Document.h

/*
   Copyright (C) 2015-2023 by Dr. Marc Boris Duerner
  
   This library 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 2.1 of the License, or (at your option) any later version.
   
   As a special exception, you may use this file as part of a free
   software library without restriction. Specifically, if other files
   instantiate templates or use macros or inline functions from this
   file, or you compile this file and link it with other files to
   produce an executable, this file does not by itself cause the
   resulting executable to be covered by the GNU General Public
   License. This exception does not however invalidate any other
   reasons why the executable file might be covered by the GNU Library
   General Public License.
   
   This library 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 this library; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 
   MA 02110-1301 USA
*/

#ifndef PT_JSON_DOCUMENT_H
#define PT_JSON_DOCUMENT_H

#include <Pt/Json/Api.h>
#include <Pt/SerializationInfo.h>
#include <Pt/String.h>
#include <string>
#include <cstddef>

namespace Pt {

namespace Json {

class PT_JSON_API Document
{
    friend class DocumentReader;

    public:
        class Element
        {
            public:
                explicit Element(SerializationInfo* si = 0)
                : _si(si)
                {}

                Element(const Element& elem)
                : _si(elem._si)
                {}

                Element& operator=(const Element& elem)
                {
                    _si = elem._si;
                    return *this;
                }

                const char* name() const
                { return _si->name(); }

                template <typename T>
                bool getValue(T& value) const
                {
                    if( ! _si )
                        return false;

                    *_si >>= value;
                    return true;
                }

                template <typename T>
                void setValue(const T& value)
                {
                    if( _si )
                    {
                        _si->setVoid();
                        *_si <<= value;
                    }
                }

                bool isNull() const
                {
                  return _si ? _si->isVoid() : true;
                }

                void setNull()
                {
                    if( _si )
                    {
                        _si->setVoid();
 
                    }
                }

                Element parent() const
                {
                  if( ! _si )
                    return Element();

                  return Element( _si->parent() );
                }

                Element begin() const
                {
                    if( ! _si )
                        return this->end();

                    SerializationInfo::Iterator it =_si->begin();
                    if( it == _si->end() )
                        return this->end();

                    SerializationInfo& si = *it;
                    return Element(&si);
                }

                Element end() const
                {
                    return Element();
                }

                Element getMember(const std::string& name) const
                {
                    if( ! _si )
                        return this->end();

                    SerializationInfo* si = _si->findMember(name);
                    return Element(si);
                }
                
                Element getMember(const char* name) const
                {
                    if( ! _si )
                        return this->end();

                    SerializationInfo* si = _si->findMember(name);
                    return Element(si);
                }
                
                Element operator[] (const std::string& name) const
                {
                    return this->getMember(name);
                }

                Element operator[] (const char* name) const
                {
                    return this->getMember(name);
                }

                Element addMember(const char* name)
                {
                    if( ! _si )
                        return Element();

                    SerializationInfo* si = _si->findMember(name);
                    if( ! si )
                        si = &_si->addMember(name);
                    
                    return Element(si);
                }

                Element addMember(const std::string& name)
                {
                    if( ! _si )
                        return Element();

                    SerializationInfo* si = _si->findMember(name);
                    if( ! si )
                        si = &_si->addMember(name);
                    
                    return Element(si);
                }

                Element addElement()
                {
                    if( ! _si )
                        return Element();

                    SerializationInfo& si = _si->addElement();
                    return Element(&si);
                }

                void removeMember(const std::string& name)
                {
                    if( _si )
                        _si->removeMember(name);
                }
                
                void removeMember(const char* name)
                {
                    if( _si )
                        _si->removeMember(name);
                }

                void removeElement(const Element& e)
                {
                    if( ! _si || ! e._si )
                      return;

                    _si->removeMember( *e._si );
                }

                Element& operator*()
                { return *this; }

                Element* operator->()
                { return this; }

                Element& operator++()
                {
                    _si = _si->sibling();
                    return *this;
                }

                bool operator!=(const Element& other) const
                { return _si != other._si; }

                bool operator==(const Element& other) const
                { return _si == other._si; }

                bool operator!() const
                { return _si == 0; }

            private:
                SerializationInfo* _si;
        };

        class ConstElement
        {
            public:
                explicit ConstElement(const SerializationInfo* si = 0)
                : _si(si)
                {}

                const char* name() const
                { return _si->name(); }

                template <typename T>
                bool getValue(T& value) const
                {
                    if( ! _si )
                        return false;

                    *_si >>= value;
                    return true;
                }

                bool isNull() const
                {
                  return _si ? _si->isVoid() : true;
                }

                ConstElement begin() const
                {
                    if( ! _si )
                        return this->end();

                    SerializationInfo::ConstIterator it =_si->begin();
                    if(it == _si->end())
                        return this->end();

                    const SerializationInfo& si = *it;
                    return ConstElement(&si);
                }

                ConstElement end() const
                {
                    return ConstElement();
                }

                ConstElement getMember(const std::string& name) const
                {
                    if( ! _si )
                        return end();

                    const SerializationInfo* si = _si->findMember(name);
                    return ConstElement(si);
                }

                ConstElement getMember(const char* name) const
                {
                    if( ! _si )
                        return end();

                    const SerializationInfo* si = _si->findMember(name);
                    return ConstElement(si);
                }

                ConstElement operator[] (const std::string& name) const
                {
                    return this->getMember(name);
                }

                ConstElement operator[] (const char* name) const
                {
                    return this->getMember(name);
                }

                const ConstElement& operator*() const
                { return *this; }

                const ConstElement* operator->() const
                { return this; }

                ConstElement& operator++()
                {
                    _si = _si->sibling();
                    return *this;
                }

                bool operator!=(const ConstElement& other) const
                { return _si != other._si; }

                bool operator==(const ConstElement& other) const
                { return _si == other._si; }

                bool operator!() const
                { return _si == 0; }

            private:
                const SerializationInfo* _si;
        };

    public:
        Document();

        void clear();

        bool isEmpty() const;

        void load( std::basic_istream<Pt::Char>& is );

        void save( std::basic_ostream<Pt::Char>& os ) const;

        Element root()
        { return Element(&_root); }

        ConstElement root() const
        { return ConstElement(&_root); }

        Element begin()
        { return root().begin(); }

        ConstElement begin() const
        { return root().begin(); }

        Element end()
        { return root().end(); }

        ConstElement end() const
        { return root().end(); }

        Element getMember(const std::string& name)
        {
            return root().getMember(name);
        }

        ConstElement getMember(const std::string& name) const
        {
            return root().getMember(name);
        }

        Element getMember(const char* name)
        {
            return root().getMember(name);
        }

        ConstElement getMember(const char* name) const
        {
            return root().getMember(name);
        }

        Element operator[] (const std::string& name)
        {
            return root().getMember(name);
        }

        ConstElement operator[] (const std::string& name) const
        {
            return root().getMember(name);
        }

        Element operator[] (const char* name)
        {
            return root().getMember(name);
        }

        ConstElement operator[] (const char* name) const
        {
            return root().getMember(name);
        }

        Element addMember(const char* name)
        {
            return root().addMember(name);
        }

        Element addMember(const std::string& name)
        {
            return root().addMember(name);
        }

        Element addElement()
        {
            return root().addElement();
        }

        void removeMember(const char* name)
        {
            root().removeMember(name);
        }

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

        void removeElement(const Element& e)
        {
            root().removeElement(e);
        }

    private:
        SerializationInfo _root;
};

} // namespace

} // namespace

#endif