value_builder.hpp

Go to the documentation of this file.

 
#ifndef JOIN_DATA_VALUE_BUILDER_HPP
#define JOIN_DATA_VALUE_BUILDER_HPP
 
// libjoin.
#include <join/value.hpp>
#include <join/utils.hpp>
#include <join/sax.hpp>
 
// C++.
#include <string_view>
#include <iterator>
#include <utility>
#include <string>
#include <vector>
 
// C.
#include <cstddef>
 
namespace join
{
    class ValueBuilder
    {
    public:
        explicit ValueBuilder (Value& root)
        : _stack (std::move (cache ()))
        , _root (root)
        {
        }
 
        ValueBuilder (const ValueBuilder& other) = delete;
 
        ValueBuilder& operator= (const ValueBuilder& other) = delete;
 
        ValueBuilder (ValueBuilder&& other) = delete;
 
        ValueBuilder& operator= (ValueBuilder&& other) = delete;
 
        ~ValueBuilder ()
        {
            _stack.clear ();
            cache () = std::move (_stack);
        }
 
        int setNull ()
        {
            return emplaceValue (nullptr);
        }
 
        int setBool (bool value)
        {
            return emplaceValue (value);
        }
 
        int setInt (int32_t value)
        {
            return emplaceValue (value);
        }
 
        int setUint (uint32_t value)
        {
            return emplaceValue (value);
        }
 
        int setInt64 (int64_t value)
        {
            return emplaceValue (value);
        }
 
        int setUint64 (uint64_t value)
        {
            return emplaceValue (value);
        }
 
        int setDouble (double value)
        {
            return emplaceValue (value);
        }
 
        int setString (std::string_view value)
        {
            return emplaceValue (std::string (value));
        }
 
        int startArray ([[maybe_unused]] uint32_t size = 0)
        {
            if (JOIN_UNLIKELY (_depth == 0))
            {
                _stack.clear ();
            }
            else if (JOIN_UNLIKELY (_depth >= saxMaxDepth))
            {
                join::lastError = make_error_code (SaxErrc::StackOverflow);
                return -1;
            }
 
            _starts[_depth++] = _stack.size ();
 
            return 0;
        }
 
        int stopArray ()
        {
            if (JOIN_UNLIKELY (_depth == 0))
            {
                join::lastError = make_error_code (SaxErrc::InvalidParent);
                return -1;
            }
 
            auto first = _stack.begin () + _starts[--_depth];
            Array array (std::make_move_iterator (first), std::make_move_iterator (_stack.end ()));
            _stack.erase (first, _stack.end ());
 
            if (_depth == 0)
            {
                _root = std::move (array);
                return 0;
            }
 
            _stack.emplace_back (std::move (array));
 
            return 0;
        }
 
        int startObject ([[maybe_unused]] uint32_t size = 0)
        {
            if (JOIN_UNLIKELY (_depth == 0))
            {
                _stack.clear ();
            }
            else if (JOIN_UNLIKELY (_depth >= saxMaxDepth))
            {
                join::lastError = make_error_code (SaxErrc::StackOverflow);
                return -1;
            }
 
            _starts[_depth++] = _stack.size ();
 
            return 0;
        }
 
        const Object& members (const Object& object) const noexcept
        {
            return object;
        }
 
        int setKey (std::nullptr_t key)
        {
            if (JOIN_UNLIKELY (_depth == 0))
            {
                join::lastError = make_error_code (SaxErrc::InvalidParent);
                return -1;
            }
 
            _stack.emplace_back (key);
 
            return 0;
        }
 
        int setKey (bool key)
        {
            if (JOIN_UNLIKELY (_depth == 0))
            {
                join::lastError = make_error_code (SaxErrc::InvalidParent);
                return -1;
            }
 
            _stack.emplace_back (key);
 
            return 0;
        }
 
        int setKey (int32_t key)
        {
            if (JOIN_UNLIKELY (_depth == 0))
            {
                join::lastError = make_error_code (SaxErrc::InvalidParent);
                return -1;
            }
 
            _stack.emplace_back (key);
 
            return 0;
        }
 
        int setKey (uint32_t key)
        {
            if (JOIN_UNLIKELY (_depth == 0))
            {
                join::lastError = make_error_code (SaxErrc::InvalidParent);
                return -1;
            }
 
            _stack.emplace_back (key);
 
            return 0;
        }
 
        int setKey (int64_t key)
        {
            if (JOIN_UNLIKELY (_depth == 0))
            {
                join::lastError = make_error_code (SaxErrc::InvalidParent);
                return -1;
            }
 
            _stack.emplace_back (key);
 
            return 0;
        }
 
        int setKey (uint64_t key)
        {
            if (JOIN_UNLIKELY (_depth == 0))
            {
                join::lastError = make_error_code (SaxErrc::InvalidParent);
                return -1;
            }
 
            _stack.emplace_back (key);
 
            return 0;
        }
 
        int setKey (double key)
        {
            if (JOIN_UNLIKELY (_depth == 0))
            {
                join::lastError = make_error_code (SaxErrc::InvalidParent);
                return -1;
            }
 
            _stack.emplace_back (key);
 
            return 0;
        }
 
        int setKey (std::string_view key)
        {
            if (JOIN_UNLIKELY (_depth == 0))
            {
                join::lastError = make_error_code (SaxErrc::InvalidParent);
                return -1;
            }
 
            _stack.emplace_back (key);
 
            return 0;
        }
 
        int setKey (const char* key)
        {
            return setKey (std::string_view (key));
        }
 
        int stopObject ()
        {
            if (JOIN_UNLIKELY (_depth == 0))
            {
                join::lastError = make_error_code (SaxErrc::InvalidParent);
                return -1;
            }
 
            if (JOIN_UNLIKELY ((_stack.size () - _starts[_depth - 1]) & 1))
            {
                join::lastError = make_error_code (SaxErrc::InvalidKey);
                return -1;
            }
 
            auto first = _stack.begin () + _starts[--_depth];
            Object object;
            object.reserve ((_stack.end () - first) / 2);
            for (auto it = first; it != _stack.end (); it += 2)
            {
                object.emplace_back (std::move (it[0]), std::move (it[1]));
            }
            _stack.erase (first, _stack.end ());
 
            if (_depth == 0)
            {
                _root = std::move (object);
                return 0;
            }
 
            _stack.emplace_back (std::move (object));
 
            return 0;
        }
 
        void reset () noexcept
        {
            _depth = 0;
            _stack.clear ();
        }
 
    private:
        template <typename T>
        int emplaceValue (T&& value)
        {
            if (JOIN_UNLIKELY (_depth == 0))
            {
                _root = Value (std::forward<T> (value));
                return 0;
            }
 
            _stack.emplace_back (std::forward<T> (value));
 
            return 0;
        }
 
        static std::vector<Value>& cache () noexcept
        {
            thread_local std::vector<Value> stack;
            return stack;
        }
 
        size_t _starts[saxMaxDepth] = {};
 
        size_t _depth = 0;
 
        std::vector<Value> _stack;
 
        Value& _root;
    };
}
 
#endif