wire_type.hpp

Go to the documentation of this file.

// Copyright (C) 2013 iwg molw5
// For conditions of distribution and use, see copyright notice in COPYING

#pragma once

#include <framework/serializable/mutators/endian.hpp>
#include <framework/serializable/mutators/stl_string.hpp>
#include <framework/serializable/mutators/stl_vector.hpp>

#include <framework/protocol_buffers/varint.hpp>
#include <framework/protocol_buffers/frame.hpp>

namespace framework
{
    namespace protocol_buffers
    {
        namespace detail
        {
            template <typename T, typename Enabler = void>
            struct is_wire_type_impl;

            template <typename T, typename Enabler = void>
            struct wire_type_impl;

            template <typename T>
            struct is_integer_type_impl;

            template <typename T>
            struct make_wire_type_impl;
        }

        enum class e_wire_type : uint8_t
        {
            varint = 0,
            fixed_64 = 1,
            length_delimited = 2,
            start_group = 3,
            end_group = 4,
            fixed_32 = 5
        };

        template <e_wire_type Type>
        struct wire_type_base
        {
// GCC bug workaround - www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#580
#if     MAX_GNUC_VERSION(4, 8, 0)
            public:
#else
            template <typename T, typename Enabler>
            friend struct detail::is_wire_type_impl;

            template <typename T, typename Enabler>
            friend struct detail::wire_type_impl;

            private:
#endif
                using protocol_buffers_wire_enabler = void;
                using protocol_buffers_wire_type = std::integral_constant <e_wire_type, Type>;
        };

        template <e_wire_type Type, typename Specification>
        struct wire_type_wrapper :
            wire_type_base <Type>,
            Specification
        {
        };

        template <typename Specification>
        struct length_delimited : 
            serializable::mutator_type <Specification>,
            wire_type_base <e_wire_type::length_delimited>
        {
        };

        template <typename T>
        using is_wire_type = typename detail::is_wire_type_impl <T>::type;

        template <typename T>
        using is_integer_type = typename detail::is_integer_type_impl <T>::type;

        template <typename T>
        using wire_type = typename detail::wire_type_impl <T>::type;

        template <typename T>
        using make_wire_type = typename detail::make_wire_type_impl <T>::type;

        using float_ = wire_type_wrapper <e_wire_type::fixed_32, serializable::little_endian <float>>;
        
        using double_ = wire_type_wrapper <e_wire_type::fixed_64, serializable::little_endian <double>>;
        
        using bool_ = wire_type_wrapper <e_wire_type::varint, varint <bool>>;

        using string_ = wire_type_wrapper <e_wire_type::length_delimited, serializable::stl_string <varint <std::size_t>>>;

        using bytes = string_;

        using int32 = wire_type_wrapper <e_wire_type::varint, varint <int32_t>>;
        
        using int64 = wire_type_wrapper <e_wire_type::varint, varint <int64_t>>;
        
        using uint32 = wire_type_wrapper <e_wire_type::varint, varint <uint32_t>>;
        
        using uint64 = wire_type_wrapper <e_wire_type::varint, varint <uint64_t>>;
        
        using sint32 = wire_type_wrapper <e_wire_type::varint, zig_zag <int32_t>>;
        
        using sint64 = wire_type_wrapper <e_wire_type::varint, zig_zag <int64_t>>;
        
        using fixed32 = wire_type_wrapper <e_wire_type::fixed_32, serializable::little_endian <uint32_t>>;
        
        using fixed64 = wire_type_wrapper <e_wire_type::fixed_64, serializable::little_endian <uint64_t>>;
        
        using sfixed32 = wire_type_wrapper <e_wire_type::fixed_32, serializable::little_endian <int32_t>>;
        
        using sfixed64 = wire_type_wrapper <e_wire_type::fixed_64, serializable::little_endian <int64_t>>;
    }
}

#include <framework/protocol_buffers/wire_type.inl>