rapidxml学习

rapidxml学习参考:官网http://rapidxml.sourceforge.net/https://blog.csdn.net/wqvbjhc/article/details/7662931http://blog.sina.com.cn/s/blog_9b0604b40101o6fm.htmlrapidxml_print.hpp修改代码:#ifndefRAPIDXML_PRINT_HP…

大家好,又见面了,我是你们的朋友全栈君。

参考: 官网http://rapidxml.sourceforge.net/
https://blog.csdn.net/wqvbjhc/article/details/7662931
http://blog.sina.com.cn/s/blog_9b0604b40101o6fm.html

rapidxml_print.hpp修改代码:

#ifndef RAPIDXML_PRINT_HPP_INCLUDED

#define RAPIDXML_PRINT_HPP_INCLUDED



// Copyright (C) 2006, 2009 Marcin Kalicinski

// Version 1.13

// Revision $DateTime: 2009/05/13 01:46:17 $

//! \file rapidxml_print.hpp This file contains rapidxml printer implementation



#include "rapidxml.hpp"



// Only include streams if not disabled

#ifndef RAPIDXML_NO_STREAMS

    #include <ostream>

    #include <iterator>

#endif



namespace rapidxml

{



    ///

    // Printing flags



    const int print_no_indenting = 0x1;   //!< Printer flag instructing the printer to suppress indenting of XML. See print() function.



    ///

    // Internal



    //! \cond internal

    namespace internal

    {

        

        ///

        // Internal character operations

    

        // Copy characters from given range to given output iterator

        template<class OutIt, class Ch>

        inline OutIt copy_chars(const Ch *begin, const Ch *end, OutIt out)

        {

            while (begin != end)

                *out++ = *begin++;

            return out;

        }

        

        // Copy characters from given range to given output iterator and expand

        // characters into references (&lt; &gt; &apos; &quot; &amp;)

        template<class OutIt, class Ch>

        inline OutIt copy_and_expand_chars(const Ch *begin, const Ch *end, Ch noexpand, OutIt out)

        {

            while (begin != end)

            {

                if (*begin == noexpand)

                {

                    *out++ = *begin;    // No expansion, copy character

                }

                else

                {

                    switch (*begin)

                    {

                    case Ch('<'):

                        *out++ = Ch('&'); *out++ = Ch('l'); *out++ = Ch('t'); *out++ = Ch(';');

                        break;

                    case Ch('>'): 

                        *out++ = Ch('&'); *out++ = Ch('g'); *out++ = Ch('t'); *out++ = Ch(';');

                        break;

                    case Ch('\''): 

                        *out++ = Ch('&'); *out++ = Ch('a'); *out++ = Ch('p'); *out++ = Ch('o'); *out++ = Ch('s'); *out++ = Ch(';');

                        break;

                    case Ch('"'): 

                        *out++ = Ch('&'); *out++ = Ch('q'); *out++ = Ch('u'); *out++ = Ch('o'); *out++ = Ch('t'); *out++ = Ch(';');

                        break;

                    case Ch('&'): 

                        *out++ = Ch('&'); *out++ = Ch('a'); *out++ = Ch('m'); *out++ = Ch('p'); *out++ = Ch(';'); 

                        break;

                    default:

                        *out++ = *begin;    // No expansion, copy character

                    }

                }

                ++begin;    // Step to next character

            }

            return out;

        }



        // Fill given output iterator with repetitions of the same character

        template<class OutIt, class Ch>

        inline OutIt fill_chars(OutIt out, int n, Ch ch)

        {

            for (int i = 0; i < n; ++i)

                *out++ = ch;

            return out;

        }



        // Find character

        template<class Ch, Ch ch>

        inline bool find_char(const Ch *begin, const Ch *end)

        {

            while (begin != end)

                if (*begin++ == ch)

                    return true;

            return false;

        }



        ///

        // Internal printing operations

    template<class OutIt, class Ch>

        OutIt print_node(OutIt out, const xml_node<Ch> *node, int flags, int indent);    

    template<class OutIt, class Ch>
    OutIt print_element_node(OutIt out, const xml_node<Ch> *node, int flags, int indent);

    template<class OutIt, class Ch>

        OutIt print_data_node(OutIt out, const xml_node<Ch> *node, int flags, int indent);

    template<class OutIt, class Ch>

        OutIt print_cdata_node(OutIt out, const xml_node<Ch> *node, int flags, int indent);

    template<class OutIt, class Ch>

        OutIt print_declaration_node(OutIt out, const xml_node<Ch> *node, int flags, int indent);
    template<class OutIt, class Ch>

         OutIt print_comment_node(OutIt out, const xml_node<Ch> *node, int flags, int indent);
    template<class OutIt, class Ch>

         OutIt print_doctype_node(OutIt out, const xml_node<Ch> *node, int flags, int indent);
    template<class OutIt, class Ch>

         OutIt print_pi_node(OutIt out, const xml_node<Ch> *node, int flags, int indent);


    // Print children of the node                               

        template<class OutIt, class Ch>

        inline OutIt print_children(OutIt out, const xml_node<Ch> *node, int flags, int indent)

        {

            for (xml_node<Ch> *child = node->first_node(); child; child = child->next_sibling())

                out = print_node(out, child, flags, indent);

            return out;

        }

    

        // Print node

        template<class OutIt, class Ch>

        inline OutIt print_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)

        {

            // Print proper node type

            switch (node->type())

            {



            // Document

            case node_document:

                out = print_children(out, node, flags, indent);

                break;



            // Element

            case node_element:

                out = print_element_node(out, node, flags, indent);

                break;

            

            // Data

            case node_data:

                out = print_data_node(out, node, flags, indent);

                break;

            

            // CDATA

            case node_cdata:

                out = print_cdata_node(out, node, flags, indent);

                break;



            // Declaration

            case node_declaration:

                out = print_declaration_node(out, node, flags, indent);

                break;



            // Comment

            case node_comment:

                out = print_comment_node(out, node, flags, indent);

                break;

            

            // Doctype

            case node_doctype:

                out = print_doctype_node(out, node, flags, indent);

                break;



            // Pi

            case node_pi:

                out = print_pi_node(out, node, flags, indent);

                break;



                // Unknown

            default:

                assert(0);

                break;

            }

            

            // If indenting not disabled, add line break after node

            if (!(flags & print_no_indenting))

                *out = Ch('\n'), ++out;



            // Return modified iterator

            return out;

        }

        

        

        // Print attributes of the node

        template<class OutIt, class Ch>

        inline OutIt print_attributes(OutIt out, const xml_node<Ch> *node, int flags)

        {

            for (xml_attribute<Ch> *attribute = node->first_attribute(); attribute; attribute = attribute->next_attribute())

            {

                if (attribute->name() && attribute->value())

                {

                    // Print attribute name

                    *out = Ch(' '), ++out;

                    out = copy_chars(attribute->name(), attribute->name() + attribute->name_size(), out);

                    *out = Ch('='), ++out;

                    // Print attribute value using appropriate quote type

                    if (find_char<Ch, Ch('"')>(attribute->value(), attribute->value() + attribute->value_size()))

                    {

                        *out = Ch('\''), ++out;

                        out = copy_and_expand_chars(attribute->value(), attribute->value() + attribute->value_size(), Ch('"'), out);

                        *out = Ch('\''), ++out;

                    }

                    else

                    {

                        *out = Ch('"'), ++out;

                        out = copy_and_expand_chars(attribute->value(), attribute->value() + attribute->value_size(), Ch('\''), out);

                        *out = Ch('"'), ++out;

                    }

                }

            }

            return out;

        }



        // Print data node

        template<class OutIt, class Ch>

        inline OutIt print_data_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)

        {

            assert(node->type() == node_data);

            if (!(flags & print_no_indenting))

                out = fill_chars(out, indent, Ch('\t'));

            out = copy_and_expand_chars(node->value(), node->value() + node->value_size(), Ch(0), out);

            return out;

        }



        // Print data node

        template<class OutIt, class Ch>

        inline OutIt print_cdata_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)

        {

            assert(node->type() == node_cdata);

            if (!(flags & print_no_indenting))

                out = fill_chars(out, indent, Ch('\t'));

            *out = Ch('<'); ++out;

            *out = Ch('!'); ++out;

            *out = Ch('['); ++out;

            *out = Ch('C'); ++out;

            *out = Ch('D'); ++out;

            *out = Ch('A'); ++out;

            *out = Ch('T'); ++out;

            *out = Ch('A'); ++out;

            *out = Ch('['); ++out;

            out = copy_chars(node->value(), node->value() + node->value_size(), out);

            *out = Ch(']'); ++out;

            *out = Ch(']'); ++out;

            *out = Ch('>'); ++out;

            return out;

        }



        // Print element node

        template<class OutIt, class Ch>

        inline OutIt print_element_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)

        {

            assert(node->type() == node_element);



            // Print element name and attributes, if any

            if (!(flags & print_no_indenting))

                out = fill_chars(out, indent, Ch('\t'));

            *out = Ch('<'), ++out;

            out = copy_chars(node->name(), node->name() + node->name_size(), out);

            out = print_attributes(out, node, flags);

            

            // If node is childless

            if (node->value_size() == 0 && !node->first_node())

            {

                // Print childless node tag ending

                *out = Ch('/'), ++out;

                *out = Ch('>'), ++out;

            }

            else

            {

                // Print normal node tag ending

                *out = Ch('>'), ++out;



                // Test if node contains a single data node only (and no other nodes)

                xml_node<Ch> *child = node->first_node();

                if (!child)

                {

                    // If node has no children, only print its value without indenting

                    out = copy_and_expand_chars(node->value(), node->value() + node->value_size(), Ch(0), out);

                }

                else if (child->next_sibling() == 0 && child->type() == node_data)

                {

                    // If node has a sole data child, only print its value without indenting

                    out = copy_and_expand_chars(child->value(), child->value() + child->value_size(), Ch(0), out);

                }

                else

                {

                    // Print all children with full indenting

                    if (!(flags & print_no_indenting))

                        *out = Ch('\n'), ++out;

                    out = print_children(out, node, flags, indent + 1);

                    if (!(flags & print_no_indenting))

                        out = fill_chars(out, indent, Ch('\t'));

                }



                // Print node end

                *out = Ch('<'), ++out;

                *out = Ch('/'), ++out;

                out = copy_chars(node->name(), node->name() + node->name_size(), out);

                *out = Ch('>'), ++out;

            }

            return out;

        }



        // Print declaration node

        template<class OutIt, class Ch>

        inline OutIt print_declaration_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)

        {

            // Print declaration start

            if (!(flags & print_no_indenting))

                out = fill_chars(out, indent, Ch('\t'));

            *out = Ch('<'), ++out;

            *out = Ch('?'), ++out;

            *out = Ch('x'), ++out;

            *out = Ch('m'), ++out;

            *out = Ch('l'), ++out;



            // Print attributes

            out = print_attributes(out, node, flags);

            

            // Print declaration end

            *out = Ch('?'), ++out;

            *out = Ch('>'), ++out;

            

            return out;

        }



        // Print comment node

        template<class OutIt, class Ch>

        inline OutIt print_comment_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)

        {

            assert(node->type() == node_comment);

            if (!(flags & print_no_indenting))

                out = fill_chars(out, indent, Ch('\t'));

            *out = Ch('<'), ++out;

            *out = Ch('!'), ++out;

            *out = Ch('-'), ++out;

            *out = Ch('-'), ++out;

            out = copy_chars(node->value(), node->value() + node->value_size(), out);

            *out = Ch('-'), ++out;

            *out = Ch('-'), ++out;

            *out = Ch('>'), ++out;

            return out;

        }



        // Print doctype node

        template<class OutIt, class Ch>

        inline OutIt print_doctype_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)

        {

            assert(node->type() == node_doctype);

            if (!(flags & print_no_indenting))

                out = fill_chars(out, indent, Ch('\t'));

            *out = Ch('<'), ++out;

            *out = Ch('!'), ++out;

            *out = Ch('D'), ++out;

            *out = Ch('O'), ++out;

            *out = Ch('C'), ++out;

            *out = Ch('T'), ++out;

            *out = Ch('Y'), ++out;

            *out = Ch('P'), ++out;

            *out = Ch('E'), ++out;

            *out = Ch(' '), ++out;

            out = copy_chars(node->value(), node->value() + node->value_size(), out);

            *out = Ch('>'), ++out;

            return out;

        }



        // Print pi node

        template<class OutIt, class Ch>

        inline OutIt print_pi_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)

        {

            assert(node->type() == node_pi);

            if (!(flags & print_no_indenting))

                out = fill_chars(out, indent, Ch('\t'));

            *out = Ch('<'), ++out;

            *out = Ch('?'), ++out;

            out = copy_chars(node->name(), node->name() + node->name_size(), out);

            *out = Ch(' '), ++out;

            out = copy_chars(node->value(), node->value() + node->value_size(), out);

            *out = Ch('?'), ++out;

            *out = Ch('>'), ++out;

            return out;

        }



    }

    //! \endcond



    ///

    // Printing



    //! Prints XML to given output iterator.

    //! \param out Output iterator to print to.

    //! \param node Node to be printed. Pass xml_document to print entire document.

    //! \param flags Flags controlling how XML is printed.

    //! \return Output iterator pointing to position immediately after last character of printed text.

    template<class OutIt, class Ch> 

    inline OutIt print(OutIt out, const xml_node<Ch> &node, int flags = 0)

    {

        return internal::print_node(out, &node, flags, 0);

    }



#ifndef RAPIDXML_NO_STREAMS



    //! Prints XML to given output stream.

    //! \param out Output stream to print to.

    //! \param node Node to be printed. Pass xml_document to print entire document.

    //! \param flags Flags controlling how XML is printed.

    //! \return Output stream.

    template<class Ch> 

    inline std::basic_ostream<Ch> &print(std::basic_ostream<Ch> &out, const xml_node<Ch> &node, int flags = 0)

    {

        print(std::ostream_iterator<Ch>(out), node, flags);

        return out;

    }



    //! Prints formatted XML to given output stream. Uses default printing flags. Use print() function to customize printing process.

    //! \param out Output stream to print to.

    //! \param node Node to be printed.

    //! \return Output stream.

    template<class Ch> 

    inline std::basic_ostream<Ch> &operator <<(std::basic_ostream<Ch> &out, const xml_node<Ch> &node)

    {

        return print(out, node);

    }



#endif



}



#endif

main.cpp

#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <functional>
#include <memory>
#include <sstream>
using namespace std;

//下面三个文件是本段代码需要的库文件
#include "rapidxml/rapidxml.hpp"
#include "rapidxml/rapidxml_utils.hpp"
#include "rapidxml/rapidxml_print.hpp"
 

using namespace rapidxml;

int CreateXml();
int ReadAndChangeXml();

int main()
{
    CreateXml();
    ReadAndChangeXml();
    cout << "hello" << endl;
    return 0;
}
//创建一个名称为config.xml文件
int CreateXml()
{
    xml_document<> doc;  
    xml_node<>* rot = doc.allocate_node(rapidxml::node_pi,doc.allocate_string("xml version='1.0' encoding='utf-8'"));
    doc.append_node(rot);
    xml_node<>* node =   doc.allocate_node(node_element,"config","information");  
    xml_node<>* color =   doc.allocate_node(node_element,"color",NULL);  
    doc.append_node(node);
    node->append_node(color);
    color->append_node(doc.allocate_node(node_element,"red","0.1"));
    color->append_node(doc.allocate_node(node_element,"green","0.1"));
    color->append_node(doc.allocate_node(node_element,"blue","0.1"));
    color->append_node(doc.allocate_node(node_element,"alpha","1.0"));
 
    xml_node<>* size =   doc.allocate_node(node_element,"size",NULL); 
    size->append_node(doc.allocate_node(node_element,"x","640"));
    size->append_node(doc.allocate_node(node_element,"y","480"));
    node->append_node(size);
 
    xml_node<>* mode = doc.allocate_node(rapidxml::node_element,"mode","screen mode");
    mode->append_attribute(doc.allocate_attribute("fullscreen","false"));
    node->append_node(mode);
 
    std::string text;  
    rapidxml::print(std::back_inserter(text), doc, 0);  
 
    std::cout<<text<<std::endl; 
 
    std::ofstream out("config.xml");
    out << doc;
}

//读取并修改config.xml
int ReadAndChangeXml()
{
     file<> fdoc("config.xml");
    std::cout<<fdoc.data()<<std::endl;
    xml_document<>   doc;
    doc.parse<0>(fdoc.data());
 
    std::cout<<doc.name()<<std::endl;


     //! 获取根节点
     rapidxml::xml_node<>* root = doc.first_node();
    std::cout<<root->name()<<std::endl;
    //! 获取根节点第一个节点
    rapidxml::xml_node<>* node1 = root->first_node();
    std::cout<<node1->name()<<std::endl;
    rapidxml::xml_node<>* node11 = node1->first_node();
    std::cout<<node11->name()<<std::endl;
    std::cout<<node11->value()<<std::endl;
    
     //! 添加之后再次保存
    //需要说明的是rapidxml明显有一个bug
    //那就是append_node(doc.allocate_node(node_element,"h","0"));的时候并不考虑该对象是否存在!
    xml_node<>* size = root->first_node("size");
    size->append_node(doc.allocate_node(node_element,"w","0"));
    size->append_node(doc.allocate_node(node_element,"h","0"));
 
    std::string text;
    rapidxml::print(std::back_inserter(text),doc,0);
 
    std::cout<<text<<std::endl;
 
    std::ofstream out("config.xml");
    out << doc;

}

编译:
g++ main.cpp -std=gnu++0x

转载于:https://www.cnblogs.com/shuqingstudy/p/11342991.html

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/160926.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(0)


相关推荐

  • https和http有什么区别(内附详细分析)

    https和http有什么区别(内附详细分析)很多站长知道https和http有所不同,但是究竟两者有什么不同浑然不知,针对这种情况,本文给大家详细分析一下https和http有什么区别。一、基本概念(http服务器–>本地浏览器,正确快速传输;https安全套接字层,http的安全版本,http+ssl层,建立一个信息安全的通道,保证数据传输的安全,确认网站的真实性)1、HTTP:超文本传输协议(HyperTextTransferProtocol)。是互联网上应用最为广泛的一种网络协议,所有的www文件都必须遵守这个…

    2022年10月16日
  • python fileinput_Python中fileinput模块

    python fileinput_Python中fileinput模块fileinput模块可以对一个或多个文件中的内容进行迭代、遍历等操作。该模块的input()函数有点类似文件readlines()方法,区别在于:前者是一个迭代对象,即每次只生成一行,需要用for循环迭代。后者是一次性读取所有行。在碰到大文件的读取时,前者无疑效率更高效。用fileinput对文件进行循环遍历,格式化输出,查找、替换等操作,非常方便。【典型用法】importfileinputf…

  • Matlab中axis函数使用

    Matlab中axis函数使用目录一.语法1.输入参数2.输出参数二.说明三.示例1.设置坐标轴范围2.使用半自动坐标轴范围3.设置多个坐标轴的坐标轴范围4.显示绘图而不显示坐标区背景5.使用紧凑的坐标轴范围并返回值6.更改坐标系的方向7.添加新绘图时保留当前的坐标轴范围axis函数是设置坐标轴范围和纵横比。一.语法axis(limits)axisstyleaxismodeaxisydirectionaxisvisibility

  • 内网IP段有哪些_为什么有些内网使用公网地址段

    内网IP段有哪些_为什么有些内网使用公网地址段常见的内网IP段有:10.0.0.0/810.0.0.0-10.255.255.255172.16.0.0/12172.16.0.0-172.31.255.255192.168.0.0/16192.168.0.0-192.168.255.255以上三个网段分别属于A、B、C三类IP地址,来自《RFC1918》。但是根据《ReservedIPaddresses-Wikipedia,thefreeencyclopedia》及《RFC6890-Special

  • Vue(6)v-on指令的使用[通俗易懂]

    Vue(6)v-on指令的使用[通俗易懂]v-on监听事件可以用v-on指令监听DOM事件,并在触发时运行一些JavaScript代码。事件代码可以直接放到v-on后面,也可以写成一个函数。示例代码如下:<divid

  • js正则使用变量_js正则表达式语法大全

    js正则使用变量_js正则表达式语法大全正常有变量evalnewRegExp

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号