xmlbase.h

Go to the documentation of this file.

#ifndef VART_XMLBASE_H
#define VART_XMLBASE_H

#include <xercesc/parsers/XercesDOMParser.hpp>
#include <xercesc/sax/ErrorHandler.hpp>
#include <xercesc/dom/DOMDocument.hpp>
#include <string>

namespace VART {
    class XmlBase
    {
        public:
        // PUBLIC METHODS
        protected:
        // PROTECTED NESTED CLASSES
            class ErrorHandler : public XERCES_CPP_NAMESPACE::ErrorHandler
            {
                friend class XmlScene;
                public:
                    ErrorHandler();
                    ~ErrorHandler();
                    bool getSawErrors() const;
                    void warning(const XERCES_CPP_NAMESPACE::SAXParseException& e);
                    void error(const XERCES_CPP_NAMESPACE::SAXParseException& e);
                    void fatalError(const XERCES_CPP_NAMESPACE::SAXParseException& e);
                    void resetErrors();

                private :
                    ErrorHandler(const ErrorHandler&);
                    void operator=(const ErrorHandler&);
                    //This is set if we get any errors, and is queryable via a getter
                    //method. Its used by the main code to suppress output if there are
                    //errors.
                    bool fSawErrors;
            }; // XmlBase::ErrorHandler

            class TempCString
            {
                public :
                    TempCString(const XMLCh* const toTranscode)
                    {
                        // Call the private transcoding method
                        cString = XERCES_CPP_NAMESPACE::XMLString::transcode(toTranscode);
                    }
                    ~TempCString()
                    {
                        XERCES_CPP_NAMESPACE::XMLString::release(&cString);
                    }
                    bool operator== (const char* other) const;

                    bool GetValue(int* valuePtr) const;
                    bool GetValue(float* valuePtr) const;
                    bool GetValue(bool* valuePtr) const;

                    operator const char* () const
                    {
                        return cString;
                    }
                private :
                    //This is the local code page form of the string.
                    char* cString;
            }; // XmlBase::TempCString

            class XercesString
            {
                public:
                    XercesString(const char* cString)
                    {
                        xString = XERCES_CPP_NAMESPACE::XMLString::transcode(cString);
                    }
                    ~XercesString()
                    {
                        XERCES_CPP_NAMESPACE::XMLString::release(&xString);
                    }
                    operator const XMLCh* () const
                    {
                        return xString;
                    }
                private:
                    XMLCh* xString;
            }; // XmlBase::XercesString;

        // PROTECTED STATIC METHODS
            static bool GetAttributeValue(XERCES_CPP_NAMESPACE::DOMNamedNodeMap* nodePtr,
                                          const char itemName[], float* valuePtr);

            static bool GetAttributeValue(XERCES_CPP_NAMESPACE::DOMNamedNodeMap* nodePtr,
                                          const char itemName[], std::string* valuePtr);

            static bool GetAttributeValue(XERCES_CPP_NAMESPACE::DOMNamedNodeMap* nodePtr,
                                          const char itemName[], bool* valuePtr);

        // PROTECTED METHODS
            XmlBase();

            bool ParseFile(const std::string& fileName);

            void Terminate();
        // PROTECTED STATIC ATTRIBUTES
        // PROTECTED ATTRIBUTES
            XERCES_CPP_NAMESPACE::XercesDOMParser* parserPtr;
            XERCES_CPP_NAMESPACE::DOMDocument* documentPtr;
    }; // end class declaration
} // end namespace

#endif