/**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 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(); }
/** 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; }
void DebugBreakpointManager::SaveState(const Poco::Path& path) const { Poco::XML::Document* doc = new Poco::XML::Document(); Poco::XML::Element* breakpoints = doc->createElement(BREAKPOINTS_TAG); doc->appendChild(breakpoints)->release(); for (std::set<unsigned long>::const_iterator i = m_ObjectBreakpoints.begin(); i != m_ObjectBreakpoints.end(); ++i) { Poco::XML::Element* objectBreakpoint = doc->createElement(OBJECT_TAG); breakpoints->appendChild(objectBreakpoint)->release(); std::stringstream ss; ss << *i; objectBreakpoint->setAttribute(ID_ATTR, ss.str()); const Object* obj = DebugUtil::GetObject(*i); if (obj) { objectBreakpoint->setAttribute(CLASSNAME_ATTR, obj->GetClassName()); } } for (Poco::HashMap<int, const Object*>::ConstIterator i = m_SmartPointerBreakpoints.begin(); i != m_SmartPointerBreakpoints.end(); ++i) { Poco::XML::Element* spBreakpoint = doc->createElement(SMARTPOINTER_TAG); breakpoints->appendChild(spBreakpoint)->release(); std::stringstream ss; ss << i->first; spBreakpoint->setAttribute(ID_ATTR, ss.str()); const Object* obj = i->second; if (i->second) { spBreakpoint->setAttribute(CLASSNAME_ATTR, obj->GetClassName()); ss.clear(); ss << obj->GetTraceId(); spBreakpoint->setAttribute(OBJECTID_ATTR, ss.str()); } } Poco::FileOutputStream writer(path.toString()); Poco::XML::DOMWriter out; out.setOptions(3); //write declaration and pretty print out.writeNode(writer, doc); doc->release(); }
void DebugUtil::SaveState() { Poco::Path path; if (!GetPersistencePath(path)) return; path.setFileName(DEBUG_UTIL_XML); Poco::XML::Document* doc = new Poco::XML::Document(); Poco::XML::Element* debugutil = doc->createElement(DEBUGUTIL_TAG); doc->appendChild(debugutil)->release(); for (std::set<unsigned int>::const_iterator i = m_TracedObjects.begin(); i != m_TracedObjects.end(); ++i) { Poco::XML::Element* traceObject = doc->createElement(TRACEOBJECT_TAG); debugutil->appendChild(traceObject)->release(); std::stringstream ss; ss << *i; traceObject->setAttribute(ID_ATTR, ss.str()); } for (std::set<std::string>::const_iterator i = m_TracedClasses.begin(); i != m_TracedClasses.end(); ++i) { Poco::XML::Element* traceClass = doc->createElement(TRACECLASS_TAG); debugutil->appendChild(traceClass)->release(); traceClass->setAttribute(NAME_ATTR, *i); } try { Poco::FileOutputStream writer(path.toString()); Poco::XML::DOMWriter out; out.setOptions(3); //write declaration and pretty print out.writeNode(writer, doc); doc->release(); // save BreakpointManager path.setFileName(DebugBreakpointManager::BREAKPOINTS_XML); GetBreakpointManager()->SaveState(path); } catch (Poco::FileException& e) { BERRY_WARN << e.displayText(); } }
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; }
/** * 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(); } }
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); }
/** * save XML grouping file */ void saveGroupingTabletoXML(Ui::MuonAnalysis& m_uiForm, const std::string& filename) { std::ofstream outFile(filename.c_str()); if (!outFile) { throw Mantid::Kernel::Exception::FileError("Unable to open file:", filename); } DOMWriter writer; writer.setNewLine("\n"); writer.setOptions(XMLWriter::PRETTY_PRINT); Poco::XML::Document* mDoc = new Document(); Element* rootElem = mDoc->createElement("detector-grouping"); rootElem->setAttribute("description", m_uiForm.groupDescription->text().toStdString()); mDoc->appendChild(rootElem); // loop over groups in table std::vector<int> groupToRow; whichGroupToWhichRow(m_uiForm, groupToRow); int num = static_cast<int>(groupToRow.size()); for (int i = 0; i < num; i++) { Element* gElem = mDoc->createElement("group"); gElem->setAttribute("name", m_uiForm.groupTable->item(groupToRow[i],0)->text().toStdString()); rootElem->appendChild(gElem); Element* idsElem = mDoc->createElement("ids"); idsElem->setAttribute("val", m_uiForm.groupTable->item(groupToRow[i],1)->text().toStdString()); gElem->appendChild(idsElem); } // loop over pairs in pair table num = m_uiForm.pairTable->rowCount(); for (int i = 0; i < num; i++) { QTableWidgetItem *itemName = m_uiForm.pairTable->item(i,0); if (!itemName) break; if ( itemName->text().isEmpty() ) break; QTableWidgetItem *itemAlpha = m_uiForm.pairTable->item(i,3); if (!itemAlpha) break; if ( itemAlpha->text().isEmpty() ) break; QComboBox* qw1 = static_cast<QComboBox*>(m_uiForm.pairTable->cellWidget(i,1)); QComboBox* qw2 = static_cast<QComboBox*>(m_uiForm.pairTable->cellWidget(i,2)); Element* gElem = mDoc->createElement("pair"); gElem->setAttribute("name", itemName->text().toStdString()); rootElem->appendChild(gElem); Element* fwElem = mDoc->createElement("forward-group"); fwElem->setAttribute("val", qw1->currentText().toStdString()); gElem->appendChild(fwElem); Element* bwElem = mDoc->createElement("backward-group"); bwElem->setAttribute("val", qw2->currentText().toStdString()); gElem->appendChild(bwElem); Element* alphaElem = mDoc->createElement("alpha"); alphaElem->setAttribute("val", itemAlpha->text().toStdString()); gElem->appendChild(alphaElem); } // save default Element* gElem = mDoc->createElement("default"); gElem->setAttribute("name", m_uiForm.frontGroupGroupPairComboBox->currentText().toStdString()); rootElem->appendChild(gElem); writer.writeNode(outFile, mDoc); }