diff options
| author | Mirrorbot <mirrorbot@cogarr.net> | 2025-12-27 17:53:06 -0600 |
|---|---|---|
| committer | Mirrorbot <mirrorbot@cogarr.net> | 2025-12-27 17:53:06 -0600 |
| commit | 71e94ee161447b84c0eaabf6567f8fa62262cd3e (patch) | |
| tree | 391064cc6173a6fe75069af2fdc1978af12f623e /include/irrXML.h | |
| download | irrlicht-71e94ee161447b84c0eaabf6567f8fa62262cd3e.tar.gz irrlicht-71e94ee161447b84c0eaabf6567f8fa62262cd3e.tar.bz2 irrlicht-71e94ee161447b84c0eaabf6567f8fa62262cd3e.zip | |
Diffstat (limited to 'include/irrXML.h')
| -rw-r--r-- | include/irrXML.h | 575 |
1 files changed, 575 insertions, 0 deletions
diff --git a/include/irrXML.h b/include/irrXML.h new file mode 100644 index 0000000..dd55b1a --- /dev/null +++ b/include/irrXML.h @@ -0,0 +1,575 @@ +// Copyright (C) 2002-2012 Nikolaus Gebhardt
+// This file is part of the "Irrlicht Engine" and the "irrXML" project.
+// For conditions of distribution and use, see copyright notice in irrlicht.h and/or irrXML.h
+
+#ifndef __IRR_XML_H_INCLUDED__
+#define __IRR_XML_H_INCLUDED__
+
+#include <stdio.h>
+#include "IrrCompileConfig.h"
+
+/** \mainpage irrXML 1.2 API documentation
+ <div align="center"><img src="logobig.png" ></div>
+
+ \section intro Introduction
+
+ Welcome to the irrXML API documentation.
+ Here you'll find any information you'll need to develop applications with
+ irrXML. If you look for a tutorial on how to start, take a look at the \ref irrxmlexample,
+ at the homepage of irrXML at <A HREF="http://www.ambiera.com/irrxml/">www.ambiera.com/irrxml/</A>
+ or into the SDK in the directory example.
+
+ irrXML is intended to be a high speed and easy-to-use XML Parser for C++, and
+ this documentation is an important part of it. If you have any questions or
+ suggestions, just send a email to the author of the engine, Nikolaus Gebhardt
+ (niko (at) irrlicht3d.org). For more informations about this parser, see \ref history.
+
+ \section features Features
+
+ irrXML provides forward-only, read-only
+ access to a stream of non validated XML data. It was fully implemented by
+ Nikolaus Gebhardt. Its current features are:
+
+ - It it fast as lighting and has very low memory usage. It was
+ developed with the intention of being used in 3D games, as it already has been.
+ - irrXML is very small: It only consists of 60 KB of code and can be added easily
+ to your existing project.
+ - Of course, it is platform independent and works with lots of compilers.
+ - It is able to parse ASCII, UTF-8, UTF-16 and UTF-32 text files, both in
+ little and big endian format.
+ - Independent of the input file format, the parser can return all strings in ASCII, UTF-8,
+ UTF-16 and UTF-32 format.
+ - With its optional file access abstraction it has the advantage that it can read not
+ only from files but from any type of data (memory, network, ...). For example when
+ used with the Irrlicht Engine, it directly reads from compressed .zip files.
+ - Just like the Irrlicht Engine for which it was originally created, it is extremely easy
+ to use.
+ - It has no external dependencies, it does not even need the STL.
+
+ Although irrXML has some strenghts, it currently also has the following limitations:
+
+ - The input xml file is not validated and assumed to be correct.
+
+ \section irrxmlexample Example
+
+ The following code demonstrates the basic usage of irrXML. A simple xml
+ file like this is parsed:
+ \code
+ <?xml version="1.0"?>
+ <config>
+ <!-- This is a config file for the mesh viewer -->
+ <model file="dwarf.dea" />
+ <messageText caption="Irrlicht Engine Mesh Viewer">
+ Welcome to the Mesh Viewer of the "Irrlicht Engine".
+ </messageText>
+ </config>
+ \endcode
+
+ The code for parsing this file would look like this:
+ \code
+ #include <irrXML.h>
+ using namespace irr; // irrXML is located in the namespace irr::io
+ using namespace io;
+
+ #include <string> // we use STL strings to store data in this example
+
+ void main()
+ {
+ // create the reader using one of the factory functions
+
+ IrrXMLReader* xml = createIrrXMLReader("config.xml");
+
+ // strings for storing the data we want to get out of the file
+ std::string modelFile;
+ std::string messageText;
+ std::string caption;
+
+ // parse the file until end reached
+
+ while(xml && xml->read())
+ {
+ switch(xml->getNodeType())
+ {
+ case EXN_TEXT:
+ // in this xml file, the only text which occurs is the messageText
+ messageText = xml->getNodeData();
+ break;
+ case EXN_ELEMENT:
+ {
+ if (!strcmp("model", xml->getNodeName()))
+ modelFile = xml->getAttributeValue("file");
+ else
+ if (!strcmp("messageText", xml->getNodeName()))
+ caption = xml->getAttributeValue("caption");
+ }
+ break;
+ }
+ }
+
+ // delete the xml parser after usage
+ delete xml;
+ }
+ \endcode
+
+ \section howto How to use
+
+ Simply add the source files in the /src directory of irrXML to your project. Done.
+
+ \section license License
+
+ The irrXML license is based on the zlib license. Basicly, this means you can do with
+ irrXML whatever you want:
+
+ Copyright (C) 2002-2012 Nikolaus Gebhardt
+
+ This software is provided 'as-is', without any express or implied
+ warranty. In no event will the authors be held liable for any damages
+ arising from the use of this software.
+
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute it
+ freely, subject to the following restrictions:
+
+ 1. The origin of this software must not be misrepresented; you must not
+ claim that you wrote the original software. If you use this software
+ in a product, an acknowledgment in the product documentation would be
+ appreciated but is not required.
+
+ 2. Altered source versions must be plainly marked as such, and must not be
+ misrepresented as being the original software.
+
+ 3. This notice may not be removed or altered from any source distribution.
+
+ \section history History
+
+ As lots of references in this documentation and the source show, this xml
+ parser has originally been a part of the
+ <A HREF="http://irrlicht.sourceforge.net" >Irrlicht Engine</A>. But because
+ the parser has become very useful with the latest release, people asked for a
+ separate version of it, to be able to use it in non Irrlicht projects. With
+ irrXML 1.0, this has now been done.
+*/
+
+namespace irr
+{
+namespace io
+{
+ //! Enumeration of all supported source text file formats
+ enum ETEXT_FORMAT
+ {
+ //! ASCII, file without byte order mark, or not a text file
+ ETF_ASCII,
+
+ //! UTF-8 format
+ ETF_UTF8,
+
+ //! UTF-16 format, big endian
+ ETF_UTF16_BE,
+
+ //! UTF-16 format, little endian
+ ETF_UTF16_LE,
+
+ //! UTF-32 format, big endian
+ ETF_UTF32_BE,
+
+ //! UTF-32 format, little endian
+ ETF_UTF32_LE
+ };
+
+
+ //! Enumeration for all xml nodes which are parsed by IrrXMLReader
+ enum EXML_NODE
+ {
+ //! No xml node. This is usually the node if you did not read anything yet.
+ EXN_NONE,
+
+ //! An xml element such as <foo>
+ EXN_ELEMENT,
+
+ //! End of an xml element such as </foo>
+ EXN_ELEMENT_END,
+
+ //! Text within an xml element: <foo> this is the text. </foo>
+ //! Also text between 2 xml elements: </foo> this is the text. <foo>
+ EXN_TEXT,
+
+ //! An xml comment like <!-- I am a comment --> or a DTD definition.
+ EXN_COMMENT,
+
+ //! An xml cdata section like <![CDATA[ this is some CDATA ]]>
+ EXN_CDATA,
+
+ //! Unknown element.
+ EXN_UNKNOWN
+ };
+
+ //! Callback class for file read abstraction.
+ /** With this, it is possible to make the xml parser read in other
+ things than just files. The Irrlicht engine is using this for example to
+ read xml from compressed .zip files. To make the parser read in
+ any other data, derive a class from this interface, implement the
+ two methods to read your data and give a pointer to an instance of
+ your implementation when calling createIrrXMLReader(),
+ createIrrXMLReaderUTF16() or createIrrXMLReaderUTF32() */
+ class IFileReadCallBack
+ {
+ public:
+
+ //! Destructor
+ virtual ~IFileReadCallBack() {}
+
+ //! Reads an amount of bytes from the file.
+ /** \param buffer: Pointer to buffer where to read bytes will be written to.
+ \param sizeToRead: Amount of bytes to read from the file.
+ \return Returns how much bytes were read. */
+ virtual int read(void* buffer, int sizeToRead) = 0;
+
+ //! Returns size of file in bytes
+ virtual long getSize() const = 0;
+ };
+
+ //! Empty class to be used as parent class for IrrXMLReader.
+ /** If you need another class as base class for the xml reader, you can do this by creating
+ the reader using for example new CXMLReaderImpl<char, YourBaseClass>(yourcallback);
+ The Irrlicht Engine for example needs IReferenceCounted as base class for every object to
+ let it automaticly reference countend, hence it replaces IXMLBase with IReferenceCounted.
+ See irrXML.cpp on how this can be done in detail. */
+ class IXMLBase
+ {
+ };
+
+ //! Interface providing easy read access to a XML file.
+ /** You can create an instance of this reader using one of the factory functions
+ createIrrXMLReader(), createIrrXMLReaderUTF16() and createIrrXMLReaderUTF32().
+ If using the parser from the Irrlicht Engine, please use IFileSystem::createXMLReader()
+ instead.
+ For a detailed intro how to use the parser, see \ref irrxmlexample and \ref features.
+
+ The typical usage of this parser looks like this:
+ \code
+ #include <irrXML.h>
+ using namespace irr; // irrXML is located in the namespace irr::io
+ using namespace io;
+
+ void main()
+ {
+ // create the reader using one of the factory functions
+ IrrXMLReader* xml = createIrrXMLReader("config.xml");
+
+ if (xml == 0)
+ return; // file could not be opened
+
+ // parse the file until end reached
+ while(xml->read())
+ {
+ // based on xml->getNodeType(), do something.
+ }
+
+ // delete the xml parser after usage
+ delete xml;
+ }
+ \endcode
+ See \ref irrxmlexample for a more detailed example.
+ */
+ template<class char_type, class super_class>
+ class IIrrXMLReader : public super_class
+ {
+ public:
+
+ //! Destructor
+ virtual ~IIrrXMLReader() {}
+
+ //! Reads forward to the next xml node.
+ /** \return Returns false, if there was no further node. */
+ virtual bool read() = 0;
+
+ //! Returns the type of the current XML node.
+ virtual EXML_NODE getNodeType() const = 0;
+
+ //! Returns attribute count of the current XML node.
+ /** This is usually
+ non null if the current node is EXN_ELEMENT, and the element has attributes.
+ \return Returns amount of attributes of this xml node. */
+ virtual unsigned int getAttributeCount() const = 0;
+
+ //! Returns name of an attribute.
+ /** \param idx: Zero based index, should be something between 0 and getAttributeCount()-1.
+ \return Name of the attribute, 0 if an attribute with this index does not exist. */
+ virtual const char_type* getAttributeName(int idx) const = 0;
+
+ //! Returns the value of an attribute.
+ /** \param idx: Zero based index, should be something between 0 and getAttributeCount()-1.
+ \return Value of the attribute, 0 if an attribute with this index does not exist. */
+ virtual const char_type* getAttributeValue(int idx) const = 0;
+
+ //! Returns the value of an attribute.
+ /** \param name: Name of the attribute.
+ \return Value of the attribute, 0 if an attribute with this name does not exist. */
+ virtual const char_type* getAttributeValue(const char_type* name) const = 0;
+
+ //! Returns the value of an attribute in a safe way.
+ /** Like getAttributeValue(), but does not
+ return 0 if the attribute does not exist. An empty string ("") is returned then.
+ \param name: Name of the attribute.
+ \return Value of the attribute, and "" if an attribute with this name does not exist */
+ virtual const char_type* getAttributeValueSafe(const char_type* name) const = 0;
+
+ //! Returns the value of an attribute as integer.
+ /** \param name Name of the attribute.
+ \return Value of the attribute as integer, and 0 if an attribute with this name does not exist or
+ the value could not be interpreted as integer. */
+ virtual int getAttributeValueAsInt(const char_type* name) const = 0;
+
+ //! Returns the value of an attribute as integer.
+ /** \param idx: Zero based index, should be something between 0 and getAttributeCount()-1.
+ \return Value of the attribute as integer, and 0 if an attribute with this index does not exist or
+ the value could not be interpreted as integer. */
+ virtual int getAttributeValueAsInt(int idx) const = 0;
+
+ //! Returns the value of an attribute as float.
+ /** \param name: Name of the attribute.
+ \return Value of the attribute as float, and 0 if an attribute with this name does not exist or
+ the value could not be interpreted as float. */
+ virtual float getAttributeValueAsFloat(const char_type* name) const = 0;
+
+ //! Returns the value of an attribute as float.
+ /** \param idx: Zero based index, should be something between 0 and getAttributeCount()-1.
+ \return Value of the attribute as float, and 0 if an attribute with this index does not exist or
+ the value could not be interpreted as float. */
+ virtual float getAttributeValueAsFloat(int idx) const = 0;
+
+ //! Returns the name of the current node.
+ /** Only valid, if the node type is EXN_ELEMENT.
+ \return Name of the current node or 0 if the node has no name. */
+ virtual const char_type* getNodeName() const = 0;
+
+ //! Returns data of the current node.
+ /** Only valid if the node has some
+ data and it is of type EXN_TEXT, EXN_COMMENT, EXN_CDATA or EXN_UNKNOWN. */
+ virtual const char_type* getNodeData() const = 0;
+
+ //! Returns if an element is an empty element, like <foo />
+ virtual bool isEmptyElement() const = 0;
+
+ //! Returns format of the source xml file.
+ /** It is not necessary to use
+ this method because the parser will convert the input file format
+ to the format wanted by the user when creating the parser. This
+ method is useful to get/display additional informations. */
+ virtual ETEXT_FORMAT getSourceFormat() const = 0;
+
+ //! Returns format of the strings returned by the parser.
+ /** This will be UTF8 for example when you created a parser with
+ IrrXMLReaderUTF8() and UTF32 when it has been created using
+ IrrXMLReaderUTF32. It should not be necessary to call this
+ method and only exists for informational purposes. */
+ virtual ETEXT_FORMAT getParserFormat() const = 0;
+ };
+
+
+ template <typename T>
+ struct xmlChar
+ {
+ T c;
+ xmlChar<T>() {}
+ xmlChar<T>(char in) : c(static_cast<T>(in)) {}
+ xmlChar<T>(wchar_t in) : c(static_cast<T>(in)) {}
+#if defined(__BORLANDC__)
+ // Note - removing explicit for borland was to get it to even compile.
+ // There haven't been any kind of tests for that besides that.
+ xmlChar<T>(unsigned char in) : c(static_cast<T>(in)) {}
+ xmlChar<T>(unsigned short in) : c(static_cast<T>(in)) {}
+ xmlChar<T>(unsigned int in) : c(static_cast<T>(in)) {}
+ xmlChar<T>(unsigned long in) : c(static_cast<T>(in)) {}
+#else
+ explicit xmlChar<T>(unsigned char in) : c(static_cast<T>(in)) {}
+ explicit xmlChar<T>(unsigned short in) : c(static_cast<T>(in)) {}
+ explicit xmlChar<T>(unsigned int in) : c(static_cast<T>(in)) {}
+ explicit xmlChar<T>(unsigned long in) : c(static_cast<T>(in)) {}
+#endif
+ operator T() const { return c; }
+ void operator=(int t) { c=static_cast<T>(t); }
+ };
+
+ //! defines the utf-16 type.
+ /** Not using wchar_t for this because
+ wchar_t has 16 bit on windows and 32 bit on other operating systems. */
+ typedef xmlChar<unsigned short> char16;
+
+ //! defines the utf-32 type.
+ /** Not using wchar_t for this because
+ wchar_t has 16 bit on windows and 32 bit on other operating systems. */
+ typedef xmlChar<unsigned int> char32;
+
+ //! A UTF-8 or ASCII character xml parser.
+ /** This means that all character data will be returned in 8 bit ASCII or UTF-8 by this parser.
+ The file to read can be in any format, it will be converted to UTF-8 if it is not
+ in this format.
+ Create an instance of this with createIrrXMLReader();
+ See IIrrXMLReader for description on how to use it. */
+ typedef IIrrXMLReader<char, IXMLBase> IrrXMLReader;
+
+ //! A UTF-16 xml parser.
+ /** This means that all character data will be returned in UTF-16 by this parser.
+ The file to read can be in any format, it will be converted to UTF-16 if it is not
+ in this format.
+ Create an instance of this with createIrrXMLReaderUTF16();
+ See IIrrXMLReader for description on how to use it. */
+ typedef IIrrXMLReader<char16, IXMLBase> IrrXMLReaderUTF16;
+
+ //! A UTF-32 xml parser.
+ /** This means that all character data will be returned in UTF-32 by this parser.
+ The file to read can be in any format, it will be converted to UTF-32 if it is not
+ in this format.
+ Create an instance of this with createIrrXMLReaderUTF32();
+ See IIrrXMLReader for description on how to use it. */
+ typedef IIrrXMLReader<char32, IXMLBase> IrrXMLReaderUTF32;
+
+
+ //! Creates an instance of an UFT-8 or ASCII character xml parser.
+ /** This means that all character data will be returned in 8 bit ASCII or UTF-8.
+ The file to read can be in any format, it will be converted to UTF-8 if it is not in this format.
+ If you are using the Irrlicht Engine, it is better not to use this function but
+ IFileSystem::createXMLReaderUTF8() instead.
+ \param filename: Name of file to be opened.
+ \return Returns a pointer to the created xml parser. This pointer should be
+ deleted using 'delete' after no longer needed. Returns 0 if an error occured
+ and the file could not be opened. */
+ IRRLICHT_API IrrXMLReader* IRRCALLCONV createIrrXMLReader(const char* filename);
+
+ //! Creates an instance of an UFT-8 or ASCII character xml parser.
+ /** This means that all character data will be returned in 8 bit ASCII or UTF-8. The file to read can
+ be in any format, it will be converted to UTF-8 if it is not in this format.
+ If you are using the Irrlicht Engine, it is better not to use this function but
+ IFileSystem::createXMLReaderUTF8() instead.
+ \param file: Pointer to opened file, must have been opened in binary mode, e.g.
+ using fopen("foo.bar", "wb"); The file will not be closed after it has been read.
+ \return Returns a pointer to the created xml parser. This pointer should be
+ deleted using 'delete' after no longer needed. Returns 0 if an error occured
+ and the file could not be opened. */
+ IRRLICHT_API IrrXMLReader* IRRCALLCONV createIrrXMLReader(FILE* file);
+
+ //! Creates an instance of an UFT-8 or ASCII character xml parser.
+ /** This means that all character data will be returned in 8 bit ASCII or UTF-8. The file to read can
+ be in any format, it will be converted to UTF-8 if it is not in this format.
+ If you are using the Irrlicht Engine, it is better not to use this function but
+ IFileSystem::createXMLReaderUTF8() instead.
+ \param callback: Callback for file read abstraction. Implement your own
+ callback to make the xml parser read in other things than just files. See
+ IFileReadCallBack for more information about this.
+ \param deleteCallback: if true, the callback will be deleted after the file
+ has been read. Otherwise the caller si responsible for cleaning it up.
+ \return Returns a pointer to the created xml parser. This pointer should be
+ deleted using 'delete' after no longer needed. Returns 0 if an error occured
+ and the file could not be opened. */
+ IRRLICHT_API IrrXMLReader* IRRCALLCONV createIrrXMLReader(IFileReadCallBack* callback,
+ bool deleteCallback = false);
+
+ //! Creates an instance of an UFT-16 xml parser.
+ /** This means that
+ all character data will be returned in UTF-16. The file to read can
+ be in any format, it will be converted to UTF-16 if it is not in this format.
+ If you are using the Irrlicht Engine, it is better not to use this function but
+ IFileSystem::createXMLReader() instead.
+ \param filename: Name of file to be opened.
+ \return Returns a pointer to the created xml parser. This pointer should be
+ deleted using 'delete' after no longer needed. Returns 0 if an error occured
+ and the file could not be opened. */
+ IRRLICHT_API IrrXMLReaderUTF16* IRRCALLCONV createIrrXMLReaderUTF16(const char* filename);
+
+ //! Creates an instance of an UFT-16 xml parser.
+ /** This means that all character data will be returned in UTF-16. The file to read can
+ be in any format, it will be converted to UTF-16 if it is not in this format.
+ If you are using the Irrlicht Engine, it is better not to use this function but
+ IFileSystem::createXMLReader() instead.
+ \param file: Pointer to opened file, must have been opened in binary mode, e.g.
+ using fopen("foo.bar", "wb"); The file will not be closed after it has been read.
+ \return Returns a pointer to the created xml parser. This pointer should be
+ deleted using 'delete' after no longer needed. Returns 0 if an error occured
+ and the file could not be opened. */
+ IRRLICHT_API IrrXMLReaderUTF16* IRRCALLCONV createIrrXMLReaderUTF16(FILE* file);
+
+ //! Creates an instance of an UFT-16 xml parser.
+ /** This means that all character data will be returned in UTF-16. The file to read can
+ be in any format, it will be converted to UTF-16 if it is not in this format.
+ If you are using the Irrlicht Engine, it is better not to use this function but
+ IFileSystem::createXMLReader() instead.
+ \param callback: Callback for file read abstraction. Implement your own
+ callback to make the xml parser read in other things than just files. See
+ IFileReadCallBack for more information about this.
+ \param deleteCallback: if true, the callback will be deleted after the file
+ has been read. Otherwise the caller si responsible for cleaning it up.
+ \return Returns a pointer to the created xml parser. This pointer should be
+ deleted using 'delete' after no longer needed. Returns 0 if an error occured
+ and the file could not be opened. */
+ IRRLICHT_API IrrXMLReaderUTF16* IRRCALLCONV createIrrXMLReaderUTF16(IFileReadCallBack* callback,
+ bool deleteCallback = false);
+
+
+ //! Creates an instance of an UFT-32 xml parser.
+ /** This means that all character data will be returned in UTF-32. The file to read can
+ be in any format, it will be converted to UTF-32 if it is not in this format.
+ If you are using the Irrlicht Engine, it is better not to use this function but
+ IFileSystem::createXMLReader() instead.
+ \param filename: Name of file to be opened.
+ \return Returns a pointer to the created xml parser. This pointer should be
+ deleted using 'delete' after no longer needed. Returns 0 if an error occured
+ and the file could not be opened. */
+ IRRLICHT_API IrrXMLReaderUTF32* IRRCALLCONV createIrrXMLReaderUTF32(const char* filename);
+
+ //! Creates an instance of an UFT-32 xml parser.
+ /** This means that all character data will be returned in UTF-32. The file to read can
+ be in any format, it will be converted to UTF-32 if it is not in this format.
+ if you are using the Irrlicht Engine, it is better not to use this function but
+ IFileSystem::createXMLReader() instead.
+ \param file: Pointer to opened file, must have been opened in binary mode, e.g.
+ using fopen("foo.bar", "wb"); The file will not be closed after it has been read.
+ \return Returns a pointer to the created xml parser. This pointer should be
+ deleted using 'delete' after no longer needed. Returns 0 if an error occured
+ and the file could not be opened. */
+ IRRLICHT_API IrrXMLReaderUTF32* IRRCALLCONV createIrrXMLReaderUTF32(FILE* file);
+
+ //! Creates an instance of an UFT-32 xml parser.
+ /** This means that
+ all character data will be returned in UTF-32. The file to read can
+ be in any format, it will be converted to UTF-32 if it is not in this format.
+ If you are using the Irrlicht Engine, it is better not to use this function but
+ IFileSystem::createXMLReader() instead.
+ \param callback: Callback for file read abstraction. Implement your own
+ callback to make the xml parser read in other things than just files. See
+ IFileReadCallBack for more information about this.
+ \param deleteCallback: if true, the callback will be deleted after the file
+ has been read. Otherwise the caller si responsible for cleaning it up.
+ \return Returns a pointer to the created xml parser. This pointer should be
+ deleted using 'delete' after no longer needed. Returns 0 if an error occured
+ and the file could not be opened. */
+ IRRLICHT_API IrrXMLReaderUTF32* IRRCALLCONV createIrrXMLReaderUTF32(IFileReadCallBack* callback,
+ bool deleteCallback = false);
+
+
+ /*! \file irrXML.h
+ \brief Header file of the irrXML, the Irrlicht XML parser.
+
+ This file includes everything needed for using irrXML,
+ the XML parser of the Irrlicht Engine. To use irrXML,
+ you only need to include this file in your project:
+
+ \code
+ #include <irrXML.h>
+ \endcode
+
+ It is also common to use the two namespaces in which irrXML is included,
+ directly after including irrXML.h:
+
+ \code
+ #include <irrXML.h>
+ using namespace irr;
+ using namespace io;
+ \endcode
+ */
+
+} // end namespace io
+} // end namespace irr
+
+#endif // __IRR_XML_H_INCLUDED__
+
|