xml_node< Ch >

#include <rapidxml.hpp>

Inheritance diagram for xml_node< Ch >:

Collaboration diagram for xml_node< Ch >:

Public Member Functions
	xml_node (node_type type)
node_type	type () const
xml_document< Ch > *	document () const
xml_node< Ch > *	first_node (const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const
xml_node< Ch > *	last_node (const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const
xml_node< Ch > *	previous_sibling (const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const
xml_node< Ch > *	next_sibling (const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const
xml_attribute< Ch > *	first_attribute (const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const
xml_attribute< Ch > *	last_attribute (const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const
void	type (node_type type)
void	prepend_node (xml_node< Ch > *child)
void	append_node (xml_node< Ch > *child)
void	insert_node (xml_node< Ch > *where, xml_node< Ch > *child)
void	remove_first_node ()
void	remove_last_node ()
void	remove_node (xml_node< Ch > *where)
	Removes specified child from the node. More...
void	remove_all_nodes ()
	Removes all child nodes (but not attributes). More...
void	prepend_attribute (xml_attribute< Ch > *attribute)
void	append_attribute (xml_attribute< Ch > *attribute)
void	insert_attribute (xml_attribute< Ch > *where, xml_attribute< Ch > *attribute)
void	remove_first_attribute ()
void	remove_last_attribute ()
void	remove_attribute (xml_attribute< Ch > *where)
void	remove_all_attributes ()
	Removes all attributes of node. More...
Ch *	name () const
void	name (const Ch *name, std::size_t size)
void	name (const Ch *name)
std::size_t	name_size () const
Ch *	value () const
void	value (const Ch *value, std::size_t size)
void	value (const Ch *value)
std::size_t	value_size () const
xml_node< Ch > *	parent () const

Static Protected Member Functions
static Ch *	nullstr ()

Protected Attributes
Ch *	m_name
Ch *	m_value
std::size_t	m_name_size
std::size_t	m_value_size
xml_node< Ch > *	m_parent

Private Member Functions
	xml_node (const xml_node &)
void	operator= (const xml_node &)

Private Attributes
node_type	m_type
xml_node< Ch > *	m_first_node
xml_node< Ch > *	m_last_node
xml_attribute< Ch > *	m_first_attribute
xml_attribute< Ch > *	m_last_attribute
xml_node< Ch > *	m_prev_sibling
xml_node< Ch > *	m_next_sibling

Detailed Description

template<class Ch = char>
class rapidxml::xml_node< Ch >

Class representing a node of XML document. Each node may have associated name and value strings, which are available through name() and value() functions. Interpretation of name and value depends on type of the node. Type of node can be determined by using type() function.

Note that after parse, both name and value of node, if any, will point interior of source text used for parsing. Thus, this text must persist in the memory for the lifetime of node.

Parameters

Ch	Character type to use.

Definition at line 137 of file rapidxml.hpp.

Constructor & Destructor Documentation

xml_node() [1/2]

xml_node ( node_type  type )

inline

Constructs an empty node with the specified type. Consider using memory_pool of appropriate document to allocate nodes manually.

Parameters

type	Type of node to construct.

Definition at line 901 of file rapidxml.hpp.

            : m_type(type)
            , m_first_node(0)
            , m_first_attribute(0)
        {
        }

xml_node() [2/2]

xml_node ( const xml_node< Ch > &  )

private

Member Function Documentation

append_attribute()

void append_attribute ( xml_attribute< Ch > *  attribute )

inline

Appends a new attribute to the node.

Parameters

attribute

Attribute to append.

Definition at line 1217 of file rapidxml.hpp.

        {
            assert(attribute && !attribute->parent());
            if (first_attribute())
            {
                attribute->m_prev_attribute = m_last_attribute;
                m_last_attribute->m_next_attribute = attribute;
            }
            else
            {
                attribute->m_prev_attribute = 0;
                m_first_attribute = attribute;
            }
            m_last_attribute = attribute;
            attribute->m_parent = this;
            attribute->m_next_attribute = 0;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

append_node()

void append_node ( xml_node< Ch > *  child )

inline

Appends a new child node. The appended child becomes the last child.

Parameters

child

Node to append.

Definition at line 1097 of file rapidxml.hpp.

        {
            assert(child && !child->parent() && child->type() != node_document);
            if (first_node())
            {
                child->m_prev_sibling = m_last_node;
                m_last_node->m_next_sibling = child;
            }
            else
            {
                child->m_prev_sibling = 0;
                m_first_node = child;
            }
            m_last_node = child;
            child->m_parent = this;
            child->m_next_sibling = 0;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

document()

xml_document<Ch>* document ( ) const

inline

Gets document of which node is a child.

Returns

Pointer to document that contains this node, or 0 if there is no parent document.

Definition at line 923 of file rapidxml.hpp.

        {
            xml_node<Ch> *node = const_cast<xml_node<Ch> *>(this);
            while (node->parent())
                node = node->parent();
            return node->type() == node_document ? static_cast<xml_document<Ch> *>(node) : 0;
        }

Here is the call graph for this function:

first_attribute()

xml_attribute<Ch>* first_attribute ( const Ch *  name = 0, std::size_t  name_size = 0, bool  case_sensitive = true  ) const

inline

Gets first attribute of node, optionally matching attribute name.

Parameters

name	Name of attribute to find, or 0 to return first attribute regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
name_size	Size of name, in characters, or 0 to have size calculated automatically from string
case_sensitive	Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters

Returns

Pointer to found attribute, or 0 if not found.

Definition at line 1025 of file rapidxml.hpp.

        {
            if (name)
            {
                if (name_size == 0)
                    name_size = internal::measure(name);
                for (xml_attribute<Ch> *attribute = m_first_attribute; attribute; attribute = attribute->m_next_attribute)
                    if (internal::compare(attribute->name(), attribute->name_size(), name, name_size, case_sensitive))
                        return attribute;
                return 0;
            }
            else
                return m_first_attribute;
        }

Here is the caller graph for this function:

first_node()

xml_node<Ch>* first_node ( const Ch *  name = 0, std::size_t  name_size = 0, bool  case_sensitive = true  ) const

inline

Gets first child node, optionally matching node name.

Parameters

name	Name of child to find, or 0 to return first child regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
name_size	Size of name, in characters, or 0 to have size calculated automatically from string
case_sensitive	Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters

Returns

Pointer to found child, or 0 if not found.

Definition at line 936 of file rapidxml.hpp.

        {
            if (name)
            {
                if (name_size == 0)
                    name_size = internal::measure(name);
                for (xml_node<Ch> *child = m_first_node; child; child = child->next_sibling())
                    if (internal::compare(child->name(), child->name_size(), name, name_size, case_sensitive))
                        return child;
                return 0;
            }
            else
                return m_first_node;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

insert_attribute()

void insert_attribute ( xml_attribute< Ch > *  where, xml_attribute< Ch > *  attribute  )

inline

Inserts a new attribute at specified place inside the node. All attributes after and including the specified attribute are moved one position back.

Parameters

where	Place where to insert the attribute, or 0 to insert at the back.
attribute	Attribute to insert.

Definition at line 1239 of file rapidxml.hpp.

        {
            assert(!where || where->parent() == this);
            assert(attribute && !attribute->parent());
            if (where == m_first_attribute)
                prepend_attribute(attribute);
            else if (where == 0)
                append_attribute(attribute);
            else
            {
                attribute->m_prev_attribute = where->m_prev_attribute;
                attribute->m_next_attribute = where;
                where->m_prev_attribute->m_next_attribute = attribute;
                where->m_prev_attribute = attribute;
                attribute->m_parent = this;
            }
        }

Here is the call graph for this function:

insert_node()

void insert_node ( xml_node< Ch > *  where, xml_node< Ch > *  child  )

inline

Inserts a new child node at specified place inside the node. All children after and including the specified node are moved one position back.

Parameters

where	Place where to insert the child, or 0 to insert at the back.
child	Node to insert.

Definition at line 1119 of file rapidxml.hpp.

        {
            assert(!where || where->parent() == this);
            assert(child && !child->parent() && child->type() != node_document);
            if (where == m_first_node)
                prepend_node(child);
            else if (where == 0)
                append_node(child);
            else
            {
                child->m_prev_sibling = where->m_prev_sibling;
                child->m_next_sibling = where;
                where->m_prev_sibling->m_next_sibling = child;
                where->m_prev_sibling = child;
                child->m_parent = this;
            }
        }

Here is the call graph for this function:

last_attribute()

xml_attribute<Ch>* last_attribute ( const Ch *  name = 0, std::size_t  name_size = 0, bool  case_sensitive = true  ) const

inline

Gets last attribute of node, optionally matching attribute name.

Parameters

name	Name of attribute to find, or 0 to return last attribute regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
name_size	Size of name, in characters, or 0 to have size calculated automatically from string
case_sensitive	Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters

Returns

Pointer to found attribute, or 0 if not found.

Definition at line 1045 of file rapidxml.hpp.

        {
            if (name)
            {
                if (name_size == 0)
                    name_size = internal::measure(name);
                for (xml_attribute<Ch> *attribute = m_last_attribute; attribute; attribute = attribute->m_prev_attribute)
                    if (internal::compare(attribute->name(), attribute->name_size(), name, name_size, case_sensitive))
                        return attribute;
                return 0;
            }
            else
                return m_first_attribute ? m_last_attribute : 0;
        }

last_node()

xml_node<Ch>* last_node ( const Ch *  name = 0, std::size_t  name_size = 0, bool  case_sensitive = true  ) const

inline

Gets last child node, optionally matching node name. Behaviour is undefined if node has no children. Use first_node() to test if node has children.

Parameters

name	Name of child to find, or 0 to return last child regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
name_size	Size of name, in characters, or 0 to have size calculated automatically from string
case_sensitive	Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters

Returns

Pointer to found child, or 0 if not found.

Definition at line 958 of file rapidxml.hpp.

        {
            assert(m_first_node);  // Cannot query for last child if node has no children
            if (name)
            {
                if (name_size == 0)
                    name_size = internal::measure(name);
                for (xml_node<Ch> *child = m_last_node; child; child = child->previous_sibling())
                    if (internal::compare(child->name(), child->name_size(), name, name_size, case_sensitive))
                        return child;
                return 0;
            }
            else
                return m_last_node;
        }

Here is the call graph for this function:

name() [1/3]

Ch* name ( ) const

inlineinherited

Gets name of the node. Interpretation of name depends on type of node. Note that name will not be zero-terminated if rapidxml::parse_no_string_terminators option was selected during parse.

Use name_size() function to determine length of the name.

Returns

Name of node, or empty string if node has no name.

Definition at line 673 of file rapidxml.hpp.

        {
            return m_name ? m_name : nullstr();
        }

Here is the caller graph for this function:

name() [2/3]

void name ( const Ch *  name, std::size_t  size  )

inlineinherited

Sets name of node to a non zero-terminated string. See ownership_of_strings.

Note that node does not own its name or value, it only stores a pointer to it. It will not delete or otherwise free the pointer on destruction. It is reponsibility of the user to properly manage lifetime of the string. The easiest way to achieve it is to use memory_pool of the document to allocate the string - on destruction of the document the string will be automatically freed.

Size of name must be specified separately, because name does not have to be zero terminated. Use name(const Ch *) function to have the length automatically calculated (string must be zero terminated).

Parameters

name	Name of node to set. Does not have to be zero terminated.
size	Size of name, in characters. This does not include zero terminator, if one is present.

Definition at line 721 of file rapidxml.hpp.

        {
            m_name = const_cast<Ch *>(name);
            m_name_size = size;
        }

name() [3/3]

void name ( const Ch *  name )

inlineinherited

Sets name of node to a zero-terminated string. See also ownership_of_strings and xml_node::name(const Ch *, std::size_t).

Parameters

name	Name of node to set. Must be zero terminated.

Definition at line 730 of file rapidxml.hpp.

        {
            this->name(name, internal::measure(name));
        }

name_size()

std::size_t name_size ( ) const

inlineinherited

Gets size of node name, not including terminator character. This function works correctly irrespective of whether name is or is not zero terminated.

Returns

Size of node name, in characters.

Definition at line 681 of file rapidxml.hpp.

        {
            return m_name ? m_name_size : 0;
        }

Here is the caller graph for this function:

next_sibling()

xml_node<Ch>* next_sibling ( const Ch *  name = 0, std::size_t  name_size = 0, bool  case_sensitive = true  ) const

inline

Gets next sibling node, optionally matching node name. Behaviour is undefined if node has no parent. Use parent() to test if node has a parent.

Parameters

name	Name of sibling to find, or 0 to return next sibling regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
name_size	Size of name, in characters, or 0 to have size calculated automatically from string
case_sensitive	Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters

Returns

Pointer to found sibling, or 0 if not found.

Definition at line 1004 of file rapidxml.hpp.

        {
            assert(this->m_parent);     // Cannot query for siblings if node has no parent
            if (name)
            {
                if (name_size == 0)
                    name_size = internal::measure(name);
                for (xml_node<Ch> *sibling = m_next_sibling; sibling; sibling = sibling->m_next_sibling)
                    if (internal::compare(sibling->name(), sibling->name_size(), name, name_size, case_sensitive))
                        return sibling;
                return 0;
            }
            else
                return m_next_sibling;
        }

Here is the caller graph for this function:

nullstr()

static Ch* nullstr ( )

inlinestaticprotectedinherited

Definition at line 778 of file rapidxml.hpp.

        {
            static Ch zero = Ch('\0');
            return &zero;
        }

operator=()

void operator= ( const xml_node< Ch > &  )

private

parent()

xml_node<Ch>* parent ( ) const

inlineinherited

Gets node parent.

Returns

Pointer to parent node, or 0 if there is no parent.

Definition at line 770 of file rapidxml.hpp.

        {
            return m_parent;
        }

Here is the caller graph for this function:

prepend_attribute()

void prepend_attribute ( xml_attribute< Ch > *  attribute )

inline

Prepends a new attribute to the node.

Parameters

attribute

Attribute to prepend.

Definition at line 1197 of file rapidxml.hpp.

        {
            assert(attribute && !attribute->parent());
            if (first_attribute())
            {
                attribute->m_next_attribute = m_first_attribute;
                m_first_attribute->m_prev_attribute = attribute;
            }
            else
            {
                attribute->m_next_attribute = 0;
                m_last_attribute = attribute;
            }
            m_first_attribute = attribute;
            attribute->m_parent = this;
            attribute->m_prev_attribute = 0;
        }

Here is the call graph for this function:

prepend_node()

void prepend_node ( xml_node< Ch > *  child )

inline

Prepends a new child node. The prepended child becomes the first child, and all existing children are moved one position back.

Parameters

child

Node to prepend.

Definition at line 1076 of file rapidxml.hpp.

        {
            assert(child && !child->parent() && child->type() != node_document);
            if (first_node())
            {
                child->m_next_sibling = m_first_node;
                m_first_node->m_prev_sibling = child;
            }
            else
            {
                child->m_next_sibling = 0;
                m_last_node = child;
            }
            m_first_node = child;
            child->m_parent = this;
            child->m_prev_sibling = 0;
        }

Here is the call graph for this function:

previous_sibling()

xml_node<Ch>* previous_sibling ( const Ch *  name = 0, std::size_t  name_size = 0, bool  case_sensitive = true  ) const

inline

Gets previous sibling node, optionally matching node name. Behaviour is undefined if node has no parent. Use parent() to test if node has a parent.

Parameters

name	Name of sibling to find, or 0 to return previous sibling regardless of its name; this string doesn't have to be zero-terminated if name_size is non-zero
name_size	Size of name, in characters, or 0 to have size calculated automatically from string
case_sensitive	Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters

Returns

Pointer to found sibling, or 0 if not found.

Definition at line 981 of file rapidxml.hpp.

        {
            assert(this->m_parent);     // Cannot query for siblings if node has no parent
            if (name)
            {
                if (name_size == 0)
                    name_size = internal::measure(name);
                for (xml_node<Ch> *sibling = m_prev_sibling; sibling; sibling = sibling->m_prev_sibling)
                    if (internal::compare(sibling->name(), sibling->name_size(), name, name_size, case_sensitive))
                        return sibling;
                return 0;
            }
            else
                return m_prev_sibling;
        }

Here is the caller graph for this function:

remove_all_attributes()

void remove_all_attributes ( )

inline

Removes all attributes of node.

Definition at line 1309 of file rapidxml.hpp.

        {
            for (xml_attribute<Ch> *attribute = first_attribute(); attribute; attribute = attribute->m_next_attribute)
                attribute->m_parent = 0;
            m_first_attribute = 0;
        }

remove_all_nodes()

void remove_all_nodes ( )

inline

Removes all child nodes (but not attributes).

Definition at line 1188 of file rapidxml.hpp.

        {
            for (xml_node<Ch> *node = first_node(); node; node = node->m_next_sibling)
                node->m_parent = 0;
            m_first_node = 0;
        }

remove_attribute()

void remove_attribute ( xml_attribute< Ch > *  where )

inline

Removes specified attribute from node.

Parameters

where

Pointer to attribute to be removed.

Definition at line 1293 of file rapidxml.hpp.

        {
            assert(first_attribute() && where->parent() == this);
            if (where == m_first_attribute)
                remove_first_attribute();
            else if (where == m_last_attribute)
                remove_last_attribute();
            else
            {
                where->m_prev_attribute->m_next_attribute = where->m_next_attribute;
                where->m_next_attribute->m_prev_attribute = where->m_prev_attribute;
                where->m_parent = 0;
            }
        }

Here is the call graph for this function:

remove_first_attribute()

void remove_first_attribute ( )

inline

Removes first attribute of the node. If node has no attributes, behaviour is undefined. Use first_attribute() to test if node has attributes.

Definition at line 1260 of file rapidxml.hpp.

        {
            assert(first_attribute());
            xml_attribute<Ch> *attribute = m_first_attribute;
            if (attribute->m_next_attribute)
            {
                attribute->m_next_attribute->m_prev_attribute = 0;
            }
            else
                m_last_attribute = 0;
            attribute->m_parent = 0;
            m_first_attribute = attribute->m_next_attribute;
        }

remove_first_node()

void remove_first_node ( )

inline

Removes first child node. If node has no children, behaviour is undefined. Use first_node() to test if node has children.

Definition at line 1140 of file rapidxml.hpp.

        {
            assert(first_node());
            xml_node<Ch> *child = m_first_node;
            m_first_node = child->m_next_sibling;
            if (child->m_next_sibling)
                child->m_next_sibling->m_prev_sibling = 0;
            else
                m_last_node = 0;
            child->m_parent = 0;
        }

remove_last_attribute()

void remove_last_attribute ( )

inline

Removes last attribute of the node. If node has no attributes, behaviour is undefined. Use first_attribute() to test if node has attributes.

Definition at line 1277 of file rapidxml.hpp.

        {
            assert(first_attribute());
            xml_attribute<Ch> *attribute = m_last_attribute;
            if (attribute->m_prev_attribute)
            {
                attribute->m_prev_attribute->m_next_attribute = 0;
                m_last_attribute = attribute->m_prev_attribute;
            }
            else
                m_first_attribute = 0;
            attribute->m_parent = 0;
        }

remove_last_node()

void remove_last_node ( )

inline

Removes last child of the node. If node has no children, behaviour is undefined. Use first_node() to test if node has children.

Definition at line 1155 of file rapidxml.hpp.

        {
            assert(first_node());
            xml_node<Ch> *child = m_last_node;
            if (child->m_prev_sibling)
            {
                m_last_node = child->m_prev_sibling;
                child->m_prev_sibling->m_next_sibling = 0;
            }
            else
                m_first_node = 0;
            child->m_parent = 0;
        }

remove_node()

void remove_node ( xml_node< Ch > *  where )

inline

Removes specified child from the node.

Definition at line 1171 of file rapidxml.hpp.

        {
            assert(where && where->parent() == this);
            assert(first_node());
            if (where == m_first_node)
                remove_first_node();
            else if (where == m_last_node)
                remove_last_node();
            else
            {
                where->m_prev_sibling->m_next_sibling = where->m_next_sibling;
                where->m_next_sibling->m_prev_sibling = where->m_prev_sibling;
                where->m_parent = 0;
            }
        }

Here is the call graph for this function:

type() [1/2]

node_type type ( ) const

inline

Gets type of node.

Returns

Type of node.

Definition at line 913 of file rapidxml.hpp.

        {
            return m_type;
        }

Here is the caller graph for this function:

type() [2/2]

void type ( node_type  type )

inline

Sets type of node.

Parameters

type	Type of node to set.

Definition at line 1065 of file rapidxml.hpp.

        {
            m_type = type;
        }

value() [1/3]

Ch* value ( ) const

inlineinherited

Gets value of node. Interpretation of value depends on type of node. Note that value will not be zero-terminated if rapidxml::parse_no_string_terminators option was selected during parse.

Use value_size() function to determine length of the value.

Returns

Value of node, or empty string if node has no value.

Definition at line 692 of file rapidxml.hpp.

        {
            return m_value ? m_value : nullstr();
        }

Here is the caller graph for this function:

value() [2/3]

void value ( const Ch *  value, std::size_t  size  )

inlineinherited

Sets value of node to a non zero-terminated string. See ownership_of_strings.

Note that node does not own its name or value, it only stores a pointer to it. It will not delete or otherwise free the pointer on destruction. It is reponsibility of the user to properly manage lifetime of the string. The easiest way to achieve it is to use memory_pool of the document to allocate the string - on destruction of the document the string will be automatically freed.

Size of value must be specified separately, because it does not have to be zero terminated. Use value(const Ch *) function to have the length automatically calculated (string must be zero terminated).

If an element has a child node of type node_data, it will take precedence over element value when printing. If you want to manipulate data of elements using values, use parser flag rapidxml::parse_no_data_nodes to prevent creation of data nodes by the parser.

Parameters

value	value of node to set. Does not have to be zero terminated.
size	Size of value, in characters. This does not include zero terminator, if one is present.

Definition at line 751 of file rapidxml.hpp.

        {
            m_value = const_cast<Ch *>(value);
            m_value_size = size;
        }

value() [3/3]

void value ( const Ch *  value )

inlineinherited

Sets value of node to a zero-terminated string. See also ownership_of_strings and xml_node::value(const Ch *, std::size_t).

Parameters

value

Vame of node to set. Must be zero terminated.

Definition at line 760 of file rapidxml.hpp.

        {
            this->value(value, internal::measure(value));
        }

value_size()

std::size_t value_size ( ) const

inlineinherited

Gets size of node value, not including terminator character. This function works correctly irrespective of whether value is or is not zero terminated.

Returns

Size of node value, in characters.

Definition at line 700 of file rapidxml.hpp.

        {
            return m_value ? m_value_size : 0;
        }

Here is the caller graph for this function:

Member Data Documentation

m_first_attribute

xml_attribute<Ch>* m_first_attribute

private

Definition at line 1340 of file rapidxml.hpp.

m_first_node

xml_node<Ch>* m_first_node

private

Definition at line 1338 of file rapidxml.hpp.

m_last_attribute

xml_attribute<Ch>* m_last_attribute

private

Definition at line 1341 of file rapidxml.hpp.

m_last_node

xml_node<Ch>* m_last_node

private

Definition at line 1339 of file rapidxml.hpp.

m_name

Ch* m_name

protectedinherited

Definition at line 784 of file rapidxml.hpp.

m_name_size

std::size_t m_name_size

protectedinherited

Definition at line 786 of file rapidxml.hpp.

m_next_sibling

xml_node<Ch>* m_next_sibling

private

Definition at line 1343 of file rapidxml.hpp.

m_parent

xml_node<Ch>* m_parent

protectedinherited

Definition at line 788 of file rapidxml.hpp.

m_prev_sibling

xml_node<Ch>* m_prev_sibling

private

Definition at line 1342 of file rapidxml.hpp.

m_type

node_type m_type

private

Definition at line 1337 of file rapidxml.hpp.

m_value

Ch* m_value

protectedinherited

Definition at line 785 of file rapidxml.hpp.

m_value_size

std::size_t m_value_size

protectedinherited

Definition at line 787 of file rapidxml.hpp.

---

The documentation for this class was generated from the following file:

• Rapidxml/rapidxml.hpp