void CADReader::connectevent (DOMElement* element) throw(CADReadException) { std::string element_name; EventConnectionData event_connection; DOMNode* child = element->getFirstChild(); while (child != 0) { if (child->getNodeType() == DOMNode::ELEMENT_NODE) { element_name = XMLString::transcode(child->getNodeName()); // // consumesport // if (element_name == "consumesport") { event_connection.consumer = consumesport((DOMElement*)(child)); } // // emitsport // else if (element_name == "emitsport") { event_connection.kind = EMITTER; event_connection.emitter = emitsport((DOMElement*)(child)); } // // publishesport // else if (element_name == "publishesport") { event_connection.kind = PUBLISHER; event_connection.emitter = publishesport((DOMElement*)(child)); } } // get next child child = child->getNextSibling(); } // add new event_connection data_->event_connections_.push_back(event_connection); }
void *NclPresentationControlParser::parseCompositeRule( DOMElement *parentElement, void *objGrandParent) { wclog << "parseCompositeRule" << endl; void *parentObject; DOMNodeList *elementNodeList; DOMElement *element; DOMNode *node; string elementTagName; void *elementObject; parentObject = createCompositeRule(parentElement, objGrandParent); if (parentObject == NULL) { return NULL; } elementNodeList = parentElement->getChildNodes(); for (int i = 0; i < (int)elementNodeList->getLength(); i++) { node = elementNodeList->item(i); if (node->getNodeType() == DOMNode::ELEMENT_NODE) { element = (DOMElement*)node; elementTagName = XMLString::transcode(element->getTagName()); wclog << ">>" << elementTagName.c_str() << ": "; wclog << XMLString::transcode(element->getAttribute(XMLString::transcode("id"))) << endl; if (XMLString::compareIString(elementTagName.c_str(), "rule") == 0) { elementObject = parseRule(element, parentObject); if (elementObject != NULL) { addRuleToCompositeRule(parentObject, elementObject); } } else if(XMLString::compareIString(elementTagName.c_str(), "compositeRule")==0) { elementObject = parseCompositeRule(element, parentObject); if (elementObject != NULL) { addCompositeRuleToCompositeRule( parentObject, elementObject); } } } } return parentObject; }
XERCES_CPP_NAMESPACE_BEGIN DOMDocument * XIncludeDOMDocumentProcessor::doXIncludeDOMProcess(const DOMDocument * const source, XMLErrorReporter *errorHandler, XMLEntityHandler* entityResolver /*=NULL*/){ XIncludeUtils xiu(errorHandler); DOMImplementation* impl = source->getImplementation(); DOMDocument *xincludedDocument = impl->createDocument(); try { /* set up the declaration etc of the output document to match the source */ xincludedDocument->setDocumentURI( source->getDocumentURI()); xincludedDocument->setXmlStandalone( source->getXmlStandalone()); xincludedDocument->setXmlVersion( source->getXmlVersion()); /* copy entire source document into the xincluded document. Xincluded document can then be modified in place */ DOMNode *child = source->getFirstChild(); for (; child != NULL; child = child->getNextSibling()){ if (child->getNodeType() == DOMNode::DOCUMENT_TYPE_NODE){ /* I am simply ignoring these at the moment */ continue; } DOMNode *newNode = xincludedDocument->importNode(child, true); xincludedDocument->appendChild(newNode); } DOMNode *docNode = xincludedDocument->getDocumentElement(); /* parse and include the document node */ xiu.parseDOMNodeDoingXInclude(docNode, xincludedDocument, entityResolver); xincludedDocument->normalizeDocument(); } catch(const XMLErrs::Codes) { xincludedDocument->release(); return NULL; } catch(...) { xincludedDocument->release(); throw; } return xincludedDocument; }
void DeltaApplyEngine::ApplyDeltaElement(DOMNode* incDeltaElement) { vddprintf(("Apply delta element\n")); deltaElement = incDeltaElement; /* ---- Do All DELETE Operations ( including 'from' part of move ) ---- */ vddprintf(("Apply Delete operations\n")); DOMNode* firstOp = deltaElement->getFirstChild() ; vddprintf((" first sort delete operations...\n")); SortDeleteOperationsEngine deleteOps(xiddoc, firstOp); vddprintf((" then apply all of them 1 by 1...\n")); while(!deleteOps.isListEmpty()) { DOMNode* op=deleteOps.getNextDeleteOperation(); ApplyOperation(op); } vddprintf(("Ok, there are no more delete operations.\n")); /* ---- Do All INSERT Operations ( including 'to' part of move ) ---- */ firstOp = deltaElement->getFirstChild() ; SortInsertOperationsEngine insertOps(xiddoc, firstOp); while(!insertOps.isListEmpty()) { DOMNode* op=insertOps.getNextInsertOperation(); ApplyOperation(op); } /* ---- Do all UPDATE & ATTRIBUTE Operations ---- */ DOMNode* child = deltaElement->getFirstChild() ; XMLCh iStr[100]; XMLString::transcode("i", iStr, 99); XMLCh dStr[100]; XMLString::transcode("d", dStr, 99); while (child != NULL) { if ( (!XMLString::equals(child->getLocalName(),iStr)) &&(!XMLString::equals(child->getLocalName(), dStr)) ) ApplyOperation(child); child = child->getNextSibling() ; } /* ---- Small consistency checks ---- */ if (moveDocument->getDocumentElement()->hasChildNodes()) THROW_AWAY(("temporary document used to move node is not empty!")); vddprintf(("xiddoc=%s\n",xiddoc->getXidMap().String().c_str() )); }
DOMNode* DOMElementImpl::rename(const XMLCh* namespaceURI, const XMLCh* name) { DOMDocumentImpl* doc = (DOMDocumentImpl*) getOwnerDocument(); if (!namespaceURI || !*namespaceURI) { fName = doc->getPooledString(name); fAttributes->reconcileDefaultAttributes(getDefaultAttributes()); return this; } else { // create a new ElementNS DOMElementNSImpl* newElem = (DOMElementNSImpl*)doc->createElementNS(namespaceURI, name); // transfer the userData doc->transferUserData(castToNodeImpl(this), castToNodeImpl(newElem)); // remove old node from parent if any DOMNode* parent = getParentNode(); DOMNode* nextSib = getNextSibling(); if (parent) { parent->removeChild(this); } // move children to new node DOMNode* child = getFirstChild(); while (child) { removeChild(child); newElem->appendChild(child); child = getFirstChild(); } // insert new node where old one was if (parent) { parent->insertBefore(newElem, nextSib); } // move specified attributes to new node newElem->fAttributes->moveSpecifiedAttributes(fAttributes); // and fire user data NODE_RENAMED event castToNodeImpl(newElem)->callUserDataHandlers(DOMUserDataHandler::NODE_RENAMED, this, newElem); return newElem; } }
Metadata::Metadata(DOMDocument *doc) { DOMElement *metadataRootElem = doc->getDocumentElement(); if(metadataRootElem == NULL){ return; } XMLCh *keyValStr = XMLString::transcode("keyval"); DOMNodeList *keyValElems = metadataRootElem->getElementsByTagName(keyValStr); const XMLSize_t nodeCount = keyValElems->getLength(); //cout << "Metadata::constructor: Found " << nodeCount << " keyval elements" << endl; for(XMLSize_t i = 0; i < nodeCount; i++){ DOMNode* currentNode = keyValElems->item(i) ; if(currentNode == NULL){ continue; } if( xercesc::DOMNode::ELEMENT_NODE != currentNode->getNodeType() ){ // not an element node -> not of interest here continue ; } DOMElement* metadataElem = dynamic_cast< xercesc::DOMElement* >(currentNode); string key; read(metadataElem, "key", key); vector<string> values; readMany(metadataElem, "val", values); /*cout << "Processing DOMElement (key, values): (" << key << ", "; for(int j=0; j < values.size(); j++){ cout << values[j] << ", "; } cout << ")" << endl;*/ elementMap[key] = values; } }
void AcsAlarmTestCase::verifyFaultStateElement(DOMDocument * doc, bool propertiesAndTimestampPopulated) { // Verify that the fault-state element exists DOMNodeList * faultStateNodes = doc->getElementsByTagName(FAULT_STATE_TAG_NAME); CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; no fault-state element found", (NULL != faultStateNodes && faultStateNodes->getLength() == 1)); // verify that there are the expected attributes (family, member, code) on the fault-state element DOMNode * faultStateItem = faultStateNodes->item(0); if(NULL != faultStateItem) { // verify that there are 3 attributes in total DOMNamedNodeMap * attributesMap = faultStateItem->getAttributes(); CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; fault-state does not contain 3 attributes", (NULL!= attributesMap && attributesMap->getLength() == 3)); // check that the fault-state element has a "family" attribute DOMNode * familyNode = attributesMap->getNamedItem(FAMILY_TAG_NAME); CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; fault-state does not contain 'family' attribute", (NULL!= familyNode)); // verify that the value of family attribute is correct const XMLCh * familyNodeValue = familyNode->getNodeValue(); CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; value of fault-state 'family' is not correct", (NULL != familyNodeValue && XMLString::equals(familyNodeValue, FAMILY_VALUE_XMLCH))); // check that the fault-state element has a "member" attribute DOMNode * memberNode = attributesMap->getNamedItem(MEMBER_TAG_NAME); CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; fault-state does not contain 'member' attribute", (NULL!= memberNode)); // verify that the value of member attribute is correct const XMLCh * memberNodeValue = memberNode->getNodeValue(); CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; value of fault-state 'member' is not correct", (NULL != memberNodeValue && XMLString::equals(memberNodeValue, MEMBER_VALUE_XMLCH))); // check that the fault-state element has a "code" attribute DOMNode * codeNode = attributesMap->getNamedItem(CODE_TAG_NAME); CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; fault-state does not contain 'code' attribute", (NULL!= codeNode)); // verify that the value of code attribute is correct const XMLCh * codeNodeValue = codeNode->getNodeValue(); char *codeNodeCharValue = XMLString::transcode(codeNodeValue); int codeNodeValueInt = atoi(codeNodeCharValue); XMLString::release(&codeNodeCharValue); CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; value of fault-state 'code' is not correct", (NULL != codeNodeValue && codeNodeValueInt == CODE_VALUE)); } verifyDescriptorElement(doc); if(propertiesAndTimestampPopulated) { verifyUserPropertiesElement(doc); verifyUserTimestampElement(doc); } }
static DeviceInstance extractDeviceInstance(DOMDocument * domDocument, DOMTreeWalker * domTreeWalker) { DeviceInstance deviceInstance; map<string, ParameterGroup> parameterGroupMap; DOMNode * node = domTreeWalker->getCurrentNode(); DOMNamedNodeMap * nodeMap = node->getAttributes(); DOMNode * nameAttribute = nodeMap->getNamedItem(XMLString::transcode("name")); if (nameAttribute) { deviceInstance.setName(XMLString::transcode(nameAttribute->getNodeValue())); } DOMNode * typenameAttribute = nodeMap->getNamedItem(XMLString::transcode("typename")); if (typenameAttribute) { deviceInstance.setDeviceTypeName(XMLString::transcode(typenameAttribute->getNodeValue())); } while (node) { if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "ParameterGroup") == 0) { DOMNamedNodeMap * nodeMap = node->getAttributes(); string name; DOMNode * nameAttribute = nodeMap->getNamedItem(XMLString::transcode("name")); if (nameAttribute) { name = XMLString::transcode(nameAttribute->getNodeValue()); } XMLNodeFilter * nodeFilter = new XMLNodeFilter(); DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true); ParameterGroup pg = extractParameterGroup(domDocument, d); pg.setName(name); parameterGroupMap[name] = pg; d->release(); delete nodeFilter; } node = domTreeWalker->nextNode(); } ParameterGroup parameterGroup; parameterGroup.setName("root"); parameterGroup.setParameterGroupMap(parameterGroupMap); deviceInstance.setParameterGroup(parameterGroup); return deviceInstance; }
//============================================================================= // METHOD: SPELLxmlConfigReaderXC::findElementsByName //============================================================================= SPELLxmlNodeList SPELLxmlConfigReaderXC::findElementsByName( std::string tagName ) { SPELLxmlNodeList result; if (m_document == NULL) { THROW_EXCEPTION("Cannot find elements", "No document available", SPELL_ERROR_CONFIG); } DEBUG("[CFGR] Get elements by name: " + tagName); // Get the tag translation XMLCh* tag = XMLString::transcode(tagName.c_str()); // Get the top-level element DOMElement* elementRoot = m_document->getDocumentElement(); if( !elementRoot ) { THROW_EXCEPTION("Cannot get root element", "Empty document", SPELL_ERROR_CONFIG); } DOMNodeList* children = elementRoot->getChildNodes(); const XMLSize_t nodeCount = children->getLength(); // For all nodes, children of "root" in the XML tree. for (XMLSize_t xx = 0; xx < nodeCount; ++xx) { DOMNode* currentNode = children->item(xx); if (currentNode->getNodeType() && // true is not NULL currentNode->getNodeType() == DOMNode::ELEMENT_NODE) // is element { // Found node which is an Element. Re-cast node as element DOMElement* currentElement = dynamic_cast<xercesc::DOMElement*> (currentNode); if (XMLString::equals(currentElement->getTagName(), tag)) { result.push_back( convertToNode( currentElement ) ); } } } XMLString::release(&tag); DEBUG("[CFGR] Found " + ISTR(result.size()) + " elements"); return result; }
static vector<Connector> extractConnectorVector(DOMDocument * domDocument, DOMTreeWalker * domTreeWalker) { vector<Connector> connectorVector; DOMNode * node = domTreeWalker->getCurrentNode(); while (node) { if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "Connector") == 0) { XMLNodeFilter * nodeFilter = new XMLNodeFilter(); DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true); Connector connector = extractConnector(domDocument, d); connectorVector.push_back(connector); d->release(); delete nodeFilter; } node = domTreeWalker->nextNode(); } return connectorVector; }
static map<string, TUIObjectType> extractTUIObjectTypeMap(DOMDocument * domDocument, DOMTreeWalker * domTreeWalker) { map<string, TUIObjectType> tuiObjectTypeMap; DOMNode * node = domTreeWalker->getCurrentNode(); while (node) { if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "TUIObjectType") == 0) { XMLNodeFilter * nodeFilter = new XMLNodeFilter(); DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true); TUIObjectType tuiObjectType = extractTUIObjectType(domDocument, d); tuiObjectTypeMap[tuiObjectType.getName()] = tuiObjectType; d->release(); delete nodeFilter; } node = domTreeWalker->nextNode(); } return tuiObjectTypeMap; }
void CSDReader::valuetypefactory (DOMElement* element) throw(CSDReadException) { std::string element_name; ValuetypeData data; data.repid = Qedo::transcode(element->getAttribute(X("repid"))); DOMNode* child = element->getFirstChild(); while (child != 0) { if (child->getNodeType() == DOMNode::ELEMENT_NODE) { element_name = Qedo::transcode(child->getNodeName()); // // codebase // if (element_name == "codebase") { // todo } // // fileinarchive // if (element_name == "fileinarchive") { data.location = fileinarchive((DOMElement*)child); } // // link // if (element_name == "link") { data.location = link((DOMElement*)child); } } // get next child child = child->getNextSibling(); } DEBUG_OUT2( "CSDReader: <valuetypefactory> ", data.repid ); data_->valuetypes.push_back(data); }
void CSDReader::softpkgref (DOMElement* element) throw(CSDReadException) { std::string element_name; std::string idref; DOMNode* child = element->getFirstChild(); while (child != 0) { if (child->getNodeType() == DOMNode::ELEMENT_NODE) { element_name = Qedo::transcode(child->getNodeName()); // // fileinarchive // if (element_name == "fileinarchive") { // todo //fileinarchive( (DOMElement*)child ); } // // link // else if (element_name == "link") { // todo //link( (DOMElement*)child ); } // // implref // else if (element_name == "implref") { idref = implref( (DOMElement*)child ); } } // get next child child = child->getNextSibling(); } data_->softpkg_dependencies.push_back( idref ); }
XmlNode addChild(const char *name) { XMLCh *tempStr = NULL; tempStr = XMLString::transcode(name); DOMElement *element = doc->createElement(tempStr); DOMNode *cnode = node->appendChild(element); XMLString::release(&tempStr); return XmlNode(cnode,doc); }
void AcsAlarmTestCase::verifyDescriptorElement(DOMDocument * doc) { // Verify the descriptor element DOMNodeList * descriptorNodes = doc->getElementsByTagName(DESCRIPTOR_TAG_NAME); CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; no descriptor element found", (NULL != descriptorNodes && descriptorNodes->getLength() == 1)); // check value of descriptor DOMNode * descriptorElementNode = descriptorNodes->item(0); DOMNode * descriptorTextNode = descriptorElementNode->getFirstChild(); CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; descriptor value is not present or null", (NULL != descriptorTextNode)); const XMLCh * descriptorNodeValue = descriptorTextNode->getNodeValue(); CPPUNIT_ASSERT_MESSAGE("FaultState::toXML appears to be broken; value of descriptor is not correct", (NULL != descriptorNodeValue && XMLString::equals(descriptorNodeValue, DESCRIPTOR_VALUE_XMLCH))); }
static ServerStartupConfig extractServerStartupConfig(DOMDocument * domDocument, DOMTreeWalker * domTreeWalker) { ServerStartupConfig serverStartupConfig; DOMNode * node = domTreeWalker->getCurrentNode(); while (node) { if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "Network") == 0) { DOMNamedNodeMap * nodeMap = node->getAttributes(); DOMNode * portAttribute = nodeMap->getNamedItem(XMLString::transcode("port")); if (portAttribute) { serverStartupConfig.setPortNr(XMLString::parseInt(portAttribute->getNodeValue())); } } node = domTreeWalker->nextNode(); } return serverStartupConfig; }
void CADReader::componentfile (DOMElement* element) throw(CADReadException) { std::string element_name; std::string file_name; DOMNode* child = element->getFirstChild(); while (child != 0) { if (child->getNodeType() == DOMNode::ELEMENT_NODE) { element_name = XMLString::transcode(child->getNodeName()); // // fileinarchive // if (element_name == "fileinarchive") { file_name = fileinarchive((DOMElement*)(child)); } // // codebase // else if (element_name == "codebase") { // TODO } // // link // else if (element_name == "link") { file_name = link((DOMElement*)(child)); } } // get next child child = child->getNextSibling(); } std::string id = XMLString::transcode(element->getAttribute(X("id"))); DEBUG_OUT2( "CADReader: <componentfile> ", file_name ); data_->implementationMap_[id] = file_name; }
void XercesUpdateFactory::completeDeletions(DynamicContext *context) { // e. Finally, for each node marked for deletion by one of the update primitives listed above, let $N be the node that is marked // for deletion, and let $P be its parent node. The following actions are applied: // i. The parent property of $N is set to empty. // ii. If $N is an attribute node, the attributes property of $P is modified to remove $N. // iii. If $N is a non-attribute node, the children property of $P is modified to remove $N. // iv. If $N is an element, attribute, or text node, and $P is an element node, then upd:removeType($P) is invoked. for(DOMNodeSet::iterator i = forDeletion_.begin(); i != forDeletion_.end(); ++i) { DOMNode *domnode = *i; if(domnode->getNodeType() == DOMNode::ATTRIBUTE_NODE) { DOMAttr *attr = (DOMAttr*)domnode; DOMElement *owner = attr->getOwnerElement(); if(owner != 0) { owner->removeAttributeNode(attr); removeType(owner); } } else { DOMNode *parent = domnode->getParentNode(); if(parent != 0) { parent->removeChild(domnode); if(domnode->getNodeType() == DOMNode::ELEMENT_NODE || domnode->getNodeType() == DOMNode::TEXT_NODE || domnode->getNodeType() == DOMNode::CDATA_SECTION_NODE) { removeType(parent); } } } } }
void XercesUpdateFactory::setTypes(DOMNode *node, const DOMNode *from) { if(node->getNodeType() == DOMNode::ELEMENT_NODE) { const XMLCh *turi, *tname; XercesNodeImpl::typeUriAndName(from, turi, tname); XercesSequenceBuilder::setElementTypeInfo((DOMElement *)node, turi, tname); DOMNamedNodeMap *attrs = node->getAttributes(); DOMNamedNodeMap *attrsfrom = from->getAttributes(); for(unsigned int i = 0; i < attrs->getLength(); ++i) { DOMNode *a = attrs->item(i); DOMNode *afrom = attrsfrom->getNamedItemNS(a->getNamespaceURI(), Axis::getLocalName(a)); if(afrom) setTypes(a, afrom); } DOMNode *child = node->getFirstChild(); DOMNode *cfrom = from->getFirstChild(); while(child) { if(child->getNodeType() == DOMNode::ELEMENT_NODE) setTypes(child, cfrom); child = child->getNextSibling(); cfrom = cfrom->getNextSibling(); } } else if(node->getNodeType() == DOMNode::ATTRIBUTE_NODE) { const XMLCh *turi, *tname; XercesNodeImpl::typeUriAndName(from, turi, tname); XercesSequenceBuilder::setAttributeTypeInfo((DOMAttr *)node, turi, tname); } }
void XercesUpdateFactory::applyRename(const PendingUpdate &update, DynamicContext *context) { const XercesNodeImpl *nodeImpl = (const XercesNodeImpl*)update.getTarget()->getInterface(Item::gXQilla); DOMNode *domnode = const_cast<DOMNode*>(nodeImpl->getDOMNode()); ATQNameOrDerived *qname = (ATQNameOrDerived*)update.getValue().first().get(); if(domnode->getNodeType() == DOMNode::PROCESSING_INSTRUCTION_NODE) { DOMProcessingInstruction *newPI = domnode->getOwnerDocument()-> createProcessingInstruction(qname->getName(), domnode->getNodeValue()); domnode->getParentNode()->replaceChild(newPI, domnode); domnode = newPI; } else { // If $newName has an implied namespace binding that conflicts with an existing namespace binding // in the namespaces property of $target, a dynamic error is raised [err:XUDY0024]. // If $target has a parent, and $newName has an implied namespace binding that conflicts with a // namespace binding in the namespaces property of parent($target), a dynamic error is raised [err:XUDY0024]. domnode->getOwnerDocument()->renameNode(domnode, qname->getURI(), qname->getName()); if(qname->getURI() != 0 && *qname->getURI() != 0) domnode->setPrefix(qname->getPrefix()); removeType(domnode); } // Deliberately create a new XercesNodeImpl, since the PI is actually // replaced, not just renamed, meaning it is no longer attached to the tree addToPutSet(nodeImpl, &update, context); }
void Materia::buildFromXml (DOMNode *node) { XMLCh* tag_codigo = XMLString::transcode("codigo"); XMLCh* tag_nome = XMLString::transcode("nome"); XMLCh* tag_creditos = XMLString::transcode("creditos"); XMLCh* tag_conceito = XMLString::transcode("conceito"); XMLCh* tag_situacao = XMLString::transcode("situacao"); DOMNodeList *l_children = node->getChildNodes(); for (XMLSize_t i = 0; i < l_children->getLength(); ++i) { DOMNode *n = l_children->item(i); const XMLCh *tag = n->getNodeName(); if (XMLString::equals(tag, tag_codigo)) { this->codigo = XMLString::transcode(n->getTextContent()); } else if (XMLString::equals(tag, tag_nome)) { this->nome = XMLString::transcode(n->getTextContent()); } else if (XMLString::equals(tag, tag_creditos)) { this->creditos = stoi(XMLString::transcode(n->getTextContent())); } else if (XMLString::equals(tag, tag_conceito)) { this->conceito = stod(XMLString::transcode(n->getTextContent())); } else if (XMLString::equals(tag, tag_situacao)) { this->situacao = XMLString::transcode(n->getTextContent()); } } XMLString::release(&tag_codigo); XMLString::release(&tag_nome); XMLString::release(&tag_creditos); XMLString::release(&tag_conceito); XMLString::release(&tag_situacao); }
void DTMReader::mapping(DOMElement* element) throw(DTMReadException) { DOMNode* child = element->getFirstChild(); while (child != 0) { if (child->getNodeType() == DOMNode::ELEMENT_NODE) { // handle corba-type if ( !XMLString::compareString(child->getNodeName(), X("corba-type")) ) vCorba_.push_back(get_value((DOMElement*)child)); // handle cpp-type else if ( !XMLString::compareString(child->getNodeName(), X("cpp-type")) ) vCpp_.push_back(get_value((DOMElement*)child)); // handle cpp-native-type else if ( !XMLString::compareString(child->getNodeName(), X("cpp-native-type")) ) vCppNative_.push_back(get_value((DOMElement*)child)); // handle sql-type else if ( !XMLString::compareString(child->getNodeName(), X("sql-type")) ) vSql_.push_back(get_value((DOMElement*)child)); } // get next child child = child->getNextSibling(); } }
string CXmlConfig::getValue(DOMNode* parentNode, const string& itemName) { string strValue; string strName; DOMNode* firstChildNode = NULL; charArrayToString(parentNode->getNodeName(), strName); if (strName == itemName) { firstChildNode = parentNode->getFirstChild(); if (firstChildNode != NULL) charArrayToString(firstChildNode->getNodeValue(), strValue); return strValue; } DOMNodeList* nodeList = parentNode->getChildNodes(); for (unsigned int i = 0; i < nodeList->getLength(); ++i) { DOMNode* nodeTemp = nodeList->item(i); if (nodeTemp->getNodeType() == DOMNode::ELEMENT_NODE) { charArrayToString(nodeTemp->getNodeName(), strName); if (strName == itemName) { firstChildNode = nodeTemp->getFirstChild(); if (firstChildNode != NULL) charArrayToString(firstChildNode->getNodeValue(), strValue); break; } } } return strValue; }
vector<ImportDescriptor*> SignatureSetImporter::createImportDescriptors(DOMTreeWalker* pTree, vector<string> &datasetPath) { vector<ImportDescriptor*> descriptors; FactoryResource<DynamicObject> pMetadata; VERIFYRV(pMetadata.get() != NULL, descriptors); string datasetName = StringUtilities::toDisplayString(mDatasetNumber++); for (DOMNode* pChld = pTree->firstChild(); pChld != NULL; pChld = pTree->nextSibling()) { if (XMLString::equals(pChld->getNodeName(), X("metadata"))) { DOMElement* pElmnt = static_cast<DOMElement*>(pChld); string name = A(pElmnt->getAttribute(X("name"))); string val = A(pElmnt->getAttribute(X("value"))); pMetadata->setAttribute(name, val); if (name == "Name") { datasetName = val; } } else if (XMLString::equals(pChld->getNodeName(), X("signature_set"))) { datasetPath.push_back(datasetName); vector<ImportDescriptor*> sub = createImportDescriptors(pTree, datasetPath); datasetPath.pop_back(); descriptors.insert(descriptors.end(), sub.begin(), sub.end()); pTree->parentNode(); } } ImportDescriptorResource pImportDescriptor(datasetName, "SignatureSet", datasetPath); VERIFYRV(pImportDescriptor.get() != NULL, descriptors); DataDescriptor* pDataDescriptor = pImportDescriptor->getDataDescriptor(); VERIFYRV(pDataDescriptor != NULL, descriptors); FactoryResource<SignatureFileDescriptor> pFileDescriptor; VERIFYRV(pFileDescriptor.get() != NULL, descriptors); pFileDescriptor->setFilename(mFilename); datasetPath.push_back(datasetName); string loc = "/" + StringUtilities::join(datasetPath, "/"); datasetPath.pop_back(); pFileDescriptor->setDatasetLocation(loc); pDataDescriptor->setFileDescriptor(pFileDescriptor.get()); pDataDescriptor->setMetadata(pMetadata.get()); descriptors.push_back(pImportDescriptor.release()); return descriptors; }
void ColladaObject::ReadRootNode(const DOMNode* node) { _ASSERTE(node != NULL); DOMNode* currentNode = node->getFirstChild(); while( currentNode != NULL ) { #if _DEBUG // デバッグ時に名前をチェックする為に const XMLCh* name = currentNode->getNodeName(); #endif if( IsElementNode( currentNode ) ) { if( Is_COLLADA_NodeName( currentNode ) ) // COLLADA要素が見つかった場合 { currentNode = currentNode->getFirstChild(); // 子ノードを処理する continue; } else if( Is_asset_NodeName( currentNode ) ) // asset要素が見つかった場合 { _ASSERTE(elemAsset == NULL); // 必ず1つ存在するのでこの時点ではNULL elemAsset = new AssetElement(); elemAsset->ReadNode( currentNode ); } else if( Is_library_NodeName( currentNode ) ) // library要素が見つかった場合 { LibraryElement* elemLibrary = CreateLibraryElement( currentNode ); if( elemLibrary != NULL ) { elemLibrary->ReadNode( currentNode ); vecElemLibrary.push_back( elemLibrary ); } } else if( Is_scene_NodeName( currentNode ) ) // scene要素が見つかった場合 { _ASSERTE(elemScene == NULL); // 0または1つ存在するのでこの時点ではNULL elemScene = new SceneElement(); elemScene->ReadNode( currentNode ); } } currentNode = currentNode->getNextSibling(); // 次の要素を処理する } }
bool CConfigParser::ParseDevices(DOMNodeList* deviceNodeList, ADeviceListener& configClass) { ASSERT(deviceNodeList->getLength() >= 1); DOMNode* deviceNode = deviceNodeList->item(0); DOMNodeList* devices = deviceNode->getChildNodes(); for(unsigned long idx = 0; idx < devices->getLength(); idx++) { DOMNode* currentDevice = devices->item(idx); wstring deviceNodeName = currentDevice->getNodeName(); if(deviceNodeName.compare(L"#text") == 0) continue; wstring deviceName = currentDevice->getAttributes()->getNamedItem(L"name")->getNodeValue(); //wstring deviceType = currentDevice->getAttributes()->getNamedItem(L"type")->getNodeValue(); wstring deviceType = deviceNodeName; if(deviceType.compare(L"mouse") == 0) { configClass.AddDevice(deviceName, new CMouseProc()); } else { CWin32SpaceNavigatorHIDCapture* deviceToAdd = new CWin32SpaceNavigatorHIDCapture(); if(currentDevice->hasChildNodes()) { if(!ParseHIDDeviceCommands(currentDevice->getChildNodes(), deviceToAdd)) return false; } configClass.AddDevice(deviceName, deviceToAdd); } } return true; }
PortData CADReader::emitsport (DOMElement* element) throw(CADReadException) { std::string element_name; PortData data; DOMNode* child = element->getFirstChild(); while (child != 0) { if (child->getNodeType() == DOMNode::ELEMENT_NODE) { element_name = XMLString::transcode(child->getNodeName()); // // emitsidentifier // if (element_name == "emitsidentifier") { data.name = emitsidentifier((DOMElement*)(child)); } // // componentinstantiationref // else if (element_name == "componentinstantiationref") { data.ref.kind = COMPONENTID; data.ref.name = componentinstantiationref((DOMElement*)(child)); } // // findby // else if (element_name == "findby") { data.ref = findby((DOMElement*)(child)); } } // get next child child = child->getNextSibling(); } return data; }
static TUIObjectType extractTUIObjectType(DOMDocument * domDocument, DOMTreeWalker * domTreeWalker) { TUIObjectType tuiObjectType; DOMNode * node = domTreeWalker->getCurrentNode(); DOMNamedNodeMap * nodeMap = node->getAttributes(); DOMNode * nameAttribute = nodeMap->getNamedItem(XMLString::transcode("name")); if (nameAttribute) { tuiObjectType.setName(XMLString::transcode(nameAttribute->getNodeValue())); } while (node) { if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "PortTypeSequence") == 0) { XMLNodeFilter * nodeFilter = new XMLNodeFilter(); DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true); tuiObjectType.setPortMap(extractPortMap(domDocument, d)); d->release(); delete nodeFilter; } else if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "Description") == 0) { XMLCh * textContent = XMLString::replicate(node->getTextContent()); XMLString::trim(textContent); tuiObjectType.setDescription(XMLString::transcode(textContent)); XMLString::release(&textContent); } node = domTreeWalker->nextNode(); } return tuiObjectType; }
// Returns the previous logical sibling with respect to the given node. DOMNode* DOMElementImpl::getPreviousLogicalSibling(const DOMNode* n) const { DOMNode* prev = n->getPreviousSibling(); // If "n" has no previous sibling and its parent is an entity reference node we // need to continue the search through the previous siblings of the entity // reference as these are logically siblings of the given node. if (prev == NULL) { DOMNode* parent = n->getParentNode(); while (parent != NULL && parent->getNodeType() == DOMNode::ENTITY_REFERENCE_NODE) { prev = parent->getPreviousSibling(); if (prev != NULL) { break; } parent = parent->getParentNode(); } } return prev; }
void printTypes(const char *label, const DOMNode *node, int indent = 0) { if(indent == 0) std::cerr << "\n"; if(node->getNodeType() == DOMNode::ELEMENT_NODE) { const XMLCh *typeURI, *typeName; XercesNodeImpl::typeUriAndName(node, typeURI, typeName); std::cerr << label << ":" << std::string(indent * 2, ' ') << "name: {" << UTF8(node->getNamespaceURI()) << "}" << UTF8(Axis::getLocalName(node)) << ", type: {" << UTF8(typeURI) << "}" << UTF8(typeName) << "\n"; DOMNode *child = node->getFirstChild(); while(child) { printTypes(label, child, indent + 1); child = child->getNextSibling(); } } }