protocol_buffers.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 <bitset>
#include <atomic>

#include <framework/common/common_macros.hpp>
#include <framework/serializable/common_macros.hpp>
#include <framework/serializable/containers/value.hpp>
#include <framework/serializable/containers/alias.hpp>
#include <framework/protocol_buffers/base_types.hpp>
#include <framework/protocol_buffers/fixed_tag.hpp>
#include <framework/protocol_buffers/wire_type.hpp>
#include <framework/protocol_buffers/field_type.hpp>
#include <framework/protocol_buffers/message_switch.hpp>

namespace framework
{
    namespace protocol_buffers
    {
        template <typename... Types>
        class message : 
            public serializable::custom_serializable <message <Types...>, Types...>,
            public serializable::comparable <message <Types...>>,
            public wire_type_base <e_wire_type::length_delimited>
        {
            private:
                DEFINE_BASE_TEMPLATE(message <Types...>);
                using serializable_base = serializable::custom_serializable <message <Types...>, Types...>;

            public:
                message () = default;
                message (message const&) = default;
                message (message&&) = default;
                message& operator= (message const&) = default;
                message& operator= (message&&) = default;

                template <typename... Args>
                message (Args&&... args)
                    : serializable_base(std::forward <Args> (args)...)
                {
                }

                message (std::tuple <>)
                    : message ()
                {
                }
                
                template <typename... Args>
                message (std::tuple <Args...>&& args)
                    : message (
                        std::forward <std::tuple <Args...>> (args), 
                        static_cast <make_indices <sizeof... (Args)>*> (nullptr))
                {
                }

            private:
                template <typename... Args, typename... Indices>
                message (std::tuple <Args...> args, pack_container <Indices...>*)
                    : serializable_base(std::forward <Args> (std::get <Indices::value> (args))...)
                {
                }

           public:
                template <typename Name, typename... Args>
                auto get (Args&&... args) const ->
                decltype(std::declval <base <Name>> ().get(std::forward <Args> (args)...))
                {
                    return base <Name>::get(std::forward <Args> (args)...);
                }

                template <typename Name, typename... Args>
                auto set (Args&&... args) ->
                decltype(std::declval <base <Name>> ().set(std::forward <Args> (args)...))
                {
                    return base <Name>::set(std::forward <Args> (args)...);
                }

                template <typename Name, typename... Args>
                auto check (Args&&... args) const ->
                decltype(std::declval <base <Name>> ().check(std::forward <Args> (args)...))
                {
                    return base <Name>::check(std::forward <Args> (args)...);
                }

                template <typename Name, typename... Args>
                auto clear (Args&&... args) ->
                decltype(std::declval <base <Name>> ().clear(std::forward <Args> (args)...))
                {
                    return base <Name>::clear(std::forward <Args> (args)...);
                }

                template <typename Name, typename... Args>
                auto mutate (Args&&... args) ->
                decltype(std::declval <base <Name>> ().mutate(std::forward <Args> (args)...))
                {
                    return base <Name>::mutate(std::forward <Args> (args)...);
                }
        };

        template <typename... Types>
        class group : 
            public serializable::custom_serializable <group <Types...>, Types...>,
            public serializable::comparable <group <Types...>>,
            public wire_type_base <e_wire_type::start_group>
        {
            private:
                DEFINE_BASE_TEMPLATE(group <Types...>);
                using serializable_base = serializable::custom_serializable <group <Types...>, Types...>;

            public:
                group () = default;
                group (group const&) = default;
                group (group&&) = default;
                group& operator= (group const&) = default;
                group& operator= (group&&) = default;

                template <typename... Args>
                group (Args&&... args)
                    : serializable_base(std::forward <Args> (args)...)
                {
                }

                group (std::tuple <>)
                    : group ()
                {
                }
                
                template <typename... Args>
                group (std::tuple <Args...>&& args)
                    : group (
                        std::forward <std::tuple <Args...>> (args), 
                        static_cast <make_indices <sizeof... (Args)>*> (nullptr))
                {
                }

            private:
                template <typename... Args, typename... Indices>
                group (std::tuple <Args...> args, pack_container <Indices...>*)
                    : serializable_base(std::forward <Args> (std::get <Indices::value> (args))...)
                {
                }

           public:
                template <typename Name, typename... Args>
                auto get (Args&&... args) const ->
                decltype(std::declval <base <Name>> ().get(std::forward <Args> (args)...))
                {
                    return base <Name>::get(std::forward <Args> (args)...);
                }

                template <typename Name, typename... Args>
                auto set (Args&&... args) ->
                decltype(std::declval <base <Name>> ().set(std::forward <Args> (args)...))
                {
                    return base <Name>::set(std::forward <Args> (args)...);
                }

                template <typename Name, typename... Args>
                auto check (Args&&... args) const ->
                decltype(std::declval <base <Name>> ().check(std::forward <Args> (args)...))
                {
                    return base <Name>::check(std::forward <Args> (args)...);
                }

                template <typename Name, typename... Args>
                auto clear (Args&&... args) ->
                decltype(std::declval <base <Name>> ().clear(std::forward <Args> (args)...))
                {
                    return base <Name>::clear(std::forward <Args> (args)...);
                }
                
                template <typename Name, typename... Args>
                auto mutate (Args&&... args) ->
                decltype(std::declval <base <Name>> ().mutate(std::forward <Args> (args)...))
                {
                    return base <Name>::mutate(std::forward <Args> (args)...);
                }
        };

        template <typename SizeFrame, typename Input, typename Output>
        bool write_to_string (Input&& in, Output&& out)
        {
            using type = typename std::remove_cv <typename std::remove_reference <Input>::type>::type;

            SizeFrame size;
            if (FRAMEWORK_EXPECT_FALSE(!serializable::write(in, size)))
                return false;

            out.resize(static_cast <std::size_t> (size));
            auto const begin = &out[0];
            auto const end = &out[out.size()];
            auto it = begin;
            if (FRAMEWORK_EXPECT_FALSE(!serializable::dispatch_write <type> (in, begin, end, it)))
                return false;

            out.resize(static_cast <std::size_t> (it - begin));
            return true;
        }

        template <typename SizeFrame, typename Input, typename Output>
        bool write_to_frame (Input&& in, Output&& out)
        {
            SizeFrame size;
            if (FRAMEWORK_EXPECT_FALSE(!serializable::write(in, size)))
                return false;

            std::size_t serialized_size;
            out.resize(static_cast <std::size_t> (size));

            // Destroy the frame before invalidating the iterators
            {
#ifdef NDEBUG
                raw_output_frame <false> frame {&out[0], &out[out.size()]};
#else
                raw_output_frame <true> frame {&out[0], &out[out.size()]};
#endif
                auto const begin = frame.tellp();
                if (FRAMEWORK_EXPECT_FALSE(!serializable::write(in, frame)))
                    return false;
                auto const end = frame.tellp();
                serialized_size = static_cast <std::size_t> (end - begin);
            }

            out.resize(serialized_size);
            return true;
        }

        template <typename Input, typename Output>
        bool write_to_string_fast (Input&& in, Output&& out)
        {
            return write_to_string <max_size_frame> (std::forward <Input> (in), std::forward <Output> (out));
        }

        template <typename Input, typename Output>
        bool write_to_string_tight (Input&& in, Output&& out)
        {
            return write_to_string <size_frame> (std::forward <Input> (in), std::forward <Output> (out));
        }

        template <typename Input, typename Output>
        bool write_to_frame_fast (Input&& in, Output&& out)
        {
            return write_to_frame <max_size_frame> (std::forward <Input> (in), std::forward <Output> (out));
        }

        template <typename Input, typename Output>
        bool write_to_frame_tight (Input&& in, Output&& out)
        {
            return write_to_frame <size_frame> (std::forward <Input> (in), std::forward <Output> (out));
        }

        template <typename Input>
        bool write_to_array (Input&& in, char* s, std::size_t& n)
        {
            using type = typename std::remove_cv <typename std::remove_reference <Input>::type>::type;

            max_size_frame max_size;
            if (FRAMEWORK_EXPECT_FALSE(!write(in, max_size)))
                return false;
            if (FRAMEWORK_EXPECT_FALSE(static_cast <std::size_t> (max_size) > n))
            {
                size_frame size;
                if (FRAMEWORK_EXPECT_FALSE(!write(in, size)))
                    return false;
                if (FRAMEWORK_EXPECT_FALSE(static_cast <std::size_t> (size) > n))
                    return false;
            }

            char* const begin = &s[0];
            char* const end = &s[n];
            char* it = begin;
            if (FRAMEWORK_EXPECT_FALSE(!serializable::dispatch_write <type> (in, begin, end, it)))
                return false;

            n = static_cast <std::size_t> (it - begin);
            return true;
        }
        
        template <typename Input>
        bool write_to_ostream (Input&& in, std::ostream& out)
        {
            return serializable::write(std::forward <Input> (in), out);
        }

        template <typename Output>
        bool read_from_array (char const* s, std::size_t n, Output&& out)
        {
            using type = typename std::remove_cv <typename std::remove_reference <Output>::type>::type;

            char const* const begin = s;
            char const* const end = s+n;
            char const* it = begin;
            
            return serializable::dispatch_read <type> (begin, end, it, std::forward <Output> (out));
        }

        template <typename Input, typename Output>
        bool read_from_string (Input&& in, Output&& out)
        {
            return read_from_array(&in[0], in.size(), std::forward <Output> (out));
        }

        template <typename Input, typename Output>
        bool read_from_frame (Input&& in, Output&& out)
        {
            raw_input_frame frame {&in[0], &in[in.size()]};
            return serializable::read(frame, out);
        }
        
        template <typename Output>
        bool read_from_istream (std::istream& in, Output&& out)
        {
            return serializable::read(in, std::forward <Output> (out));
        }
    }
}

#include <framework/protocol_buffers/protocol_buffers.inl>