TinyXml解析代码

最新推荐文章于 2024-04-02 15:27:21 发布
最新推荐文章于 2024-04-02 15:27:21 发布
阅读量291 收藏
点赞数
分类专栏： xml json格式化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/blackbattery/article/details/75041552
版权

网上已经有很多关于这部分的内容，这里提供部分代码用于实例。

[in] info 条件信息  
<?xml version='1.0' encoding='utf-8' standalone='no' ?>
<root>
    <srcdomid />        发起域ID
    <starttime />       开始时间
    <endtime />         结束时间
    <type />            告警类型 -1 查询全部 其它查询指定
    <domid />           设备域ID
    <devcode />         通道设备代码，比如"'chn0','chn1','chn2'"
    <chnidx />          通道序号
    <domdevcode />      设备域ID+设备代码，比如"'chn0','chn1','chn2'@domid1; 'chn0','chn1','chn2'@domid2"
    <size />            每页大小
    <curpage />         查询第几页
</root>

[out] outxml 返回信息 <?xml version='1.0' encoding='utf-8' standalone='no' ?>
<root>
    <total></total>             总数
    <item 
        id=""                   告警记录ID
        domid=""                域ID
        devcode=""              设备代码
        devname=""              设备名称
        chnidx=""               通道索引
        devtype=""              设备类型
        type=""                 告警类型
        status=""               状态
        level=""                告警等级
        alarmtime=""            告警时间
        length=""               数据长度
        msgtxt=""               消息文本
        confirmor=""            确认人
        confirmtime=""          确认时间
        comfirmmsg=""           确认消息
        comfirmstatus=""        确认状态
    />
</root>

代码实例：

#ifndef _ALARM_INFO_REQ_XML_H
#define _ALARM_INFO_REQ_XML_H

#include <vector>
#include <string>
#include "tinyxml.h"
#include "tinyxmldefine.h"
#include "XMLParser.h"

#define  XML_NODE_COUNT 7

class  CXMLProduce : public CXMLParser
{
public:
    CXMLProduce();
    virtual ~CXMLProduce();

public:
    int fromStream(const char *data);
    int toStream(char *buf, int &nLen);

    int fromStreamHisAlarm(const char *data);
    int toStreamHisAlarm(char *buf, int &nLen);

    int fromStreamHisRealData(const char *data);
    int toStreamHisRealData(char *buf, int &nLen);

    int toStreamDevHisRealData(char *buf, int &nLen);
    int fromStreamDevHisRealData(const char *data);//历史查询中历史数据


    void initialVector();
    void setDomid(const char *szDomid);
    void setSrcdomid(const char *szsrcdomid);
    void setStartTime(const char *szStartTime);
    void setEndTime(const char *szEndTime);
    void setType(int Type);
    void setDevcode(const char *szDevcode);
    void setDomDevcode(const char *szDomDevcode);
    void setChnidx(int Chnidx);
    void setCurpage(int Curpage);
    void setSize(int Size);


    int fromStreamQueryConfirmMsg(const char *data);
    int toStreamQueryConfirmMsg(char *buf, int &nLen);

protected:
    int packetXmlInside(TiXmlDocument &doc);
    int parseXmlInside(TiXmlDocument &doc);

    int packetXmlInsideHisAlarm(TiXmlDocument &doc);
    int parseXmlInsideHisAlarm(TiXmlDocument &doc);

    int packetXmlInsideHisRealData(TiXmlDocument &doc);
    int parseXmlInsideHisRealData(TiXmlDocument &doc);

    int packetXmlInsideDevHisRealData(TiXmlDocument &doc);//历史查询中历史数据
    int parseXmlInsideDevHisRealData(TiXmlDocument &doc);

    int packetXmlInsideQueryConfirmData(TiXmlDocument &doc);
    int parseXmlInsideQueryConfirmData(TiXmlDocument &doc);

public:
    int m_pageSize;
    int m_alarmTotal;
    AlarmInfo_t m_alarmInfo;

    char m_strDomid[64];
    char m_strDevcode[64];
    char m_strSrcdomid[64];
    char m_strStartTime[64];
    char m_strEndTime[64];
    int  m_strType;
    int  m_strCurpage;
    int m_strSize;
    int m_strChnidx;
    char m_strDomdevcode[64];

    HistoryAlarmDataInfo_t m_DeviceAlarmHisInfo;
    vector<string> vec;

    SCS_HistoryDataInfo_t m_MapDoorHisRealData;
    SCS_HistoryDataInfo_t m_MapDevHisRealData;

    std::list<_AlarmConfirm> m_confirmMsg;
};
#endif

#include "AlarmInfoReqXML.h"
#include <iostream>
#include<sstream>
#include"cstdio"
#include "string"

CXMLProduce::CXMLProduce()
{
    initialVector();
}
CXMLProduce::~CXMLProduce()
{

}

/********* 解析XML文件  *********/

int CXMLProduce::fromStream(const char *data)
{
    TiXmlDocument doc;
    doc.Parse(data);

    return parseXmlInside(doc);
}

int CXMLProduce::fromStreamHisAlarm(const char *data)
{
    TiXmlDocument doc;
    doc.Parse(data);

    return parseXmlInsideHisAlarm(doc);
}

int CXMLProduce::fromStreamHisRealData(const char *data)
{
    TiXmlDocument doc;
    doc.Parse(data);

    return parseXmlInsideHisRealData(doc);
}

int CXMLProduce::fromStreamDevHisRealData(const char *data)
{
    TiXmlDocument doc;
    doc.Parse(data);

    return parseXmlInsideDevHisRealData(doc);
}

int CXMLProduce::fromStreamQueryConfirmMsg(const char *data)
{
    TiXmlDocument doc;
    doc.Parse(data);

    return parseXmlInsideQueryConfirmData(doc);
}

int CXMLProduce::parseXmlInside(TiXmlDocument &doc)
{
    TiXmlElement *pRoot = doc.FirstChildElement("root");
    if(pRoot == nullptr)
    {
        return -1;  
    }

    TiXmlElement *pElement = pRoot->FirstChildElement("total");
    if (pElement != nullptr)
    {
        m_alarmTotal = atoi(pElement->GetText());
        m_alarmInfo.count =m_alarmTotal;
    }

    pElement = pRoot->FirstChildElement("taskrecord");
    while (pElement != nullptr)
    {
        AlarmInfoItem_t item;
        item.flag = -1;

        pElement->Attribute("id", &item.id);
        item.domid = pElement->Attribute("domid");
        item.devcode = pElement->Attribute("devcode");
        item.devname = pElement->Attribute("devname");
        item.orgname = pElement->Attribute("orgname");
        item.time = pElement->Attribute("time");
        item.result = pElement->Attribute("result");

        pElement->Attribute("type", &item.type);
        pElement->Attribute("alarmlevel", &item.alarm_level);

        XmlNodeKey node(item.domid, item.devcode);
        m_alarmInfo.items[node] = item;
        pElement = pElement->NextSiblingElement();
    }

    return 0;
}

int CXMLProduce::parseXmlInsideHisAlarm(TiXmlDocument &doc)
{
    TiXmlElement *pRoot = doc.FirstChildElement("root");
    if(pRoot == nullptr)
    {
        return -1;  
    }

    m_DeviceAlarmHisInfo.items.clear();
    TiXmlElement *pElement = pRoot->FirstChildElement("total");
    if (pElement != nullptr)
    {
        m_DeviceAlarmHisInfo.count = atoi(pElement->GetText());
    }

    pElement = pRoot->FirstChildElement("item");
    while (pElement != nullptr)
    {
        AlarmInfoItem_t alarmItem;
        string keyCode;
        alarmItem.flag = -1;
        pElement->Attribute("id", &alarmItem.id);
        alarmItem.domid= pElement->Attribute("domid");
        alarmItem.devcode = pElement->Attribute("devcode");
        alarmItem.chnname=pElement->Attribute("chnname");
        std::stringstream stream;
        stream<<alarmItem.id;
        keyCode=stream.str();
        alarmItem.devname = pElement->Attribute("devname");
        alarmItem.alarmtime = pElement->Attribute("alarmtime");
        pElement->Attribute("level", &alarmItem.alarm_level);
        pElement->Attribute("type", &alarmItem.hisalarm_type);
        pElement->Attribute("status",&alarmItem.status);

        m_DeviceAlarmHisInfo.items[keyCode] = alarmItem;
        pElement = pElement->NextSiblingElement();
    }

    return 0;
}

int CXMLProduce::parseXmlInsideHisRealData(TiXmlDocument &doc)
{
    TiXmlElement *pRoot = doc.FirstChildElement("root");
    if(pRoot == nullptr)
    {
        return -1;  
    }

    TiXmlElement *pElement = pRoot->FirstChildElement("total");
    if (pElement != nullptr)
    {
        int totalNum = atoi(pElement->GetText());
        m_MapDoorHisRealData.totalNum =totalNum;
    }

    pElement = pRoot->FirstChildElement("item");

    while (pElement != nullptr)
    {
        SCS_RealData hisDoorRealDataItem;

        TiXmlAttribute *xmlAttri = nullptr;
        xmlAttri = pElement->FirstAttribute();
        if (xmlAttri != nullptr)
        {
            hisDoorRealDataItem._domainId = xmlAttri->Value();
            xmlAttri = xmlAttri->Next();
        }

        if (xmlAttri != nullptr)
        {
            hisDoorRealDataItem._deviceCode = xmlAttri->Value();
            xmlAttri = xmlAttri->Next();
        }

        if (xmlAttri != nullptr)
        {
            hisDoorRealDataItem._chnName = xmlAttri->Value();
            xmlAttri = xmlAttri->Next();
        }

        if (xmlAttri != nullptr)
        {
            hisDoorRealDataItem._alarmtype = xmlAttri->IntValue();
            xmlAttri = xmlAttri->Next();
        }

        if (xmlAttri != nullptr)
        {
            hisDoorRealDataItem._isAlarm = xmlAttri->IntValue();
            xmlAttri = xmlAttri->Next();
        }

        if (xmlAttri != nullptr)
        {
            const char *pTime = xmlAttri->Value();
            std::string strTime(pTime);
            hisDoorRealDataItem._time = strTime;
            xmlAttri = xmlAttri->Next();
        }

        if (xmlAttri != nullptr)
        {

            hisDoorRealDataItem._value = xmlAttri->DoubleValue();
            xmlAttri = xmlAttri->Next();
        }

        if (xmlAttri != nullptr)
        {
            hisDoorRealDataItem._strunit = xmlAttri->Value();
        }


        if (xmlAttri != nullptr)
        {
            std::string strCodeTime("");
            strCodeTime.append(hisDoorRealDataItem._deviceCode);
            strCodeTime.append("@");
            strCodeTime.append(hisDoorRealDataItem._time);
            char buffer[20];
            sprintf_s(buffer,"f",hisDoorRealDataItem._value);
            string str=buffer;
            strCodeTime.append(str);

            m_MapDoorHisRealData.devRealDataMap[strCodeTime] = hisDoorRealDataItem;
        }

        pElement = pElement->NextSiblingElement();

    }
    return 0;
}
int CXMLProduce::parseXmlInsideDevHisRealData(TiXmlDocument &doc)
{
    TiXmlElement *pRoot = doc.FirstChildElement("root");
    if(pRoot == nullptr)
    {
        return -1;  
    }

    TiXmlElement *pElement = pRoot->FirstChildElement("total");
    if (pElement != nullptr)
    {
        int totalNum = atoi(pElement->GetText());
        m_MapDevHisRealData.totalNum =totalNum;
    }

    pElement = pRoot->FirstChildElement("item");

    while (pElement != nullptr)
    {
        SCS_RealData devHisRealDataItem;
        TiXmlAttribute *xmlAttri = nullptr;
        xmlAttri = pElement->FirstAttribute();
        if (xmlAttri != nullptr)
        {
            devHisRealDataItem._domainId = xmlAttri->Value();
            xmlAttri = xmlAttri->Next();
        }

        if (xmlAttri != nullptr)
        {
            devHisRealDataItem._deviceCode = xmlAttri->Value();
            xmlAttri = xmlAttri->Next();
        }

        if (xmlAttri != nullptr)
        {
            devHisRealDataItem._chnName = xmlAttri->Value();
            xmlAttri = xmlAttri->Next();
        }

        if (xmlAttri != nullptr)
        {
            devHisRealDataItem._alarmtype = xmlAttri->IntValue();
            xmlAttri = xmlAttri->Next();
        }
        if (xmlAttri != nullptr)
        {
            devHisRealDataItem._isAlarm = xmlAttri->IntValue();
            xmlAttri = xmlAttri->Next();
        }
        if (xmlAttri != nullptr)
        {
            const char *pTime = xmlAttri->Value();
            std::string strTime(pTime);
            devHisRealDataItem._time = strTime;
            xmlAttri = xmlAttri->Next();
        }

        if (xmlAttri != nullptr)
        {
            devHisRealDataItem._value = xmlAttri->DoubleValue();
            xmlAttri = xmlAttri->Next();
        }

        if (xmlAttri != nullptr)
        {
            devHisRealDataItem._strunit = xmlAttri->Value();
        }


        if (xmlAttri != nullptr)
        {
            std::string strCodeTime("");
            strCodeTime.append(devHisRealDataItem._deviceCode);
            strCodeTime.append("@");
            strCodeTime.append(devHisRealDataItem._time);

            char buffer[20];
            sprintf_s(buffer,"f",devHisRealDataItem._value);
            string str=buffer;
            strCodeTime.append(str);

            m_MapDevHisRealData.devRealDataMap[strCodeTime] = devHisRealDataItem;
        }

        pElement = pElement->NextSiblingElement();

    }
    return 0;
}

int CXMLProduce::parseXmlInsideQueryConfirmData(TiXmlDocument &doc)
{
    TiXmlElement *pRoot = doc.FirstChildElement("root");
    if(pRoot == nullptr)
    {
        return -1;  
    }

    TiXmlElement *pElement = pRoot->FirstChildElement("taskrecord");

    while (pElement != nullptr)
    {
        _AlarmConfirm item;

        pElement->Attribute("id", &item.alarmId);

        const char *pTime = pElement->Attribute("dealtime");
        if (pTime != nullptr)
        {
            item.confirm_time = pTime;
        }

        const char *pPerson = pElement->Attribute("dealperson");
        if (pPerson != nullptr)
        {
            item.dealperson = pPerson;
        }

        const char *pMsg = pElement->Attribute("dealresult");
        if (pMsg != nullptr)
        {
            item.confirm_msg = pMsg;
        }

        m_confirmMsg.push_back(item);

        pElement = pElement->NextSiblingElement();
    }

    return 0;
}



int CXMLProduce::toStream(char *buf, int &nLen)
{
    if (buf == nullptr)
    {
        return -2;
    }

    TiXmlDocument doc;
    int res = packetXmlInside(doc);
    if (res < 0)
    {
        return res;
    }

    TiXmlPrinter printer;
    doc.Accept(&printer);
    strcpy(buf, printer.CStr());
    nLen = printer.Size();

    return 0;
}

int CXMLProduce::toStreamHisAlarm(char *buf, int &nLen)
{
    if (buf == nullptr)
    {
        return -2;
    }

    TiXmlDocument doc;
    int res = packetXmlInsideHisAlarm(doc);
    if (res < 0)
    {
        return res;
    }

    TiXmlPrinter printer;
    doc.Accept(&printer);
    strcpy(buf, printer.CStr());
    nLen = printer.Size();

    return 0;
}

int CXMLProduce::toStreamHisRealData(char *buf, int &nLen)
{
    if (buf == nullptr)
    {
        return -2;
    }

    TiXmlDocument doc;
    int res = packetXmlInsideHisRealData(doc);
    if (res < 0)
    {
        return res;
    }

    TiXmlPrinter printer;
    doc.Accept(&printer);
    strcpy(buf, printer.CStr());
    nLen = printer.Size();

    return 0;
}

int CXMLProduce::toStreamQueryConfirmMsg(char *buf, int &nLen)
{
    if (buf == nullptr)
    {
        return -2;
    }

    TiXmlDocument doc;
    int res = packetXmlInsideQueryConfirmData(doc);
    if (res < 0)
    {
        return res;
    }

    TiXmlPrinter printer;
    doc.Accept(&printer);
    strcpy(buf, printer.CStr());
    nLen = printer.Size();

    return 0;
}


///

int CXMLProduce::packetXmlInside(TiXmlDocument &doc)
{

    TiXmlDeclaration *del = new TiXmlDeclaration("1.0", "'utf-8", "no");
    if( doc.LinkEndChild(del) == nullptr)
    {
        return -3;
    }

    TiXmlElement *pRoot = new TiXmlElement("root");
    if (doc.LinkEndChild(pRoot) == nullptr)
    {
        return -4;
    }



    TiXmlElement *pdomidElement = new TiXmlElement("domid");

    TiXmlText textDomid(m_strDomid);
    pdomidElement->InsertEndChild(textDomid);

    TiXmlElement *psizeElement = new TiXmlElement("size");
    char bufSize[64] = {0};
    m_pageSize = 500;
    _snprintf_s(bufSize, sizeof(bufSize), "%d", m_pageSize);
    TiXmlText textSize(bufSize);
    psizeElement->InsertEndChild(textSize);

    TiXmlElement *pcurpageElement = new TiXmlElement("curpage");
    char bufCuepage[64] = {0};
    _snprintf_s(bufCuepage, sizeof(bufCuepage), "%d", 0);
    TiXmlText textCurpage(bufCuepage);
    pcurpageElement->InsertEndChild(textCurpage);


    pRoot->LinkEndChild(pdomidElement);
    pRoot->LinkEndChild(psizeElement);
    pRoot->LinkEndChild(pcurpageElement);

    return 0;
}

int CXMLProduce::packetXmlInsideHisAlarm(TiXmlDocument &doc)
{
    TiXmlDeclaration *del = new TiXmlDeclaration("1.0", "'utf-8", "no");
    if( doc.LinkEndChild(del) == nullptr)
    {
        return -3;
    }

    TiXmlElement *pRoot = new TiXmlElement("root");
    if (doc.LinkEndChild(pRoot) == nullptr)
    {
        return -4;
    }
    TiXmlElement *psrcdomidElement = new TiXmlElement("srcdomid");
    TiXmlText textSrcDomid(m_strSrcdomid);
    psrcdomidElement->InsertEndChild(textSrcDomid);

    TiXmlElement *pstartElement = new TiXmlElement("starttime");
    TiXmlText textStartTime(m_strStartTime);
    pstartElement->InsertEndChild(textStartTime);

    TiXmlElement *pendElement = new TiXmlElement("endtime");
    TiXmlText textEndTime(m_strEndTime);
    pendElement->InsertEndChild(textEndTime);

    TiXmlElement *ptypeElement = new TiXmlElement("type");
    char bufType[64]={0};
    //m_strType= -1;
    _snprintf_s(bufType, sizeof(bufType), "%d",m_strType );
    TiXmlText textType(bufType);
    ptypeElement->InsertEndChild(textType);


    TiXmlElement *pdomidElement = new TiXmlElement("domid");
    TiXmlText textDomid(m_strDomid);
    pdomidElement->InsertEndChild(textDomid);

    TiXmlElement *pdevcodeElement = new TiXmlElement("devcode");
    char bufDevcode[64] = {0};
    _snprintf_s(bufDevcode, sizeof(bufDevcode), "\'%s\'", m_strDevcode);
    TiXmlText textDevcode(m_strDevcode);
    pdevcodeElement->InsertEndChild(textDevcode);



    TiXmlElement *pchnidxElement = new TiXmlElement("chnidx");
    char bufChnidx[64]={0};
    _snprintf_s(bufChnidx, sizeof(bufChnidx), "%d", m_strChnidx);
    TiXmlText textChnidx(bufChnidx);
    pchnidxElement->InsertEndChild(textChnidx);

    TiXmlElement *pdomdevElement = new TiXmlElement("domdevcode");
    TiXmlText textDomdevcode(m_strDomdevcode);
    pdomdevElement->InsertEndChild(textDomdevcode);


    TiXmlElement *psizeElement = new TiXmlElement("size");
    char bufSize[64] = {0};

    _snprintf_s(bufSize, sizeof(bufSize), "%d", m_strSize);
    TiXmlText textSize(bufSize);
    psizeElement->InsertEndChild(textSize);

    TiXmlElement *pcurpageElement = new TiXmlElement("curpage");
    char bufCurpage[64]={0};

    _snprintf_s(bufCurpage, sizeof(bufSize), "%d", m_strCurpage);
    TiXmlText textCurpage(bufCurpage);
    pcurpageElement->InsertEndChild(textCurpage);


    pRoot->LinkEndChild(psrcdomidElement);
    pRoot->LinkEndChild(pstartElement);
    pRoot->LinkEndChild(pendElement);
    pRoot->LinkEndChild(ptypeElement);
    pRoot->LinkEndChild(pdomidElement);
    pRoot->LinkEndChild(pdevcodeElement);
    pRoot->LinkEndChild(pchnidxElement);
    pRoot->LinkEndChild(pdomdevElement);
    pRoot->LinkEndChild(psizeElement);
    pRoot->LinkEndChild(pcurpageElement);       
    return 0;
}

int CXMLProduce::packetXmlInsideHisRealData(TiXmlDocument &doc)
{
    TiXmlDeclaration *del = new TiXmlDeclaration("1.0", "'utf-8", "no");
    if( doc.LinkEndChild(del) == nullptr)
    {
        return -3;
    }

    TiXmlElement *pRoot = new TiXmlElement("root");
    if (doc.LinkEndChild(pRoot) == nullptr)
    {
        return -4;
    }
    TiXmlElement *psrcdomidElement = new TiXmlElement("srcdomid");
    TiXmlText textSrcDomid(m_strSrcdomid);
    psrcdomidElement->InsertEndChild(textSrcDomid);

    TiXmlElement *pstartElement = new TiXmlElement("starttime");
    TiXmlText textStartTime(m_strStartTime);
    pstartElement->InsertEndChild(textStartTime);

    TiXmlElement *pendElement = new TiXmlElement("endtime");
    TiXmlText textEndTime(m_strEndTime);
    pendElement->InsertEndChild(textEndTime);


    TiXmlElement *pdomidElement = new TiXmlElement("domid");
    TiXmlText textDomid(m_strDomid);
    pdomidElement->InsertEndChild(textDomid);

    TiXmlElement *pdevcodeElement = new TiXmlElement("devcode");
    TiXmlText textDevcode(m_strDevcode);
    pdevcodeElement->InsertEndChild(textDevcode);

    TiXmlElement *psizeElement = new TiXmlElement("size");
    char bufSize[64] = {0};

    _snprintf_s(bufSize, sizeof(bufSize), "%d", m_strSize);
    TiXmlText textSize(bufSize);
    psizeElement->InsertEndChild(textSize);

    TiXmlElement *pcurpageElement = new TiXmlElement("curpage");
    char bufCurpage[64]={0};

    _snprintf_s(bufCurpage, sizeof(bufSize), "%d", m_strCurpage);
    TiXmlText textCurpage(bufCurpage);
    pcurpageElement->InsertEndChild(textCurpage);


    pRoot->LinkEndChild(psrcdomidElement);
    pRoot->LinkEndChild(pstartElement);
    pRoot->LinkEndChild(pendElement);
    pRoot->LinkEndChild(pdomidElement);
    pRoot->LinkEndChild(pdevcodeElement);
    pRoot->LinkEndChild(psizeElement);
    pRoot->LinkEndChild(pcurpageElement);       
    return 0;
}


int CXMLProduce::packetXmlInsideQueryConfirmData(TiXmlDocument &doc)
{
    TiXmlDeclaration *del = new TiXmlDeclaration("1.0", "utf-8", "no");
    if( doc.LinkEndChild(del) == nullptr)
    {
        return -3;
    }

    TiXmlElement *pRoot = new TiXmlElement("root");
    if (doc.LinkEndChild(pRoot) == nullptr)
    {
        return -4;
    }

    TiXmlElement *pdomidElement = new TiXmlElement("domid");
    TiXmlText textDomid(m_strDomid);
    pdomidElement->InsertEndChild(textDomid);

    TiXmlElement *pdevcodeElement = new TiXmlElement("devcode");
    TiXmlText textDevcode(m_strDevcode);
    pdevcodeElement->InsertEndChild(textDevcode);

    TiXmlElement *pstartElement = new TiXmlElement("starttime");
    TiXmlText textStartTime(m_strStartTime);
    pstartElement->InsertEndChild(textStartTime);

    TiXmlElement *pendElement = new TiXmlElement("endtime");
    TiXmlText textEndTime(m_strEndTime);
    pendElement->InsertEndChild(textEndTime);

    TiXmlElement *psizeElement = new TiXmlElement("size");
    char bufSize[64] = {0};

    _snprintf_s(bufSize, sizeof(bufSize), "%d", m_strSize);
    TiXmlText textSize(bufSize);
    psizeElement->InsertEndChild(textSize);

    TiXmlElement *pcurpageElement = new TiXmlElement("curpage");
    char bufCurpage[64]={0};

    _snprintf_s(bufCurpage, sizeof(bufSize), "%d", m_strCurpage);
    TiXmlText textCurpage(bufCurpage);
    pcurpageElement->InsertEndChild(textCurpage);

    //将元素加入root
    pRoot->LinkEndChild(pdomidElement);
    pRoot->LinkEndChild(pdevcodeElement);
    pRoot->LinkEndChild(pstartElement);
    pRoot->LinkEndChild(pendElement);
    pRoot->LinkEndChild(psizeElement);
    pRoot->LinkEndChild(pcurpageElement);       
    return 0;
}


void CXMLProduce::setDomid(const char *szDomid)
{
    if(szDomid!=nullptr)
    {
        strcpy_s(m_strDomid,szDomid);
    }   
}
void CXMLProduce::setSrcdomid(const char *szsrcdomid)
{
    if(szsrcdomid!=nullptr)
    {
        strcpy_s(m_strSrcdomid,szsrcdomid);
    }
}
void CXMLProduce::setStartTime(const char *szStartTime)
{
    if(szStartTime!=nullptr)
    {
        strcpy_s(m_strStartTime, szStartTime);
    }

}
void CXMLProduce::setEndTime(const char *szEndTime)
{
    if(szEndTime!=nullptr)
    {
        strcpy_s(m_strEndTime, szEndTime);
    }   
}
void CXMLProduce::setType(int Type)
{
    m_strType= Type;
}
void CXMLProduce::setDevcode(const char *szDevcode)
{
    if(szDevcode!=nullptr)
    {
        strcpy_s(m_strDevcode, szDevcode);
    }   
}
void CXMLProduce::setChnidx(int Chnidx)
{
    m_strChnidx=Chnidx;
}
void CXMLProduce::setDomDevcode(const char *szDomDevcode)
{
    if(szDomDevcode!=nullptr)
    {
        strcpy_s(m_strDomdevcode, szDomDevcode);
    }   
}
void CXMLProduce::setSize(int size)
{
    m_strSize=size;
}
void CXMLProduce::setCurpage(int Curpage)
{
    m_strCurpage= Curpage;
}

void CXMLProduce::initialVector()
{
    vec.push_back("srcdomid");
    vec.push_back("starttime");
    vec.push_back("endtime");
    vec.push_back("domid");
    vec.push_back("devcode");
    vec.push_back("size");
    vec.push_back("curpage");
}
游学四方
关注
专栏目录
tinyXml解析XML文件
程序猿老樊的博客
06-30 3761
TinyXML解析一个XML文档，并从该文档构建可读取、修改和保存的文档对象模型（DOM）。 XML代表“可扩展标记语言”，它允许您创建您自己的文档标记。HTML在标记方面做得很好用于浏览器的文档，XML允许您定义任何类型的文档标记，例如描述组织者应用程序。XML是一种非常结构化和方便的格式。所有为存储应用程序数据而创建的随机文件格式都可以全部替换为XML。所有内...
XML解析工具- TinyXML2 -源代码 - C++
02-10
作为XML解析器，TinyXML-2具有以下特点： 1. 轻量级且易于集成：它体积小巧，代码简洁，易于集成到各种 C++ 项目中。 2. API简单易用：它提供了简单易用的 API，使得解析和操作 XML 数据变得简单快捷。开发者可以...
【XML】TinyXML 详解（二）：接口详解
郭老二
12-23 1737
XML开源库TinyXML接口使用，使用几个示例来认识常用的接口， 和注意事项
tinyxml解析xml文件
曾经记忆的专栏
01-06 1193
一、tinyxml 库 tinyxml 开源精简版本xml 解析库，相比于libxml2 更适合使用于嵌入式设备当中xml数据的解析和构造 TiXmlBase Class Reference   下载TinyXML的网址： http://www.grinninglizard.com/tinyxml/ 二、tinyxml 编译成.so  1、
C++ 使用 TinyXml 解析 XML 文件
freeking101的博客
12-02 2036
TinyXML是一个开源的解析XML的解析库，能够用于C++，能够在Windows或Linux中编译,使用TinyXML进行C++ XML解析，使用简单，容易上手。这个解析库的模型通过解析XML文件，然后在内存中生成DOM模型，从而让我们很方便的遍历这棵XML树。 DOM模型即文档对象模型，是将整个文档分成多个元素（如书、章、节、段等），并利用树型结构表示这些元素之间的顺序关系以及嵌套包含关系。
xml快速入门（tinyxml解析）
先锋小牛
09-11 1888
简述 xml是一种可扩展标记语言，用于传输和存储数据。 语法 1.xml必须有根节点   &lt;root&gt;   &lt;child&gt;child&lt;/child&gt;   &lt;/root&gt; 2xml节点必须有始有终（有关闭标签）   &lt;radius&gt;1&lt;/radius&gt; 3 xml标签对大小写敏感   &lt;grayscal...
tinyxml2 version 9.0.0下载地址
08-20
- **示例代码**：可能包含一些示例程序，演示如何使用TinyXML2进行XML解析和操作。 - **文档**：可能有Markdown或HTML格式的文档，解释库的用法、API和常见问题解答。 - **测试代码**：单元测试代码用于验证库的功能...
C++ XML文件解析库 tinyxml2
07-02
1. **XML解析**：TinyXML2通过`XMLDocument`类来表示整个XML文档，你可以使用`LoadFile()`或`Parse()`方法加载XML文件或内存中的XML字符串。解析完成后，文档的结构被映射为一系列的节点，包括元素（XMLElement）、...
tinyxml.zip
12-04
1. **XML解析**：TinyXML能够读取XML文件或XML字符串，并将其转换为DOM（Document Object Model）结构。DOM是一种树形结构，将XML文档的元素、属性、文本等内容表示为对象，便于程序进行访问和操作。 2. **XML创建...
tinyxml2+示例代码+介绍文档
09-26
资源包含2015.9.23从官网下载的tinyxml2的源码和自己编写的示例代码还有介绍文档，容易上手。官网的示例代码和文档晦涩难懂，才自己整理。
QT使用TinyXML开源库解析XML文件
02-06
QT5.9.1 + MSVC2015 一个简单解析XML文件的例子，很简单；
Windows下编译TinyXML（XML文件解析）
最新发布
翟天保的博客
04-02 1271
Windows下编译TinyXML（XML文件解析）
Tinyxml一一利用tinyxml读取节点元素完整代码
xuanyin235的专栏
07-12 1175
//GolbalParam_Defination.h #include &lt;Windows.h&gt; #include &lt;map&gt; #include &lt;vector&gt; #include &lt;string&gt; using namespace std; typedef struct { vector&lt;string&gt; v_param; }_STL_1...
mac悬浮窗_苹果的软件悬浮窗在哪里?
weixin_35068573的博客
02-07 905
朋友，你先清理一下：【IE缓存和网页垃圾】！ 这是你的电脑误删了系统文件，或系统文件被顽固木马破坏！(答案原 创，原作者：力王历史)提示：急救箱无法联网，就用：“离线模式”！ 1。下载个“360系统急救箱”，已经安装了“360安全卫士”的朋友，直接打开 “功能大全”的下面的“360系统急救箱”，点击它： 【1】。开始急救！急救完毕后，立即处理，重启！ 【2】。开机后，“文件恢复区”，彻...
C++使用TinyXML解析XML
weixin_42975610的博客
11-18 1138
C++解析XML简介TinyXML包含的对象及方法使用步骤 C++解析XML(Win10-x64+VS2015) 简介 ​ 使用开源库TinyXML解析XML文件，TinyXML能够在windows或linux中编译，使用TinyXML只需要将其中的6个文件拷贝到项目中就可以直接使用了，这六个文件是:tinyxml.h、tinystr.h、tinyxml.cpp、tinystr.cpp、tinyxmlerror.cpp、tinyxmlparser.cpp。 TinyXML包含的对象及方法 1.
计算机丢失tinyxml.dll该怎么办,提示“系统缺少tinyxml.dll”怎么解决？tinyxml.dll使用方法...
weixin_34237941的博客
07-24 4021
tinyxml.dll是一个重要的系统文件，这个文件是随着windows系统在你的电脑中安装的时候一同形成的。如果你的电脑系统文件夹中缺少了或者这个文件损坏的话，那么你的电脑就会出现错误弹窗，提示你“系统缺少tinyxml.dll”，这样就会导致你的电脑无法正常运行某些软件。使用方法1、在本站下载好文件的压缩包，将其解压，将文件复制到对应你电脑的系统文件夹下;Windows 95/98/Me系统，...
TinyXML解析
dielu7895的博客
08-02 204
TinyXML介绍 最近做一个负载均衡的小项目，需要解析xml配置文件，用到了TinyXML，感觉使用起来很容易，给出一个使用TinyXML进行XML解析的简单例子，很多复杂的应用都可以基于本例子的方法来完成。 TinyXML是一个开源的解析XML的解析库，能够用于C++，能够在Windows或Linux中编译。这个解析库的模型通过解析XML文件，然后在内存中生成DOM模型，从而让我们很...
在C++中使用TinyXML2解析xml
热门推荐
爱冒险的技术宅
01-10 2万+
读取和设置xml配置文件是最常用的操作，试用了几个C++的XML解析器，个人感觉TinyXML是使用起来最舒服的，因为它的API接口和Java的十分类似，面向对象性很好。       TinyXML是一个开源的解析XML的解析库，能够用于C++，能够在Windows或Linux中编译。这个解析库的模型通过解析XML文件，然后在内存中生成DOM模型，从而让我们很方便的遍历这棵XML树。
tinyxml解析xml代码
06-08
以下是使用 TinyXML 解析 XML 的示例代码： ```c++ #include #include "tinyxml.h" int main() { TiXmlDocument doc("example.xml"); // 加载 XML 文件 bool loadOkay = doc.LoadFile(); // 解析 XML 文件 if...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值