XMLDocument.h

Go to the documentation of this file.

#ifndef __XMLDOCUMENT_H__INCLUDED__
#define __XMLDOCUMENT_H__INCLUDED__

#include <string>
#include <map>
#include <vector>
#include <iterator>

#include <ostream>

namespace XMLDOM
{
class XMLDocument;

class XMLElement
{
public:
    enum Type
    {
        XET_TAG,
        XET_CDATA,
        XET_COMMENT,
        XET_ROOT
    };

private:
    Type mType;
    std::string mTagName;
    std::string mContents;     //for cdata elements

    typedef std::vector< XMLElement* >          ElementList;
    typedef std::map< std::string, XMLElement* >ElementMap;
    typedef std::map< std::string, std::string >AttributeMap;

    ElementList  mChildren;
    ElementMap   mById;
    ElementMap   mByName;
    AttributeMap mAttributes;

    XMLElement  *mParent;
    XMLDocument *mDocument;

public:
    typedef ElementList::iterator        child_iterator;
    typedef ElementList::const_iterator  const_child_iterator;

    typedef AttributeMap::iterator       attribute_iterator;
    typedef AttributeMap::const_iterator const_attribute_iterator;

private:
    const_attribute_iterator mIdAttribute;
    const_attribute_iterator mNameAttribute;

public:
    //Constructors

    XMLElement();

    XMLElement( Type type, const std::string &data = std::string() );

    XMLElement( const std::string &cdata );

    XMLElement( const char *tagName, const char*const *attrValuePairList );

    XMLElement( const char *tagName, const char*const *attrValuePairList, unsigned int nAttr );

    XMLElement( const std::string &tagName, const std::vector< std::string > &attrValuePairList );

    XMLElement( const std::string &tagName, const std::map< std::string, std::string > &attrValuePairList );

    ~XMLElement();

protected:
    void setParent( XMLElement *parent );

    void setDocument( XMLDocument *document );

public:
    Type type() const
    {
        return mType;
    }

    void setType( Type newType );

    const std::string& tagName() const
    {
        return mTagName;
    }

    const XMLElement * getParent() const
    {
        return mParent;
    }

    XMLElement * getParent()
    {
        return mParent;
    }

    const XMLDocument * getDocument() const
    {
        return mDocument;
    }

    XMLDocument * getDocument()
    {
        return mDocument;
    }

    const std::string& contents() const;

    std::string& contents();

    void appendContents( const std::string &cont );

    unsigned int numChildren() const
    {
        return mChildren.size();
    }

    const XMLElement * getChild( unsigned int idx ) const
    {
        return ( idx < mChildren.size() ) ? mChildren[idx] : 0;
    }

    XMLElement * getChild( unsigned int idx )
    {
        return ( idx < mChildren.size() ) ? mChildren[idx] : 0;
    }

    const XMLElement * getChildById( const std::string &id ) const;

    XMLElement * getChildById( const std::string &id );

    const XMLElement * getChildByName( const std::string &name ) const;

    XMLElement * getChildByName( const std::string &name );

    const std::string& getId() const
    {
        static std::string empty;
        return ( mIdAttribute == mAttributes.end() ) ? empty : mIdAttribute->second;
    }

    const std::string& getName() const
    {
        static std::string empty;
        return ( mNameAttribute == mAttributes.end() ) ? empty : mNameAttribute->second;
    }

    const XMLElement * getChildByHierarchicalId( const std::string &id ) const;

    XMLElement * getChildByHierarchicalId( const std::string &id );

    const XMLElement * getChildByHierarchicalName( const std::string &name ) const;

    XMLElement * getChildByHierarchicalName( const std::string &name );

    unsigned int appendChild( XMLElement *newElem );

    void removeChild( unsigned int idx );

    void removeChild( const XMLElement *which );

    void removeChildById( const std::string &id )
    {
        removeChild( getChildById( id ) );
    }

    void removeChildByName( const std::string &name )
    {
        removeChild( getChildByName( name ) );
    }

    void clear( bool doAttributes = true );

    const_attribute_iterator getAttribute( const std::string &name ) const
    {
        return mAttributes.find( name );
    }

    attribute_iterator getAttribute( const std::string &name )
    {
        return mAttributes.find( name );
    }

    void removeAttribute( const std::string &name );

    void setAttribute( const std::string &name, const std::string &value );

    const std::string& getAttributeValue( const std::string &name ) const
    {
        return getAttribute( name )->second;
    }

    const std::string& getAttributeValue( const std::string &name, const std::string &def ) const
    {
        const_attribute_iterator it = getAttribute( name );
        return ( it == attributesEnd() ) ? def : it->second;
    }

    attribute_iterator attributesBegin()
    {
        return mAttributes.begin();
    }
    
    const_attribute_iterator attributesBegin() const
    {
        return mAttributes.begin();
    }
    attribute_iterator attributesEnd()
    {
        return mAttributes.end();
    }
    
    const_attribute_iterator attributesEnd() const
    {
        return mAttributes.end();
    }

    child_iterator childrenBegin()
    {
        return mChildren.begin();
    }
    
    const_child_iterator childrenBegin() const
    {
        return mChildren.begin();
    }
    
    child_iterator childrenEnd()
    {
        return mChildren.end();
    }
    
    const_child_iterator childrenEnd() const
    {
        return mChildren.end();
    }

    void rebuildNamedBindings( bool deepScan = true );

private:
    static void JoinMaps( ElementMap &dst, const ElementMap &src );
};

class XMLDocument
{
public:
    std::string docType;
    std::string sysId;
    std::string pubId;

    bool dirty;

    XMLElement root;

public: XMLDocument() : dirty( false )
        , root( XMLElement::XET_ROOT ) {}
    ~XMLDocument() {}

public:

    //
    //A series of handy wrappers, to mimic JavaScript.
    //(mostly for Python GUI event handlers)
    //

    void rebuildNamedBindings( bool deepScan = true )
    {
        root.rebuildNamedBindings( deepScan );
    }

    void removeElementById( const std::string &id )
    {
        root.removeChildById( id );
    }

    void removeElementByName( const std::string &name )
    {
        root.removeChildByName( name );
    }

    void clear()
    {
        root.clear();
    }

    const XMLElement * getElementById( const std::string &id ) const
    {
        return root.getChildById( id );
    }

    XMLElement * getElementById( const std::string &id )
    {
        return root.getChildById( id );
    }

    const XMLElement * getElementByName( const std::string &name ) const
    {
        return root.getChildByName( name );
    }

    XMLElement * getElementByName( const std::string &name )
    {
        return root.getChildByName( name );
    }

    const XMLElement * getElementByHierarchicalId( const std::string &id ) const
    {
        return root.getChildByHierarchicalId( id );
    }

    XMLElement * getElementByHierarchicalId( const std::string &id )
    {
        return root.getChildByHierarchicalId( id );
    }

    const XMLElement * getElementByHierarchicalName( const std::string &name ) const
    {
        return root.getChildByHierarchicalName( name );
    }

    XMLElement * getElementByHierarchicalName( const std::string &name )
    {
        return root.getChildByHierarchicalName( name );
    }
};

class XMLProcessor;

class XMLSerializer
{
public:
    enum Options
    {
        OPT_WANT_CDATA=0x01,
        OPT_WANT_COMMENTS    =0x02,
        OPT_WANT_NAMEBINDINGS=0x04,
        OPT_WANT_NAMEBINDINGS_DEEPSCAN=0x08,
        OPT_WANT_ALL=OPT_WANT_CDATA|OPT_WANT_COMMENTS,
        OPT_WANT_DEEPBINDINGS=OPT_WANT_NAMEBINDINGS|OPT_WANT_NAMEBINDINGS_DEEPSCAN,
        OPT_DEFAULT=OPT_WANT_ALL|OPT_WANT_DEEPBINDINGS
    };
    int   options;

private:
    void *internals;

public: XMLSerializer( const char *encoding = 0, XMLDocument *doc = 0, XMLElement *elem = 0 );
    virtual ~XMLSerializer();

    virtual bool parse( const void *buf, unsigned int len );

    virtual bool importXML( const std::string &path );

    virtual bool exportXML( std::ostream &stream );

    bool exportXML( const std::string &filename );

    virtual void addProcessor( XMLProcessor *proc );

    virtual bool initialise( const char *encoding = 0, XMLDocument *doc = 0, XMLElement *elem = 0 );

    virtual XMLDocument * close();
};

class XMLProcessor
{
public: XMLProcessor() {}
    virtual ~XMLProcessor() {}

    virtual const std::string& getTarget() const = 0;

    virtual std::pair< bool, std::string >execute( XMLSerializer *serializer,
                                                   XMLDocument *doc,
                                                   XMLElement *current,
                                                   const std::string &data ) = 0;
};
}

#endif //__XMLDOCUMENT_H__INCLUDED__