xml_document< Ch >

#include <rapidxml.hpp>

Inheritance diagram for xml_document< Ch >:

Collaboration diagram for xml_document< Ch >:

Classes
struct	attribute_name_pred
struct	attribute_value_pred
struct	attribute_value_pure_pred
struct	node_name_pred
struct	text_pred
struct	text_pure_no_ws_pred
struct	text_pure_with_ws_pred
struct	whitespace_pred

Public Member Functions
	xml_document ()
	Constructs empty XML document. More...
template<int Flags>
void	parse (Ch *text)
void	clear ()
node_type	type () const
void	type (node_type type)
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	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
xml_node< Ch > *	allocate_node (node_type type, const Ch *name=0, const Ch *value=0, std::size_t name_size=0, std::size_t value_size=0)
xml_attribute< Ch > *	allocate_attribute (const Ch *name=0, const Ch *value=0, std::size_t name_size=0, std::size_t value_size=0)
Ch *	allocate_string (const Ch *source=0, std::size_t size=0)
xml_node< Ch > *	clone_node (const xml_node< Ch > *source, xml_node< Ch > *result=0)
void	set_allocator (alloc_func *af, free_func *ff)

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
template<int Flags>
void	parse_bom (Ch *&text)
template<int Flags>
xml_node< Ch > *	parse_xml_declaration (Ch *&text)
template<int Flags>
xml_node< Ch > *	parse_comment (Ch *&text)
template<int Flags>
xml_node< Ch > *	parse_doctype (Ch *&text)
template<int Flags>
xml_node< Ch > *	parse_pi (Ch *&text)
template<int Flags>
Ch	parse_and_append_data (xml_node< Ch > *node, Ch *&text, Ch *contents_start)
template<int Flags>
xml_node< Ch > *	parse_cdata (Ch *&text)
template<int Flags>
xml_node< Ch > *	parse_element (Ch *&text)
template<int Flags>
xml_node< Ch > *	parse_node (Ch *&text)
template<int Flags>
void	parse_node_contents (Ch *&text, xml_node< Ch > *node)
template<int Flags>
void	parse_node_attributes (Ch *&text, xml_node< Ch > *node)

Static Private Member Functions
template<int Flags>
static void	insert_coded_character (Ch *&text, unsigned long code)
template<class StopPred , int Flags>
static void	skip (Ch *&text)
template<class StopPred , class StopPredPure , int Flags>
static Ch *	skip_and_expand_character_refs (Ch *&text)

Detailed Description

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

This class represents root of the DOM hierarchy. It is also an xml_node and a memory_pool through public inheritance. Use parse() function to build a DOM tree from a zero-terminated XML text string. parse() function allocates memory for nodes and attributes by using functions of xml_document, which are inherited from memory_pool. To access root node of the document, use the document itself, as if it was an xml_node.

Parameters

Ch	Character type to use.

Definition at line 139 of file rapidxml.hpp.

Constructor & Destructor Documentation

xml_document()

xml_document ( )

inline

Constructs empty XML document.

Definition at line 1364 of file rapidxml.hpp.

            : xml_node<Ch>(node_document)
        {
        }

Member Function Documentation

allocate_attribute()

xml_attribute<Ch>* allocate_attribute ( const Ch *  name = 0, const Ch *  value = 0, std::size_t  name_size = 0, std::size_t  value_size = 0  )

inlineinherited

Allocates a new attribute from the pool, and optionally assigns name and value to it. If the allocation request cannot be accomodated, this function will throw std::bad_alloc. If exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, this function will call rapidxml::parse_error_handler() function.

Parameters

name	Name to assign to the attribute, or 0 to assign no name.
value	Value to assign to the attribute, or 0 to assign no value.
name_size	Size of name to assign, or 0 to automatically calculate size from name string.
value_size	Size of value to assign, or 0 to automatically calculate size from value string.

Returns

Pointer to allocated attribute. This pointer will never be NULL.

Definition at line 447 of file rapidxml.hpp.

        {
            void *memory = allocate_aligned(sizeof(xml_attribute<Ch>));
            xml_attribute<Ch> *attribute = new(memory) xml_attribute<Ch>;
            if (name)
            {
                if (name_size > 0)
                    attribute->name(name, name_size);
                else
                    attribute->name(name);
            }
            if (value)
            {
                if (value_size > 0)
                    attribute->value(value, value_size);
                else
                    attribute->value(value);
            }
            return attribute;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

allocate_node()

xml_node<Ch>* allocate_node ( node_type  type, const Ch *  name = 0, const Ch *  value = 0, std::size_t  name_size = 0, std::size_t  value_size = 0  )

inlineinherited

Allocates a new node from the pool, and optionally assigns name and value to it. If the allocation request cannot be accomodated, this function will throw std::bad_alloc. If exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, this function will call rapidxml::parse_error_handler() function.

Parameters

type	Type of node to create.
name	Name to assign to the node, or 0 to assign no name.
value	Value to assign to the node, or 0 to assign no value.
name_size	Size of name to assign, or 0 to automatically calculate size from name string.
value_size	Size of value to assign, or 0 to automatically calculate size from value string.

Returns

Pointer to allocated node. This pointer will never be NULL.

Definition at line 415 of file rapidxml.hpp.

        {
            void *memory = allocate_aligned(sizeof(xml_node<Ch>));
            xml_node<Ch> *node = new(memory) xml_node<Ch>(type);
            if (name)
            {
                if (name_size > 0)
                    node->name(name, name_size);
                else
                    node->name(name);
            }
            if (value)
            {
                if (value_size > 0)
                    node->value(value, value_size);
                else
                    node->value(value);
            }
            return node;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

allocate_string()

Ch* allocate_string ( const Ch *  source = 0, std::size_t  size = 0  )

inlineinherited

Allocates a char array of given size from the pool, and optionally copies a given string to it. If the allocation request cannot be accomodated, this function will throw std::bad_alloc. If exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, this function will call rapidxml::parse_error_handler() function.

Parameters

source	String to initialize the allocated memory with, or 0 to not initialize it.
size	Number of characters to allocate, or zero to calculate it automatically from source string length; if size is 0, source string must be specified and null terminated.

Returns

Pointer to allocated char array. This pointer will never be NULL.

Definition at line 476 of file rapidxml.hpp.

        {
            assert(source || size);     // Either source or size (or both) must be specified
            if (size == 0)
                size = internal::measure(source) + 1;
            Ch *result = static_cast<Ch *>(allocate_aligned(size * sizeof(Ch)));
            if (source)
                for (std::size_t i = 0; i < size; ++i)
                    result[i] = source[i];
            return result;
        }

Here is the caller graph for this function:

append_attribute()

void append_attribute ( xml_attribute< Ch > *  attribute )

inlineinherited

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 )

inlineinherited

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:

clear()

void clear ( )

inline

Clears the document by deleting all nodes and clearing the memory pool. All nodes owned by document pool are destroyed.

Definition at line 1415 of file rapidxml.hpp.

        {
            this->remove_all_nodes();
            this->remove_all_attributes();
            memory_pool<Ch>::clear();
        }

Here is the call graph for this function:

Here is the caller graph for this function:

clone_node()

xml_node<Ch>* clone_node ( const xml_node< Ch > *  source, xml_node< Ch > *  result = 0  )

inlineinherited

Clones an xml_node and its hierarchy of child nodes and attributes. Nodes and attributes are allocated from this memory pool. Names and values are not cloned, they are shared between the clone and the source. Result node can be optionally specified as a second parameter, in which case its contents will be replaced with cloned source node. This is useful when you want to clone entire document.

Parameters

source	Node to clone.
result	Node to put results in, or 0 to automatically allocate result node

Returns

Pointer to cloned node. This pointer will never be NULL.

Definition at line 497 of file rapidxml.hpp.

        {
            // Prepare result node
            if (result)
            {
                result->remove_all_attributes();
                result->remove_all_nodes();
                result->type(source->type());
            }
            else
                result = allocate_node(source->type());

            // Clone name and value
            result->name(source->name(), source->name_size());
            result->value(source->value(), source->value_size());

            // Clone child nodes and attributes
            for (xml_node<Ch> *child = source->first_node(); child; child = child->next_sibling())
                result->append_node(clone_node(child));
            for (xml_attribute<Ch> *attr = source->first_attribute(); attr; attr = attr->next_attribute())
                result->append_attribute(allocate_attribute(attr->name(), attr->value(), attr->name_size(), attr->value_size()));

            return result;
        }

Here is the call graph for this function:

document()

xml_document<Ch>* document ( ) const

inlineinherited

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

inlineinherited

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

inlineinherited

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  )

inlineinherited

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_coded_character()

static void insert_coded_character ( Ch *&  text, unsigned long  code  )

inlinestaticprivate

Definition at line 1511 of file rapidxml.hpp.

        {
            if (Flags & parse_no_utf8)
            {
                // Insert 8-bit ASCII character
                // Todo: possibly verify that code is less than 256 and use replacement char otherwise?
                text[0] = static_cast<unsigned char>(code);
                text += 1;
            }
            else
            {
                // Insert UTF8 sequence
                if (code < 0x80)    // 1 byte sequence
                {
                    text[0] = static_cast<unsigned char>(code);
                    text += 1;
                }
                else if (code < 0x800)  // 2 byte sequence
                {
                    text[1] = static_cast<unsigned char>((code | 0x80) & 0xBF); code >>= 6;
                    text[0] = static_cast<unsigned char>(code | 0xC0);
                    text += 2;
                }
                else if (code < 0x10000)    // 3 byte sequence
                {
                    text[2] = static_cast<unsigned char>((code | 0x80) & 0xBF); code >>= 6;
                    text[1] = static_cast<unsigned char>((code | 0x80) & 0xBF); code >>= 6;
                    text[0] = static_cast<unsigned char>(code | 0xE0);
                    text += 3;
                }
                else if (code < 0x110000)   // 4 byte sequence
                {
                    text[3] = static_cast<unsigned char>((code | 0x80) & 0xBF); code >>= 6;
                    text[2] = static_cast<unsigned char>((code | 0x80) & 0xBF); code >>= 6;
                    text[1] = static_cast<unsigned char>((code | 0x80) & 0xBF); code >>= 6;
                    text[0] = static_cast<unsigned char>(code | 0xF0);
                    text += 4;
                }
                else    // Invalid, only codes up to 0x10FFFF are allowed in Unicode
                {
                    RAPIDXML_PARSE_ERROR("invalid numeric character entity", text);
                }
            }
        }

insert_node()

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

inlineinherited

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

inlineinherited

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

inlineinherited

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

inlineinherited

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;
        }

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:

parse()

void parse ( Ch *  text )

inline

Parses zero-terminated XML string according to given flags. Passed string will be modified by the parser, unless rapidxml::parse_non_destructive flag is used. The string must persist for the lifetime of the document. In case of error, rapidxml::parse_error exception will be thrown.

If you want to parse contents of a file, you must first load the file into the memory, and pass pointer to its beginning. Make sure that data is zero-terminated.

Document can be parsed into multiple times. Each new call to parse removes previous nodes and attributes (if any), but does not clear memory pool.

Parameters

text	XML data to parse; pointer is non-const to denote fact that this data may be modified by the parser.

Definition at line 1381 of file rapidxml.hpp.

        {
            assert(text);
            
            // Remove current contents
            this->remove_all_nodes();
            this->remove_all_attributes();
            
            // Parse BOM, if any
            parse_bom<Flags>(text);
            
            // Parse children
            while (1)
            {
                // Skip whitespace before node
                skip<whitespace_pred, Flags>(text);
                if (*text == 0)
                    break;

                // Parse and append new child
                if (*text == Ch('<'))
                {
                    ++text;     // Skip '<'
                    if (xml_node<Ch> *node = parse_node<Flags>(text))
                        this->append_node(node);
                }
                else
                    RAPIDXML_PARSE_ERROR("expected <", text);
            }

        }

Here is the caller graph for this function:

parse_and_append_data()

Ch parse_and_append_data ( xml_node< Ch > *  node, Ch *&  text, Ch *  contents_start  )

inlineprivate

Definition at line 1940 of file rapidxml.hpp.

        {
            // Backup to contents start if whitespace trimming is disabled
            if (!(Flags & parse_trim_whitespace))
                text = contents_start;     
            
            // Skip until end of data
            Ch *value = text, *end;
            if (Flags & parse_normalize_whitespace)
                end = skip_and_expand_character_refs<text_pred, text_pure_with_ws_pred, Flags>(text);   
            else
                end = skip_and_expand_character_refs<text_pred, text_pure_no_ws_pred, Flags>(text);

            // Trim trailing whitespace if flag is set; leading was already trimmed by whitespace skip after >
            if (Flags & parse_trim_whitespace)
            {
                if (Flags & parse_normalize_whitespace)
                {
                    // Whitespace is already condensed to single space characters by skipping function, so just trim 1 char off the end
                    if (*(end - 1) == Ch(' '))
                        --end;
                }
                else
                {
                    // Backup until non-whitespace character is found
                    while (whitespace_pred::test(*(end - 1)))
                        --end;
                }
            }
            
            // If characters are still left between end and value (this test is only necessary if normalization is enabled)
            // Create new data node
            if (!(Flags & parse_no_data_nodes))
            {
                xml_node<Ch> *data = this->allocate_node(node_data);
                data->value(value, end - value);
                node->append_node(data);
            }

            // Add data to parent node if no data exists yet
            if (!(Flags & parse_no_element_values)) 
                if (*node->value() == Ch('\0'))
                    node->value(value, end - value);

            // Place zero terminator after value
            if (!(Flags & parse_no_string_terminators))
            {
                Ch ch = *text;
                *end = Ch('\0');
                return ch;      // Return character that ends data; this is required because zero terminator overwritten it
            }

            // Return character that ends data
            return *text;
        }

Here is the call graph for this function:

parse_bom()

void parse_bom ( Ch *&  text )

inlineprivate

Definition at line 1725 of file rapidxml.hpp.

        {
            // UTF-8?
            if (static_cast<unsigned char>(text[0]) == 0xEF && 
                static_cast<unsigned char>(text[1]) == 0xBB && 
                static_cast<unsigned char>(text[2]) == 0xBF)
            {
                text += 3;      // Skup utf-8 bom
            }
        }

parse_cdata()

xml_node<Ch>* parse_cdata ( Ch *&  text )

inlineprivate

Definition at line 1998 of file rapidxml.hpp.

        {
            // If CDATA is disabled
            if (Flags & parse_no_data_nodes)
            {
                // Skip until end of cdata
                while (text[0] != Ch(']') || text[1] != Ch(']') || text[2] != Ch('>'))
                {
                    if (!text[0])
                        RAPIDXML_PARSE_ERROR("unexpected end of data", text);
                    ++text;
                }
                text += 3;      // Skip ]]>
                return 0;       // Do not produce CDATA node
            }

            // Skip until end of cdata
            Ch *value = text;
            while (text[0] != Ch(']') || text[1] != Ch(']') || text[2] != Ch('>'))
            {
                if (!text[0])
                    RAPIDXML_PARSE_ERROR("unexpected end of data", text);
                ++text;
            }

            // Create new cdata node
            xml_node<Ch> *cdata = this->allocate_node(node_cdata);
            cdata->value(value, text - value);

            // Place zero terminator after value
            if (!(Flags & parse_no_string_terminators))
                *text = Ch('\0');

            text += 3;      // Skip ]]>
            return cdata;
        }

Here is the call graph for this function:

parse_comment()

xml_node<Ch>* parse_comment ( Ch *&  text )

inlineprivate

Definition at line 1773 of file rapidxml.hpp.

        {
            // If parsing of comments is disabled
            if (!(Flags & parse_comment_nodes))
            {
                // Skip until end of comment
                while (text[0] != Ch('-') || text[1] != Ch('-') || text[2] != Ch('>'))
                {
                    if (!text[0])
                        RAPIDXML_PARSE_ERROR("unexpected end of data", text);
                    ++text;
                }
                text += 3;     // Skip '-->'
                return 0;      // Do not produce comment node
            }

            // Remember value start
            Ch *value = text;

            // Skip until end of comment
            while (text[0] != Ch('-') || text[1] != Ch('-') || text[2] != Ch('>'))
            {
                if (!text[0])
                    RAPIDXML_PARSE_ERROR("unexpected end of data", text);
                ++text;
            }

            // Create comment node
            xml_node<Ch> *comment = this->allocate_node(node_comment);
            comment->value(value, text - value);
            
            // Place zero terminator after comment value
            if (!(Flags & parse_no_string_terminators))
                *text = Ch('\0');
            
            text += 3;     // Skip '-->'
            return comment;
        }

Here is the call graph for this function:

parse_doctype()

xml_node<Ch>* parse_doctype ( Ch *&  text )

inlineprivate

Definition at line 1814 of file rapidxml.hpp.

        {
            // Remember value start
            Ch *value = text;

            // Skip to >
            while (*text != Ch('>'))
            {
                // Determine character type
                switch (*text)
                {
                
                // If '[' encountered, scan for matching ending ']' using naive algorithm with depth
                // This works for all W3C test files except for 2 most wicked
                case Ch('['):
                {
                    ++text;     // Skip '['
                    int depth = 1;
                    while (depth > 0)
                    {
                        switch (*text)
                        {
                            case Ch('['): ++depth; break;
                            case Ch(']'): --depth; break;
                            case 0: RAPIDXML_PARSE_ERROR("unexpected end of data", text);
                        }
                        ++text;
                    }
                    break;
                }
                
                // Error on end of text
                case Ch('\0'):
                    RAPIDXML_PARSE_ERROR("unexpected end of data", text);
                
                // Other character, skip it
                default:
                    ++text;

                }
            }
            
            // If DOCTYPE nodes enabled
            if (Flags & parse_doctype_node)
            {
                // Create a new doctype node
                xml_node<Ch> *doctype = this->allocate_node(node_doctype);
                doctype->value(value, text - value);
                
                // Place zero terminator after value
                if (!(Flags & parse_no_string_terminators))
                    *text = Ch('\0');

                text += 1;      // skip '>'
                return doctype;
            }
            else
            {
                text += 1;      // skip '>'
                return 0;
            }

        }

Here is the call graph for this function:

parse_element()

xml_node<Ch>* parse_element ( Ch *&  text )

inlineprivate

Definition at line 2037 of file rapidxml.hpp.

        {
            // Create element node
            xml_node<Ch> *element = this->allocate_node(node_element);

            // Extract element name
            Ch *name = text;
            skip<node_name_pred, Flags>(text);
            if (text == name)
                RAPIDXML_PARSE_ERROR("expected element name", text);
            element->name(name, text - name);
            
            // Skip whitespace between element name and attributes or >
            skip<whitespace_pred, Flags>(text);

            // Parse attributes, if any
            parse_node_attributes<Flags>(text, element);

            // Determine ending type
            if (*text == Ch('>'))
            {
                ++text;
                parse_node_contents<Flags>(text, element);
            }
            else if (*text == Ch('/'))
            {
                ++text;
                if (*text != Ch('>'))
                    RAPIDXML_PARSE_ERROR("expected >", text);
                ++text;
            }
            else
                RAPIDXML_PARSE_ERROR("expected >", text);

            // Place zero terminator after name
            if (!(Flags & parse_no_string_terminators))
                element->name()[element->name_size()] = Ch('\0');

            // Return parsed element
            return element;
        }

Here is the call graph for this function:

parse_node()

xml_node<Ch>* parse_node ( Ch *&  text )

inlineprivate

Definition at line 2081 of file rapidxml.hpp.

        {
            // Parse proper node type
            switch (text[0])
            {

            // <...
            default: 
                // Parse and append element node
                return parse_element<Flags>(text);

            // <?...
            case Ch('?'): 
                ++text;     // Skip ?
                if ((text[0] == Ch('x') || text[0] == Ch('X')) &&
                    (text[1] == Ch('m') || text[1] == Ch('M')) && 
                    (text[2] == Ch('l') || text[2] == Ch('L')) &&
                    whitespace_pred::test(text[3]))
                {
                    // '<?xml ' - xml declaration
                    text += 4;      // Skip 'xml '
                    return parse_xml_declaration<Flags>(text);
                }
                else
                {
                    // Parse PI
                    return parse_pi<Flags>(text);
                }
            
            // <!...
            case Ch('!'): 

                // Parse proper subset of <! node
                switch (text[1])    
                {
                
                // <!-
                case Ch('-'):
                    if (text[2] == Ch('-'))
                    {
                        // '<!--' - xml comment
                        text += 3;     // Skip '!--'
                        return parse_comment<Flags>(text);
                    }
                    break;

                // <![
                case Ch('['):
                    if (text[2] == Ch('C') && text[3] == Ch('D') && text[4] == Ch('A') && 
                        text[5] == Ch('T') && text[6] == Ch('A') && text[7] == Ch('['))
                    {
                        // '<![CDATA[' - cdata
                        text += 8;     // Skip '![CDATA['
                        return parse_cdata<Flags>(text);
                    }
                    break;

                // <!D
                case Ch('D'):
                    if (text[2] == Ch('O') && text[3] == Ch('C') && text[4] == Ch('T') && 
                        text[5] == Ch('Y') && text[6] == Ch('P') && text[7] == Ch('E') && 
                        whitespace_pred::test(text[8]))
                    {
                        // '<!DOCTYPE ' - doctype
                        text += 9;      // skip '!DOCTYPE '
                        return parse_doctype<Flags>(text);
                    }

                }   // switch

                // Attempt to skip other, unrecognized node types starting with <!
                ++text;     // Skip !
                while (*text != Ch('>'))
                {
                    if (*text == 0)
                        RAPIDXML_PARSE_ERROR("unexpected end of data", text);
                    ++text;
                }
                ++text;     // Skip '>'
                return 0;   // No node recognized

            }
        }

parse_node_attributes()

void parse_node_attributes ( Ch *&  text, xml_node< Ch > *  node  )

inlineprivate

Definition at line 2237 of file rapidxml.hpp.

        {
            // For all attributes 
            while (attribute_name_pred::test(*text))
            {
                // Extract attribute name
                Ch *name = text;
                ++text;     // Skip first character of attribute name
                skip<attribute_name_pred, Flags>(text);
                if (text == name)
                    RAPIDXML_PARSE_ERROR("expected attribute name", name);

                // Create new attribute
                xml_attribute<Ch> *attribute = this->allocate_attribute();
                attribute->name(name, text - name);
                node->append_attribute(attribute);

                // Skip whitespace after attribute name
                skip<whitespace_pred, Flags>(text);

                // Skip =
                if (*text != Ch('='))
                    RAPIDXML_PARSE_ERROR("expected =", text);
                ++text;

                // Add terminating zero after name
                if (!(Flags & parse_no_string_terminators))
                    attribute->name()[attribute->name_size()] = 0;

                // Skip whitespace after =
                skip<whitespace_pred, Flags>(text);

                // Skip quote and remember if it was ' or "
                Ch quote = *text;
                if (quote != Ch('\'') && quote != Ch('"'))
                    RAPIDXML_PARSE_ERROR("expected ' or \"", text);
                ++text;

                // Extract attribute value and expand char refs in it
                Ch *value = text, *end;
                const int AttFlags = Flags & ~parse_normalize_whitespace;   // No whitespace normalization in attributes
                if (quote == Ch('\''))
                    end = skip_and_expand_character_refs<attribute_value_pred<Ch('\'')>, attribute_value_pure_pred<Ch('\'')>, AttFlags>(text);
                else
                    end = skip_and_expand_character_refs<attribute_value_pred<Ch('"')>, attribute_value_pure_pred<Ch('"')>, AttFlags>(text);
                
                // Set attribute value
                attribute->value(value, end - value);
                
                // Make sure that end quote is present
                if (*text != quote)
                    RAPIDXML_PARSE_ERROR("expected ' or \"", text);
                ++text;     // Skip quote

                // Add terminating zero after value
                if (!(Flags & parse_no_string_terminators))
                    attribute->value()[attribute->value_size()] = 0;

                // Skip whitespace after attribute value
                skip<whitespace_pred, Flags>(text);
            }
        }

Here is the call graph for this function:

parse_node_contents()

void parse_node_contents ( Ch *&  text, xml_node< Ch > *  node  )

inlineprivate

Definition at line 2167 of file rapidxml.hpp.

        {
            // For all children and text
            while (1)
            {
                // Skip whitespace between > and node contents
                Ch *contents_start = text;      // Store start of node contents before whitespace is skipped
                skip<whitespace_pred, Flags>(text);
                Ch next_char = *text;

            // After data nodes, instead of continuing the loop, control jumps here.
            // This is because zero termination inside parse_and_append_data() function
            // would wreak havoc with the above code.
            // Also, skipping whitespace after data nodes is unnecessary.
            after_data_node:    
                
                // Determine what comes next: node closing, child node, data node, or 0?
                switch (next_char)
                {
                
                // Node closing or child node
                case Ch('<'):
                    if (text[1] == Ch('/'))
                    {
                        // Node closing
                        text += 2;      // Skip '</'
                        if (Flags & parse_validate_closing_tags)
                        {
                            // Skip and validate closing tag name
                            Ch *closing_name = text;
                            skip<node_name_pred, Flags>(text);
                            if (!internal::compare(node->name(), node->name_size(), closing_name, text - closing_name, true))
                                RAPIDXML_PARSE_ERROR("invalid closing tag name", text);
                        }
                        else
                        {
                            // No validation, just skip name
                            skip<node_name_pred, Flags>(text);
                        }
                        // Skip remaining whitespace after node name
                        skip<whitespace_pred, Flags>(text);
                        if (*text != Ch('>'))
                            RAPIDXML_PARSE_ERROR("expected >", text);
                        ++text;     // Skip '>'
                        return;     // Node closed, finished parsing contents
                    }
                    else
                    {
                        // Child node
                        ++text;     // Skip '<'
                        if (xml_node<Ch> *child = parse_node<Flags>(text))
                            node->append_node(child);
                    }
                    break;

                // End of data - error
                case Ch('\0'):
                    RAPIDXML_PARSE_ERROR("unexpected end of data", text);

                // Data node
                default:
                    next_char = parse_and_append_data<Flags>(node, text, contents_start);
                    goto after_data_node;   // Bypass regular processing after data nodes

                }
            }
        }

Here is the call graph for this function:

parse_pi()

xml_node<Ch>* parse_pi ( Ch *&  text )

inlineprivate

Definition at line 1880 of file rapidxml.hpp.

        {
            // If creation of PI nodes is enabled
            if (Flags & parse_pi_nodes)
            {
                // Create pi node
                xml_node<Ch> *pi = this->allocate_node(node_pi);

                // Extract PI target name
                Ch *name = text;
                skip<node_name_pred, Flags>(text);
                if (text == name)
                    RAPIDXML_PARSE_ERROR("expected PI target", text);
                pi->name(name, text - name);
                
                // Skip whitespace between pi target and pi
                skip<whitespace_pred, Flags>(text);

                // Remember start of pi
                Ch *value = text;
                
                // Skip to '?>'
                while (text[0] != Ch('?') || text[1] != Ch('>'))
                {
                    if (*text == Ch('\0'))
                        RAPIDXML_PARSE_ERROR("unexpected end of data", text);
                    ++text;
                }

                // Set pi value (verbatim, no entity expansion or whitespace normalization)
                pi->value(value, text - value);     
                
                // Place zero terminator after name and value
                if (!(Flags & parse_no_string_terminators))
                {
                    pi->name()[pi->name_size()] = Ch('\0');
                    pi->value()[pi->value_size()] = Ch('\0');
                }
                
                text += 2;                          // Skip '?>'
                return pi;
            }
            else
            {
                // Skip to '?>'
                while (text[0] != Ch('?') || text[1] != Ch('>'))
                {
                    if (*text == Ch('\0'))
                        RAPIDXML_PARSE_ERROR("unexpected end of data", text);
                    ++text;
                }
                text += 2;    // Skip '?>'
                return 0;
            }
        }

Here is the call graph for this function:

parse_xml_declaration()

xml_node<Ch>* parse_xml_declaration ( Ch *&  text )

inlineprivate

Definition at line 1738 of file rapidxml.hpp.

        {
            // If parsing of declaration is disabled
            if (!(Flags & parse_declaration_node))
            {
                // Skip until end of declaration
                while (text[0] != Ch('?') || text[1] != Ch('>'))
                {
                    if (!text[0])
                        RAPIDXML_PARSE_ERROR("unexpected end of data", text);
                    ++text;
                }
                text += 2;    // Skip '?>'
                return 0;
            }

            // Create declaration
            xml_node<Ch> *declaration = this->allocate_node(node_declaration);

            // Skip whitespace before attributes or ?>
            skip<whitespace_pred, Flags>(text);

            // Parse declaration attributes
            parse_node_attributes<Flags>(text, declaration);
            
            // Skip ?>
            if (text[0] != Ch('?') || text[1] != Ch('>'))
                RAPIDXML_PARSE_ERROR("expected ?>", text);
            text += 2;
            
            return declaration;
        }

prepend_attribute()

void prepend_attribute ( xml_attribute< Ch > *  attribute )

inlineinherited

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 )

inlineinherited

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

inlineinherited

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 ( )

inlineinherited

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 ( )

inlineinherited

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 )

inlineinherited

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 ( )

inlineinherited

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 ( )

inlineinherited

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 ( )

inlineinherited

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 ( )

inlineinherited

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 )

inlineinherited

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:

set_allocator()

void set_allocator ( alloc_func *  af, free_func *  ff  )

inlineinherited

Sets or resets the user-defined memory allocation functions for the pool. This can only be called when no memory is allocated from the pool yet, otherwise results are undefined. Allocation function must not return invalid pointer on failure. It should either throw, stop the program, or use longjmp() function to pass control to other place of program. If it returns invalid pointer, results are undefined.

User defined allocation functions must have the following forms:

void *allocate(std::size_t size);
void free(void *pointer);

Parameters

af	Allocation function, or 0 to restore default function
ff	Free function, or 0 to restore default function

Definition at line 552 of file rapidxml.hpp.

        {
            assert(m_begin == m_static_memory && m_ptr == align(m_begin));    // Verify that no memory is allocated yet
            m_alloc_func = af;
            m_free_func = ff;
        }

skip()

static void skip ( Ch *&  text )

inlinestaticprivate

Definition at line 1558 of file rapidxml.hpp.

        {
            Ch *tmp = text;
            while (StopPred::test(*tmp))
                ++tmp;
            text = tmp;
        }

skip_and_expand_character_refs()

static Ch* skip_and_expand_character_refs ( Ch *&  text )

inlinestaticprivate

Definition at line 1570 of file rapidxml.hpp.

        {
            // If entity translation, whitespace condense and whitespace trimming is disabled, use plain skip
            if (Flags & parse_no_entity_translation && 
                !(Flags & parse_normalize_whitespace) &&
                !(Flags & parse_trim_whitespace))
            {
                skip<StopPred, Flags>(text);
                return text;
            }
            
            // Use simple skip until first modification is detected
            skip<StopPredPure, Flags>(text);

            // Use translation skip
            Ch *src = text;
            Ch *dest = src;
            while (StopPred::test(*src))
            {
                // If entity translation is enabled    
                if (!(Flags & parse_no_entity_translation))
                {
                    // Test if replacement is needed
                    if (src[0] == Ch('&'))
                    {
                        switch (src[1])
                        {

                        // &amp; &apos;
                        case Ch('a'): 
                            if (src[2] == Ch('m') && src[3] == Ch('p') && src[4] == Ch(';'))
                            {
                                *dest = Ch('&');
                                ++dest;
                                src += 5;
                                continue;
                            }
                            if (src[2] == Ch('p') && src[3] == Ch('o') && src[4] == Ch('s') && src[5] == Ch(';'))
                            {
                                *dest = Ch('\'');
                                ++dest;
                                src += 6;
                                continue;
                            }
                            break;

                        // &quot;
                        case Ch('q'): 
                            if (src[2] == Ch('u') && src[3] == Ch('o') && src[4] == Ch('t') && src[5] == Ch(';'))
                            {
                                *dest = Ch('"');
                                ++dest;
                                src += 6;
                                continue;
                            }
                            break;

                        // &gt;
                        case Ch('g'): 
                            if (src[2] == Ch('t') && src[3] == Ch(';'))
                            {
                                *dest = Ch('>');
                                ++dest;
                                src += 4;
                                continue;
                            }
                            break;

                        // &lt;
                        case Ch('l'): 
                            if (src[2] == Ch('t') && src[3] == Ch(';'))
                            {
                                *dest = Ch('<');
                                ++dest;
                                src += 4;
                                continue;
                            }
                            break;

                        // &#...; - assumes ASCII
                        case Ch('#'): 
                            if (src[2] == Ch('x'))
                            {
                                unsigned long code = 0;
                                src += 3;   // Skip &#x
                                while (1)
                                {
                                    unsigned char digit = internal::lookup_tables<0>::lookup_digits[static_cast<unsigned char>(*src)];
                                    if (digit == 0xFF)
                                        break;
                                    code = code * 16 + digit;
                                    ++src;
                                }
                                insert_coded_character<Flags>(dest, code);    // Put character in output
                            }
                            else
                            {
                                unsigned long code = 0;
                                src += 2;   // Skip &#
                                while (1)
                                {
                                    unsigned char digit = internal::lookup_tables<0>::lookup_digits[static_cast<unsigned char>(*src)];
                                    if (digit == 0xFF)
                                        break;
                                    code = code * 10 + digit;
                                    ++src;
                                }
                                insert_coded_character<Flags>(dest, code);    // Put character in output
                            }
                            if (*src == Ch(';'))
                                ++src;
                            else
                                RAPIDXML_PARSE_ERROR("expected ;", src);
                            continue;

                        // Something else
                        default:
                            // Ignore, just copy '&' verbatim
                            break;

                        }
                    }
                }
                
                // If whitespace condensing is enabled
                if (Flags & parse_normalize_whitespace)
                {
                    // Test if condensing is needed                 
                    if (whitespace_pred::test(*src))
                    {
                        *dest = Ch(' '); ++dest;    // Put single space in dest
                        ++src;                      // Skip first whitespace char
                        // Skip remaining whitespace chars
                        while (whitespace_pred::test(*src))
                            ++src;
                        continue;
                    }
                }

                // No replacement, only copy character
                *dest++ = *src++;

            }

            // Return new end
            text = src;
            return dest;

        }

type() [1/2]

node_type type ( ) const

inlineinherited

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 )

inlineinherited

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_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_parent

xml_node<Ch>* m_parent

protectedinherited

Definition at line 788 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