map<string, DatasetSpecification> Specifications::readDatasetIndex(string str){ map<string, DatasetSpecification> result; XERCES_CPP_NAMESPACE_USE XMLPlatformUtils::Initialize(); XercesDOMParser parser; parser.setValidationScheme(XercesDOMParser::Val_Always); HandlerBase errHandler;// = (ErrorHandler*) new HandlerBase(); parser.setErrorHandler(&errHandler); parser.parse(str.c_str()); DOMDocument * doc = parser.getDocument(); DOMElement* elementRoot = doc->getDocumentElement(); DOMNodeList *entries = elementRoot->getElementsByTagName(XMLString::transcode("dataset")); cout << "Databases in index:\n"; for(size_t i = 0; i < entries->getLength(); ++i){ DOMNode *current = entries->item(i); DatasetSpecification dss; dss.name = XMLString::transcode(current->getAttributes()-> getNamedItem(XMLString::transcode("name"))-> getNodeValue()); dss.root = XMLString::transcode(current->getAttributes()-> getNamedItem(XMLString::transcode("root"))-> getNodeValue()); cout << " name: " << dss.name << " root: " << dss.root << endl; DOMNodeList *categories = current->getChildNodes(); for(size_t j = 0; j < categories->getLength(); ++j) if((string) XMLString::transcode(categories->item(j)->getNodeName()) == "category") dss.categories.push_back(XMLString::transcode(categories->item(j)->getTextContent())); result[dss.name] = dss; } return result; }
bool CConfigParser::ParseGesture(DOMNode* node, TActionByNameMap actions, CDeviceContext* device) { TGestureList gestures; wstring actionName = node->getAttributes()->getNamedItem(L"action")->getNodeValue(); unsigned long length = node->getChildNodes()->getLength(); for(unsigned long i = 0; i < length; i++) { DOMNode* gestNode = node->getChildNodes()->item(i); wstring nodeType = gestNode->getNodeName(); if(nodeType.compare(L"#text") == 0) continue; if(nodeType.compare(L"motion") == 0) { wstring position = gestNode->getAttributes()->getNamedItem(L"position")->getNodeValue(); wstring axe = gestNode->getAttributes()->getNamedItem(L"axe")->getNodeValue(); EGesturePosition pos; if(position.compare(L"positive") == 0) pos = EGesturePosition::POSITIVE; if(position.compare(L"negative") == 0) pos = EGesturePosition::NEGATIVE; if(position.compare(L"center") == 0) pos = EGesturePosition::CENTER; gestures.push_back(new CMotion(pos, _wtoi(axe.c_str()))); } if(nodeType.compare(L"wait") == 0) gestures.push_back(new CTimeFrame(_wtoi(gestNode->getAttributes()->getNamedItem(L"length")->getNodeValue()))); } device->_gestureProcessor.addMacro(gestures, actions[actionName]); return true; }
bool CConfigParser::ParseContexts(DOMNodeList* contextNodes, ADeviceListener& configClass) { ASSERT(contextNodes->getLength() == 1); DOMNode* contextNode = contextNodes->item(0); DOMNodeList* contexts = contextNode->getChildNodes(); for(unsigned long idx = 0; idx < contexts->getLength(); idx++) { DOMNode* currentContext = contexts->item(idx); wstring contextNodeName = currentContext->getNodeName(); if(contextNodeName.compare(L"#text") == 0) continue; wstring contextName = currentContext->getAttributes()->getNamedItem(L"name")->getNodeValue(); CContext* contextToAdd = new CContext(); unsigned long attrLen = currentContext->getAttributes()->getLength(); for(unsigned long attr = 0; attr < attrLen; attr++) { DOMNode* deviceContextAttr = currentContext->getAttributes()->item(attr); if(wcscmp(deviceContextAttr->getNodeName(), L"deviceContext") == 0) { wstring deviceContextName = deviceContextAttr->getNodeValue(); CDeviceContext* deviceContext = configClass.GetDeviceContexts()[deviceContextName]; IDeviceCapture* device = configClass.GetDevices()[deviceContext->GetDeviceName()]; contextToAdd->AddDeviceContext(device, deviceContext); } } configClass.AddContext(contextName, contextToAdd); } return true; }
bool CConfigParser::ParseHIDDeviceCommands(DOMNodeList* commandNodeList, CWin32SpaceNavigatorHIDCapture* device) { if(commandNodeList == NULL) return true; for(unsigned long idx = 0; idx < commandNodeList->getLength(); idx++) { DOMNode* currentCommand = commandNodeList->item(idx); wstring commandNodeName = currentCommand->getNodeName(); if(commandNodeName.compare(L"command") != 0) continue; wstring commandName = currentCommand->getAttributes()->getNamedItem(L"name")->getNodeValue(); wstring commandReport = currentCommand->getAttributes()->getNamedItem(L"report")->getNodeValue(); wstring commandValue = currentCommand->getAttributes()->getNamedItem(L"value")->getNodeValue(); unsigned int report = NULL; unsigned int value = NULL; swscanf(commandReport.c_str(), L"0x%04X", &report); swscanf(commandValue.c_str(), L"0x%04X", &value); device->AddCommand(commandName, report, value); } return true; }
bool CConfigParser::ParseDeviceContexts(DOMNodeList* deviceContextNodes, ADeviceListener& configClass) { ASSERT(deviceContextNodes->getLength() == 1); DOMNode* deviceContextNode = deviceContextNodes->item(0); DOMNodeList* deviceContexts = deviceContextNode->getChildNodes(); for(unsigned long idx = 0; idx < deviceContexts->getLength(); idx++) { DOMNode* currentDeviceContext = deviceContexts->item(idx); wstring deviceContextNodeName = currentDeviceContext->getNodeName(); if(deviceContextNodeName.compare(L"#text") == 0) continue; if(deviceContextNodeName.compare(L"#comment") == 0) continue; wstring deviceContextName = currentDeviceContext->getAttributes()->getNamedItem(L"name")->getNodeValue(); wstring deviceName = currentDeviceContext->getAttributes()->getNamedItem(L"device")->getNodeValue(); bool gestures = false; if(currentDeviceContext->getAttributes()->getNamedItem(L"gestures") != NULL) gestures = true; // Create the device context to add CDeviceContext* deviceContextToAdd = NULL; if(configClass.GetDevices()[deviceName]->GetType().compare("mouse") == 0) deviceContextToAdd = new CMouseDeviceContext(gestures, deviceName); else deviceContextToAdd = new CDeviceContext(gestures, deviceName); // Get the device contexts axis and buttons added if(currentDeviceContext->hasChildNodes()) { unsigned char axeIdx = 0; DOMNodeList* children = currentDeviceContext->getChildNodes(); unsigned long childCount = children->getLength(); for(unsigned long idx = 0; idx < childCount; idx++) { DOMNode* childNode = children->item(idx); wstring nodeName = childNode->getNodeName(); if(nodeName.compare(L"axe") == 0) { ParseAxe(childNode, configClass.GetActions(), deviceContextToAdd, axeIdx); axeIdx++; } if(nodeName.compare(L"buttons") == 0) ParseButtons(childNode, configClass.GetActions(), deviceContextToAdd); if(nodeName.compare(L"gesture") == 0) ParseGesture(childNode, configClass.GetActions(), deviceContextToAdd); } } configClass.AddDeviceContext(deviceContextName, deviceContextToAdd); TRACE("Device Context <%S> is 0x%X\r\n", deviceContextName.c_str(), deviceContextToAdd); } return true; }
static MSPInstance extractMSPInstance(DOMDocument * domDocument, DOMTreeWalker * domTreeWalker) { MSPInstance mspInstance; map<string, ParameterGroup> parameterGroupMap; DOMNode * node = domTreeWalker->getCurrentNode(); DOMNamedNodeMap * nodeMap = node->getAttributes(); DOMNode * nameAttribute = nodeMap->getNamedItem(XMLString::transcode("name")); if (nameAttribute) { mspInstance.setName(XMLString::transcode(nameAttribute->getNodeValue())); } DOMNode * typeNameAttribute = nodeMap->getNamedItem(XMLString::transcode("typename")); if (typeNameAttribute) { //TFDEBUG(XMLString::transcode(typeNameAttribute->getNodeValue())); mspInstance.setTypeName(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; } else if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "Description") == 0) { XMLCh * textContent = XMLString::replicate(node->getTextContent()); XMLString::trim(textContent); mspInstance.setDescription(XMLString::transcode(textContent)); XMLString::release(&textContent); } node = domTreeWalker->nextNode(); } ParameterGroup parameterGroup; parameterGroup.setName("root"); parameterGroup.setParameterGroupMap(parameterGroupMap); mspInstance.setParameterGroup(parameterGroup); return mspInstance; }
static ParameterGroup extractParameterGroup(DOMDocument * domDocument, DOMTreeWalker * domTreeWalker) { map<string, string> parameterMap; map<string, ParameterGroup> parameterGroupMap; DOMNode * node = domTreeWalker->nextNode(); while (node) { if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "Parameter") == 0) { DOMNamedNodeMap * nodeMap = node->getAttributes(); string name; DOMNode * nameAttribute = nodeMap->getNamedItem(XMLString::transcode("name")); if (nameAttribute) { name = XMLString::transcode(nameAttribute->getNodeValue()); } string value; DOMNode * valueAttribute = nodeMap->getNamedItem(XMLString::transcode("value")); if (valueAttribute) { value = XMLString::transcode(valueAttribute->getNodeValue()); } parameterMap[name] = value; //TFINFO("Parameter: " << name << " -> " << value); } else 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.setParameterMap(parameterMap); parameterGroup.setParameterGroupMap(parameterGroupMap); return parameterGroup; }
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; }
static TUIObjectInstance extractTUIObjectInstance(DOMDocument * domDocument, DOMTreeWalker * domTreeWalker) { TUIObjectInstance tuiObjectInstance; DOMNode * node = domTreeWalker->getCurrentNode(); DOMNamedNodeMap * nodeMap = node->getAttributes(); DOMNode * nameAttribute = nodeMap->getNamedItem(XMLString::transcode("name")); if (nameAttribute) { tuiObjectInstance.setName(XMLString::transcode(nameAttribute->getNodeValue())); } DOMNode * tuiTypeNameAttribute = nodeMap->getNamedItem(XMLString::transcode("typename")); if (tuiTypeNameAttribute) { tuiObjectInstance.setTypeName(XMLString::transcode(tuiTypeNameAttribute->getNodeValue())); } while (node) { if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "Description") == 0) { XMLCh * textContent = XMLString::replicate(node->getTextContent()); XMLString::trim(textContent); tuiObjectInstance.setDescription(XMLString::transcode(textContent)); XMLString::release(&textContent); } node = domTreeWalker->nextNode(); } return tuiObjectInstance; }
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; }
/** * extract's the value of an attribute and returns it: * * <parentNode> * <elementNode attribute="returnstring" /> * </parentNode> * * the first parentNode found in the document is used. thus, it is expected to be unique. * * @param parentNode * @param elementNode * @param attribute * @return */ string InputHandler::getAttributeValue(const XMLCh* parentNode, const XMLCh* elementNode, const XMLCh* attribute) { crusde_debug("%s, line: %d, InputHandler::getAttributeValue(%s) ", __FILE__, __LINE__, XMLString::transcode(elementNode)); DOMElement *root = doc->getDocumentElement(); DOMNodeList *node_list = root->getElementsByTagName(parentNode); /*if element does not exist, return emptry string*/ if(node_list->getLength() == 0) return string(); DOMNode *child = node_list->item(0)->getFirstChild(); DOMNamedNodeMap *attributes = NULL; while (child) { if( child->getNodeType() == DOMNode::ELEMENT_NODE) { attributes = child->getAttributes(); if( XMLString::compareIString(child->getNodeName(), elementNode) == 0 ) { char *val = XMLString::transcode(attributes->getNamedItem(attribute)->getNodeValue()); string value(val); XMLString::release(&val); return value; } } child = child->getNextSibling(); } return string(); }
std::string DeltaApplyEngine::getDestinationURI(XID_DOMDocument *IncDeltaDoc) { DOMNode* deltaElement = DeltaApplyEngine::getDeltaElement(IncDeltaDoc); DOMNode* toItem = deltaElement->getAttributes()->getNamedItem(XMLString::transcode("to")); if (toItem==NULL) THROW_AWAY(("attribute 'to' not found")); return std::string(XyLatinStr(toItem->getNodeValue())); }
set<string>* EpiMCMCConfig::getParameterNames() { /** Returns a pointer to an STL set of parameter names. Throws a ConfigException if duplicate names are found in the DOM **/ XMLCh* buff; // Character buffer. Used to delete objects mainly. buff = XMLString::transcode("parameter"); DOMNodeList* parmList = doc->getElementsByTagName(buff); XMLString::release(&buff); set<string>* parmNames = new set<string>; pair<set<string>::iterator,bool> isInserted; for(size_t i = 0; i<parmList->getLength(); ++i) { DOMNode* parm = parmList->item(i); buff = XMLString::transcode("id"); DOMNode* idAttr = parm->getAttributes()->getNamedItem(buff); XMLString::release(&buff); char* id = XMLString::transcode(idAttr->getNodeValue()) ; isInserted = parmNames->insert(id); if(isInserted.second == false) { string msg("Duplicate string inserted: "); msg += id; XMLString::release(&id); throw ConfigException(msg.c_str()); } XMLString::release(&id); } return parmNames; }
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; }
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); } }
set<StringTable::countryCode> XMLIndata::parseCountryList(const DOMNode* cntrListTopNode){ set<StringTable::countryCode> countryList; mc2dbg << "Parsing country list" << endl; const XMLCh* name = cntrListTopNode->getNodeName(); if ( ! WFXMLStr::equals(name, "country_list") ){ mc2log << error << "Strange country list element name: " << name << endl; MC2_ASSERT(false); } const DOMNodeList* countryNodes = cntrListTopNode->getChildNodes(); for (XMLSize_t i=0; i<countryNodes->getLength(); i++){ DOMNode* countryNode = countryNodes->item(i); DOMNode::NodeType nodeType = static_cast<DOMNode::NodeType>(countryNode->getNodeType()); const XMLCh* name = countryNode->getNodeName(); if ( nodeType == DOMNode::ELEMENT_NODE ){ if ( WFXMLStr::equals(name,"country") ){ DOMNamedNodeMap* attributes = countryNode->getAttributes(); DOMNode* attribute = attributes->getNamedItem( X( "id_string" ) ); MC2_ASSERT( attribute != NULL ); MC2String gmsName = XMLString::transcode( attribute->getNodeValue() ); StringTable::countryCode countryCode = MapGenUtil::getCountryCodeFromGmsName( gmsName ); mc2dbg << " Country: " << gmsName << " " << countryCode << endl; if ( countryCode == StringTable::NBR_COUNTRY_CODES ){ mc2log << error << "Strange GMS name: " << gmsName << endl; MC2_ASSERT(false); } countryList.insert(countryCode); } else { mc2log << error << "Strange element name: " << name << endl; MC2_ASSERT(false); } } else if ( nodeType == DOMNode::COMMENT_NODE ){ // Don't bother with comments. } else { mc2log << error << "Strange node type: " << nodeType << endl; MC2_ASSERT(false); } } return countryList; } // parseCountryList
void OptionValueParser::parse_category(OptionCategory* category, DOMNode* node) { DOMNodeList* children = node->getChildNodes(); // Traverse the children for (size_t i = 0; i < children->getLength(); ++i) { DOMNode* item = children->item(i); if (item->getNodeType() != DOMNode::ELEMENT_NODE) continue; XMLUnicodeString node_name = item->getNodeName(); DOMNamedNodeMap* attributes = item->getAttributes(); XMLUnicodeString name = attributes->getNamedItem(XMLUnicodeString("name"))->getNodeValue(); if (node_name.str() == std::string("OptionCategory")) { // Parsing a category node parse_category(category->category(name.str().c_str()), item); } else { // Parsing an option node Option* option = category->option(name.str().c_str()); if (option && (node_name.str() == std::string("BooleanOption"))) { parse_boolean_option((BooleanOption*) option, item); } else if (option && (node_name.str() == std::string("StringOption"))) { parse_string_option((StringOption*) option, item); } else if (option && (node_name.str() == std::string("IntegerOption"))) { parse_integer_option((IntegerOption*) option, item); } else if (option && (node_name.str() == std::string("EnumOption"))) { parse_enum_option((EnumOption*) option, item); } /* else throw UnknownOptionKind(name.str()); */ } } }
XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *ParameterGrp::FindElement(XERCES_CPP_NAMESPACE_QUALIFIER DOMElement *Start, const char* Type, const char* Name) const { for (DOMNode *clChild = Start->getFirstChild(); clChild != 0; clChild = clChild->getNextSibling()) { if (clChild->getNodeType() == DOMNode::ELEMENT_NODE) { // the right node Type if (!strcmp(Type,StrX(clChild->getNodeName()).c_str())) { if (clChild->getAttributes()->getLength() > 0) { if (Name) { if (!strcmp(Name,StrX(clChild->getAttributes()->getNamedItem(XStr("Name").unicodeForm())->getNodeValue()).c_str())) return (DOMElement*)clChild; } else return (DOMElement*)clChild; } } } } return NULL; }
// initially set up the default attribute information based on doctype information void DOMElementImpl::setupDefaultAttributes() { DOMDocument *tmpdoc = getOwnerDocument(); if ((fNode.fOwnerNode == 0) || (tmpdoc == 0) || (tmpdoc->getDoctype() == 0)) return; DOMNode *eldef = ((DOMDocumentTypeImpl*)tmpdoc->getDoctype())->getElements()->getNamedItem(getNodeName()); DOMAttrMapImpl* defAttrs = (eldef == 0) ? 0 : (DOMAttrMapImpl *)(eldef->getAttributes()); if (defAttrs) fDefaultAttributes = new (getOwnerDocument()) DOMAttrMapImpl(this, defAttrs); }
const XMLCh* DOMNodeImpl::lookupNamespacePrefix(const XMLCh* const namespaceURI, bool useDefault, DOMElement *el) const { DOMNode *thisNode = castToNode(this); const XMLCh* ns = thisNode->getNamespaceURI(); // REVISIT: if no prefix is available is it null or empty string, or // could be both? const XMLCh* prefix = thisNode->getPrefix(); if (ns != 0 && XMLString::equals(ns,namespaceURI)) { if (useDefault || prefix != 0) { const XMLCh* foundNamespace = el->lookupNamespaceURI(prefix); if (foundNamespace != 0 && XMLString::equals(foundNamespace, namespaceURI)) { return prefix; } } } if (thisNode->hasAttributes()) { DOMNamedNodeMap *nodeMap = thisNode->getAttributes(); if(nodeMap != 0) { int length = nodeMap->getLength(); for (int i = 0;i < length;i++) { DOMNode *attr = nodeMap->item(i); const XMLCh* attrPrefix = attr->getPrefix(); const XMLCh* value = attr->getNodeValue(); ns = attr->getNamespaceURI(); if (ns != 0 && XMLString::equals(ns, XMLUni::fgXMLNSURIName)) { // DOM Level 2 nodes if ((useDefault && XMLString::equals(attr->getNodeName(), XMLUni::fgXMLNSString)) || (attrPrefix != 0 && XMLString::equals(attrPrefix, XMLUni::fgXMLNSString)) && XMLString::equals(value, namespaceURI)) { const XMLCh* localname= attr->getLocalName(); const XMLCh* foundNamespace = el->lookupNamespaceURI(localname); if (foundNamespace != 0 && XMLString::equals(foundNamespace, namespaceURI)) { return localname; } } } } } } DOMNode *ancestor = getElementAncestor(thisNode); if (ancestor != 0) { return castToNodeImpl(ancestor)->lookupNamespacePrefix(namespaceURI, useDefault, el); } return 0; }
bool CConfigParser::ParseButtons(DOMNode* node, TActionByNameMap actions, CDeviceContext* device) { if(node->hasChildNodes()) { DOMNodeList* buttonNodes = node->getChildNodes(); unsigned long length = buttonNodes->getLength(); for(unsigned long idx = 0; idx < length; idx++) { DOMNode* buttonNode = buttonNodes->item(idx); wstring nodeName = buttonNode->getNodeName(); if(buttonNode->hasAttributes()) { DOMNode* mouseSim = buttonNode->getAttributes()->getNamedItem(L"simulateMouseButton"); if(mouseSim != NULL) { wstring mouseSimBtn = mouseSim->getNodeValue(); if(mouseSimBtn.compare(L"left") == 0) device->AddButton(new CLeftMouseButtonAction()); if(mouseSimBtn.compare(L"right") == 0) device->AddButton(new CRightMouseButtonAction()); } else { wstring downAction = buttonNode->getAttributes()->getNamedItem(L"downAction")->getNodeValue(); wstring upAction = buttonNode->getAttributes()->getNamedItem(L"upAction")->getNodeValue(); device->AddButton(new CActionButton(actions[downAction], actions[upAction])); } } else if (nodeName.compare(L"button") == 0) { device->AddButton((IButton*)NULL); } } } return false; }
bool ConfigurationFileHandler::getSubAlgorithm(std::string algorithm, std::string subalgorithm, std::string* result){ #ifdef BRICS_XERCES_ENABLE if (errorsOccured) { return false; } DOMNode* current = NULL; DOMNode* attributeNode = NULL; XMLCh* algorithmName = XMLString::transcode(algorithm.c_str()); XMLCh* subAlgorithmName = XMLString::transcode(subalgorithm.c_str()); XMLCh* implementationString = XMLString::transcode("implementation"); bool subAlgorithmFound = false; DOMDocument* doc = parser->getDocument(); DOMNodeList* root = doc->getElementsByTagName(algorithmName); if (root->getLength() > 1) { LOG(WARNING) << "More than one " << algorithm << " found, taking the first one"; } else if(root->getLength() < 1) { LOG(WARNING) << "No algorithm called " << algorithm << " found."; return false; //TODO release resouces } current = root->item(0); //search in children notes for (current = current->getFirstChild()->getNextSibling(); current!=NULL; current = current->getNextSibling()) { string nodeName = XMLString::transcode(current->getNodeName()); if (nodeName.compare(subalgorithm) == 0) { DOMNamedNodeMap* attributesList = current->getAttributes(); attributeNode = attributesList->getNamedItem(implementationString); if (attributeNode != 0) { *result = XMLString::transcode(attributeNode->getNodeValue()); subAlgorithmFound = true; break; //take only first found } } } XMLString::release(&algorithmName); XMLString::release(&subAlgorithmName); XMLString::release(&implementationString); return subAlgorithmFound; #else return false; #endif }
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 DeltaApplyEngine::Attribute_Insert( XID_t nodeXID, const XMLCh* attr, const XMLCh* value ) { vddprintf((" insert attr at xid=%d\n",(int)nodeXID)); DOMNode* node = xiddoc->getXidMap().getNodeWithXID( nodeXID ); if (node==NULL) THROW_AWAY(("node with XID=%d not found",(int)nodeXID)); DOMAttr* attrNode = xiddoc->createAttribute( attr ); attrNode->setNodeValue( value ); DOMNamedNodeMap *attrs = node->getAttributes(); if (attrs == NULL) { if (node->getNodeType() != DOMNode::ELEMENT_NODE) { THROW_AWAY(("Attempted to insert an attribute on a non-element node. Perhaps xidmap was corrupted?")); } else { THROW_AWAY(("Unexpected error encountered: getAttributes() returned NULL for element")); } } else { attrs->setNamedItem( attrNode ); } }
static PortAddress extractPortAddress(DOMDocument * domDocument, DOMTreeWalker * domTreeWalker) { PortAddress portAddress; DOMNode * node = domTreeWalker->getCurrentNode(); DOMNamedNodeMap * nodeMap = node->getAttributes(); // entityType = DEV | TUI | MSP DOMNode * entityTypeAttribute = nodeMap->getNamedItem(XMLString::transcode("entityType")); if (entityTypeAttribute) { if (XMLString::compareString(XMLString::transcode(entityTypeAttribute->getNodeValue()), "DEV") == 0) { //TFINFO("DEV"); portAddress.setOwnerType(PortAddress::DEVICE); } else if (XMLString::compareString(XMLString::transcode(entityTypeAttribute->getNodeValue()), "TUI") == 0) { //TFINFO("TUI"); portAddress.setOwnerType(PortAddress::TUIOBJECT); } else if (XMLString::compareString(XMLString::transcode(entityTypeAttribute->getNodeValue()), "MSP") == 0) { //TFINFO("MSP"); portAddress.setOwnerType(PortAddress::MSP); } else { // TODO throw Exception TFERROR(""); } } else { TFERROR("No entityType found") } DOMNode * entityNameAttribute = nodeMap->getNamedItem(XMLString::transcode("entityName")); if (entityNameAttribute) { portAddress.setName(XMLString::transcode(entityNameAttribute->getNodeValue())); } else { TFERROR("No entityName found") } DOMNode * portNameAttribute = nodeMap->getNamedItem(XMLString::transcode("portName")); if (portNameAttribute) { portAddress.setPortName(XMLString::transcode(portNameAttribute->getNodeValue())); } else { TFERROR("No portName found") } return portAddress; }
static void removeBaseAttr(DOMDocument * domDocument) { XMLNodeFilter * nodeFilter = new XMLNodeFilter(); DOMTreeWalker * domTreeWalker = domDocument->createTreeWalker(domDocument, DOMNodeFilter::SHOW_ALL, nodeFilter, true); DOMNode * node = domTreeWalker->getCurrentNode(); while (node) { DOMNamedNodeMap * nodeMap = node->getAttributes(); if (nodeMap != 0) { DOMNode * attr = nodeMap->getNamedItem(XMLString::transcode("xml:base")); if (attr) { DOMNode * node = nodeMap->removeNamedItem(XMLString::transcode("xml:base")); TFINFO("[Server Config] filtered attribute: " << XMLString::transcode(node->getNodeName()) << "=" << XMLString::transcode(node->getNodeValue())); node->release(); } } node = domTreeWalker->nextNode(); } delete nodeFilter; }
bool ConfigurationFileHandler::getAttribute(std::string algorithm, std::string attribute, int* result) { #ifdef BRICS_XERCES_ENABLE if (errorsOccured) { return false; } DOMNode* current = NULL; DOMNode* attributeNode = NULL; XMLCh* algorithmName = XMLString::transcode(algorithm.c_str()); XMLCh* attributeName = XMLString::transcode(attribute.c_str()); string tmpResult; bool attributeFound = false; DOMDocument* doc = parser->getDocument(); DOMNodeList* root = doc->getElementsByTagName(algorithmName); if (root->getLength() > 1) { LOG(WARNING) << "More than one " << algorithm << " found, taking the first one"; } else if(root->getLength() < 1) { LOG(WARNING) << "No algorithm called " << algorithm << " found."; return false; //TODO release resouces } current = root->item(0); DOMNamedNodeMap* attributesList = current->getAttributes(); attributeNode = attributesList->getNamedItem(attributeName); if (attributeNode != 0) { tmpResult = XMLString::transcode(attributeNode->getNodeValue()); *result = atoi(tmpResult.c_str()); attributeFound = true; } XMLString::release(&algorithmName); XMLString::release(&attributeName); return attributeFound; #else return false; #endif }
string InputHandler::getAttributeValueByName(const XMLCh* elementNode, const XMLCh* attribute, const XMLCh* name) { crusde_debug("%s, line: %d, InputHandler::getAttributeValueByName(%s) name = %s ", __FILE__, __LINE__, XMLString::transcode(elementNode), XMLString::transcode(name)); assert(doc); DOMElement *root = doc->getDocumentElement(); DOMNode *child = root->getFirstChild(); DOMNamedNodeMap *attributes = NULL; while (child) { if(child != NULL) if( child->getNodeType() == DOMNode::ELEMENT_NODE ) { if(child->hasAttributes()) { attributes = child->getAttributes(); if( XMLString::compareIString( child->getNodeName(), elementNode) == 0 && XMLString::compareIString( attributes->getNamedItem(ATTR_name.xmlStr())->getNodeValue(), name) == 0 ) { char *val = XMLString::transcode(attributes->getNamedItem(attribute)->getNodeValue()); string value(val); XMLString::release(&val); return value; } } } child = child->getNextSibling(); } return string(); }
const XMLCh* DOMNodeImpl::lookupNamespaceURI(const XMLCh* specifiedPrefix) const { DOMNode *thisNode = castToNode(this); short type = thisNode->getNodeType(); switch (type) { case DOMNode::ELEMENT_NODE : { const XMLCh* ns = thisNode->getNamespaceURI(); const XMLCh* prefix = thisNode->getPrefix(); if (ns != 0) { // REVISIT: is it possible that prefix is empty string? if (specifiedPrefix == 0 && prefix == specifiedPrefix) { // looking for default namespace return ns; } else if (prefix != 0 && XMLString::equals(prefix, specifiedPrefix)) { // non default namespace return ns; } } if (thisNode->hasAttributes()) { DOMNamedNodeMap *nodeMap = thisNode->getAttributes(); if(nodeMap != 0) { int length = nodeMap->getLength(); for (int i = 0;i < length;i++) { DOMNode *attr = nodeMap->item(i); const XMLCh *attrPrefix = attr->getPrefix(); const XMLCh *value = attr->getNodeValue(); ns = attr->getNamespaceURI(); if (ns != 0 && XMLString::equals(ns, XMLUni::fgXMLNSURIName)) { // at this point we are dealing with DOM Level 2 nodes only if (specifiedPrefix == 0 && XMLString::equals(attr->getNodeName(), XMLUni::fgXMLNSString)) { // default namespace return value; } else if (attrPrefix != 0 && XMLString::equals(attrPrefix, XMLUni::fgXMLNSString) && XMLString::equals(attr->getLocalName(), specifiedPrefix)) { // non default namespace return value; } } } } } DOMNode *ancestor = getElementAncestor(thisNode); if (ancestor != 0) { return ancestor->lookupNamespaceURI(specifiedPrefix); } return 0; } case DOMNode::DOCUMENT_NODE : { return((DOMDocument*)thisNode)->getDocumentElement()->lookupNamespaceURI(specifiedPrefix); } case DOMNode::ENTITY_NODE : case DOMNode::NOTATION_NODE: case DOMNode::DOCUMENT_FRAGMENT_NODE: case DOMNode::DOCUMENT_TYPE_NODE: // type is unknown return 0; case DOMNode::ATTRIBUTE_NODE:{ if (fOwnerNode->getNodeType() == DOMNode::ELEMENT_NODE) { return fOwnerNode->lookupNamespaceURI(specifiedPrefix); } return 0; } default:{ DOMNode *ancestor = getElementAncestor(castToNode(this)); if (ancestor != 0) { return ancestor->lookupNamespaceURI(specifiedPrefix); } return 0; } } }
// --------------------------------------------------------------------------- // This method assumes that currentNode is an xinclude element and parses // it accordingly, acting on what it finds. // --------------------------------------------------------------------------- bool XIncludeUtils::doDOMNodeXInclude(DOMNode *xincludeNode, DOMDocument *parsedDocument, XMLEntityHandler* entityResolver){ bool modifiedNode = false; /* the relevant attributes to look for */ const XMLCh *href = NULL; const XMLCh *parse = NULL; const XMLCh *xpointer = NULL; const XMLCh *encoding = NULL; const XMLCh *accept = NULL; const XMLCh *acceptlanguage = NULL; DOMNode *includeParent = xincludeNode->getParentNode(); if(xincludeNode->hasAttributes()) { /* get all the attributes of the node */ DOMNamedNodeMap *pAttributes = xincludeNode->getAttributes(); XMLSize_t nSize = pAttributes->getLength(); for(XMLSize_t i=0;i<nSize;++i) { DOMAttr *pAttributeNode = (DOMAttr*) pAttributes->item(i); const XMLCh *attrName = pAttributeNode->getName(); /* check each attribute against the potential useful names */ if (XMLString::equals(attrName, XIncludeUtils::fgXIIncludeHREFAttrName)){ href = pAttributeNode->getValue(); } else if (XMLString::equals(attrName, XIncludeUtils::fgXIIncludeParseAttrName)){ parse = pAttributeNode->getValue(); } else if (XMLString::equals(attrName, XIncludeUtils::fgXIIncludeXPointerAttrName)){ xpointer = pAttributeNode->getValue(); } else if (XMLString::equals(attrName, XIncludeUtils::fgXIIncludeEncodingAttrName)){ encoding = pAttributeNode->getValue(); } else if (XMLString::equals(attrName, XIncludeUtils::fgXIIncludeAcceptAttrName)){ accept = pAttributeNode->getValue(); } else if (XMLString::equals(attrName, XIncludeUtils::fgXIIncludeAcceptLanguageAttrName)){ acceptlanguage = pAttributeNode->getValue(); } else { /* if any other attribute is in the xi namespace, it's an error */ const XMLCh *attrNamespaceURI = pAttributeNode->getNamespaceURI(); if (attrNamespaceURI && XMLString::equals(attrNamespaceURI, XIncludeUtils::fgXIIIncludeNamespaceURI)){ } else { /* ignore - any other attribute is allowed according to spec, and must be ignored */ } } } } // 3.1 xi:include Element // The children property of the xi:include element may include a single xi:fallback element; // the appearance of more than one xi:fallback element, an xi:include element, // or any other element from the XInclude namespace is a fatal error. DOMNode *child; DOMElement *fallback = NULL; for (child = xincludeNode->getFirstChild(); child != 0; child=child->getNextSibling()){ if(child->getNodeType()!=DOMNode::ELEMENT_NODE) continue; if ( isXIFallbackDOMNode(child) ){ if (fallback != NULL){ /* fatal error - there are more than one fallback children */ XIncludeUtils::reportError(xincludeNode, XMLErrs::XIncludeMultipleFallbackElems, parsedDocument->getDocumentURI(), parsedDocument->getDocumentURI()); return false; } fallback = (DOMElement*)child; } else if(isXIIncludeDOMNode(child) || XMLString::equals(child->getNamespaceURI(), XIncludeUtils::fgXIIIncludeNamespaceURI)) { /* fatal error - an xi element different from xi:fallback is a child of xi:include */ XIncludeUtils::reportError(xincludeNode, XMLErrs::XIncludeDisallowedChild, child->getNodeName(), parsedDocument->getDocumentURI()); return false; } } if (href == NULL){ /* this is an unrecoverable error until we have xpointer support - if there is an xpointer, the current document is assumed however, there is no xpointer support yet */ XIncludeUtils::reportError(xincludeNode, XMLErrs::XIncludeNoHref, NULL, parsedDocument->getDocumentURI()); return false; } /* set up the accept and accept-language values */ if (accept != NULL){ } if (parse == NULL){ /* use the default, as specified */ parse = XIncludeUtils::fgXIIncludeParseAttrXMLValue; } if (xpointer != NULL){ /* not supported yet */ /* Note that finding an xpointer attr along with parse="text" is a Fatal Error * - http://www.w3.org/TR/xinclude/#include-location */ XIncludeUtils::reportError(xincludeNode, XMLErrs::XIncludeXPointerNotSupported, NULL, href); return false; } /* set up the href according to what has gone before */ XIncludeLocation hrefLoc(href); XIncludeLocation relativeLocation(href); const XMLCh *includeBase = xincludeNode->getBaseURI(); if (includeBase != NULL){ hrefLoc.prependPath(includeBase); } if (getBaseAttrValue(xincludeNode) != NULL){ relativeLocation.prependPath(getBaseAttrValue(xincludeNode)); } /* Take the relevant action - we need to retrieve the target as a whole before we can know if it was successful or not, therefore the do* methods do not modify the parsedDocument. Swapping the results in is left to the caller (i.e. here) */ DOMText *includedText = NULL; DOMDocument *includedDoc = NULL; if (XMLString::equals(parse, XIncludeUtils::fgXIIncludeParseAttrXMLValue)){ /* including a XML element */ includedDoc = doXIncludeXMLFileDOM(hrefLoc.getLocation(), relativeLocation.getLocation(), xincludeNode, parsedDocument, entityResolver); } else if (XMLString::equals(parse, XIncludeUtils::fgXIIncludeParseAttrTextValue)){ /* including a text value */ includedText = doXIncludeTEXTFileDOM(hrefLoc.getLocation(), relativeLocation.getLocation(), encoding, xincludeNode, parsedDocument, entityResolver); } else { /* invalid parse attribute value - fatal error according to the specification */ XIncludeUtils::reportError(xincludeNode, XMLErrs::XIncludeInvalidParseVal, parse, parsedDocument->getDocumentURI()); return false; } RefVectorOf<DOMNode> delayedProcessing(12,false); if (includedDoc == NULL && includedText == NULL){ /* there was an error - this is now a resource error let's see if there is a fallback */ XIncludeUtils::reportError(xincludeNode, XMLErrs::XIncludeIncludeFailedResourceError, hrefLoc.getLocation(), parsedDocument->getDocumentURI()); if (includeParent == NULL){ includeParent = parsedDocument; } // we could be getting errors trying to insert elements at the root of the document, so we should use replaceChild; // in order to handle multiple nodes, add them to a document fragment and use that to replace the original node if (fallback){ /* baseURI fixups - see http://www.w3.org/TR/xinclude/#base for details. */ XMLUri parentURI(includeParent->getBaseURI()); XMLUri includedURI(fallback->getBaseURI()); if (fallback->hasChildNodes()){ DOMDocumentFragment* frag = parsedDocument->createDocumentFragment(); DOMNode *child = fallback->getFirstChild(); /* add the content of the fallback element, and remove the fallback elem itself */ for ( ; child != NULL ; child=child->getNextSibling()){ if (child->getNodeType() == DOMNode::DOCUMENT_TYPE_NODE){ continue; } DOMNode *newNode = parsedDocument->importNode(child, true); /* if the paths differ we need to add a base attribute */ if (newNode->getNodeType()==DOMNode::ELEMENT_NODE && !XMLString::equals(parentURI.getPath(), includedURI.getPath())){ if (getBaseAttrValue(newNode) == NULL){ /* need to calculate the proper path difference to get the relativePath */ ((DOMElement*)newNode)->setAttribute(fgXIBaseAttrName, getBaseAttrValue(fallback->getParentNode())); } else { /* the included node has base of its own which takes precedence */ XIncludeLocation xil(getBaseAttrValue(newNode)); if (getBaseAttrValue(fallback->getParentNode()) != NULL){ /* prepend any specific base modification of the xinclude node */ xil.prependPath(getBaseAttrValue(fallback->getParentNode())); } ((DOMElement*)newNode)->setAttribute(fgXIBaseAttrName, xil.getLocation()); } } DOMNode *newChild = frag->appendChild(newNode); // don't process the node now, wait until it is placed in the final position delayedProcessing.addElement(newChild); //parseDOMNodeDoingXInclude(newChild, parsedDocument, entityResolver); } includeParent->replaceChild(frag, xincludeNode); frag->release(); for(XMLSize_t i=0;i<delayedProcessing.size();i++) { DOMNode* childNode=delayedProcessing.elementAt(i); parseDOMNodeDoingXInclude(childNode, parsedDocument, entityResolver); } modifiedNode = true; } else { /* empty fallback element - simply remove it! */ includeParent->removeChild(xincludeNode); modifiedNode = true; } } else { XIncludeUtils::reportError(xincludeNode, XMLErrs::XIncludeIncludeFailedNoFallback, parsedDocument->getDocumentURI(), parsedDocument->getDocumentURI()); return false; } } else { if (includedDoc){ /* record the successful include while we process the children */ addDocumentURIToCurrentInclusionHistoryStack(hrefLoc.getLocation()); DOMDocumentFragment* frag = parsedDocument->createDocumentFragment(); /* need to import the document prolog here */ DOMNode *child = includedDoc->getFirstChild(); for (; child != NULL; child = child->getNextSibling()) { if (child->getNodeType() == DOMNode::DOCUMENT_TYPE_NODE) continue; // check for NOTATION or ENTITY clash if(child->getNodeType()==DOMNode::ELEMENT_NODE && includedDoc->getDoctype()!=NULL) { DOMNamedNodeMap *pAttributes = child->getAttributes(); XMLSize_t nSize = pAttributes->getLength(); for(XMLSize_t i=0;i<nSize;++i) { DOMAttr *pAttributeNode = (DOMAttr*) pAttributes->item(i); const DOMTypeInfo * typeInfo=pAttributeNode->getSchemaTypeInfo(); if(typeInfo && XMLString::equals(typeInfo->getTypeNamespace(), XMLUni::fgInfosetURIName)) { if(XMLString::equals(typeInfo->getTypeName(), XMLUni::fgNotationString)) { const XMLCh* notationName=pAttributeNode->getNodeValue(); DOMNotation* notat=(DOMNotation*)includedDoc->getDoctype()->getNotations()->getNamedItem(notationName); // ensure we have a DTD if(parsedDocument->getDoctype()==NULL) parsedDocument->insertBefore(parsedDocument->createDocumentType(parsedDocument->getDocumentElement()->getNodeName(), NULL,NULL), parsedDocument->getFirstChild()); DOMNotation* myNotation=(DOMNotation*)parsedDocument->getDoctype()->getNotations()->getNamedItem(notationName); if(myNotation==NULL) { // it's missing, add it parsedDocument->getDoctype()->getNotations()->setNamedItem(parsedDocument->importNode(notat, true)); } else if(XMLString::equals(myNotation->getPublicId(), notat->getPublicId()) && XMLString::equals(myNotation->getSystemId(), notat->getSystemId()) && XMLString::equals(myNotation->getBaseURI(), notat->getBaseURI())) { // it's duplicate, ignore it } else { // it's a conflict, report it XIncludeUtils::reportError(xincludeNode, XMLErrs::XIncludeConflictingNotation, notationName, parsedDocument->getDocumentURI()); } } else if(XMLString::equals(typeInfo->getTypeName(), XMLUni::fgEntityString)) { const XMLCh* entityName=pAttributeNode->getNodeValue(); DOMEntity* ent=(DOMEntity*)includedDoc->getDoctype()->getEntities()->getNamedItem(entityName); // ensure we have a DTD if(parsedDocument->getDoctype()==NULL) parsedDocument->insertBefore(parsedDocument->createDocumentType(parsedDocument->getDocumentElement()->getNodeName(), NULL,NULL), parsedDocument->getFirstChild()); DOMEntity* myEnt=(DOMEntity*)parsedDocument->getDoctype()->getEntities()->getNamedItem(entityName); if(myEnt==NULL) { // it's missing, add it parsedDocument->getDoctype()->getEntities()->setNamedItem(parsedDocument->importNode(ent, true)); } else if(XMLString::equals(myEnt->getPublicId(), ent->getPublicId()) && XMLString::equals(myEnt->getSystemId(), ent->getSystemId()) && XMLString::equals(myEnt->getBaseURI(), ent->getBaseURI())) { // it's duplicate, ignore it } else { // it's a conflict, report it XIncludeUtils::reportError(xincludeNode, XMLErrs::XIncludeConflictingEntity, entityName, parsedDocument->getDocumentURI()); } } } } } DOMNode *newNode = parsedDocument->importNode(child, true); DOMNode *newChild = frag->appendChild(newNode); // don't process the node now, wait until it is placed in the final position delayedProcessing.addElement(newChild); //parseDOMNodeDoingXInclude(newChild, parsedDocument, entityResolver); } includeParent->replaceChild(frag, xincludeNode); frag->release(); for(XMLSize_t i=0;i<delayedProcessing.size();i++) { DOMNode* childNode=delayedProcessing.elementAt(i); parseDOMNodeDoingXInclude(childNode, parsedDocument, entityResolver); } popFromCurrentInclusionHistoryStack(NULL); modifiedNode = true; } else if (includedText){ includeParent->replaceChild(includedText, xincludeNode); modifiedNode = true; } } if (includedDoc) includedDoc->release(); return modifiedNode; }