pack.hpp

Go to the documentation of this file.

 
#ifndef __JOIN_PACK_HPP__
#define __JOIN_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
        {
            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 (), 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 std::string& key) override
        {
            return setString (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;
            }
 
            return 0;
        }
 
        template <typename ViewType>
        int readNull (ViewType& document)
        {
            document.get ();
            return setNull ();
        }
 
        template <typename ViewType>
        int readFalse (ViewType& document)
        {
            document.get ();
            return setBool (false);
        }
 
        template <typename ViewType>
        int readTrue (ViewType& document)
        {
            document.get ();
            return 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 (readString (document, true) == -1))
                {
                    return -1;
                }
 
                if (JOIN_UNLIKELY (readValue (document) == -1))
                {
                    return -1;
                }
 
                --len;
            }
 
            return stopObject ();
        }
 
        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 (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)
        {
            if (document.getIf (0xd3))
            {
                return setInt64 (unpack <int64_t> (document));
            }
            else if (document.getIf (0xcf))
            {
                return setUint64 (unpack <uint64_t> (document));
            }
            else if (document.getIf (0xcb))
            {
                return setDouble (unpack <double> (document));
            }
            else if (document.getIf (0xd2))
            {
                return setInt (unpack <int32_t> (document));
            }
            else if (document.getIf (0xce))
            {
                return setUint (unpack <uint32_t> (document));
            }
            else if (document.getIf (0xca))
            {
                return setDouble (unpack <float> (document));
            }
            else if (document.getIf (0xd1))
            {
                return setInt (unpack <int16_t> (document));
            }
            else if (document.getIf (0xcd))
            {
                return setUint (unpack <uint16_t> (document));
            }
            else if (document.getIf (0xd0))
            {
                return setInt (unpack <int8_t> (document));
            }
            else if (document.getIf (0xcc))
            {
                return setUint (unpack <uint8_t> (document));
            }
 
            return setInt (document.get ());
        }
 
        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) || (c == 0xd3);
        }
 
        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