Tree.hpp

Go to the documentation of this file.

#ifndef UI_GXML_TREE_HPP
#define UI_GXML_TREE_HPP

// STDC++
#include <string>
#include <cassert>
#include <istream>
#include <vector>

// C++ libraries
#include <ui-gxmlcpp/Exception.hpp>
#include <ui-gxmlcpp/XPathContext.hpp>
#include <ui-gxmlcpp/XPathObject.hpp>
#include <ui-gxmlcpp/Buffer.hpp>
#include <ui-gxmlcpp/Util.hpp>

namespace UI {
namespace GXML {

class Tree: private UI::Util::auto_base<xmlDoc>
{
        friend class XSLTransTree;
        friend class SchemaTree;
        friend class RelaxNGTree;
private:
        /* Create a libxml2 <tt>xmlDoc</tt>.
         *
         * @param xmlBuffer Null-terminated C string or buffer of length len.
         * @param base XML Base (@see RFC 2396).
         * @param len Len of buffer. If not given, xmlBuffer will be treated as null-terminated c string.
         * @param options Parse options; To avoid segfaults later, use the
         *        XML=XML_PARSE_NOBLANKS
         *        XSL=XML_PARSE_NOBLANKS | XSLT_PARSE_OPTIONS
         */
        static xmlDoc * create(char const * xml, int len, std::string const & base, int const options);
        static xmlDoc * create(xmlDoc const * const doc);
        static xmlDoc * create(std::string const & file, int const options);

public:
        enum ErrorCode
        {
                Parse_,
                Mem_,
                NoNode_,
                Internal_
        };
        typedef CodeException<ErrorCode> Exception;

        typedef std::map<std::string, std::string> NamespaceMap;

        static std::string const DefaultEncoding_;
        static std::string const DefaultEncodings_;
        static std::string const DefaultDocbase_;

        friend class XMLTree;

protected:
        Tree();

        NamespaceMap xPathNamespaces_;

public:
        friend class XPathContext;

        Tree(char const * xml, int len=-1, std::string const & base=DefaultDocbase_, int const options=0);

        Tree(std::string const & xml, std::string const & base=DefaultDocbase_, int const options=0);

        Tree(std::istream & xml, std::string const & base=DefaultDocbase_, int const options=0);

        enum FileConstructor
        {
                File_
        };
        Tree(FileConstructor const & dummy, std::string const & file, int const options=0);
        Tree(Tree const & tree);
private:
        void dealloc();

public:
        ~Tree();

        Tree & operator=(Tree const & tree);

        bool operator==(Tree const & tree);

        Tree & setContext(bool on=true);

        XPathContext * getContext() const;
        Tree & setTopLevelNamespaces();

        Tree & setXPathNamespace(std::string const & prefix, std::string const & uri);

protected:
        Tree & setDontFreeDoc(bool on=true);

public:
        class NodeSet;

        class Node: private UI::Util::auto_base<xmlNode>
        {
                friend class NodeSet;
        public:
                Node(xmlNode * const node=0);
                bool isNull() const;
                void unlink();

                Node getParent() const;
                Node getChild() const;
                Node getNext() const;
                Node getPrev() const;
                NodeSet getChilds(std::string const & name="") const;

                typedef xmlElementType Type;

                Type getType() const;

                std::string getXPath() const;

                char const * getNameC() const;
                std::string getName() const;
                void setName(std::string const & name);
                char const * getContentC() const;
                std::string getContent() const;
                void setContent(std::string const & content);
                char const * hasAttribute(std::string const & name) const;
                char const * getAttributeC(std::string const & name) const;
                std::string getAttribute(std::string const & name) const;
                void setAttribute(std::string const & name, std::string const & content);

                NodeSet getNodeSet(std::string const & xpath) const;
                Node getNode(std::string const & xpath, bool const & doThrow=true) const;
        private:
                Node copy() const;

        public:
                Node addChild(std::string const & name, std::string const & content="");
                Node addChild(Node const & n);

                Node addSiblingAfter(std::string const & name, std::string const & content);
                Node addSiblingAfter(Node const & n);

                std::string dump(bool const & format=false, std::string const & encoding=DefaultEncoding_) const;

                using UI::Util::auto_base<xmlNode>::get;
                using UI::Util::auto_base<xmlNode>::operator->;

        private:
                static xmlNode * const NullNode_;
        };

        class NodeSet: public std::vector<Node>
        {
        public:
                NodeSet(XPathObject const & xPathObject);
                NodeSet(Node const & node=Node(0), bool const & childs=false, std::string const & name="");
                NodeSet(NodeSet const & ns, bool const & childs=false, std::string const & name="");
                void add(Node const & node, bool const & childs=false, std::string const & name="");
                void add(NodeSet const & ns, bool const & childs=false, std::string const & name="");
                void unlink();
                NodeSet getChilds(std::string const & name="") const;
                std::string getContent(std::string const & nodeSeparator="") const;

                class Dump
                {
                public:
                        Dump();

                        int concat(std::string const & text);

                        int concat(Node const & node,
                                    bool const & format=false, std::string const & encoding=DefaultEncoding_);

                        Dump(Node const & node,
                             bool const & format=false, std::string const & encoding=DefaultEncoding_);

                        int concat(NodeSet const & nodeSet,
                                    bool const & format=false, std::string const & encoding=DefaultEncoding_);

                        Dump(NodeSet const & ns,
                             bool const & format=false, std::string const & encoding=DefaultEncoding_);

                        char const * getC() const;
                        std::string get() const;
                        int getSize() const;
                private:
                        OutputBuffer outbuf_;
                };

                std::string dump(bool const & format=false, std::string const & encoding=DefaultEncoding_) const;
        };

        class Dump
        {
        public:
                Dump(Tree const & tree, bool const & format=false, std::string const & encoding=DefaultEncoding_);
                ~Dump();
                char const * getC() const;
                std::string get() const;
                int getSize() const;
        private:
                xmlChar * buf_;
                int size_;
        };

        std::string dump(bool const & format=false, std::string const & encoding=DefaultEncoding_) const;

        std::string formatDump(std::string const & encoding=DefaultEncoding_) const;

        XPathObject getXPathObject(std::string const & xpath) const;
        NodeSet getNodeSet(std::string const & xpath) const;
        Node getNode(std::string const & xpath, bool const & doThrow=true) const;
        Node getRootNode() const;
        std::string getOrigEncoding() const;

        int getCount(std::string const & xpath) const;
        bool exists(std::string const & xpath, int const times=1) const;
        char const * getContentC(std::string const & xpath) const;
        std::string getContent(std::string const & xpath) const;
        void setContent(std::string const & xpath, std::string const & content);
        void setName(std::string const & xpath, std::string const & name);

        void setAttribute(std::string const & xpath, std::string const & name, std::string const & content);
        std::string getAttribute(std::string const & xpath, std::string const & name) const;
        Node addChild(std::string const & xpath, std::string const & name, std::string const & content="");
        Node addChild(std::string const & xpath, Node const & node);
        void unlink(std::string const & xpath);

        void addTree(std::string const & xpath, Tree const & source, std::string const & sourceXPath="/*");
        void addXML(std::string const & xpath, std::string const & source, std::string const & sourceXPath="/*");
protected:
        using UI::Util::auto_base<xmlDoc>::get;
        using UI::Util::auto_base<xmlDoc>::operator->;

private:
        class XPathContextSwitch
        {
        public:
                XPathContextSwitch(Tree const & tree, NamespaceMap const & namespaces);
                ~XPathContextSwitch();
                XPathContext & get();
        private:
                XPathContext * treeContext_;
                XPathContext * tempContext_;
        };

        bool dontFreeDoc_;
        XPathContext * context_;
};

}}
#endif