C++ TiXmlElement::Type方法代码示例

void 			BBWinConfig::LoadConfiguration(const string & fileName, const string & configNameSpace, bbwinconfig_t  & config) {
	string				configName(BBWIN_CONFIG_ROOT);

	EnterCriticalSection(&m_configCriticalSection); 
	m_path = fileName;
	m_doc = new TiXmlDocument(m_path.c_str());
	if (m_doc == NULL) 
		throw BBWinConfigException("can't allocare tinyxml instance");
	bool loadOkay = m_doc->LoadFile();
	if ( !loadOkay ) {
		LeaveCriticalSection(&m_configCriticalSection);
		throw BBWinConfigException(m_doc->ErrorDesc());
	}
	TiXmlElement *root = m_doc->FirstChildElement( "configuration" );
	if ( root ) {
		TiXmlNode * nameSpaceNode = root->FirstChild( configNameSpace.c_str() );
		if ( nameSpaceNode ) {
			TiXmlElement		* elem;
			for (elem = nameSpaceNode->FirstChildElement(); elem ; elem = elem->NextSiblingElement()) {
				bbwinconfig_attr_t		config_attr;
				if (elem->Type() == TiXmlNode::ELEMENT) {
					TiXmlAttribute 			* attr;
					
					for (attr = elem->FirstAttribute(); attr; attr = attr->Next()) {
						config_attr.insert(pair< string, string >(attr->Name(), attr->Value()));
					}
				}
				config.insert(pair < string, bbwinconfig_attr_t > (elem->Value(), config_attr));
			}
		}
	}
	delete m_doc;
	m_doc = NULL;
	LeaveCriticalSection(&m_configCriticalSection);
}

/***********************************************************************************************************
 * 程序作者：赵进军
 * 函数功能：通过节点名获取XML中所有符合条件的节点指针
 * 参数说明：
 *    pRootEle：XML文件的根节点
 * strNodeName：需要获取的节点指针的名称
 *     retNode：获取到的符合条件的节点指针数组
 * 注意事项：在使用该函数之前 arrayIndex全局变量必须置为0
 * 修改日期：2015/12/13 13:56:00
 ***********************************************************************************************************/
bool OperationProfile_XML::GetNodePointerByNameAll(TiXmlElement* pRootEle, char*  strNodeName, TiXmlElement* retNode[])
{
	if (pRootEle == NULL)
		return false;

	if (!strcmp(strNodeName, pRootEle->Value()))																			// 假如等于节点名就自动退出
	{
		if (arrayIndex < groupNodeCount)
			retNode[arrayIndex] = pRootEle;
		else
			printf("请重新定义节点的数量");
		arrayIndex++;
		return true;
	}

	TiXmlElement* pchild = pRootEle->FirstChildElement();
	while (pchild)
	{
		int t = pchild->Type();

		if (t == TiXmlNode::TINYXML_ELEMENT)
			GetNodePointerByNameAll(pchild, strNodeName, retNode);

		pchild = pchild->NextSiblingElement();
	}

	if (NULL == retNode)
		return false;
	else
		return true;
}

/***********************************************************************************************************
 * 程序作者：赵进军
 * 函数功能：通过节点名获取XML的节点指针
 * 参数说明：
 *    pRootEle：XML文件的根节点
 * strNodeName：需要获取的节点指针的名称
 *		  node：获取到的符合条件的节点指针
 *   nodeIndex：节点的位置
 * 注意事项：在使用该函数之前 arrayIndex全局变量必须置为0
 * 修改日期：2015/12/12 17:18:00
 ***********************************************************************************************************/
bool OperationProfile_XML::GetNodePointerByName(TiXmlElement* pRootEle, char* strNodeName, TiXmlElement* &node, int nodeIndex)
{
	if (pRootEle == NULL)
		return false;

	if (!strcmp(strNodeName, pRootEle->Value()))																			// 假如等于节点名就自动退出
	{
		if (arrayIndex == nodeIndex)
			node = pRootEle;
		arrayIndex++;
		return true;
	}

	TiXmlElement* pchild = pRootEle->FirstChildElement();
	while (pchild)
	{
		int t = pchild->Type();

		if (t == TiXmlNode::TINYXML_ELEMENT)
			GetNodePointerByName(pchild, strNodeName, node, nodeIndex);
		pchild = pchild->NextSiblingElement();
	}

	if (NULL == node)
		return false;
	else
		return true;
}

 bool XmlParseConfig(Config &c, TiXmlElement *conf)
 {
     if ( conf == NULL ) return false;
     stringstream ss;
     TiXmlElement *config = conf->FirstChildElement();
     for ( ; config; config = config->NextSiblingElement() ) {
         if ( config->Type() != TiXmlNode::TINYXML_ELEMENT ) continue;
         string configType(config->Value());
         const char *name = config->Attribute("Name");
         if ( !name ) {
             Severe("Config Name attribute missing");
             return false;
         }
         string configName(name);
         if ( configType == "Float" ) {
             double value;
             if ( !config->Attribute("Value", &value) ) {
                 ss << "Config [" << configName << "] missing value";
                 Severe(ss);
                 return false;
             }
             c.AddAttribute(configName, (float) value);
         } else if ( configType == "Int32" ) {
             int i;
             if ( !config->Attribute("Value", &i) ) {
                 ss << "Config [" << configName << "] missing value";
                 Severe(ss);
                 return false;
             }
             c.AddAttribute(configName, i);
         } else if ( configType == "Vector" ) {
             Vector vec;
             TiXmlElement *elemVec = config->FirstChildElement("Value");
             if ( !elemVec ) {
                 ss << "Config [" << configName << "] missing value";
                 Severe(ss);
                 return false;
             }
             if ( !XmlParseVector(vec, elemVec) ) return false;
             c.AddAttribute(configName, vec);
         } else if ( configType == "Bool" ) {
             int b;
             if ( !config->Attribute("Value", &b) ) {
                 ss << "Config [" << configName << "] missing value";
                 Severe(ss);
                 return false;
             }
             c.AddAttribute(configName, b != 0);
         } else {
             ss << "Unknown config type: [" << configType << "]";
             Severe(ss);
             return false;
         }
     }
     return true;
 }

int em::EmXml::ReadRootChildAttrList( EmVecMapStr &rVecMapStr )
{
	int iResult = 0;
	rVecMapStr.clear();

	TiXmlElement *pElemRoot = m_pDoc->RootElement();
	if(pElemRoot == NULL)
	{
		return 0;
	}
	
	TiXmlElement *pElemChild = pElemRoot->FirstChildElement();
	TiXmlAttribute *pAttrChild = NULL;
	EmMapStr MapStr;
	while(true)
	{
		if(pElemChild == NULL)
		{
			break;
		}
		
		if(pElemChild->Type() != TiXmlNode::TINYXML_ELEMENT)
		{
			continue;
		}
		
		MapStr.clear();
		
		pAttrChild = pElemChild->FirstAttribute();
		while(true)
		{
			if(pAttrChild == NULL)
			{
				break;
			}
			
			MapStr[ pAttrChild->Name() ] = pAttrChild->Value();
			
			pAttrChild = pAttrChild->Next();
		}
		
		rVecMapStr.push_back(MapStr);
		pElemChild = pElemChild->NextSiblingElement();
	}
	
	iResult = rVecMapStr.size();
	
	return iResult;
}

void VersionInfoFactory::ParseOffsets(TiXmlElement * parent, VersionInfo* target, bool initial)
{
    // we parse the groups iteratively instead of recursively
    // breadcrubs acts like a makeshift stack
    // first pair entry stores the current element of that level
    // second pair entry the group object from OffsetGroup
    typedef triple< TiXmlElement *, OffsetGroup *, INVAL_TYPE> groupTriple;
    vector< groupTriple > breadcrumbs;
    {
        TiXmlElement* pEntry;
        // we get the <Offsets>, look at the children
        pEntry = parent->FirstChildElement();
        if(!pEntry)
            return;
        const char *cstr_invalid = parent->Attribute("valid");
        INVAL_TYPE parent_inval = NOT_SET;
        if(cstr_invalid)
        {
            if(strcmp(cstr_invalid,"false") == 0)
                parent_inval = IS_INVALID;
            else if(strcmp(cstr_invalid,"true") == 0)
                parent_inval = IS_VALID;
        }
        OffsetGroup * currentGroup = reinterpret_cast<OffsetGroup *> (target);
        currentGroup->setInvalid(parent_inval);
        breadcrumbs.push_back(groupTriple(pEntry,currentGroup, parent_inval));
    }

    // work variables
    OffsetGroup * currentGroup = 0;
    TiXmlElement * currentElem = 0;
    INVAL_TYPE parent_inval = NOT_SET;
    //cerr << "<Offsets>"<< endl;
    while(1)
    {
        // get current work variables
        currentElem = breadcrumbs.back().first;
        currentGroup = breadcrumbs.back().second;
        parent_inval = breadcrumbs.back().third;

        // we reached the end of the current group?
        if(!currentElem)
        {
            // go one level up
            breadcrumbs.pop_back();
            // exit if no more work
            if(breadcrumbs.empty())
            {
                break;
            }
            else
            {
                //cerr << "</group>" << endl;
                continue;
            }
        }

        if(!currentGroup)
        {
            groupTriple & gp = breadcrumbs.back();
            gp.first = gp.first->NextSiblingElement();
            continue;
        }

        // skip non-elements
        if (currentElem->Type() != TiXmlNode::ELEMENT)
        {
            groupTriple & gp = breadcrumbs.back();
            gp.first = gp.first->NextSiblingElement();
            continue;
        }

        // we have a valid current element and current group
        // get properties
        string type = currentElem->Value();
        std::transform(type.begin(), type.end(), type.begin(), ::tolower);
        const char *cstr_name = currentElem->Attribute("name");
        if(!cstr_name)
        {
            // ERROR, missing attribute
        }

        // evaluate elements
        const char *cstr_value = currentElem->Attribute("value");
        const char *cstr_invalid = currentElem->Attribute("valid");

        INVAL_TYPE child_inval = parent_inval;
        if(cstr_invalid)
        {
            if(strcmp(cstr_invalid,"false") == 0)
                child_inval = IS_INVALID;
            else if(strcmp(cstr_invalid,"true") == 0)
                child_inval = IS_VALID;
        }
        if(type == "group")
        {
            // create or get group
            OffsetGroup * og;
            if(initial)
                og = currentGroup->createGroup(cstr_name);
//.........这里部分代码省略.........