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;
}
Пример #4
0
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();	// 次の要素を処理する
	}
}
Пример #5
0
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();
}
Пример #6
0
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;
}
Пример #7
0
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--;
}
Пример #9
0
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;
}
Пример #11
0
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()));
  }
}
Пример #12
0
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);
}
Пример #13
0
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;
}
Пример #15
0
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;
}
Пример #16
0
/**
 * 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();
}
Пример #17
0
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();
	}
}
Пример #18
0
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();	// 次の要素を処理する
	}
}
Пример #19
0
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();
    }
}
Пример #20
0
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();
    }

		
}
Пример #21
0
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;
}
Пример #23
0
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
}
Пример #24
0
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;
}
Пример #25
0
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();	// 次の要素を処理する
    }
}
Пример #26
0
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;
}
Пример #27
0
//=============================================================================
// 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;
}
Пример #28
0
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;
}