pack.hpp

Go to the documentation of this file.

 
#ifndef JOIN_DATA_PACK_HPP
#define JOIN_DATA_PACK_HPP
 
// libjoin.
#include <join/utils.hpp>
#include <join/sax.hpp>
 
// C++.
#include <stdexcept>
 
namespace join
{
    class PackWriter : public StreamWriter
    {
    public:
        PackWriter (std::ostream& document)
        : StreamWriter (document)
        {
        }
 
        PackWriter (const PackWriter& other) = delete;
 
        PackWriter& operator= (const PackWriter& other) = delete;
 
        PackWriter (PackWriter&& other) = delete;
 
        PackWriter& operator= (PackWriter&& other) = delete;
 
        virtual ~PackWriter () = default;
 
        virtual int setNull () override
        {
            append (0xc0);
            return 0;
        }
 
        virtual int setBool (bool value) override
        {
            if (value)
            {
                append (0xc3);
            }
            else
            {
                append (0xc2);
            }
            return 0;
        }
 
        virtual int setInt (int32_t value) override
        {
            if (value < -(1 << 15))
            {
                append (0xd2);
                pack (static_cast<uint32_t> (value));
            }
            else if (value < -(1 << 7))
            {
                append (0xd1);
                pack (static_cast<uint16_t> (value));
            }
            else if (value < -(1 << 5))
            {
                append (0xd0);
                pack (static_cast<uint8_t> (value));
            }
            else if (value < (1 << 7))
            {
                append (static_cast<uint8_t> (value));
            }
            else if (value < (1 << 8))
            {
                append (0xcc);
                pack (static_cast<uint8_t> (value));
            }
            else if (value < (1 << 16))
            {
                append (0xcd);
                pack (static_cast<uint16_t> (value));
            }
            else
            {
                append (0xce);
                pack (static_cast<uint32_t> (value));
            }
            return 0;
        }
 
        virtual int setUint (uint32_t value) override
        {
            if (value < (1 << 7))
            {
                append (static_cast<uint8_t> (value));
            }
            else if (value < (1 << 8))
            {
                append (0xcc);
                pack (static_cast<uint8_t> (value));
            }
            else if (value < (1 << 16))
            {
                append (0xcd);
                pack (static_cast<uint16_t> (value));
            }
            else
            {
                append (0xce);
                pack (value);
            }
            return 0;
        }
 
        virtual int setInt64 (int64_t value) override
        {
            if (value < -(1LL << 31))
            {
                append (0xd3);
                pack (static_cast<uint64_t> (value));
            }
            else if (value < -(1LL << 15))
            {
                append (0xd2);
                pack (static_cast<uint32_t> (value));
            }
            else if (value < -(1LL << 7))
            {
                append (0xd1);
                pack (static_cast<uint16_t> (value));
            }
            else if (value < -(1LL << 5))
            {
                append (0xd0);
                pack (static_cast<uint8_t> (value));
            }
            else if (value < (1LL << 7))
            {
                append (static_cast<uint8_t> (value));
            }
            else if (value < (1LL << 8))
            {
                append (0xcc);
                pack (static_cast<uint8_t> (value));
            }
            else if (value < (1LL << 16))
            {
                append (0xcd);
                pack (static_cast<uint16_t> (value));
            }
            else if (value < (1LL << 32))
            {
                append (0xce);
                pack (static_cast<uint32_t> (value));
            }
            else
            {
                append (0xcf);
                pack (static_cast<uint64_t> (value));
            }
            return 0;
        }
 
        virtual int setUint64 (uint64_t value) override
        {
            if (value < (1ULL << 7))
            {
                append (static_cast<uint8_t> (value));
            }
            else if (value < (1ULL << 8))
            {
                append (0xcc);
                pack (static_cast<uint8_t> (value));
            }
            else if (value < (1ULL << 16))
            {
                append (0xcd);
                pack (static_cast<uint16_t> (value));
            }
            else if (value < (1ULL << 32))
            {
                append (0xce);
                pack (static_cast<uint32_t> (value));
            }
            else
            {
                append (0xcf);
                pack (value);
            }
            return 0;
        }
 
        virtual int setDouble (double value) override
        {
            float f = static_cast<float> (value);
            if (std::isfinite (value) && static_cast<double> (f) == value)
            {
                append (0xca);
                pack (f);
            }
            else
            {
                append (0xcb);
                pack (value);
            }
            return 0;
        }
 
        virtual int setString (const std::string& value) override
        {
            if (value.size () < 32)
            {
                append (static_cast<char> (0xa0 | value.size ()));
            }
            else if (value.size () < 256)
            {
                append (0xd9);
                pack (static_cast<uint8_t> (value.size ()));
            }
            else if (value.size () < 65536)
            {
                append (0xda);
                pack (static_cast<uint16_t> (value.size ()));
            }
            else
            {
                append (0xdb);
                pack (static_cast<uint32_t> (value.size ()));
            }
            append (value.c_str (), static_cast<uint32_t> (value.size ()));
            return 0;
        }
 
        virtual int startArray (uint32_t size = 0) override
        {
            if (size < 16)
            {
                append (static_cast<char> (0x90 | size));
            }
            else if (size < 65536)
            {
                append (0xdc);
                pack (static_cast<uint16_t> (size));
            }
            else
            {
                append (0xdd);
                pack (size);
            }
            return 0;
        }
 
        virtual int startObject (uint32_t size = 0) override
        {
            if (size < 16)
            {
                append (static_cast<char> (0x80 | size));
            }
            else if (size < 65536)
            {
                append (0xde);
                pack (static_cast<uint16_t> (size));
            }
            else
            {
                append (0xdf);
                pack (size);
            }
            return 0;
        }
 
        virtual int setKey (const Value& key) override
        {
            if (JOIN_UNLIKELY (key.isArray () || key.isObject ()))
            {
                join::lastError = make_error_code (SaxErrc::InvalidKey);
                return -1;
            }
            return setValue (key);
        }
 
    protected:
        template <typename Type>
        void pack (Type value)
        {
            append (reinterpret_cast<const char*> (&swap (value)), sizeof (value));
        }
    };
 
    class PackReader : public StreamReader
    {
    public:
        PackReader (Value& root)
        : StreamReader (root)
        {
        }
 
        PackReader (const PackReader& other) = delete;
 
        PackReader& operator= (const PackReader& other) = delete;
 
        PackReader (PackReader&& other) = delete;
 
        PackReader& operator= (PackReader&& other) = delete;
 
        virtual ~PackReader () = default;
 
        int deserialize (const char* document, size_t length) override
        {
            StringView in (document, length);
            return read (in);
        }
 
        int deserialize (const char* first, const char* last) override
        {
            StringView in (first, last);
            return read (in);
        }
 
        int deserialize (const std::string& document) override
        {
            StringView in (document.c_str (), document.size ());
            return read (in);
        }
 
        int deserialize (std::stringstream& document) override
        {
            StringStreamView in (document);
            return read (in);
        }
 
        int deserialize (std::istringstream& document) override
        {
            StringStreamView in (document);
            return read (in);
        }
 
        int deserialize (std::fstream& document) override
        {
            FileStreamView in (document);
            return read (in);
        }
 
        int deserialize (std::ifstream& document) override
        {
            FileStreamView in (document);
            return read (in);
        }
 
        int deserialize (std::iostream& document) override
        {
            StreamView in (document);
            return read (in);
        }
 
        int deserialize (std::istream& document) override
        {
            StreamView in (document);
            return read (in);
        }
 
    protected:
        template <typename ViewType>
        int read (ViewType& document)
        {
            if (JOIN_LIKELY (readValue (document) == 0))
            {
                if (JOIN_LIKELY (document.peek () == std::char_traits<char>::eof ()))
                {
                    return 0;
                }
 
                join::lastError = make_error_code (SaxErrc::ExtraData);
            }
 
            return -1;
        }
 
        template <typename ViewType>
        int readValue (ViewType& document)
        {
            uint8_t head = static_cast<uint8_t> (document.peek ());
 
            try
            {
                if (isArray (head))
                {
                    return readArray (document);
                }
                else if (isObject (head))
                {
                    return readObject (document);
                }
                else if (isNull (head))
                {
                    return readNull (document);
                }
                else if (isFalse (head))
                {
                    return readFalse (document);
                }
                else if (isTrue (head))
                {
                    return readTrue (document);
                }
                else if (isString (head))
                {
                    return readString (document);
                }
                else if (isBin (head))
                {
                    return readBin (document);
                }
                else if (isNumber (head))
                {
                    return readNumber (document);
                }
                else
                {
                    join::lastError = make_error_code (SaxErrc::InvalidValue);
                    return -1;
                }
            }
            catch (...)
            {
                join::lastError = make_error_code (SaxErrc::InvalidValue);
                return -1;
            }
        }
 
        template <typename ViewType>
        int readNull (ViewType& document, bool isKey = false)
        {
            document.get ();
            return (isKey) ? setKey (Value (in_place_index_t<Value::Null>{}, nullptr)) : setNull ();
        }
 
        template <typename ViewType>
        int readFalse (ViewType& document, bool isKey = false)
        {
            document.get ();
            return (isKey) ? setKey (Value (in_place_index_t<Value::Boolean>{}, false)) : setBool (false);
        }
 
        template <typename ViewType>
        int readTrue (ViewType& document, bool isKey = false)
        {
            document.get ();
            return (isKey) ? setKey (Value (in_place_index_t<Value::Boolean>{}, true)) : setBool (true);
        }
 
        template <typename ViewType>
        int readArray (ViewType& document)
        {
            uint32_t len = 0;
 
            if (document.getIf (0xdd))
            {
                len = unpack<uint32_t> (document);
            }
            else if (document.getIf (0xdc))
            {
                len = unpack<uint16_t> (document);
            }
            else
            {
                len = unpack<uint8_t> (document) & ~0x90;
            }
 
            if (JOIN_UNLIKELY (startArray (len) == -1))
            {
                return -1;
            }
 
            while (len)
            {
                if (JOIN_UNLIKELY (readValue (document) == -1))
                {
                    return -1;
                }
 
                --len;
            }
 
            return stopArray ();
        }
 
        template <typename ViewType>
        int readObject (ViewType& document)
        {
            uint32_t len = 0;
 
            if (document.getIf (0xdf))
            {
                len = unpack<uint32_t> (document);
            }
            else if (document.getIf (0xde))
            {
                len = unpack<uint16_t> (document);
            }
            else
            {
                len = unpack<uint8_t> (document) & ~0x80;
            }
 
            if (JOIN_UNLIKELY (startObject (len) == -1))
            {
                return -1;
            }
 
            while (len)
            {
                if (JOIN_UNLIKELY (readKey (document) == -1))
                {
                    return -1;
                }
 
                if (JOIN_UNLIKELY (readValue (document) == -1))
                {
                    return -1;
                }
 
                --len;
            }
 
            return stopObject ();
        }
 
        template <typename ViewType>
        int readKey (ViewType& document)
        {
            uint8_t head = static_cast<uint8_t> (document.peek ());
 
            try
            {
                if (isNull (head))
                {
                    return readNull (document, true);
                }
                else if (isFalse (head))
                {
                    return readFalse (document, true);
                }
                else if (isTrue (head))
                {
                    return readTrue (document, true);
                }
                else if (isString (head))
                {
                    return readString (document, true);
                }
                else if (isNumber (head))
                {
                    return readNumber (document, true);
                }
                else
                {
                    join::lastError = make_error_code (SaxErrc::InvalidValue);
                    return -1;
                }
            }
            catch (...)
            {
                join::lastError = make_error_code (SaxErrc::InvalidValue);
                return -1;
            }
        }
 
        template <typename ViewType>
        int readString (ViewType& document, bool isKey = false)
        {
            uint32_t len = 0;
 
            if (document.getIf (0xdb))
            {
                len = unpack<uint32_t> (document);
            }
            else if (document.getIf (0xda))
            {
                len = unpack<uint16_t> (document);
            }
            else if (document.getIf (0xd9))
            {
                len = unpack<uint8_t> (document);
            }
            else
            {
                len = unpack<uint8_t> (document) & ~0xa0;
            }
 
            std::string output;
            output.resize (len);
 
            if (JOIN_UNLIKELY (document.read (&output[0], len) != len))
            {
                join::lastError = make_error_code (SaxErrc::InvalidValue);
                return -1;
            }
 
            return isKey ? setKey (Value (in_place_index_t<Value::String>{}, output)) : setString (output);
        }
 
        template <typename ViewType>
        int readBin (ViewType& document)
        {
            uint32_t len = 0;
 
            if (document.getIf (0xc6))
            {
                len = unpack<uint32_t> (document);
            }
            else if (document.getIf (0xc5))
            {
                len = unpack<uint16_t> (document);
            }
            else if (document.getIf (0xc4))
            {
                len = unpack<uint8_t> (document);
            }
 
            std::string output;
            output.resize (len);
 
            if (JOIN_UNLIKELY (document.read (&output[0], len) != len))
            {
                join::lastError = make_error_code (SaxErrc::InvalidValue);
                return -1;
            }
 
            return setString (output);
        }
 
        template <typename ViewType>
        int readNumber (ViewType& document, bool isKey = false)
        {
            uint8_t head = document.get ();
 
            if (head <= 0x7f)
            {
                auto number = uint32_t (head);
                return isKey ? setKey (Value (in_place_index_t<Value::Unsigned>{}, number)) : setUint (number);
            }
            else if (head >= 0xe0)
            {
                auto number = int32_t (static_cast<int8_t> (head));
                return isKey ? setKey (Value (in_place_index_t<Value::Integer>{}, number)) : setInt (number);
            }
            else if (head == 0xd3)
            {
                auto number = unpack<int64_t> (document);
                return isKey ? setKey (Value (in_place_index_t<Value::Integer64>{}, number)) : setInt64 (number);
            }
            else if (head == 0xcf)
            {
                auto number = unpack<uint64_t> (document);
                return isKey ? setKey (Value (in_place_index_t<Value::Unsigned64>{}, number)) : setUint64 (number);
            }
            else if (head == 0xcb)
            {
                auto number = unpack<double> (document);
                return isKey ? setKey (Value (in_place_index_t<Value::Real>{}, number)) : setDouble (number);
            }
            else if (head == 0xd2)
            {
                auto number = unpack<int32_t> (document);
                return isKey ? setKey (Value (in_place_index_t<Value::Integer>{}, number)) : setInt (number);
            }
            else if (head == 0xce)
            {
                auto number = unpack<uint32_t> (document);
                return isKey ? setKey (Value (in_place_index_t<Value::Unsigned>{}, number)) : setUint (number);
            }
            else if (head == 0xca)
            {
                auto number = double (unpack<float> (document));
                return isKey ? setKey (Value (in_place_index_t<Value::Real>{}, number)) : setDouble (number);
            }
            else if (head == 0xd1)
            {
                auto number = int32_t (unpack<int16_t> (document));
                return isKey ? setKey (Value (in_place_index_t<Value::Integer>{}, number)) : setInt (number);
            }
            else if (head == 0xcd)
            {
                auto number = uint32_t (unpack<uint16_t> (document));
                return isKey ? setKey (Value (in_place_index_t<Value::Unsigned>{}, number)) : setUint (number);
            }
            else if (head == 0xd0)
            {
                auto number = int32_t (unpack<int8_t> (document));
                return isKey ? setKey (Value (in_place_index_t<Value::Integer>{}, number)) : setInt (number);
            }
            else if (head == 0xcc)
            {
                auto number = uint32_t (unpack<uint8_t> (document));
                return isKey ? setKey (Value (in_place_index_t<Value::Unsigned>{}, number)) : setUint (number);
            }
            else
            {
                join::lastError = make_error_code (SaxErrc::InvalidValue);
                return -1;
            }
        }
 
        template <typename Type, typename ViewType>
        std::enable_if_t<std::is_arithmetic<Type>::value, Type> static unpack (ViewType& document)
        {
            Type value;
            if (JOIN_UNLIKELY (document.read (reinterpret_cast<char*> (&value), sizeof (value)) != sizeof (value)))
            {
                throw std::range_error ("not enough data to unpack");
            }
            return swap (value);
        }
 
        constexpr bool isNull (uint8_t c)
        {
            return (c == 0xc0);
        }
 
        constexpr bool isFalse (uint8_t c)
        {
            return (c == 0xc2);
        }
 
        constexpr bool isTrue (uint8_t c)
        {
            return (c == 0xc3);
        }
 
        constexpr bool isInt (uint8_t c)
        {
            return ((c <= 0x7f) || (c >= 0xe0)) || (c == 0xd0) || (c == 0xd1) || (c == 0xd2);
        }
 
        constexpr bool isUint (uint8_t c)
        {
            return (c == 0xcc) || (c == 0xcd) || (c == 0xce);
        }
 
        constexpr bool isInt64 (uint8_t c)
        {
            return (c == 0xd3);
        }
 
        constexpr bool isUint64 (uint8_t c)
        {
            return (c == 0xcf);
        }
 
        constexpr bool isReal (uint8_t c)
        {
            return (c == 0xca) || (c == 0xcb);
        }
 
        constexpr bool isNumber (uint8_t c)
        {
            return isInt (c) || isUint (c) || isInt64 (c) || isUint64 (c) || isReal (c);
        }
 
        constexpr bool isString (uint8_t c)
        {
            return ((c >= 0xa0) && (c <= 0xbf)) || (c == 0xd9) || (c == 0xda) || (c == 0xdb);
        }
 
        constexpr bool isBin (uint8_t c)
        {
            return (c == 0xc4) || (c == 0xc5) || (c == 0xc6);
        }
 
        constexpr bool isArray (uint8_t c)
        {
            return ((c >= 0x90) && (c <= 0x9f)) || (c == 0xdc) || (c == 0xdd);
        }
 
        constexpr bool isObject (uint8_t c)
        {
            return ((c >= 0x80) && (c <= 0x8f)) || (c == 0xde) || (c == 0xdf);
        }
    };
}
 
#endif