Poco::AutoPtr<Poco::XML::Document> Twitter::invoke(const std::string& httpMethod, const std::string& twitterMethod, Poco::Net::HTMLForm& form)
{
// Create the request URI.
// We use the XML version of the Twitter API.
Poco::URI uri(_uri + twitterMethod + ".xml");
std::string path(uri.getPath());
Poco::Net::HTTPClientSession session(uri.getHost(), uri.getPort());
Poco::Net::HTTPRequest req(httpMethod, path, Poco::Net::HTTPMessage::HTTP_1_1);
// Add username and password (HTTP basic authentication) to the request.
Poco::Net::HTTPBasicCredentials cred(_username, _password);
cred.authenticate(req);
// Send the request.
form.prepareSubmit(req);
std::ostream& ostr = session.sendRequest(req);
form.write(ostr);
// Receive the response.
Poco::Net::HTTPResponse res;
std::istream& rs = session.receiveResponse(res);
// Create a DOM document from the response.
Poco::XML::DOMParser parser;
parser.setFeature(Poco::XML::DOMParser::FEATURE_FILTER_WHITESPACE, true);
parser.setFeature(Poco::XML::XMLReader::FEATURE_NAMESPACES, false);
Poco::XML::InputSource source(rs);
Poco::AutoPtr<Poco::XML::Document> pDoc = parser.parse(&source);
// If everything went fine, return the XML document.
// Otherwise look for an error message in the XML document.
if (res.getStatus() == Poco::Net::HTTPResponse::HTTP_OK)
{
return pDoc;
}
else
{
std::string error(res.getReason());
Poco::AutoPtr<Poco::XML::NodeList> pList = pDoc->getElementsByTagName("error");
if (pList->length() > 0)
{
error += ": ";
error += pList->item(0)->innerText();
}
throw Poco::ApplicationException("Twitter Error", error);
}
}
void Mapper::LoadInputMappings(const std::string &file)
{
if (boost::filesystem::exists(file) == false)
{
InputModuleOIS::LogInfo("Input mappings file not found, using default mappings.");
Export(file);
} else
{
InputModuleOIS::LogInfo("Loading input mappings from file " + file + "...");
try
{
Poco::XML::InputSource source(file);
Poco::XML::DOMParser parser;
Poco::XML::AutoPtr<Poco::XML::Document> document = parser.parse(&source);
if (!document.isNull())
{
Poco::XML::Node* node = document->firstChild();
if (node)
{
LoadInputMappings(node);
}
}
else
{
throw Exception("Failed to parse xml document.");
}
} catch (std::exception &e)
{
InputModuleOIS::LogInfo(e.what());
InputModuleOIS::LogInfo("Failed to parse input mappings file, using default mappings.");
}
}
}
XmlHandler::XmlHandler(std::string filename) {
std::ifstream in(filename);
Poco::XML::InputSource src(in);
Poco::XML::DOMParser parser;
pDoc = parser.parse(&src);
}
/* Validate all of the pipelines in the given config file.
* This method does some basic parsing of the config file to learn
* about the various pipelines that exist in the file.
*/
bool ValidatePipeline::isValid(const char *a_configPath) const
{
bool failed = false;
std::ifstream in(a_configPath);
if (!in) {
fprintf(stdout, "Error opening pipeline config file: %s\n", a_configPath);
} else {
try {
Poco::XML::InputSource src(in);
Poco::XML::DOMParser parser;
// basic parsing
Poco::AutoPtr<Poco::XML::Document> xmlDoc = parser.parse(&src);
// must have at least one pipeline element
Poco::AutoPtr<Poco::XML::NodeList> pipelines =
xmlDoc->getElementsByTagName(TskPipelineManager::PIPELINE_ELEMENT);
if (pipelines->length() == 0) {
fprintf(stdout, "No pipelines found in config file.\n");
} else {
// parse all pipelines in the config file
for (unsigned long i = 0; i < pipelines->length(); i++)
{
Poco::XML::Node * pNode = pipelines->item(i);
Poco::XML::Element* pElem = dynamic_cast<Poco::XML::Element*>(pNode);
Poco::XML::DOMWriter writer;
std::ostringstream pipelineXml;
writer.writeNode(pipelineXml, pNode);
std::string pipelineType = pElem->getAttribute(TskPipelineManager::PIPELINE_TYPE_ATTRIBUTE);
TskPipeline * pipeline = 0;
if (pipelineType == TskPipelineManager::FILE_ANALYSIS_PIPELINE_STR)
pipeline = new TskFileAnalysisPipeline();
else if (pipelineType == TskPipelineManager::REPORTING_PIPELINE_STR)
pipeline = new TskReportPipeline();
else {
fprintf(stdout, "Unsupported pipeline type: %s\n", pipelineType.c_str());
failed = true;
continue;
}
try {
pipeline->validate(pipelineXml.str());
} catch (...) {
fprintf(stdout, "Error parsing pipeline: %s\n", pElem->getAttribute(TskPipelineManager::PIPELINE_TYPE_ATTRIBUTE).c_str());
failed = true;
}
delete pipeline;
}
}
} catch (Poco::XML::SAXParseException& ex) {
fprintf(stderr, "Error parsing pipeline config file: %s (%s)\n", a_configPath, ex.what());
}
}
// If any of the pipelines failed validation we return false
return failed ? false : true;
}
/**Set the xml string from which the dimension will be generated.
@param dimensionXMLString : xml string to generate the dimension from.
*/
void IMDDimensionFactory::setXMLString(const std::string& dimensionXMLString)
{
Poco::XML::DOMParser pParser;
Poco::XML::Document* pDoc = pParser.parseString(dimensionXMLString);
Poco::XML::Element* pDimensionElement = pDoc->documentElement();
m_dimensionXML = pDimensionElement;
}
/**
Execution method to run the extraction.
@return implicit function if one could be found, or a NullImplicitFunction.
*/
Mantid::Geometry::MDImplicitFunction* vtkDataSetToImplicitFunction::execute()
{
using Mantid::Geometry::NullImplicitFunction;
using Mantid::Geometry::MDGeometryXMLDefinitions;
std::unique_ptr<Mantid::Geometry::MDImplicitFunction> function =
Mantid::Kernel::make_unique<NullImplicitFunction>();
FieldDataToMetadata convert;
std::string xmlString = convert(m_dataset->GetFieldData(), XMLDefinitions::metaDataId());
if (false == xmlString.empty())
{
Poco::XML::DOMParser pParser;
Poco::AutoPtr<Poco::XML::Document> pDoc = pParser.parseString(xmlString);
Poco::XML::Element* pRootElem = pDoc->documentElement();
Poco::XML::Element* functionElem = pRootElem->getChildElement(MDGeometryXMLDefinitions::functionElementName());
if(NULL != functionElem)
{
auto existingFunction =
std::unique_ptr<Mantid::Geometry::MDImplicitFunction>(
Mantid::API::ImplicitFunctionFactory::Instance()
.createUnwrapped(functionElem));
function.swap(existingFunction);
}
}
return function.release();
}
//---------------------------------------------------------
bool ofXml::loadFromBuffer( const string& buffer )
{
Poco::XML::DOMParser parser;
// release and nullptr out if we already have a document
if(document) {
document->release();
}
try {
document = parser.parseString(buffer);
element = (Poco::XML::Element*) document->firstChild();
document->normalize();
return true;
} catch( const Poco::XML::SAXException & e ) {
ofLogError("ofXml") << "parse error: " << e.message();
document = new Poco::XML::Document;
element = document->documentElement();
return false;
} catch( const exception & e ) {
short msg = atoi(e.what());
ofLogError("ofXml") << "parse error: " << DOMErrorMessage(msg);
document = new Poco::XML::Document;
element = document->documentElement();
return false;
}
}
/** Static method that sets the data inside this BoxController from an XML string
*
* @param xml :: string generated by BoxController::toXMLString()
*/
void BoxController::fromXMLString(const std::string & xml)
{
using namespace Poco::XML;
Poco::XML::DOMParser pParser;
Poco::AutoPtr<Poco::XML::Document> pDoc = pParser.parseString(xml);
Poco::XML::Element* pBoxElement = pDoc->documentElement();
std::string s;
s = pBoxElement->getChildElement("NumDims")->innerText();
Strings::convert(s, nd);
if (nd <= 0 || nd > 20) throw std::runtime_error("BoxController::fromXMLString(): Bad number of dimensions found.");
size_t ival;
Strings::convert(pBoxElement->getChildElement("MaxId")->innerText(), ival);
this->setMaxId(ival);
Strings::convert(pBoxElement->getChildElement("SplitThreshold")->innerText(), ival);
this->setSplitThreshold(ival);
Strings::convert(pBoxElement->getChildElement("MaxDepth")->innerText(), ival);
this->setMaxDepth(ival);
s = pBoxElement->getChildElement("SplitInto")->innerText();
this->m_splitInto = splitStringIntoVector<size_t>(s);
s = pBoxElement->getChildElement("NumMDBoxes")->innerText();
this->m_numMDBoxes = splitStringIntoVector<size_t>(s);
s = pBoxElement->getChildElement("NumMDGridBoxes")->innerText();
this->m_numMDGridBoxes = splitStringIntoVector<size_t>(s);
this->calcNumSplit();
}
/**
* Parse the runinfo file to find the names of the neutron event files.
*
* @param runinfo Runinfo file with full path.
* @param dataDir Directory where the runinfo file lives.
* @param eventFilenames vector of all possible event files. This is filled by
*the algorithm.
*/
void LoadPreNexus::parseRuninfo(const string &runinfo, string &dataDir,
vector<string> &eventFilenames) {
eventFilenames.clear();
// Create a Poco Path object for runinfo filename
Poco::Path runinfoPath(runinfo, Poco::Path::PATH_GUESS);
// Now lets get the directory
Poco::Path dirPath(runinfoPath.parent());
dataDir = dirPath.absolute().toString();
g_log.debug() << "Data directory \"" << dataDir << "\"\n";
std::ifstream in(runinfo.c_str());
Poco::XML::InputSource src(in);
Poco::XML::DOMParser parser;
Poco::AutoPtr<Poco::XML::Document> pDoc = parser.parse(&src);
Poco::XML::NodeIterator it(pDoc, Poco::XML::NodeFilter::SHOW_ELEMENT);
Poco::XML::Node *pNode = it.nextNode(); // root node
while (pNode) {
if (pNode->nodeName() == "RunInfo") // standard name for this type
{
pNode = pNode->firstChild();
while (pNode) {
if (pNode->nodeName() == "FileList") {
pNode = pNode->firstChild();
while (pNode) {
if (pNode->nodeName() == "DataList") {
pNode = pNode->firstChild();
while (pNode) {
if (pNode->nodeName() == "scattering") {
Poco::XML::Element *element =
static_cast<Poco::XML::Element *>(pNode);
eventFilenames.push_back(element->getAttribute("name"));
}
pNode = pNode->nextSibling();
}
} else // search for DataList
pNode = pNode->nextSibling();
}
} else // search for FileList
pNode = pNode->nextSibling();
}
} else // search for RunInfo
pNode = pNode->nextSibling();
}
// report the results to the log
if (eventFilenames.size() == 1) {
g_log.debug() << "Found 1 event file: \"" << eventFilenames[0] << "\"\n";
} else {
g_log.debug() << "Found " << eventFilenames.size() << " event files:";
for (auto &eventFilename : eventFilenames) {
g_log.debug() << "\"" << eventFilename << "\" ";
}
g_log.debug() << "\n";
}
}
void XMLConfiguration::load(Poco::XML::InputSource* pInputSource)
{
poco_check_ptr (pInputSource);
Poco::XML::DOMParser parser;
parser.setFeature(Poco::XML::XMLReader::FEATURE_NAMESPACES, false);
parser.setFeature(Poco::XML::DOMParser::FEATURE_FILTER_WHITESPACE, true);
Poco::XML::AutoPtr<Poco::XML::Document> pDoc = parser.parse(pInputSource);
load(pDoc);
}
void Configure::loadChannelList(void)
{
std::ifstream in(SystemInfo::instance().getExecutePath() + "\\config\\channelList.xml");
Poco::XML::InputSource src(in);
Poco::XML::DOMParser parser;
try
{
Poco::AutoPtr<Poco::XML::Document> pDoc = parser.parse(&src);
Poco::XML::NodeIterator it(pDoc, Poco::XML::NodeFilter::SHOW_ALL);
Poco::XML::Node* pNode = it.nextNode();
static int index = 0;
std::string channelInfo[3];
while (pNode)
{
if(pNode->nodeName() == "Row")
{
pNode = it.nextNode();
if(pNode->nodeName() != "#text")
{
continue; //No text node present
}
index = 0;
if(m_encodeChannel == channelInfo[1])
{
// 找到频道对照表
m_encodeChannelID = channelInfo[0];
m_encodeChannelPrefix = channelInfo[2];
LOG(INFO) << "get channel info : ID [" << m_encodeChannelID << "] Prefix[" << m_encodeChannelPrefix << "].";
return;
}
}
if(pNode->nodeName() == "Cell")
{
pNode = it.nextNode();
if(pNode->nodeName() != "#text")
{
pNode = it.nextNode();
continue; //No text node present
}
channelInfo[index++] = pNode->nodeValue();
}
pNode = it.nextNode();//指向下一个node
}
}
catch(std::exception& e)
{
LOG(ERROR) << "parse channelList xml file error." << e.what() ;
}
}
const bool BoardListXML::ParseXML(const std::string &xml)
{
bool parsed=false;
Poco::XML::DOMParser dp;
dp.setEntityResolver(0);
Initialize();
try
{
Poco::AutoPtr<Poco::XML::Document> doc=dp.parseString(FixCDATA(xml));
Poco::XML::Element *root=XMLGetFirstChild(doc,"BoardList");
Poco::XML::Element *boardel=NULL;
boardel=XMLGetFirstChild(root,"Board");
while(boardel)
{
std::string name="";
std::string description="";
Poco::XML::Element *txt=XMLGetFirstChild(boardel,"Name");
if(txt && txt->firstChild())
{
name=SanitizeSingleString(txt->firstChild()->getNodeValue());
StringFunctions::LowerCase(name,name);
}
txt=XMLGetFirstChild(boardel,"Description");
if(txt && txt->firstChild())
{
description=SanitizeSingleString(txt->firstChild()->getNodeValue());
}
if(name!="" && description!="")
{
m_boards.push_back(board(name,description));
}
boardel=XMLGetNextSibling(boardel,"Board");
}
parsed=true;
}
catch(...)
{
}
return parsed;
}
void ExtensionPointService::handleExtensions(Bundle::ConstPtr pBundle, std::istream& istr, GenericHandler handler, Direction dir)
{
Poco::XML::DOMParser parser;
parser.setFeature(Poco::XML::XMLReader::FEATURE_NAMESPACES, false);
parser.setFeature(Poco::XML::DOMParser::FEATURE_FILTER_WHITESPACE, true);
Poco::XML::InputSource source(istr);
AutoPtr<Document> pDoc(parser.parse(&source));
Node* pRoot = pDoc->firstChild();
while (pRoot && pRoot->nodeName() != EXTENSIONS_ELEM)
{
pRoot = pRoot->nextSibling();
}
if (pRoot)
{
Node* pNode = (dir == DIR_FORWARD ? pRoot->firstChild() : pRoot->lastChild());
while (pNode)
{
if (pNode->nodeType() == Node::ELEMENT_NODE)
{
if (pNode->nodeName() == EXTENSION_ELEM)
{
Element* pElem = static_cast<Element*>(pNode);
const std::string& id = pElem->getAttribute(POINT_ATTR);
if (!id.empty())
{
(this->*handler)(pBundle, id, pElem);
}
else
{
_logger.error(std::string("No point attribute found in extension element of bundle ")
+ pBundle->symbolicName());
}
}
else
{
_logger.warning(std::string("Unsupported element '")
+ pNode->nodeName()
+ "' found in "
+ EXTENSIONS_XML
+ " of bundle "
+ pBundle->symbolicName());
}
}
pNode = (dir == DIR_FORWARD ? pNode->nextSibling() : pNode->previousSibling());
}
}
else throw Poco::NotFoundException("No extensions element found");
}
/**
Execution method to run the extraction.
@return location string
*/
std::string vtkDataSetToWsLocation::execute()
{
using Mantid::Geometry::MDGeometryXMLDefinitions;
FieldDataToMetadata convert;
std::string xmlString = convert(m_dataset->GetFieldData(), XMLDefinitions::metaDataId());
Poco::XML::DOMParser pParser;
Poco::XML::Document* pDoc = pParser.parseString(xmlString);
Poco::XML::Element* pRootElem = pDoc->documentElement();
Poco::XML::Element* wsLocationElem = pRootElem->getChildElement(MDGeometryXMLDefinitions::workspaceLocationElementName());
if(wsLocationElem == NULL)
{
throw std::runtime_error("The element containing the workspace location must be present.");
}
return wsLocationElem->innerText();
}
/*
* Initalize Poco XML Parser
*/
void LoadGroupXMLFile::initializeXMLParser(const std::string &filename) {
const std::string xmlText = Kernel::Strings::loadFile(filename);
// Set up the DOM parser and parse xml file
Poco::XML::DOMParser pParser;
try {
m_pDoc = pParser.parseString(xmlText);
} catch (Poco::Exception &exc) {
throw Kernel::Exception::FileError(
exc.displayText() + ". Unable to parse File:", filename);
} catch (...) {
throw Kernel::Exception::FileError("Unable to parse File:", filename);
}
// Get pointer to root element
m_pRootElem = m_pDoc->documentElement();
if (!m_pRootElem->hasChildNodes()) {
throw Kernel::Exception::InstrumentDefinitionError(
"No root element in XML instrument file", filename);
}
}
/**
Execution method to run the extraction.
@return implicit function if one could be found, or a NullImplicitFunction.
*/
Mantid::Geometry::MDImplicitFunction* vtkDataSetToImplicitFunction::execute()
{
using Mantid::MDAlgorithms::NullImplicitFunction;
using Mantid::Geometry::MDGeometryXMLDefinitions;
Mantid::Geometry::MDImplicitFunction* function = new NullImplicitFunction;
FieldDataToMetadata convert;
std::string xmlString = convert(m_dataset->GetFieldData(), XMLDefinitions::metaDataId());
if (false == xmlString.empty())
{
Poco::XML::DOMParser pParser;
Poco::XML::Document* pDoc = pParser.parseString(xmlString);
Poco::XML::Element* pRootElem = pDoc->documentElement();
Poco::XML::Element* functionElem = pRootElem->getChildElement(MDGeometryXMLDefinitions::functionElementName());
if(NULL != functionElem)
{
delete function;
function = Mantid::API::ImplicitFunctionFactory::Instance().createUnwrapped(functionElem);
}
}
return function;
}
const bool IdentityIntroductionXML::ParseXML(const std::string &xml)
{
FreenetSSKKey ssk;
bool parsed=false;
Poco::XML::DOMParser dp;
dp.setEntityResolver(0);
Initialize();
try
{
Poco::AutoPtr<Poco::XML::Document> doc=dp.parseString(FixCDATA(xml));
Poco::XML::Element *root=XMLGetFirstChild(doc,"IdentityIntroduction");
Poco::XML::Element *txt=NULL;
txt=XMLGetFirstChild(root,"Identity");
if(txt)
{
if(txt->firstChild())
{
m_identity=SanitizeSingleString(txt->firstChild()->getNodeValue());
if(ssk.TryParse(m_identity)==false)
{
return false;
}
m_identity=ssk.GetBaseKey();
}
}
parsed=true;
}
catch(...)
{
}
return parsed;
}
void TskPipeline::initialize(const std::string & pipelineConfig)
{
if (pipelineConfig.empty())
{
throw TskException("TskPipeline::initialize: Pipeline configuration string is empty.");
}
try
{
Poco::XML::DOMParser parser;
Poco::AutoPtr<Poco::XML::Document> xmlDoc = parser.parseString(pipelineConfig);
// Get all Module elements
Poco::AutoPtr<Poco::XML::NodeList> modules =
xmlDoc->getElementsByTagName(TskPipeline::MODULE_ELEMENT);
if (modules->length() == 0)
{
LOGWARN(L"TskPipeline::initialize - No modules found in config file.");
return;
}
// Size our list based on the number of modules
m_modules.resize(modules->length());
// Iterate through the module elements, make sure they are increasing order
// we now allow for gaps to make it easier to comment things out.
int prevOrder = -1;
for (unsigned int i = 0; i < modules->length(); i++)
{
Poco::XML::Node * pNode = modules->item(i);
Poco::XML::Element* pElem = dynamic_cast<Poco::XML::Element*>(pNode);
Poco::XML::XMLString orderStr = pElem->getAttribute(TskPipeline::MODULE_ORDER_ATTR);
if (orderStr == "") {
throw TskException("TskPipeline::initialize: Module order missing.");
}
int order;
try
{
order = Poco::NumberParser::parse(orderStr);
} catch (Poco::SyntaxException ex)
{
std::stringstream msg;
msg << "TskPipeline::initialize - Module order must a decimal number. Got " << orderStr.c_str();
throw TskException(msg.str());
}
if (order <= prevOrder)
{
std::stringstream msg;
msg << "TskPipeline::initialize - Expecting order bigger than " << prevOrder << ", got " << order;
throw TskException(msg.str());
}
prevOrder = order;
}
// Iterate through the module elements creating a new Module for each one
m_modules.clear();
for (unsigned int i = 0; i < modules->length(); i++)
{
Poco::XML::Node * pNode = modules->item(i);
Poco::XML::Element* pElem = dynamic_cast<Poco::XML::Element*>(pNode);
if (!pElem)
continue;
// Create a new module
TskModule * pModule = createModule(pElem);
if (pModule == NULL)
{
throw TskException("TskPipeline::initialize - Module creation failed.");
}
if (m_loadDll)
{
TskImgDB& imgDB = TskServices::Instance().getImgDB();
// Insert into Modules table
int moduleId = 0;
if (imgDB.addModule(pModule->getName(), pModule->getDescription(), moduleId))
{
std::stringstream errorMsg;
errorMsg << "TskPipeline::initialize - Failed to insert into Modules table. "
<< " module name=" << pModule->getName() ;
throw TskException(errorMsg.str());
}
else
{
pModule->setModuleId(moduleId);
m_moduleNames.insert(std::make_pair(moduleId, pModule->getName()));
m_moduleExecTimes.insert(std::make_pair(moduleId, Poco::Timespan()));
}
bool duplicate = false;
for (std::vector<TskModule*>::iterator it = m_modules.begin(); it != m_modules.end(); it++) {
if ((*it)->getModuleId() == pModule->getModuleId()) {
duplicate = true;
std::stringstream msg;
msg << "TskPipeline::initialize - " << pModule->getName() << " is a duplicate module. " <<
"The duplicate will not be added to the pipeline";
throw TskException(msg.str());
}
}
if (!duplicate)
m_modules.push_back(pModule);
}
}
}
// rethrow this, otherwise it is caught by std::exception and we lose the detail.
catch (TskException& ex) {
throw(ex);
}
catch (std::exception& ex)
{
std::stringstream errorMsg;
errorMsg << "TskPipeline::initialize - Pipeline initialization failed: " <<ex.what() ;
throw TskException(errorMsg.str());
}
}
/**
* @param filenames : List of files to search
* @param exts : List of extensions to check against
* @return list of archive locations
*/
std::string SNSDataArchive::getArchivePath(const std::set<std::string>& filenames, const std::vector<std::string>& exts) const
{
std::set<std::string>::const_iterator iter = filenames.begin();
std::string filename = *iter;
//ICAT4 web service take upper case filename such as HYSA_2662
std::transform(filename.begin(),filename.end(),filename.begin(),toupper);
std::vector<std::string>::const_iterator iter2 = exts.begin();
for(; iter2!=exts.end(); ++iter2)
{
g_log.debug() << *iter2 << ";";
}
g_log.debug() << "\n";
std::string baseURL("http://icat.sns.gov:8080/icat-rest-ws/datafile/filename/");
std::string URL(baseURL + filename);
g_log.debug() << "URL: " << URL << "\n";
Poco::URI uri(URL);
std::string path(uri.getPathAndQuery());
Poco::Net::HTTPClientSession session(uri.getHost(), uri.getPort());
Poco::Net::HTTPRequest req(Poco::Net::HTTPRequest::HTTP_GET, path, Poco::Net::HTTPMessage::HTTP_1_1);
session.sendRequest(req);
Poco::Net::HTTPResponse res;
std::istream& rs = session.receiveResponse(res);
g_log.debug() << "res.getStatus(): " << res.getStatus() << "\n";
// Create a DOM document from the response.
Poco::XML::DOMParser parser;
Poco::XML::InputSource source(rs);
Poco::AutoPtr<Poco::XML::Document> pDoc = parser.parse(&source);
std::vector<std::string> locations;
// If everything went fine, return the XML document.
// Otherwise look for an error message in the XML document.
if (res.getStatus() == Poco::Net::HTTPResponse::HTTP_OK)
{
std::string location;
Poco::AutoPtr<Poco::XML::NodeList> pList = pDoc->getElementsByTagName("location");
for(unsigned long i = 0 ; i < pList->length(); i++)
{
location = pList->item(i)->innerText();
g_log.debug() << "location: " << location << "\n";
locations.push_back(location);
}
}
else
{
std::string error(res.getReason());
throw Poco::ApplicationException("HTTPRequest Error", error);
}
std::vector<std::string>::const_iterator ext = exts.begin();
for (; ext != exts.end(); ++ext)
{
std::string datafile = filename + *ext;
std::vector<std::string>::const_iterator iter = locations.begin();
for(; iter!=locations.end(); ++iter)
{
if (boost::algorithm::ends_with((*iter), datafile))
{
return *iter;
} // end if
} // end for iter
} // end for ext
return "";
}
const bool MessageXML::ParseXML(const std::string &xml)
{
bool parsed=false;
Poco::XML::DOMParser dp;
dp.setEntityResolver(0);
Initialize();
try
{
Poco::AutoPtr<Poco::XML::Document> doc=dp.parseString(FixCDATA(xml));
Poco::XML::Element *root=XMLGetFirstChild(doc,"Message");
Poco::XML::Element *txt=NULL;
txt=XMLGetFirstChild(root,"Date");
if(txt)
{
if(txt->firstChild())
{
m_date=SanitizeSingleString(txt->firstChild()->getNodeValue());
}
}
txt=XMLGetFirstChild(root,"Time");
if(txt)
{
if(txt->firstChild())
{
m_time=SanitizeSingleString(txt->firstChild()->getNodeValue());
}
}
txt=XMLGetFirstChild(root,"Subject");
if(txt)
{
if(txt->firstChild())
{
m_subject=SanitizeSingleString(txt->firstChild()->getNodeValue());
}
}
txt=XMLGetFirstChild(root,"MessageID");
if(txt)
{
if(txt->firstChild())
{
m_messageid=SanitizeSingleString(txt->firstChild()->getNodeValue());
}
}
txt=XMLGetFirstChild(root,"ReplyBoard");
if(txt)
{
if(txt->firstChild())
{
m_replyboard=SanitizeSingleString(txt->firstChild()->getNodeValue());
// strip off everything after , in board name
if(m_replyboard.find(',')!=std::string::npos)
{
m_replyboard.erase(m_replyboard.find(','));
}
m_replyboard=Board::FixBoardName(m_replyboard);
}
}
txt=XMLGetFirstChild(root,"Body");
if(txt)
{
if(txt->firstChild())
{
m_body=txt->firstChild()->getNodeValue();
}
}
Poco::XML::Element *boards=XMLGetFirstChild(root,"Boards");
if(boards)
{
Poco::XML::Element *board=XMLGetFirstChild(boards,"Board");
while(board)
{
if(board->firstChild())
{
std::string boardname=SanitizeSingleString(board->firstChild()->getNodeValue());
// strip off everything after , in board name
if(boardname.find(',')!=std::string::npos)
{
boardname.erase(boardname.find(','));
}
boardname=Board::FixBoardName(boardname);
m_boards.push_back(boardname);
}
board=XMLGetNextSibling(board,"Board");
}
}
Poco::XML::Element *inreplyto=XMLGetFirstChild(root,"InReplyTo");
if(inreplyto)
{
Poco::XML::Element *message=XMLGetFirstChild(inreplyto,"Message");
while(message)
{
Poco::XML::Element *orderel=XMLGetFirstChild(message,"Order");
Poco::XML::Element *messageidel=XMLGetFirstChild(message,"MessageID");
if(orderel && orderel->firstChild() && messageidel && messageidel->firstChild())
{
int order=-1;
std::string messageid="";
StringFunctions::Convert(orderel->firstChild()->getNodeValue(),order);
messageid=messageidel->firstChild()->getNodeValue();
if(order!=-1 && messageid!="")
{
m_inreplyto[order]=messageid;
}
}
message=XMLGetNextSibling(message,"Message");
}
}
Poco::XML::Element *attachments=XMLGetFirstChild(root,"Attachments");
if(attachments)
{
Poco::XML::Element *file=XMLGetFirstChild(attachments,"File");
while(file)
{
Poco::XML::Element *keyel=XMLGetFirstChild(file,"Key");
Poco::XML::Element *sizeel=XMLGetFirstChild(file,"Size");
if(keyel && keyel->firstChild() && sizeel && sizeel->firstChild())
{
int size=-1;
std::string key="";
StringFunctions::Convert(sizeel->firstChild()->getNodeValue(),size);
key=keyel->firstChild()->getNodeValue();
if(size!=-1 && key!="")
{
m_fileattachments.push_back(fileattachment(key,size));
}
}
file=XMLGetNextSibling(file,"File");
}
}
parsed=true;
}
catch(Poco::Exception &e)
{
m_lasterror="Caught exception - "+e.displayText();
}
catch(...)
{
}
return parsed;
}
void DebugUtil::RestoreState()
{
Poco::Path path;
if (!GetPersistencePath(path)) return;
path.setFileName(DEBUG_UTIL_XML);
try
{
Poco::XML::DOMParser parser;
Poco::FileInputStream reader(path.toString());
Poco::XML::InputSource source(reader);
//source.setSystemId(baseDir);
Poco::XML::Document* doc = parser.parse(&source);
Poco::XML::Element* debugutil = doc->documentElement();
if (debugutil)
{
// restore traced objects
Poco::XML::NodeList* elementList = debugutil->getElementsByTagName(TRACEOBJECT_TAG);
for (std::size_t i = 0; i < elementList->length(); i++)
{
Poco::XML::Element* elem =
dynamic_cast<Poco::XML::Element*> (elementList->item(static_cast<unsigned long>(i)));
if (!elem->hasAttribute(ID_ATTR)) continue;
const std::string& attr = elem->getAttribute(ID_ATTR);
int traceId = 0;
try
{
traceId = Poco::NumberParser::parse(attr);
}
catch (const Poco::SyntaxException& e)
{
BERRY_WARN << e.displayText();
}
DebugUtil::TraceObject(traceId);
}
elementList->release();
// restore traced classes
elementList = debugutil->getElementsByTagName(TRACECLASS_TAG);
for (std::size_t i = 0; i < elementList->length(); i++)
{
Poco::XML::Element* elem =
dynamic_cast<Poco::XML::Element*> (elementList->item(static_cast<unsigned long>(i)));
if (!elem->hasAttribute(NAME_ATTR)) continue;
const std::string& traceClass = elem->getAttribute(NAME_ATTR);
if (!traceClass.empty())
DebugUtil::TraceClass(traceClass);
}
elementList->release();
}
doc->release();
}
catch (Poco::XML::SAXParseException& e)
{
BERRY_WARN << e.displayText();
}
catch (Poco::FileNotFoundException&)
{
}
catch (Poco::FileException& e)
{
BERRY_WARN << e.displayText();
}
// restore BreakpointManager
path.setFileName(DebugBreakpointManager::BREAKPOINTS_XML);
GetBreakpointManager()->RestoreState(path);
}
bool Configure::load(void)
{
std::ifstream in(SystemInfo::instance().getExecutePath() + "\\config\\sys.xml");
Poco::XML::InputSource src(in);
Poco::XML::DOMParser parser;
try
{
Poco::AutoPtr<Poco::XML::Document> pDoc = parser.parse(&src);
Poco::XML::NodeIterator it(pDoc, Poco::XML::NodeFilter::SHOW_ALL);
Poco::XML::Node* pNode = it.nextNode();
while (pNode)
{
if(pNode->nodeName() == "EncodChannel")
{
pNode = it.nextNode();
if(pNode->nodeName() != "#text")
{
continue; //No text node present
}
m_encodeChannel = pNode->nodeValue();
Poco::XML::XMLString tt = Poco::XML::toXMLString(m_encodeChannel);
}
if(pNode->nodeName() == "InputTSPath")
{
getNetWorkPathAttr(pNode->attributes(),&m_inputTSPath);
pNode = it.nextNode();
if(pNode->nodeName() != "#text")
{
continue; //No text node present
}
m_inputTSPath.path = pNode->nodeValue();
m_inputTSPath.objectName = "o:";
}
if(pNode->nodeName() == "InputXMLPath")
{
getNetWorkPathAttr(pNode->attributes(),&m_inputXMLPath);
pNode = it.nextNode();
if(pNode->nodeName() != "#text")
{
continue; //No text node present
}
m_inputXMLPath.path = pNode->nodeValue();
m_inputXMLPath.objectName = "p:";
}
if(pNode->nodeName() == "OutputTSPath")
{
getNetWorkPathAttr(pNode->attributes(),&m_outputTSPath);
pNode = it.nextNode();
if(pNode->nodeName() != "#text")
{
continue; //No text node present
}
m_outputTSPath.path = pNode->nodeValue();
m_outputTSPath.objectName = "q:";
}
if(pNode->nodeName() == "OutputXMLPath")
{
getNetWorkPathAttr(pNode->attributes(),&m_outputXMLPath);
pNode = it.nextNode();
if(pNode->nodeName() != "#text")
{
continue; //No text node present
}
m_outputXMLPath.path = pNode->nodeValue();
m_outputXMLPath.objectName = "r:";
}
if(pNode->nodeName() == "OutputStream1")
{
getOutputStreamAttr(pNode->attributes(),&m_outputStream[0]);
pNode = it.nextNode();
if(pNode->nodeName() != "#text")
{
continue; //No text node present
}
}
if(pNode->nodeName() == "OutputStream2")
{
getOutputStreamAttr(pNode->attributes(),&m_outputStream[1]);
pNode = it.nextNode();
if(pNode->nodeName() != "#text")
{
continue; //No text node present
}
}
if(pNode->nodeName() == "OutputStream3")
{
getOutputStreamAttr(pNode->attributes(),&m_outputStream[2]);
pNode = it.nextNode();
if(pNode->nodeName() != "#text")
{
continue; //No text node present
}
}
if(pNode->nodeName() == "Storage")
{
if(pNode->attributes())//看看是否真有属性
{
for(int i = 0 ; i < pNode->attributes()->length() ; i++)
{
Poco::XML::Node* attr = pNode->attributes()->item(i);
if(attr->nodeName() == "KeepingDateTime")
{
m_keepDateTime = boost::lexical_cast<int>(attr->nodeValue());
}
}//属性结束
}
pNode = it.nextNode();
if(pNode->nodeName() != "#text")
{
continue; //No text node present
}
}
//LOG(INFO) << "name : " << pNode->nodeName() ;//取出当前节点的Name
//LOG(INFO)<< "value : " << pNode->nodeValue() ;//取出当前节点的Value
pNode = it.nextNode();//指向下一个node
}
}
catch(std::exception& e)
{
LOG(ERROR) << "parse xml file error." << e.what() ;
return false;
}
this->loadChannelList();
if(m_encodeChannel.empty() || m_encodeChannelID.empty() || m_encodeChannelPrefix.empty() ||
m_inputTSPath.path.empty() || m_inputTSPath.objectName.empty() ||
m_inputXMLPath.path.empty() || m_inputXMLPath.objectName.empty() ||
m_outputTSPath.path.empty() || m_outputTSPath.objectName.empty() ||
m_outputXMLPath.path.empty() || m_outputXMLPath.objectName.empty() ||
m_outputStream[0].bitrate.empty() || m_outputStream[0].enable.empty() || m_outputStream[0].resolutionRatio.empty() ||
m_outputStream[1].bitrate.empty() || m_outputStream[1].enable.empty() || m_outputStream[1].resolutionRatio.empty() ||
m_outputStream[2].bitrate.empty() || m_outputStream[2].enable.empty() || m_outputStream[2].resolutionRatio.empty() ||
m_keepDateTime == -2)
{
return false;
}
LOG(INFO) << "EncodChannel [" << Configure::instance().m_encodeChannel << "] ID[" << m_encodeChannelID << "] Prefix[" << m_encodeChannelPrefix << "].";
LOG(INFO) << "InputTSPath [" << Configure::instance().m_inputTSPath.path << "]" << " as [" << Configure::instance().m_inputTSPath.objectName << "]";
LOG(INFO) << "InputXMLPath [" << Configure::instance().m_inputXMLPath.path << "]" << " as [" << Configure::instance().m_inputXMLPath.objectName << "]";
LOG(INFO) << "OutputTSPath [" << Configure::instance().m_outputTSPath.path << "]" << " as [" << Configure::instance().m_outputTSPath.objectName << "]";
LOG(INFO) << "OutputXMLPath [" << Configure::instance().m_outputXMLPath.path << "]" << " as [" << Configure::instance().m_outputXMLPath.objectName << "]";
LOG(INFO) << "OutputStream1 [" << Configure::instance().m_outputStream[0].enable << ", " << Configure::instance().m_outputStream[0].bitrate << ", " << Configure::instance().m_outputStream[0].resolutionRatio << "]";
LOG(INFO) << "OutputStream2 [" << Configure::instance().m_outputStream[1].enable << ", " << Configure::instance().m_outputStream[1].bitrate << ", " << Configure::instance().m_outputStream[1].resolutionRatio << "]";
LOG(INFO) << "OutputStream3 [" << Configure::instance().m_outputStream[2].enable << ", " << Configure::instance().m_outputStream[2].bitrate << ", " << Configure::instance().m_outputStream[2].resolutionRatio << "]";
LOG(INFO) << "stoage keep DateTime [" << m_keepDateTime << "].";
return true;
}
/**
* Reads detctor ids for groups from an XML grouping file, such as one created by the SpatialGrouping algorithm.
* @param filename :: path and name of input file
* @throw FileError is there is a problem with the XML file
*/
void ReadGroupsFromFile::readXMLGroupingFile(const std::string& filename)
{
Poco::XML::DOMParser xmlParser;
Poco::XML::Document* file;
try
{
file = xmlParser.parse(filename);
}
catch ( ... )
{
throw Kernel::Exception::FileError("Unable to parse file: ", filename);
}
Poco::XML::Element* root = file->documentElement();
if ( ! root->hasChildNodes() )
{
throw Kernel::Exception::FileError("No root element in XML grouping file: ", filename);
}
Poco::XML::NodeList* groups = root->getElementsByTagName("group");
if ( groups->length() == 0 )
{
throw Kernel::Exception::FileError("XML group file contains no group elements:", filename);
}
unsigned int nGroups = static_cast<unsigned int>(groups->length());
for ( unsigned int i = 0; i < nGroups; i++ )
{
// Get the "detids" element from the grouping file
Poco::XML::Element* elem = static_cast<Poco::XML::Element*>(groups->item(i));
Poco::XML::Element* group = elem->getChildElement("detids");
if ( ! group )
{
throw Mantid::Kernel::Exception::FileError("XML Group File, group contains no <detids> element:", filename);
}
std::string ids = group->getAttribute("val");
Poco::StringTokenizer data(ids, ",", Poco::StringTokenizer::TOK_TRIM);
if ( data.begin() != data.end() )
{
for ( Poco::StringTokenizer::Iterator it = data.begin(); it != data.end(); ++it )
{
// cast the string to an int
int detID;
try
{
detID = boost::lexical_cast<int>(*it);
} catch ( boost::bad_lexical_cast & )
{
throw Mantid::Kernel::Exception::FileError("Could cast string to integer in input XML file", filename);
}
if ( calibration.find(detID) == calibration.end() )
{
// add detector to a group
calibration[detID] = std::pair<int,int>(i+1, 1);
}
}
}
}
progress(0.7);
}
svgtiny_code svgtiny_parse(svgInfo &info,struct svgtiny_diagram *diagram, const char *buffer,int viewport_width, int viewport_height){
Poco::XML::Document *document;
Poco::XML::Element *svg;
struct svgtiny_parse_state state;
float x, y, width, height;
svgtiny_code code;
assert(diagram);
assert(buffer);
string rawXMLstring(buffer);
//info.rawXML = rawXMLstring;
//parser is statically allocated
Poco::XML::DOMParser parser;
/*
Why does this upset the internal SVG parser?
*/
//parser.setFeature(Poco::XML::XMLReader::FEATURE_NAMESPACES, false);
document = parser.parseString(rawXMLstring);
svg = document->documentElement();
//std::cout << svg->localName() << std::endl;
if (!svg){
code = svgtiny_NOT_SVG;
return code;
}else if(svg->localName().compare("svg") != 0){
code= svgtiny_NOT_SVG;
return code;
}else{
/* get graphic dimensions */
state.diagram = diagram;
state.document = document;
state.viewport_width = viewport_width;
state.viewport_height = viewport_height;
svgtiny_parse_position_attributes(svg, state, &x, &y, &width, &height);
diagram->width = width;
diagram->height = height;
/* set up parsing state */
state.viewport_width = width;
state.viewport_height = height;
state.ctm.a = 1; /*(float) viewport_width / (float) width;*/
state.ctm.b = 0;
state.ctm.c = 0;
state.ctm.d = 1; /*(float) viewport_height / (float) height;*/
state.ctm.e = 0; /*x;*/
state.ctm.f = 0; /*y;*/
/*state.style = css_base_style;
state.style.font_size.value.length.value = option_font_size * 0.1;*/
state.fill = 0x000000;
state.stroke = svgtiny_TRANSPARENT;
state.stroke_width = 1;
state.linear_gradient_stop_count = 0;
//borg
state.info = &info;
/* parse tree */
ofPtr<svgNode> rootnode(new svgNode());
rootnode->type = SVG_TAG_TYPE_DOCUMENT;
info.rootnode = rootnode;
//store root svg info
info.width = ofToString(svg->getAttribute("width").c_str());
info.height = ofToString(svg->getAttribute("height").c_str());
info.x = ofToString(svg->getAttribute("x").c_str());
info.y = ofToString(svg->getAttribute("y").c_str());
info.viewbox = ofToString(svg->getAttribute("viewBox").c_str());
info.id = ofToString(svg->getAttribute("id").c_str());
info.xmlns = ofToString(svg->getAttribute("xmlns").c_str());
info.version = ofToString(svg->getAttribute("version").c_str());
info.preserveAspectRatio = ofToString(svg->getAttribute("preserveAspectRatio").c_str());
code = svgtiny_parse_svg(info,svg, state,rootnode);
}
/* free XML tree */
//xmlFreeDoc(document);
//return without namespace
//parser.setFeature(Poco::XML::XMLReader::FEATURE_NAMESPACES, false);
//document = parser.parseString(rawXMLstring);
return code;
}
void DebugBreakpointManager::RestoreState(const Poco::Path& path)
{
try
{
Poco::XML::DOMParser parser;
Poco::FileInputStream reader(path.toString());
Poco::XML::InputSource source(reader);
//source.setSystemId(baseDir);
Poco::XML::Document* doc = parser.parse(&source);
Poco::XML::Element* breakpoints = doc->documentElement();
if (breakpoints)
{
// restore object breakpoints
Poco::XML::NodeList* elementList = breakpoints->getElementsByTagName(
OBJECT_TAG);
for (std::size_t i = 0; i < elementList->length(); i++)
{
Poco::XML::Element* elem =
dynamic_cast<Poco::XML::Element*> (elementList->item(i));
if (!elem->hasAttribute(ID_ATTR))
continue;
const std::string& attr = elem->getAttribute(ID_ATTR);
int traceId = 0;
try
{
traceId = Poco::NumberParser::parse(attr);
} catch (const Poco::SyntaxException& e)
{
BERRY_WARN << e.displayText();
}
DebugUtil::GetBreakpointManager()->AddObjectBreakpoint(traceId);
}
elementList->release();
// restore smartpointer breakpoints
elementList = breakpoints->getElementsByTagName(SMARTPOINTER_TAG);
for (std::size_t i = 0; i < elementList->length(); i++)
{
Poco::XML::Element* elem =
dynamic_cast<Poco::XML::Element*> (elementList->item(i));
if (!elem->hasAttribute(ID_ATTR))
continue;
const std::string& attr = elem->getAttribute(ID_ATTR);
int spId = 0;
try
{
spId = Poco::NumberParser::parse(attr);
} catch (const Poco::SyntaxException& e)
{
BERRY_WARN << e.displayText();
}
DebugUtil::GetBreakpointManager()->AddSmartpointerBreakpoint(spId);
}
elementList->release();
}
doc->release();
} catch (Poco::XML::SAXParseException& e)
{
BERRY_WARN << e.displayText();
}
catch (Poco::FileNotFoundException& /*e*/)
{
}
catch (Poco::FileException& e)
{
BERRY_WARN << e.displayText();
}
}
const bool SoneXML::ParseXML(const std::string &xml)
{
bool parsed=false;
Poco::XML::DOMParser dp;
dp.setEntityResolver(0);
Initialize();
try
{
Poco::AutoPtr<Poco::XML::Document> doc=dp.parseString(FixCDATA(xml));
Poco::XML::Element *root=XMLGetFirstChild(doc,"sone");
Poco::XML::Element *posts=NULL;
Poco::XML::Element *replies=NULL;
Poco::XML::Element *txt=NULL;
Poco::XML::Element *profile=NULL;
Poco::XML::Element *albums=NULL;
if(root)
{
posts=XMLGetFirstChild(root,"posts");
replies=XMLGetFirstChild(root,"replies");
profile=XMLGetFirstChild(root,"profile");
albums=XMLGetFirstChild(root,"albums");
}
if(posts)
{
txt=XMLGetFirstChild(posts,"post");
while(txt)
{
std::string id("");
std::string timestr("");
Poco::Timestamp::TimeVal timeval;
Poco::DateTime messagetime;
std::string messagetext("");
Poco::XML::Element *el;
el=XMLGetFirstChild(txt,"id");
if(el && el->firstChild())
{
id=el->firstChild()->getNodeValue();
}
el=XMLGetFirstChild(txt,"time");
if(el && el->firstChild())
{
timestr=el->firstChild()->getNodeValue();
StringFunctions::Convert(timestr,timeval);
messagetime=Poco::Timestamp(timeval*static_cast<Poco::Timestamp::TimeVal>(1000));
}
el=XMLGetFirstChild(txt,"text");
if(el && el->firstChild())
{
messagetext=el->firstChild()->getNodeValue();
}
if(id!="" && messagetext!="")
{
m_messages.push_back(message(messagetime,id,std::string(""),messagetext));
}
txt=XMLGetNextSibling(txt,"post");
}
}
if(replies)
{
txt=XMLGetFirstChild(replies,"reply");
while(txt)
{
std::string id("");
std::string replyto("");
std::string timestr("");
Poco::Timestamp::TimeVal timeval;
Poco::DateTime messagetime;
std::string messagetext("");
Poco::XML::Element *el;
el=XMLGetFirstChild(txt,"id");
if(el && el->firstChild())
{
id=el->firstChild()->getNodeValue();
}
el=XMLGetFirstChild(txt,"post-id");
if(el && el->firstChild())
{
replyto=el->firstChild()->getNodeValue();
}
el=XMLGetFirstChild(txt,"time");
if(el && el->firstChild())
{
timestr=el->firstChild()->getNodeValue();
StringFunctions::Convert(timestr,timeval);
messagetime=Poco::Timestamp(timeval*static_cast<Poco::Timestamp::TimeVal>(1000));
}
el=XMLGetFirstChild(txt,"text");
if(el && el->firstChild())
{
messagetext=el->firstChild()->getNodeValue();
}
if(id!="" && messagetext!="")
{
m_messages.push_back(message(messagetime,id,replyto,messagetext));
}
txt=XMLGetNextSibling(txt,"reply");
}
}
if(profile)
{
std::string avatarid("");
Poco::XML::Element *avatar=XMLGetFirstChild(profile,"avatar");
if(avatar && avatar->firstChild() && avatar->firstChild()->getNodeValue()!="")
{
std::string avatarid=avatar->firstChild()->getNodeValue();
if(albums)
{
Poco::XML::Element *album=XMLGetFirstChild(albums,"album");
while(album)
{
Poco::XML::Element *images=XMLGetFirstChild(album,"images");
if(images)
{
Poco::XML::Element *image=XMLGetFirstChild(images,"image");
while(image)
{
Poco::XML::Element *imid=XMLGetFirstChild(image,"id");
if(imid && imid->firstChild())
{
if(imid->firstChild()->getNodeValue()==avatarid)
{
Poco::XML::Element *key=XMLGetFirstChild(image,"key");
if(key && key->firstChild())
{
m_avatar=key->firstChild()->getNodeValue();
}
}
}
image=XMLGetNextSibling(image,"image");
}
}
album=XMLGetNextSibling(album,"album");
}
}
}
}
parsed=true;
}
catch(...)
{
}
return parsed;
}
svgtiny_code svgtiny_parse(struct svgtiny_diagram *diagram,
const char *buffer, size_t size, const char *url,
int viewport_width, int viewport_height)
{
Poco::XML::Document *document;
//Poco::XML::Element *svg;
Poco::XML::Element *svg;
struct svgtiny_parse_state state;
float x, y, width, height;
svgtiny_code code;
assert(diagram);
assert(buffer);
assert(url);
std::string str(buffer);
Poco::XML::DOMParser parser;
document = parser.parseString(str);
svg = document->documentElement();
//std::cout << svg->localName() << std::endl;
if (!svg)
return svgtiny_NOT_SVG;
if (svg->localName().compare("svg") != 0)
return svgtiny_NOT_SVG;
/* get graphic dimensions */
state.diagram = diagram;
state.document = document;
state.viewport_width = viewport_width;
state.viewport_height = viewport_height;
svgtiny_parse_position_attributes(svg, state, &x, &y, &width, &height);
diagram->width = width;
diagram->height = height;
/* set up parsing state */
state.viewport_width = width;
state.viewport_height = height;
state.ctm.a = 1; /*(float) viewport_width / (float) width;*/
state.ctm.b = 0;
state.ctm.c = 0;
state.ctm.d = 1; /*(float) viewport_height / (float) height;*/
state.ctm.e = 0; /*x;*/
state.ctm.f = 0; /*y;*/
/*state.style = css_base_style;
state.style.font_size.value.length.value = option_font_size * 0.1;*/
state.fill = 0x000000;
state.stroke = svgtiny_TRANSPARENT;
state.stroke_width = 1;
state.linear_gradient_stop_count = 0;
/* parse tree */
code = svgtiny_parse_svg(svg, state, diagram);
/* free XML tree */
//xmlFreeDoc(document);
return code;
}
/**
Peforms the processing associated with these transformations.
*/
void MDGeometryXMLParser::execute() {
Poco::XML::DOMParser pParser;
Poco::AutoPtr<Poco::XML::Document> pDoc = pParser.parseString(m_xmlToProcess);
Poco::XML::Element *pRootElem = pDoc->documentElement();
// Apply root node checking if supplied.
Poco::XML::Element *geometryXMLElement = nullptr;
if (!m_rootNodeName.empty()) {
Poco::XML::Element *temp = pRootElem->getChildElement(m_rootNodeName);
geometryXMLElement = temp;
if (geometryXMLElement == nullptr) {
std::string message =
"Root node was not found to be the expected value of " +
m_rootNodeName;
throw std::runtime_error(message);
}
} else {
// The default is to take the root node to be the geometry xml element.
geometryXMLElement = pRootElem;
}
Poco::AutoPtr<Poco::XML::NodeList> dimensionsXML =
geometryXMLElement->getElementsByTagName(
MDGeometryXMLDefinitions::workspaceDimensionElementName());
size_t nDimensions = dimensionsXML->length();
VecIMDDimension_sptr vecAllDims(nDimensions);
////Extract dimensions
for (size_t i = 0; i < nDimensions; i++) {
Poco::XML::Element *dimensionXML = static_cast<Poco::XML::Element *>(
dimensionsXML->item(static_cast<unsigned long>(i)));
vecAllDims[i] = createDimension(*dimensionXML);
}
VecIMDDimension_sptr vecNonMappedDims = vecAllDims;
Poco::XML::Element *xDimensionElement = geometryXMLElement->getChildElement(
MDGeometryXMLDefinitions::workspaceXDimensionElementName());
std::string xDimId =
xDimensionElement
->getChildElement(
MDGeometryXMLDefinitions::workspaceRefDimensionElementName())
->innerText();
if (!xDimId.empty()) {
auto xDimensionIt =
find_if(vecAllDims.begin(), vecAllDims.end(), findID(xDimId));
if (xDimensionIt == vecAllDims.end()) {
throw std::invalid_argument("Cannot determine x-dimension mapping.");
}
m_xDimension = *xDimensionIt;
vecNonMappedDims.erase(std::remove_if(vecNonMappedDims.begin(),
vecNonMappedDims.end(),
findID(xDimId)),
vecNonMappedDims.end());
}
Poco::XML::Element *yDimensionElement = geometryXMLElement->getChildElement(
MDGeometryXMLDefinitions::workspaceYDimensionElementName());
std::string yDimId =
yDimensionElement
->getChildElement(
MDGeometryXMLDefinitions::workspaceRefDimensionElementName())
->innerText();
if (!yDimId.empty()) {
auto yDimensionIt =
find_if(vecAllDims.begin(), vecAllDims.end(), findID(yDimId));
if (yDimensionIt == vecAllDims.end()) {
throw std::invalid_argument("Cannot determine y-dimension mapping.");
}
m_yDimension = *yDimensionIt;
vecNonMappedDims.erase(std::remove_if(vecNonMappedDims.begin(),
vecNonMappedDims.end(),
findID(yDimId)),
vecNonMappedDims.end());
}
Poco::XML::Element *zDimensionElement = geometryXMLElement->getChildElement(
MDGeometryXMLDefinitions::workspaceZDimensionElementName());
std::string zDimId =
zDimensionElement
->getChildElement(
MDGeometryXMLDefinitions::workspaceRefDimensionElementName())
->innerText();
if (!zDimId.empty()) {
auto zDimensionIt =
find_if(vecAllDims.begin(), vecAllDims.end(), findID(zDimId));
if (zDimensionIt == vecAllDims.end()) {
throw std::invalid_argument("Cannot determine z-dimension mapping.");
}
m_zDimension = *zDimensionIt;
vecNonMappedDims.erase(std::remove_if(vecNonMappedDims.begin(),
vecNonMappedDims.end(),
findID(zDimId)),
vecNonMappedDims.end());
}
Poco::XML::Element *tDimensionElement = geometryXMLElement->getChildElement(
MDGeometryXMLDefinitions::workspaceTDimensionElementName());
std::string tDimId =
tDimensionElement
->getChildElement(
MDGeometryXMLDefinitions::workspaceRefDimensionElementName())
->innerText();
if (!tDimId.empty()) {
auto tDimensionIt =
find_if(vecAllDims.begin(), vecAllDims.end(), findID(tDimId));
if (tDimensionIt == vecAllDims.end()) {
throw std::invalid_argument("Cannot determine t-dimension mapping.");
}
m_tDimension = *tDimensionIt;
if (!vecNonMappedDims.empty()) {
vecNonMappedDims.erase(std::remove_if(vecNonMappedDims.begin(),
vecNonMappedDims.end(),
findID(tDimId)),
vecNonMappedDims.end());
}
}
m_vecNonMappedDims = vecNonMappedDims; // Copy with strong guarantee.
m_vecAllDims = vecAllDims;
m_executed = true;
}
