sax.hpp

Go to the documentation of this file.

 
#ifndef JOIN_DATA_SAX_HPP
#define JOIN_DATA_SAX_HPP
 
// libjoin.
#include <join/error.hpp>
#include <join/value.hpp>
#include <join/utils.hpp>
#include <join/view.hpp>
 
// C++.
#include <system_error>
#include <iostream>
#include <fstream>
#include <sstream>
#include <memory>
#include <string>
#include <stack>
 
// C.
#include <cstddef>
 
namespace join
{
    class Value;
 
    enum class SaxErrc
    {
        StackOverflow = 1, 
        InvalidParent,     
        InvalidKey,        
        InvalidValue,      
        ExtraData          
    };
 
    class SaxCategory : public std::error_category
    {
    public:
        virtual const char* name () const noexcept;
 
        virtual std::string message (int code) const;
    };
 
    const std::error_category& saxCategory () noexcept;
 
    std::error_code make_error_code (SaxErrc code) noexcept;
 
    std::error_condition make_error_condition (SaxErrc code) noexcept;
 
    class SaxHandler
    {
    public:
        SaxHandler () = default;
 
        SaxHandler (const SaxHandler& other) = default;
 
        SaxHandler& operator= (const SaxHandler& other) = default;
 
        SaxHandler (SaxHandler&& other) = default;
 
        SaxHandler& operator= (SaxHandler&& other) = default;
 
        virtual ~SaxHandler () = default;
 
        virtual int setNull () = 0;
 
        virtual int setBool (bool value) = 0;
 
        virtual int setInt (int32_t value) = 0;
 
        virtual int setUint (uint32_t value) = 0;
 
        virtual int setInt64 (int64_t value) = 0;
 
        virtual int setUint64 (uint64_t value) = 0;
 
        virtual int setDouble (double value) = 0;
 
        virtual int setString (const std::string& value) = 0;
 
        virtual int startArray (uint32_t size = 0) = 0;
 
        virtual int stopArray ()
        {
            return 0;
        }
 
        virtual int startObject (uint32_t size = 0) = 0;
 
        virtual int setKey (const Value& key) = 0;
 
        virtual int stopObject ()
        {
            return 0;
        }
    };
 
    class StreamWriter : public SaxHandler
    {
    public:
        StreamWriter (std::ostream& document)
        : SaxHandler ()
        , _out (document.rdbuf ())
        {
        }
 
        StreamWriter (const StreamWriter& other) = delete;
 
        StreamWriter& operator= (const StreamWriter& other) = delete;
 
        StreamWriter (StreamWriter&& other) = delete;
 
        StreamWriter& operator= (StreamWriter&& other) = delete;
 
        virtual ~StreamWriter () = default;
 
        virtual int serialize (const Value& value)
        {
            return setValue (value);
        }
 
    protected:
        int setValue (const Value& value)
        {
            switch (value.index ())
            {
                case Value::Boolean:
                    return setBool (value.get<Value::Boolean> ());
 
                case Value::Integer:
                    return setInt (value.get<Value::Integer> ());
 
                case Value::Unsigned:
                    return setUint (value.get<Value::Unsigned> ());
 
                case Value::Integer64:
                    return setInt64 (value.get<Value::Integer64> ());
 
                case Value::Unsigned64:
                    return setUint64 (value.get<Value::Unsigned64> ());
 
                case Value::Real:
                    return setDouble (value.get<Value::Real> ());
 
                case Value::String:
                    return setString (value.get<Value::String> ());
 
                case Value::ArrayValue:
                    return setArray (value.get<Value::ArrayValue> ());
 
                case Value::ObjectValue:
                    return setObject (value.get<Value::ObjectValue> ());
 
                default:
                    return setNull ();
            }
        }
 
        virtual int setArray (const Array& array)
        {
            if (startArray (array.size ()) == -1)
            {
                return -1;
            }
 
            for (auto const& element : array)
            {
                if (setValue (element) == -1)
                {
                    return -1;
                }
            }
 
            return stopArray ();
        }
 
        virtual int setObject (const Object& object)
        {
            if (startObject (object.size ()) == -1)
            {
                return -1;
            }
 
            for (auto const& member : object)
            {
                if (setKey (member.first) == -1)
                {
                    return -1;
                }
 
                if (setValue (member.second) == -1)
                {
                    return -1;
                }
            }
 
            return stopObject ();
        }
 
        inline void append (char data) noexcept
        {
            _out->sputc (data);
        }
 
        inline void append2 (const char* data) noexcept
        {
            _out->sputc (data[0]);
            _out->sputc (data[1]);
        }
 
        inline void append3 (const char* data) noexcept
        {
            _out->sputc (data[0]);
            _out->sputc (data[1]);
            _out->sputc (data[2]);
        }
 
        inline void append4 (const char* data) noexcept
        {
            _out->sputc (data[0]);
            _out->sputc (data[1]);
            _out->sputc (data[2]);
            _out->sputc (data[3]);
        }
 
        inline void append5 (const char* data) noexcept
        {
            _out->sputc (data[0]);
            _out->sputc (data[1]);
            _out->sputc (data[2]);
            _out->sputc (data[3]);
            _out->sputc (data[4]);
        }
 
        inline void append (const char* data, uint32_t size) noexcept
        {
            _out->sputn (data, size);
        }
 
    protected:
        std::streambuf* _out;
    };
 
    class StreamReader : protected SaxHandler
    {
    public:
        StreamReader (Value& root)
        : SaxHandler ()
        , _root (root)
        {
        }
 
        StreamReader (const StreamReader& other) = delete;
 
        StreamReader& operator= (const StreamReader& other) = delete;
 
        StreamReader (StreamReader&& other) = delete;
 
        StreamReader& operator= (StreamReader&& other) = delete;
 
        virtual ~StreamReader () = default;
 
        virtual int deserialize (const char* document, size_t length) = 0;
 
        virtual int deserialize (const char* first, const char* last) = 0;
 
        virtual int deserialize (const std::string& document) = 0;
 
        virtual int deserialize (std::stringstream& document) = 0;
 
        virtual int deserialize (std::istringstream& document) = 0;
 
        virtual int deserialize (std::fstream& document) = 0;
 
        virtual int deserialize (std::ifstream& document) = 0;
 
        virtual int deserialize (std::iostream& document) = 0;
 
        virtual int deserialize (std::istream& document) = 0;
 
    protected:
        virtual int setNull () override
        {
            return setValue (Value (in_place_index_t<Value::Null>{}, nullptr));
        }
 
        virtual int setBool (bool value) override
        {
            return setValue (Value (in_place_index_t<Value::Boolean>{}, value));
        }
 
        virtual int setInt (int32_t value) override
        {
            return setValue (Value (in_place_index_t<Value::Integer>{}, value));
        }
 
        virtual int setUint (uint32_t value) override
        {
            return setValue (Value (in_place_index_t<Value::Unsigned>{}, value));
        }
 
        virtual int setInt64 (int64_t value) override
        {
            return setValue (Value (in_place_index_t<Value::Integer64>{}, value));
        }
 
        virtual int setUint64 (uint64_t value) override
        {
            return setValue (Value (in_place_index_t<Value::Unsigned64>{}, value));
        }
 
        virtual int setDouble (double value) override
        {
            return setValue (Value (in_place_index_t<Value::Real>{}, value));
        }
 
        virtual int setString (const std::string& value) override
        {
            return setValue (Value (in_place_index_t<Value::String>{}, value));
        }
 
        virtual int startArray (uint32_t size = 0) override
        {
            Array array;
            array.reserve (size ? size : 8);
 
            if (JOIN_UNLIKELY (_stack.empty ()))
            {
                _root = std::move (array);
                _stack.push (&_root);
                return 0;
            }
 
            if (JOIN_UNLIKELY (_stack.size () >= _maxdepth))
            {
                join::lastError = make_error_code (SaxErrc::StackOverflow);
                return -1;
            }
 
            Value::Ptr parent = _stack.top ();
 
            if (parent->index () == Value::ObjectValue)
            {
                _stack.push (&parent->insert ({std::move (_curkey), std::move (array)}));
            }
            else
            {
                _stack.push (&parent->pushBack (std::move (array)));
            }
 
            return 0;
        }
 
        virtual int stopArray () override
        {
            if (JOIN_LIKELY (_stack.size ()))
            {
                _stack.pop ();
            }
 
            return 0;
        }
 
        virtual int startObject (uint32_t size = 0) override
        {
            Object object;
            object.reserve (size ? size : 8);
 
            if (JOIN_UNLIKELY (_stack.empty ()))
            {
                _root = std::move (object);
                _stack.push (&_root);
                return 0;
            }
 
            if (JOIN_UNLIKELY (_stack.size () >= _maxdepth))
            {
                join::lastError = make_error_code (SaxErrc::StackOverflow);
                return -1;
            }
 
            Value::Ptr parent = _stack.top ();
 
            if (parent->index () == Value::ObjectValue)
            {
                _stack.push (&parent->insert ({std::move (_curkey), std::move (object)}));
            }
            else
            {
                _stack.push (&parent->pushBack (std::move (object)));
            }
 
            return 0;
        }
 
        virtual int setKey (const Value& key) override
        {
            _curkey = key;
            return 0;
        }
 
        virtual int stopObject () override
        {
            if (JOIN_LIKELY (_stack.size ()))
            {
                _stack.pop ();
            }
 
            return 0;
        }
 
        virtual int setValue (Value&& value)
        {
            if (JOIN_UNLIKELY (_stack.empty ()))
            {
                join::lastError = make_error_code (SaxErrc::InvalidParent);
                return -1;
            }
 
            Value::Ptr parent = _stack.top ();
 
            if (parent->index () == Value::ObjectValue)
            {
                parent->insert ({std::move (_curkey), std::move (value)});
            }
            else
            {
                parent->pushBack (std::move (value));
            }
 
            return 0;
        }
 
        static constexpr size_t _maxdepth = 19;
 
        std::stack<Value*> _stack;
 
        Value _curkey;
 
        Value& _root;
    };
}
 
namespace std
{
    template <>
    struct is_error_condition_enum<join::SaxErrc> : public true_type
    {
    };
}
 
#endif