Zakero_MessagePack.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2021 Andrew Moore
 * 
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/.
 */
 
#ifndef zakero_MessagePack_h
#define zakero_MessagePack_h
 
/******************************************************************************
 * Includes
 */
 
// C++
#include <cstring>
#include <string>
#include <limits>
#include <vector>
 
// POSIX
#include <arpa/inet.h>
 
// Linux
 
 
/******************************************************************************
 * Macros
 */
 
// {{{ Macros
 
#define ZAKERO_DISABLE_IMPLICIT_CASTS(func_name_) \
        template <typename... T>                  \
        void func_name_(T...) = delete
 
#define ZAKERO_MESSAGEPACK__ERROR_DATA \
        X(Error_None    ,  0 , "No Error"                                                        ) \
        X(Error_Unknown ,  1 , "An unknown error has occurred"                                   ) \
 
// }}}
 
 
namespace zakero
{
        // {{{ Declaration
 
        class MessagePack
        {
                public:
                        // Rename to Type
                        enum class DataType
                        {       Null
                        ,       Bool
                        ,       Int64
                        ,       Uint64
                        ,       Float
                        ,       Double
                        ,       String
                        ,       Vector
                        };
 
                        struct Object
                        {
                                DataType type;
                                union
                                {
                                        bool     bool_;
                                        int64_t  int64_;
                                        uint64_t uint64_;
                                        float    float_;
                                        double   double_;
                                };
                                std::string          string = {};
                                std::vector<uint8_t> vector = {};
 
                                Object() noexcept;
                                Object(const Object&) noexcept;
                                Object(Object&&) noexcept;
                                Object(const bool) noexcept;
                                Object(const int64_t) noexcept;
                                Object(const uint64_t) noexcept;
                                Object(const float) noexcept;
                                Object(const double) noexcept;
                                Object(const std::string_view) noexcept;
                                Object(std::vector<uint8_t>) noexcept;
                        };
 
                        MessagePack() = default;
 
                        void                               append(const bool, size_t* const = nullptr) noexcept;
                        void                               append(const int64_t, size_t* const = nullptr) noexcept;
                        void                               append(const uint64_t, size_t* const = nullptr) noexcept;
                        void                               append(const float, size_t* = nullptr) noexcept;
                        void                               append(const double, size_t* = nullptr) noexcept;
                        void                               append(const std::string_view, size_t* = nullptr) noexcept;
                        void                               append(const std::vector<uint8_t>&, size_t* = nullptr) noexcept;
                        void                               append(uint8_t*, size_t, size_t* = nullptr);
                        //void                               appendArray(size_t* = nullptr);
                        //void                               appendExtension(int8_t, std::vector<uint8_t>&, size_t* = nullptr);
                        //void                               appendExtension(int8_t, uint8_t*, size_t, size_t* = nullptr);
                        //void                               appendMap(size_t* = nullptr);
                        void                               appendNull(size_t* const = nullptr) noexcept;
                        //void                               appendTimeStamp(uint64_t);
 
                        [[nodiscard]] Object&              object(const size_t index) noexcept;
 
                        void                               clear() noexcept;
                        [[nodiscard]] size_t               size() noexcept;
 
                        void                               deserialize(const std::vector<uint8_t>&) noexcept;
 
                        [[nodiscard]] std::vector<uint8_t> serialize() noexcept;
 
                private:
                        using VectorObject = std::vector<Object>;
 
                        VectorObject object_vector = {};
        }; // class MessagePack
 
        // }}}
}
 
// {{{ Implementation
 
#ifdef ZAKERO_MESSAGEPACK_IMPLEMENTATION
 
// {{{ Macros
// {{{ Macros : Doxygen
 
#ifdef ZAKERO__DOXYGEN_DEFINE_DOCS
 
// Only used for generating Doxygen documentation
 
#define ZAKERO_MESSAGEPACK_IMPLEMENTATION
 
#endif
 
// }}}
 
#define ZAKERO_MESSAGEPACK__FORMAT_DATA \
        /* Type Name      Type Id  Type Id Mask  Type Spec Name   */ \
        X(Fixed_Int_Pos , 0x00   , 0b10000000  , "positive fixint" ) \
        X(fixmap        , 0x80   , 0b00000000  , "fixmap"          ) \
        X(fixarray      , 0x90   , 0b00000000  , "fixarray"        ) \
        X(Fixed_Str     , 0xa0   , 0b11100000  , "fixstr"          ) \
        X(Nill          , 0xc0   , 0b00000000  , "nill"            ) \
        X(never_used    , 0xc1   , 0b00000000  , "(never used)"    ) \
        X(False         , 0xc2   , 0b00000000  , "false"           ) \
        X(True          , 0xc3   , 0b00000000  , "true"            ) \
        X(Bin8          , 0xc4   , 0b11111111  , "bin 8"           ) \
        X(Bin16         , 0xc5   , 0b11111111  , "bin 16"          ) \
        X(Bin32         , 0xc6   , 0b11111111  , "bin 32"          ) \
        X(ext8          , 0xc7   , 0b00000000  , "ext 8"           ) \
        X(ext16         , 0xc8   , 0b00000000  , "ext 16"          ) \
        X(ext32         , 0xc9   , 0b00000000  , "ext 32"          ) \
        X(Float32       , 0xca   , 0b11111111  , "float 32"        ) \
        X(Float64       , 0xcb   , 0b11111111  , "float 64"        ) \
        X(Uint8         , 0xcc   , 0b11111111  , "uint 8"          ) \
        X(Uint16        , 0xcd   , 0b11111111  , "uint 16"         ) \
        X(Uint32        , 0xce   , 0b11111111  , "uint 32"         ) \
        X(Uint64        , 0xcf   , 0b11111111  , "uint 64"         ) \
        X(Int8          , 0xd0   , 0b11111111  , "int 8"           ) \
        X(Int16         , 0xd1   , 0b11111111  , "int 16"          ) \
        X(Int32         , 0xd2   , 0b11111111  , "int 32"          ) \
        X(Int64         , 0xd3   , 0b11111111  , "int 64"          ) \
        X(fixext1       , 0xd4   , 0b00000000  , "fixext 1"        ) \
        X(fixext2       , 0xd5   , 0b00000000  , "fixext 2"        ) \
        X(fixext4       , 0xd6   , 0b00000000  , "fixext 4"        ) \
        X(fixext8       , 0xd7   , 0b00000000  , "fixext 8"        ) \
        X(fixext16      , 0xd8   , 0b00000000  , "fixext 16"       ) \
        X(Str8          , 0xd9   , 0b00000000  , "str 8"           ) \
        X(Str16         , 0xda   , 0b00000000  , "str 16"          ) \
        X(Str32         , 0xdb   , 0b00000000  , "str 32"          ) \
        X(array16       , 0xdc   , 0b00000000  , "array 16"        ) \
        X(array32       , 0xdd   , 0b00000000  , "array 32"        ) \
        X(map16         , 0xde   , 0b00000000  , "map 16"          ) \
        X(map32         , 0xdf   , 0b00000000  , "map 32"          ) \
        X(Fixed_Int_Neg , 0xe0   , 0b11100000  , "negative fixint" ) \
 
// }}}
// {{{ Documentation
 
// }}}
 
namespace zakero
{
// {{{ Anonymous Namespace
 
namespace
{
        enum class Type : uint8_t
        {
#define X(type_, id_, mask_, text_) \
                type_ = id_, \
 
                ZAKERO_MESSAGEPACK__FORMAT_DATA
#undef X
        };
 
#define X(type_, id_, mask_, text_) \
        constexpr uint8_t type_ ## _Mask  = mask_;  \
 
        ZAKERO_MESSAGEPACK__FORMAT_DATA
#undef X
#define X(type_, id_, mask_, text_) \
        constexpr uint8_t type_ ## _Value = (uint8_t)~mask_;\
 
        ZAKERO_MESSAGEPACK__FORMAT_DATA
#undef X
        union
        {
                uint64_t uint64;
                uint32_t uint32;
                uint16_t uint16;
                int64_t  int64;
                int32_t  int32;
                int16_t  int16;
                float    float32;
                double   float64;
                uint8_t  uint8[8];
        } Convert;
 
#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
        uint8_t& Convert_Byte0 = Convert.uint8[7];
        uint8_t& Convert_Byte1 = Convert.uint8[6];
        uint8_t& Convert_Byte2 = Convert.uint8[5];
        uint8_t& Convert_Byte3 = Convert.uint8[4];
        uint8_t& Convert_Byte4 = Convert.uint8[3];
        uint8_t& Convert_Byte5 = Convert.uint8[2];
        uint8_t& Convert_Byte6 = Convert.uint8[1];
        uint8_t& Convert_Byte7 = Convert.uint8[0];
#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
        uint8_t& Convert_Byte0 = Convert.uint8[0];
        uint8_t& Convert_Byte1 = Convert.uint8[1];
        uint8_t& Convert_Byte2 = Convert.uint8[2];
        uint8_t& Convert_Byte3 = Convert.uint8[3];
        uint8_t& Convert_Byte4 = Convert.uint8[4];
        uint8_t& Convert_Byte5 = Convert.uint8[5];
        uint8_t& Convert_Byte6 = Convert.uint8[6];
        uint8_t& Convert_Byte7 = Convert.uint8[7];
#endif
}
 
// }}}
// {{{ MessagePack
 
void MessagePack::append(const bool value 
        , size_t* const             index 
        ) noexcept
{
        if(index != nullptr)
        {
                *index = object_vector.size();
        }
 
        object_vector.emplace_back(value);
}
 
 
#ifdef ZAKERO_MESSAGEPACK_IMPLEMENTATION_TEST // {{{
TEST_CASE("Append: Bool")
{
        MessagePack mesg_pack;
 
        size_t index = 0;
        mesg_pack.append(true, &index);
 
        CHECK(index == 0);
        CHECK(mesg_pack.size() == 1);
 
        mesg_pack.append(false, &index);
 
        CHECK(index == 1);
        CHECK(mesg_pack.size() == 2);
 
        // Check serialized data
 
        std::vector<uint8_t> data = mesg_pack.serialize();
 
        CHECK(data.size() == 2);
        CHECK(data[0] == (uint8_t)Type::True);
        CHECK(data[1] == (uint8_t)Type::False);
 
        // Check deserialized data
 
        mesg_pack.deserialize(data);
        CHECK(mesg_pack.size() == 2);
 
        {
                const MessagePack::Object& object = mesg_pack.object(0);
                CHECK(object.type  == MessagePack::DataType::Bool);
                CHECK(object.bool_ == true);
        }
 
        {
                const MessagePack::Object& object = mesg_pack.object(1);
                CHECK(object.type  == MessagePack::DataType::Bool);
                CHECK(object.bool_ == false);
        }
}
#endif // }}}
 
 
void MessagePack::append(const int64_t value 
        , size_t* const                index 
        ) noexcept
{
        if(index != nullptr)
        {
                *index = object_vector.size();
        }
 
        object_vector.emplace_back(value);
}
 
 
#ifdef ZAKERO_MESSAGEPACK_IMPLEMENTATION_TEST // {{{
TEST_CASE("Append: Fixed_Int")
{
        MessagePack mesg_pack;
 
        const int64_t fixint_zero = 0;
        const int64_t fixint_max  = 127;
        const int64_t fixint_min  = -32;
        const int64_t fixint_p24  = 24;
        const int64_t fixint_n24  = -24;
        size_t count = 0;
 
        mesg_pack.append(fixint_zero); count++;
        mesg_pack.append(fixint_max);  count++;
        mesg_pack.append(fixint_min);  count++;
        mesg_pack.append(fixint_p24);  count++;
        mesg_pack.append(fixint_n24);  count++;
 
        CHECK(mesg_pack.size() == count);
 
        // Check serialized data
 
        std::vector<uint8_t> data = mesg_pack.serialize();
 
        size_t size = (count * sizeof(uint8_t));
 
        CHECK(data.size() == size);
        CHECK((data[0] & Fixed_Int_Pos_Mask) == ((uint8_t)Type::Fixed_Int_Pos));
        CHECK((data[0] & Fixed_Int_Pos_Value) == fixint_zero);
        CHECK((data[1] & Fixed_Int_Pos_Mask) == ((uint8_t)Type::Fixed_Int_Pos));
        CHECK((data[1] & Fixed_Int_Pos_Value) == fixint_max);
        CHECK((data[2] & Fixed_Int_Neg_Mask) == ((uint8_t)Type::Fixed_Int_Neg));
        CHECK(((data[2] & Fixed_Int_Neg_Value) - 32) == fixint_min);
        CHECK((data[3] & Fixed_Int_Pos_Mask) == ((uint8_t)Type::Fixed_Int_Pos));
        CHECK((data[3] & Fixed_Int_Pos_Value) == fixint_p24);
        CHECK((data[4] & Fixed_Int_Neg_Mask) == ((uint8_t)Type::Fixed_Int_Neg));
        CHECK(((data[4] & Fixed_Int_Neg_Value) - 32) == fixint_n24);
 
        // Check deserialized data
 
        mesg_pack.deserialize(data);
        CHECK(mesg_pack.size() == count);
 
        {
                const MessagePack::Object& object = mesg_pack.object(0);
                CHECK(object.type   == MessagePack::DataType::Int64);
                CHECK(object.int64_ == fixint_zero);
        }
 
        {
                const MessagePack::Object& object = mesg_pack.object(1);
                CHECK(object.type   == MessagePack::DataType::Int64);
                CHECK(object.int64_ == fixint_max);
        }
 
        {
                const MessagePack::Object& object = mesg_pack.object(2);
                CHECK(object.type   == MessagePack::DataType::Int64);
                CHECK(object.int64_ == fixint_min);
        }
 
        {
                const MessagePack::Object& object = mesg_pack.object(3);
                CHECK(object.type   == MessagePack::DataType::Int64);
                CHECK(object.int64_ == fixint_p24);
        }
 
        {
                const MessagePack::Object& object = mesg_pack.object(4);
                CHECK(object.type   == MessagePack::DataType::Int64);
                CHECK(object.int64_ == fixint_n24);
        }
}
 
TEST_CASE("Append: Int8")
{
        MessagePack mesg_pack;
 
        // Don't test the maximum Int8 value 127
        // because that is handled by Fixed_Int_Pos
 
        const int64_t i8_min1 = std::numeric_limits<int8_t>::min();
        const int64_t i8_min2 = -33;
        size_t count = 0;
 
        mesg_pack.append(i8_min1); count++;
        mesg_pack.append(i8_min2); count++;
 
        CHECK(mesg_pack.size() == count);
 
        // Check serialized data
 
        std::vector<uint8_t> data = mesg_pack.serialize();
 
        size_t size = (count * 2 * sizeof(uint8_t));
        CHECK(data.size() == size);
 
        CHECK(data[0] == ((uint8_t)Type::Int8));
        CHECK((int8_t)data[1] == i8_min1);
        CHECK(data[2] == ((uint8_t)Type::Int8));
        CHECK((int8_t)data[3] == i8_min2);
 
        // Check deserialized data
 
        mesg_pack.deserialize(data);
 
        CHECK(mesg_pack.size() == count);
 
        {
                const MessagePack::Object& object = mesg_pack.object(0);
                CHECK(object.type   == MessagePack::DataType::Int64);
                CHECK(object.int64_ == i8_min1);
        }
 
        {
                const MessagePack::Object& object = mesg_pack.object(1);
                CHECK(object.type   == MessagePack::DataType::Int64);
                CHECK(object.int64_ == i8_min2);
        }
}
 
TEST_CASE("Append: Int16")
{
        MessagePack mesg_pack;
 
        const int64_t i16_min1 = std::numeric_limits<int16_t>::min();
        const int64_t i16_max1 = std::numeric_limits<int16_t>::max();
        const int64_t i16_min2 = std::numeric_limits<int8_t>::min() - (int64_t)1;
        const int64_t i16_max2 = std::numeric_limits<int8_t>::max() + (int64_t)1;
        size_t count = 0;
 
        mesg_pack.clear();
        mesg_pack.append(i16_min1); count++;
        mesg_pack.append(i16_max1); count++;
        mesg_pack.append(i16_min2); count++;
        mesg_pack.append(i16_max2); count++;
 
        CHECK(mesg_pack.size() == count);
 
        // Check serialized data
 
        std::vector<uint8_t> data = mesg_pack.serialize();
 
        size_t size = (count * 3 * sizeof(uint8_t));
        CHECK(data.size() == size);
 
        CHECK(data[0] == ((uint8_t)Type::Int16));
 
        Convert.uint64 = 0;
        Convert_Byte1 = data[1];
        Convert_Byte0 = data[2];
        CHECK(Convert.int16 == i16_min1);
 
        CHECK(data[3] == ((uint8_t)Type::Int16));
        Convert_Byte1 = data[4];
        Convert_Byte0 = data[5];
        CHECK(Convert.int16 == i16_max1);
 
        CHECK(data[6] == ((uint8_t)Type::Int16));
        Convert_Byte1 = data[7];
        Convert_Byte0 = data[8];
        CHECK(Convert.int16 == i16_min2);
 
        CHECK(data[9] == ((uint8_t)Type::Int16));
        Convert_Byte1 = data[10];
        Convert_Byte0 = data[11];
        CHECK(Convert.int16 == i16_max2);
 
        // Check deserialized data
 
        mesg_pack.deserialize(data);
 
        CHECK(mesg_pack.size() == count);
 
        {
                const MessagePack::Object& object = mesg_pack.object(0);
                CHECK(object.type   == MessagePack::DataType::Int64);
                CHECK(object.int64_ == i16_min1);
        }
 
        {
                const MessagePack::Object& object = mesg_pack.object(1);
                CHECK(object.type   == MessagePack::DataType::Int64);
                CHECK(object.int64_ == i16_max1);
        }
 
        {
                const MessagePack::Object& object = mesg_pack.object(2);
                CHECK(object.type   == MessagePack::DataType::Int64);
                CHECK(object.int64_ == i16_min2);
        }
 
        {
                const MessagePack::Object& object = mesg_pack.object(3);
                CHECK(object.type   == MessagePack::DataType::Int64);
                CHECK(object.int64_ == i16_max2);
        }
}
 
TEST_CASE("Append: Int32")
{
        MessagePack mesg_pack;
 
        const int64_t i32_min1 = std::numeric_limits<int32_t>::min();
        const int64_t i32_max1 = std::numeric_limits<int32_t>::max();
        const int64_t i32_min2 = std::numeric_limits<int16_t>::min() - (int64_t)1;
        const int64_t i32_max2 = std::numeric_limits<int16_t>::max() + (int64_t)1;
        size_t count = 0;
 
        mesg_pack.clear();
        mesg_pack.append(i32_min1); count++;
        mesg_pack.append(i32_max1); count++;
        mesg_pack.append(i32_min2); count++;
        mesg_pack.append(i32_max2); count++;
 
        CHECK(mesg_pack.size() == count);
 
        // Check serialized data
 
        std::vector<uint8_t> data = mesg_pack.serialize();
 
        size_t size = (count * 5 * sizeof(uint8_t));
        CHECK(data.size() == size);
 
        CHECK(data[0] == ((uint8_t)Type::Int32));
 
        Convert.uint64 = 0;
        Convert_Byte3 = data[1];
        Convert_Byte2 = data[2];
        Convert_Byte1 = data[3];
        Convert_Byte0 = data[4];
        CHECK(Convert.int32 == i32_min1);
 
        CHECK(data[5] == ((uint8_t)Type::Int32));
        Convert_Byte3 = data[6];
        Convert_Byte2 = data[7];
        Convert_Byte1 = data[8];
        Convert_Byte0 = data[9];
        CHECK(Convert.int32 == i32_max1);
 
        CHECK(data[10] == ((uint8_t)Type::Int32));
        Convert_Byte3 = data[11];
        Convert_Byte2 = data[12];
        Convert_Byte1 = data[13];
        Convert_Byte0 = data[14];
        CHECK(Convert.int32 == i32_min2);
 
        CHECK(data[15] == ((uint8_t)Type::Int32));
        Convert_Byte3 = data[16];
        Convert_Byte2 = data[17];
        Convert_Byte1 = data[18];
        Convert_Byte0 = data[19];
        CHECK(Convert.int32 == i32_max2);
 
        // Check deserialized data
 
        mesg_pack.deserialize(data);
 
        CHECK(mesg_pack.size() == count);
 
        {
                const MessagePack::Object& object = mesg_pack.object(0);
                CHECK(object.type   == MessagePack::DataType::Int64);
                CHECK(object.int64_ == i32_min1);
        }
 
        {
                const MessagePack::Object& object = mesg_pack.object(1);
                CHECK(object.type   == MessagePack::DataType::Int64);
                CHECK(object.int64_ == i32_max1);
        }
 
        {
                const MessagePack::Object& object = mesg_pack.object(2);
                CHECK(object.type   == MessagePack::DataType::Int64);
                CHECK(object.int64_ == i32_min2);
        }
 
        {
                const MessagePack::Object& object = mesg_pack.object(3);
                CHECK(object.type   == MessagePack::DataType::Int64);
                CHECK(object.int64_ == i32_max2);
        }
}
 
TEST_CASE("Append: Int64")
{
        MessagePack mesg_pack;
 
        const int64_t i64_min1 = std::numeric_limits<int64_t>::min();
        const int64_t i64_max1 = std::numeric_limits<int64_t>::max();
        const int64_t i64_min2 = std::numeric_limits<int32_t>::min() - (int64_t)1;
        const int64_t i64_max2 = std::numeric_limits<int32_t>::max() + (int64_t)1;
        size_t count = 0;
 
        mesg_pack.clear();
        mesg_pack.append(i64_min1); count++;
        mesg_pack.append(i64_max1); count++;
        mesg_pack.append(i64_min2); count++;
        mesg_pack.append(i64_max2); count++;
 
        CHECK(mesg_pack.size() == count);
 
        // Check serialized data
 
        std::vector<uint8_t> data = mesg_pack.serialize();
 
        size_t size = (count * 9 * sizeof(uint8_t));
        CHECK(data.size() == size);
 
        CHECK(data[0] == ((uint8_t)Type::Int64));
 
        Convert.uint64 = 0;
        Convert_Byte7 = data[1];
        Convert_Byte6 = data[2];
        Convert_Byte5 = data[3];
        Convert_Byte4 = data[4];
        Convert_Byte3 = data[5];
        Convert_Byte2 = data[6];
        Convert_Byte1 = data[7];
        Convert_Byte0 = data[8];
        CHECK(Convert.int64 == i64_min1);
 
        CHECK(data[9] == ((uint8_t)Type::Int64));
        Convert_Byte7 = data[10];
        Convert_Byte6 = data[11];
        Convert_Byte5 = data[12];
        Convert_Byte4 = data[13];
        Convert_Byte3 = data[14];
        Convert_Byte2 = data[15];
        Convert_Byte1 = data[16];
        Convert_Byte0 = data[17];
        CHECK(Convert.int64 == i64_max1);
 
        CHECK(data[18] == ((uint8_t)Type::Int64));
        Convert_Byte7 = data[19];
        Convert_Byte6 = data[20];
        Convert_Byte5 = data[21];
        Convert_Byte4 = data[22];
        Convert_Byte3 = data[23];
        Convert_Byte2 = data[24];
        Convert_Byte1 = data[25];
        Convert_Byte0 = data[26];
        CHECK(Convert.int64 == i64_min2);
 
        CHECK(data[27] == ((uint8_t)Type::Int64));
        Convert_Byte7 = data[28];
        Convert_Byte6 = data[29];
        Convert_Byte5 = data[30];
        Convert_Byte4 = data[31];
        Convert_Byte3 = data[32];
        Convert_Byte2 = data[33];
        Convert_Byte1 = data[34];
        Convert_Byte0 = data[35];
        CHECK(Convert.int64 == i64_max2);
 
        // Check deserialized data
 
        mesg_pack.deserialize(data);
 
        CHECK(mesg_pack.size() == count);
 
        {
                const MessagePack::Object& object = mesg_pack.object(0);
                CHECK(object.type   == MessagePack::DataType::Int64);
                CHECK(object.int64_ == i64_min1);
        }
 
        {
                const MessagePack::Object& object = mesg_pack.object(1);
                CHECK(object.type   == MessagePack::DataType::Int64);
                CHECK(object.int64_ == i64_max1);
 
        }
 
        {
                const MessagePack::Object& object = mesg_pack.object(2);
                CHECK(object.type   == MessagePack::DataType::Int64);
                CHECK(object.int64_ == i64_min2);
        }
 
        {
                const MessagePack::Object& object = mesg_pack.object(3);
                CHECK(object.type   == MessagePack::DataType::Int64);
                CHECK(object.int64_ == i64_max2);
        }
}
#endif // }}}
 
 
void MessagePack::append(const uint64_t value 
        , size_t* const                 index 
        ) noexcept
{
        if(index != nullptr)
        {
                *index = object_vector.size();
        }
 
        object_vector.emplace_back(value);
}
 
 
#ifdef ZAKERO_MESSAGEPACK_IMPLEMENTATION_TEST // {{{
TEST_CASE("Append: Uint8")
{
        MessagePack mesg_pack;
 
        const uint64_t u8_min = 0x00;
        const uint64_t u8_max = std::numeric_limits<uint8_t>::max();
        size_t count = 0;
 
        mesg_pack.append(u8_min); count++;
        mesg_pack.append(u8_max); count++;
 
        CHECK(mesg_pack.size() == count);
 
        // Check serialized data
 
        std::vector<uint8_t> data = mesg_pack.serialize();
 
        size_t size = (count * 2 * sizeof(uint8_t));
        CHECK(data.size() == size);
 
        CHECK(data[0] == ((uint8_t)Type::Uint8));
        CHECK(data[1] == u8_min);
        CHECK(data[2] == ((uint8_t)Type::Uint8));
        CHECK(data[3] == u8_max);
 
        // Check deserialized data
 
        mesg_pack.deserialize(data);
 
        CHECK(mesg_pack.size() == count);
 
        {
                const MessagePack::Object& object = mesg_pack.object(0);
                CHECK(object.type    == MessagePack::DataType::Uint64);
                CHECK(object.uint64_ == u8_min);
        }
 
        {
                const MessagePack::Object& object = mesg_pack.object(1);
                CHECK(object.type    == MessagePack::DataType::Uint64);
                CHECK(object.uint64_ == u8_max);
        }
}
 
TEST_CASE("Append: Uint16")
{
        MessagePack mesg_pack;
 
        const uint64_t u16_min = std::numeric_limits<uint8_t>::max() + (uint64_t)1;
        const uint64_t u16_max = std::numeric_limits<uint16_t>::max();
        size_t count = 0;
 
        mesg_pack.append(u16_min); count++;
        mesg_pack.append(u16_max); count++;
 
        CHECK(mesg_pack.size() == count);
 
        // Check serialized data
 
        std::vector<uint8_t> data = mesg_pack.serialize();
 
        size_t size = (count * 3 * sizeof(uint8_t));
        CHECK(data.size() == size);
 
        CHECK(data[0] == ((uint8_t)Type::Uint16));
 
        Convert_Byte1 = data[1];
        Convert_Byte0 = data[2];
        CHECK(Convert.uint16 == u16_min);
 
        CHECK(data[3] == ((uint8_t)Type::Uint16));
        Convert_Byte1 = data[4];
        Convert_Byte0 = data[5];
        CHECK(Convert.uint16 == u16_max);
 
        // Check deserialized data
 
        mesg_pack.deserialize(data);
 
        CHECK(mesg_pack.size() == count);
 
        {
                const MessagePack::Object& object = mesg_pack.object(0);
                CHECK(object.type    == MessagePack::DataType::Uint64);
                CHECK(object.uint64_ == u16_min);
        }
 
        {
                const MessagePack::Object& object = mesg_pack.object(1);
                CHECK(object.type    == MessagePack::DataType::Uint64);
                CHECK(object.uint64_ == u16_max);
        }
}
 
TEST_CASE("Append: Uint32")
{
        MessagePack mesg_pack;
 
        const uint64_t u32_min = std::numeric_limits<uint16_t>::max() + (uint64_t)1;
        const uint64_t u32_max = std::numeric_limits<uint32_t>::max();
        size_t count = 0;
 
        mesg_pack.append(u32_min); count++;
        mesg_pack.append(u32_max); count++;
 
        CHECK(mesg_pack.size() == count);
 
        // Check serialized data
 
        std::vector<uint8_t> data = mesg_pack.serialize();
 
        size_t size = (count * 5 * sizeof(uint8_t));
        CHECK(data.size() == size);
 
        CHECK(data[0] == ((uint8_t)Type::Uint32));
 
        Convert_Byte3 = data[1];
        Convert_Byte2 = data[2];
        Convert_Byte1 = data[3];
        Convert_Byte0 = data[4];
        CHECK(Convert.uint32 == u32_min);
 
        CHECK(data[5] == ((uint8_t)Type::Uint32));
        Convert_Byte3 = data[6];
        Convert_Byte2 = data[7];
        Convert_Byte1 = data[8];
        Convert_Byte0 = data[9];
        CHECK(Convert.uint32 == u32_max);
 
        // Check deserialized data
 
        mesg_pack.deserialize(data);
 
        CHECK(mesg_pack.size() == count);
 
        {
                const MessagePack::Object& object = mesg_pack.object(0);
                CHECK(object.type    == MessagePack::DataType::Uint64);
                CHECK(object.uint64_ == u32_min);
        }
 
        {
                const MessagePack::Object& object = mesg_pack.object(1);
                CHECK(object.type    == MessagePack::DataType::Uint64);
                CHECK(object.uint64_ == u32_max);
        }
}
 
TEST_CASE("Append: Uint64")
{
        MessagePack mesg_pack;
 
        const uint64_t u64_min = std::numeric_limits<uint32_t>::max() + (uint64_t)1;
        const uint64_t u64_max = std::numeric_limits<uint64_t>::max();
        size_t count = 0;
 
        mesg_pack.append(u64_min); count++;
        mesg_pack.append(u64_max); count++;
 
        CHECK(mesg_pack.size() == count);
 
        // Check serialized data
 
        std::vector<uint8_t> data = mesg_pack.serialize();
 
        size_t size = (count * 9 * sizeof(uint8_t));
        CHECK(data.size() == size);
 
        CHECK(data[0] == ((uint8_t)Type::Uint64));
 
        Convert_Byte7 = data[1];
        Convert_Byte6 = data[2];
        Convert_Byte5 = data[3];
        Convert_Byte4 = data[4];
        Convert_Byte3 = data[5];
        Convert_Byte2 = data[6];
        Convert_Byte1 = data[7];
        Convert_Byte0 = data[8];
        CHECK(Convert.uint64 == u64_min);
 
        CHECK(data[9] == ((uint8_t)Type::Uint64));
        Convert_Byte7 = data[10];
        Convert_Byte6 = data[11];
        Convert_Byte5 = data[12];
        Convert_Byte4 = data[13];
        Convert_Byte3 = data[14];
        Convert_Byte2 = data[15];
        Convert_Byte1 = data[16];
        Convert_Byte0 = data[17];
        CHECK(Convert.uint64 == u64_max);
 
        // Check deserialized data
 
        mesg_pack.deserialize(data);
 
        CHECK(mesg_pack.size() == count);
 
        {
                const MessagePack::Object& object = mesg_pack.object(0);
                CHECK(object.type    == MessagePack::DataType::Uint64);
                CHECK(object.uint64_ == u64_min);
        }
 
        {
                const MessagePack::Object& object = mesg_pack.object(1);
                CHECK(object.type    == MessagePack::DataType::Uint64);
                CHECK(object.uint64_ == u64_max);
        }
}
#endif // }}}
 
 
void MessagePack::append(const float value 
        , size_t* const              index 
        ) noexcept
{
        if(index != nullptr)
        {
                *index = object_vector.size();
        }
 
        object_vector.emplace_back(value);
}
 
 
#ifdef ZAKERO_MESSAGEPACK_IMPLEMENTATION_TEST // {{{
TEST_CASE("Append: Float32")
{
        MessagePack mesg_pack;
 
        const float f32_min  = std::numeric_limits<float>::min();
        const float f32_max  = std::numeric_limits<float>::max();
        const float f32_zero = 0.0f;
        size_t count = 0;
 
        mesg_pack.append(f32_min);  count++;
        mesg_pack.append(f32_max);  count++;
        mesg_pack.append(f32_zero); count++;
 
        CHECK(mesg_pack.size() == count);
 
        // Check serialized data
 
        std::vector<uint8_t> data = mesg_pack.serialize();
 
        size_t size = (count * 5 * sizeof(uint8_t));
        CHECK(data.size() == size);
 
        CHECK(data[0] == ((uint8_t)Type::Float32));
        Convert_Byte3 = data[1];
        Convert_Byte2 = data[2];
        Convert_Byte1 = data[3];
        Convert_Byte0 = data[4];
        CHECK(Convert.float32 == f32_min);
 
        CHECK(data[5] == ((uint8_t)Type::Float32));
        Convert_Byte3 = data[6];
        Convert_Byte2 = data[7];
        Convert_Byte1 = data[8];
        Convert_Byte0 = data[9];
        CHECK(Convert.float32 == f32_max);
 
        CHECK(data[10] == ((uint8_t)Type::Float32));
        Convert_Byte3 = data[11];
        Convert_Byte2 = data[12];
        Convert_Byte1 = data[13];
        Convert_Byte0 = data[14];
        CHECK(Convert.float32 == f32_zero);
 
        // Check deserialized data
 
        mesg_pack.deserialize(data);
 
        CHECK(mesg_pack.size() == count);
 
        {
                const MessagePack::Object& object = mesg_pack.object(0);
                CHECK(object.type   == MessagePack::DataType::Float);
                CHECK(object.float_ == f32_min);
        }
 
        {
                const MessagePack::Object& object = mesg_pack.object(1);
                CHECK(object.type   == MessagePack::DataType::Float);
                CHECK(object.float_ == f32_max);
        }
 
        {
                const MessagePack::Object& object = mesg_pack.object(2);
                CHECK(object.type   == MessagePack::DataType::Float);
                CHECK(object.float_ == f32_zero);
        }
}
#endif // }}}
 
 
void MessagePack::append(const double value 
        , size_t* const               index 
        ) noexcept
{
        if(index != nullptr)
        {
                *index = object_vector.size();
        }
 
        object_vector.emplace_back(value);
}
 
 
#ifdef ZAKERO_MESSAGEPACK_IMPLEMENTATION_TEST // {{{
TEST_CASE("Append: Float64")
{
        MessagePack mesg_pack;
 
        const double f64_min  = std::numeric_limits<double>::min();
        const double f64_max  = std::numeric_limits<double>::max();
        const double f64_zero = 0.0f;
        size_t count = 0;
 
        mesg_pack.append(f64_min);  count++;
        mesg_pack.append(f64_max);  count++;
        mesg_pack.append(f64_zero); count++;
 
        CHECK(mesg_pack.size() == count);
 
        // Check serialized data
 
        std::vector<uint8_t> data = mesg_pack.serialize();
 
        size_t size = (count * 9 * sizeof(uint8_t));
        CHECK(data.size() == size);
 
        CHECK(data[0] == ((uint8_t)Type::Float64));
        Convert_Byte7 = data[1];
        Convert_Byte6 = data[2];
        Convert_Byte5 = data[3];
        Convert_Byte4 = data[4];
        Convert_Byte3 = data[5];
        Convert_Byte2 = data[6];
        Convert_Byte1 = data[7];
        Convert_Byte0 = data[8];
        CHECK(Convert.float64 == f64_min);
 
        CHECK(data[9] == ((uint8_t)Type::Float64));
        Convert_Byte7 = data[10];
        Convert_Byte6 = data[11];
        Convert_Byte5 = data[12];
        Convert_Byte4 = data[13];
        Convert_Byte3 = data[14];
        Convert_Byte2 = data[15];
        Convert_Byte1 = data[16];
        Convert_Byte0 = data[17];
        CHECK(Convert.float64 == f64_max);
 
        CHECK(data[18] == ((uint8_t)Type::Float64));
        Convert_Byte7 = data[19];
        Convert_Byte6 = data[20];
        Convert_Byte5 = data[21];
        Convert_Byte4 = data[22];
        Convert_Byte3 = data[23];
        Convert_Byte2 = data[24];
        Convert_Byte1 = data[25];
        Convert_Byte0 = data[26];
        CHECK(Convert.float64 == f64_zero);
 
        // Check deserialized data
 
        mesg_pack.deserialize(data);
 
        CHECK(mesg_pack.size() == count);
 
        {
                const MessagePack::Object& object = mesg_pack.object(0);
                CHECK(object.type    == MessagePack::DataType::Double);
                CHECK(object.double_ == f64_min);
        }
 
        {
                const MessagePack::Object& object = mesg_pack.object(1);
                CHECK(object.type    == MessagePack::DataType::Double);
                CHECK(object.double_ == f64_max);
        }
 
        {
                const MessagePack::Object& object = mesg_pack.object(2);
                CHECK(object.type    == MessagePack::DataType::Double);
                CHECK(object.double_ == f64_zero);
        }
}
#endif // }}}
 
 
void MessagePack::append(const std::string_view value 
        , size_t* const                         index 
        ) noexcept
{
        if(index != nullptr)
        {
                *index = object_vector.size();
        }
 
        object_vector.emplace_back(value);
}
 
 
#ifdef ZAKERO_MESSAGEPACK_IMPLEMENTATION_TEST // {{{
TEST_CASE("Append: Fixed_Str")
{
        MessagePack mesg_pack;
 
        const std::string str_empty;
        const std::string str_1("_");
        const std::string str_31(31, 'a');
        size_t count = 0;
 
        mesg_pack.append(str_empty); count++;
        mesg_pack.append(str_1);     count++;
        mesg_pack.append(str_31);    count++;
 
        CHECK(mesg_pack.size() == count);
 
        // Check serialized data
 
        std::vector<uint8_t> data = mesg_pack.serialize();
 
        size_t size = (count * 1 * sizeof(uint8_t))
                + str_empty.size()
                + str_1.size()
                + str_31.size()
                ;
        CHECK(data.size() == size);
 
        size_t str_len = 0;
        size_t index = 0;
        std::string_view str;
 
        CHECK((data[0] & Fixed_Str_Mask) == ((uint8_t)Type::Fixed_Str));
        str_len = data[0] & Fixed_Str_Value;
        CHECK(str_len == str_empty.size());
        index += str_len + 1;
 
        CHECK((data[index] & Fixed_Str_Mask) == ((uint8_t)Type::Fixed_Str));
        str_len = data[index] & Fixed_Str_Value;
        CHECK(str_len == str_1.size());
        index++;
        str = std::string_view((char*)&data[index], str_len);
        CHECK(str == str_1);
        index += str_len;
 
        CHECK((data[index] & Fixed_Str_Mask) == ((uint8_t)Type::Fixed_Str));
        str_len = data[index] & Fixed_Str_Value;
        CHECK(str_len == str_31.size());
        index++;
        str = std::string_view((char*)&data[index], str_len);
        CHECK(str == str_31);
 
        // Check deserialized data
 
        mesg_pack.deserialize(data);
 
        CHECK(mesg_pack.size() == count);
 
        {
                const MessagePack::Object& object = mesg_pack.object(0);
                CHECK(object.type   == MessagePack::DataType::String);
                CHECK(object.string == str_empty);
        }
 
        {
                const MessagePack::Object& object = mesg_pack.object(1);
                CHECK(object.type   == MessagePack::DataType::String);
                CHECK(object.string == str_1);
        }
 
        {
                const MessagePack::Object& object = mesg_pack.object(2);
                CHECK(object.type   == MessagePack::DataType::String);
                CHECK(object.string == str_31);
        }
}
 
TEST_CASE("Append: Str8")
{
        MessagePack mesg_pack;
 
        const std::string str_min(32  , '_');
        const std::string str_max(std::numeric_limits<uint8_t>::max(), 'X');
        size_t count = 0;
 
        mesg_pack.append(str_min); count++;
        mesg_pack.append(str_max); count++;
 
        CHECK(mesg_pack.size() == count);
 
        // Check serialized data
 
        std::vector<uint8_t> data = mesg_pack.serialize();
 
        size_t size = (count * 2 * sizeof(uint8_t))
                + str_min.size()
                + str_max.size()
                ;
        CHECK(data.size() == size);
 
        size_t str_len = 0;
        size_t index = 0;
        std::string_view str;
 
        CHECK(data[index] == ((uint8_t)Type::Str8));
        str_len = data[++index];
        CHECK(str_len == str_min.size());
        str = std::string_view((char*)&data[++index], str_len);
        CHECK(str == str_min);
        index += str_len;
 
        CHECK(data[index] == ((uint8_t)Type::Str8));
        str_len = data[++index];
        CHECK(str_len == str_max.size());
        str = std::string_view((char*)&data[++index], str_len);
        CHECK(str == str_max);
        index += str_len;
 
        // Check deserialized data
 
        mesg_pack.deserialize(data);
 
        CHECK(mesg_pack.size() == count);
 
        {
                const MessagePack::Object& object = mesg_pack.object(0);
                CHECK(object.type   == MessagePack::DataType::String);
                CHECK(object.string == str_min);
        }
 
        {
                const MessagePack::Object& object = mesg_pack.object(1);
                CHECK(object.type   == MessagePack::DataType::String);
                CHECK(object.string == str_max);
        }
}
 
TEST_CASE("Append: Str16")
{
        MessagePack mesg_pack;
 
        const std::string str_min(std::numeric_limits<uint8_t>::max() + 1, '_');
        const std::string str_max(std::numeric_limits<uint16_t>::max()   , 'X');
        size_t count = 0;
 
        mesg_pack.append(str_min); count++;
        mesg_pack.append(str_max); count++;
 
        CHECK(mesg_pack.size() == count);
 
        // Check serialized data
 
        std::vector<uint8_t> data = mesg_pack.serialize();
 
        size_t size = (count * 3 * sizeof(uint8_t))
                + str_min.size()
                + str_max.size()
                ;
        CHECK(data.size() == size);
 
        size_t str_len = 0;
        size_t index = 0;
        std::string_view str;
 
        CHECK(data[index] == ((uint8_t)Type::Str16));
        Convert_Byte1 = data[++index];
        Convert_Byte0 = data[++index];
        str_len = Convert.uint16;
        CHECK(str_len == str_min.size());
        str = std::string_view((char*)&data[++index], str_len);
        CHECK(str == str_min);
        index += str_len;
 
        CHECK(data[index] == ((uint8_t)Type::Str16));
        Convert_Byte1 = data[++index];
        Convert_Byte0 = data[++index];
        str_len = Convert.uint16;
        CHECK(str_len == str_max.size());
        str = std::string_view((char*)&data[++index], str_len);
        CHECK(str == str_max);
        index += str_len;
 
        // Check deserialized data
 
        mesg_pack.deserialize(data);
 
        CHECK(mesg_pack.size() == count);
 
        {
                const MessagePack::Object& object = mesg_pack.object(0);
                CHECK(object.type   == MessagePack::DataType::String);
                CHECK(object.string == str_min);
        }
 
        {
                const MessagePack::Object& object = mesg_pack.object(1);
                CHECK(object.type   == MessagePack::DataType::String);
                CHECK(object.string == str_max);
        }
}
 
TEST_CASE("Append: Str32")
{
        MessagePack mesg_pack;
 
        const std::string str_min(std::numeric_limits<uint16_t>::max() + 1, '_');
        // This string size would be 4GB + overhead from std::string
        // Serializing would consume another 4GB.
        // For a total of 8GB to test the maximum Str32 length.
        //const std::string str_max(std::numeric_limits<uint32_t>::max()    , 'X');
        size_t count = 0;
 
        mesg_pack.append(str_min); count++;
        //mesg_pack.append(str_max); count++;
 
        CHECK(mesg_pack.size() == count);
 
        // Check serialized data
 
        std::vector<uint8_t> data = mesg_pack.serialize();
 
        size_t size = (count * 5 * sizeof(uint8_t))
                + str_min.size()
                //+ str_max.size()
                ;
        CHECK(data.size() == size);
 
        size_t str_len = 0;
        size_t index = 0;
        std::string_view str;
 
        CHECK(data[index] == ((uint8_t)Type::Str32));
        Convert_Byte3 = data[++index];
        Convert_Byte2 = data[++index];
        Convert_Byte1 = data[++index];
        Convert_Byte0 = data[++index];
        str_len = Convert.uint32;
        CHECK(str_len == str_min.size());
        str = std::string_view((char*)&data[++index], str_len);
        CHECK(str == str_min);
        index += str_len;
 
        //CHECK(data[index] == ((uint8_t)Type::Str32));
        //Convert_Byte1 = data[++index];
        //Convert_Byte0 = data[++index];
        //str_len = Convert.uint16;
        //CHECK(str_len == str_max.size());
        //str = std::string_view((char*)&data[++index], str_len);
        //CHECK(str == str_max);
        //index += str_len;
 
        // Check deserialized data
 
        mesg_pack.deserialize(data);
 
        CHECK(mesg_pack.size() == count);
 
        {
                const MessagePack::Object& object = mesg_pack.object(0);
                CHECK(object.type   == MessagePack::DataType::String);
                CHECK(object.string == str_min);
        }
 
        //{
        //      const MessagePack::Object& object = mesg_pack.object(1);
        //      CHECK(object.type   == MessagePack::DataType::String);
        //      CHECK(object.string == str_max);
        //}
}
#endif // }}}
 
 
void MessagePack::append(const std::vector<uint8_t>& value 
        , size_t* const                              index 
        ) noexcept
{
        if(index != nullptr)
        {
                *index = object_vector.size();
        }
 
        object_vector.emplace_back(value);
}
 
 
#ifdef ZAKERO_MESSAGEPACK_IMPLEMENTATION_TEST // {{{
TEST_CASE("Append: Bin8")
{
        MessagePack mesg_pack;
 
        const std::vector<uint8_t> bin_min = {};
        const std::vector<uint8_t> bin_max(std::numeric_limits<uint8_t>::max(), 'X');
        size_t count = 0;
 
        mesg_pack.append(bin_min); count++;
        mesg_pack.append(bin_max); count++;
 
        CHECK(mesg_pack.size() == count);
 
        // Check serialized data
 
        std::vector<uint8_t> data = mesg_pack.serialize();
 
        size_t size = (count * 2 * sizeof(uint8_t))
                + bin_min.size()
                + bin_max.size()
                ;
        CHECK(data.size() == size);
 
        size_t bin_len = 0;
        size_t index = 0;
 
        CHECK(data[index] == ((uint8_t)Type::Bin8));
        bin_len = data[++index];
        CHECK(bin_len == bin_min.size());
        for(size_t i = 0; i < bin_len; i++)
        {
                CHECK(data[++index] == bin_min[i]);
        }
 
        CHECK(data[++index] == ((uint8_t)Type::Bin8));
        bin_len = data[++index];
        CHECK(bin_len == bin_max.size());
        for(size_t i = 0; i < bin_len; i++)
        {
                CHECK(data[++index] == bin_max[i]);
        }
 
        // Check deserialized data
 
        mesg_pack.deserialize(data);
 
        CHECK(mesg_pack.size() == count);
 
        {
                const MessagePack::Object& object = mesg_pack.object(0);
                CHECK(object.type == MessagePack::DataType::Vector);
                CHECK(object.vector.size() == bin_min.size());
                for(size_t i = 0; i < bin_min.size(); i++)
                {
                        CHECK(object.vector[i] == bin_min[i]);
                }
        }
 
        {
                const MessagePack::Object& object = mesg_pack.object(1);
                CHECK(object.type == MessagePack::DataType::Vector);
                CHECK(object.vector.size() == bin_max.size());
                for(size_t i = 0; i < bin_max.size(); i++)
                {
                        CHECK(object.vector[i] == bin_max[i]);
                }
        }
}
 
TEST_CASE("Append: Bin16")
{
        MessagePack mesg_pack;
 
        const std::vector<uint8_t> bin_min(std::numeric_limits<uint8_t>::max() + 1, '_');
        const std::vector<uint8_t> bin_max(std::numeric_limits<uint16_t>::max()   , 'X');
        size_t count = 0;
 
        mesg_pack.append(bin_min); count++;
        mesg_pack.append(bin_max); count++;
 
        CHECK(mesg_pack.size() == count);
 
        // Check serialized data
 
        std::vector<uint8_t> data = mesg_pack.serialize();
 
        size_t size = (count * 3 * sizeof(uint8_t))
                + bin_min.size()
                + bin_max.size()
                ;
        CHECK(data.size() == size);
 
        size_t bin_len = 0;
        size_t index = 0;
 
        CHECK(data[index] == (uint8_t)Type::Bin16);
        Convert_Byte1 = data[++index];
        Convert_Byte0 = data[++index];
        bin_len = Convert.uint16;
        CHECK(bin_len == bin_min.size());
        for(size_t i = 0; i < bin_len; i++)
        {
                CHECK(data[++index] == bin_min[i]);
        }
 
        CHECK(data[++index] == ((uint8_t)Type::Bin16));
        Convert_Byte1 = data[++index];
        Convert_Byte0 = data[++index];
        bin_len = Convert.uint16;
        CHECK(bin_len == bin_max.size());
        for(size_t i = 0; i < bin_len; i++)
        {
                CHECK(data[++index] == bin_max[i]);
        }
 
        // Check deserialized data
 
        mesg_pack.deserialize(data);
 
        CHECK(mesg_pack.size() == count);
 
        {
                const MessagePack::Object& object = mesg_pack.object(0);
                CHECK(object.type == MessagePack::DataType::Vector);
                CHECK(object.vector.size() == bin_min.size());
                for(size_t i = 0; i < bin_min.size(); i++)
                {
                        CHECK(object.vector[i] == bin_min[i]);
                }
        }
 
        {
                const MessagePack::Object& object = mesg_pack.object(1);
                CHECK(object.type == MessagePack::DataType::Vector);
                CHECK(object.vector.size() == bin_max.size());
                for(size_t i = 0; i < bin_max.size(); i++)
                {
                        CHECK(object.vector[i] == bin_max[i]);
                }
        }
}
 
TEST_CASE("Append: Bin32")
{
        MessagePack mesg_pack;
 
        const std::vector<uint8_t> bin_min(std::numeric_limits<uint16_t>::max() + 1, '_');
        // This vector size would be 4GB + overhead from std::vector
        // Serializing would consume another 4GB.
        // For a total of 8GB to test the maximum Bin32 length.
        //const std::vector<uint8_t> bin_max(std::numeric_limits<uint32_t>::max()    , 'X');
        size_t count = 0;
 
        mesg_pack.append(bin_min); count++;
        //mesg_pack.append(bin_max); count++;
 
        CHECK(mesg_pack.size() == count);
 
        // Check serialized data
 
        std::vector<uint8_t> data = mesg_pack.serialize();
 
        size_t size = (count * 5 * sizeof(uint8_t))
                + bin_min.size()
                //+ bin_max.size()
                ;
        CHECK(data.size() == size);
 
        size_t bin_len = 0;
        size_t index = 0;
 
        CHECK(data[index] == (uint8_t)Type::Bin32);
        Convert_Byte3 = data[++index];
        Convert_Byte2 = data[++index];
        Convert_Byte1 = data[++index];
        Convert_Byte0 = data[++index];
        bin_len = Convert.uint32;
        CHECK(bin_len == bin_min.size());
        for(size_t i = 0; i < bin_len; i++)
        {
                CHECK(data[++index] == bin_min[i]);
        }
 
        //CHECK(data[++index] == ((uint8_t)Type::Bin32));
        //Convert_Byte3 = data[++index];
        //Convert_Byte2 = data[++index];
        //Convert_Byte1 = data[++index];
        //Convert_Byte0 = data[++index];
        //bin_len = Convert.uint32;
        //CHECK(bin_len == bin_max.size());
        //for(size_t i = 0; i < bin_len; i++)
        //{
        //      CHECK(data[++index] == bin_max[i]);
        //}
 
        // Check deserialized data
 
        mesg_pack.deserialize(data);
 
        CHECK(mesg_pack.size() == count);
 
        {
                const MessagePack::Object& object = mesg_pack.object(0);
                CHECK(object.type == MessagePack::DataType::Vector);
                CHECK(object.vector.size() == bin_min.size());
                for(size_t i = 0; i < bin_min.size(); i++)
                {
                        CHECK(object.vector[i] == bin_min[i]);
                }
        }
 
        //{
        //      const MessagePack::Object& object = mesg_pack.object(1);
        //      CHECK(object.type == MessagePack::DataType::Vector);
        //      CHECK(object.vector.size() == bin_max.size());
        //      for(size_t i = 0; i < bin_max.size(); i++)
        //      {
        //              CHECK(object.vector[i] == bin_max[i]);
        //      }
        //}
}
#endif // }}}
 
 
void MessagePack::appendNull(size_t* const index 
        ) noexcept
{
        if(index != nullptr)
        {
                *index = object_vector.size();
        }
 
        object_vector.emplace_back();
}
 
#ifdef ZAKERO_MESSAGEPACK_IMPLEMENTATION_TEST // {{{
TEST_CASE("Append: Nill")
{
        MessagePack mesg_pack;
 
        size_t index = 0;
        mesg_pack.appendNull(&index);
 
        CHECK(index == 0);
        CHECK(mesg_pack.size() == 1);
 
        mesg_pack.appendNull(&index);
 
        CHECK(index == 1);
        CHECK(mesg_pack.size() == 2);
 
        // Check serialized data
 
        std::vector<uint8_t> data = mesg_pack.serialize();
 
        CHECK(data.size() == 2);
        CHECK(data[0] == (uint8_t)Type::Nill);
        CHECK(data[1] == (uint8_t)Type::Nill);
 
        // Check deserialized data
 
        mesg_pack.deserialize(data);
        CHECK(mesg_pack.size() == 2);
 
        {
                const MessagePack::Object& object = mesg_pack.object(0);
                CHECK(object.type   == MessagePack::DataType::Null);
                CHECK(object.int64_ == 0);
        }
 
        {
                const MessagePack::Object& object = mesg_pack.object(1);
                CHECK(object.type   == MessagePack::DataType::Null);
                CHECK(object.int64_ == 0);
        }
}
#endif // }}}
 
 
MessagePack::Object& MessagePack::object(const size_t index 
        ) noexcept
{
        return object_vector[index];
}
 
 
void MessagePack::clear() noexcept
{
        object_vector.clear();
}
 
 
size_t MessagePack::size() noexcept
{
        return object_vector.size();
}
 
 
#ifdef ZAKERO_MESSAGEPACK_IMPLEMENTATION_TEST // {{{
// Nothing to test
#endif // }}}
 
 
void MessagePack::deserialize(const std::vector<uint8_t>& data 
        ) noexcept
{
        object_vector.clear();
 
        for(size_t index = 0; index < data.size(); index++)
        {
                uint8_t byte = data[index];
 
                if(byte == (uint8_t)Type::Nill)
                {
                        appendNull();
                }
                else if(byte == (uint8_t)Type::False)
                {
                        append(false);
                }
                else if(byte == (uint8_t)Type::True)
                {
                        append(true);
                }
                else if((byte & (uint8_t)Fixed_Int_Pos_Mask) == (uint8_t)Type::Fixed_Int_Pos)
                {
                        int64_t value = byte & (uint8_t)Fixed_Int_Pos_Value;
                        append(value);
                }
                else if((byte & (uint8_t)Fixed_Int_Neg_Mask) == (uint8_t)Type::Fixed_Int_Neg)
                {
                        int64_t value = (int8_t)(byte & Fixed_Int_Neg_Value) - 32;
                        append(value);
                }
                else if(byte == (uint8_t)Type::Int8)
                {
                        int64_t value = (int8_t)data[++index];
                        append(value);
                }
                else if(byte == (uint8_t)Type::Int16)
                {
                        Convert_Byte1 = data[++index];
                        Convert_Byte0 = data[++index];
 
                        int64_t value = Convert.int16;
                        append(value);
                }
                else if(byte == (uint8_t)Type::Int32)
                {
                        Convert_Byte3 = data[++index];
                        Convert_Byte2 = data[++index];
                        Convert_Byte1 = data[++index];
                        Convert_Byte0 = data[++index];
 
                        int64_t value = Convert.int32;
                        append(value);
                }
                else if(byte == (uint8_t)Type::Int64)
                {
                        Convert_Byte7 = data[++index];
                        Convert_Byte6 = data[++index];
                        Convert_Byte5 = data[++index];
                        Convert_Byte4 = data[++index];
                        Convert_Byte3 = data[++index];
                        Convert_Byte2 = data[++index];
                        Convert_Byte1 = data[++index];
                        Convert_Byte0 = data[++index];
 
                        int64_t value = Convert.int64;
                        append(value);
                }
                else if(byte == (uint8_t)Type::Uint8)
                {
                        uint64_t value = data[++index];
                        append(value);
                }
                else if(byte == (uint8_t)Type::Uint16)
                {
                        Convert_Byte1 = data[++index];
                        Convert_Byte0 = data[++index];
 
                        uint64_t value = Convert.uint16;
                        append(value);
                }
                else if(byte == (uint8_t)Type::Uint32)
                {
                        Convert_Byte3 = data[++index];
                        Convert_Byte2 = data[++index];
                        Convert_Byte1 = data[++index];
                        Convert_Byte0 = data[++index];
 
                        uint64_t value = Convert.uint32;
                        append(value);
                }
                else if(byte == (uint8_t)Type::Uint64)
                {
                        Convert_Byte7 = data[++index];
                        Convert_Byte6 = data[++index];
                        Convert_Byte5 = data[++index];
                        Convert_Byte4 = data[++index];
                        Convert_Byte3 = data[++index];
                        Convert_Byte2 = data[++index];
                        Convert_Byte1 = data[++index];
                        Convert_Byte0 = data[++index];
 
                        uint64_t value = Convert.uint64;
                        append(value);
                }
                else if(byte == (uint8_t)Type::Float32)
                {
                        Convert_Byte3 = data[++index];
                        Convert_Byte2 = data[++index];
                        Convert_Byte1 = data[++index];
                        Convert_Byte0 = data[++index];
 
                        float value = Convert.float32;
                        append(value);
                }
                else if(byte == (uint8_t)Type::Float64)
                {
                        Convert_Byte7 = data[++index];
                        Convert_Byte6 = data[++index];
                        Convert_Byte5 = data[++index];
                        Convert_Byte4 = data[++index];
                        Convert_Byte3 = data[++index];
                        Convert_Byte2 = data[++index];
                        Convert_Byte1 = data[++index];
                        Convert_Byte0 = data[++index];
 
                        double value = Convert.float64;
                        append(value);
                }
                else if((byte & (uint8_t)Fixed_Str_Mask) == (uint8_t)Type::Fixed_Str)
                {
                        size_t length = byte & Fixed_Str_Value;
 
                        if(length == 0)
                        {
                                append(std::string_view(""));
                        }
                        else
                        {
                                std::string_view str((char*)&data[++index], length);
                                append(str);
 
                                index += length - 1;
                        }
                }
                else if(byte == (uint8_t)Type::Str8)
                {
                        size_t length = data[++index];
 
                        std::string_view str((char*)&data[++index], length);
                        append(str);
 
                        index += length - 1;
                }
                else if(byte == (uint8_t)Type::Str16)
                {
                        Convert_Byte1 = data[++index];
                        Convert_Byte0 = data[++index];
 
                        size_t length = Convert.uint16;
                        std::string_view str((char*)&data[++index], length);
                        append(str);
 
                        index += length - 1;
                }
                else if(byte == (uint8_t)Type::Str32)
                {
                        Convert_Byte3 = data[++index];
                        Convert_Byte2 = data[++index];
                        Convert_Byte1 = data[++index];
                        Convert_Byte0 = data[++index];
 
                        size_t length = Convert.uint32;
                        std::string_view str((char*)&data[++index], length);
                        append(str);
 
                        index += length - 1;
                }
                else if(byte == (uint8_t)Type::Bin8)
                {
                        size_t length = data[++index];
 
                        std::vector<uint8_t> vector(length, 0);
                        memcpy((void*)vector.data(), (void*)&data[++index], length);
                        index += length - 1;
 
                        append(vector);
                }
                else if(byte == (uint8_t)Type::Bin16)
                {
                        Convert_Byte1 = data[++index];
                        Convert_Byte0 = data[++index];
 
                        size_t length = Convert.uint16;
 
                        std::vector<uint8_t> vector(length, 0);
                        memcpy((void*)vector.data(), (void*)&data[++index], length);
                        index += length - 1;
 
                        append(vector);
                }
                else if(byte == (uint8_t)Type::Bin32)
                {
                        Convert_Byte3 = data[++index];
                        Convert_Byte2 = data[++index];
                        Convert_Byte1 = data[++index];
                        Convert_Byte0 = data[++index];
 
                        size_t length = Convert.uint32;
 
                        std::vector<uint8_t> vector(length, 0);
                        memcpy((void*)vector.data(), (void*)&data[++index], length);
                        index += length - 1;
 
                        append(vector);
                }
        }
}
 
 
std::vector<uint8_t> MessagePack::serialize() noexcept
{
        std::vector<uint8_t> vector;
 
        for(const Object& object : object_vector)
        {
                if(object.type == DataType::Null)
                {
                        vector.push_back((uint8_t)Type::Nill);
                }
                else if(object.type == DataType::Bool)
                {
                        vector.push_back(object.bool_
                                ? (uint8_t)Type::True
                                : (uint8_t)Type::False
                                );
                }
                else if(object.type == DataType::Int64)
                {
                        if(object.int64_ < 0)
                        {
                                if(object.int64_ >= -32)
                                {
                                        vector.push_back((uint8_t)Type::Fixed_Int_Neg
                                                | (uint8_t)(object.int64_ & Fixed_Int_Neg_Value)
                                                );
                                }
                                else if(object.int64_ >= std::numeric_limits<int8_t>::min())
                                {
                                        vector.reserve(vector.size() + 2);
 
                                        vector.push_back((uint8_t)Type::Int8);
                                        vector.push_back((int8_t)object.int64_);
                                }
                                else if(object.int64_ >= std::numeric_limits<int16_t>::min())
                                {
                                        vector.reserve(vector.size() + 3);
 
                                        vector.push_back((uint8_t)Type::Int16);
 
                                        Convert.int16 = (int16_t)object.int64_;
                                        vector.push_back(Convert_Byte1);
                                        vector.push_back(Convert_Byte0);
                                }
                                else if(object.int64_ >= std::numeric_limits<int32_t>::min())
                                {
                                        vector.reserve(vector.size() + 5);
 
                                        vector.push_back((uint8_t)Type::Int32);
 
                                        Convert.int32 = (int32_t)object.int64_;
                                        vector.push_back(Convert_Byte3);
                                        vector.push_back(Convert_Byte2);
                                        vector.push_back(Convert_Byte1);
                                        vector.push_back(Convert_Byte0);
                                }
                                else if(object.int64_ >= std::numeric_limits<int64_t>::min())
                                {
                                        vector.reserve(vector.size() + 9);
 
                                        vector.push_back((uint8_t)Type::Int64);
 
                                        Convert.int64 = (int64_t)object.int64_;
                                        vector.push_back(Convert_Byte7);
                                        vector.push_back(Convert_Byte6);
                                        vector.push_back(Convert_Byte5);
                                        vector.push_back(Convert_Byte4);
                                        vector.push_back(Convert_Byte3);
                                        vector.push_back(Convert_Byte2);
                                        vector.push_back(Convert_Byte1);
                                        vector.push_back(Convert_Byte0);
                                }
                        }
                        else
                        {
                                if(object.int64_ <= std::numeric_limits<int8_t>::max())
                                {
                                        vector.push_back((int8_t)object.int64_);
                                }
                                else if(object.int64_ <= std::numeric_limits<int16_t>::max())
                                {
                                        vector.reserve(vector.size() + 3);
 
                                        vector.push_back((uint8_t)Type::Int16);
 
                                        Convert.int16 = (int16_t)object.int64_;
                                        vector.push_back(Convert_Byte1);
                                        vector.push_back(Convert_Byte0);
                                }
                                else if(object.int64_ <= std::numeric_limits<int32_t>::max())
                                {
                                        vector.reserve(vector.size() + 5);
 
                                        vector.push_back((uint8_t)Type::Int32);
 
                                        Convert.int32 = (int32_t)object.int64_;
                                        vector.push_back(Convert_Byte3);
                                        vector.push_back(Convert_Byte2);
                                        vector.push_back(Convert_Byte1);
                                        vector.push_back(Convert_Byte0);
                                }
                                else if(object.int64_ <= std::numeric_limits<int64_t>::max())
                                {
                                        vector.reserve(vector.size() + 9);
 
                                        vector.push_back((uint8_t)Type::Int64);
 
                                        Convert.int64 = (int64_t)object.int64_;
                                        vector.push_back(Convert_Byte7);
                                        vector.push_back(Convert_Byte6);
                                        vector.push_back(Convert_Byte5);
                                        vector.push_back(Convert_Byte4);
                                        vector.push_back(Convert_Byte3);
                                        vector.push_back(Convert_Byte2);
                                        vector.push_back(Convert_Byte1);
                                        vector.push_back(Convert_Byte0);
                                }
                        }
                }
                else if(object.type == DataType::Uint64)
                {
                        if(object.uint64_ <= std::numeric_limits<uint8_t>::max())
                        {
                                vector.reserve(vector.size() + 2);
 
                                vector.push_back((uint8_t)Type::Uint8);
                                vector.push_back((uint8_t)object.uint64_);
                        }
                        else if(object.uint64_ <= std::numeric_limits<uint16_t>::max())
                        {
                                vector.reserve(vector.size() + 3);
 
                                vector.push_back((uint8_t)Type::Uint16);
 
                                Convert.uint16 = (uint16_t)object.uint64_;
                                vector.push_back(Convert_Byte1);
                                vector.push_back(Convert_Byte0);
                        }
                        else if(object.uint64_ <= std::numeric_limits<uint32_t>::max())
                        {
                                vector.reserve(vector.size() + 5);
 
                                vector.push_back((uint8_t)Type::Uint32);
 
                                Convert.uint32 = (uint32_t)object.uint64_;
                                vector.push_back(Convert_Byte3);
                                vector.push_back(Convert_Byte2);
                                vector.push_back(Convert_Byte1);
                                vector.push_back(Convert_Byte0);
                        }
                        else
                        {
                                vector.reserve(vector.size() + 9);
 
                                vector.push_back((uint8_t)Type::Uint64);
 
                                Convert.uint64 = object.uint64_;
                                vector.push_back(Convert_Byte7);
                                vector.push_back(Convert_Byte6);
                                vector.push_back(Convert_Byte5);
                                vector.push_back(Convert_Byte4);
                                vector.push_back(Convert_Byte3);
                                vector.push_back(Convert_Byte2);
                                vector.push_back(Convert_Byte1);
                                vector.push_back(Convert_Byte0);
                        }
                }
                else if(object.type == DataType::Float)
                {
                        vector.reserve(vector.size() + 5);
 
                        vector.push_back((uint8_t)Type::Float32);
 
                        Convert.float32 = object.float_;
                        vector.push_back(Convert_Byte3);
                        vector.push_back(Convert_Byte2);
                        vector.push_back(Convert_Byte1);
                        vector.push_back(Convert_Byte0);
                }
                else if(object.type == DataType::Double)
                {
                        vector.reserve(vector.size() + 9);
 
                        vector.push_back((uint8_t)Type::Float64);
 
                        Convert.float64 = object.double_;
                        vector.push_back(Convert_Byte7);
                        vector.push_back(Convert_Byte6);
                        vector.push_back(Convert_Byte5);
                        vector.push_back(Convert_Byte4);
                        vector.push_back(Convert_Byte3);
                        vector.push_back(Convert_Byte2);
                        vector.push_back(Convert_Byte1);
                        vector.push_back(Convert_Byte0);
                }
                else if(object.type == DataType::String)
                {
                        const size_t string_length = object.string.size();
 
                        if(string_length <= 31)
                        {
                                vector.reserve(string_length + 1);
 
                                vector.push_back((uint8_t)Type::Fixed_Str
                                        | (uint8_t)string_length
                                        );
 
                                for(const auto& c : object.string)
                                {
                                        vector.push_back((uint8_t)c);
                                }
                        }
                        else if(string_length <= std::numeric_limits<uint8_t>::max())
                        {
                                vector.reserve(string_length + 2);
 
                                vector.push_back((uint8_t)Type::Str8);
                                vector.push_back((uint8_t)string_length);
 
                                for(const auto& c : object.string)
                                {
                                        vector.push_back((uint8_t)c);
                                }
                        }
                        else if(string_length <= std::numeric_limits<uint16_t>::max())
                        {
                                vector.reserve(string_length + 3);
 
                                vector.push_back((uint8_t)Type::Str16);
 
                                Convert.uint16 = (uint16_t)string_length;
                                vector.push_back(Convert_Byte1);
                                vector.push_back(Convert_Byte0);
 
                                for(const auto& c : object.string)
                                {
                                        vector.push_back((uint8_t)c);
                                }
                        }
                        else if(string_length <= std::numeric_limits<uint32_t>::max())
                        {
                                vector.reserve(string_length + 5);
 
                                vector.push_back((uint8_t)Type::Str32);
 
                                Convert.uint32 = (uint32_t)string_length;
                                vector.push_back(Convert_Byte3);
                                vector.push_back(Convert_Byte2);
                                vector.push_back(Convert_Byte1);
                                vector.push_back(Convert_Byte0);
 
                                for(const auto& c : object.string)
                                {
                                        vector.push_back((uint8_t)c);
                                }
                        }
                }
                else if(object.type == DataType::Vector)
                {
                        const size_t vector_length = object.vector.size();
 
                        if(vector_length <= std::numeric_limits<uint8_t>::max())
                        {
                                vector.reserve(vector_length + 2);
 
                                vector.push_back((uint8_t)Type::Bin8);
                                vector.push_back((uint8_t)vector_length);
 
                                vector.insert(vector.end()
                                        , object.vector.begin()
                                        , object.vector.end()
                                        );
                        }
                        else if(vector_length <= std::numeric_limits<uint16_t>::max())
                        {
                                vector.reserve(vector_length + 3);
 
                                vector.push_back((uint8_t)Type::Bin16);
 
                                Convert.uint16 = (uint16_t)vector_length;
                                vector.push_back(Convert_Byte1);
                                vector.push_back(Convert_Byte0);
 
                                vector.insert(vector.end()
                                        , object.vector.begin()
                                        , object.vector.end()
                                        );
                        }
                        else if(vector_length <= std::numeric_limits<uint32_t>::max())
                        {
                                vector.reserve(vector_length + 5);
 
                                vector.push_back((uint8_t)Type::Bin32);
 
                                Convert.uint32 = (uint32_t)vector_length;
                                vector.push_back(Convert_Byte3);
                                vector.push_back(Convert_Byte2);
                                vector.push_back(Convert_Byte1);
                                vector.push_back(Convert_Byte0);
 
                                vector.insert(vector.end()
                                        , object.vector.begin()
                                        , object.vector.end()
                                        );
                        }
                }
        }
 
        return vector;
}
 
#ifdef ZAKERO_MESSAGEPACK_IMPLEMENTATION_TEST
// Nothing to test
#endif
 
// }}} MessagePack
// {{{ MessagePack::Object
 
/*
 * \var MessagePack::Object::bool_
 *
 * \brief A value.
 *
 * \note This variable is a member of a union.
 */
 
/*
 * \var MessagePack::Object::int64_
 *
 * \brief A value.
 *
 * \note This variable is a member of a union.
 */
 
/*
 * \var MessagePack::Object::uint64_
 *
 * \brief A value.
 *
 * \note This variable is a member of a union.
 */
 
/*
 * \var MessagePack::Object::float_
 *
 * \brief A value.
 *
 * \note This variable is a member of a union.
 */
 
/*
 * \var MessagePack::Object::double_
 *
 * \brief A value.
 *
 * \note This variable is a member of a union.
 */
 
MessagePack::Object::Object() noexcept
        : type(DataType::Null)
        , uint64_(0)
{
}
 
 
MessagePack::Object::Object(const Object& object 
        ) noexcept
        : type(object.type)
        , uint64_(0)
{
        switch(type)
        {
                case DataType::Null:                             break;
                case DataType::Bool:   bool_   = object.bool_;   break;
                case DataType::Int64:  int64_  = object.int64_;  break;
                case DataType::Uint64: uint64_ = object.uint64_; break;
                case DataType::Float:  float_  = object.float_;  break;
                case DataType::Double: double_ = object.double_; break;
                case DataType::String: string  = object.string;  break;
                case DataType::Vector: vector  = object.vector;  break;
        }
}
 
 
MessagePack::Object::Object(Object&& object 
        ) noexcept
        : type(object.type)
        , uint64_(0)
{
        switch(type)
        {
                case DataType::Null:                             break;
                case DataType::Bool:   bool_   = object.bool_;   break;
                case DataType::Int64:  int64_  = object.int64_;  break;
                case DataType::Uint64: uint64_ = object.uint64_; break;
                case DataType::Float:  float_  = object.float_;  break;
                case DataType::Double: double_ = object.double_; break;
                case DataType::String: string  = object.string;  break;
                case DataType::Vector: vector  = object.vector;  break;
        }
 
        object.type    = DataType::Null;
        object.uint64_ = 0;
        object.string.clear();
        object.vector.clear();
}
 
 
MessagePack::Object::Object(const bool value 
        ) noexcept
        : type(DataType::Bool)
        , bool_(value)
{
}
 
 
MessagePack::Object::Object(const int64_t value 
        ) noexcept
        : type(DataType::Int64)
        , int64_(value)
{
}
 
 
MessagePack::Object::Object(const uint64_t value 
        ) noexcept
        : type(DataType::Uint64)
        , uint64_(value)
{
}
 
 
MessagePack::Object::Object(const float value 
        ) noexcept
        : type(DataType::Float)
        , float_(value)
{
}
 
 
MessagePack::Object::Object(const double value 
        ) noexcept
        : type(DataType::Double)
        , double_(value)
{
}
 
 
MessagePack::Object::Object(const std::string_view value 
        ) noexcept
        : type(DataType::String)
        , string(value)
{
        //std::cout << "t: '" << (uint32_t)type << "'\n";
        //std::cout << "v: '" << v << "'\n";
        //std::cout << "s: '" << string << "'\n";
}
 
 
MessagePack::Object::Object(std::vector<uint8_t> value 
        ) noexcept
        : type(DataType::Vector)
        , vector(value)
{
}
 
// }}} MessagePack::Object
}
 
#endif // ZAKERO_MESSAGEPACK_IMPLEMENTATION
 
// }}}
 
#endif // zakero_MessagePack_h