yatexml.h

#ifndef __YATEXML_H
#define __YATEXML_H

#ifndef __cplusplus
#error C++ is required
#endif

#include <yateclass.h>

namespace TelEngine {

class XmlSaxParser;
class XmlDomParser;
class XmlDeclaration;
class XmlFragment;
class XmlChild;
class XmlParent;
class XmlDocument;
class XmlElement;
class XmlComment;
class XmlCData;
class XmlText;
class XmlDoctype;


struct YATE_API XmlEscape {
    const char* value;

    char replace;
};

class YATE_API XmlSaxParser : public DebugEnabler
{
public:
    enum Error {
        NoError = 0,
        NotWellFormed,
        Unknown,
        IOError,
        ElementParse,
        ReadElementName,
        InvalidElementName,
        ReadingAttributes,
        CommentParse,
        DeclarationParse,
        DefinitionParse,
        CDataParse,
        ReadingEndTag,
        Incomplete,
        InvalidEncoding,
        UnsupportedEncoding,
        UnsupportedVersion,
    };
    enum Type {
        None           = 0,
        Text           = 1,
        CData          = 2,
        Element        = 3,
        Doctype        = 4,
        Comment        = 5,
        Declaration    = 6,
        Instruction    = 7,
        EndTag         = 8,
        Special        = 9
    };

    virtual ~XmlSaxParser();

    inline unsigned int offset() const
        { return m_offset; }

    inline unsigned int row() const
        { return m_row; }

    inline unsigned int column() const
        { return m_column; }

    inline const String& buffer() const
        { return m_buf; }

    bool parse(const char* data);

    bool completeText();

    inline Error error()
        { return m_error; }

    bool setError(Error error, XmlChild* child = 0);

    inline const char* getError(const char* defVal = "Xml error")
        { return getError(m_error,defVal); }

    inline Type unparsed()
        { return m_unparsed; }

    inline void setUnparsed(Type id)
        { m_unparsed = id;}

    virtual void reset();

    const String& getBuffer() const
        { return m_buf; }

    static inline const char* getError(int code, const char* defVal = "Xml error")
        { return lookup(code,s_errorString,defVal); }

    static inline bool blank(char c)
        { return (c == 0x20) || (c == 0x09) || (c == 0x0d) || (c == 0x0a); }

    static bool checkFirstNameCharacter(unsigned char ch);

    static bool checkDataChar(unsigned char c);

    static bool checkNameCharacter(unsigned char ch);

    static bool validTag(const String& buf);

    static void escape(String& buf, const String& text);

    static const TokenDict s_errorString[];

    static const XmlEscape s_escape[];

protected:
    XmlSaxParser(const char* name = "XmlSaxParser");

    bool parseInstruction();

    bool parseCData();

    bool parseComment();

    bool parseElement();

    bool parseDeclaration();

    bool parseSpecial();

    bool parseEndTag();

    bool parseDoctype();

    bool auxParse();

    void unEscape(String& text);

    void skipBlanks();

    inline bool badCharacter(char c)
        { return c == '<' || c == '>'; }

    inline void resetError()
        { m_error = NoError; }

    inline void resetParsed()
        { m_parsed.clear(); m_parsed.clearParams(); }

    String* extractName(bool& empty);

    NamedString* getAttribute();

    virtual void gotComment(const String& text)
        { }

    virtual void gotProcessing(const NamedString& instr)
        { }

    virtual void gotDeclaration(const NamedList& decl)
        { }

    virtual void gotText(const String& text)
        { }

    virtual void gotCdata(const String& data)
        { }

    virtual void gotElement(const NamedList& element, bool empty)
        { }

    virtual void endElement(const String& name)
        { }

    virtual void gotDoctype(const String& doc)
        { }

    virtual bool completed()
        { return true; }

    bool processElement(NamedList& list, bool empty);

    bool processText(String& text);

    unsigned int m_offset;

    unsigned int m_row;

    unsigned int m_column;

    Error m_error;

    String m_buf;

    NamedList m_parsed;

    Type m_unparsed;
};

class YATE_API XmlParent
{
public:
    XmlParent()
        { }

    virtual ~XmlParent()
        { }

    virtual XmlDocument* document()
        { return 0; }

    virtual XmlFragment* fragment()
        { return 0; }

    virtual XmlElement* element()
        { return 0; }

    virtual XmlSaxParser::Error addChild(XmlChild* child) = 0;

    inline XmlChild* addChildSafe(XmlChild* child) {
            XmlSaxParser::Error err = addChild(child);
            if (err != XmlSaxParser::NoError)
                TelEngine::destruct(child);
            return child;
        }

    virtual XmlChild* removeChild(XmlChild* child, bool delObj = true) = 0;

    virtual void reset()
        { }

    virtual const ObjList& getChildren() const
        { return ObjList::empty(); }

    virtual void clearChildren()
        {  }

    inline bool hasChildren() const
        { return getChildren().skipNull() != 0; }
};

class YATE_API XmlDomParser : public XmlSaxParser
{
    friend class XmlChild;
public:
    XmlDomParser(const char* name = "XmlDomParser", bool fragment = false);

    XmlDomParser(XmlParent* fragment, bool takeOwnership);

    virtual ~XmlDomParser();

    XmlDocument* document()
        { return m_data->document(); }

    XmlFragment* fragment()
        { return m_data->fragment(); }

    virtual void reset();

    inline bool isCurrent(const XmlElement* el) const
        { return el == m_current; }

protected:

    virtual void gotComment(const String& text);

    virtual void gotProcessing(const NamedString& instr);

    virtual void gotDeclaration(const NamedList& decl);

    virtual void gotText(const String& text);

    virtual void gotCdata(const String& data);

    virtual void gotElement(const NamedList& element, bool empty);

    virtual void endElement(const String& name);

    virtual void gotDoctype(const String& doc);

    virtual bool completed()
        { return m_current == 0; }

private:
    XmlElement* m_current;                   // The current xml element
    XmlParent* m_data;                       // Main xml fragment
    bool m_ownData;                          // The DOM owns data
};

class YATE_API XmlChild : public GenObject
{
    YCLASS(XmlChild,GenObject)
    friend class XmlDomParser;
public:
    XmlChild();

    virtual void setParent(XmlParent* parent)
        { }

    virtual XmlElement* xmlElement()
        { return 0; }

    virtual XmlComment* xmlComment()
        { return 0; }

    virtual XmlCData* xmlCData()
        { return 0; }

    virtual XmlText* xmlText()
        { return 0; }

    virtual XmlDeclaration* xmlDeclaration()
        { return 0; }

    virtual XmlDoctype* xmlDoctype()
        { return 0; }
};


class YATE_API XmlDeclaration : public XmlChild
{
    YCLASS(XmlDeclaration,XmlChild)
public:
    XmlDeclaration(const char* version = "1.0", const char* enc = "utf-8");

    XmlDeclaration(const NamedList& decl);

    XmlDeclaration(const XmlDeclaration& orig);

    ~XmlDeclaration();

    inline const NamedList& getDec() const
        { return m_declaration; }

    virtual XmlDeclaration* xmlDeclaration()
        { return this; }

    void toString(String& dump, bool escape = true) const;

private:
    NamedList m_declaration;                 // The declaration
};

class YATE_API XmlFragment : public XmlParent
{
public:

    XmlFragment();

    XmlFragment(const XmlFragment& orig);

    virtual ~XmlFragment();

    virtual XmlFragment* fragment()
        { return this; }

    virtual const ObjList& getChildren() const
        { return m_list; }

    virtual XmlSaxParser::Error addChild(XmlChild* child);

    virtual void reset();

    inline XmlChild* pop()
        { return static_cast<XmlChild*>(m_list.remove(false)); }

    XmlElement* popElement();

    virtual XmlChild* removeChild(XmlChild* child, bool delObj = true);

    virtual void clearChildren()
        { m_list.clear(); }

    void toString(String& dump, bool escape = true, const String& indent = String::empty(),
        const String& origIndent = String::empty(), bool completeOnly = true,
        const String* auth = 0, const XmlElement* parent = 0) const;

    static XmlElement* findElement(ObjList* list, const String* name, const String* ns,
        bool noPrefix = true);

private:
    ObjList m_list;                    // The children list
};

class YATE_API XmlDocument : public XmlParent
{
public:

    XmlDocument();

    virtual ~XmlDocument();

    virtual XmlDocument* document()
        { return this; }

    virtual XmlSaxParser::Error addChild(XmlChild* child);

    XmlDeclaration* declaration() const;

    XmlElement* root(bool completed = false) const;

    inline XmlElement* takeRoot(bool completed = false)
    {
        XmlElement* r = root(completed);
        if (r)
            m_root = 0;
        return r;
    }

    virtual void reset();

    virtual XmlChild* removeChild(XmlChild* child, bool delObj = true)
        { return m_beforeRoot.removeChild(child,delObj); }

    virtual XmlSaxParser::Error read(Stream& in, int* error = 0);

    virtual int write(Stream& out, bool escape = true,
        const String& indent = String::empty(), const String& origIndent = String::empty(),
        bool completeOnly = true) const;

    XmlSaxParser::Error loadFile(const char* file, int* error = 0);

    int saveFile(const char* file = 0, bool escape = true,
        const String& indent = String::empty(), bool completeOnly = true) const;

    void toString(String& dump, bool escape = true, const String& indent = String::empty(),
        const String& origIndent = String::empty()) const;

private:
    XmlElement* m_root;                  // The root element
    XmlFragment m_beforeRoot;            // XML children before root (declaration ...)
    String m_file;                       // The file name used on load
    XmlFragment m_afterRoot;             // XML children after root (comments, empty text)
};


class YATE_API XmlElement : public XmlChild, public XmlParent
{
    YCLASS(XmlElement,XmlChild)
public:
    XmlElement(const NamedList& element, bool empty, XmlParent* parent = 0);

    XmlElement(const char* name, bool complete = true);

    XmlElement(const char* name, const char* value, bool complete = true);

    XmlElement(const XmlElement& orig);

    virtual ~XmlElement();

    inline const char* tag() const
        { return m_element; }

    inline bool isDefaultNs() const
        { return m_prefixed == 0; }

    inline const String& unprefixedTag() const
        { return m_prefixed ? m_prefixed->name() : static_cast<const String&>(m_element); }

    void setUnprefixedTag(const String& s);

    inline const String& getTag() const
        { return m_prefixed ? m_prefixed->name() : static_cast<const String&>(m_element); }

    bool getTag(const String*& tag, const String*& ns) const;

    virtual XmlElement* xmlElement()
        { return this; }

    virtual XmlElement* element()
        { return this; }

    virtual XmlSaxParser::Error addChild(XmlChild* child);

    virtual XmlChild* removeChild(XmlChild* child, bool delObj = true);

    virtual void setCompleted()
        { m_complete = true; }

    inline bool completed() const
        { return m_complete; }

    inline bool empty() const
        { return m_empty; }

    inline XmlElement* parent() const
        { return m_parent ? m_parent->element() : 0; }

    virtual XmlParent* getParent()
        { return m_parent; }

    virtual void setParent(XmlParent* parent);

    virtual const String& getName() const
        { return m_element; }

    virtual const NamedList& getElement() const
        { return m_element; }

    inline const ObjList& getChildren() const
        { return m_children.getChildren(); }

    inline void clearChildren()
        { return m_children.clearChildren(); }

    inline const NamedList* inheritedNs() const
        { return m_inheritedNs; }

    void setInheritedNs(const XmlElement* xml = 0, bool inherit = true);

    void addInheritedNs(const NamedList& list);

    inline XmlElement* pop() {
            XmlElement* x = findFirstChild();
            if (!(x && x->completed()))
                return 0;
            m_children.removeChild(x,false);
            return x;
        }

    virtual const String& toString() const
        { return m_element; }

    void toString(String& dump, bool escape = true, const String& indent = String::empty(),
        const String& origIndent = String::empty(), bool completeOnly = true,
        const String* auth = 0) const;

    inline XmlElement* findFirstChild(const String* name = 0, const String* ns = 0,
        bool noPrefix = true) const
        { return XmlFragment::findElement(getChildren().skipNull(),name,ns,noPrefix); }

    inline XmlElement* findFirstChild(const String& name, const String* ns = 0,
        bool noPrefix = true) const
        { return XmlFragment::findElement(getChildren().skipNull(),&name,ns,noPrefix); }

    inline XmlElement* findNextChild(const XmlElement* prev = 0, const String* name = 0,
        const String* ns = 0, bool noPrefix = true) const {
            if (!prev)
                return findFirstChild(name,ns,noPrefix);
            ObjList* start = getChildren().find(prev);
            return start ? XmlFragment::findElement(start->skipNext(),name,ns,noPrefix) : 0;
        }

    inline XmlElement* findNextChild(const String& name, const XmlElement* prev = 0,
        const String* ns = 0, bool noPrefix = true) const
        { return findNextChild(prev,&name,ns,noPrefix); }

    inline const String* childText(const String& name, const String* ns = 0,
        bool noPrefix = true) const {
            XmlElement* c = findFirstChild(&name,ns,noPrefix);
            return c ? &(c->getText()) : 0;
        }

     XmlChild* getFirstChild();

    const String& getText() const;

    XmlText* setText(const char* text);

    void addText(const char* text);

    inline const NamedList& attributes() const
        { return m_element; }

    unsigned int copyAttributes(NamedList& list, const String& prefix) const;

    void setAttributes(NamedList& list, const String& prefix, bool skipPrefix = true);

    inline void setAttribute(const String& name, const char* value)
        { m_element.setParam(name,value); }

    inline void setAttributeValid(const String& name, const char* value) {
            if (!TelEngine::null(value))
                m_element.setParam(name,value);
            else
                removeAttribute(name);
        }

    inline const char* attribute(const String& name) const
        { return m_element.getValue(name); }

    inline String* getAttribute(const String& name) const
        { return m_element.getParam(name); }

    inline bool hasAttribute(const String& name, const String& value) const {
            String* a = getAttribute(name);
            return a && *a == value;
        }

    inline void removeAttribute(const String& name)
        { m_element.clearParam(name); }

    inline String* xmlns() const {
            if (!m_prefixed)
                return xmlnsAttribute(s_ns);
            return xmlnsAttribute(s_nsPrefix + *m_prefixed);
        }

    String* xmlnsAttribute(const String& name) const;

    inline bool hasXmlns(const String& ns) const {
            const String* x = xmlns();
            return x && *x == ns;
        }

    bool setXmlns(const String& name = String::empty(), bool addAttr = false,
        const String& value = String::empty());

    static inline bool isXmlns(const String& str)
        { return str == s_ns || str.startsWith(s_nsPrefix); }

    static XmlElement* param2xml(NamedString* param, const String& tag,
        bool copyXml = false);

    static NamedString* xml2param(XmlElement* xml, const String* tag,
        bool copyXml = false);

    static void xml2param(NamedList& list, XmlElement* parent, const String* tag,
        bool copyXml = false);

    static const String s_ns;

    static const String s_nsPrefix;

private:
    // Set prefixed data (tag and prefix)
    inline void setPrefixed() {
            TelEngine::destruct(m_prefixed);
            int pos = m_element.find(":");
            if (pos != -1)
                m_prefixed = new NamedString(m_element.substr(pos + 1),m_element.substr(0,pos));
        }

    XmlFragment m_children;                      // Children of this element
    NamedList m_element;                         // The element
    NamedString* m_prefixed;                     // Splitted prefixed tag (the value is the namespace prefix)
    XmlParent* m_parent;                         // The XmlElement who holds this element
    NamedList* m_inheritedNs;                    // Inherited namespaces (if parent is 0)
    bool m_empty;                                // True if this element does not have any children
    bool m_complete;                             // True if the end element tag war reported
};

class YATE_API XmlComment : public XmlChild
{
    YCLASS(XmlComment,XmlChild)
public:
    XmlComment(const String& comm);

    XmlComment(const XmlComment& orig);

    virtual ~XmlComment();

    inline const String& getComment() const
        { return m_comment; }

    void toString(String& dump, const String& indent = String::empty()) const;

    virtual XmlComment* xmlComment()
        { return this; }

private:
    String m_comment;                       // The comment
};

class YATE_API XmlCData : public XmlChild
{
    YCLASS(XmlCData,XmlChild)
public:

    XmlCData(const String& data);

    XmlCData(const XmlCData& orig);

    virtual ~XmlCData();

    inline const String& getCData() const
        { return m_data;}

    void toString(String& dump, const String& indent = String::empty()) const;

    virtual XmlCData* xmlCData()
        { return this; }

private:
    String m_data;                        // The data
};

class YATE_API XmlText : public XmlChild
{
    YCLASS(XmlText,XmlChild)
public:
    XmlText(const String& text);

    XmlText(const XmlText& orig);

    virtual ~XmlText();

    inline const String& getText() const
        { return m_text; }

    inline void setText(const char* text)
        { m_text = text; }

    void toString(String& dump, bool escape = true, const String& indent = String::empty(),
        const String* auth = 0, const XmlElement* parent = 0) const;

    virtual XmlText* xmlText()
        { return this; }

    bool onlySpaces();
private:
    String m_text;                        // The text
};

class YATE_API XmlDoctype : public XmlChild
{
    YCLASS(XmlDoctype,XmlChild)
public:
    XmlDoctype(const String& doctype);

    XmlDoctype(const XmlDoctype& orig);

    virtual ~XmlDoctype();

    inline const String& getDoctype() const
        { return m_doctype; }

    virtual XmlDoctype* xmlDoctype()
        { return this; }

    void toString(String& dump, const String& indent = String::empty()) const;

private:
    String m_doctype;                          // The document type
};

}; // namespace TelEngine

#endif /* __YATEXML_H */

/* vi: set ts=8 sw=4 sts=4 noet: */