irrXML.h

Go to the documentation of this file.

// 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"
#include "irrArray.h"
#include "irrString.h"

namespace irr
{
namespace io
{
        enum ETEXT_FORMAT
        {
                ETF_ASCII,

                ETF_UTF8,

                ETF_UTF16_BE,

                ETF_UTF16_LE,

                ETF_UTF32_BE,

                ETF_UTF32_LE
        };


        enum EXML_NODE
        {
                EXN_NONE,

                EXN_ELEMENT,

                EXN_ELEMENT_END,

                EXN_TEXT,

                EXN_COMMENT,

                EXN_CDATA,

                EXN_UNKNOWN
        };


        class IFileReadCallBack
        {
        public:

                virtual ~IFileReadCallBack() {}


                virtual int read(void* buffer, int sizeToRead) = 0;

                virtual long getSize() const = 0;
        };


        class IXMLBase
        {
        };


        template<class char_type, class super_class>
        class IIrrXMLReader : public super_class
        {
        public:

                virtual ~IIrrXMLReader() {}


                virtual bool read() = 0;

                virtual EXML_NODE getNodeType() const = 0;


                virtual unsigned int getAttributeCount() const = 0;


                virtual const char_type* getAttributeName(int idx) const = 0;


                virtual const char_type* getAttributeValue(int idx) const = 0;


                virtual const char_type* getAttributeValue(const char_type* name) const = 0;


                virtual const char_type* getAttributeValueSafe(const char_type* name) const = 0;


                virtual int getAttributeValueAsInt(const char_type* name, int defaultNotFound=0) const = 0;


                virtual int getAttributeValueAsInt(int idx, int defaultNotFound=0) const = 0;


                virtual float getAttributeValueAsFloat(const char_type* name, float defaultNotFound=0.f) const = 0;


                virtual float getAttributeValueAsFloat(int idx, float defaultNotFound=0.f) const = 0;


                virtual const char_type* getNodeName() const = 0;


                virtual const char_type* getNodeData() const = 0;

                virtual bool isEmptyElement() const = 0;


                virtual ETEXT_FORMAT getSourceFormat() const = 0;


                virtual ETEXT_FORMAT getParserFormat() const = 0;
        };

        template<class char_type, class super_class>
        class IIrrXMLWriter : public super_class
        {
        public:

                virtual ~IIrrXMLWriter() {}


                virtual void writeXMLHeader() = 0;


                virtual void writeElement(const char_type* name, bool empty=false,
                        const char_type* attr1Name = 0, const char_type* attr1Value = 0,
                        const char_type* attr2Name = 0, const char_type* attr2Value = 0,
                        const char_type* attr3Name = 0, const char_type* attr3Value = 0,
                        const char_type* attr4Name = 0, const char_type* attr4Value = 0,
                        const char_type* attr5Name = 0, const char_type* attr5Value = 0) = 0;

                virtual void writeElement(const char_type* name, bool empty,
                                core::array<core::string<char_type> > &names, core::array<core::string<char_type> > &values) = 0;

                virtual void writeComment(const char_type* comment) = 0;

                virtual void writeClosingTag(const char_type* name) = 0;


                virtual void writeText(const char_type* text) = 0;

                virtual void writeLineBreak() = 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)) {}

#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED)      // VS compiling without native wchar_t can't have it
                explicit xmlChar<T>(unsigned short in) : c(static_cast<T>(in)) {}
#endif
                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); }
        };


        typedef xmlChar<unsigned short> char16;


        typedef xmlChar<unsigned int> char32;


        typedef IIrrXMLReader<char, IXMLBase> IrrXMLReader;


        typedef IIrrXMLReader<char16, IXMLBase> IrrXMLReaderUTF16;


        typedef IIrrXMLReader<char32, IXMLBase> IrrXMLReaderUTF32;

#ifdef _IRR_COMPILE_WITH_XML_


        IRRLICHT_API IrrXMLReader* IRRCALLCONV createIrrXMLReader(const char* filename);


        IRRLICHT_API IrrXMLReader* IRRCALLCONV createIrrXMLReader(FILE* file);


        IRRLICHT_API IrrXMLReader* IRRCALLCONV createIrrXMLReader(IFileReadCallBack* callback,
                                                                                                                                bool deleteCallback = false);


        IRRLICHT_API IrrXMLReaderUTF16* IRRCALLCONV createIrrXMLReaderUTF16(const char* filename);


        IRRLICHT_API IrrXMLReaderUTF16* IRRCALLCONV createIrrXMLReaderUTF16(FILE* file);


        IRRLICHT_API IrrXMLReaderUTF16* IRRCALLCONV createIrrXMLReaderUTF16(IFileReadCallBack* callback,
                                                                                                                                                bool deleteCallback = false);



        IRRLICHT_API IrrXMLReaderUTF32* IRRCALLCONV createIrrXMLReaderUTF32(const char* filename);


        IRRLICHT_API IrrXMLReaderUTF32* IRRCALLCONV createIrrXMLReaderUTF32(FILE* file);


        IRRLICHT_API IrrXMLReaderUTF32* IRRCALLCONV createIrrXMLReaderUTF32(IFileReadCallBack* callback,
                                                                                                                                                bool deleteCallback = false);

#endif // _IRR_COMPILE_WITH_XML_

} // end namespace io
} // end namespace irr

#endif // __IRR_XML_H_INCLUDED__