//解析相应详细
IVS_INT32 CMediaXMLProcess::ParseVideoNumAndResource(CXml& xmlRsq,IVS_INT32& iReachLimit, IVS_INT32& iWhetherCited)
{
	const char*AttriValue = NULL;   //临时存储单个节点值
	if (xmlRsq.FindElemEx("Content"))
	{
		(void)xmlRsq.IntoElem();
		GET_ELEM_VALUE_NUM("ReachLimit", AttriValue, iReachLimit, xmlRsq);

		GET_ELEM_VALUE_NUM("WhetherCited", AttriValue, iWhetherCited, xmlRsq);
		return IVS_SUCCEED;
	}
	BP_RUN_LOG_ERR(IVS_FAIL, "Parse VideoNum And Resource XML", "Get VideoNum And Resource Error");
	return IVS_FAIL;
}
// 解析抓拍图片查询参数xml
IVS_INT32 OCXCapturePictureXMLProcess::GetSnapshotListParseXml(CXml &xml, IVS_QUERY_SNAPSHOT_PARAM *pQueryParam, const IVS_CHAR* pCameraCode)
{
	CHECK_POINTER(pQueryParam,IVS_PARA_INVALID);
	CHECK_POINTER(pCameraCode, IVS_PARA_INVALID);
	IVS_DEBUG_TRACE("");

	const char* szElemValue = NULL;
	const char* pTemp = NULL;
	if (!xml.FindElemEx("Content"))
	{
		BP_RUN_LOG_ERR(IVS_XML_INVALID,"Parse Result XML", "xml.FindElem(Content/PageInfo) is fail");
		return IVS_XML_INVALID;
	}
	GET_ELEM_VALUE_CHAR("CameraCode",szElemValue,  pCameraCode,IVS_DEV_CODE_LEN, xml);

	if (!xml.FindElemEx("Content/PageInfo"))
	{
		BP_RUN_LOG_ERR(IVS_XML_INVALID,"Parse Result XML", "xml.FindElem(Content/PageInfo) is fail");
		return IVS_XML_INVALID;
	}
	(void)xml.IntoElem();
	GET_ELEM_VALUE_NUM_FOR_UINT("FromIndex", pTemp, pQueryParam->stIndexRange.uiFromIndex, xml);
	GET_ELEM_VALUE_NUM_FOR_UINT("ToIndex", pTemp, pQueryParam->stIndexRange.uiToIndex, xml);

	if (!xml.FindElemEx("Content/TimeInfo"))
	{
		BP_RUN_LOG_ERR(IVS_XML_INVALID,"Parse Result XML", "xml.FindElem(Content/PageInfo) is fail");
		return IVS_XML_INVALID;
	}
	(void)xml.IntoElem();
	GET_ELEM_VALUE_CHAR("FromTime",szElemValue,  pQueryParam->stTimeSpan.cStart, IVS_TIME_LEN, xml);
	GET_ELEM_VALUE_CHAR("ToTime",szElemValue,  pQueryParam->stTimeSpan.cEnd, IVS_TIME_LEN, xml);
	xml.OutOfElem();
	GET_ELEM_VALUE_NUM_FOR_UINT("SnapType", pTemp, pQueryParam->uiSnapType, xml); // plint !e

	return IVS_SUCCEED;
}
 // 修改AlarmInCode
 IVS_INT32 CXmlProcess::SetAlarmInCodeValue(const IVS_CHAR* pPath, CXml& xml)
 {
	 CHECK_POINTER(pPath, IVS_OPERATE_MEMORY_ERROR);

	 if (!xml.FindElemEx(pPath))
	 {
		 BP_RUN_LOG_ERR(IVS_XML_INVALID, "SetAlarmInCodeValue", "xml.FindElemEx(pPath)");
		 return IVS_XML_INVALID;
	 }

	 const IVS_CHAR* pElemValue = xml.GetElemValue();
	 IVS_CHAR szAlarmInCode[IVS_ALARM_CODE_LEN + 1] = {0};
	 IVS_CHAR szDomainCode[IVS_DOMAIN_CODE_LEN + 1] = {0};
	 IVS_INT32 iRet = CXmlProcess::ParseDevCode(pElemValue, szAlarmInCode, szDomainCode);
	 xml.ModifyElemValue(szAlarmInCode);
	 return iRet;
 }
//解析密钥值
IVS_INT32 CMediaXMLProcess::ParseStreamencryKey(CXml& xmlRsq,char* pStreamencryKey)
{
	if (NULL == pStreamencryKey)
	{
		BP_RUN_LOG_ERR(IVS_FAIL, "Streamencry Key Space is NULL", "Get Streamencry Key Error");
		return IVS_FAIL;
	}
	const char*AttriValue = NULL;   //临时存储单个节点值
	if (xmlRsq.FindElemEx("Content"))
	{
		(void)xmlRsq.IntoElem();
		GET_ELEM_VALUE_CHAR("StreamEncryPWD", AttriValue, pStreamencryKey, ENCRY_KEY_LEN, xmlRsq);
	//	memcpy(pStreamencryKey,AttriValue,IVS_PWD_LEN);
		return IVS_SUCCEED;
	}
	BP_RUN_LOG_ERR(IVS_FAIL, "Parse Streamencry Key XML", "Get Streamencry Key Error");
	return IVS_FAIL;
}
 // 通用请求XML增加QueryField字段
 IVS_INT32 CXmlProcess::AddQueryFieldForUnifiedFormatQueryXML(const IVS_CHAR* pField,const IVS_CHAR* pValue, CXml& xmlReq)
 {
	 CHECK_POINTER(pField, IVS_OPERATE_MEMORY_ERROR);
	 CHECK_POINTER(pValue, IVS_OPERATE_MEMORY_ERROR);

	 std::string sQueryType = "EXACT";
	 if (xmlReq.FindElemEx("Content/PageInfo/QueryCond/QueryField"))
	 {
		 xmlReq.OutOfElem();
		 (void)xmlReq.AddElem("QueryField");
		 (void)xmlReq.AddChildElem("Field");
		 (void)xmlReq.IntoElem();
		 (void)xmlReq.SetElemValue(pField);
		 (void)xmlReq.AddElem("Value");
		 (void)xmlReq.SetElemValue(pValue); 
		 (void)xmlReq.AddElem("QueryType");
		 (void)xmlReq.SetElemValue(sQueryType.c_str());
		 xmlReq.OutOfElem();
	 }
	 return IVS_SUCCEED;
 }
예제 #6
0
bool CI18N::SetLanguage(const std::string& strLanguageXMLPath)
{
    BP_RUN_LOG_INF("load language xml failed","strLanguageXMLPath %s", strLanguageXMLPath.c_str());
	CXml xml;
	if (!xml.Load(strLanguageXMLPath.c_str(), TIXML_ENCODING_UTF8))
	{
		//表示加载资源XML不成功
		BP_RUN_LOG_ERR(IVS_FAIL,"load language xml failed","NA");
		return false;
	}

	//如果加载成功了,就遍历xml将所有的资源和语言绑定并加入map表
	if (!xml.FindElemEx("Content"))
	{
		//没找到第一个结点
		return false;
	}

	//先进行清除
	Clear();

	do 
	{
		// 获取当前结点
		const char* ResourceNode = xml.GetElem();
		// 获取当前结点的值
		const char* ResourceNodeValue = xml.GetElemValue();
		// 转换编码,防止乱码
		char* xml2ANSI = CToolsHelp::UTF8ToANSI(ResourceNodeValue);
		//把结点和值绑定进行插入
		(void)VOS_MutexLock(m_pMutexLock);
		(void)m_mapResource2Language.insert(std::make_pair(ResourceNode, xml2ANSI));
		(void)VOS_MutexUnlock(m_pMutexLock);
		free(xml2ANSI);
	} while (xml.NextElem());

	return true;
}
//对XML中的设备编码拼装与编码
int CSDKMainctrl::ModifyDevCode(CXml& xml, IVS_CHAR* pData)const
{
	CHECK_POINTER(pData, IVS_OPERATE_MEMORY_ERROR);

	if (!xml.Parse(pData))
	{
		BP_RUN_LOG_ERR(IVS_SMU_XML_INVALID, "xml.Parse(pData)", "NA");
		//IVS_DELETE(pData, MUILI);
		return IVS_SMU_XML_INVALID;
	}
	if (!xml.FindElemEx("Content/Action"))
	{
		BP_RUN_LOG_ERR(IVS_SMU_XML_INVALID, "xml.FindElem(Content/Action)", "NA");
		//IVS_DELETE(pData, MUILI);
		return IVS_SMU_XML_INVALID;		
	}
	// 若xml包含DevList,需要处理DevCode(拼接设备所在域编码DevDomainCode)
	if (xml.FindElem("DevList"))
	{
		xml.IntoElem();
		if (!xml.FindElem("DevInfo"))
		{
			BP_RUN_LOG_ERR(IVS_SMU_XML_INVALID, "xml.FindElem(DevInfo)", "NA");
			//IVS_DELETE(pData, MUILI);
			return IVS_SMU_XML_INVALID;		
		}
		do 
		{
			(void)xml.IntoElem();
			// 找到设备所在域编码拼在DevCode后面
			if (!xml.FindElem("DevDomainCode"))
			{
				BP_RUN_LOG_ERR(IVS_SMU_XML_INVALID, "xml.FindElem(DevCode)", "NA");
				//IVS_DELETE(pData, MUILI);
				return IVS_SMU_XML_INVALID;		
			}
			std::string strDevDomainCode;
            const IVS_CHAR* pDevDomainCode = xml.GetElemValue();
            if (NULL != pDevDomainCode)
            {
                strDevDomainCode = pDevDomainCode;
            }
			// 拼接设备所在域编码
			if (!xml.FindElem("DevCode"))
			{
				BP_RUN_LOG_ERR(IVS_SMU_XML_INVALID, "xml.FindElem(DevCode)", "NA");
				//IVS_DELETE(pData, MUILI);
				return IVS_SMU_XML_INVALID;		
			}
			std::string strDevCode;
            
            const IVS_CHAR* pDevCode = xml.GetElemValue();
            if (NULL != pDevCode)
            {
                strDevCode = pDevCode;
            }

			if (!strDevCode.empty())
			{
				strDevCode.append("#").append(strDevDomainCode);
				xml.ModifyElemValue(strDevCode.c_str());
			}
			xml.OutOfElem();
		} while (xml.NextElem());
		xml.OutOfElem();
	}
// 
// 	IVS_UINT32 uiXmlLen = 0;
// 	pDataXml = xml.GetXMLStream(uiXmlLen);
// 	CHECK_POINTER(pDataXml, IVS_OPERATE_MEMORY_ERROR);
	return IVS_SUCCEED;
}//lint !e818
// 解析本地抓拍参数客户端配置xml
IVS_INT32 OCXCapturePictureXMLProcess::LocalCaptureParseClientConfig(LPCTSTR pXmlStr, IVS_LOCAL_CAPTURE_PARAM &LocalCaptuParam)
{
	IVS_DEBUG_TRACE("Local Capture Config %s", pXmlStr);
	(void)CToolsHelp::Strncpy(LocalCaptuParam.cCapturePath, sizeof(LocalCaptuParam.cCapturePath) - 1, CAPTURE_DEFAULT_PATH, sizeof(CAPTURE_DEFAULT_PATH));  
	LocalCaptuParam.uiSnapshotMode = CAPTURE_DEFAULT_MODE;
	LocalCaptuParam.uiSnapshotCount = CAPTURE_DEFAULT_COUNT;			
	LocalCaptuParam.uiSnapshotInterval = CAPTURE_DEFAULT_INTERVAL;		
	LocalCaptuParam.uiSnapshotFormat = CAPTURE_DEFAULT_FORMAT;		
	LocalCaptuParam.uiNameRule = CAPTURE_DEFAULT_NAME_RULE;		
	if (NULL == pXmlStr || '\0' == pXmlStr[0])
	{
		return IVS_PARA_INVALID;
	}

	CXml xml;
	if (!xml.Parse(pXmlStr))
	{
		BP_RUN_LOG_ERR(IVS_XML_INVALID, "Local Capture Parse Client Config", "parse xml error, use default");
		return IVS_FAIL;
	}

	if (!xml.FindElemEx("CaptureConfig"))
	{
		BP_RUN_LOG_ERR(IVS_XML_INVALID,"Local Capture Parse Client Config fail", "no 'CaptureConfig' elemenet");
		return IVS_XML_INVALID;
	}
	xml.IntoElem();

	const char *value = NULL;
	bool  bSuccess = true;
	bool  bRet = false;

	bSuccess = (xml.FindElem("CapturePath")) && (NULL != (value = xml.GetElemValue()));
	if (bSuccess)
	{
		bRet = CToolsHelp::Strncpy(LocalCaptuParam.cCapturePath, sizeof(LocalCaptuParam.cCapturePath) - 1, value, strlen(value));  
	} else {
		bRet = CToolsHelp::Strncpy(LocalCaptuParam.cCapturePath, sizeof(LocalCaptuParam.cCapturePath) - 1, CAPTURE_DEFAULT_PATH, sizeof(CAPTURE_DEFAULT_PATH));
	}
	if(false == bRet)
	{
		BP_RUN_LOG_ERR(IVS_ALLOC_MEMORY_ERROR,"Local Capture Parse Client Config", "Strncpy error.");
		return IVS_ALLOC_MEMORY_ERROR;
	}

	bSuccess = (xml.FindElem("SnapshotMode")) && (NULL != (value = xml.GetElemValue()));
	LocalCaptuParam.uiSnapshotMode = bSuccess ? atoi(value) : CAPTURE_DEFAULT_MODE;

	bSuccess = (xml.FindElem("SnapshotCount")) &&(NULL != (value = xml.GetElemValue()));
	LocalCaptuParam.uiSnapshotCount = bSuccess ? (IVS_UINT32)atoi(value) : CAPTURE_DEFAULT_COUNT;

	bSuccess = (xml.FindElem("SnapshotInterval")) &&(NULL != (value = xml.GetElemValue()));
	LocalCaptuParam.uiSnapshotInterval = bSuccess ? (IVS_UINT32)atoi(value) : CAPTURE_DEFAULT_INTERVAL;
	
	bSuccess = (xml.FindElem("SnapshotFormat")) &&(NULL != (value = xml.GetElemValue()));
	LocalCaptuParam.uiSnapshotFormat = bSuccess ? atoi(value) : CAPTURE_DEFAULT_FORMAT;
	
	bSuccess = (xml.FindElem("NameRule")) && (NULL != (value = xml.GetElemValue()));
	LocalCaptuParam.uiNameRule = bSuccess ? atoi(value) : CAPTURE_DEFAULT_NAME_RULE;

	return IVS_SUCCEED;
}
//设置平台抓拍计划:将请求XML转换为结构体
IVS_INT32 OCXCapturePictureXMLProcess::SetSnapshotPlanGetXML(IVS_CHAR* pCameraCode,IVS_SNAPSHOT_PLAN* pSnapShotPlan, CXml &xml)
{ 
	CHECK_POINTER(pCameraCode,IVS_PARA_INVALID);
	CHECK_POINTER(pSnapShotPlan,IVS_PARA_INVALID);
	IVS_DEBUG_TRACE("");
	if (!xml.FindElemEx("Content/SnapshotPlanInfo"))
	{
		BP_RUN_LOG_ERR(IVS_XML_INVALID,"Set Snapshot Plan Get XML", "fail", "no 'SnapshotPlanInfo' elemenet");
		return IVS_XML_INVALID;
	}      
	(void)xml.IntoElem();
	const char* szElemValue = NULL;

	// 摄像机编码
	if (!xml.FindElem("CameraCode"))
	{
		BP_RUN_LOG_ERR(IVS_XML_INVALID,"Set Snapshot Plan Get XML", "faill", "no 'CameraCode' elemenet");
		return IVS_XML_INVALID;
	}
	GET_ELEM_VALUE_CHAR("CameraCode",szElemValue,pCameraCode,IVS_DEV_CODE_LEN,xml);
	// 是否启用 
	if (!xml.FindElem("IsEnable"))
	{
		BP_RUN_LOG_ERR(IVS_XML_INVALID,"Set Snapshot Plan Get XML", "faill", "no 'IsEnable' elemenet");
		return IVS_XML_INVALID;
	}
	const IVS_CHAR* cpszIsEnable = xml.GetElemValue();
	if (NULL == cpszIsEnable)
	{
		return IVS_XML_INVALID;
	}
	pSnapShotPlan->bEnable = static_cast<IVS_BOOL>(atoi(cpszIsEnable));

	// 计划方式(周计划 日计划 全程录像)
	if (!xml.FindElem("PlanType"))
	{
		BP_RUN_LOG_ERR(IVS_XML_INVALID,"Set Snapshot Plan Get XML", "faill", "no 'PlanType' elemenet");
		return IVS_XML_INVALID;
	}
	GET_ELEM_VALUE_NUM_FOR_UINT("PlanType",szElemValue,pSnapShotPlan->uiPlanType,xml);

	IVS_UINT32 iPlanInfoNum = 0;
	IVS_INT32 iTimeInfoNum = 0;
	if (xml.FindElemEx("Content/SnapshotPlanInfo/PlanList"))
	{
		do 
		{
			(void)xml.IntoElem();
			//解析PlanInfo
			(void)xml.IntoElem();
			memset(&pSnapShotPlan->stPlanInfo[iPlanInfoNum],0, sizeof(IVS_SNAPSHOT_PLAN_INFO));
			GET_ELEM_VALUE_NUM_FOR_UINT("DayType",szElemValue,pSnapShotPlan->stPlanInfo[iPlanInfoNum].uiDayType,xml);

			if (xml.FindElem("TimeList"))
			{
				xml.IntoElem();
			}
			if(xml.FindElem("TimeInfo"))
			{
				do{ 
					(void)xml.IntoElem();
					GET_ELEM_VALUE_CHAR("StartTime",szElemValue,  pSnapShotPlan->stPlanInfo[iPlanInfoNum].stTimeSpanInfo[iTimeInfoNum].cStart,IVS_TIME_LEN,xml);
					GET_ELEM_VALUE_CHAR("EndTime",szElemValue,  pSnapShotPlan->stPlanInfo[iPlanInfoNum].stTimeSpanInfo[iTimeInfoNum].cEnd,IVS_TIME_LEN,xml);
					GET_ELEM_VALUE_NUM_FOR_UINT("SnapInterval",szElemValue,pSnapShotPlan->stPlanInfo[iPlanInfoNum].stTimeSpanInfo[iTimeInfoNum].SnapInterval,xml);
					iTimeInfoNum++;
					xml.OutOfElem();
				}while(xml.NextElem());
			}
			pSnapShotPlan->stPlanInfo[iPlanInfoNum].uiTimeSpanInfoNum = static_cast<IVS_UINT32>(iTimeInfoNum);
			xml.OutOfElem();
			xml.OutOfElem();
			iPlanInfoNum++;
			iTimeInfoNum = 0;
		} while(xml.NextElem());
	}
	pSnapShotPlan->uiPlanInfoNum = iPlanInfoNum;
	xml.OutOfElem();

	return IVS_SUCCEED;
}
예제 #10
0
IVS_INT32 CDomainRouteMgr::GetShareCatalogList(const IVS_CHAR* pQueryInfo, IVS_CHAR** pRspXml)
{
    CHECK_POINTER(m_pUserMgr, IVS_OPERATE_MEMORY_ERROR);
	if (NULL == pQueryInfo)
	{
		BP_RUN_LOG_ERR(IVS_FAIL, "Get Share Cata log List", "Query Info is NULL");
		return IVS_FAIL;
	}
    // 获取本域SMU连接
    std::string strSMULinkID;
    IVS_INT32 iGetLinkRet = m_pUserMgr->GetLocalDomainLinkID(NET_ELE_SMU_NSS, strSMULinkID);
    if (IVS_SUCCEED != iGetLinkRet)
    {
        BP_RUN_LOG_ERR(iGetLinkRet, "Get LocalDomainLinkID failed", "NA");
        return iGetLinkRet;
    }
	CCmd* pCmd = CNSSOperator::instance().BuildSMUCmd(NSS_GET_SHARE_CATALOG_LIST_REQ, pQueryInfo, strSMULinkID);
	CHECK_POINTER(pCmd, IVS_OPERATE_MEMORY_ERROR);
	//发送消息
	IVS_INT32 iRet = IVS_FAIL;
	CCmd *pCmdRsp = CNSSOperator::instance().SendSyncCmd(pCmd);
	CHECK_POINTER(pCmdRsp, IVS_NET_RECV_TIMEOUT);
	const char* pBefore =  CNSSOperator::instance().ParseCmd2XML(pCmdRsp, iRet);
	if (IVS_SUCCEED != iRet || NULL == pBefore)
	{
		HW_DELETE(pCmdRsp);
		BP_RUN_LOG_ERR(iRet, "Share Cata log list", "XML illegal ");
		return iRet;
	}
	HW_DELETE(pCmdRsp);
	std::string strBefore = pBefore;
	IVS_DELETE(pBefore, MUILI);
	//std::string strBefore("<Content><ShareDevList><ShareDevInfo><OriginDevCode>123456</OriginDevCode><OriginDomainCode>0123456789</OriginDomainCode><LocalDevCode>0123#001</LocalDevCode></ShareDevInfo></ShareDevList></Content>");
	//std::string strBefore("<OriginDevCode>00000010000000000301</OriginDevCode><OriginDomainCode>001</OriginDomainCode><Latitude>0</Latitude><OriginDevCode>00000010000000000201#001</OriginDevCode><OriginDomainCode>001</OriginDomainCode><LocalDevCode /><Latitude>0</Latitude><OriginDevCode>00000010000000000101#001</OriginDevCode><OriginDomainCode>001</OriginDomainCode><OriginDevCode>1</OriginDevCode><OriginDomainCode /><LocalDevCode />");
	std::string strAfter;
	iRet = ComplicationDevDomainCode(strBefore,strAfter);

	CXml xml;
	std::string strDomainCode;
	m_pUserMgr->GetDomainCode(strDomainCode);
	std::string strLocalDevCode;
	if (!xml.Parse(strAfter.c_str()))
	{
		BP_RUN_LOG_ERR(IVS_OPERATE_MEMORY_ERROR, "xml.Parse(strAfter) fail", "NA");
		return IVS_OPERATE_MEMORY_ERROR;
	}
	if (!xml.FindElemEx("Content/ShareDevList"))
	{
		BP_RUN_LOG_ERR(IVS_SMU_DEV_REQ_XML_INVALID, "xml.FindElemEx(Content/ShareDevList) fail", "NA");
		return IVS_SMU_DEV_REQ_XML_INVALID;
	}
	if (!xml.FindElem("ShareDevInfo"))
	{
		IVS_UINT32 uiXmlLen = 0;
		const IVS_CHAR* pRsp = xml.GetXMLStream(uiXmlLen);
        if (NULL == pRsp)
        {
            return IVS_SMU_DEV_REQ_XML_INVALID;
        }

		IVS_CHAR *cTmp = IVS_NEW(cTmp,strlen(pRsp) + 1);
		if (NULL == cTmp)
		{
			return IVS_ALLOC_MEMORY_ERROR;
		}
		memset(cTmp, 0, strlen(pRsp) + 1);
		memcpy(cTmp, pRsp, strlen(pRsp));
		*pRspXml = cTmp;
		return IVS_SUCCEED;
	}
	do 
	{
		(void)xml.IntoElem();
		if (!xml.FindElem("LocalDevCode"))
		{
			BP_RUN_LOG_ERR(IVS_SMU_DEV_REQ_XML_INVALID, "xml.FindElem(LocalDevCode) fail", "NA");
			return IVS_SMU_DEV_REQ_XML_INVALID;
		}
        const IVS_CHAR* pLocalDevCode =  xml.GetElemValue();
        if (NULL != pLocalDevCode)
        {
            strLocalDevCode = pLocalDevCode;
        }

		if (0 != strcmp(strLocalDevCode.c_str(), ""))
		{
			strLocalDevCode.append("#");
			strLocalDevCode.append(strDomainCode);
			xml.ModifyElemValue(strLocalDevCode.c_str());
		}
		xml.OutOfElem();
	} while (xml.NextElem());

	IVS_UINT32 uiLen = 0;
	const IVS_CHAR* pRsq = xml.GetXMLStream(uiLen);

    if (NULL == pRsq)
    {
        return IVS_SMU_DEV_REQ_XML_INVALID;
    }

	IVS_CHAR *cTmp = IVS_NEW(cTmp,strlen(pRsq) + 1);
	if (NULL == cTmp)
	{
		return IVS_ALLOC_MEMORY_ERROR;
	}
	memset(cTmp, 0, strlen(pRsq) + 1);
	memcpy(cTmp, pRsq, strlen(pRsq));
	*pRspXml = cTmp;

	return iRet;
}//lint !e1762
예제 #11
0
// 解析域路由到List
IVS_INT32 CDomainRouteMgr::GetDomainRouteToListParseXML(DOMAIN_CODE_LIST& stCodeInfoList, CXml &xmlRsp)
{
    BP_RUN_LOG_INF("Parse XML to List", "Enter");

    if (!xmlRsp.FindElemEx("Content/DomainRoutes"))
    {
        BP_RUN_LOG_ERR(IVS_XML_INVALID, "Parse XML to List",
                       "no 'Content/DomainRoutes' elemenet");
        return IVS_XML_INVALID;
    }

    if (!xmlRsp.FindElem("DomainRoute"))
    {
        BP_RUN_LOG_ERR(IVS_XML_INVALID, "Parse XML to List",
                       "no 'DevInfo' elemenet");
        return IVS_XML_INVALID;
    }

    const IVS_CHAR *pSzElement = NULL;
    IVS_UINT32 uiSTLen = sizeof(IVS_DOMAIN_ROUTE);
    const int tempLength = 10;
    IVS_CHAR tempChar[tempLength]={0};
    do
    {
        if (!xmlRsp.FindElemValue("DomainRoute"))
        {
            break;
        }

        xmlRsp.IntoElem();

        IVS_DOMAIN_ROUTE *pDomain_route = IVS_NEW(pDomain_route);

        if (NULL == pDomain_route)
        {
            return IVS_FAIL;
        }

        memset(pDomain_route, 0, uiSTLen);

        //域编码
        GET_ELEM_VALUE_CHAR("DomainCode", pSzElement, pDomain_route->cDomainCode, IVS_DOMAIN_CODE_LEN, xmlRsp);

        //域名称
        GET_ELEM_VALUE_CHAR("DomainName", pSzElement, pDomain_route->cDomainName, IVS_NAME_LEN, xmlRsp);

        //域IP
        GET_ELEM_VALUE_CHAR("DomainIP", pSzElement, pDomain_route->stIP.cIP, IVS_IP_LEN, xmlRsp);

        //域端口
        //GET_ELEM_VALUE_NUM_FOR_UINT("DomainPort", pSzElement, pDomain_route->uiPort, xmlRsp);

        //域模式
        GET_ELEM_VALUE_NUM_FOR_UINT("DomainType", pSzElement, pDomain_route->uiDomainType, xmlRsp);

        //是否代理
        GET_ELEM_VALUE_NUM("IsProxy", pSzElement, pDomain_route->bIsAgent, xmlRsp);

        //代理网段
        //GET_ELEM_VALUE_NUM("ProxySegment", pSzElement, stDomainRoute.bIsAgent, xmlRsp);

        //上级域编码
        GET_ELEM_VALUE_CHAR("SuperDomain", pSzElement, pDomain_route->cSuperDomain, IVS_DOMAIN_CODE_LEN, xmlRsp);

        GET_ELEM_VALUE_CHAR("IsOnline", pSzElement, tempChar, sizeof(tempChar) - 1, xmlRsp);

        pDomain_route->uiStatus = CDevEnum::GetDevStatusEnum(tempChar);

        //是否本域
        GET_ELEM_VALUE_NUM("IsLocalDomain", pSzElement, pDomain_route->bIsLocalDomain, xmlRsp);


        pDomain_route->uiPort = DEFAULT_SMU_PORT;
        
        stCodeInfoList.push_back(pDomain_route);
        xmlRsp.OutOfElem();
    } while (xmlRsp.NextElem());

    BP_RUN_LOG_INF("Parse XML to List", "Leave");
    return IVS_SUCCEED;
} //lint !e1762