base_types.hpp

Go to the documentation of this file.

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

#pragma once

#include <type_traits>
#include <algorithm>

#include <framework/common/common_macros.hpp>

namespace framework
{
    namespace serializable
    {
        template <typename T>
        using reference_base = typename std::remove_cv <typename std::remove_reference <T>::type>::type;

        template <typename Input, typename T>
        typename std::enable_if <
            std::is_arithmetic <T>::value,
            bool
        >::type read_dispatch (T*, Input& in, T& out);

        template <typename Output, typename T>
        typename std::enable_if <
            std::is_arithmetic <T>::value,
            bool
        >::type write_dispatch (T*, T in, Output& out);

        template <typename Specification, typename... Args>
        FRAMEWORK_ALWAYS_INLINE
        auto dispatch_read (Args&&... args) ->
        decltype(read_dispatch(
            static_cast <Specification*> (nullptr), 
            std::forward <Args> (args)...))
        {
            return read_dispatch(
                static_cast <Specification*> (nullptr),
                std::forward <Args> (args)...);
        }
        
        template <typename Specification, typename... Args>
        FRAMEWORK_ALWAYS_INLINE
        auto dispatch_write (Args&&... args) ->
        decltype(write_dispatch(
            static_cast <Specification*> (nullptr),
            std::forward <Args> (args)...))
        {
            return write_dispatch(
                static_cast <Specification*> (nullptr),
                std::forward <Args> (args)...);
        }

        template <std::size_t N, typename Stream>
        bool stream_read (Stream&& stream, void* s);

        template <typename Stream>
        bool stream_read (Stream&& stream, void* s, std::size_t n);

        template <std::size_t N, typename Stream>
        bool stream_write (Stream&& stream, void const* s);

        template <typename Stream>
        bool stream_write (Stream&& stream, void const* s, std::size_t n);

        template <typename Input, typename Output>
        FRAMEWORK_ALWAYS_INLINE
        auto read (Input&& in, Output&& out) ->
        decltype(dispatch_read <reference_base <Output>> (
            std::forward <Input> (in),
            std::forward <Output> (out)))
        {
            return dispatch_read <reference_base <Output>> (
                std::forward <Input> (in),
                std::forward <Output> (out));
        }

        template <typename Input, typename Output>
        FRAMEWORK_ALWAYS_INLINE
        auto write (Input&& in, Output&& out) ->
        decltype(dispatch_write <reference_base <Input>> (
            std::forward <Input> (in),
            std::forward <Output> (out)))
        {
            return dispatch_write <reference_base <Input>> (
                std::forward <Input> (in),
                std::forward <Output> (out));
        }
    }
}

#include <framework/serializable/base_types.inl>