src/tools/tXmlParser.h

Go to the documentation of this file.

/*

*************************************************************************

ArmageTron -- Just another Tron Lightcycle Game in 3D.
Copyright (C) 2005  by 
and the AA DevTeam (see the file AUTHORS(.txt) in the main source directory)

**************************************************************************

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  
***************************************************************************

*/

// The base class for xml parsers

#ifndef ArmageTron_XMLPARSER_H
#define ArmageTron_XMLPARSER_H

#include "defs.h"
#include <libxml/parser.h>
#include <libxml/tree.h>

#include "tString.h"
#include "tError.h"
#include "tConsole.h"
#include "tResourceManager.h"

#include <map>
#include <typeinfo>

namespace tXmlParserNamespace {

typedef std::map<tString, tString> tAttributeList;
enum { SAX, DOM };

class tXmlParser {
public:
    class node {
        typedef char CHAR; 
        xmlNode *m_cur;  
    public:
        node(xmlNode *cur); 
        node() : m_cur(0) {} 
        bool IsOfType(CHAR const *name) const; 
        tString GetName(void) const; 
        bool HasProp(CHAR const *prop) const; 
        tString GetProp(CHAR const *prop) const; 
        bool GetPropBool(CHAR const *prop) const; 
#ifndef _MSC_VER
        template<typename T> void GetProp(CHAR const *prop, T &target) const; 
#else
        void GetProp(CHAR const *prop, REAL &target) const;
        void GetProp(CHAR const *prop, bool &target) const;
        void GetProp(CHAR const *prop, int &target) const;
        void GetProp(CHAR const *prop, tString &target) const;
#endif

        bool IsOfType(tString const &name) const { return IsOfType(name.c_str());} 
        bool HasProp(tString const &prop) const { return HasProp(prop.c_str()); } 
        tString GetProp(tString const &prop) const { return GetProp(prop.c_str()); } 
        bool GetPropBool(tString const &prop) const { return GetPropBool(prop.c_str()); } 
        template<typename T> void GetProp(tString const &prop, T &target) const {GetProp(prop.c_str(), target);} 

        node &operator++(); 
        node const operator++(int); 

        operator bool () const; 

        node GetFirstChild(void) const; 
    };

    node GetRoot();

    xmlDocPtr m_Doc; /* The xml document */

    // If DOM isn't what you want, make sure you override this accordingly
    tXmlParser() : m_Doc(0) { SetMode(DOM); };
    virtual ~tXmlParser();

    // Provided just in case you need it, probably will never be used
    tXmlParser(int mode) { SetMode(mode); m_Doc = 0; };

    void SetMode(int mode) { m_Mode = mode; };

    virtual bool LoadFile(const char* filename, const char *uri="");

    // Loads and parses, which is usually what you want
    bool LoadXmlFile(const char* filename, const char* uri="");

    // Loads without parsing, used if you need special parameters in your parse function
    bool LoadWithoutParsing(const char* filename, const char* uri="");
    bool LoadWithParsing(const char* filename, const char* uri="");

    // This is a generic parse.  If you're in DOM mode, it will call your ParseDom
    // method, if you're in SAX mode, it will start the sax parser.
    // If you need to parse with special parameters, you need to make your own method
    // to do it.
    bool Parse();

    // The default implementation does nothing, override this to provide your own
    // dom walker or whatever.  Return true on success, false on failure
    virtual bool ParseDom();

    // Starts the sax parser.  You should override the callbacks listed below to use
    // this and call the constructor to initialize with sax mode
    bool ParseSax();

    // todo: add arguments to these methods
    virtual void startElement(tString &element, tAttributeList &attributes);
    virtual void endElement(tString &element);
    virtual void startDocument();
    virtual void endDocument();

    // internal callbacks, used to bridge libxml2's sax data to armagetron's internal
    // data types.  subclasses can safely ignore these
    void cb_startDocument();
    void cb_endDocument();
    void cb_startElement(const xmlChar* name, const xmlChar** attrs);
    void cb_endElement(const xmlChar *name);
    tString m_Filename;
private:
    int m_Mode;
protected:
    virtual bool ValidateXml(FILE* docfd, const char* uri=NULL, const char* filepath=NULL);
};

class tXmlResource : public tXmlParser {
public:
    bool LoadFile(const char* filename, const char* uri="");
        tResourcePath const &Path() const {return m_Path;} 
protected:
    bool ValidateXml(FILE* docfd, const char* uri, const char* filepath);
    tResourcePath m_Path; 
    node GetFileContents(void); 
};

#ifndef _MSC_VER
template<typename T> void tXmlParser::node::GetProp(CHAR const *prop, T &target) const {
    if(!(GetProp(prop).Convert(target))) {
        tERR_WARN( "Property '" + tString(prop) + "' of node of type '" + GetName() + "' is '" + GetProp(prop) + "' which isn't of type '" + typeid(T).name() + "' as needed.");
    }
}
#endif

}
using tXmlParserNamespace::tXmlParser;
using tXmlParserNamespace::tXmlResource;
#endif

---