tinyXml learning

#include <string>
#include <iostream>
#include <tinyxml.h>

using std::string;
using std::cout;
using std::endl;

struct xmlNodeList{
TiXmlNode *node;
struct xmlNodeList *next;
struct xmlNodeList *front;
};

void test_char_buffer();
void printMyXml();
void getMyXml();
void writeXmlToDocument();
std::string printAllNode(TiXmlNode * pNode,int childDeep);
TiXmlNode* findTheLastSpecialNode(TiXmlNode * pNode, const std::string&  dstStr, TiXmlNode **resultNode );
xmlNodeList* findAllSpecialNode(TiXmlNode * pNode, const std::string&  dstStr, xmlNodeList **NodeList);

//function: get the node attribute
//[in]:  pNode, the one xml node
//[return]: the current node attribute string, format [name=vale,name=vale,...]
string getNodeAttribute(TiXmlNode * pNode)
{
if(pNode == NULL) return "";
string attributeStr = "";
TiXmlElement * pElement = pNode->ToElement();    //get current node element
TiXmlAttribute * pAttr = pElement->FirstAttribute();   //get the first attribute
string tmpAttrMsg = "";

if( NULL != pAttr )
{
std::string tmpAttrName = "";
std::string tmpAttrVal = "";
do{
tmpAttrName = pAttr->Name();
tmpAttrVal = pAttr->Value();
attributeStr += tmpAttrName+"=" + tmpAttrVal+",";   //split each attribute with  character ','
}while( (pAttr = pAttr->Next() ) );  //look for the other attribute of the current element
attributeStr = attributeStr.erase(attributeStr.find_last_of(","));  //clear the last ','
attributeStr += "]";
}

attributeStr += tmpAttrMsg;
return attributeStr;
}

int main(int argc, char *argv[]) {

// setbuf(stdout,NULL);
// setbuf(stderr,NULL);

// printMyXml();
// getMyXml();
// writeXmlToDocument();

test_char_buffer();
return 0;
}

void printMyXml() {
using namespace std;
TiXmlDocument doc;
const char * xmlFile = "first.xml";
if (doc.LoadFile(xmlFile)) {
doc.Print();
} else {
cout << "can not parse xml first.xml" << endl;
}
}

void getMyXml() {
using namespace std;
const char * xmlFile = "first.xml";
TiXmlDocument doc;
if (doc.LoadFile(xmlFile)) {
//doc.Print();
} else {
cout << "can not parse xml first.xml" << endl;
return;
}
TiXmlElement *rootElement = doc.RootElement();

//get the xml head, the declaration
TiXmlDeclaration* decl = doc.FirstChild()->ToDeclaration();
if(decl){
cout << "xml version: " << decl->Version() << endl;
cout << "xml encoding format: " << decl->Encoding() << endl;
}

TiXmlElement *RootElement = doc.RootElement(); //get the root element
cout << "RootValue: " <<RootElement->Value();  //print the root element value

TiXmlElement *root = rootElement;
TiXmlNode *originalRootContentElement = root->FirstChildElement();
for( TiXmlNode *rootContentElement=originalRootContentElement ; rootContentElement!=NULL ; rootContentElement= rootContentElement->NextSibling() )
{
std::cout<<printAllNode(rootContentElement, 0)<<"\n";
}

TiXmlNode *pRootNode=rootElement->FirstChildElement();

string dstStr= "email";
std::cout<<"look for : " <<dstStr<<endl;
TiXmlNode *res_node;
TiXmlNode *res_node_back_up = res_node;
findTheLastSpecialNode(pRootNode,dstStr,&res_node);
if(res_node_back_up != res_node)
{
std::string nodeStr = res_node->Value();
nodeStr = nodeStr + getNodeAttribute( res_node );
std::cout<<"-----reslut " << nodeStr<<"\n"<<endl;
}

xmlNodeList *result_node=NULL;
dstStr= "email";
std::cout<<"look for : " <<dstStr<<endl;

findAllSpecialNode(pRootNode,dstStr,&result_node);
xmlNodeList *p_result_node=result_node;
for( int i=0 ;p_result_node; p_result_node=p_result_node->next ){
TiXmlNode *res_node = p_result_node->node;
std::string nodeStr = res_node->Value();
nodeStr = nodeStr + getNodeAttribute( res_node );
std::cout<<i++<<"-----reslut  " << nodeStr<<"\n"<<endl;
}

//  TiXmlNode* pNode  = NULL;
//  string msg = "";
//  //  for(pNode=RootElement->FirstChildElement();pNode;pNode=pNode->NextSiblingElement())
//  //  {
//  //      msg += printAllNode(pNode,0);
//  //  }

}

void writeXmlToDocument() {
using namespace std;
const char * xmlFile = "unhappy.xml";
TiXmlDocument doc;
TiXmlDeclaration * decl = new TiXmlDeclaration("1.0", "", "");
TiXmlElement * schoolElement = new TiXmlElement( "company" );
TiXmlElement * classElement = new TiXmlElement( "money" );
classElement->SetAttribute("NoOne", "C++");

TiXmlElement * stu1Element = new TiXmlElement("SB1?");
stu1Element->SetAttribute("name", "tinyxml");
stu1Element->SetAttribute("anxiety", "very much");
TiXmlElement * stu1EmailElement = new TiXmlElement("email");
stu1EmailElement->LinkEndChild(new TiXmlText("go to hell 1@welcom.com") );
TiXmlElement * stu1AddressElement = new TiXmlElement("address");
stu1AddressElement->LinkEndChild(new TiXmlText("I don't Know"));
stu1Element->LinkEndChild(stu1EmailElement);
stu1Element->LinkEndChild(stu1AddressElement);

TiXmlElement * stu2Element = new TiXmlElement("SB2?");
stu2Element->SetAttribute("name", "wait");
stu2Element->SetAttribute("unhappy", "very much");
TiXmlElement * stu2EmailElement = new TiXmlElement("email");
stu2EmailElement->LinkEndChild(new TiXmlText("go to hell 2@welcom.com"));
TiXmlElement * stu2AddressElement = new TiXmlElement("address");
stu2AddressElement->LinkEndChild(new TiXmlText("Where?"));
stu2Element->LinkEndChild(stu2EmailElement);
stu2Element->LinkEndChild(stu2AddressElement);

classElement->LinkEndChild(stu1Element);
classElement->LinkEndChild(stu2Element);
schoolElement->LinkEndChild(classElement);

doc.LinkEndChild(decl);
doc.LinkEndChild(schoolElement);
doc.SaveFile(xmlFile);
}

//function: start to print all the element from the pNode
// [in] pNode, the one xml Node element, will start  from this node
// [in] childDeep,  the depth of the current node relative to the original node
// [return],   the structured string
std::string printAllNode(TiXmlNode * pNode,int childDeep)
{
std::string structured_str = "";

if(pNode == NULL){
return "";
}
TiXmlText * pText = NULL;
TiXmlNode * pChildNode = NULL;
int t = pNode->Type();

if(t == TiXmlText::TINYXML_TEXT)  //the node type is TINYXML_TEXT
{
pText = pNode->ToText();
std::string text = pText->Value();
//std::cout<<"TINYXML_TEXT: "<<text<<"\n";
if(!text.empty()){
structured_str = structured_str + "="+ text;
}
} //the node type is TINYXML_ELEMENT
else if(t == TiXmlText::TINYXML_ELEMENT)
{
structured_str = structured_str + "\r\n";
int num = childDeep;
while(num >= 1){
structured_str = structured_str + "\t";
num--;
}
structured_str = structured_str + pNode->Value();
//std::cout<<"TINYXML_TEXT: "<<pNode->Value()<<"\n";
structured_str = structured_str + getNodeAttribute( pNode );
}
//look for the child element
for( pChildNode=pNode->FirstChild() ; pChildNode!=(void*)0 ; pChildNode = pChildNode->NextSibling() )
{
structured_str = structured_str + printAllNode(pChildNode,childDeep+1);
}
return structured_str;
}

//function: find the last matching element
//[in]: pNode ,look for the matching element from the node
//[in]: dstStr, the compare string
//[in]: resultNode, the last matching element
//[return] the last matching element
TiXmlNode* findTheLastSpecialNode(TiXmlNode * pNode, const std::string&  dstStr, TiXmlNode **resultNode )
{
if(!pNode){
return NULL;
}
int t = pNode->Type();

if( TiXmlText::TINYXML_TEXT ==t)   //the node type is TINYXML_TEXT, text node
{
TiXmlText *pText = pNode->ToText();
std::string text = pText->Value();
//std::cout<<"TINYXML_TEXT: "<<text<<"\n";
}
if( TiXmlText::TINYXML_ELEMENT ==t) //the node type is TINYXML_ELEMENT, element node
{
//std::cout<<"TINYXML_ELEMENT: "<<pNode->Value()<<"\n";
std::string text = pNode->Value();
if( 0 == text.compare(dstStr) )
{
*resultNode = pNode;
}
}

for(TiXmlNode *p_child_node=pNode->FirstChild(); p_child_node; p_child_node=p_child_node->NextSibling() )
{
findTheLastSpecialNode(p_child_node,dstStr,resultNode);
}
return *resultNode;
}

//function: find all the special node, return a node list
//[in]: pNode ,look for the matching element from the node
//[in]: the compare string
//[in]: the node list, you should make *NodeList =NULL; becuse *NodeList is the list head
//[return] the list head
xmlNodeList* findAllSpecialNode(TiXmlNode * pNode, const std::string&  dstStr, xmlNodeList **NodeList)
{
if(NULL == pNode){
return NULL;
}
int t = pNode->Type();

if( TiXmlText::TINYXML_TEXT ==t)  //the node type is TINYXML_TEXT, text node
{
TiXmlText *pText = pNode->ToText();
std::string text = pText->Value();
//std::cout<<"TINYXML_TEXT: "<<text<<"\n";
}
else if( TiXmlText::TINYXML_ELEMENT ==t) //the node type is TINYXML_ELEMENT, element node
{
//std::cout<<"TINYXML_ELEMENT: "<<pNode->Value()<<"\n";
std::string text = pNode->Value();
if( 0 == text.compare(dstStr) ){
if(NULL == NodeList )
{
fprintf(stderr,"NodeList = %p error!\n", NodeList);
exit(-1);
}
else
{

xmlNodeList *ptmp =(xmlNodeList*)malloc( sizeof(xmlNodeList) );
if(NULL==ptmp)
{
fprintf(stderr,"malloc memory error!\n");
exit(-1);
}
memset(ptmp, 0, sizeof(ptmp) );

if( NULL==*NodeList )  //list head
{
//DBG_MY_("*NodeList=%p\n",*NodeList);
ptmp->front = NULL;
ptmp->next = NULL;
ptmp->node = pNode;
*NodeList = ptmp;
}
else
{
xmlNodeList* pListHead= *NodeList;
//DBG_MY_("pListHead=%p\n",pListHead);
for( ; NULL!=pListHead->next ; pListHead = pListHead->next  )
;
ptmp->front = pListHead;
ptmp->next = NULL;
ptmp->node = pNode;
pListHead->next = ptmp;
}
}
}
}

for(TiXmlNode *p_child_node=pNode->FirstChild(); p_child_node; p_child_node=p_child_node->NextSibling() )
{
findAllSpecialNode(p_child_node,dstStr,NodeList);
}
return *NodeList;
}

//function: char buffer to xml document
// [in] msgBuf, the char buffer
// [return],
int  bufferToXml(char *msgBuf)
{
TiXmlDocument  buffer ;
buffer.Parse( msgBuf,  0, TIXML_DEFAULT_ENCODING );
TiXmlElement* rootElement = buffer.RootElement();
TiXmlElement* Element = rootElement->FirstChildElement();

std::cout<< printAllNode(rootElement , 0) <<"\n";
return 0;
}

// <?xml version="1.0" encoding="UTF-8"?>
// <recipe>
//  <recipename>Ice Cream Sundae</recipename>
//  <ingredlist>

//      <listitem>
//      <quantity>3</quantity>
//      <itemdescription>chocolate syrup or chocolate fudge</itemdescription>
//      </listitem>

//      <listitem>
//      <quantity>1</quantity>
//      <itemdescription>nuts</itemdescription>
//      </listitem>

//      <listitem>
//      <quantity>1</quantity>
//      <itemdescription>cherry</itemdescription>
//      </listitem>

//  </ingredlist>
//  <preptime>5 minutes</preptime>
// </recipe>
void test_char_buffer()
{
string str123 = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
str123 = str123 + "<recipe>";
str123 = str123 + "<recipename>Ice Cream Sundae</recipename>";
str123 = str123 + "<ingredlist>";
str123 = str123 + "<listitem>";
str123 = str123 + "<quantity>3</quantity>";
str123 = str123 + "<itemdescription>chocolate syrup or chocolate fudge</itemdescription>";
str123 = str123 + "</listitem>";
str123 = str123 + "<listitem>";
str123 = str123 + "<quantity>1</quantity>";
str123 = str123 + "<itemdescription>nuts</itemdescription>";
str123 = str123 + "</listitem>";
str123 = str123 + "<listitem>";
str123 = str123 + "<quantity>1</quantity>";
str123 = str123 + "<itemdescription>cherry</itemdescription>";
str123 = str123 + "</listitem>";
str123 = str123 + "</ingredlist>";
str123 = str123 + "<preptime>5 minutes</preptime>";
str123 = str123 + "</recipe>"       ;

char src[4096]={0};

strncpy(src ,str123.c_str(), str123.size() );

printf("\n\n%s\n\n", src);
bufferToXml(src);
}

//function: a example , xml to buffer
void XmlToBuffer(void)
{
TiXmlDocument doc ;
TiXmlDeclaration * decl = new TiXmlDeclaration( "1.0","UTF-8", "" );
doc.LinkEndChild( decl );

TiXmlElement * MESSAGE = new TiXmlElement( "MESSAGE");
MESSAGE->SetAttribute("Version", "1.0");

TiXmlElement * Header = new TiXmlElement( "Header");
Header->SetAttribute("Number", "110");
Header->SetAttribute("ID", "120");

TiXmlElement * Label = new TiXmlElement( "Label");
Label->SetAttribute("Type", "TERMINAL");
Label->SetAttribute("IP", "192.168.1.1");
Label->SetAttribute("Item", "Nothing");

TiXmlElement * Body = new TiXmlElement( "Body");

TiXmlElement* Time = new TiXmlElement("Time");
Time->LinkEndChild(new TiXmlText("1999-9-9") );
TiXmlElement * person = new TiXmlElement("person");
person->LinkEndChild(new TiXmlText("monkey"));
TiXmlElement* action = new TiXmlElement("action");
action->LinkEndChild(new TiXmlText("type the codes") );

MESSAGE->LinkEndChild(Header);
MESSAGE->LinkEndChild(Label);
MESSAGE->LinkEndChild(Body);

Body->LinkEndChild(Time);
Body->LinkEndChild(person);
Body->LinkEndChild(action);

doc.LinkEndChild( MESSAGE );

TiXmlPrinter printer;
doc.Accept( &printer );
doc.SaveFile();

unsigned int xmlLength = printer.Size();
printf("the length of this xml content is %d \n",xmlLength );

char xmlBuffer[1024] = {0};
strncpy(xmlBuffer ,printer.CStr(), sizeof(xmlBuffer)>xmlLength ? xmlLength:sizeof(xmlBuffer) );

printf("cotent :\n%s\n",xmlBuffer );

}