├── README.md
├── src
    ├── testMain.cpp
    ├── silenceException.cpp
    ├── RMSMeasurement.cpp
    ├── silenceDetector.cpp
    ├── main.cpp
    ├── detectorTypes.cpp
    └── streamDumper.cpp
├── inc
    ├── silenceException.hpp
    ├── RMSMeasurement.hpp
    ├── detectorTypes.hpp
    ├── silenceDetector.hpp
    └── streamDumper.hpp
├── Makefile
├── test.xml
├── LICENSE.txt
└── lib
    └── rapidxml-1.13
        ├── license.txt
        ├── rapidxml_utils.hpp
        ├── rapidxml_iterators.hpp
        ├── rapidxml_print.hpp
        └── manual.html


/README.md:
--------------------------------------------------------------------------------
1 | Silence-Detector
2 | ================
3 | 
4 | Detects and logs when a LiveWire stream has no audio.
5 | 


--------------------------------------------------------------------------------
/src/testMain.cpp:
--------------------------------------------------------------------------------
 1 | #include <silenceDetector.hpp>
 2 | 
 3 | //192.168.0.200 239.192.39.123, 5004
 4 | 
 5 | int main(int argc, char *argv[])
 6 | {
 7 | 	silenceDetector sd;
 8 | 	sd.setIPAddress("239.192.39.123");
 9 | 	sd.setBindingAddress("192.168.0.200");
10 | 	sd.setPort("5004");
11 | 
12 | 	sd.signalProcessingLoop();
13 | 
14 | }
15 | 


--------------------------------------------------------------------------------
/src/silenceException.cpp:
--------------------------------------------------------------------------------
 1 | #include <silenceException.hpp>
 2 | 
 3 | silenceException::silenceException(std::string in)
 4 | {
 5 | 	msg = in;
 6 | }
 7 | 
 8 | silenceException::~silenceException() throw()
 9 | {
10 | 	//empty
11 | }
12 | 
13 | const char * silenceException::what() const throw()
14 | {
15 | 	return (char *)msg.c_str();
16 | }
17 | 


--------------------------------------------------------------------------------
/inc/silenceException.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SILENCEEXCEPTION_H
 2 | #define SILENCEEXCEPTION_H
 3 | 
 4 | #include <exception>
 5 | #include <string>
 6 | 
 7 | class silenceException : public std::exception
 8 | {
 9 | 	public:
10 | 		silenceException(std::string);
11 | 		~silenceException() throw();
12 | 		virtual const char *what() const throw();
13 | 	
14 | 	private:
15 | 		std::string msg;
16 | };
17 | 
18 | 
19 | #endif
20 | 


--------------------------------------------------------------------------------
/inc/RMSMeasurement.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef RMSMEASUREMENT_H
 2 | #define RMSMEASUREMENT_H
 3 | 
 4 | class RMSMeasurement
 5 | {
 6 |     public:
 7 |         RMSMeasurement();
 8 |         ~RMSMeasurement();
 9 |         RMSMeasurement(const unsigned char*, unsigned long);
10 |         void setData(const unsigned char*, unsigned long);
11 |         double getMeasurementValue() const;
12 | 
13 |     private:
14 |         double measurementValue;
15 | 
16 | };
17 | 
18 | #endif
19 | 
20 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | IFLAGS=-I./inc -Ilib/rapidxml-1.13
 2 | LIBS =-lcurl
 3 | OBJDIR=bin
 4 | SRCDIR=src
 5 | OBJS=bin/silenceException.o bin/detectorTypes.o bin/silenceDetector.o bin/RMSMeasurement.o bin/streamDumper.o
 6 | 
 7 | default: silenceDetector
 8 | 
 9 | $(OBJDIR) : 
10 | 	mkdir $(OBJDIR)
11 | 
12 | $(OBJDIR)/%.o : $(SRCDIR)/%.cpp $(OBJDIR)
13 | 	g++ -c $(IFLAGS) $< -o $@
14 | 
15 | test : $(OBJS) bin/testMain.o
16 | 	g++  -o $(OBJDIR)/test $^ $(LIBS)
17 | 
18 | clean:
19 | 	rm $(OBJDIR)/*
20 | 
21 | silenceDetector: bin/silenceException.o bin/detectorTypes.o bin/silenceDetector.o bin/RMSMeasurement.o bin/streamDumper.o bin/main.o
22 | 	g++ -o $(OBJDIR)/silenceDetector $^ $(LIBS)
23 | 
24 | 


--------------------------------------------------------------------------------
/inc/detectorTypes.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef DETECTORTYPES_H
 2 | #define DETECTORTYPES_H
 3 | 
 4 | #include <silenceDetector.hpp>
 5 | 
 6 | class detectorEmail : public detectorAction
 7 | {
 8 | 	public:
 9 | 		detectorEmail(const std::string&, const std::string&, const std::string&);
10 | 		detectorEmail();
11 | 		~detectorEmail();
12 | 		
13 | 	private:
14 | 		std::string emailTo;
15 | 		std::string emailServer;
16 | 		std::string emailMessage;
17 | 		void doAction();
18 | 		void sendEmail(const std::string&, const std::string&, const std::string&);
19 | 
20 | };
21 | 
22 | class detectorLog : public detectorAction
23 | {
24 | 	public:
25 | 		detectorLog(const std::string&, const std::string&);
26 | 		detectorLog();
27 | 		~detectorLog();
28 | 		
29 | 	private:
30 | 		std::string logFn;
31 | 		std::string logMessage;
32 | 		void doAction();
33 | 		void writeLog();
34 | };
35 | 
36 | #endif
37 | 


--------------------------------------------------------------------------------
/test.xml:
--------------------------------------------------------------------------------
 1 | <BindingAddress>192.168.0.200</BindingAddress>
 2 | <IPAddress>239.192.39.123</IPAddress>
 3 | <Port>5004</Port>
 4 | <Action>
 5 |  <Type>log</Type>
 6 |  <message>Silence for 1 hour.</message>
 7 |  <file>/tmp/silence_log</file>
 8 |  <threshold>25000</threshold>
 9 |  <counts>3600</counts>
10 | </Action>
11 | <Action>
12 |  <Type>log</Type>
13 |  <message>Silence for 30 minutes.</message>
14 |  <file>/tmp/silence_log</file>
15 |  <threshold>25000</threshold>
16 |  <counts>1800</counts>
17 | </Action>
18 | <Action>
19 |  <Type>log</Type>
20 |  <message>Silence for 10 seconds.</message>
21 |  <file>/tmp/silence_log</file>
22 |  <threshold>25000</threshold>
23 |  <counts>10</counts>
24 | </Action>
25 | <Action>
26 |  <Type>log</Type>
27 |  <message>Silence for 30 seconds.</message>
28 |  <file>/tmp/silence_log</file>
29 |  <threshold>25000</threshold>
30 |  <counts>30</counts>
31 | </Action>
32 | 
33 | 


--------------------------------------------------------------------------------
/LICENSE.txt:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2014 Benjamin Yu, WMFO Tufts Freeform Radio
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.
22 | 
23 | 


--------------------------------------------------------------------------------
/inc/silenceDetector.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SILENCEDETECTOR_H
 2 | #define SILENCEDETECTOR_H
 3 | 
 4 | #include <string>
 5 | #include <list>
 6 | #include <streamDumper.hpp>
 7 | 
 8 | class silenceDetector;
 9 | class detectorAction;
10 | 
11 | class silenceDetector
12 | {
13 |     public:
14 | 
15 |         silenceDetector();
16 |         ~silenceDetector();
17 |         void setIPAddress(const std::string&);
18 | 	void setBindingAddress(const std::string&);
19 | 	void setPort(const std::string&);
20 |         void signalProcessingLoop();
21 |         void addDetectorAction(detectorAction*);
22 | 
23 |     private:
24 |         //Members
25 |         streamDumper *sDump;
26 | 	std::string IPAddr;
27 | 	std::string bindAddr;
28 | 	unsigned int port;
29 |         std::list<detectorAction*> actionList;
30 | 
31 | };
32 | 
33 | 
34 | //base class
35 | class detectorAction
36 | {
37 | 	public:
38 | 		detectorAction();
39 | 		~detectorAction();
40 | 		double getSilenceThreshold();
41 | 		unsigned long getSilenceCount();
42 | 		void setSilenceCount(const unsigned long);
43 | 		void setSilenceThreshold(const double);
44 | 		void sendMeasurement(const double);
45 | 
46 | 	private:
47 | 		virtual void doAction();
48 | 		unsigned long counts;
49 | 		unsigned long countsThreshold;
50 | 		double silenceThreshold;
51 | };
52 | 
53 | #endif
54 | 
55 | 


--------------------------------------------------------------------------------
/src/RMSMeasurement.cpp:
--------------------------------------------------------------------------------
 1 | #include <cmath>
 2 | #include <RMSMeasurement.hpp>
 3 | 
 4 | #define TWO_TO_23RD 8388608
 5 | 
 6 | RMSMeasurement::RMSMeasurement()
 7 | {
 8 |     measurementValue = 0.0;
 9 | }
10 | 
11 | RMSMeasurement::~RMSMeasurement()
12 | {
13 | 
14 | }
15 | 
16 | RMSMeasurement::RMSMeasurement(const unsigned char *in, unsigned long len)
17 | {
18 |     setData(in, len);
19 | }
20 | 
21 | void RMSMeasurement::setData(const unsigned char *in, unsigned long len)
22 | {
23 |     //Create RMS sound level measurement off of two channel data
24 |     long right;
25 |     long left;
26 |     measurementValue = 0.0;
27 |     unsigned long num_samples = len/6; //6 is the 2*(size of one sample in one channel = 3)
28 | 
29 |     for (unsigned long i = 0; i < len; i += 6) //6 is the 2*(size of one sample = 3)
30 |     {
31 |         //Remember, 24 bit big endian samples, and they are signed (bleh)
32 |         left = ((in[i] & 127) << 16)  | (in[i+1] << 8) | (in[i+2]);
33 |         if (in[i] & 128)
34 |         {
35 |             //Must apply the two's complement since the MSB is set
36 |             left += -TWO_TO_23RD;
37 |         }
38 | 
39 |         right = ((in[i+3] & 127) << 16) | (in[i+4] << 8) | (in[i+5]);
40 |         if (in[i+3] & 128)
41 |         {
42 |             //Must apply the two's complemennt since the MSB is set
43 |             right += -TWO_TO_23RD;
44 |         }
45 | 
46 |         //Right now using measurementValue to hold the mean of the squares
47 |         measurementValue += std::pow(((left + right)/2.0), 2.0)/num_samples;
48 |     }
49 | 
50 |     //Take square root to finish calculation
51 |     measurementValue = std::sqrt(measurementValue);
52 | 
53 | }
54 | 
55 | double RMSMeasurement::getMeasurementValue() const
56 | {
57 |     return measurementValue;
58 | }
59 | 
60 | 


--------------------------------------------------------------------------------
/src/silenceDetector.cpp:
--------------------------------------------------------------------------------
 1 | #include <silenceDetector.hpp>
 2 | #include <silenceException.hpp>
 3 | #include <RMSMeasurement.hpp>
 4 | #include <cstdlib>
 5 | 
 6 | silenceDetector::silenceDetector()
 7 | {
 8 | 	sDump = NULL;
 9 | 	actionList.empty();
10 | }
11 | 
12 | silenceDetector::~silenceDetector()
13 | {
14 | 	if (sDump != NULL)
15 | 		delete sDump;
16 | 
17 | 	std::list<detectorAction*>::iterator it;
18 | 
19 | 	for (it = actionList.begin(); it != actionList.end(); ++it)
20 | 	{
21 | 		delete (*it);
22 | 	}
23 | }
24 | 
25 | void silenceDetector::setIPAddress(const std::string &in)
26 | {
27 | 	IPAddr = in;
28 | }
29 | 
30 | void silenceDetector::setBindingAddress(const std::string &in)
31 | {
32 | 	bindAddr = in;
33 | }
34 | 
35 | void silenceDetector::setPort(const std::string &in)
36 | {
37 | 	port = atoi(in.c_str());
38 | }
39 | 
40 | void silenceDetector::addDetectorAction(detectorAction *in)
41 | {
42 | 	if (in == NULL)
43 | 		throw silenceException("Attempted to add null detectorAction to queue.");
44 | 
45 | 	actionList.push_back(in);
46 | }
47 | 
48 | void silenceDetector::signalProcessingLoop()
49 | {
50 | 	unsigned char buf[3*2*48000]; //Believe this is one second
51 | 	double measurementValue;
52 | 	try
53 | 	{
54 | 		sDump = new streamDumper(bindAddr, IPAddr, port);
55 | 	}
56 | 	catch (std::exception e)
57 | 	{
58 | 		std::cerr << "Unable to begin streamDumping..." << std::endl;
59 | 		std::cerr << e.what() << std::endl;
60 | 		return;
61 | 	}
62 | 
63 | 	while(1)
64 | 	{
65 | 		try
66 | 		{
67 | 			sDump->getSocketData(buf, 3*2*48000);
68 | 			measurementValue = RMSMeasurement(buf, 3*2*48000).getMeasurementValue();
69 | 			//std::cout << "RMS Value: " << measurementValue << std::endl;
70 | 
71 | 			std::list<detectorAction*>::iterator it;
72 | 			for (it = actionList.begin(); it != actionList.end(); ++it)
73 | 			{
74 | 				(*it)->sendMeasurement(measurementValue);
75 | 			}
76 | 		}
77 | 		catch (std::exception e)
78 | 		{
79 | 			std::cerr << "Error while monitoring stream..." << std::endl;
80 | 			std::cerr << e.what() << std::endl;
81 | 		}
82 | 	}
83 | }
84 | 
85 | 


--------------------------------------------------------------------------------
/lib/rapidxml-1.13/license.txt:
--------------------------------------------------------------------------------
 1 | Use of this software is granted under one of the following two licenses,
 2 | to be chosen freely by the user.
 3 | 
 4 | 1. Boost Software License - Version 1.0 - August 17th, 2003
 5 | ===============================================================================
 6 | 
 7 | Copyright (c) 2006, 2007 Marcin Kalicinski
 8 | 
 9 | Permission is hereby granted, free of charge, to any person or organization
10 | obtaining a copy of the software and accompanying documentation covered by
11 | this license (the "Software") to use, reproduce, display, distribute,
12 | execute, and transmit the Software, and to prepare derivative works of the
13 | Software, and to permit third-parties to whom the Software is furnished to
14 | do so, all subject to the following:
15 | 
16 | The copyright notices in the Software and this entire statement, including
17 | the above license grant, this restriction and the following disclaimer,
18 | must be included in all copies of the Software, in whole or in part, and
19 | all derivative works of the Software, unless such copies or derivative
20 | works are solely in the form of machine-executable object code generated by
21 | a source language processor.
22 | 
23 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
24 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
25 | FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
26 | SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
27 | FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
28 | ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
29 | DEALINGS IN THE SOFTWARE.
30 | 
31 | 2. The MIT License
32 | ===============================================================================
33 | 
34 | Copyright (c) 2006, 2007 Marcin Kalicinski
35 | 
36 | Permission is hereby granted, free of charge, to any person obtaining a copy 
37 | of this software and associated documentation files (the "Software"), to deal 
38 | in the Software without restriction, including without limitation the rights 
39 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 
40 | of the Software, and to permit persons to whom the Software is furnished to do so, 
41 | subject to the following conditions:
42 | 
43 | The above copyright notice and this permission notice shall be included in all 
44 | copies or substantial portions of the Software.
45 | 
46 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
47 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
48 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
49 | THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
50 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
51 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 
52 | IN THE SOFTWARE.
53 | 


--------------------------------------------------------------------------------
/src/main.cpp:
--------------------------------------------------------------------------------
  1 | #include <silenceDetector.hpp>
  2 | #include <detectorTypes.hpp>
  3 | #include <rapidxml.hpp>
  4 | #include <exception>
  5 | #include <fstream>
  6 | #include <iostream>
  7 | #include <string>
  8 | #include <cstring>
  9 | #include <map>
 10 | #include <unistd.h>
 11 | 
 12 | void processDetectorAction(rapidxml::xml_node<> *, silenceDetector &);
 13 | 
 14 | int main(int argc, char *argv[])
 15 | {
 16 | 	if (argc < 2)
 17 | 	{
 18 | 		std::cout << "Usage: silenceDetector <xml_config>" << std::endl;
 19 | 		return 1;
 20 | 	}
 21 | 
 22 | 	//Daemonize
 23 | 	if (fork() != 0)
 24 | 		return 0; 
 25 | 
 26 | 	setsid();
 27 | 
 28 | 	if (fork() != 0)
 29 | 		return 0;
 30 | 	
 31 | 	std::fstream f;
 32 | 	f.open(argv[1], std::ios_base::in);
 33 | 	if (f.fail())
 34 | 	{
 35 | 		std::cerr << "Unable to open config file." << std::endl;
 36 | 		return 1;
 37 | 	}
 38 | 
 39 | 	std::string config_xml;
 40 | 	while (!f.eof())
 41 | 	{
 42 | 		char c = f.get();
 43 | 		if (!f.eof())
 44 | 			config_xml += c;
 45 | 	}
 46 | 
 47 | 	char *buf = new char[config_xml.length()+1];
 48 | 	strncpy(buf, config_xml.c_str(), config_xml.length());
 49 | 	buf[config_xml.length()] = 0;
 50 | 	rapidxml::xml_document<> xml;
 51 | 	try
 52 | 	{
 53 | 		xml.parse<0>(buf);
 54 | 	}
 55 | 	catch (std::exception e)
 56 | 	{
 57 | 		std::cerr << "Unable to parse xml configuration file." << std::endl;
 58 | 		std::cerr << e.what() << std::endl;
 59 | 		return 1;
 60 | 	}
 61 | 
 62 | 	silenceDetector sd;
 63 | 	rapidxml::xml_node<> *node = xml.first_node();
 64 | 	if (node == 0)
 65 | 	{
 66 | 		std::cerr << "Empty document." << std::endl;
 67 | 		return 1;
 68 | 	}
 69 | 
 70 | 	while (node != 0)
 71 | 	{
 72 | 		if (!strcmp(node->name(), "BindingAddress"))
 73 | 		{
 74 | 			sd.setBindingAddress(node->first_node()->value());
 75 | 		}
 76 | 		else if ( !strcmp(node->name(), "IPAddress")  )
 77 | 		{
 78 | 			sd.setIPAddress(node->first_node()->value());
 79 | 		}
 80 | 		else if ( !strcmp(node->name(), "Port")  )
 81 | 		{
 82 | 			sd.setPort(node->first_node()->value());
 83 | 		}
 84 | 		else if ( !strcmp(node->name(), "Action")  )
 85 | 		{
 86 | 			processDetectorAction(node, sd);
 87 | 		}
 88 | 
 89 | 		node = node->next_sibling();
 90 | 	}
 91 | 
 92 | 	sd.signalProcessingLoop();
 93 | 	return 0;
 94 | }
 95 | 
 96 | void processDetectorAction(rapidxml::xml_node<> *node, silenceDetector &sd)
 97 | {
 98 | 	std::string actionType;
 99 | 	std::map<std::string, std::string> params;
100 | 	detectorAction *newAction;
101 | 	bool makeAction = true;
102 | 	for (rapidxml::xml_node<> *n = node->first_node(); n != 0; n = n->next_sibling())
103 | 	{
104 | 		detectorAction *act;
105 | 		if ( !strcmp(n->name(), "Type") )
106 | 		{
107 | 			actionType = n->first_node()->value();
108 | 		}
109 | 		else
110 | 		{
111 | 			params[n->name()] = n->first_node()->value();
112 | 		}
113 | 	}
114 | 
115 | 	if (actionType == "email")
116 | 	{
117 | 		newAction = new detectorEmail(params["to"], params["server"], params["message"]);
118 |  	}
119 | 	else if (actionType == "log")
120 | 	{
121 | 		newAction = new detectorLog(params["message"], params["file"]);
122 | 	}
123 | 	else
124 | 	{
125 | 		makeAction = false;
126 | 	}
127 | 
128 | 	if (makeAction)
129 | 	{
130 | 		newAction->setSilenceThreshold(atoi(params["threshold"].c_str()));
131 | 		newAction->setSilenceCount(atoi(params["counts"].c_str()));
132 | 		std::cout << newAction->getSilenceCount() << " " << newAction->getSilenceThreshold() << std::endl;
133 | 		sd.addDetectorAction(newAction);
134 | 	}
135 | }
136 | 


--------------------------------------------------------------------------------
/inc/streamDumper.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef STREAMDUMPER_H
  2 | #define STREAMDUMPER_H
  3 | 
  4 | #include <exception>
  5 | #include <string>
  6 | #include <iostream>
  7 | #include <list>
  8 | 
  9 | class streamDumper
 10 | {
 11 |      public:
 12 |         streamDumper();
 13 |         streamDumper(const std::string &bindAddr, const std::string &ipaddr, int portNumber);
 14 |         void openMulticastStream(const std::string &bindAddr, const std::string &ipaddr, int portNumber);
 15 |         ~streamDumper();
 16 |         void getSocketData(unsigned char* buf, unsigned long bufLen);
 17 | 
 18 |     private:
 19 |         std::string multicastAddr;
 20 |         int port;
 21 |         bool socketActive;
 22 |         bool subscriptionActive;
 23 |         int socketDescriptor;
 24 |         unsigned char *remainderData;
 25 |         unsigned long remainderDataLength;
 26 |         void openSocket();
 27 |         void closeSocket();
 28 |         void readSocket();
 29 | 
 30 |         class RTPHeader
 31 |         {
 32 |             public:
 33 |                 RTPHeader();
 34 |                 RTPHeader(unsigned char*);
 35 |                 ~RTPHeader();
 36 |                 void readData(unsigned char*);
 37 |                 int getVersion() const;
 38 |                 bool hasPadding() const;
 39 |                 bool hasExtension() const;
 40 |                 unsigned int getCSRCCount() const;
 41 |                 unsigned int getPayloadType() const;
 42 |                 unsigned long getSequenceNumber() const;
 43 |                 unsigned long getTimestamp() const;
 44 |                 unsigned long getSSRCIdentifier() const;
 45 |                 unsigned long getHeaderLength() const;
 46 | 
 47 |             private:
 48 |                 int version;
 49 |                 bool padding;
 50 |                 bool extensions;
 51 |                 unsigned int CSRCCount;
 52 |                 unsigned int payloadType;
 53 |                 unsigned long sequenceNumber;
 54 |                 unsigned long timeStamp;
 55 |                 unsigned long SSRCIdentifier;
 56 |                 unsigned long extensionLength;
 57 | 
 58 |         };
 59 | 
 60 |         class RTPPacket
 61 |         {
 62 |                 public:
 63 |                     RTPHeader header;
 64 |                     RTPPacket();
 65 |                     RTPPacket(unsigned char*, unsigned long);
 66 |                     ~RTPPacket();
 67 |                     void readData(unsigned char*, unsigned long);
 68 |                     unsigned long getContentLength() const;
 69 |                     unsigned char *getContent() const;
 70 |                     bool operator<(const RTPPacket &b) const;
 71 |                     RTPPacket(const RTPPacket &b);
 72 |                     RTPPacket &operator=(const RTPPacket &b);
 73 | 
 74 |                 private:
 75 |                     unsigned char *content;
 76 |                     unsigned long contentLength;
 77 | 
 78 |         };
 79 | 
 80 |         void setRemainderData(const unsigned char *, unsigned long, const std::list<RTPPacket>&);
 81 | 
 82 | };
 83 | 
 84 | //Exceptions
 85 | class streamDumperException : public std::exception
 86 | {
 87 |     public:
 88 |         streamDumperException(const std::string &reason) throw()
 89 |         {
 90 |             exceptionWhat = reason;
 91 |         }
 92 | 
 93 |         virtual const char *what() const throw()
 94 |         {
 95 |             return exceptionWhat.c_str();
 96 |         }
 97 | 
 98 |         virtual ~streamDumperException() throw() {};
 99 | 
100 |     private:
101 |         std::string exceptionWhat;
102 | 
103 | };
104 | 
105 | #endif
106 | 
107 | 


--------------------------------------------------------------------------------
/lib/rapidxml-1.13/rapidxml_utils.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef RAPIDXML_UTILS_HPP_INCLUDED
  2 | #define RAPIDXML_UTILS_HPP_INCLUDED
  3 | 
  4 | // Copyright (C) 2006, 2009 Marcin Kalicinski
  5 | // Version 1.13
  6 | // Revision $DateTime: 2009/05/13 01:46:17 $
  7 | //! \file rapidxml_utils.hpp This file contains high-level rapidxml utilities that can be useful
  8 | //! in certain simple scenarios. They should probably not be used if maximizing performance is the main objective.
  9 | 
 10 | #include "rapidxml.hpp"
 11 | #include <vector>
 12 | #include <string>
 13 | #include <fstream>
 14 | #include <stdexcept>
 15 | 
 16 | namespace rapidxml
 17 | {
 18 | 
 19 |     //! Represents data loaded from a file
 20 |     template<class Ch = char>
 21 |     class file
 22 |     {
 23 |         
 24 |     public:
 25 |         
 26 |         //! Loads file into the memory. Data will be automatically destroyed by the destructor.
 27 |         //! \param filename Filename to load.
 28 |         file(const char *filename)
 29 |         {
 30 |             using namespace std;
 31 | 
 32 |             // Open stream
 33 |             basic_ifstream<Ch> stream(filename, ios::binary);
 34 |             if (!stream)
 35 |                 throw runtime_error(string("cannot open file ") + filename);
 36 |             stream.unsetf(ios::skipws);
 37 |             
 38 |             // Determine stream size
 39 |             stream.seekg(0, ios::end);
 40 |             size_t size = stream.tellg();
 41 |             stream.seekg(0);   
 42 |             
 43 |             // Load data and add terminating 0
 44 |             m_data.resize(size + 1);
 45 |             stream.read(&m_data.front(), static_cast<streamsize>(size));
 46 |             m_data[size] = 0;
 47 |         }
 48 | 
 49 |         //! Loads file into the memory. Data will be automatically destroyed by the destructor
 50 |         //! \param stream Stream to load from
 51 |         file(std::basic_istream<Ch> &stream)
 52 |         {
 53 |             using namespace std;
 54 | 
 55 |             // Load data and add terminating 0
 56 |             stream.unsetf(ios::skipws);
 57 |             m_data.assign(istreambuf_iterator<Ch>(stream), istreambuf_iterator<Ch>());
 58 |             if (stream.fail() || stream.bad())
 59 |                 throw runtime_error("error reading stream");
 60 |             m_data.push_back(0);
 61 |         }
 62 |         
 63 |         //! Gets file data.
 64 |         //! \return Pointer to data of file.
 65 |         Ch *data()
 66 |         {
 67 |             return &m_data.front();
 68 |         }
 69 | 
 70 |         //! Gets file data.
 71 |         //! \return Pointer to data of file.
 72 |         const Ch *data() const
 73 |         {
 74 |             return &m_data.front();
 75 |         }
 76 | 
 77 |         //! Gets file data size.
 78 |         //! \return Size of file data, in characters.
 79 |         std::size_t size() const
 80 |         {
 81 |             return m_data.size();
 82 |         }
 83 | 
 84 |     private:
 85 | 
 86 |         std::vector<Ch> m_data;   // File data
 87 | 
 88 |     };
 89 | 
 90 |     //! Counts children of node. Time complexity is O(n).
 91 |     //! \return Number of children of node
 92 |     template<class Ch>
 93 |     inline std::size_t count_children(xml_node<Ch> *node)
 94 |     {
 95 |         xml_node<Ch> *child = node->first_node();
 96 |         std::size_t count = 0;
 97 |         while (child)
 98 |         {
 99 |             ++count;
100 |             child = child->next_sibling();
101 |         }
102 |         return count;
103 |     }
104 | 
105 |     //! Counts attributes of node. Time complexity is O(n).
106 |     //! \return Number of attributes of node
107 |     template<class Ch>
108 |     inline std::size_t count_attributes(xml_node<Ch> *node)
109 |     {
110 |         xml_attribute<Ch> *attr = node->first_attribute();
111 |         std::size_t count = 0;
112 |         while (attr)
113 |         {
114 |             ++count;
115 |             attr = attr->next_attribute();
116 |         }
117 |         return count;
118 |     }
119 | 
120 | }
121 | 
122 | #endif
123 | 


--------------------------------------------------------------------------------
/src/detectorTypes.cpp:
--------------------------------------------------------------------------------
  1 | #include <silenceDetector.hpp>
  2 | #include <detectorTypes.hpp>
  3 | #include <silenceException.hpp>
  4 | #include <curl/curl.h>
  5 | #include <fstream>
  6 | #include <ctime>
  7 | 
  8 | detectorAction::detectorAction()
  9 | {
 10 | 	counts = 0;
 11 | 	countsThreshold = 0;
 12 | 	silenceThreshold = 0.0;
 13 | }
 14 | 
 15 | detectorAction::~detectorAction()
 16 | {
 17 | 	//empty
 18 | }
 19 | 
 20 | double detectorAction::getSilenceThreshold()
 21 | {
 22 | 	return silenceThreshold;
 23 | }
 24 | 
 25 | void detectorAction::setSilenceThreshold(const double in)
 26 | {
 27 | 	if (in > 0.0)
 28 | 	{
 29 | 		silenceThreshold = in;
 30 | 	}
 31 | 	else
 32 | 	{
 33 | 		throw silenceException("silenceThreshold must be greater than 0.");
 34 | 	}
 35 | }
 36 | 
 37 | unsigned long detectorAction::getSilenceCount()
 38 | {
 39 | 	return countsThreshold;
 40 | }
 41 | 
 42 | void detectorAction::setSilenceCount(const unsigned long in)
 43 | {
 44 | 	countsThreshold = in;
 45 | }
 46 | 
 47 | void detectorAction::sendMeasurement(const double in)
 48 | {
 49 | 	if (in > silenceThreshold)
 50 | 	{
 51 | 		counts = 0;
 52 | 		return;
 53 | 	}
 54 | 
 55 | 	if (++counts == countsThreshold)
 56 | 	{
 57 | 		doAction();
 58 | 		return;
 59 | 	}
 60 | }
 61 | 
 62 | void detectorAction::doAction()
 63 | {
 64 | 	//empty
 65 | }
 66 | 
 67 | //detectorEmail class
 68 | 
 69 | detectorEmail::detectorEmail()
 70 | {
 71 | 	//empty
 72 | }
 73 | 
 74 | detectorEmail::~detectorEmail()
 75 | {
 76 | 	//empty
 77 | }
 78 | 
 79 | extern "C" size_t emailCallback(void *, size_t, size_t, void *);
 80 | 
 81 | detectorEmail::detectorEmail(const std::string &to, const std::string &Server, const std::string &msg)
 82 | {
 83 | 	emailTo = to;
 84 | 	emailServer = Server;
 85 | 	emailMessage = msg;
 86 | }
 87 | 
 88 | void detectorEmail::doAction()
 89 | {
 90 | 	sendEmail(emailTo, emailServer, emailMessage);
 91 | }
 92 | 
 93 | void detectorEmail::sendEmail(const std::string &to, const std::string &server, const std::string &message)
 94 | {
 95 |     CURL *curl;
 96 |     CURLcode res;
 97 |     curl_slist *recipients = NULL;
 98 | 
 99 |     curl = curl_easy_init();
100 |     if (!curl)
101 |     {
102 |         throw silenceException("Unable to initialize curl while sending alert email.");
103 |     }
104 | 
105 |     curl_easy_setopt(curl, CURLOPT_URL, ("smtp://" + server).c_str());
106 |     curl_easy_setopt(curl, CURLOPT_MAIL_FROM, "silenceDetector@wmfo.org");
107 |     recipients = curl_slist_append(recipients, to.c_str());
108 |     curl_easy_setopt(curl, CURLOPT_MAIL_RCPT, recipients);
109 | 
110 |     //Add the headers
111 |     std::string message2 = "To: " + to + "\nFrom: silenceDetector@wmfo.org\nSubject: Silence Alert\n\n"
112 |      + message;
113 | 
114 |     curl_easy_setopt(curl, CURLOPT_READFUNCTION, emailCallback);
115 |     curl_easy_setopt(curl, CURLOPT_READDATA, &message2);
116 | 
117 |     res = curl_easy_perform(curl);
118 |     if (res != CURLE_OK)
119 |     {
120 |         curl_slist_free_all(recipients);
121 |         curl_easy_cleanup(curl);
122 |         throw silenceException("Curl initialized, but sending of emails failed.");
123 |         return;
124 |     }
125 | 
126 |     curl_slist_free_all(recipients);
127 |     curl_easy_cleanup(curl);
128 | 
129 | }
130 | 
131 | //Internal Function, use to access C Code
132 | //Will erase the std::string pointed to by messageString
133 | extern "C" size_t emailCallback(void *buf, size_t size, size_t numbmemb, void *messageString)
134 | {
135 |     std::string *message = (std::string *)messageString;
136 |     size_t numBytes;
137 |     std::cout << message->c_str() << std::endl;
138 | 
139 |     if (message->length() == 0)
140 |         return 0;
141 | 
142 |     if (size*numbmemb <= message->length())
143 |     {
144 |         numBytes = size * numbmemb;
145 |     }
146 |     else
147 |     {
148 |         numBytes = message->length();
149 |     }
150 | 
151 |     size_t actualBytesSent = message->copy((char *)buf, numBytes, 0);
152 |     message->erase(0, actualBytesSent);
153 | 
154 |     return actualBytesSent;
155 | }
156 | 
157 | //log class
158 | 
159 | detectorLog::detectorLog()
160 | {
161 | 	//empty
162 | }
163 | 
164 | detectorLog::~detectorLog()
165 | {
166 | 	//empty
167 | }
168 | 
169 | 
170 | detectorLog::detectorLog(const std::string &msg, const std::string &_logFn)
171 | {
172 | 	logMessage = msg;
173 | 	logFn = _logFn;
174 | }
175 | 
176 | void detectorLog::doAction()
177 | {
178 | 	writeLog();
179 | }
180 | 
181 | void detectorLog::writeLog()
182 | {
183 | 	std::fstream file;
184 | 	file.open(logFn.c_str(), std::ios_base::out | std::ios_base::app);
185 | 
186 | 	if (file.fail())
187 | 		throw silenceException("Unable to open log file.");
188 | 
189 | 	time_t timer;
190 | 	time(&timer);
191 | 	std::string logTime = ctime(&timer);
192 | 	logTime[logTime.length() - 1] = ':'; //remove the new line
193 | 	file << logTime << " " << logMessage << std::endl;
194 | 
195 | 	file.close();	
196 | }
197 | 
198 | 


--------------------------------------------------------------------------------
/lib/rapidxml-1.13/rapidxml_iterators.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef RAPIDXML_ITERATORS_HPP_INCLUDED
  2 | #define RAPIDXML_ITERATORS_HPP_INCLUDED
  3 | 
  4 | // Copyright (C) 2006, 2009 Marcin Kalicinski
  5 | // Version 1.13
  6 | // Revision $DateTime: 2009/05/13 01:46:17 $
  7 | //! \file rapidxml_iterators.hpp This file contains rapidxml iterators
  8 | 
  9 | #include "rapidxml.hpp"
 10 | 
 11 | namespace rapidxml
 12 | {
 13 | 
 14 |     //! Iterator of child nodes of xml_node
 15 |     template<class Ch>
 16 |     class node_iterator
 17 |     {
 18 |     
 19 |     public:
 20 | 
 21 |         typedef typename xml_node<Ch> value_type;
 22 |         typedef typename xml_node<Ch> &reference;
 23 |         typedef typename xml_node<Ch> *pointer;
 24 |         typedef std::ptrdiff_t difference_type;
 25 |         typedef std::bidirectional_iterator_tag iterator_category;
 26 |         
 27 |         node_iterator()
 28 |             : m_node(0)
 29 |         {
 30 |         }
 31 | 
 32 |         node_iterator(xml_node<Ch> *node)
 33 |             : m_node(node->first_node())
 34 |         {
 35 |         }
 36 |         
 37 |         reference operator *() const
 38 |         {
 39 |             assert(m_node);
 40 |             return *m_node;
 41 |         }
 42 | 
 43 |         pointer operator->() const
 44 |         {
 45 |             assert(m_node);
 46 |             return m_node;
 47 |         }
 48 | 
 49 |         node_iterator& operator++()
 50 |         {
 51 |             assert(m_node);
 52 |             m_node = m_node->next_sibling();
 53 |             return *this;
 54 |         }
 55 | 
 56 |         node_iterator operator++(int)
 57 |         {
 58 |             node_iterator tmp = *this;
 59 |             ++this;
 60 |             return tmp;
 61 |         }
 62 | 
 63 |         node_iterator& operator--()
 64 |         {
 65 |             assert(m_node && m_node->previous_sibling());
 66 |             m_node = m_node->previous_sibling();
 67 |             return *this;
 68 |         }
 69 | 
 70 |         node_iterator operator--(int)
 71 |         {
 72 |             node_iterator tmp = *this;
 73 |             ++this;
 74 |             return tmp;
 75 |         }
 76 | 
 77 |         bool operator ==(const node_iterator<Ch> &rhs)
 78 |         {
 79 |             return m_node == rhs.m_node;
 80 |         }
 81 | 
 82 |         bool operator !=(const node_iterator<Ch> &rhs)
 83 |         {
 84 |             return m_node != rhs.m_node;
 85 |         }
 86 | 
 87 |     private:
 88 | 
 89 |         xml_node<Ch> *m_node;
 90 | 
 91 |     };
 92 | 
 93 |     //! Iterator of child attributes of xml_node
 94 |     template<class Ch>
 95 |     class attribute_iterator
 96 |     {
 97 |     
 98 |     public:
 99 | 
100 |         typedef typename xml_attribute<Ch> value_type;
101 |         typedef typename xml_attribute<Ch> &reference;
102 |         typedef typename xml_attribute<Ch> *pointer;
103 |         typedef std::ptrdiff_t difference_type;
104 |         typedef std::bidirectional_iterator_tag iterator_category;
105 |         
106 |         attribute_iterator()
107 |             : m_attribute(0)
108 |         {
109 |         }
110 | 
111 |         attribute_iterator(xml_node<Ch> *node)
112 |             : m_attribute(node->first_attribute())
113 |         {
114 |         }
115 |         
116 |         reference operator *() const
117 |         {
118 |             assert(m_attribute);
119 |             return *m_attribute;
120 |         }
121 | 
122 |         pointer operator->() const
123 |         {
124 |             assert(m_attribute);
125 |             return m_attribute;
126 |         }
127 | 
128 |         attribute_iterator& operator++()
129 |         {
130 |             assert(m_attribute);
131 |             m_attribute = m_attribute->next_attribute();
132 |             return *this;
133 |         }
134 | 
135 |         attribute_iterator operator++(int)
136 |         {
137 |             attribute_iterator tmp = *this;
138 |             ++this;
139 |             return tmp;
140 |         }
141 | 
142 |         attribute_iterator& operator--()
143 |         {
144 |             assert(m_attribute && m_attribute->previous_attribute());
145 |             m_attribute = m_attribute->previous_attribute();
146 |             return *this;
147 |         }
148 | 
149 |         attribute_iterator operator--(int)
150 |         {
151 |             attribute_iterator tmp = *this;
152 |             ++this;
153 |             return tmp;
154 |         }
155 | 
156 |         bool operator ==(const attribute_iterator<Ch> &rhs)
157 |         {
158 |             return m_attribute == rhs.m_attribute;
159 |         }
160 | 
161 |         bool operator !=(const attribute_iterator<Ch> &rhs)
162 |         {
163 |             return m_attribute != rhs.m_attribute;
164 |         }
165 | 
166 |     private:
167 | 
168 |         xml_attribute<Ch> *m_attribute;
169 | 
170 |     };
171 | 
172 | }
173 | 
174 | #endif
175 | 


--------------------------------------------------------------------------------
/src/streamDumper.cpp:
--------------------------------------------------------------------------------
  1 | #include <streamDumper.hpp>
  2 | #include <list>
  3 | #include <cstring>
  4 | #include <sys/types.h>
  5 | #include <sys/socket.h>
  6 | #include <netinet/in.h>
  7 | #include <arpa/inet.h>
  8 | 
  9 | streamDumper::streamDumper()
 10 | {
 11 |     socketActive = false;
 12 |     socketDescriptor = -1;
 13 |     subscriptionActive = false;
 14 |     remainderData = NULL;
 15 |     remainderDataLength = 0;
 16 | }
 17 | 
 18 | streamDumper::streamDumper(const std::string &bindAddr, const std::string &ipaddr, int portNumber)
 19 | {
 20 |     socketActive = false;
 21 |     socketDescriptor = -1;
 22 |     subscriptionActive = false;
 23 |     remainderData = NULL;
 24 |     remainderDataLength = 0;
 25 |     openMulticastStream(bindAddr, ipaddr, portNumber);
 26 | }
 27 | 
 28 | streamDumper::~streamDumper()
 29 | {
 30 |     if (socketActive == true)
 31 |     {
 32 |         //Need to close the socket.
 33 |         closeSocket();
 34 |     }
 35 | }
 36 | 
 37 | void streamDumper::closeSocket()
 38 | {
 39 |     if (!socketActive)
 40 |         throw streamDumperException("Cannot close socket (never active).");
 41 | 
 42 |     close(socketDescriptor);
 43 | }
 44 | 
 45 | void streamDumper::openSocket()
 46 | {
 47 |     socketDescriptor = socket(AF_INET, SOCK_DGRAM, 0);
 48 | 
 49 |     //Check for errors
 50 |     if (socketDescriptor < 0)
 51 |     {
 52 |         //Throw an exception
 53 |         throw streamDumperException("Unable to create a socket.");
 54 |     }
 55 | 
 56 |     socketActive = true;
 57 | }
 58 | 
 59 | void streamDumper::openMulticastStream(const std::string &bindAddr, const std::string &ipaddr, int portnum)
 60 | {
 61 |     //Check
 62 |     if (socketActive)
 63 |         throw streamDumperException("Socket is already active.");
 64 |     if (subscriptionActive)
 65 |         throw streamDumperException("Already subscribed to a multicast stream.");
 66 | 
 67 |     //Setup the ip structure
 68 |     ip_mreq multicastSubscriptionReq;
 69 |     if (!inet_aton(ipaddr.c_str(), &multicastSubscriptionReq.imr_multiaddr))
 70 |         throw streamDumperException("Invalid IP address specified.");
 71 |     if (!inet_aton(bindAddr.c_str(), &multicastSubscriptionReq.imr_interface))
 72 |         throw streamDumperException("Invalid bind address specified.");
 73 |     //multicastSubscriptionReq.imr_interface.s_addr = htonl(INADDR_ANY);
 74 |     
 75 |     //Open the socket
 76 |     openSocket();
 77 | 
 78 |     //Bind the socket
 79 |     sockaddr_in bindStruct;
 80 |     memset(&bindStruct, 0, sizeof(bindStruct));
 81 |     bindStruct.sin_family = AF_INET;
 82 |     bindStruct.sin_addr.s_addr = htonl(INADDR_ANY);
 83 |     bindStruct.sin_port = htons(portnum);
 84 |     if (bind(socketDescriptor, (sockaddr *) &bindStruct, sizeof(bindStruct)) != 0)
 85 |         throw streamDumperException("Unable to bind socket to address.");
 86 | 
 87 |     //Attempt to join the multicast group
 88 |     if (setsockopt(socketDescriptor, IPPROTO_IP, IP_ADD_MEMBERSHIP, &multicastSubscriptionReq, sizeof(multicastSubscriptionReq)) != 0)
 89 |         throw streamDumperException("Unable to join multicast group.");
 90 | 
 91 |     subscriptionActive = true;
 92 | }
 93 | 
 94 | void streamDumper::getSocketData(unsigned char *buf, unsigned long buflen)
 95 | {
 96 |     if (!socketActive)
 97 |         throw streamDumperException("Cannot receive data. Socket not active.");
 98 |     if (!subscriptionActive)
 99 |         throw streamDumperException("Cannot receive data. Not subscribed to multicast group.");
100 |     if (buflen < 1)
101 |         return;
102 | 
103 |     unsigned char packetBuf[2048];
104 |     unsigned long curCache = remainderDataLength;
105 |     unsigned char *pos = buf;
106 |     std::list<RTPPacket> packets;
107 | 
108 |     while (curCache < buflen)
109 |     {
110 |         ssize_t num_bytes = recvfrom(socketDescriptor, packetBuf, 2048, 0, NULL, NULL);
111 |         RTPPacket rtpPacket(packetBuf, num_bytes);
112 |         curCache += rtpPacket.getContentLength();
113 |         packets.push_back(rtpPacket);
114 |     }
115 | 
116 |     packets.sort();
117 | 
118 |     //Add the remainder data to the buffer
119 |     if (remainderDataLength > 0)
120 |     {
121 |         if (remainderDataLength < buflen)
122 |         {
123 |             memcpy(pos, remainderData, remainderDataLength);
124 |             pos += remainderDataLength;
125 |             remainderDataLength = 0;
126 |             delete[] remainderData;
127 |             remainderData = NULL;
128 |         }
129 |         else
130 |         {
131 |             //Buffer is not big enough to hold entirety of remainder data
132 |             memcpy(pos, remainderData, buflen);
133 |             unsigned char *leftOverBytes = new unsigned char[remainderDataLength-buflen];
134 |             memcpy(leftOverBytes, remainderData+buflen, remainderDataLength-buflen);
135 |             setRemainderData(leftOverBytes, remainderDataLength-buflen, packets);
136 |             delete[] leftOverBytes;
137 |             return;
138 |         }
139 |     }
140 | 
141 |     //Add the packet data
142 |     std::list<RTPPacket>::iterator it = packets.begin();
143 |     while (pos < (buf + buflen))
144 |     {
145 |         if ((*it).getContentLength() < ((buf + buflen) - pos))
146 |         {
147 |             //Copy the whole packet in
148 |             memcpy(pos, (*it).getContent(), (*it).getContentLength());
149 |             pos += (*it).getContentLength();
150 |             it++;
151 |             packets.pop_front();
152 |         }
153 |         else
154 |         {
155 |             //Need to copy only some of the packet in
156 |             unsigned char *endbuf = buf + buflen;
157 |             unsigned long numLeftOverBytes = (*it).getContentLength() - (endbuf - pos);
158 |             unsigned long numBytesToWrite = endbuf - pos;
159 |             memcpy(pos, (*it).getContent(), numBytesToWrite);
160 |             unsigned char *leftOverBytes = new unsigned char[numLeftOverBytes];
161 |             memcpy(leftOverBytes, (*it).getContent() + numBytesToWrite, numLeftOverBytes);
162 |             it++;
163 |             packets.pop_front();
164 |             setRemainderData(leftOverBytes, numLeftOverBytes, packets);
165 |             delete[] leftOverBytes;
166 |             return;
167 |         }
168 |     }
169 |     
170 | 
171 | //    std::cout << "Recv'd " << num_bytes << " from the socket." << std::endl;
172 | //    std::cout << "Version: " << rtpHead.getVersion() << std::endl;
173 | //    std::cout << "Padding: " << rtpHead.hasPadding() << std::endl;
174 | //    std::cout << "Extensions: " << rtpHead.hasExtension() << std::endl;
175 | //    std::cout << "CSRCCount: " << rtpHead.getCSRCCount() << std::endl;
176 | //    std::cout << "PayloadType: " << rtpHead.getPayloadType() << std::endl;
177 | //    std::cout << "Sequence #: " << rtpPacket.header.getSequenceNumber() << std::endl;
178 | //    std::cout << "Timestamp: " << rtpHead.getTimestamp() << std::endl;
179 | //    std::cout << "SSRC: " << rtpHead.getSSRCIdentifier() << std::endl << std::endl;
180 | //    std::cout << "Header Length: " << rtpPacket.header.getHeaderLength() << std::endl;
181 | //    std::cout << "Content Length: " << rtpPacket.getContentLength() << std::endl;
182 | }
183 | 
184 | void streamDumper::setRemainderData(const unsigned char *data, unsigned long data_len, const std::list<RTPPacket>& l)
185 | {
186 |     //Determine how much data we have here
187 |     unsigned long newRemainderDataLength = data_len;
188 |     for (std::list<RTPPacket>::const_iterator i = l.begin(); i != l.end(); i++)
189 |     {
190 |         newRemainderDataLength += (*i).getContentLength();
191 |     }
192 | 
193 |     unsigned char *newRemainderData = new unsigned char[newRemainderDataLength];
194 |     unsigned char *pos = newRemainderData;
195 | 
196 |     //Copy the raw data
197 |     memcpy(pos, data, data_len);
198 |     pos += data_len;
199 | 
200 |     //Copy the data from full packets
201 |     for (std::list<RTPPacket>::const_iterator i = l.begin(); i != l.end(); i++)
202 |     {
203 |         memcpy(pos, (*i).getContent(), (*i).getContentLength());
204 |         pos += (*i).getContentLength();
205 |     }
206 | 
207 |     //Clear the old remainder data and set new data
208 |     delete[] remainderData;
209 |     remainderData = newRemainderData;
210 |     remainderDataLength = newRemainderDataLength;
211 | }
212 | 
213 | streamDumper::RTPHeader::RTPHeader()
214 | {
215 |     version = 0;
216 |     padding = false;
217 |     extensions = false;
218 |     CSRCCount = 0;
219 |     payloadType = 0;
220 |     sequenceNumber = 0;
221 |     timeStamp = 0;
222 |     SSRCIdentifier = 0;
223 |     extensionLength = 0;
224 | }
225 | 
226 | streamDumper::RTPHeader::~RTPHeader() { };
227 | 
228 | streamDumper::RTPHeader::RTPHeader(unsigned char *in)
229 | {
230 |     version = 0;
231 |     padding = false;
232 |     extensions = false;
233 |     CSRCCount = 0;
234 |     payloadType = 0;
235 |     sequenceNumber = 0;
236 |     timeStamp = 0;
237 |     SSRCIdentifier = 0;
238 |     extensionLength = 0;
239 |     readData(in);
240 | }
241 | 
242 | void streamDumper::RTPHeader::readData(unsigned char *in)
243 | {
244 |     version = (in[0] & 192) >> 6;
245 |     padding = in[0] & (1 << 5);
246 |     extensions = in[0] & (1 << 4);
247 |     CSRCCount = ((1 << 3) | (1 << 2) | (1 << 1) | 1) & in[0];
248 |     payloadType = in[1] & ~128;
249 |     sequenceNumber = (in[2] << 8) | (in[3]);
250 |     timeStamp = (in[4] << 24) | (in[5] << 16) | (in[6] << 8) | in[7];
251 |     SSRCIdentifier = (in[8] << 24) | (in[9] << 16) | (in[10] << 8) | in[11];
252 | 
253 |     //Extenstion length code
254 |     if (extensions)
255 |     {
256 |         unsigned long ind = 16 + 4*CSRCCount + 2;
257 |         extensionLength = (in[ind] << 8) | in[ind+1];
258 |         extensionLength = (extensionLength+1)*4;
259 |     }
260 |     else
261 |     {
262 |         extensionLength = 0;
263 |     }
264 | }
265 | 
266 | unsigned long streamDumper::RTPHeader::getHeaderLength() const
267 | {
268 |     return 12 + 4*CSRCCount + extensionLength;
269 | }
270 | 
271 | int streamDumper::RTPHeader::getVersion() const
272 | {
273 |     return version;
274 | }
275 | 
276 | bool streamDumper::RTPHeader::hasPadding() const
277 | {
278 |     return padding;
279 | }
280 | 
281 | bool streamDumper::RTPHeader::hasExtension() const
282 | {
283 |     return extensions;
284 | }
285 | 
286 | unsigned int streamDumper::RTPHeader::getCSRCCount() const
287 | {
288 |     return CSRCCount;
289 | }
290 | 
291 | unsigned int streamDumper::RTPHeader::getPayloadType() const
292 | {
293 |     return payloadType;
294 | }
295 | 
296 | unsigned long streamDumper::RTPHeader::getSequenceNumber() const
297 | {
298 |     return sequenceNumber;
299 | }
300 | 
301 | unsigned long streamDumper::RTPHeader::getTimestamp() const
302 | {
303 |     return timeStamp;
304 | }
305 | 
306 | unsigned long streamDumper::RTPHeader::getSSRCIdentifier() const
307 | {
308 |     return SSRCIdentifier;
309 | }
310 | 
311 | streamDumper::RTPPacket::RTPPacket()
312 | {
313 |     content = NULL;
314 |     contentLength = 0;
315 | }
316 | 
317 | streamDumper::RTPPacket::~RTPPacket()
318 | {
319 |     if (content != NULL)
320 |         delete[] content;
321 | }
322 | 
323 | streamDumper::RTPPacket::RTPPacket(unsigned char *in, unsigned long in_len)
324 | {
325 |     content = NULL;
326 |     contentLength = 0;
327 |     readData(in, in_len);
328 | }
329 | 
330 | void streamDumper::RTPPacket::readData(unsigned char *in, unsigned long in_len)
331 | {
332 |     if (in_len < 12)
333 |         throw streamDumperException("RTP Packet must be at least 12 bytes long.");
334 | 
335 |     header.readData(in);
336 |     contentLength = in_len - header.getHeaderLength();
337 |     if (contentLength > 0)
338 |     {
339 |         content = new unsigned char[contentLength];
340 |         memcpy(content, in+header.getHeaderLength(), contentLength);
341 |     }
342 | }
343 | 
344 | unsigned long streamDumper::RTPPacket::getContentLength() const
345 | {
346 |     return contentLength;
347 | }
348 | 
349 | unsigned char *streamDumper::RTPPacket::getContent() const
350 | {
351 |     return content;
352 | }
353 | 
354 | streamDumper::RTPPacket::RTPPacket(const RTPPacket &b)
355 | {
356 |     //Copy constructor
357 |     if (b.contentLength > 0)
358 |     {
359 |         contentLength = b.contentLength;
360 |         header = b.header;
361 |         content = new unsigned char[contentLength];
362 |         memcpy(content, b.content, contentLength);
363 |     }
364 |     else
365 |     {
366 |         contentLength = 0;
367 |         content = NULL;
368 |     };
369 | 
370 | }
371 | 
372 | streamDumper::RTPPacket& streamDumper::RTPPacket::operator=(const streamDumper::RTPPacket &b)
373 | {
374 |     //Assignment operator
375 |     if (contentLength > 0)
376 |     {
377 |         //Clear old memory
378 |         delete[] content;
379 |     }
380 | 
381 |     if (b.contentLength > 0)
382 |     {
383 |         header = b.header;
384 |         contentLength = b.contentLength;
385 |         content = new unsigned char[contentLength];
386 |         memcpy(content, b.content, contentLength);
387 |     }
388 |     else
389 |     {
390 |         header = b.header;
391 |         contentLength = 0;
392 |         content = NULL;
393 |     }
394 | 
395 |     return *this;
396 | }
397 | 
398 | bool streamDumper::RTPPacket::operator<(const RTPPacket &b) const
399 | {
400 |     unsigned long seq_a, seq_b;
401 |     seq_a = header.getSequenceNumber();
402 |     seq_b = b.header.getSequenceNumber();
403 | 
404 |     if (seq_a < seq_b)
405 |     {
406 |         if ((seq_b - seq_a) < 32768)
407 |         {
408 |             //No wrap around
409 |             return true;
410 |         }
411 |         else
412 |         {
413 |             //Wrap around
414 |             return false;
415 |         }
416 |     }
417 |     else
418 |     {
419 |         // b < a
420 |         if ((seq_a - seq_b) < 32768)
421 |         {
422 |             //No wrap around
423 |             return false;
424 |         }
425 |         else
426 |         {
427 |             //Wrap around
428 |             return true;
429 |         }
430 |     }
431 | 
432 | }
433 | 


--------------------------------------------------------------------------------
/lib/rapidxml-1.13/rapidxml_print.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef RAPIDXML_PRINT_HPP_INCLUDED
  2 | #define RAPIDXML_PRINT_HPP_INCLUDED
  3 | 
  4 | // Copyright (C) 2006, 2009 Marcin Kalicinski
  5 | // Version 1.13
  6 | // Revision $DateTime: 2009/05/13 01:46:17 $
  7 | //! \file rapidxml_print.hpp This file contains rapidxml printer implementation
  8 | 
  9 | #include "rapidxml.hpp"
 10 | 
 11 | // Only include streams if not disabled
 12 | #ifndef RAPIDXML_NO_STREAMS
 13 |     #include <ostream>
 14 |     #include <iterator>
 15 | #endif
 16 | 
 17 | namespace rapidxml
 18 | {
 19 | 
 20 |     ///////////////////////////////////////////////////////////////////////
 21 |     // Printing flags
 22 | 
 23 |     const int print_no_indenting = 0x1;   //!< Printer flag instructing the printer to suppress indenting of XML. See print() function.
 24 | 
 25 |     ///////////////////////////////////////////////////////////////////////
 26 |     // Internal
 27 | 
 28 |     //! \cond internal
 29 |     namespace internal
 30 |     {
 31 |         
 32 |         ///////////////////////////////////////////////////////////////////////////
 33 |         // Internal character operations
 34 |     
 35 |         // Copy characters from given range to given output iterator
 36 |         template<class OutIt, class Ch>
 37 |         inline OutIt copy_chars(const Ch *begin, const Ch *end, OutIt out)
 38 |         {
 39 |             while (begin != end)
 40 |                 *out++ = *begin++;
 41 |             return out;
 42 |         }
 43 |         
 44 |         // Copy characters from given range to given output iterator and expand
 45 |         // characters into references (&lt; &gt; &apos; &quot; &amp;)
 46 |         template<class OutIt, class Ch>
 47 |         inline OutIt copy_and_expand_chars(const Ch *begin, const Ch *end, Ch noexpand, OutIt out)
 48 |         {
 49 |             while (begin != end)
 50 |             {
 51 |                 if (*begin == noexpand)
 52 |                 {
 53 |                     *out++ = *begin;    // No expansion, copy character
 54 |                 }
 55 |                 else
 56 |                 {
 57 |                     switch (*begin)
 58 |                     {
 59 |                     case Ch('<'):
 60 |                         *out++ = Ch('&'); *out++ = Ch('l'); *out++ = Ch('t'); *out++ = Ch(';');
 61 |                         break;
 62 |                     case Ch('>'): 
 63 |                         *out++ = Ch('&'); *out++ = Ch('g'); *out++ = Ch('t'); *out++ = Ch(';');
 64 |                         break;
 65 |                     case Ch('\''): 
 66 |                         *out++ = Ch('&'); *out++ = Ch('a'); *out++ = Ch('p'); *out++ = Ch('o'); *out++ = Ch('s'); *out++ = Ch(';');
 67 |                         break;
 68 |                     case Ch('"'): 
 69 |                         *out++ = Ch('&'); *out++ = Ch('q'); *out++ = Ch('u'); *out++ = Ch('o'); *out++ = Ch('t'); *out++ = Ch(';');
 70 |                         break;
 71 |                     case Ch('&'): 
 72 |                         *out++ = Ch('&'); *out++ = Ch('a'); *out++ = Ch('m'); *out++ = Ch('p'); *out++ = Ch(';'); 
 73 |                         break;
 74 |                     default:
 75 |                         *out++ = *begin;    // No expansion, copy character
 76 |                     }
 77 |                 }
 78 |                 ++begin;    // Step to next character
 79 |             }
 80 |             return out;
 81 |         }
 82 | 
 83 |         // Fill given output iterator with repetitions of the same character
 84 |         template<class OutIt, class Ch>
 85 |         inline OutIt fill_chars(OutIt out, int n, Ch ch)
 86 |         {
 87 |             for (int i = 0; i < n; ++i)
 88 |                 *out++ = ch;
 89 |             return out;
 90 |         }
 91 | 
 92 |         // Find character
 93 |         template<class Ch, Ch ch>
 94 |         inline bool find_char(const Ch *begin, const Ch *end)
 95 |         {
 96 |             while (begin != end)
 97 |                 if (*begin++ == ch)
 98 |                     return true;
 99 |             return false;
100 |         }
101 | 
102 |         ///////////////////////////////////////////////////////////////////////////
103 |         // Internal printing operations
104 |     
105 |         // Print node
106 |         template<class OutIt, class Ch>
107 |         inline OutIt print_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)
108 |         {
109 |             // Print proper node type
110 |             switch (node->type())
111 |             {
112 | 
113 |             // Document
114 |             case node_document:
115 |                 out = print_children(out, node, flags, indent);
116 |                 break;
117 | 
118 |             // Element
119 |             case node_element:
120 |                 out = print_element_node(out, node, flags, indent);
121 |                 break;
122 |             
123 |             // Data
124 |             case node_data:
125 |                 out = print_data_node(out, node, flags, indent);
126 |                 break;
127 |             
128 |             // CDATA
129 |             case node_cdata:
130 |                 out = print_cdata_node(out, node, flags, indent);
131 |                 break;
132 | 
133 |             // Declaration
134 |             case node_declaration:
135 |                 out = print_declaration_node(out, node, flags, indent);
136 |                 break;
137 | 
138 |             // Comment
139 |             case node_comment:
140 |                 out = print_comment_node(out, node, flags, indent);
141 |                 break;
142 |             
143 |             // Doctype
144 |             case node_doctype:
145 |                 out = print_doctype_node(out, node, flags, indent);
146 |                 break;
147 | 
148 |             // Pi
149 |             case node_pi:
150 |                 out = print_pi_node(out, node, flags, indent);
151 |                 break;
152 | 
153 |                 // Unknown
154 |             default:
155 |                 assert(0);
156 |                 break;
157 |             }
158 |             
159 |             // If indenting not disabled, add line break after node
160 |             if (!(flags & print_no_indenting))
161 |                 *out = Ch('\n'), ++out;
162 | 
163 |             // Return modified iterator
164 |             return out;
165 |         }
166 |         
167 |         // Print children of the node                               
168 |         template<class OutIt, class Ch>
169 |         inline OutIt print_children(OutIt out, const xml_node<Ch> *node, int flags, int indent)
170 |         {
171 |             for (xml_node<Ch> *child = node->first_node(); child; child = child->next_sibling())
172 |                 out = print_node(out, child, flags, indent);
173 |             return out;
174 |         }
175 | 
176 |         // Print attributes of the node
177 |         template<class OutIt, class Ch>
178 |         inline OutIt print_attributes(OutIt out, const xml_node<Ch> *node, int flags)
179 |         {
180 |             for (xml_attribute<Ch> *attribute = node->first_attribute(); attribute; attribute = attribute->next_attribute())
181 |             {
182 |                 if (attribute->name() && attribute->value())
183 |                 {
184 |                     // Print attribute name
185 |                     *out = Ch(' '), ++out;
186 |                     out = copy_chars(attribute->name(), attribute->name() + attribute->name_size(), out);
187 |                     *out = Ch('='), ++out;
188 |                     // Print attribute value using appropriate quote type
189 |                     if (find_char<Ch, Ch('"')>(attribute->value(), attribute->value() + attribute->value_size()))
190 |                     {
191 |                         *out = Ch('\''), ++out;
192 |                         out = copy_and_expand_chars(attribute->value(), attribute->value() + attribute->value_size(), Ch('"'), out);
193 |                         *out = Ch('\''), ++out;
194 |                     }
195 |                     else
196 |                     {
197 |                         *out = Ch('"'), ++out;
198 |                         out = copy_and_expand_chars(attribute->value(), attribute->value() + attribute->value_size(), Ch('\''), out);
199 |                         *out = Ch('"'), ++out;
200 |                     }
201 |                 }
202 |             }
203 |             return out;
204 |         }
205 | 
206 |         // Print data node
207 |         template<class OutIt, class Ch>
208 |         inline OutIt print_data_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)
209 |         {
210 |             assert(node->type() == node_data);
211 |             if (!(flags & print_no_indenting))
212 |                 out = fill_chars(out, indent, Ch('\t'));
213 |             out = copy_and_expand_chars(node->value(), node->value() + node->value_size(), Ch(0), out);
214 |             return out;
215 |         }
216 | 
217 |         // Print data node
218 |         template<class OutIt, class Ch>
219 |         inline OutIt print_cdata_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)
220 |         {
221 |             assert(node->type() == node_cdata);
222 |             if (!(flags & print_no_indenting))
223 |                 out = fill_chars(out, indent, Ch('\t'));
224 |             *out = Ch('<'); ++out;
225 |             *out = Ch('!'); ++out;
226 |             *out = Ch('['); ++out;
227 |             *out = Ch('C'); ++out;
228 |             *out = Ch('D'); ++out;
229 |             *out = Ch('A'); ++out;
230 |             *out = Ch('T'); ++out;
231 |             *out = Ch('A'); ++out;
232 |             *out = Ch('['); ++out;
233 |             out = copy_chars(node->value(), node->value() + node->value_size(), out);
234 |             *out = Ch(']'); ++out;
235 |             *out = Ch(']'); ++out;
236 |             *out = Ch('>'); ++out;
237 |             return out;
238 |         }
239 | 
240 |         // Print element node
241 |         template<class OutIt, class Ch>
242 |         inline OutIt print_element_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)
243 |         {
244 |             assert(node->type() == node_element);
245 | 
246 |             // Print element name and attributes, if any
247 |             if (!(flags & print_no_indenting))
248 |                 out = fill_chars(out, indent, Ch('\t'));
249 |             *out = Ch('<'), ++out;
250 |             out = copy_chars(node->name(), node->name() + node->name_size(), out);
251 |             out = print_attributes(out, node, flags);
252 |             
253 |             // If node is childless
254 |             if (node->value_size() == 0 && !node->first_node())
255 |             {
256 |                 // Print childless node tag ending
257 |                 *out = Ch('/'), ++out;
258 |                 *out = Ch('>'), ++out;
259 |             }
260 |             else
261 |             {
262 |                 // Print normal node tag ending
263 |                 *out = Ch('>'), ++out;
264 | 
265 |                 // Test if node contains a single data node only (and no other nodes)
266 |                 xml_node<Ch> *child = node->first_node();
267 |                 if (!child)
268 |                 {
269 |                     // If node has no children, only print its value without indenting
270 |                     out = copy_and_expand_chars(node->value(), node->value() + node->value_size(), Ch(0), out);
271 |                 }
272 |                 else if (child->next_sibling() == 0 && child->type() == node_data)
273 |                 {
274 |                     // If node has a sole data child, only print its value without indenting
275 |                     out = copy_and_expand_chars(child->value(), child->value() + child->value_size(), Ch(0), out);
276 |                 }
277 |                 else
278 |                 {
279 |                     // Print all children with full indenting
280 |                     if (!(flags & print_no_indenting))
281 |                         *out = Ch('\n'), ++out;
282 |                     out = print_children(out, node, flags, indent + 1);
283 |                     if (!(flags & print_no_indenting))
284 |                         out = fill_chars(out, indent, Ch('\t'));
285 |                 }
286 | 
287 |                 // Print node end
288 |                 *out = Ch('<'), ++out;
289 |                 *out = Ch('/'), ++out;
290 |                 out = copy_chars(node->name(), node->name() + node->name_size(), out);
291 |                 *out = Ch('>'), ++out;
292 |             }
293 |             return out;
294 |         }
295 | 
296 |         // Print declaration node
297 |         template<class OutIt, class Ch>
298 |         inline OutIt print_declaration_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)
299 |         {
300 |             // Print declaration start
301 |             if (!(flags & print_no_indenting))
302 |                 out = fill_chars(out, indent, Ch('\t'));
303 |             *out = Ch('<'), ++out;
304 |             *out = Ch('?'), ++out;
305 |             *out = Ch('x'), ++out;
306 |             *out = Ch('m'), ++out;
307 |             *out = Ch('l'), ++out;
308 | 
309 |             // Print attributes
310 |             out = print_attributes(out, node, flags);
311 |             
312 |             // Print declaration end
313 |             *out = Ch('?'), ++out;
314 |             *out = Ch('>'), ++out;
315 |             
316 |             return out;
317 |         }
318 | 
319 |         // Print comment node
320 |         template<class OutIt, class Ch>
321 |         inline OutIt print_comment_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)
322 |         {
323 |             assert(node->type() == node_comment);
324 |             if (!(flags & print_no_indenting))
325 |                 out = fill_chars(out, indent, Ch('\t'));
326 |             *out = Ch('<'), ++out;
327 |             *out = Ch('!'), ++out;
328 |             *out = Ch('-'), ++out;
329 |             *out = Ch('-'), ++out;
330 |             out = copy_chars(node->value(), node->value() + node->value_size(), out);
331 |             *out = Ch('-'), ++out;
332 |             *out = Ch('-'), ++out;
333 |             *out = Ch('>'), ++out;
334 |             return out;
335 |         }
336 | 
337 |         // Print doctype node
338 |         template<class OutIt, class Ch>
339 |         inline OutIt print_doctype_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)
340 |         {
341 |             assert(node->type() == node_doctype);
342 |             if (!(flags & print_no_indenting))
343 |                 out = fill_chars(out, indent, Ch('\t'));
344 |             *out = Ch('<'), ++out;
345 |             *out = Ch('!'), ++out;
346 |             *out = Ch('D'), ++out;
347 |             *out = Ch('O'), ++out;
348 |             *out = Ch('C'), ++out;
349 |             *out = Ch('T'), ++out;
350 |             *out = Ch('Y'), ++out;
351 |             *out = Ch('P'), ++out;
352 |             *out = Ch('E'), ++out;
353 |             *out = Ch(' '), ++out;
354 |             out = copy_chars(node->value(), node->value() + node->value_size(), out);
355 |             *out = Ch('>'), ++out;
356 |             return out;
357 |         }
358 | 
359 |         // Print pi node
360 |         template<class OutIt, class Ch>
361 |         inline OutIt print_pi_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)
362 |         {
363 |             assert(node->type() == node_pi);
364 |             if (!(flags & print_no_indenting))
365 |                 out = fill_chars(out, indent, Ch('\t'));
366 |             *out = Ch('<'), ++out;
367 |             *out = Ch('?'), ++out;
368 |             out = copy_chars(node->name(), node->name() + node->name_size(), out);
369 |             *out = Ch(' '), ++out;
370 |             out = copy_chars(node->value(), node->value() + node->value_size(), out);
371 |             *out = Ch('?'), ++out;
372 |             *out = Ch('>'), ++out;
373 |             return out;
374 |         }
375 | 
376 |     }
377 |     //! \endcond
378 | 
379 |     ///////////////////////////////////////////////////////////////////////////
380 |     // Printing
381 | 
382 |     //! Prints XML to given output iterator.
383 |     //! \param out Output iterator to print to.
384 |     //! \param node Node to be printed. Pass xml_document to print entire document.
385 |     //! \param flags Flags controlling how XML is printed.
386 |     //! \return Output iterator pointing to position immediately after last character of printed text.
387 |     template<class OutIt, class Ch> 
388 |     inline OutIt print(OutIt out, const xml_node<Ch> &node, int flags = 0)
389 |     {
390 |         return internal::print_node(out, &node, flags, 0);
391 |     }
392 | 
393 | #ifndef RAPIDXML_NO_STREAMS
394 | 
395 |     //! Prints XML to given output stream.
396 |     //! \param out Output stream to print to.
397 |     //! \param node Node to be printed. Pass xml_document to print entire document.
398 |     //! \param flags Flags controlling how XML is printed.
399 |     //! \return Output stream.
400 |     template<class Ch> 
401 |     inline std::basic_ostream<Ch> &print(std::basic_ostream<Ch> &out, const xml_node<Ch> &node, int flags = 0)
402 |     {
403 |         print(std::ostream_iterator<Ch>(out), node, flags);
404 |         return out;
405 |     }
406 | 
407 |     //! Prints formatted XML to given output stream. Uses default printing flags. Use print() function to customize printing process.
408 |     //! \param out Output stream to print to.
409 |     //! \param node Node to be printed.
410 |     //! \return Output stream.
411 |     template<class Ch> 
412 |     inline std::basic_ostream<Ch> &operator <<(std::basic_ostream<Ch> &out, const xml_node<Ch> &node)
413 |     {
414 |         return print(out, node);
415 |     }
416 | 
417 | #endif
418 | 
419 | }
420 | 
421 | #endif
422 | 


--------------------------------------------------------------------------------
/lib/rapidxml-1.13/manual.html:
--------------------------------------------------------------------------------
  1 | <html><head><style type="text/css">
  2 | 
  3 |           body
  4 |           {
  5 |           font-family: sans-serif;
  6 |           font-size: 90%;
  7 |           margin: 8pt 8pt 8pt 8pt;
  8 |           text-align: justify;
  9 |           background-color: White;
 10 |           }
 11 | 
 12 |           h1 { font-weight: bold; text-align: left;  }
 13 |           h2 { font: 140% sans-serif; font-weight: bold; text-align: left;  }
 14 |           h3 { font: 120% sans-serif; font-weight: bold; text-align: left;  }
 15 |           h4 { font: bold 100% sans-serif; font-weight: bold; text-align: left;  }
 16 |           h5 { font: italic 100% sans-serif; font-weight: bold; text-align: left;  }
 17 |           h6 { font: small-caps 100% sans-serif; font-weight: bold; text-align: left;  }
 18 | 
 19 |           code
 20 |           {
 21 |           font-family: &quot;Courier New&quot;, Courier, mono;
 22 |           }
 23 | 
 24 |           pre
 25 |           {
 26 |           border-top: gray 0.5pt solid;
 27 |           border-right: gray 0.5pt solid;
 28 |           border-left: gray 0.5pt solid;
 29 |           border-bottom: gray 0.5pt solid;
 30 |           padding-top: 2pt;
 31 |           padding-right: 2pt;
 32 |           padding-left: 2pt;
 33 |           padding-bottom: 2pt;
 34 |           display: block;
 35 |           font-family: &quot;courier new&quot;, courier, mono;
 36 |           background-color: #eeeeee;
 37 |           }
 38 | 
 39 |           a
 40 |           {
 41 |           color: #000080;
 42 |           text-decoration: none;
 43 |           }
 44 | 
 45 |           a:hover
 46 |           {
 47 |           text-decoration: underline;
 48 |           }
 49 | 
 50 |           .reference-header
 51 |           {
 52 |           border-top: gray 0.5pt solid;
 53 |           border-right: gray 0.5pt solid;
 54 |           border-left: gray 0.5pt solid;
 55 |           border-bottom: gray 0.5pt solid;
 56 |           padding-top: 2pt;
 57 |           padding-right: 2pt;
 58 |           padding-left: 2pt;
 59 |           padding-bottom: 2pt;
 60 |           background-color: #dedede;
 61 |           }
 62 | 
 63 |           .parameter-name
 64 |           {
 65 |           font-style: italic;
 66 |           }
 67 | 
 68 |           .indented
 69 |           {
 70 |           margin-left: 0.5cm;
 71 |           }
 72 | 
 73 |           a.toc1
 74 |           {
 75 |           margin-left: 0.0cm;
 76 |           }
 77 | 
 78 |           a.toc2
 79 |           {
 80 |           margin-left: 0.75cm;
 81 |           }
 82 | 
 83 |           a.toc3
 84 |           {
 85 |           margin-left: 1.5cm;
 86 |           }
 87 | 
 88 |         </style></head><body><h1>RAPIDXML Manual</h1><h3>Version 1.13</h3><detaileddescription xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"><para><i>Copyright (C) 2006, 2009 Marcin Kalicinski</i><br/><i>See accompanying file <a href="license.txt">license.txt</a> for license information.</i><hr/><h2 level="2">Table of Contents</h2></para><para><toc><toc-contents><a href="#namespacerapidxml_1what_is_rapidxml" class="toc1">1. What is RapidXml?</a><br/><a href="#namespacerapidxml_1dependencies_and_compatibility" class="toc2">1.1 Dependencies And Compatibility</a><br/><a href="#namespacerapidxml_1character_types_and_encodings" class="toc2">1.2 Character Types And Encodings</a><br/><a href="#namespacerapidxml_1error_handling" class="toc2">1.3 Error Handling</a><br/><a href="#namespacerapidxml_1memory_allocation" class="toc2">1.4 Memory Allocation</a><br/><a href="#namespacerapidxml_1w3c_compliance" class="toc2">1.5 W3C Compliance</a><br/><a href="#namespacerapidxml_1api_design" class="toc2">1.6 API Design</a><br/><a href="#namespacerapidxml_1reliability" class="toc2">1.7 Reliability</a><br/><a href="#namespacerapidxml_1acknowledgements" class="toc2">1.8 Acknowledgements</a><br/><a href="#namespacerapidxml_1two_minute_tutorial" class="toc1">2. Two Minute Tutorial</a><br/><a href="#namespacerapidxml_1parsing" class="toc2">2.1 Parsing</a><br/><a href="#namespacerapidxml_1accessing_dom_tree" class="toc2">2.2 Accessing The DOM Tree</a><br/><a href="#namespacerapidxml_1modifying_dom_tree" class="toc2">2.3 Modifying The DOM Tree</a><br/><a href="#namespacerapidxml_1printing" class="toc2">2.4 Printing XML</a><br/><a href="#namespacerapidxml_1differences" class="toc1">3. Differences From Regular XML Parsers</a><br/><a href="#namespacerapidxml_1lifetime_of_source_text" class="toc2">3.1 Lifetime Of Source Text</a><br/><a href="#namespacerapidxml_1ownership_of_strings" class="toc2">3.2 Ownership Of Strings</a><br/><a href="#namespacerapidxml_1destructive_non_destructive" class="toc2">3.3 Destructive Vs Non-Destructive Mode</a><br/><a href="#namespacerapidxml_1performance" class="toc1">4. Performance</a><br/><a href="#namespacerapidxml_1performance_charts" class="toc2">4.1 Comparison With Other Parsers</a><br/><a href="#namespacerapidxml_1reference" class="toc1">5. Reference</a><br/></toc-contents></toc><br/></para><sect1><h2 id="namespacerapidxml_1what_is_rapidxml">1. What is RapidXml?</h2><para><a href="http://rapidxml.sourceforge.net">RapidXml</a> is an attempt to create the fastest XML DOM parser possible, while retaining useability, portability and reasonable W3C compatibility. It is an in-situ parser written in C++, with parsing speed approaching that of <code>strlen()</code> function executed on the same data. <br/><br/>
 89 |  Entire parser is contained in a single header file, so no building or linking is neccesary. To use it you just need to copy <code>rapidxml.hpp</code> file to a convenient place (such as your project directory), and include it where needed. You may also want to use printing functions contained in header <code>rapidxml_print.hpp</code>.</para><sect2><h3 id="namespacerapidxml_1dependencies_and_compatibility">1.1 Dependencies And Compatibility</h3><para>RapidXml has <i>no dependencies</i> other than a very small subset of standard C++ library (<code>&lt;cassert&gt;</code>, <code>&lt;cstdlib&gt;</code>, <code>&lt;new&gt;</code> and <code>&lt;exception&gt;</code>, unless exceptions are disabled). It should compile on any reasonably conformant compiler, and was tested on Visual C++ 2003, Visual C++ 2005, Visual C++ 2008, gcc 3, gcc 4, and Comeau 4.3.3. Care was taken that no warnings are produced on these compilers, even with highest warning levels enabled.</para></sect2><sect2><h3 id="namespacerapidxml_1character_types_and_encodings">1.2 Character Types And Encodings</h3><para>RapidXml is character type agnostic, and can work both with narrow and wide characters. Current version does not fully support UTF-16 or UTF-32, so use of wide characters is somewhat incapacitated. However, it should succesfully parse <code>wchar_t</code> strings containing UTF-16 or UTF-32 if endianness of the data matches that of the machine. UTF-8 is fully supported, including all numeric character references, which are expanded into appropriate UTF-8 byte sequences (unless you enable parse_no_utf8 flag). <br/><br/>
 90 |  Note that RapidXml performs no decoding - strings returned by name() and value() functions will contain text encoded using the same encoding as source file. Rapidxml understands and expands the following character references: <code>&amp;apos; &amp;amp; &amp;quot; &amp;lt; &amp;gt; &amp;#...;</code> Other character references are not expanded.</para></sect2><sect2><h3 id="namespacerapidxml_1error_handling">1.3 Error Handling</h3><para>By default, RapidXml uses C++ exceptions to report errors. If this behaviour is undesirable, RAPIDXML_NO_EXCEPTIONS can be defined to suppress exception code. See <a href="#classrapidxml_1_1parse__error" kindref="compound">parse_error</a> class and <a href="#namespacerapidxml_ff5d67f74437199d316d2b2660653ae1_1ff5d67f74437199d316d2b2660653ae1" kindref="member">parse_error_handler()</a> function for more information.</para></sect2><sect2><h3 id="namespacerapidxml_1memory_allocation">1.4 Memory Allocation</h3><para>RapidXml uses a special memory pool object to allocate nodes and attributes, because direct allocation using <code>new</code> operator would be far too slow. Underlying memory allocations performed by the pool can be customized by use of <a href="#classrapidxml_1_1memory__pool_c0a55a6ef0837dca67572e357100d78a_1c0a55a6ef0837dca67572e357100d78a" kindref="member">memory_pool::set_allocator()</a> function. See class <a href="#classrapidxml_1_1memory__pool" kindref="compound">memory_pool</a> for more information.</para></sect2><sect2><h3 id="namespacerapidxml_1w3c_compliance">1.5 W3C Compliance</h3><para>RapidXml is not a W3C compliant parser, primarily because it ignores DOCTYPE declarations. There is a number of other, minor incompatibilities as well. Still, it can successfully parse and produce complete trees of all valid XML files in W3C conformance suite (over 1000 files specially designed to find flaws in XML processors). In destructive mode it performs whitespace normalization and character entity substitution for a small set of built-in entities.</para></sect2><sect2><h3 id="namespacerapidxml_1api_design">1.6 API Design</h3><para>RapidXml API is minimalistic, to reduce code size as much as possible, and facilitate use in embedded environments. Additional convenience functions are provided in separate headers: <code>rapidxml_utils.hpp</code> and <code><a href="#rapidxml__print_8hpp" kindref="compound">rapidxml_print.hpp</a></code>. Contents of these headers is not an essential part of the library, and is currently not documented (otherwise than with comments in code).</para></sect2><sect2><h3 id="namespacerapidxml_1reliability">1.7 Reliability</h3><para>RapidXml is very robust and comes with a large harness of unit tests. Special care has been taken to ensure stability of the parser no matter what source text is thrown at it. One of the unit tests produces 100,000 randomly corrupted variants of XML document, which (when uncorrupted) contains all constructs recognized by RapidXml. RapidXml passes this test when it correctly recognizes that errors have been introduced, and does not crash or loop indefinitely. <br/><br/>
 91 |  Another unit test puts RapidXml head-to-head with another, well estabilished XML parser, and verifies that their outputs match across a wide variety of small and large documents. <br/><br/>
 92 |  Yet another test feeds RapidXml with over 1000 test files from W3C compliance suite, and verifies that correct results are obtained. There are also additional tests that verify each API function separately, and test that various parsing modes work as expected.</para></sect2><sect2><h3 id="namespacerapidxml_1acknowledgements">1.8 Acknowledgements</h3><para>I would like to thank Arseny Kapoulkine for his work on <a href="http://code.google.com/p/pugixml">pugixml</a>, which was an inspiration for this project. Additional thanks go to Kristen Wegner for creating <a href="http://www.codeproject.com/soap/pugxml.asp">pugxml</a>, from which pugixml was derived. Janusz Wohlfeil kindly ran RapidXml speed tests on hardware that I did not have access to, allowing me to expand performance comparison table.</para></sect2></sect1><sect1><h2 id="namespacerapidxml_1two_minute_tutorial">2. Two Minute Tutorial</h2><sect2><h3 id="namespacerapidxml_1parsing">2.1 Parsing</h3><para>The following code causes RapidXml to parse a zero-terminated string named <code>text</code>: <pre>using namespace rapidxml;
 93 | xml_document&lt;&gt; doc;    // character type defaults to char
 94 | doc.parse&lt;0&gt;(text);    // 0 means default parse flags
 95 | </pre><code>doc</code> object is now a root of DOM tree containing representation of the parsed XML. Because all RapidXml interface is contained inside namespace <code>rapidxml</code>, users must either bring contents of this namespace into scope, or fully qualify all the names. Class <a href="#classrapidxml_1_1xml__document" kindref="compound">xml_document</a> represents a root of the DOM hierarchy. By means of public inheritance, it is also an <a href="#classrapidxml_1_1xml__node" kindref="compound">xml_node</a> and a <a href="#classrapidxml_1_1memory__pool" kindref="compound">memory_pool</a>. Template parameter of <a href="#classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c" kindref="member">xml_document::parse()</a> function is used to specify parsing flags, with which you can fine-tune behaviour of the parser. Note that flags must be a compile-time constant.</para></sect2><sect2><h3 id="namespacerapidxml_1accessing_dom_tree">2.2 Accessing The DOM Tree</h3><para>To access the DOM tree, use methods of <a href="#classrapidxml_1_1xml__node" kindref="compound">xml_node</a> and <a href="#classrapidxml_1_1xml__attribute" kindref="compound">xml_attribute</a> classes: <pre>cout &lt;&lt; &quot;Name of my first node is: &quot; &lt;&lt; doc.first_node()-&gt;name() &lt;&lt; &quot;\n&quot;;
 96 | xml_node&lt;&gt; *node = doc.first_node(&quot;foobar&quot;);
 97 | cout &lt;&lt; &quot;Node foobar has value &quot; &lt;&lt; node-&gt;value() &lt;&lt; &quot;\n&quot;;
 98 | for (xml_attribute&lt;&gt; *attr = node-&gt;first_attribute();
 99 |      attr; attr = attr-&gt;next_attribute())
100 | {
101 |     cout &lt;&lt; &quot;Node foobar has attribute &quot; &lt;&lt; attr-&gt;name() &lt;&lt; &quot; &quot;;
102 |     cout &lt;&lt; &quot;with value &quot; &lt;&lt; attr-&gt;value() &lt;&lt; &quot;\n&quot;;
103 | }
104 | </pre></para></sect2><sect2><h3 id="namespacerapidxml_1modifying_dom_tree">2.3 Modifying The DOM Tree</h3><para>DOM tree produced by the parser is fully modifiable. Nodes and attributes can be added/removed, and their contents changed. The below example creates a HTML document, whose sole contents is a link to google.com website: <pre>xml_document&lt;&gt; doc;
105 | xml_node&lt;&gt; *node = doc.allocate_node(node_element, &quot;a&quot;, &quot;Google&quot;);
106 | doc.append_node(node);
107 | xml_attribute&lt;&gt; *attr = doc.allocate_attribute(&quot;href&quot;, &quot;google.com&quot;);
108 | node-&gt;append_attribute(attr);
109 | </pre> One quirk is that nodes and attributes <i>do not own</i> the text of their names and values. This is because normally they only store pointers to the source text. So, when assigning a new name or value to the node, care must be taken to ensure proper lifetime of the string. The easiest way to achieve it is to allocate the string from the <a href="#classrapidxml_1_1xml__document" kindref="compound">xml_document</a> memory pool. In the above example this is not necessary, because we are only assigning character constants. But the code below uses <a href="#classrapidxml_1_1memory__pool_69729185bc59b0875192d667c47b8859_169729185bc59b0875192d667c47b8859" kindref="member">memory_pool::allocate_string()</a> function to allocate node name (which will have the same lifetime as the document), and assigns it to a new node: <pre>xml_document&lt;&gt; doc;
110 | char *node_name = doc.allocate_string(name);        // Allocate string and copy name into it
111 | xml_node&lt;&gt; *node = doc.allocate_node(node_element, node_name);  // Set node name to node_name
112 | </pre> Check <a href="#namespacerapidxml_1reference" kindref="member">Reference</a>  section for description of the entire interface.</para></sect2><sect2><h3 id="namespacerapidxml_1printing">2.4 Printing XML</h3><para>You can print <code><a href="#classrapidxml_1_1xml__document" kindref="compound">xml_document</a></code> and <code><a href="#classrapidxml_1_1xml__node" kindref="compound">xml_node</a></code> objects into an XML string. Use <a href="#namespacerapidxml_b94d570fc4c4ab2423813cd0243326b1_1b94d570fc4c4ab2423813cd0243326b1" kindref="member">print()</a> function or operator &lt;&lt;, which are defined in <code><a href="#rapidxml__print_8hpp" kindref="compound">rapidxml_print.hpp</a></code> header. <pre>using namespace rapidxml;
113 | xml_document&lt;&gt; doc;    // character type defaults to char
114 | // ... some code to fill the document
115 | 
116 | // Print to stream using operator &lt;&lt;
117 | std::cout &lt;&lt; doc;   
118 | 
119 | // Print to stream using print function, specifying printing flags
120 | print(std::cout, doc, 0);   // 0 means default printing flags
121 | 
122 | // Print to string using output iterator
123 | std::string s;
124 | print(std::back_inserter(s), doc, 0);
125 | 
126 | // Print to memory buffer using output iterator
127 | char buffer[4096];                      // You are responsible for making the buffer large enough!
128 | char *end = print(buffer, doc, 0);      // end contains pointer to character after last printed character
129 | *end = 0;                               // Add string terminator after XML
130 | </pre></para></sect2></sect1><sect1><h2 id="namespacerapidxml_1differences">3. Differences From Regular XML Parsers</h2><para>RapidXml is an <i>in-situ parser</i>, which allows it to achieve very high parsing speed. In-situ means that parser does not make copies of strings. Instead, it places pointers to the <i>source text</i> in the DOM hierarchy.</para><sect2><h3 id="namespacerapidxml_1lifetime_of_source_text">3.1 Lifetime Of Source Text</h3><para>In-situ parsing requires that source text lives at least as long as the document object. If source text is destroyed, names and values of nodes in DOM tree will become destroyed as well. Additionally, whitespace processing, character entity translation, and zero-termination of strings require that source text be modified during parsing (but see non-destructive mode). This makes the text useless for further processing once it was parsed by RapidXml. <br/><br/>
131 |  In many cases however, these are not serious issues.</para></sect2><sect2><h3 id="namespacerapidxml_1ownership_of_strings">3.2 Ownership Of Strings</h3><para>Nodes and attributes produced by RapidXml do not own their name and value strings. They merely hold the pointers to them. This means you have to be careful when setting these values manually, by using <a href="#classrapidxml_1_1xml__base_e099c291e104a0d277307fe71f5e0f9e_1e099c291e104a0d277307fe71f5e0f9e" kindref="member">xml_base::name(const Ch *)</a> or <a href="#classrapidxml_1_1xml__base_18c7469acdca771de9b4f3054053029c_118c7469acdca771de9b4f3054053029c" kindref="member">xml_base::value(const Ch *)</a> functions. Care must be taken to ensure that lifetime of the string passed is at least as long as lifetime of the node/attribute. The easiest way to achieve it is to allocate the string from <a href="#classrapidxml_1_1memory__pool" kindref="compound">memory_pool</a> owned by the document. Use <a href="#classrapidxml_1_1memory__pool_69729185bc59b0875192d667c47b8859_169729185bc59b0875192d667c47b8859" kindref="member">memory_pool::allocate_string()</a> function for this purpose.</para></sect2><sect2><h3 id="namespacerapidxml_1destructive_non_destructive">3.3 Destructive Vs Non-Destructive Mode</h3><para>By default, the parser modifies source text during the parsing process. This is required to achieve character entity translation, whitespace normalization, and zero-termination of strings. <br/><br/>
132 |  In some cases this behaviour may be undesirable, for example if source text resides in read only memory, or is mapped to memory directly from file. By using appropriate parser flags (parse_non_destructive), source text modifications can be disabled. However, because RapidXml does in-situ parsing, it obviously has the following side-effects:<ul><li><para>no whitespace normalization is done</para></li><li><para>no entity reference translation is done</para></li><li><para>names and values are not zero-terminated, you must use <a href="#classrapidxml_1_1xml__base_0dae694c8f7e4d89f1003e2f3a15a43c_10dae694c8f7e4d89f1003e2f3a15a43c" kindref="member">xml_base::name_size()</a> and <a href="#classrapidxml_1_1xml__base_aed5ae791b7164c1ee5e649198cbb3db_1aed5ae791b7164c1ee5e649198cbb3db" kindref="member">xml_base::value_size()</a> functions to tell where they end</para></li></ul></para></sect2></sect1><sect1><h2 id="namespacerapidxml_1performance">4. Performance</h2><para>RapidXml achieves its speed through use of several techniques:<ul><li><para>In-situ parsing. When building DOM tree, RapidXml does not make copies of string data, such as node names and values. Instead, it stores pointers to interior of the source text.</para></li><li><para>Use of template metaprogramming techniques. This allows it to move much of the work to compile time. Through magic of the templates, C++ compiler generates a separate copy of parsing code for any combination of parser flags you use. In each copy, all possible decisions are made at compile time and all unused code is omitted.</para></li><li><para>Extensive use of lookup tables for parsing.</para></li><li><para>Hand-tuned C++ with profiling done on several most popular CPUs.</para></li></ul></para><para>This results in a very small and fast code: a parser which is custom tailored to exact needs with each invocation.</para><sect2><h3 id="namespacerapidxml_1performance_charts">4.1 Comparison With Other Parsers</h3><para>The table below compares speed of RapidXml to some other parsers, and to <code>strlen()</code> function executed on the same data. On a modern CPU (as of 2007), you can expect parsing throughput to be close to 1 GB/s. As a rule of thumb, parsing speed is about 50-100x faster than Xerces DOM, 30-60x faster than TinyXml, 3-12x faster than pugxml, and about 5% - 30% faster than pugixml, the fastest XML parser I know of.</para><para><ul><li><para>The test file is a real-world, 50kB large, moderately dense XML file. </para></li><li><para>All timing is done by using RDTSC instruction present in Pentium-compatible CPUs. </para></li><li><para>No profile-guided optimizations are used. </para></li><li><para>All parsers are running in their fastest modes. </para></li><li><para>The results are given in CPU cycles per character, so frequency of CPUs is irrelevant. </para></li><li><para>The results are minimum values from a large number of runs, to minimize effects of operating system activity, task switching, interrupt handling etc. </para></li><li><para>A single parse of the test file takes about 1/10th of a millisecond, so with large number of runs there is a good chance of hitting at least one no-interrupt streak, and obtaining undisturbed results. </para></li></ul><table rows="9" cols="7" border="1" cellpadding="3pt"><tr><th thead="yes"><para><center>Platform</center></para></th><th thead="yes"><para><center>Compiler</center></para></th><th thead="yes"><para>strlen() </para></th><th thead="yes"><para>RapidXml </para></th><th thead="yes"><para>pugixml 0.3 </para></th><th thead="yes"><para>pugxml </para></th><th thead="yes"><para>TinyXml  </para></th></tr><tr><td thead="no"><para><center>Pentium 4</center></para></td><td thead="no"><para><center>MSVC 8.0</center></para></td><td thead="no"><para><center>2.5</center></para></td><td thead="no"><para><center>5.4</center></para></td><td thead="no"><para><center>7.0</center></para></td><td thead="no"><para><center>61.7</center></para></td><td thead="no"><para><center>298.8</center></para></td></tr><tr><td thead="no"><para><center>Pentium 4</center></para></td><td thead="no"><para><center>gcc 4.1.1</center></para></td><td thead="no"><para><center>0.8</center></para></td><td thead="no"><para><center>6.1</center></para></td><td thead="no"><para><center>9.5</center></para></td><td thead="no"><para><center>67.0</center></para></td><td thead="no"><para><center>413.2</center></para></td></tr><tr><td thead="no"><para><center>Core 2</center></para></td><td thead="no"><para><center>MSVC 8.0</center></para></td><td thead="no"><para><center>1.0</center></para></td><td thead="no"><para><center>4.5</center></para></td><td thead="no"><para><center>5.0</center></para></td><td thead="no"><para><center>24.6</center></para></td><td thead="no"><para><center>154.8</center></para></td></tr><tr><td thead="no"><para><center>Core 2</center></para></td><td thead="no"><para><center>gcc 4.1.1</center></para></td><td thead="no"><para><center>0.6</center></para></td><td thead="no"><para><center>4.6</center></para></td><td thead="no"><para><center>5.4</center></para></td><td thead="no"><para><center>28.3</center></para></td><td thead="no"><para><center>229.3</center></para></td></tr><tr><td thead="no"><para><center>Athlon XP</center></para></td><td thead="no"><para><center>MSVC 8.0</center></para></td><td thead="no"><para><center>3.1</center></para></td><td thead="no"><para><center>7.7</center></para></td><td thead="no"><para><center>8.0</center></para></td><td thead="no"><para><center>25.5</center></para></td><td thead="no"><para><center>182.6</center></para></td></tr><tr><td thead="no"><para><center>Athlon XP</center></para></td><td thead="no"><para><center>gcc 4.1.1</center></para></td><td thead="no"><para><center>0.9</center></para></td><td thead="no"><para><center>8.2</center></para></td><td thead="no"><para><center>9.2</center></para></td><td thead="no"><para><center>33.7</center></para></td><td thead="no"><para><center>265.2</center></para></td></tr><tr><td thead="no"><para><center>Pentium 3</center></para></td><td thead="no"><para><center>MSVC 8.0</center></para></td><td thead="no"><para><center>2.0</center></para></td><td thead="no"><para><center>6.3</center></para></td><td thead="no"><para><center>7.0</center></para></td><td thead="no"><para><center>30.9</center></para></td><td thead="no"><para><center>211.9</center></para></td></tr><tr><td thead="no"><para><center>Pentium 3</center></para></td><td thead="no"><para><center>gcc 4.1.1</center></para></td><td thead="no"><para><center>1.0</center></para></td><td thead="no"><para><center>6.7</center></para></td><td thead="no"><para><center>8.9</center></para></td><td thead="no"><para><center>35.3</center></para></td><td thead="no"><para><center>316.0</center></para></td></tr></table><i>(*) All results are in CPU cycles per character of source text</i></para></sect2></sect1><sect1><h2 id="namespacerapidxml_1reference">5. Reference</h2><para>This section lists all classes, functions, constants etc. and describes them in detail. </para></sect1></detaileddescription><dl><dt>class
133 | 								  template
134 | 							   <a href="#classrapidxml_1_1memory__pool">rapidxml::memory_pool</a></dt><dt class="indented">
135 | 				constructor
136 | 			 <a href="#classrapidxml_1_1memory__pool_f8fb3c8f1a564f8045c40bcd07a89866_1f8fb3c8f1a564f8045c40bcd07a89866">memory_pool()</a></dt><dt class="indented">
137 | 				destructor
138 | 			 <a href="#classrapidxml_1_1memory__pool_6f8c7990d9ec1ed2acf6558b238570eb_16f8c7990d9ec1ed2acf6558b238570eb">~memory_pool()</a></dt><dt class="indented">function <a href="#classrapidxml_1_1memory__pool_750ba3c610b129ac057d817509d08f41_1750ba3c610b129ac057d817509d08f41">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)</a></dt><dt class="indented">function <a href="#classrapidxml_1_1memory__pool_462de142669e0ff649e8e615b82bf457_1462de142669e0ff649e8e615b82bf457">allocate_attribute(const Ch *name=0, const Ch *value=0, std::size_t name_size=0, std::size_t value_size=0)</a></dt><dt class="indented">function <a href="#classrapidxml_1_1memory__pool_69729185bc59b0875192d667c47b8859_169729185bc59b0875192d667c47b8859">allocate_string(const Ch *source=0, std::size_t size=0)</a></dt><dt class="indented">function <a href="#classrapidxml_1_1memory__pool_95c49fcb056e9103ec906a59e3e01d76_195c49fcb056e9103ec906a59e3e01d76">clone_node(const xml_node&lt; Ch &gt; *source, xml_node&lt; Ch &gt; *result=0)</a></dt><dt class="indented">function <a href="#classrapidxml_1_1memory__pool_c8bb3912a3ce86b15842e79d0b421204_1c8bb3912a3ce86b15842e79d0b421204">clear()</a></dt><dt class="indented">function <a href="#classrapidxml_1_1memory__pool_c0a55a6ef0837dca67572e357100d78a_1c0a55a6ef0837dca67572e357100d78a">set_allocator(alloc_func *af, free_func *ff)</a></dt><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><p/><p/><dt>class <a href="#classrapidxml_1_1parse__error">rapidxml::parse_error</a></dt><dt class="indented">
139 | 				constructor
140 | 			 <a href="#classrapidxml_1_1parse__error_4dd8d1bdbd9221df4dcb90cafaee3332_14dd8d1bdbd9221df4dcb90cafaee3332">parse_error(const char *what, void *where)</a></dt><dt class="indented">function <a href="#classrapidxml_1_1parse__error_ff06f49065b54a8a86e02e9a2441a8ba_1ff06f49065b54a8a86e02e9a2441a8ba">what() const </a></dt><dt class="indented">function <a href="#classrapidxml_1_1parse__error_377be7d201d95221c318682c35377aca_1377be7d201d95221c318682c35377aca">where() const </a></dt><dt class="indented"/><dt class="indented"/><p/><dt>class
141 | 								  template
142 | 							   <a href="#classrapidxml_1_1xml__attribute">rapidxml::xml_attribute</a></dt><dt class="indented">
143 | 				constructor
144 | 			 <a href="#classrapidxml_1_1xml__attribute_d5464aadf08269a886b730993525db34_1d5464aadf08269a886b730993525db34">xml_attribute()</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__attribute_77aea7d8d996ba4f6bd61cc478a4e72d_177aea7d8d996ba4f6bd61cc478a4e72d">document() const </a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__attribute_5c4a98d2b75f9b41b12c110108fd55ab_15c4a98d2b75f9b41b12c110108fd55ab">previous_attribute(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const </a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__attribute_1b8a814d0d3a7165396b08433eee8a91_11b8a814d0d3a7165396b08433eee8a91">next_attribute(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const </a></dt><dt class="indented"/><dt class="indented"/><dt class="indented"/><p/><dt>class
145 | 								  template
146 | 							   <a href="#classrapidxml_1_1xml__base">rapidxml::xml_base</a></dt><dt class="indented">
147 | 				constructor
148 | 			 <a href="#classrapidxml_1_1xml__base_23630d2c130a9e0e3f3afa7584a9b218_123630d2c130a9e0e3f3afa7584a9b218">xml_base()</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__base_622eade29fdf7806d3ef93ac4d90e707_1622eade29fdf7806d3ef93ac4d90e707">name() const </a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__base_0dae694c8f7e4d89f1003e2f3a15a43c_10dae694c8f7e4d89f1003e2f3a15a43c">name_size() const </a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__base_c54fa4987fb503916a7b541eb15c9c7f_1c54fa4987fb503916a7b541eb15c9c7f">value() const </a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__base_aed5ae791b7164c1ee5e649198cbb3db_1aed5ae791b7164c1ee5e649198cbb3db">value_size() const </a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__base_4e7e23d06d48126c65b1f6266acfba5c_14e7e23d06d48126c65b1f6266acfba5c">name(const Ch *name, std::size_t size)</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__base_e099c291e104a0d277307fe71f5e0f9e_1e099c291e104a0d277307fe71f5e0f9e">name(const Ch *name)</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__base_d9640aa3f5374673cb72a5289b6c91eb_1d9640aa3f5374673cb72a5289b6c91eb">value(const Ch *value, std::size_t size)</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__base_18c7469acdca771de9b4f3054053029c_118c7469acdca771de9b4f3054053029c">value(const Ch *value)</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__base_798e8df7ea53ade4d9f0701017dce80e_1798e8df7ea53ade4d9f0701017dce80e">parent() const </a></dt><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><p/><dt>class
149 | 								  template
150 | 							   <a href="#classrapidxml_1_1xml__document">rapidxml::xml_document</a></dt><dt class="indented">
151 | 				constructor
152 | 			 <a href="#classrapidxml_1_1xml__document_6ce266cc52d549c42abe3a3d5e8af9ba_16ce266cc52d549c42abe3a3d5e8af9ba">xml_document()</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c">parse(Ch *text)</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__document_c8bb3912a3ce86b15842e79d0b421204_1c8bb3912a3ce86b15842e79d0b421204">clear()</a></dt><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><p/><p/><p/><p/><p/><p/><p/><p/><p/><dt>class
153 | 								  template
154 | 							   <a href="#classrapidxml_1_1xml__node">rapidxml::xml_node</a></dt><dt class="indented">
155 | 				constructor
156 | 			 <a href="#classrapidxml_1_1xml__node_34c55af3504549a475e5b9dfcaa6adf5_134c55af3504549a475e5b9dfcaa6adf5">xml_node(node_type type)</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_975e86937621ae4afe6a423219de30d0_1975e86937621ae4afe6a423219de30d0">type() const </a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_77aea7d8d996ba4f6bd61cc478a4e72d_177aea7d8d996ba4f6bd61cc478a4e72d">document() const </a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_7823e36687669e59c2afdf66334ef35a_17823e36687669e59c2afdf66334ef35a">first_node(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const </a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_fcb6e2209b591a36d2dadba20d2bc7cc_1fcb6e2209b591a36d2dadba20d2bc7cc">last_node(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const </a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_ac2f6886c0107e9d5f156e9542546df6_1ac2f6886c0107e9d5f156e9542546df6">previous_sibling(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const </a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_b3ead2cefecc03a813836203e3f6f38f_1b3ead2cefecc03a813836203e3f6f38f">next_sibling(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const </a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_5810a09f82f8d53efbe9456286dcec83_15810a09f82f8d53efbe9456286dcec83">first_attribute(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const </a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_16953d66751b5b949ee4ee2d9c0bc63a_116953d66751b5b949ee4ee2d9c0bc63a">last_attribute(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const </a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_a78759bfa429fa2ab6bc5fe617cfa3cf_1a78759bfa429fa2ab6bc5fe617cfa3cf">type(node_type type)</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_0c39df6617e709eb2fba11300dea63f2_10c39df6617e709eb2fba11300dea63f2">prepend_node(xml_node&lt; Ch &gt; *child)</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_86de2e22276826089b7baed2599f8dee_186de2e22276826089b7baed2599f8dee">append_node(xml_node&lt; Ch &gt; *child)</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_780972a57fc447250ab47cc8f421b65e_1780972a57fc447250ab47cc8f421b65e">insert_node(xml_node&lt; Ch &gt; *where, xml_node&lt; Ch &gt; *child)</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_9a31d861e1bddc710839c551a5d2b3a4_19a31d861e1bddc710839c551a5d2b3a4">remove_first_node()</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_87addf2bc127ee31aa4b5295d3c9b530_187addf2bc127ee31aa4b5295d3c9b530">remove_last_node()</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_9316463a2201631e7e2062b17729f9cd_19316463a2201631e7e2062b17729f9cd">remove_node(xml_node&lt; Ch &gt; *where)</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_0218147d13e41d5fa60ced4e7a7e9726_10218147d13e41d5fa60ced4e7a7e9726">remove_all_nodes()</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_f6dffa513da74cc0be71a7ba84f8265e_1f6dffa513da74cc0be71a7ba84f8265e">prepend_attribute(xml_attribute&lt; Ch &gt; *attribute)</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_8fbd4f5ef7169d493da9f8d87ac04b77_18fbd4f5ef7169d493da9f8d87ac04b77">append_attribute(xml_attribute&lt; Ch &gt; *attribute)</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_070d5888b0557fe06a5b24961de1b988_1070d5888b0557fe06a5b24961de1b988">insert_attribute(xml_attribute&lt; Ch &gt; *where, xml_attribute&lt; Ch &gt; *attribute)</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_4eea4a7f6cb484ca9944f7eafe6e1843_14eea4a7f6cb484ca9944f7eafe6e1843">remove_first_attribute()</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_37d87c4d5d89fa0cf05b72ee8d4cba3b_137d87c4d5d89fa0cf05b72ee8d4cba3b">remove_last_attribute()</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_c75154db2e768c0e5b541fc8cd0775ab_1c75154db2e768c0e5b541fc8cd0775ab">remove_attribute(xml_attribute&lt; Ch &gt; *where)</a></dt><dt class="indented">function <a href="#classrapidxml_1_1xml__node_59e6ad4cfd5e8096c052e71d79561eda_159e6ad4cfd5e8096c052e71d79561eda">remove_all_attributes()</a></dt><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><p/><dt>namespace <a href="#namespacerapidxml">rapidxml</a></dt><dt class="indented">enum <a href="#namespacerapidxml_6a276b85e2da28c5f9c3dbce61c55682_16a276b85e2da28c5f9c3dbce61c55682">node_type</a></dt><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented"/><dt class="indented">function <a href="#namespacerapidxml_ff5d67f74437199d316d2b2660653ae1_1ff5d67f74437199d316d2b2660653ae1">parse_error_handler(const char *what, void *where)</a></dt><dt class="indented">function <a href="#namespacerapidxml_b94d570fc4c4ab2423813cd0243326b1_1b94d570fc4c4ab2423813cd0243326b1">print(OutIt out, const xml_node&lt; Ch &gt; &amp;node, int flags=0)</a></dt><dt class="indented">function <a href="#namespacerapidxml_13bc37d6d1047acb0efdbc1689221a5e_113bc37d6d1047acb0efdbc1689221a5e">print(std::basic_ostream&lt; Ch &gt; &amp;out, const xml_node&lt; Ch &gt; &amp;node, int flags=0)</a></dt><dt class="indented">function <a href="#namespacerapidxml_5619b38000d967fb223b2b0a8c17463a_15619b38000d967fb223b2b0a8c17463a">operator&lt;&lt;(std::basic_ostream&lt; Ch &gt; &amp;out, const xml_node&lt; Ch &gt; &amp;node)</a></dt><dt class="indented">
157 | 				constant
158 | 			 <a href="#namespacerapidxml_87e8bbab53702cf3b438bd553c10b6b9_187e8bbab53702cf3b438bd553c10b6b9">parse_no_data_nodes</a></dt><dt class="indented">
159 | 				constant
160 | 			 <a href="#namespacerapidxml_97e2c4fdc04fae17126f9971a4fc993e_197e2c4fdc04fae17126f9971a4fc993e">parse_no_element_values</a></dt><dt class="indented">
161 | 				constant
162 | 			 <a href="#namespacerapidxml_9cae3801e70437cbc410c24bf6be691c_19cae3801e70437cbc410c24bf6be691c">parse_no_string_terminators</a></dt><dt class="indented">
163 | 				constant
164 | 			 <a href="#namespacerapidxml_7223b7815c4fb8b42e6e4e77e1ea6b97_17223b7815c4fb8b42e6e4e77e1ea6b97">parse_no_entity_translation</a></dt><dt class="indented">
165 | 				constant
166 | 			 <a href="#namespacerapidxml_ccde57f6054857ee4042a1b4d98c83b9_1ccde57f6054857ee4042a1b4d98c83b9">parse_no_utf8</a></dt><dt class="indented">
167 | 				constant
168 | 			 <a href="#namespacerapidxml_52e2c934ad9c845a5f4cc49570470556_152e2c934ad9c845a5f4cc49570470556">parse_declaration_node</a></dt><dt class="indented">
169 | 				constant
170 | 			 <a href="#namespacerapidxml_0f7479dacbc868456d07897a8c072784_10f7479dacbc868456d07897a8c072784">parse_comment_nodes</a></dt><dt class="indented">
171 | 				constant
172 | 			 <a href="#namespacerapidxml_8e187746ba1ca04f107951ad32df962e_18e187746ba1ca04f107951ad32df962e">parse_doctype_node</a></dt><dt class="indented">
173 | 				constant
174 | 			 <a href="#namespacerapidxml_1c20b2b2b75711cd76423e119c49f830_11c20b2b2b75711cd76423e119c49f830">parse_pi_nodes</a></dt><dt class="indented">
175 | 				constant
176 | 			 <a href="#namespacerapidxml_a5daff9d61c7d4eaf98e4d42efe628ee_1a5daff9d61c7d4eaf98e4d42efe628ee">parse_validate_closing_tags</a></dt><dt class="indented">
177 | 				constant
178 | 			 <a href="#namespacerapidxml_ac1f06b1afd47b812732fb521b146fd9_1ac1f06b1afd47b812732fb521b146fd9">parse_trim_whitespace</a></dt><dt class="indented">
179 | 				constant
180 | 			 <a href="#namespacerapidxml_88f95d4e275ba01408fefde83078651b_188f95d4e275ba01408fefde83078651b">parse_normalize_whitespace</a></dt><dt class="indented">
181 | 				constant
182 | 			 <a href="#namespacerapidxml_45751cf2f38fd6915f35b3122b46d5b6_145751cf2f38fd6915f35b3122b46d5b6">parse_default</a></dt><dt class="indented">
183 | 				constant
184 | 			 <a href="#namespacerapidxml_a97ba1a0a79a6d66f4eef3612508d943_1a97ba1a0a79a6d66f4eef3612508d943">parse_non_destructive</a></dt><dt class="indented">
185 | 				constant
186 | 			 <a href="#namespacerapidxml_398c5476e76102f8bd76c10bb0abbe10_1398c5476e76102f8bd76c10bb0abbe10">parse_fastest</a></dt><dt class="indented">
187 | 				constant
188 | 			 <a href="#namespacerapidxml_b4f2515265facb42291570307924bd57_1b4f2515265facb42291570307924bd57">parse_full</a></dt><dt class="indented">
189 | 				constant
190 | 			 <a href="#namespacerapidxml_b08b8d4293c203b69ed6c5ae77ac1907_1b08b8d4293c203b69ed6c5ae77ac1907">print_no_indenting</a></dt><p/><p/><p/><p/></dl><hr/><h3 class="reference-header" id="classrapidxml_1_1memory__pool">class
191 | 									  template
192 | 								   rapidxml::memory_pool</h3>
193 | 
194 | 							  Defined in <a href="rapidxml.hpp">rapidxml.hpp</a><br/>
195 | 								  Base class for
196 | 								  <a href="#classrapidxml_1_1xml__document">xml_document</a> <h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">This class is used by the parser to create new nodes and attributes, without overheads of dynamic memory allocation. In most cases, you will not need to use this class directly. However, if you need to create nodes manually or modify names/values of nodes, you are encouraged to use <a href="#classrapidxml_1_1memory__pool" kindref="compound">memory_pool</a> of relevant <a href="#classrapidxml_1_1xml__document" kindref="compound">xml_document</a> to allocate the memory. Not only is this faster than allocating them by using <code>new</code> operator, but also their lifetime will be tied to the lifetime of document, possibly simplyfing memory management. <br/><br/>
197 |  Call <a href="#classrapidxml_1_1memory__pool_750ba3c610b129ac057d817509d08f41_1750ba3c610b129ac057d817509d08f41" kindref="member">allocate_node()</a> or <a href="#classrapidxml_1_1memory__pool_462de142669e0ff649e8e615b82bf457_1462de142669e0ff649e8e615b82bf457" kindref="member">allocate_attribute()</a> functions to obtain new nodes or attributes from the pool. You can also call <a href="#classrapidxml_1_1memory__pool_69729185bc59b0875192d667c47b8859_169729185bc59b0875192d667c47b8859" kindref="member">allocate_string()</a> function to allocate strings. Such strings can then be used as names or values of nodes without worrying about their lifetime. Note that there is no <code>free()</code> function -- all allocations are freed at once when <a href="#classrapidxml_1_1memory__pool_c8bb3912a3ce86b15842e79d0b421204_1c8bb3912a3ce86b15842e79d0b421204" kindref="member">clear()</a> function is called, or when the pool is destroyed. <br/><br/>
198 |  It is also possible to create a standalone <a href="#classrapidxml_1_1memory__pool" kindref="compound">memory_pool</a>, and use it to allocate nodes, whose lifetime will not be tied to any document. <br/><br/>
199 |  Pool maintains <code>RAPIDXML_STATIC_POOL_SIZE</code> bytes of statically allocated memory. Until static memory is exhausted, no dynamic memory allocations are done. When static memory is exhausted, pool allocates additional blocks of memory of size <code>RAPIDXML_DYNAMIC_POOL_SIZE</code> each, by using global <code>new[]</code> and <code>delete[]</code> operators. This behaviour can be changed by setting custom allocation routines. Use <a href="#classrapidxml_1_1memory__pool_c0a55a6ef0837dca67572e357100d78a_1c0a55a6ef0837dca67572e357100d78a" kindref="member">set_allocator()</a> function to set them. <br/><br/>
200 |  Allocations for nodes, attributes and strings are aligned at <code>RAPIDXML_ALIGNMENT</code> bytes. This value defaults to the size of pointer on target architecture. <br/><br/>
201 |  To obtain absolutely top performance from the parser, it is important that all nodes are allocated from a single, contiguous block of memory. Otherwise, cache misses when jumping between two (or more) disjoint blocks of memory can slow down parsing quite considerably. If required, you can tweak <code>RAPIDXML_STATIC_POOL_SIZE</code>, <code>RAPIDXML_DYNAMIC_POOL_SIZE</code> and <code>RAPIDXML_ALIGNMENT</code> to obtain best wasted memory to performance compromise. To do it, define their values before <a href="#rapidxml_8hpp" kindref="compound">rapidxml.hpp</a> file is included. </para><h4>Parameters</h4><dl><dt class="parameter-name">Ch</dt><dd>Character type of created nodes. </dd></dl><p/><h3 class="reference-header" id="classrapidxml_1_1memory__pool_f8fb3c8f1a564f8045c40bcd07a89866_1f8fb3c8f1a564f8045c40bcd07a89866">
202 | 				constructor
203 | 			 memory_pool::memory_pool</h3><h4>Synopsis</h4><code class="synopsis">memory_pool();
204 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Constructs empty pool with default allocator functions. </para><p/><h3 class="reference-header" id="classrapidxml_1_1memory__pool_6f8c7990d9ec1ed2acf6558b238570eb_16f8c7990d9ec1ed2acf6558b238570eb">
205 | 				destructor
206 | 			 memory_pool::~memory_pool</h3><h4>Synopsis</h4><code class="synopsis">~memory_pool();
207 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Destroys pool and frees all the memory. This causes memory occupied by nodes allocated by the pool to be freed. Nodes allocated from the pool are no longer valid. </para><p/><h3 class="reference-header" id="classrapidxml_1_1memory__pool_750ba3c610b129ac057d817509d08f41_1750ba3c610b129ac057d817509d08f41">function memory_pool::allocate_node</h3><h4>Synopsis</h4><code class="synopsis">xml_node&lt;Ch&gt;* 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);
208 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">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 <code>std::bad_alloc</code>. If exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, this function will call <a href="#namespacerapidxml_ff5d67f74437199d316d2b2660653ae1_1ff5d67f74437199d316d2b2660653ae1" kindref="member">rapidxml::parse_error_handler()</a> function. </para><h4>Parameters</h4><dl><dt class="parameter-name">type</dt><dd class="parameter-def">Type of node to create. </dd></dl><dl><dt class="parameter-name">name</dt><dd class="parameter-def">Name to assign to the node, or 0 to assign no name. </dd></dl><dl><dt class="parameter-name">value</dt><dd class="parameter-def">Value to assign to the node, or 0 to assign no value. </dd></dl><dl><dt class="parameter-name">name_size</dt><dd class="parameter-def">Size of name to assign, or 0 to automatically calculate size from name string. </dd></dl><dl><dt class="parameter-name">value_size</dt><dd class="parameter-def">Size of value to assign, or 0 to automatically calculate size from value string. </dd></dl><h4>Returns</h4>Pointer to allocated node. This pointer will never be NULL. <p/><h3 class="reference-header" id="classrapidxml_1_1memory__pool_462de142669e0ff649e8e615b82bf457_1462de142669e0ff649e8e615b82bf457">function memory_pool::allocate_attribute</h3><h4>Synopsis</h4><code class="synopsis">xml_attribute&lt;Ch&gt;* allocate_attribute(const Ch *name=0, const Ch *value=0, std::size_t name_size=0, std::size_t value_size=0);
209 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">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 <code>std::bad_alloc</code>. If exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, this function will call <a href="#namespacerapidxml_ff5d67f74437199d316d2b2660653ae1_1ff5d67f74437199d316d2b2660653ae1" kindref="member">rapidxml::parse_error_handler()</a> function. </para><h4>Parameters</h4><dl><dt class="parameter-name">name</dt><dd class="parameter-def">Name to assign to the attribute, or 0 to assign no name. </dd></dl><dl><dt class="parameter-name">value</dt><dd class="parameter-def">Value to assign to the attribute, or 0 to assign no value. </dd></dl><dl><dt class="parameter-name">name_size</dt><dd class="parameter-def">Size of name to assign, or 0 to automatically calculate size from name string. </dd></dl><dl><dt class="parameter-name">value_size</dt><dd class="parameter-def">Size of value to assign, or 0 to automatically calculate size from value string. </dd></dl><h4>Returns</h4>Pointer to allocated attribute. This pointer will never be NULL. <p/><h3 class="reference-header" id="classrapidxml_1_1memory__pool_69729185bc59b0875192d667c47b8859_169729185bc59b0875192d667c47b8859">function memory_pool::allocate_string</h3><h4>Synopsis</h4><code class="synopsis">Ch* allocate_string(const Ch *source=0, std::size_t size=0);
210 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">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 <code>std::bad_alloc</code>. If exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, this function will call <a href="#namespacerapidxml_ff5d67f74437199d316d2b2660653ae1_1ff5d67f74437199d316d2b2660653ae1" kindref="member">rapidxml::parse_error_handler()</a> function. </para><h4>Parameters</h4><dl><dt class="parameter-name">source</dt><dd class="parameter-def">String to initialize the allocated memory with, or 0 to not initialize it. </dd></dl><dl><dt class="parameter-name">size</dt><dd class="parameter-def">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. </dd></dl><h4>Returns</h4>Pointer to allocated char array. This pointer will never be NULL. <p/><h3 class="reference-header" id="classrapidxml_1_1memory__pool_95c49fcb056e9103ec906a59e3e01d76_195c49fcb056e9103ec906a59e3e01d76">function memory_pool::clone_node</h3><h4>Synopsis</h4><code class="synopsis">xml_node&lt;Ch&gt;* clone_node(const xml_node&lt; Ch &gt; *source, xml_node&lt; Ch &gt; *result=0);
211 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Clones an <a href="#classrapidxml_1_1xml__node" kindref="compound">xml_node</a> 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. </para><h4>Parameters</h4><dl><dt class="parameter-name">source</dt><dd class="parameter-def">Node to clone. </dd></dl><dl><dt class="parameter-name">result</dt><dd class="parameter-def">Node to put results in, or 0 to automatically allocate result node </dd></dl><h4>Returns</h4>Pointer to cloned node. This pointer will never be NULL. <p/><h3 class="reference-header" id="classrapidxml_1_1memory__pool_c8bb3912a3ce86b15842e79d0b421204_1c8bb3912a3ce86b15842e79d0b421204">function memory_pool::clear</h3><h4>Synopsis</h4><code class="synopsis">void clear();
212 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Clears the pool. This causes memory occupied by nodes allocated by the pool to be freed. Any nodes or strings allocated from the pool will no longer be valid. </para><p/><h3 class="reference-header" id="classrapidxml_1_1memory__pool_c0a55a6ef0837dca67572e357100d78a_1c0a55a6ef0837dca67572e357100d78a">function memory_pool::set_allocator</h3><h4>Synopsis</h4><code class="synopsis">void set_allocator(alloc_func *af, free_func *ff);
213 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">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 <code>longjmp()</code> function to pass control to other place of program. If it returns invalid pointer, results are undefined. <br/><br/>
214 |  User defined allocation functions must have the following forms: <br/><code><br/>
215 | void *allocate(std::size_t size); <br/>
216 | void free(void *pointer); </code><br/></para><h4>Parameters</h4><dl><dt class="parameter-name">af</dt><dd class="parameter-def">Allocation function, or 0 to restore default function </dd></dl><dl><dt class="parameter-name">ff</dt><dd class="parameter-def">Free function, or 0 to restore default function </dd></dl><p/><h3 class="reference-header" id="classrapidxml_1_1parse__error">class rapidxml::parse_error</h3>
217 | 
218 | 							  Defined in <a href="rapidxml.hpp">rapidxml.hpp</a><br/><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Parse error exception. This exception is thrown by the parser when an error occurs. Use <a href="#classrapidxml_1_1parse__error_ff06f49065b54a8a86e02e9a2441a8ba_1ff06f49065b54a8a86e02e9a2441a8ba" kindref="member">what()</a> function to get human-readable error message. Use <a href="#classrapidxml_1_1parse__error_377be7d201d95221c318682c35377aca_1377be7d201d95221c318682c35377aca" kindref="member">where()</a> function to get a pointer to position within source text where error was detected. <br/><br/>
219 |  If throwing exceptions by the parser is undesirable, it can be disabled by defining RAPIDXML_NO_EXCEPTIONS macro before <a href="#rapidxml_8hpp" kindref="compound">rapidxml.hpp</a> is included. This will cause the parser to call <a href="#namespacerapidxml_ff5d67f74437199d316d2b2660653ae1_1ff5d67f74437199d316d2b2660653ae1" kindref="member">rapidxml::parse_error_handler()</a> function instead of throwing an exception. This function must be defined by the user. <br/><br/>
220 |  This class derives from <code>std::exception</code> class. </para><p/><h3 class="reference-header" id="classrapidxml_1_1parse__error_4dd8d1bdbd9221df4dcb90cafaee3332_14dd8d1bdbd9221df4dcb90cafaee3332">
221 | 				constructor
222 | 			 parse_error::parse_error</h3><h4>Synopsis</h4><code class="synopsis">parse_error(const char *what, void *where);
223 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Constructs parse error. </para><p/><h3 class="reference-header" id="classrapidxml_1_1parse__error_ff06f49065b54a8a86e02e9a2441a8ba_1ff06f49065b54a8a86e02e9a2441a8ba">function parse_error::what</h3><h4>Synopsis</h4><code class="synopsis">virtual const char* what() const;
224 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Gets human readable description of error. </para><h4>Returns</h4>Pointer to null terminated description of the error. <p/><h3 class="reference-header" id="classrapidxml_1_1parse__error_377be7d201d95221c318682c35377aca_1377be7d201d95221c318682c35377aca">function parse_error::where</h3><h4>Synopsis</h4><code class="synopsis">Ch* where() const;
225 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Gets pointer to character data where error happened. Ch should be the same as char type of <a href="#classrapidxml_1_1xml__document" kindref="compound">xml_document</a> that produced the error. </para><h4>Returns</h4>Pointer to location within the parsed string where error occured. <p/><h3 class="reference-header" id="classrapidxml_1_1xml__attribute">class
226 | 									  template
227 | 								   rapidxml::xml_attribute</h3>
228 | 
229 | 							  Defined in <a href="rapidxml.hpp">rapidxml.hpp</a><br/>
230 | 								  Inherits from
231 | 								  <a href="#classrapidxml_1_1xml__base">xml_base</a> <br/><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Class representing attribute node of XML document. Each attribute has name and value strings, which are available through <a href="#classrapidxml_1_1xml__base_622eade29fdf7806d3ef93ac4d90e707_1622eade29fdf7806d3ef93ac4d90e707" kindref="member">name()</a> and <a href="#classrapidxml_1_1xml__base_c54fa4987fb503916a7b541eb15c9c7f_1c54fa4987fb503916a7b541eb15c9c7f" kindref="member">value()</a> functions (inherited from <a href="#classrapidxml_1_1xml__base" kindref="compound">xml_base</a>). Note that after parse, both name and value of attribute will point to interior of source text used for parsing. Thus, this text must persist in memory for the lifetime of attribute. </para><h4>Parameters</h4><dl><dt class="parameter-name">Ch</dt><dd>Character type to use. </dd></dl><p/><h3 class="reference-header" id="classrapidxml_1_1xml__attribute_d5464aadf08269a886b730993525db34_1d5464aadf08269a886b730993525db34">
232 | 				constructor
233 | 			 xml_attribute::xml_attribute</h3><h4>Synopsis</h4><code class="synopsis">xml_attribute();
234 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Constructs an empty attribute with the specified type. Consider using <a href="#classrapidxml_1_1memory__pool" kindref="compound">memory_pool</a> of appropriate <a href="#classrapidxml_1_1xml__document" kindref="compound">xml_document</a> if allocating attributes manually. </para><p/><h3 class="reference-header" id="classrapidxml_1_1xml__attribute_77aea7d8d996ba4f6bd61cc478a4e72d_177aea7d8d996ba4f6bd61cc478a4e72d">function xml_attribute::document</h3><h4>Synopsis</h4><code class="synopsis">xml_document&lt;Ch&gt;* document() const;
235 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Gets document of which attribute is a child. </para><h4>Returns</h4>Pointer to document that contains this attribute, or 0 if there is no parent document. <p/><h3 class="reference-header" id="classrapidxml_1_1xml__attribute_5c4a98d2b75f9b41b12c110108fd55ab_15c4a98d2b75f9b41b12c110108fd55ab">function xml_attribute::previous_attribute</h3><h4>Synopsis</h4><code class="synopsis">xml_attribute&lt;Ch&gt;* previous_attribute(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const;
236 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Gets previous attribute, optionally matching attribute name. </para><h4>Parameters</h4><dl><dt class="parameter-name">name</dt><dd class="parameter-def">Name of attribute to find, or 0 to return previous attribute regardless of its name; this string doesn&apos;t have to be zero-terminated if name_size is non-zero </dd></dl><dl><dt class="parameter-name">name_size</dt><dd class="parameter-def">Size of name, in characters, or 0 to have size calculated automatically from string </dd></dl><dl><dt class="parameter-name">case_sensitive</dt><dd class="parameter-def">Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters </dd></dl><h4>Returns</h4>Pointer to found attribute, or 0 if not found. <p/><h3 class="reference-header" id="classrapidxml_1_1xml__attribute_1b8a814d0d3a7165396b08433eee8a91_11b8a814d0d3a7165396b08433eee8a91">function xml_attribute::next_attribute</h3><h4>Synopsis</h4><code class="synopsis">xml_attribute&lt;Ch&gt;* next_attribute(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const;
237 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Gets next attribute, optionally matching attribute name. </para><h4>Parameters</h4><dl><dt class="parameter-name">name</dt><dd class="parameter-def">Name of attribute to find, or 0 to return next attribute regardless of its name; this string doesn&apos;t have to be zero-terminated if name_size is non-zero </dd></dl><dl><dt class="parameter-name">name_size</dt><dd class="parameter-def">Size of name, in characters, or 0 to have size calculated automatically from string </dd></dl><dl><dt class="parameter-name">case_sensitive</dt><dd class="parameter-def">Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters </dd></dl><h4>Returns</h4>Pointer to found attribute, or 0 if not found. <p/><h3 class="reference-header" id="classrapidxml_1_1xml__base">class
238 | 									  template
239 | 								   rapidxml::xml_base</h3>
240 | 
241 | 							  Defined in <a href="rapidxml.hpp">rapidxml.hpp</a><br/>
242 | 								  Base class for
243 | 								  <a href="#classrapidxml_1_1xml__attribute">xml_attribute</a> <a href="#classrapidxml_1_1xml__node">xml_node</a> <h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Base class for <a href="#classrapidxml_1_1xml__node" kindref="compound">xml_node</a> and <a href="#classrapidxml_1_1xml__attribute" kindref="compound">xml_attribute</a> implementing common functions: <a href="#classrapidxml_1_1xml__base_622eade29fdf7806d3ef93ac4d90e707_1622eade29fdf7806d3ef93ac4d90e707" kindref="member">name()</a>, <a href="#classrapidxml_1_1xml__base_0dae694c8f7e4d89f1003e2f3a15a43c_10dae694c8f7e4d89f1003e2f3a15a43c" kindref="member">name_size()</a>, <a href="#classrapidxml_1_1xml__base_c54fa4987fb503916a7b541eb15c9c7f_1c54fa4987fb503916a7b541eb15c9c7f" kindref="member">value()</a>, <a href="#classrapidxml_1_1xml__base_aed5ae791b7164c1ee5e649198cbb3db_1aed5ae791b7164c1ee5e649198cbb3db" kindref="member">value_size()</a> and <a href="#classrapidxml_1_1xml__base_798e8df7ea53ade4d9f0701017dce80e_1798e8df7ea53ade4d9f0701017dce80e" kindref="member">parent()</a>. </para><h4>Parameters</h4><dl><dt class="parameter-name">Ch</dt><dd>Character type to use </dd></dl><p/><h3 class="reference-header" id="classrapidxml_1_1xml__base_23630d2c130a9e0e3f3afa7584a9b218_123630d2c130a9e0e3f3afa7584a9b218">
244 | 				constructor
245 | 			 xml_base::xml_base</h3><h4>Synopsis</h4><code class="synopsis">xml_base();
246 | 									  </code><p/><h3 class="reference-header" id="classrapidxml_1_1xml__base_622eade29fdf7806d3ef93ac4d90e707_1622eade29fdf7806d3ef93ac4d90e707">function xml_base::name</h3><h4>Synopsis</h4><code class="synopsis">Ch* name() const;
247 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Gets name of the node. Interpretation of name depends on type of node. Note that name will not be zero-terminated if <a href="#namespacerapidxml_9cae3801e70437cbc410c24bf6be691c_19cae3801e70437cbc410c24bf6be691c" kindref="member">rapidxml::parse_no_string_terminators</a> option was selected during parse. <br/><br/>
248 |  Use <a href="#classrapidxml_1_1xml__base_0dae694c8f7e4d89f1003e2f3a15a43c_10dae694c8f7e4d89f1003e2f3a15a43c" kindref="member">name_size()</a> function to determine length of the name. </para><h4>Returns</h4>Name of node, or empty string if node has no name. <p/><h3 class="reference-header" id="classrapidxml_1_1xml__base_0dae694c8f7e4d89f1003e2f3a15a43c_10dae694c8f7e4d89f1003e2f3a15a43c">function xml_base::name_size</h3><h4>Synopsis</h4><code class="synopsis">std::size_t name_size() const;
249 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Gets size of node name, not including terminator character. This function works correctly irrespective of whether name is or is not zero terminated. </para><h4>Returns</h4>Size of node name, in characters. <p/><h3 class="reference-header" id="classrapidxml_1_1xml__base_c54fa4987fb503916a7b541eb15c9c7f_1c54fa4987fb503916a7b541eb15c9c7f">function xml_base::value</h3><h4>Synopsis</h4><code class="synopsis">Ch* value() const;
250 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Gets value of node. Interpretation of value depends on type of node. Note that value will not be zero-terminated if <a href="#namespacerapidxml_9cae3801e70437cbc410c24bf6be691c_19cae3801e70437cbc410c24bf6be691c" kindref="member">rapidxml::parse_no_string_terminators</a> option was selected during parse. <br/><br/>
251 |  Use <a href="#classrapidxml_1_1xml__base_aed5ae791b7164c1ee5e649198cbb3db_1aed5ae791b7164c1ee5e649198cbb3db" kindref="member">value_size()</a> function to determine length of the value. </para><h4>Returns</h4>Value of node, or empty string if node has no value. <p/><h3 class="reference-header" id="classrapidxml_1_1xml__base_aed5ae791b7164c1ee5e649198cbb3db_1aed5ae791b7164c1ee5e649198cbb3db">function xml_base::value_size</h3><h4>Synopsis</h4><code class="synopsis">std::size_t value_size() const;
252 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Gets size of node value, not including terminator character. This function works correctly irrespective of whether value is or is not zero terminated. </para><h4>Returns</h4>Size of node value, in characters. <p/><h3 class="reference-header" id="classrapidxml_1_1xml__base_4e7e23d06d48126c65b1f6266acfba5c_14e7e23d06d48126c65b1f6266acfba5c">function xml_base::name</h3><h4>Synopsis</h4><code class="synopsis">void name(const Ch *name, std::size_t size);
253 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Sets name of node to a non zero-terminated string. See <a href="#namespacerapidxml_1ownership_of_strings" kindref="member">Ownership Of Strings</a> . <br/><br/>
254 |  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 <a href="#classrapidxml_1_1memory__pool" kindref="compound">memory_pool</a> of the document to allocate the string - on destruction of the document the string will be automatically freed. <br/><br/>
255 |  Size of name must be specified separately, because name does not have to be zero terminated. Use <a href="#classrapidxml_1_1xml__base_e099c291e104a0d277307fe71f5e0f9e_1e099c291e104a0d277307fe71f5e0f9e" kindref="member">name(const Ch *)</a> function to have the length automatically calculated (string must be zero terminated). </para><h4>Parameters</h4><dl><dt class="parameter-name">name</dt><dd class="parameter-def">Name of node to set. Does not have to be zero terminated. </dd></dl><dl><dt class="parameter-name">size</dt><dd class="parameter-def">Size of name, in characters. This does not include zero terminator, if one is present. </dd></dl><p/><h3 class="reference-header" id="classrapidxml_1_1xml__base_e099c291e104a0d277307fe71f5e0f9e_1e099c291e104a0d277307fe71f5e0f9e">function xml_base::name</h3><h4>Synopsis</h4><code class="synopsis">void name(const Ch *name);
256 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Sets name of node to a zero-terminated string. See also <a href="#namespacerapidxml_1ownership_of_strings" kindref="member">Ownership Of Strings</a>  and <a href="#classrapidxml_1_1xml__base_4e7e23d06d48126c65b1f6266acfba5c_14e7e23d06d48126c65b1f6266acfba5c" kindref="member">xml_node::name(const Ch *, std::size_t)</a>. </para><h4>Parameters</h4><dl><dt class="parameter-name">name</dt><dd class="parameter-def">Name of node to set. Must be zero terminated. </dd></dl><p/><h3 class="reference-header" id="classrapidxml_1_1xml__base_d9640aa3f5374673cb72a5289b6c91eb_1d9640aa3f5374673cb72a5289b6c91eb">function xml_base::value</h3><h4>Synopsis</h4><code class="synopsis">void value(const Ch *value, std::size_t size);
257 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Sets value of node to a non zero-terminated string. See <a href="#namespacerapidxml_1ownership_of_strings" kindref="member">Ownership Of Strings</a> . <br/><br/>
258 |  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 <a href="#classrapidxml_1_1memory__pool" kindref="compound">memory_pool</a> of the document to allocate the string - on destruction of the document the string will be automatically freed. <br/><br/>
259 |  Size of value must be specified separately, because it does not have to be zero terminated. Use <a href="#classrapidxml_1_1xml__base_18c7469acdca771de9b4f3054053029c_118c7469acdca771de9b4f3054053029c" kindref="member">value(const Ch *)</a> function to have the length automatically calculated (string must be zero terminated). <br/><br/>
260 |  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 <a href="#namespacerapidxml_87e8bbab53702cf3b438bd553c10b6b9_187e8bbab53702cf3b438bd553c10b6b9" kindref="member">rapidxml::parse_no_data_nodes</a> to prevent creation of data nodes by the parser. </para><h4>Parameters</h4><dl><dt class="parameter-name">value</dt><dd class="parameter-def">value of node to set. Does not have to be zero terminated. </dd></dl><dl><dt class="parameter-name">size</dt><dd class="parameter-def">Size of value, in characters. This does not include zero terminator, if one is present. </dd></dl><p/><h3 class="reference-header" id="classrapidxml_1_1xml__base_18c7469acdca771de9b4f3054053029c_118c7469acdca771de9b4f3054053029c">function xml_base::value</h3><h4>Synopsis</h4><code class="synopsis">void value(const Ch *value);
261 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Sets value of node to a zero-terminated string. See also <a href="#namespacerapidxml_1ownership_of_strings" kindref="member">Ownership Of Strings</a>  and <a href="#classrapidxml_1_1xml__base_d9640aa3f5374673cb72a5289b6c91eb_1d9640aa3f5374673cb72a5289b6c91eb" kindref="member">xml_node::value(const Ch *, std::size_t)</a>. </para><h4>Parameters</h4><dl><dt class="parameter-name">value</dt><dd class="parameter-def">Vame of node to set. Must be zero terminated. </dd></dl><p/><h3 class="reference-header" id="classrapidxml_1_1xml__base_798e8df7ea53ade4d9f0701017dce80e_1798e8df7ea53ade4d9f0701017dce80e">function xml_base::parent</h3><h4>Synopsis</h4><code class="synopsis">xml_node&lt;Ch&gt;* parent() const;
262 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Gets node parent. </para><h4>Returns</h4>Pointer to parent node, or 0 if there is no parent. <p/><h3 class="reference-header" id="classrapidxml_1_1xml__document">class
263 | 									  template
264 | 								   rapidxml::xml_document</h3>
265 | 
266 | 							  Defined in <a href="rapidxml.hpp">rapidxml.hpp</a><br/>
267 | 								  Inherits from
268 | 								  <a href="#classrapidxml_1_1xml__node">xml_node</a> <a href="#classrapidxml_1_1memory__pool">memory_pool</a> <br/><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">This class represents root of the DOM hierarchy. It is also an <a href="#classrapidxml_1_1xml__node" kindref="compound">xml_node</a> and a <a href="#classrapidxml_1_1memory__pool" kindref="compound">memory_pool</a> through public inheritance. Use <a href="#classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c" kindref="member">parse()</a> function to build a DOM tree from a zero-terminated XML text string. <a href="#classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c" kindref="member">parse()</a> function allocates memory for nodes and attributes by using functions of <a href="#classrapidxml_1_1xml__document" kindref="compound">xml_document</a>, which are inherited from <a href="#classrapidxml_1_1memory__pool" kindref="compound">memory_pool</a>. To access root node of the document, use the document itself, as if it was an <a href="#classrapidxml_1_1xml__node" kindref="compound">xml_node</a>. </para><h4>Parameters</h4><dl><dt class="parameter-name">Ch</dt><dd>Character type to use. </dd></dl><p/><h3 class="reference-header" id="classrapidxml_1_1xml__document_6ce266cc52d549c42abe3a3d5e8af9ba_16ce266cc52d549c42abe3a3d5e8af9ba">
269 | 				constructor
270 | 			 xml_document::xml_document</h3><h4>Synopsis</h4><code class="synopsis">xml_document();
271 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Constructs empty XML document. </para><p/><h3 class="reference-header" id="classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c">function xml_document::parse</h3><h4>Synopsis</h4><code class="synopsis">void parse(Ch *text);
272 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Parses zero-terminated XML string according to given flags. Passed string will be modified by the parser, unless <a href="#namespacerapidxml_a97ba1a0a79a6d66f4eef3612508d943_1a97ba1a0a79a6d66f4eef3612508d943" kindref="member">rapidxml::parse_non_destructive</a> flag is used. The string must persist for the lifetime of the document. In case of error, <a href="#classrapidxml_1_1parse__error" kindref="compound">rapidxml::parse_error</a> exception will be thrown. <br/><br/>
273 |  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. <br/><br/>
274 |  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. </para><h4>Parameters</h4><dl><dt class="parameter-name">text</dt><dd class="parameter-def">XML data to parse; pointer is non-const to denote fact that this data may be modified by the parser. </dd></dl><p/><h3 class="reference-header" id="classrapidxml_1_1xml__document_c8bb3912a3ce86b15842e79d0b421204_1c8bb3912a3ce86b15842e79d0b421204">function xml_document::clear</h3><h4>Synopsis</h4><code class="synopsis">void clear();
275 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Clears the document by deleting all nodes and clearing the memory pool. All nodes owned by document pool are destroyed. </para><p/><h3 class="reference-header" id="classrapidxml_1_1xml__node">class
276 | 									  template
277 | 								   rapidxml::xml_node</h3>
278 | 
279 | 							  Defined in <a href="rapidxml.hpp">rapidxml.hpp</a><br/>
280 | 								  Inherits from
281 | 								  <a href="#classrapidxml_1_1xml__base">xml_base</a> <br/>
282 | 								  Base class for
283 | 								  <a href="#classrapidxml_1_1xml__document">xml_document</a> <h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Class representing a node of XML document. Each node may have associated name and value strings, which are available through <a href="#classrapidxml_1_1xml__base_622eade29fdf7806d3ef93ac4d90e707_1622eade29fdf7806d3ef93ac4d90e707" kindref="member">name()</a> and <a href="#classrapidxml_1_1xml__base_c54fa4987fb503916a7b541eb15c9c7f_1c54fa4987fb503916a7b541eb15c9c7f" kindref="member">value()</a> functions. Interpretation of name and value depends on type of the node. Type of node can be determined by using <a href="#classrapidxml_1_1xml__node_975e86937621ae4afe6a423219de30d0_1975e86937621ae4afe6a423219de30d0" kindref="member">type()</a> function. <br/><br/>
284 |  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. </para><h4>Parameters</h4><dl><dt class="parameter-name">Ch</dt><dd>Character type to use. </dd></dl><p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_34c55af3504549a475e5b9dfcaa6adf5_134c55af3504549a475e5b9dfcaa6adf5">
285 | 				constructor
286 | 			 xml_node::xml_node</h3><h4>Synopsis</h4><code class="synopsis">xml_node(node_type type);
287 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Constructs an empty node with the specified type. Consider using <a href="#classrapidxml_1_1memory__pool" kindref="compound">memory_pool</a> of appropriate document to allocate nodes manually. </para><h4>Parameters</h4><dl><dt class="parameter-name">type</dt><dd class="parameter-def">Type of node to construct. </dd></dl><p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_975e86937621ae4afe6a423219de30d0_1975e86937621ae4afe6a423219de30d0">function xml_node::type</h3><h4>Synopsis</h4><code class="synopsis">node_type type() const;
288 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Gets type of node. </para><h4>Returns</h4>Type of node. <p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_77aea7d8d996ba4f6bd61cc478a4e72d_177aea7d8d996ba4f6bd61cc478a4e72d">function xml_node::document</h3><h4>Synopsis</h4><code class="synopsis">xml_document&lt;Ch&gt;* document() const;
289 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Gets document of which node is a child. </para><h4>Returns</h4>Pointer to document that contains this node, or 0 if there is no parent document. <p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_7823e36687669e59c2afdf66334ef35a_17823e36687669e59c2afdf66334ef35a">function xml_node::first_node</h3><h4>Synopsis</h4><code class="synopsis">xml_node&lt;Ch&gt;* first_node(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const;
290 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Gets first child node, optionally matching node name. </para><h4>Parameters</h4><dl><dt class="parameter-name">name</dt><dd class="parameter-def">Name of child to find, or 0 to return first child regardless of its name; this string doesn&apos;t have to be zero-terminated if name_size is non-zero </dd></dl><dl><dt class="parameter-name">name_size</dt><dd class="parameter-def">Size of name, in characters, or 0 to have size calculated automatically from string </dd></dl><dl><dt class="parameter-name">case_sensitive</dt><dd class="parameter-def">Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters </dd></dl><h4>Returns</h4>Pointer to found child, or 0 if not found. <p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_fcb6e2209b591a36d2dadba20d2bc7cc_1fcb6e2209b591a36d2dadba20d2bc7cc">function xml_node::last_node</h3><h4>Synopsis</h4><code class="synopsis">xml_node&lt;Ch&gt;* last_node(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const;
291 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Gets last child node, optionally matching node name. Behaviour is undefined if node has no children. Use <a href="#classrapidxml_1_1xml__node_7823e36687669e59c2afdf66334ef35a_17823e36687669e59c2afdf66334ef35a" kindref="member">first_node()</a> to test if node has children. </para><h4>Parameters</h4><dl><dt class="parameter-name">name</dt><dd class="parameter-def">Name of child to find, or 0 to return last child regardless of its name; this string doesn&apos;t have to be zero-terminated if name_size is non-zero </dd></dl><dl><dt class="parameter-name">name_size</dt><dd class="parameter-def">Size of name, in characters, or 0 to have size calculated automatically from string </dd></dl><dl><dt class="parameter-name">case_sensitive</dt><dd class="parameter-def">Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters </dd></dl><h4>Returns</h4>Pointer to found child, or 0 if not found. <p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_ac2f6886c0107e9d5f156e9542546df6_1ac2f6886c0107e9d5f156e9542546df6">function xml_node::previous_sibling</h3><h4>Synopsis</h4><code class="synopsis">xml_node&lt;Ch&gt;* previous_sibling(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const;
292 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Gets previous sibling node, optionally matching node name. Behaviour is undefined if node has no parent. Use <a href="#classrapidxml_1_1xml__base_798e8df7ea53ade4d9f0701017dce80e_1798e8df7ea53ade4d9f0701017dce80e" kindref="member">parent()</a> to test if node has a parent. </para><h4>Parameters</h4><dl><dt class="parameter-name">name</dt><dd class="parameter-def">Name of sibling to find, or 0 to return previous sibling regardless of its name; this string doesn&apos;t have to be zero-terminated if name_size is non-zero </dd></dl><dl><dt class="parameter-name">name_size</dt><dd class="parameter-def">Size of name, in characters, or 0 to have size calculated automatically from string </dd></dl><dl><dt class="parameter-name">case_sensitive</dt><dd class="parameter-def">Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters </dd></dl><h4>Returns</h4>Pointer to found sibling, or 0 if not found. <p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_b3ead2cefecc03a813836203e3f6f38f_1b3ead2cefecc03a813836203e3f6f38f">function xml_node::next_sibling</h3><h4>Synopsis</h4><code class="synopsis">xml_node&lt;Ch&gt;* next_sibling(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const;
293 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Gets next sibling node, optionally matching node name. Behaviour is undefined if node has no parent. Use <a href="#classrapidxml_1_1xml__base_798e8df7ea53ade4d9f0701017dce80e_1798e8df7ea53ade4d9f0701017dce80e" kindref="member">parent()</a> to test if node has a parent. </para><h4>Parameters</h4><dl><dt class="parameter-name">name</dt><dd class="parameter-def">Name of sibling to find, or 0 to return next sibling regardless of its name; this string doesn&apos;t have to be zero-terminated if name_size is non-zero </dd></dl><dl><dt class="parameter-name">name_size</dt><dd class="parameter-def">Size of name, in characters, or 0 to have size calculated automatically from string </dd></dl><dl><dt class="parameter-name">case_sensitive</dt><dd class="parameter-def">Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters </dd></dl><h4>Returns</h4>Pointer to found sibling, or 0 if not found. <p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_5810a09f82f8d53efbe9456286dcec83_15810a09f82f8d53efbe9456286dcec83">function xml_node::first_attribute</h3><h4>Synopsis</h4><code class="synopsis">xml_attribute&lt;Ch&gt;* first_attribute(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const;
294 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Gets first attribute of node, optionally matching attribute name. </para><h4>Parameters</h4><dl><dt class="parameter-name">name</dt><dd class="parameter-def">Name of attribute to find, or 0 to return first attribute regardless of its name; this string doesn&apos;t have to be zero-terminated if name_size is non-zero </dd></dl><dl><dt class="parameter-name">name_size</dt><dd class="parameter-def">Size of name, in characters, or 0 to have size calculated automatically from string </dd></dl><dl><dt class="parameter-name">case_sensitive</dt><dd class="parameter-def">Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters </dd></dl><h4>Returns</h4>Pointer to found attribute, or 0 if not found. <p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_16953d66751b5b949ee4ee2d9c0bc63a_116953d66751b5b949ee4ee2d9c0bc63a">function xml_node::last_attribute</h3><h4>Synopsis</h4><code class="synopsis">xml_attribute&lt;Ch&gt;* last_attribute(const Ch *name=0, std::size_t name_size=0, bool case_sensitive=true) const;
295 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Gets last attribute of node, optionally matching attribute name. </para><h4>Parameters</h4><dl><dt class="parameter-name">name</dt><dd class="parameter-def">Name of attribute to find, or 0 to return last attribute regardless of its name; this string doesn&apos;t have to be zero-terminated if name_size is non-zero </dd></dl><dl><dt class="parameter-name">name_size</dt><dd class="parameter-def">Size of name, in characters, or 0 to have size calculated automatically from string </dd></dl><dl><dt class="parameter-name">case_sensitive</dt><dd class="parameter-def">Should name comparison be case-sensitive; non case-sensitive comparison works properly only for ASCII characters </dd></dl><h4>Returns</h4>Pointer to found attribute, or 0 if not found. <p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_a78759bfa429fa2ab6bc5fe617cfa3cf_1a78759bfa429fa2ab6bc5fe617cfa3cf">function xml_node::type</h3><h4>Synopsis</h4><code class="synopsis">void type(node_type type);
296 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Sets type of node. </para><h4>Parameters</h4><dl><dt class="parameter-name">type</dt><dd class="parameter-def">Type of node to set. </dd></dl><p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_0c39df6617e709eb2fba11300dea63f2_10c39df6617e709eb2fba11300dea63f2">function xml_node::prepend_node</h3><h4>Synopsis</h4><code class="synopsis">void prepend_node(xml_node&lt; Ch &gt; *child);
297 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Prepends a new child node. The prepended child becomes the first child, and all existing children are moved one position back. </para><h4>Parameters</h4><dl><dt class="parameter-name">child</dt><dd class="parameter-def">Node to prepend. </dd></dl><p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_86de2e22276826089b7baed2599f8dee_186de2e22276826089b7baed2599f8dee">function xml_node::append_node</h3><h4>Synopsis</h4><code class="synopsis">void append_node(xml_node&lt; Ch &gt; *child);
298 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Appends a new child node. The appended child becomes the last child. </para><h4>Parameters</h4><dl><dt class="parameter-name">child</dt><dd class="parameter-def">Node to append. </dd></dl><p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_780972a57fc447250ab47cc8f421b65e_1780972a57fc447250ab47cc8f421b65e">function xml_node::insert_node</h3><h4>Synopsis</h4><code class="synopsis">void insert_node(xml_node&lt; Ch &gt; *where, xml_node&lt; Ch &gt; *child);
299 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Inserts a new child node at specified place inside the node. All children after and including the specified node are moved one position back. </para><h4>Parameters</h4><dl><dt class="parameter-name">where</dt><dd class="parameter-def">Place where to insert the child, or 0 to insert at the back. </dd></dl><dl><dt class="parameter-name">child</dt><dd class="parameter-def">Node to insert. </dd></dl><p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_9a31d861e1bddc710839c551a5d2b3a4_19a31d861e1bddc710839c551a5d2b3a4">function xml_node::remove_first_node</h3><h4>Synopsis</h4><code class="synopsis">void remove_first_node();
300 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Removes first child node. If node has no children, behaviour is undefined. Use <a href="#classrapidxml_1_1xml__node_7823e36687669e59c2afdf66334ef35a_17823e36687669e59c2afdf66334ef35a" kindref="member">first_node()</a> to test if node has children. </para><p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_87addf2bc127ee31aa4b5295d3c9b530_187addf2bc127ee31aa4b5295d3c9b530">function xml_node::remove_last_node</h3><h4>Synopsis</h4><code class="synopsis">void remove_last_node();
301 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Removes last child of the node. If node has no children, behaviour is undefined. Use <a href="#classrapidxml_1_1xml__node_7823e36687669e59c2afdf66334ef35a_17823e36687669e59c2afdf66334ef35a" kindref="member">first_node()</a> to test if node has children. </para><p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_9316463a2201631e7e2062b17729f9cd_19316463a2201631e7e2062b17729f9cd">function xml_node::remove_node</h3><h4>Synopsis</h4><code class="synopsis">void remove_node(xml_node&lt; Ch &gt; *where);
302 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Removes specified child from the node. </para><p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_0218147d13e41d5fa60ced4e7a7e9726_10218147d13e41d5fa60ced4e7a7e9726">function xml_node::remove_all_nodes</h3><h4>Synopsis</h4><code class="synopsis">void remove_all_nodes();
303 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Removes all child nodes (but not attributes). </para><p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_f6dffa513da74cc0be71a7ba84f8265e_1f6dffa513da74cc0be71a7ba84f8265e">function xml_node::prepend_attribute</h3><h4>Synopsis</h4><code class="synopsis">void prepend_attribute(xml_attribute&lt; Ch &gt; *attribute);
304 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Prepends a new attribute to the node. </para><h4>Parameters</h4><dl><dt class="parameter-name">attribute</dt><dd class="parameter-def">Attribute to prepend. </dd></dl><p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_8fbd4f5ef7169d493da9f8d87ac04b77_18fbd4f5ef7169d493da9f8d87ac04b77">function xml_node::append_attribute</h3><h4>Synopsis</h4><code class="synopsis">void append_attribute(xml_attribute&lt; Ch &gt; *attribute);
305 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Appends a new attribute to the node. </para><h4>Parameters</h4><dl><dt class="parameter-name">attribute</dt><dd class="parameter-def">Attribute to append. </dd></dl><p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_070d5888b0557fe06a5b24961de1b988_1070d5888b0557fe06a5b24961de1b988">function xml_node::insert_attribute</h3><h4>Synopsis</h4><code class="synopsis">void insert_attribute(xml_attribute&lt; Ch &gt; *where, xml_attribute&lt; Ch &gt; *attribute);
306 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Inserts a new attribute at specified place inside the node. All attributes after and including the specified attribute are moved one position back. </para><h4>Parameters</h4><dl><dt class="parameter-name">where</dt><dd class="parameter-def">Place where to insert the attribute, or 0 to insert at the back. </dd></dl><dl><dt class="parameter-name">attribute</dt><dd class="parameter-def">Attribute to insert. </dd></dl><p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_4eea4a7f6cb484ca9944f7eafe6e1843_14eea4a7f6cb484ca9944f7eafe6e1843">function xml_node::remove_first_attribute</h3><h4>Synopsis</h4><code class="synopsis">void remove_first_attribute();
307 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Removes first attribute of the node. If node has no attributes, behaviour is undefined. Use <a href="#classrapidxml_1_1xml__node_5810a09f82f8d53efbe9456286dcec83_15810a09f82f8d53efbe9456286dcec83" kindref="member">first_attribute()</a> to test if node has attributes. </para><p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_37d87c4d5d89fa0cf05b72ee8d4cba3b_137d87c4d5d89fa0cf05b72ee8d4cba3b">function xml_node::remove_last_attribute</h3><h4>Synopsis</h4><code class="synopsis">void remove_last_attribute();
308 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Removes last attribute of the node. If node has no attributes, behaviour is undefined. Use <a href="#classrapidxml_1_1xml__node_5810a09f82f8d53efbe9456286dcec83_15810a09f82f8d53efbe9456286dcec83" kindref="member">first_attribute()</a> to test if node has attributes. </para><p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_c75154db2e768c0e5b541fc8cd0775ab_1c75154db2e768c0e5b541fc8cd0775ab">function xml_node::remove_attribute</h3><h4>Synopsis</h4><code class="synopsis">void remove_attribute(xml_attribute&lt; Ch &gt; *where);
309 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Removes specified attribute from node. </para><h4>Parameters</h4><dl><dt class="parameter-name">where</dt><dd class="parameter-def">Pointer to attribute to be removed. </dd></dl><p/><h3 class="reference-header" id="classrapidxml_1_1xml__node_59e6ad4cfd5e8096c052e71d79561eda_159e6ad4cfd5e8096c052e71d79561eda">function xml_node::remove_all_attributes</h3><h4>Synopsis</h4><code class="synopsis">void remove_all_attributes();
310 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Removes all attributes of node. </para><p/><h3 class="reference-header" id="namespacerapidxml_6a276b85e2da28c5f9c3dbce61c55682_16a276b85e2da28c5f9c3dbce61c55682">enum node_type</h3><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Enumeration listing all node types produced by the parser. Use <a href="#classrapidxml_1_1xml__node_975e86937621ae4afe6a423219de30d0_1975e86937621ae4afe6a423219de30d0" kindref="member">xml_node::type()</a> function to query node type. </para><h4>Values</h4><dl><dt class="parameter-name">node_document</dt><dd class="parameter-def">A document node. Name and value are empty. </dd></dl><dl><dt class="parameter-name">node_element</dt><dd class="parameter-def">An element node. Name contains element name. Value contains text of first data node. </dd></dl><dl><dt class="parameter-name">node_data</dt><dd class="parameter-def">A data node. Name is empty. Value contains data text. </dd></dl><dl><dt class="parameter-name">node_cdata</dt><dd class="parameter-def">A CDATA node. Name is empty. Value contains data text. </dd></dl><dl><dt class="parameter-name">node_comment</dt><dd class="parameter-def">A comment node. Name is empty. Value contains comment text. </dd></dl><dl><dt class="parameter-name">node_declaration</dt><dd class="parameter-def">A declaration node. Name and value are empty. Declaration parameters (version, encoding and standalone) are in node attributes. </dd></dl><dl><dt class="parameter-name">node_doctype</dt><dd class="parameter-def">A DOCTYPE node. Name is empty. Value contains DOCTYPE text. </dd></dl><dl><dt class="parameter-name">node_pi</dt><dd class="parameter-def">A PI node. Name contains target. Value contains instructions. </dd></dl><p/><h3 class="reference-header" id="namespacerapidxml_ff5d67f74437199d316d2b2660653ae1_1ff5d67f74437199d316d2b2660653ae1">function parse_error_handler</h3><h4>Synopsis</h4><code class="synopsis">void rapidxml::parse_error_handler(const char *what, void *where);
311 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">When exceptions are disabled by defining RAPIDXML_NO_EXCEPTIONS, this function is called to notify user about the error. It must be defined by the user. <br/><br/>
312 |  This function cannot return. If it does, the results are undefined. <br/><br/>
313 |  A very simple definition might look like that: <preformatted>
314 |         void rapidxml::parse_error_handler(const char *what, void *where)
315 |         {
316 |             std::cout &lt;&lt; &quot;Parse error: &quot; &lt;&lt; what &lt;&lt; &quot;\n&quot;;
317 |             std::abort();
318 |         }
319 |         </preformatted></para><h4>Parameters</h4><dl><dt class="parameter-name">what</dt><dd class="parameter-def">Human readable description of the error. </dd></dl><dl><dt class="parameter-name">where</dt><dd class="parameter-def">Pointer to character data where error was detected. </dd></dl><p/><h3 class="reference-header" id="namespacerapidxml_b94d570fc4c4ab2423813cd0243326b1_1b94d570fc4c4ab2423813cd0243326b1">function print</h3><h4>Synopsis</h4><code class="synopsis">OutIt rapidxml::print(OutIt out, const xml_node&lt; Ch &gt; &amp;node, int flags=0);
320 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Prints XML to given output iterator. </para><h4>Parameters</h4><dl><dt class="parameter-name">out</dt><dd class="parameter-def">Output iterator to print to. </dd></dl><dl><dt class="parameter-name">node</dt><dd class="parameter-def">Node to be printed. Pass xml_document to print entire document. </dd></dl><dl><dt class="parameter-name">flags</dt><dd class="parameter-def">Flags controlling how XML is printed. </dd></dl><h4>Returns</h4>Output iterator pointing to position immediately after last character of printed text. <p/><h3 class="reference-header" id="namespacerapidxml_13bc37d6d1047acb0efdbc1689221a5e_113bc37d6d1047acb0efdbc1689221a5e">function print</h3><h4>Synopsis</h4><code class="synopsis">std::basic_ostream&lt;Ch&gt;&amp; rapidxml::print(std::basic_ostream&lt; Ch &gt; &amp;out, const xml_node&lt; Ch &gt; &amp;node, int flags=0);
321 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Prints XML to given output stream. </para><h4>Parameters</h4><dl><dt class="parameter-name">out</dt><dd class="parameter-def">Output stream to print to. </dd></dl><dl><dt class="parameter-name">node</dt><dd class="parameter-def">Node to be printed. Pass xml_document to print entire document. </dd></dl><dl><dt class="parameter-name">flags</dt><dd class="parameter-def">Flags controlling how XML is printed. </dd></dl><h4>Returns</h4>Output stream. <p/><h3 class="reference-header" id="namespacerapidxml_5619b38000d967fb223b2b0a8c17463a_15619b38000d967fb223b2b0a8c17463a">function operator&lt;&lt;</h3><h4>Synopsis</h4><code class="synopsis">std::basic_ostream&lt;Ch&gt;&amp; rapidxml::operator&lt;&lt;(std::basic_ostream&lt; Ch &gt; &amp;out, const xml_node&lt; Ch &gt; &amp;node);
322 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Prints formatted XML to given output stream. Uses default printing flags. Use <a href="#namespacerapidxml_b94d570fc4c4ab2423813cd0243326b1_1b94d570fc4c4ab2423813cd0243326b1" kindref="member">print()</a> function to customize printing process. </para><h4>Parameters</h4><dl><dt class="parameter-name">out</dt><dd class="parameter-def">Output stream to print to. </dd></dl><dl><dt class="parameter-name">node</dt><dd class="parameter-def">Node to be printed. </dd></dl><h4>Returns</h4>Output stream. <p/><h3 class="reference-header" id="namespacerapidxml_87e8bbab53702cf3b438bd553c10b6b9_187e8bbab53702cf3b438bd553c10b6b9">
323 | 				constant
324 | 			 parse_no_data_nodes</h3><h4>Synopsis</h4><code class="synopsis">const int parse_no_data_nodes
325 | 											  = 0x1;
326 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Parse flag instructing the parser to not create data nodes. Text of first data node will still be placed in value of parent element, unless <a href="#namespacerapidxml_97e2c4fdc04fae17126f9971a4fc993e_197e2c4fdc04fae17126f9971a4fc993e" kindref="member">rapidxml::parse_no_element_values</a> flag is also specified. Can be combined with other flags by use of | operator. <br/><br/>
327 |  See <a href="#classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c" kindref="member">xml_document::parse()</a> function. </para><p/><h3 class="reference-header" id="namespacerapidxml_97e2c4fdc04fae17126f9971a4fc993e_197e2c4fdc04fae17126f9971a4fc993e">
328 | 				constant
329 | 			 parse_no_element_values</h3><h4>Synopsis</h4><code class="synopsis">const int parse_no_element_values
330 | 											  = 0x2;
331 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Parse flag instructing the parser to not use text of first data node as a value of parent element. Can be combined with other flags by use of | operator. Note that child data nodes of element node take precendence over its value when printing. That is, if element has one or more child data nodes <i>and</i> a value, the value will be ignored. Use <a href="#namespacerapidxml_87e8bbab53702cf3b438bd553c10b6b9_187e8bbab53702cf3b438bd553c10b6b9" kindref="member">rapidxml::parse_no_data_nodes</a> flag to prevent creation of data nodes if you want to manipulate data using values of elements. <br/><br/>
332 |  See <a href="#classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c" kindref="member">xml_document::parse()</a> function. </para><p/><h3 class="reference-header" id="namespacerapidxml_9cae3801e70437cbc410c24bf6be691c_19cae3801e70437cbc410c24bf6be691c">
333 | 				constant
334 | 			 parse_no_string_terminators</h3><h4>Synopsis</h4><code class="synopsis">const int parse_no_string_terminators
335 | 											  = 0x4;
336 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Parse flag instructing the parser to not place zero terminators after strings in the source text. By default zero terminators are placed, modifying source text. Can be combined with other flags by use of | operator. <br/><br/>
337 |  See <a href="#classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c" kindref="member">xml_document::parse()</a> function. </para><p/><h3 class="reference-header" id="namespacerapidxml_7223b7815c4fb8b42e6e4e77e1ea6b97_17223b7815c4fb8b42e6e4e77e1ea6b97">
338 | 				constant
339 | 			 parse_no_entity_translation</h3><h4>Synopsis</h4><code class="synopsis">const int parse_no_entity_translation
340 | 											  = 0x8;
341 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Parse flag instructing the parser to not translate entities in the source text. By default entities are translated, modifying source text. Can be combined with other flags by use of | operator. <br/><br/>
342 |  See <a href="#classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c" kindref="member">xml_document::parse()</a> function. </para><p/><h3 class="reference-header" id="namespacerapidxml_ccde57f6054857ee4042a1b4d98c83b9_1ccde57f6054857ee4042a1b4d98c83b9">
343 | 				constant
344 | 			 parse_no_utf8</h3><h4>Synopsis</h4><code class="synopsis">const int parse_no_utf8
345 | 											  = 0x10;
346 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Parse flag instructing the parser to disable UTF-8 handling and assume plain 8 bit characters. By default, UTF-8 handling is enabled. Can be combined with other flags by use of | operator. <br/><br/>
347 |  See <a href="#classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c" kindref="member">xml_document::parse()</a> function. </para><p/><h3 class="reference-header" id="namespacerapidxml_52e2c934ad9c845a5f4cc49570470556_152e2c934ad9c845a5f4cc49570470556">
348 | 				constant
349 | 			 parse_declaration_node</h3><h4>Synopsis</h4><code class="synopsis">const int parse_declaration_node
350 | 											  = 0x20;
351 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Parse flag instructing the parser to create XML declaration node. By default, declaration node is not created. Can be combined with other flags by use of | operator. <br/><br/>
352 |  See <a href="#classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c" kindref="member">xml_document::parse()</a> function. </para><p/><h3 class="reference-header" id="namespacerapidxml_0f7479dacbc868456d07897a8c072784_10f7479dacbc868456d07897a8c072784">
353 | 				constant
354 | 			 parse_comment_nodes</h3><h4>Synopsis</h4><code class="synopsis">const int parse_comment_nodes
355 | 											  = 0x40;
356 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Parse flag instructing the parser to create comments nodes. By default, comment nodes are not created. Can be combined with other flags by use of | operator. <br/><br/>
357 |  See <a href="#classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c" kindref="member">xml_document::parse()</a> function. </para><p/><h3 class="reference-header" id="namespacerapidxml_8e187746ba1ca04f107951ad32df962e_18e187746ba1ca04f107951ad32df962e">
358 | 				constant
359 | 			 parse_doctype_node</h3><h4>Synopsis</h4><code class="synopsis">const int parse_doctype_node
360 | 											  = 0x80;
361 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Parse flag instructing the parser to create DOCTYPE node. By default, doctype node is not created. Although W3C specification allows at most one DOCTYPE node, RapidXml will silently accept documents with more than one. Can be combined with other flags by use of | operator. <br/><br/>
362 |  See <a href="#classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c" kindref="member">xml_document::parse()</a> function. </para><p/><h3 class="reference-header" id="namespacerapidxml_1c20b2b2b75711cd76423e119c49f830_11c20b2b2b75711cd76423e119c49f830">
363 | 				constant
364 | 			 parse_pi_nodes</h3><h4>Synopsis</h4><code class="synopsis">const int parse_pi_nodes
365 | 											  = 0x100;
366 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Parse flag instructing the parser to create PI nodes. By default, PI nodes are not created. Can be combined with other flags by use of | operator. <br/><br/>
367 |  See <a href="#classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c" kindref="member">xml_document::parse()</a> function. </para><p/><h3 class="reference-header" id="namespacerapidxml_a5daff9d61c7d4eaf98e4d42efe628ee_1a5daff9d61c7d4eaf98e4d42efe628ee">
368 | 				constant
369 | 			 parse_validate_closing_tags</h3><h4>Synopsis</h4><code class="synopsis">const int parse_validate_closing_tags
370 | 											  = 0x200;
371 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Parse flag instructing the parser to validate closing tag names. If not set, name inside closing tag is irrelevant to the parser. By default, closing tags are not validated. Can be combined with other flags by use of | operator. <br/><br/>
372 |  See <a href="#classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c" kindref="member">xml_document::parse()</a> function. </para><p/><h3 class="reference-header" id="namespacerapidxml_ac1f06b1afd47b812732fb521b146fd9_1ac1f06b1afd47b812732fb521b146fd9">
373 | 				constant
374 | 			 parse_trim_whitespace</h3><h4>Synopsis</h4><code class="synopsis">const int parse_trim_whitespace
375 | 											  = 0x400;
376 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Parse flag instructing the parser to trim all leading and trailing whitespace of data nodes. By default, whitespace is not trimmed. This flag does not cause the parser to modify source text. Can be combined with other flags by use of | operator. <br/><br/>
377 |  See <a href="#classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c" kindref="member">xml_document::parse()</a> function. </para><p/><h3 class="reference-header" id="namespacerapidxml_88f95d4e275ba01408fefde83078651b_188f95d4e275ba01408fefde83078651b">
378 | 				constant
379 | 			 parse_normalize_whitespace</h3><h4>Synopsis</h4><code class="synopsis">const int parse_normalize_whitespace
380 | 											  = 0x800;
381 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Parse flag instructing the parser to condense all whitespace runs of data nodes to a single space character. Trimming of leading and trailing whitespace of data is controlled by <a href="#namespacerapidxml_ac1f06b1afd47b812732fb521b146fd9_1ac1f06b1afd47b812732fb521b146fd9" kindref="member">rapidxml::parse_trim_whitespace</a> flag. By default, whitespace is not normalized. If this flag is specified, source text will be modified. Can be combined with other flags by use of | operator. <br/><br/>
382 |  See <a href="#classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c" kindref="member">xml_document::parse()</a> function. </para><p/><h3 class="reference-header" id="namespacerapidxml_45751cf2f38fd6915f35b3122b46d5b6_145751cf2f38fd6915f35b3122b46d5b6">
383 | 				constant
384 | 			 parse_default</h3><h4>Synopsis</h4><code class="synopsis">const int parse_default
385 | 											  = 0;
386 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Parse flags which represent default behaviour of the parser. This is always equal to 0, so that all other flags can be simply ored together. Normally there is no need to inconveniently disable flags by anding with their negated (~) values. This also means that meaning of each flag is a <i>negation</i> of the default setting. For example, if flag name is <a href="#namespacerapidxml_ccde57f6054857ee4042a1b4d98c83b9_1ccde57f6054857ee4042a1b4d98c83b9" kindref="member">rapidxml::parse_no_utf8</a>, it means that utf-8 is <i>enabled</i> by default, and using the flag will disable it. <br/><br/>
387 |  See <a href="#classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c" kindref="member">xml_document::parse()</a> function. </para><p/><h3 class="reference-header" id="namespacerapidxml_a97ba1a0a79a6d66f4eef3612508d943_1a97ba1a0a79a6d66f4eef3612508d943">
388 | 				constant
389 | 			 parse_non_destructive</h3><h4>Synopsis</h4><code class="synopsis">const int parse_non_destructive
390 | 											  = parse_no_string_terminators | parse_no_entity_translation;
391 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">A combination of parse flags that forbids any modifications of the source text. This also results in faster parsing. However, note that the following will occur: <ul><li><para>names and values of nodes will not be zero terminated, you have to use <a href="#classrapidxml_1_1xml__base_0dae694c8f7e4d89f1003e2f3a15a43c_10dae694c8f7e4d89f1003e2f3a15a43c" kindref="member">xml_base::name_size()</a> and <a href="#classrapidxml_1_1xml__base_aed5ae791b7164c1ee5e649198cbb3db_1aed5ae791b7164c1ee5e649198cbb3db" kindref="member">xml_base::value_size()</a> functions to determine where name and value ends </para></li><li><para>entities will not be translated </para></li><li><para>whitespace will not be normalized </para></li></ul>
392 | See <a href="#classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c" kindref="member">xml_document::parse()</a> function. </para><p/><h3 class="reference-header" id="namespacerapidxml_398c5476e76102f8bd76c10bb0abbe10_1398c5476e76102f8bd76c10bb0abbe10">
393 | 				constant
394 | 			 parse_fastest</h3><h4>Synopsis</h4><code class="synopsis">const int parse_fastest
395 | 											  = parse_non_destructive | parse_no_data_nodes;
396 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">A combination of parse flags resulting in fastest possible parsing, without sacrificing important data. <br/><br/>
397 |  See <a href="#classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c" kindref="member">xml_document::parse()</a> function. </para><p/><h3 class="reference-header" id="namespacerapidxml_b4f2515265facb42291570307924bd57_1b4f2515265facb42291570307924bd57">
398 | 				constant
399 | 			 parse_full</h3><h4>Synopsis</h4><code class="synopsis">const int parse_full
400 | 											  = parse_declaration_node | parse_comment_nodes | parse_doctype_node | parse_pi_nodes | parse_validate_closing_tags;
401 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">A combination of parse flags resulting in largest amount of data being extracted. This usually results in slowest parsing. <br/><br/>
402 |  See <a href="#classrapidxml_1_1xml__document_8338ce6042e7b04d5a42144fb446b69c_18338ce6042e7b04d5a42144fb446b69c" kindref="member">xml_document::parse()</a> function. </para><p/><h3 class="reference-header" id="namespacerapidxml_b08b8d4293c203b69ed6c5ae77ac1907_1b08b8d4293c203b69ed6c5ae77ac1907">
403 | 				constant
404 | 			 print_no_indenting</h3><h4>Synopsis</h4><code class="synopsis">const int print_no_indenting
405 | 											  = 0x1;
406 | 									  </code><h4>Description</h4><para xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">Printer flag instructing the printer to suppress indenting of XML. See <a href="#namespacerapidxml_b94d570fc4c4ab2423813cd0243326b1_1b94d570fc4c4ab2423813cd0243326b1" kindref="member">print()</a> function. </para><p/></body></html>


--------------------------------------------------------------------------------