CRNXml.h

Go to the documentation of this file.

/* Copyright 2012-2014 CoReNum
 * 
 * This file is part of libcrn.
 * 
 * libcrn is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * libcrn 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 Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with libcrn.  If not, see <http://www.gnu.org/licenses/>.
 * 
 * file: CRNXml.h
 * \author Yann LEYDIER
 */

#ifndef CRNXml_HEADER
#define CRNXml_HEADER

#include <CRNIO/CRNPath.h>
#include <CRNUtils/CRNCharsetConverter.h>

namespace tinyxml2
{
    class XMLDocument;
    class XMLNode;
    class XMLComment;
    class XMLElement;
    class XMLText;
    class XMLAttribute;
}
namespace crn
{
    namespace xml
    {
        class Element;
        class Comment;
        class Text;
        class Node
        {
            public:
                virtual ~Node() {}
                Node(const Node&) = default;
                Node(Node&&) = default;
                Node& operator=(const Node&) = default;
                Node& operator=(Node&&) = default;

                bool IsElement();
                bool IsComment();
                bool IsText();

                Element AsElement();
                Comment AsComment();
                Text AsText();

                operator bool() const noexcept { return node != nullptr; }
                bool operator!() const noexcept { return node == nullptr; }
                bool operator==(const Node &other) const noexcept { return node == other.node; }
                bool operator!=(const Node &other) const noexcept { return !(*this == other); }

                virtual StringUTF8 GetValue() const;
                void SetValue(const StringUTF8 &s);

                Node GetParent();

                Node GetPreviousSibling();
                Node GetNextSibling();
                Node& operator++();
                Node operator++(int);

                Element GetNextSiblingElement(const StringUTF8 &name = "");
                Element GetPreviousSiblingElement(const StringUTF8 &name = "");

            protected:
                Node(tinyxml2::XMLNode *n, const SCharsetConverter &c);
                SCharsetConverter conv;

            private:
                tinyxml2::XMLNode *node;

            friend class Document;
            friend class Element;
        };

        class Element: public Node
        {
            public:
                virtual ~Element() override {}
                Element(const Element&) = default;
                Element(Element&&) = default;
                Element& operator=(const Element&) = default;
                Element& operator=(Element&&) = default;

                StringUTF8 GetName() const { return GetValue(); }
                void SetName(const StringUTF8 &s) { SetValue(s); }

                Element& operator++();
                Element operator++(int);

                // Children
                size_t GetNbSubnodes() const { return nb_subnodes; }
                size_t GetNbSubelements() const { return nb_subelems; }
                Node GetFirstChild();
                Node GetLastChild();
                Node BeginNode() { return GetFirstChild(); }
                Node EndNode() { return Node(nullptr, conv); }

                Element GetFirstChildElement(const StringUTF8 &name = "");
                Element GetLastChildElement(const StringUTF8 &name = "");
                Element BeginElement() { return GetFirstChildElement(); }
                Element EndElement() { return Element(nullptr, conv); }

                StringUTF8 GetFirstChildText();

                Element PushBackElement(const StringUTF8 &name);
                Element PushFrontElement(const StringUTF8 &name);
                Element InsertElement(Node &n, const StringUTF8 &name);

                Comment PushBackComment(const StringUTF8 &text);
                Comment PushFrontComment(const StringUTF8 &text);
                Comment InsertComment(Node &n, const StringUTF8 &text);

                Text PushBackText(const StringUTF8 &text, bool cdata = false);
                Text PushFrontText(const StringUTF8 &text, bool cdata = false);
                Text InsertText(Node &n, const StringUTF8 &text, bool cdata = false);

                Node PushBackClone(Node &n, bool recursive = false);

                void Clear();
                void RemoveChild(Node &n);

                // Attributes
                template<typename T> T GetAttribute(const StringUTF8 &name, bool silent = true) const
                {
                    T attr;
                    if (silent)
                    {
                        try { queryAttribute(name, attr); }
                        catch (...) { return T(0); }
                    }
                    else
                        queryAttribute(name, attr);
                    return attr;
                }
                void SetAttribute(const StringUTF8 &name, const StringUTF8 &value);
                void RemoveAttribute(const StringUTF8 &name);

                class Attribute
                {
                    public:
                        Attribute(const Attribute&) = default;
                        Attribute(Attribute&&) = default;
                        Attribute& operator=(const Attribute&) = default;
                        Attribute& operator=(Attribute&&) = default;
                        ~Attribute() {}

                        Attribute& operator++();
                        Attribute operator++(int);
                        Attribute Next();

                        bool operator==(const Attribute &other) const noexcept { return attr == other.attr; }
                        bool operator!=(const Attribute &other) const noexcept { return !(*this == other); }

                        StringUTF8 GetName() const;
                        template<typename T> T GetValue(bool silent = true) const
                        {
                            T val;
                            if (silent)
                            {
                                try { queryValue(val); }
                                catch (...) { return T(0); }
                            }
                            else
                                queryValue(val);
                            return val;
                        }
                        void SetValue(const StringUTF8 &value);

                    private:
                        Attribute(tinyxml2::XMLAttribute *a, const SCharsetConverter &c);

                        void queryValue(StringUTF8 &value) const;
                        void queryValue(int &value) const;
                        void queryValue(unsigned int &value) const;
                        void queryValue(bool &value) const;
                        void queryValue(double &value) const;
                        void queryValue(float &value) const;

                        tinyxml2::XMLAttribute *attr;
                        SCharsetConverter conv;

                    friend class Element;
                };
                Attribute BeginAttribute();
                Attribute EndAttribute();

            protected:
                Element(tinyxml2::XMLElement *el, const SCharsetConverter &c);

            private:
                void queryAttribute(const StringUTF8 &name, StringUTF8 &value) const;
                void queryAttribute(const StringUTF8 &name, int &value) const;
                void queryAttribute(const StringUTF8 &name, unsigned int &value) const;
                void queryAttribute(const StringUTF8 &name, bool &value) const;
                void queryAttribute(const StringUTF8 &name, double &value) const;
                void queryAttribute(const StringUTF8 &name, float &value) const;
                void count_subnondes();

                tinyxml2::XMLElement *element;
                size_t nb_subnodes, nb_subelems;

            friend class Node;
            friend class Document;
        };
        template<> inline StringUTF8 Element::GetAttribute<StringUTF8>(const StringUTF8 &name, bool silent) const
        {
            StringUTF8 attr;
            if (silent)
            {
                try { queryAttribute(name, attr); }
                catch (...) { return StringUTF8(); }
            }
            else
                queryAttribute(name, attr);
            return attr;
        }

        class Comment: public Node
        {
            public:
                Comment(const Comment&) = default;
                Comment(Comment&&) = default;
                Comment& operator=(const Comment&) = default;
                Comment& operator=(Comment&&) = default;
                virtual ~Comment() override {}

            protected:
                Comment(tinyxml2::XMLComment *c, const SCharsetConverter &co);

            private:
                tinyxml2::XMLComment *comment;

            friend class Element;
            friend class Node;
            friend class Document;
        };

        class Text: public Node
        {
            public:
                Text(const Text&) = default;
                Text(Text&&) = default;
                Text& operator=(const Text&) = default;
                Text& operator=(Text&&) = default;
                virtual ~Text() override {}

                bool IsCData() const;
                
                virtual StringUTF8 GetValue() const override;
            protected:
                Text(tinyxml2::XMLText *t, const SCharsetConverter &c);

            private:
                tinyxml2::XMLText *text;

            friend class Element;
            friend class Node;
            friend class Document;
        };

        class Document
        {
            public:
                Document(const StringUTF8 &encoding = "UTF-8", const StringUTF8 &version = "1.0", bool char_conversion_throws = true);
                Document(const Path &fname, bool char_conversion_throws = true);
                Document(const char *content, bool char_conversion_throws = true);
                Document(const Document&) = delete;
                Document(Document&&);
                Document& operator=(const Document&) = delete;
                Document& operator=(Document&&);
                virtual ~Document();

                operator bool() const noexcept { return doc != nullptr; }
                bool operator!() const noexcept { return doc == nullptr; }

                void Save(const Path &fname);
                void Save();
                const Path& GetFilename() const noexcept { return filename; }

                const StringUTF8& GetEncoding() const noexcept { return enc; }
                const StringUTF8& GetVersion() const noexcept { return ver; }

                Element GetRoot();

                Node GetFirstNode();
                Node GetLastNode();
                Node BeginNode() { return GetFirstNode(); }
                Node EndNode() { return Node(nullptr, conv); }

                Element GetFirstElement(const StringUTF8 &name = "");
                Element GetLastElement(const StringUTF8 &name = "");
                Element BeginElement() { return GetFirstElement(); }
                Element EndElement() { return Element(nullptr, conv); }

                Element PushBackElement(const StringUTF8 &name);
                Element InsertElement(Node &n, const StringUTF8 &name);

                Comment PushBackComment(const StringUTF8 &text);
                Comment InsertComment(Node &n, const StringUTF8 &text);

                Node PushBackClone(Node &n, bool recursive = false);

                StringUTF8 AsString();

            private:
                std::unique_ptr<tinyxml2::XMLDocument> doc;
                StringUTF8 enc, ver;
                SCharsetConverter conv;
                Path filename;
        };

    }
}


#endif