irrXML.hpp

// 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 duckcpp/duckcpp.hpp and/or irrXML.h
 
#ifndef DCPP_XML_HPP_INCLUDED
#define DCPP_XML_HPP_INCLUDED
 
#include <duckcpp/core/engine/DcppCompileConfig.hpp>
#include <duckcpp/core/engine/irrArray.hpp>
#include <duckcpp/core/engine/irrString.hpp>
 
namespace dcpp
{
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,
                dcpp::nub::array<dcpp::nub::basic_string<char_type> > &names, dcpp::nub::array<dcpp::nub::basic_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>
    class xmlChar
    {
    public:
        T c;
        xmlChar() {}
        xmlChar(char in) : c(static_cast<T>(in)) {}
        xmlChar(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(unsigned char in) : c(static_cast<T>(in)) {}
        xmlChar(unsigned short in) : c(static_cast<T>(in)) {}
        xmlChar(unsigned int in) : c(static_cast<T>(in)) {}
        xmlChar(unsigned long in) : c(static_cast<T>(in)) {}
#else
        explicit xmlChar(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(unsigned short in) : c(static_cast<T>(in)) {}
#endif
        explicit xmlChar(unsigned int in) : c(static_cast<T>(in)) {}
        explicit xmlChar(unsigned long in) : c(static_cast<T>(in)) {}
#endif
        operator T() const { return c; }
        void operator=(int t) { c=static_cast<T>(t); }
    };
 
 
    using char16 = xmlChar<unsigned short>;
 
 
    using char32 = xmlChar<unsigned int>;
 
 
    using IrrXMLReader = IIrrXMLReader<char, IXMLBase>;
 
 
    using IrrXMLReaderUTF16 = IIrrXMLReader<char16, IXMLBase>;
 
 
    using IrrXMLReaderUTF32 = IIrrXMLReader<char32, IXMLBase>;
 
#ifdef _DCPP_COMPILE_WITH_XML_
 
 
    DUCKCPP_API IrrXMLReader* IRRCALLCONV createIrrXMLReader(const char* filename);
 
 
    DUCKCPP_API IrrXMLReader* IRRCALLCONV createIrrXMLReader(FILE* file);
 
 
    DUCKCPP_API IrrXMLReader* IRRCALLCONV createIrrXMLReader(IFileReadCallBack* callback,
                                                                bool deleteCallback = false);
 
 
    DUCKCPP_API IrrXMLReaderUTF16* IRRCALLCONV createIrrXMLReaderUTF16(const char* filename);
 
 
    DUCKCPP_API IrrXMLReaderUTF16* IRRCALLCONV createIrrXMLReaderUTF16(FILE* file);
 
 
    DUCKCPP_API IrrXMLReaderUTF16* IRRCALLCONV createIrrXMLReaderUTF16(IFileReadCallBack* callback,
                                                                        bool deleteCallback = false);
 
 
 
    DUCKCPP_API IrrXMLReaderUTF32* IRRCALLCONV createIrrXMLReaderUTF32(const char* filename);
 
 
    DUCKCPP_API IrrXMLReaderUTF32* IRRCALLCONV createIrrXMLReaderUTF32(FILE* file);
 
 
    DUCKCPP_API IrrXMLReaderUTF32* IRRCALLCONV createIrrXMLReaderUTF32(IFileReadCallBack* callback,
                                                                        bool deleteCallback = false);
 
#endif // _DCPP_COMPILE_WITH_XML_
 
} // end namespace io
} // end namespace dcpp
 
#endif // DCPP_XML_HPP_INCLUDED