static ServerConfig extractServerConfig(DOMDocument * domDocument, DOMTreeWalker * domTreeWalker) { ServerConfig serverConfig; DOMNode * node = domTreeWalker->getCurrentNode(); while (node) { if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "ServerStartupConfig") == 0) { XMLNodeFilter * nodeFilter = new XMLNodeFilter(); DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true); serverConfig.setServerStartupConfig(extractServerStartupConfig(domDocument, d)); d->release(); delete nodeFilter; } else if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "DeviceTypeSequence") == 0) { XMLNodeFilter * nodeFilter = new XMLNodeFilter(); DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true); serverConfig.setDeviceTypeMap(extractDeviceTypeMap(domDocument, d)); d->release(); delete nodeFilter; } else if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "DeviceInstanceSequence") == 0) { XMLNodeFilter * nodeFilter = new XMLNodeFilter(); DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true); serverConfig.setDeviceInstanceMap(extractDeviceInstanceMap(domDocument, d)); d->release(); delete nodeFilter; } else if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "TUIObjectTypeSequence") == 0) { XMLNodeFilter * nodeFilter = new XMLNodeFilter(); DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true); serverConfig.setTUIObjectTypeMap(extractTUIObjectTypeMap(domDocument, d)); d->release(); delete nodeFilter; } else if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "TUIObjectInstanceSequence") == 0) { XMLNodeFilter * nodeFilter = new XMLNodeFilter(); DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true); serverConfig.setTUIObjectInstanceMap(extractTUIObjectInstanceMap(domDocument, d)); d->release(); delete nodeFilter; } else if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "ConnectorSequence") == 0) { XMLNodeFilter * nodeFilter = new XMLNodeFilter(); DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true); serverConfig.setConnectorVector(extractConnectorVector(domDocument, d)); d->release(); delete nodeFilter; } else if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "MSPTypeSequence") == 0) { XMLNodeFilter * nodeFilter = new XMLNodeFilter(); DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true); //serverConfig.setMSPTypeMap(extractMSPTypeMap(domDocument, d)); d->release(); delete nodeFilter; } else if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "MSPInstanceSequence") == 0) { XMLNodeFilter * nodeFilter = new XMLNodeFilter(); DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true); serverConfig.setMSPInstanceMap(extractMSPInstanceMap(domDocument, d)); d->release(); delete nodeFilter; } node = domTreeWalker->nextNode(); } return serverConfig; }
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::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; }
void JointsElement::ReadNode(const DOMNode* node) { _ASSERTE(node != NULL); ReadAttributes( node ); DOMNode* currentNode = node->getFirstChild(); while( currentNode != NULL ) { #if _DEBUG // デバッグ時に名前をチェックする為に const XMLCh* name = currentNode->getNodeName(); #endif if( IsElementNode( currentNode ) ) { if( Is_input_NodeName( currentNode ) ) { InputElement* elemInput = new InputElement(); elemInput->ReadNode( currentNode ); vecElemInput.push_back( elemInput ); } } currentNode = currentNode->getNextSibling(); // 次の要素を処理する } }
std::string CSDReader::descriptor (DOMElement* element) throw(CSDReadException) { std::string element_name; DOMNode* child = element->getFirstChild(); while (child != 0) { if (child->getNodeType() == DOMNode::ELEMENT_NODE) { element_name = Qedo::transcode(child->getNodeName()); // // link // if (element_name == "link") { return link((DOMElement*)child).file; } // // fileinarchive // else if (element_name == "fileinarchive") { return fileinarchive((DOMElement*)child).file; } } // get next child child = child->getNextSibling(); } throw CSDReadException(); }
bool DataElementImp::fromXml(DOMNode* pDocument, unsigned int version) { if (pDocument == NULL) { return false; } for (DOMNode* pChild = pDocument->getFirstChild(); pChild != NULL; pChild = pChild->getNextSibling()) { if (XMLString::equals(pChild->getNodeName(), X("DataDescriptor"))) { if (mpDataDescriptor == NULL) { throw XmlReader::DomParseException("Cannot access the data descriptor", pDocument); } if (mpDataDescriptor->fromXml(pChild, version) == false) { throw XmlReader::DomParseException("Cannot deserialize data descriptor", pDocument); } } } return true; }
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 browseTree(DOMNode* root) { static int indent = 1; indent++; DOMNodeList* list = root->getChildNodes(); for( int i = 0; i < list->getLength(); i++ ) { DOMNode* node = list->item(i); DOMString name = node->getLocalName(); if( name.isNull() ) { name = node->getNodeName(); } if( name.isNull() ) { continue; } if ( name.equals("#text") ) continue; printDash(indent); cout<<name<<endl; browseTree(node); } indent--; }
void DTMReader::readDatatype(std::string descriptor) throw(DTMReadException) { DOMXMLParser parser; if ( parser.parse( ((char*)descriptor.c_str()) ) != 0 ) { std::cerr << "Error during XML parsing" << std::endl; throw DTMReadException(); } dtm_document_ = parser.getDocument(); DOMNode* child = dtm_document_->getDocumentElement()->getFirstChild(); while (child != 0) { if (child->getNodeType() == DOMNode::ELEMENT_NODE) // handle type_mapping if ( !XMLString::compareString(child->getNodeName(), X("type-mapping")) ) type_mapping((DOMElement*)child); // get next child child = child->getNextSibling(); } }
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; }
void DOMtoXMLElement(DOMNode* dom, XMLElement& xml) { xml.setName(StrX(dom->getNodeName())); unsigned int i; string text; DOMNodeList* children = dom->getChildNodes(); for (i=0;children && i<children->getLength();i++) { DOMNode* child = children->item(i); switch (child->getNodeType()) { case DOMNode::TEXT_NODE: text+=StrX(child->getNodeValue()); break; case DOMNode::ELEMENT_NODE: { XMLElement childElement; DOMtoXMLElement(child, childElement); xml.addChild(childElement); } break; default: continue; } } xml.setText(text); DOMNamedNodeMap* attrs = dom->getAttributes(); if (attrs == 0) return; for (i=0;i<attrs->getLength();i++) { DOMNode* attr = attrs->item(i); xml.setAttribute(StrX(attr->getNodeName()), StrX(attr->getNodeValue())); } }
void Aluno::buildFromXml (DOMNode *node) { DOMElement *element = dynamic_cast<DOMElement*>(node); //recuperar dados do xml XMLCh* tag_cpf = XMLString::transcode("cpf"); //strings do xml usam o tipo XMLCh XMLCh* tag_nome = XMLString::transcode("nome"); XMLCh* tag_universidade = XMLString::transcode("universidade"); XMLCh* tag_curso = XMLString::transcode("curso"); //armazenar dados no objeto 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_cpf)) { this->cpf = XMLString::transcode(n->getTextContent()); } else if (XMLString::equals(tag, tag_nome)) { this->nome = XMLString::transcode(n->getTextContent()); } else if (XMLString::equals(tag, tag_universidade)) { this->universidade = XMLString::transcode(n->getTextContent()); } else if (XMLString::equals(tag, tag_curso)) { this->curso = XMLString::transcode(n->getTextContent()); } } //strings xml precisam passar por um release apos uso XMLString::release(&tag_cpf); XMLString::release(&tag_nome); XMLString::release(&tag_universidade); XMLString::release(&tag_curso); }
DOMElement* XmlHelper::getChildNamed(DOMElement* parent, const char* const name) { if( parent == NULL ) Throw( NullPointerException, "parent darf nicht NULL sein" ); DOMNodeList* nodes = parent->getChildNodes(); XMLCh* nameXml = XMLString::transcode(name); DOMElement* rval = 0; for (unsigned int idx = 0; idx < nodes->getLength(); idx++) { DOMNode* item = nodes->item(idx); if (item->getNodeType() == DOMNode::ELEMENT_NODE && XMLString::compareString(item->getNodeName(), nameXml)==0 ) { rval = reinterpret_cast<DOMElement*>(item); break; } } XMLString::release(&nameXml); return rval; }
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 PointSetImp::fromXml(DOMNode* pDocument, unsigned int version) { if (pDocument == NULL || !PlotObjectImp::fromXml(pDocument, version)) { return false; } DOMElement* pElem = static_cast<DOMElement*>(pDocument); mSymbols = StringUtilities::fromXmlString<bool>(A(pElem->getAttribute(X("symbols")))); mLine = StringUtilities::fromXmlString<bool>(A(pElem->getAttribute(X("line")))); ColorType color = StringUtilities::fromXmlString<ColorType>(A(pElem->getAttribute(X("lineColor")))); mLineColor = COLORTYPE_TO_QCOLOR(color); mLineWidth = StringUtilities::fromXmlString<int>(A(pElem->getAttribute(X("lineWidth")))); mLineStyle = StringUtilities::fromXmlString<LineStyle>(A(pElem->getAttribute(X("lineStyle")))); for (DOMNode* pChld = pElem->getFirstChild(); pChld != NULL; pChld = pChld->getNextSibling()) { if (XMLString::equals(pChld->getNodeName(), X("Point"))) { PointImp* pPoint = dynamic_cast<PointImp*>(addPoint()); if (pPoint == NULL || !pPoint->fromXml(pChld, version)) { return false; } } } return true; }
/** * 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(); }
void DTMReader::readConnection(std::string descriptor, CosPersistentState::ParameterList& params) throw(DTMReadException) { DOMXMLParser parser; if ( parser.parse( ((char*)descriptor.c_str()) ) != 0 ) { std::cerr << "Error during XML parsing" << std::endl; throw DTMReadException(); } dtm_document_ = parser.getDocument(); DOMNode* child = dtm_document_->getDocumentElement()->getFirstChild(); while (child != 0) { if (child->getNodeType() == DOMNode::ELEMENT_NODE) // handle connection if ( !XMLString::compareString(child->getNodeName(), X("connection")) ) connection((DOMElement*)child); // get next child child = child->getNextSibling(); } params.length(vName_.size()); for(unsigned int i=0; i<vName_.size(); i++) { params[i].name = vName_[i].c_str(); params[i].val <<= vValue_[i].c_str(); } }
void OpticsElement::ReadNode(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_program_NodeName( currentNode ) ) { ProgramElement* elemProgram = new ProgramElement(); elemProgram->ReadNode( currentNode ); vecElemProgram.push_back( elemProgram ); } } currentNode = currentNode->getNextSibling(); // 次の要素を処理する } }
void DTMReader::connection (DOMElement* element) throw(DTMReadException) { std::string strTemp; DOMElement* child_element; DOMNode* child = element->getFirstChild(); while (child != 0) { if (child->getNodeType() == DOMNode::ELEMENT_NODE) { child_element = (DOMElement*)child; if ( !XMLString::compareString(child->getNodeName(), X("param")) ) { strTemp = XMLString::transcode(child_element->getAttribute(X("name"))); vName_.push_back(strTemp); strTemp = XMLString::transcode(child_element->getAttribute(X("value"))); vValue_.push_back(strTemp); } } // get next child child = child->getNextSibling(); } }
void CCDReader4qxml::softpkg (DOMElement* element) throw(CCDReadException) { if ( !package_ ) abort(); std::string element_name; DOMNode* child = element->getFirstChild(); while (child != 0) { if (child->getNodeType() == DOMNode::ELEMENT_NODE) { element_name = Qedo::transcode(child->getNodeName()); // // componentfeatures // if (element_name == "componentfeatures") { componentfeatures((DOMElement*)child); } } // get next child child = child->getNextSibling(); } }
int CApp::loadXercesDataFamille( dlgAmonSoft &amon ) { try { XERCES_CPP_NAMESPACE::DOMDocument *pDoc = g_ParserFamille->getDocument(); XERCES_CPP_NAMESPACE::DOMElement *pElem = pDoc->getDocumentElement(); CheckDataFileVersion( pElem, amon ); DOMNodeList *pNodeList = pElem->getChildNodes (); uint size = pNodeList->getLength(); for( uint i = 0; i < size; i++ ) { DOMNode *pNode = pNodeList->item( i ); if( XMLString::equals( XMLString::transcode( pNode->getNodeName() ), "Famille" ) ) { Datas::CFamille *pFamille = new Datas::CFamille( 0 ); DOMElement *elmt = static_cast< DOMElement* >( pNode ); mAssert( elmt != 0, "elmt != 0" ); // loadFromXML has to link with correct CPersonne, this means // that all CPersonne *must* be loaded before ! int iRet = pFamille->loadFromXML( elmt ); if( iRet == -1 ) delete pFamille; } } } catch( DOMException &e ) { qDebug( XMLString::transcode( e.getMessage() ) ); } return 0; }
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; }
int DOMAttrMapImpl::findNamePoint(const XMLCh *namespaceURI, const XMLCh *localName) const { if (fNodes == 0) return -1; // This is a linear search through the same fNodes Vector. // The Vector is sorted on the DOM Level 1 nodename. // The DOM Level 2 NS keys are namespaceURI and Localname, // so we must linear search thru it. // In addition, to get this to work with fNodes without any namespace // (namespaceURI and localNames are both 0) we then use the nodeName // as a secondary key. int i, len = fNodes -> size(); for (i = 0; i < len; ++i) { DOMNode *node = fNodes -> elementAt(i); const XMLCh * nNamespaceURI = node->getNamespaceURI(); const XMLCh * nLocalName = node->getLocalName(); if (!XMLString::equals(nNamespaceURI, namespaceURI)) //URI not match continue; else { if (XMLString::equals(localName, nLocalName) || (nLocalName == 0 && XMLString::equals(localName, node->getNodeName()))) return i; } } return -1; //not found }
EppCredsOptions * EppCredsOptions::fromXML( const DOMNode& root ) { DOMString version; DOMString lang; DOMNodeList* list = root.getChildNodes(); for( unsigned int i = 0; i < list->getLength(); i++ ) { DOMNode* node = list->item(i); DOMString name = node->getLocalName(); if( name.isNull() ) { name = node->getNodeName(); } if( name.isNull() ) { continue; } if( name.equals("version") ) { version = EppUtil::getText(*node); } else if( name.equals("lang") ) { lang = EppUtil::getText(*node); } } if( (version.isNotNull()) && (lang.isNotNull()) ) { return new EppCredsOptions(version, lang); } return null; }
void GeometryElement::ReadNode(const DOMNode* node) { _ASSERTE(node != NULL); ReadAttributes( node ); DOMNode* currentNode = node->getFirstChild(); while( currentNode != NULL ) { #if _DEBUG // デバッグ時に名前をチェックする為に const XMLCh* name = currentNode->getNodeName(); #endif if( IsElementNode( currentNode ) ) { if( Is_mesh_NodeName( currentNode ) ) { _ASSERTE(elemMesh == NULL); // 必ず1つ存在するのでこの時点ではNULL elemMesh = new MeshElement(); elemMesh->ReadNode( currentNode ); } else if( Is_extra_NodeName( currentNode ) ) { ExtraElement* elemExtra = new ExtraElement(); elemExtra->ReadNode( currentNode ); vecElemExtra.push_back( elemExtra ); } } currentNode = currentNode->getNextSibling(); // 次の要素を処理する } }
EppAuthInfo * EppAuthInfo::fromXML( const DOMNode& root ) { DOMNodeList* list = root.getChildNodes(); for( unsigned int i = 0; i < list->getLength(); i++ ) { DOMNode* node = list->item(i); DOMString name = node->getLocalName(); if( name.isNull() ) { name = node->getNodeName(); } if( name.isNull() ) { continue; } // if( name.equals("pw") ) if( name.equals("pw") || name.equals("contact:pw") || name.equals("domain:pw") || name.equals("svcsub:pw") || name.equals("xriAU:pw") || name.equals("xriINU:pw") || name.equals("xriINA:pw") || name.equals("xriISV:pw") /* Uncomment for CodeString || name.equals("xriCS:pw")*/ ) { DOMElement * elm = (DOMElement *) node; DOMString roid = elm->getAttribute(XS("roid")); DOMString value = EppUtil::getText(*node); return new EppAuthInfo(XS(TYPE_PW), value, roid); } // else if( name.equals("ext") ) else if( name.equals("ext") || name.equals("contact:ext") || name.equals("domain:ext") || name.equals("svcsub:ext") || name.equals("xriAU:ext") || name.equals("xriINU:ext") || name.equals("xriINA:ext") || name.equals("xriISV:ext") ) { return new EppAuthInfo(XS(TYPE_EXT), NULLXS); } } return null; }
//============================================================================= // METHOD: SPELLxmlConfigReaderXC::convertToNode //============================================================================= SPELLxmlNode* SPELLxmlConfigReaderXC::convertToNode( DOMElement* element ) { // Create an abstract node with this name SPELLxmlNode* node = new SPELLxmlNode( XMLString::transcode(element->getNodeName()) ); // Get any possible attributes DOMNamedNodeMap* attrs = element->getAttributes(); XMLSize_t numAttrs = attrs->getLength(); for( XMLSize_t idx = 0; idx < numAttrs; idx++) { // Get the attribute node DOMNode* attrNode = attrs->item(idx); // Get name and value const XMLCh* aname = attrNode->getNodeName(); const XMLCh* avalue = attrNode->getNodeValue(); // Convert name and value to strings std::string name = "<?>"; if (aname != NULL) { name = XMLString::transcode(aname); } std::string value = "<?>"; if (avalue != NULL) { value = XMLString::transcode(avalue); } node->addAttribute( name, value ); } // Get any possible children DOMNodeList* children = element->getChildNodes(); XMLSize_t numChildren = children->getLength(); for( XMLSize_t idx = 0; idx < numChildren; idx++) { // Get the children node DOMNode* childNode = children->item(idx); // Process only ELEMENTs and TEXTs if (childNode->getNodeType() && // true is not NULL childNode->getNodeType() == DOMNode::ELEMENT_NODE) // is element { // For elements, recursively add children SPELLxmlNode* child = convertToNode( dynamic_cast<xercesc::DOMElement*>(childNode) ); node->addChild(child); } else if (childNode->getNodeType() == DOMNode::TEXT_NODE) { // For text values, add the value. This code will just ignore // carriage-return values const XMLCh* nvalue = childNode->getNodeValue(); if (nvalue != NULL) { std::string thevalue = XMLString::transcode(nvalue); SPELLutils::trim(thevalue, " \n\r\t"); node->setValue( thevalue ); } } } return node; }
bool DynamicObjectImp::fromXml(DOMNode* pDocument, unsigned int version) { clear(); for (DOMNode* pNode = pDocument->getFirstChild(); pNode != NULL; pNode = pNode->getNextSibling()) { if (XMLString::equals(pNode->getNodeName(), X("attribute"))) { string name; DataVariant var; try { DOMElement* pElement(static_cast<DOMElement*>(pNode)); name = A(pElement->getAttribute(X("name"))); if (!var.fromXml(pNode, version)) { return false; } } catch (XmlReader::DomParseException& exc) { throw exc; } setAttribute(name, var, true); } } return true; }
void ControllerElement::ReadNode(const DOMNode* node) { _ASSERTE(node != NULL); ReadAttributes( node ); DOMNode* currentNode = node->getFirstChild(); while( currentNode != NULL ) { #if _DEBUG // デバッグ時に名前をチェックする為に const XMLCh* name = currentNode->getNodeName(); #endif if( IsElementNode( currentNode ) ) { if( Is_skin_NodeName( currentNode ) ) { _ASSERTE(elemSkin == NULL); // 必ず1つ存在するのでこの時点ではNULL elemSkin = new SkinElement(); elemSkin->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; }