fast_binary.h

// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
#pragma once
 
#include <bond/core/config.h>
 
#include "encoding.h"
 
#include <bond/core/bond_version.h>
#include <bond/core/detail/checked.h>
#include <bond/core/detail/recursionguard.h>
 
#include <boost/call_traits.hpp>
#include <boost/noncopyable.hpp>
 
/*
                     .----------.--------------.   .----------.---------.
   struct hierarchy  |  struct  | BT_STOP_BASE |...|  struct  | BT_STOP |
                     '----------'--------------'   '----------'---------'
 
                     .----------.----------.   .----------.
   struct            |  field   |  field   |...|  field   |
                     '----------'----------'   '----------'
 
                     .------.----.----------.
   field             | type | id |  value   |
                     '------'----'----------'
 
                     .---.---.---.---.---.---.---.---.                           i - id bits
   type              | 0 | 0 | 0 | t | t | t | t | t |                           t - type bits
                     '---'---'---'---'---'---'---'---'                           v - value bits
                                   4               0
 
   id                .---.   .---.---.   .---.
                     | i |...| i | i |...| i |
                     '---'   '---'---'   '---'
                       7       0   15      8
 
                                            .---.---.---.---.---.---.---.---.
   value             bool                   |   |   |   |   |   |   |   | v |
                                            '---'---'---'---'---'---'---'---'
                                                                          0
 
                     integer,               little endian
                     float, double
 
 
                                            .-------.------------.
                     string, wstring        | count | characters |
                                            '-------'------------'
 
                           count            variable encoded uint32 count of 1-byte (for
                                            string) or 2-byte (for wstring) Unicode code
                                            units
 
                           characters       1-byte UTF-8 code units (for string) or 2-byte
                                            UTF-16LE code units (for wstring)
 
 
                                            .-------.-------.-------.
                     blob, list, set,       | type  | count | items |
                     vector, nullable       '-------'-------'-------'
 
                                            .---.---.---.---.---.---.---.---.
                           type             |   |   |   | t | t | t | t | t |
                                            '---'---'---'---'---'---'---'---'
                                                          4               0
 
                           count            variable uint32 count of items
 
                           items            each item encoded according to its type
 
 
                                            .----------.------------.-------.-----.-------.
                     map                    | key type | value type | count | key | value |
                                            '----------'------------'-------'-----'-------'
 
                                            .---.---.---.---.---.---.---.---.
                            key type,       |   |   |   | t | t | t | t | t |
                            value type      '---'---'---'---'---'---'---'---'
                                                          4               0
 
                            count           variable encoded uint32 count of {key,mapped} pairs
 
                            key, mapped     each item encoded according to its type
 
 
   variable uint32
                     .---.---.   .---..---.---.   .---..---.---.   .---..---.---.   .---..---.---.---.---.   .---.
                     | 1 | v |...| v || 1 | v |...| v || 1 | v |...| v || 1 | v |...| v || 0 | 0 | 0 | v |...| v |
                     '---'---'   '---''---'---'   '---''---'---'   '---''---'---'   '---''---'---'---'---'   '---'
                           6       0        13      7        20      14       27      21               31      28
 
                     1 to 5 bytes, high bit of every byte indicates if there is another byte
 
*/
 
namespace bond
{
 
template <typename BufferT>
class FastBinaryWriter;

template <typename BufferT>
class FastBinaryReader
{
public:
    typedef BufferT                             Buffer;
    typedef DynamicParser<FastBinaryReader&>   Parser;
    typedef FastBinaryWriter<Buffer>           Writer;
 
    BOND_STATIC_CONSTEXPR uint16_t magic = FAST_PROTOCOL;
    BOND_STATIC_CONSTEXPR uint16_t version = v1;

    FastBinaryReader(typename boost::call_traits<Buffer>::param_type buffer)
       : _input(buffer)
    {}
    FastBinaryReader(typename boost::call_traits<Buffer>::param_type buffer) {…}
 
 
    // This identical to compiler generated ctor except for noexcept declaration.
    // Copy ctor that is explicitly declared throw() is needed for boost::variant
    // to use optimized code path.
    FastBinaryReader(const FastBinaryReader& that) BOND_NOEXCEPT
        : _input(that._input)
    {}
    FastBinaryReader(const FastBinaryReader& that) BOND_NOEXCEPT {…}
 

    bool operator==(const FastBinaryReader& rhs) const
    {
        return _input == rhs._input;
    }
    bool operator==(const FastBinaryReader& rhs) const {…}
 

    typename boost::call_traits<Buffer>::const_reference
    GetBuffer() const
    {
        return _input;
    }
    GetBuffer() const {…}
 

    typename boost::call_traits<Buffer>::reference
    GetBuffer()
    {
        return _input;
    }
    GetBuffer() {…}
 
 
    bool ReadVersion()
    {
        uint16_t magic_value, version_value;
 
        _input.Read(magic_value);
        _input.Read(version_value);
 
        return magic_value == FastBinaryReader::magic
            && version_value <= FastBinaryReader::version;
    }
 
 
    // Read for primitive types
    template <typename T>
    typename boost::disable_if<is_string_type<T> >::type
    Read(T& value)
    {
        _input.Read(value);
    }
 
 
    // Read for strings
    template <typename T>
    typename boost::enable_if<is_string_type<T> >::type
    Read(T& value)
    {
        uint32_t length = 0;
 
        ReadVariableUnsigned(_input, length);
 
        constexpr uint8_t charSize = static_cast<uint8_t>(sizeof(typename detail::string_char_int_type<T>::type));
        uint32_t numStringBytes = detail::checked_multiply(length, charSize);
        if (!_input.CanRead(numStringBytes))
            OutOfBoundStringSizeException();
 
        detail::ReadStringData(_input, value, length);
    }
 
 
    // Read for blob
    void Read(blob& value, uint32_t size)
    {
        _input.Read(value, size);
    }
 
    // Does the reader have enough input buffer left to read an array of T?
    template<typename T>
    bool CanReadArray(uint32_t num_elems)
    {
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:4127)
#endif
 
        BOND_IF_CONSTEXPR(is_string_type<T>::value)
        {
            return _input.CanRead(num_elems);
        }
        else
        {
            // We will need to read num_elems instances of T. This will not overflow because
            // num_elems < 2^32 and we call this only for primitive types, so sizeof(T) <= 8.
            uint64_t num_bytes = static_cast<uint64_t>(num_elems) * sizeof(T);
            return (num_bytes >> 32 == 0) && _input.CanRead(num_bytes & 0xffffffff);
            }
 
#ifdef _MSC_VER
#pragma warning(pop)
#endif
    }
 
    void ReadStructBegin()
    {}
 
 
    void ReadStructEnd()
    {}
 
 
    void ReadFieldBegin(BondDataType& type, uint16_t& id)
    {
        ReadType(type);
 
        if (type != BT_STOP && type != BT_STOP_BASE)
            Read(id);
        else
            id = 0;
    }
 
 
    void ReadFieldEnd()
    {}
 
 
    void ReadContainerBegin(uint32_t& size, BondDataType& type)
    {
        ReadType(type);
        ReadVariableUnsigned(_input, size);
    }
 
 
    // container of 2-tuple (e.g. map)
    void ReadContainerBegin(uint32_t& size, std::pair<BondDataType, BondDataType>& type)
    {
        ReadType(type.first);
        ReadType(type.second);
        ReadVariableUnsigned(_input, size);
    }
 
 
    void ReadContainerEnd()
    {}
 
 
    template <typename T>
    void Skip()
    {
        SkipType<get_type_id<T>::value>();
    }
 
 
    template <typename T>
    void Skip(const bonded<T, FastBinaryReader&>&)
    {
        SkipType<BT_STRUCT>();
    }
 
    void Skip(BondDataType type)
    {
        SkipType(type);
    }
 
protected:
    void ReadType(BondDataType& type)
    {
        uint8_t byte;
 
        Read(byte);
        type = static_cast<BondDataType>(byte);
    }
 
    using BT = BondDataType;
 
    template <BT T>
    typename boost::enable_if_c<(T == BT_BOOL || T == BT_UINT8 || T == BT_INT8)>::type
    SkipType(uint32_t size = 1)
    {
        _input.Skip(detail::checked_multiply(size, sizeof(uint8_t)));
    }
 
    template <BT T>
    typename boost::enable_if_c<(T == BT_UINT16 || T == BT_INT16)>::type
    SkipType(uint32_t size = 1)
    {
        _input.Skip(detail::checked_multiply(size, sizeof(uint16_t)));
    }
 
    template <BT T>
    typename boost::enable_if_c<(T == BT_UINT32 || T == BT_INT32)>::type
    SkipType(uint32_t size = 1)
    {
        _input.Skip(detail::checked_multiply(size, sizeof(uint32_t)));
    }
 
    template <BT T>
    typename boost::enable_if_c<(T == BT_UINT64 || T == BT_INT64)>::type
    SkipType(uint32_t size = 1)
    {
        _input.Skip(detail::checked_multiply(size, sizeof(uint64_t)));
    }
 
    template <BT T>
    typename boost::enable_if_c<(T == BT_FLOAT)>::type
    SkipType(uint32_t size = 1)
    {
        _input.Skip(detail::checked_multiply(size, sizeof(float)));
    }
 
    template <BT T>
    typename boost::enable_if_c<(T == BT_DOUBLE)>::type
    SkipType(uint32_t size = 1)
    {
        _input.Skip(detail::checked_multiply(size, sizeof(double)));
    }
 
    template <BT T>
    typename boost::enable_if_c<(T == BT_STRING)>::type
    SkipType()
    {
        uint32_t size = 0;
 
        ReadVariableUnsigned(_input, size);
        _input.Skip(size);
    }
 
    template <BT T>
    typename boost::enable_if_c<(T == BT_WSTRING)>::type
    SkipType()
    {
        uint32_t size = 0;
 
        ReadVariableUnsigned(_input, size);
        _input.Skip(detail::checked_multiply(size, sizeof(uint16_t)));
    }
 
    template <BT T>
    typename boost::enable_if_c<(T == BT_STRUCT)>::type
    SkipType()
    {
        bond::detail::RecursionGuard guard;
 
        for (;;)
        {
            ReadStructBegin();
 
            uint16_t     id;
            BondDataType field_type;
 
            for (ReadFieldBegin(field_type, id);
                    field_type != BT_STOP && field_type != BT_STOP_BASE;
                    ReadFieldEnd(), ReadFieldBegin(field_type, id))
            {
                SkipType(field_type);
            }
 
            ReadStructEnd();
 
            if (field_type == BT_STOP)
                break;
        }
    }
 
    template <BT T>
    typename boost::enable_if_c<(T == BT_SET || T == BT_LIST)>::type
    SkipType()
    {
        BondDataType element_type;
        uint32_t size;
 
        bond::detail::RecursionGuard guard;
 
        ReadContainerBegin(size, element_type);
        SkipType(element_type, size);
        ReadContainerEnd();
    }
 
    template <BT T>
    typename boost::enable_if_c<(T == BT_MAP)>::type
    SkipType()
    {
        std::pair<BondDataType, BondDataType> element_type;
        uint32_t size;
 
        bond::detail::RecursionGuard guard;
 
        ReadContainerBegin(size, element_type);
        for (int64_t i = 0; i < size; ++i)
        {
            SkipType(element_type.first);
            SkipType(element_type.second);
        }
        ReadContainerEnd();
    }
 
    template <BT T>
    typename boost::enable_if_c<(T == BT_STRING || T == BT_WSTRING || T == BT_STRUCT
                                || T == BT_SET || T == BT_LIST || T == BT_MAP)>::type
    SkipType(uint32_t size)
    {
        for (int64_t i = 0; i < size; ++i)
        {
            SkipType<T>();
        }
    }
 
    template <typename... Args>
    void SkipType(BondDataType type, Args&&... args)
    {
        switch (type)
        {
            case BT_BOOL:
            case BT_UINT8:
            case BT_INT8:
                SkipType<BT_BOOL>(std::forward<Args>(args)...);
                break;
 
            case BT_UINT16:
            case BT_INT16:
                SkipType<BT_UINT16>(std::forward<Args>(args)...);
                break;
 
            case BT_UINT32:
            case BT_INT32:
                SkipType<BT_UINT32>(std::forward<Args>(args)...);
                break;
 
            case BT_UINT64:
            case BT_INT64:
                SkipType<BT_UINT64>(std::forward<Args>(args)...);
                break;
 
            case BT_FLOAT:
                SkipType<BT_FLOAT>(std::forward<Args>(args)...);
                break;
 
            case BT_DOUBLE:
                SkipType<BT_DOUBLE>(std::forward<Args>(args)...);
                break;
 
            case BT_STRING:
                SkipType<BT_STRING>(std::forward<Args>(args)...);
                break;
 
            case BT_WSTRING:
                SkipType<BT_WSTRING>(std::forward<Args>(args)...);
                break;
 
            case BT_SET:
            case BT_LIST:
                SkipType<BT_SET>(std::forward<Args>(args)...);
                break;
 
            case BT_MAP:
                SkipType<BT_MAP>(std::forward<Args>(args)...);
                break;
 
            case BT_STRUCT:
                SkipType<BT_STRUCT>(std::forward<Args>(args)...);
                break;
 
            default:
                bond::UnknownDataTypeException();
                break;
        }
    }
 
    Buffer _input;
};
class FastBinaryReader {…};
 
template <typename Buffer>
BOND_CONSTEXPR_OR_CONST uint16_t FastBinaryReader<Buffer>::magic;
 
template <typename Buffer>
BOND_CONSTEXPR_OR_CONST uint16_t FastBinaryReader<Buffer>::version;
 

template <typename BufferT>
class FastBinaryWriter
    : boost::noncopyable
{
public:
    typedef BufferT                     Buffer;
    typedef FastBinaryReader<Buffer>   Reader;

    FastBinaryWriter(Buffer& buffer)
        : _output(buffer)
    {
    }
    FastBinaryWriter(Buffer& buffer) {…}

    typename boost::call_traits<Buffer>::reference
    GetBuffer()
    {
        return _output;
    }
    GetBuffer() {…}
 
    void WriteVersion()
    {
        _output.Write(Reader::magic);
        _output.Write(Reader::version);
    }
 
    //
    // Write methods
    //
    void WriteStructBegin(const Metadata& /*metadata*/, bool /*base*/)
    {}
 
    void WriteStructEnd(bool base = false)
    {
        WriteType(base ? BT_STOP_BASE : BT_STOP);
    }
 
    template <typename T>
    void WriteField(uint16_t id, const bond::Metadata& /*metadata*/, const T& value)
    {
        WriteFieldBegin(get_type_id<T>::value, id);
        Write(value);
        WriteFieldEnd();
    }
 
    void WriteFieldBegin(BondDataType type, uint16_t id, const bond::Metadata& /*metadata*/)
    {
        WriteFieldBegin(type, id);
    }
 
    void WriteFieldBegin(BondDataType type, uint16_t id)
    {
        WriteType(type);
        Write(id);
    }
 
    void WriteFieldEnd()
    {}
 
    void WriteContainerBegin(uint32_t size, BondDataType type)
    {
        WriteType(type);
        WriteVariableUnsigned(_output, size);
    }
 
    // container of 2-tuples (e.g. map)
    void WriteContainerBegin(uint32_t size, std::pair<BondDataType, BondDataType> type)
    {
        WriteType(type.first);
        WriteType(type.second);
        WriteVariableUnsigned(_output, size);
    }
 
    void WriteContainerEnd()
    {}
 
    // Write for primitive types
    template<typename T>
    typename boost::disable_if<is_string_type<T> >::type
    Write(const T& value)
    {
        _output.Write(value);
    }
 
    // Write for strings
    template <typename T>
    typename boost::enable_if<is_string_type<T> >::type
    Write(const T& value)
    {
        uint32_t length = string_length(value);
 
        WriteVariableUnsigned(_output, length);
        detail::WriteStringData(_output, value, length);
    }
 
    // Write for blob
    void Write(const blob& value)
    {
        _output.Write(value);
    }
 
protected:
    void WriteType(BondDataType type)
    {
        _output.Write(static_cast<uint8_t>(type));
    }
 
    Buffer& _output;
};
class FastBinaryWriter {…};
 
 
}; // namespace bond