io_runtimetype_features.h

//   Copyright Giuseppe Campana (giu.campana@gmail.com) 2016-2018.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          http://www.boost.org/LICENSE_1_0.txt)

#pragma once
#include <density/density_common.h>
#include <density/dynamic_reference.h>
#include <density/runtime_type.h>
#include <istream>
#include <ostream>

namespace density
{
    class f_istream
    {
      public:
        template <typename TARGET_TYPE> constexpr static f_istream make() noexcept
        {
            return f_istream{&invoke<TARGET_TYPE>};
        }

        void operator()(std::istream & i_istream, void * i_dest) const
        {
            DENSITY_ASSUME(i_dest != nullptr);
            (*m_function)(i_istream, i_dest);
        }

      private:
        using Function = void (*)(std::istream & i_istream, void * i_dest);
        Function const m_function;
        constexpr f_istream(Function i_function) noexcept : m_function(i_function) {}
        template <typename TARGET_TYPE> static void invoke(std::istream & i_istream, void * i_dest)
        {
            const auto derived = static_cast<TARGET_TYPE *>(i_dest);
            i_istream >> *derived;
        }
    };

    class f_ostream
    {
      public:
        template <typename TARGET_TYPE> constexpr static f_ostream make() noexcept
        {
            return f_ostream{&invoke<TARGET_TYPE>};
        }

        void operator()(std::ostream & i_ostream, const void * i_dest) const
        {
            DENSITY_ASSUME(i_dest != nullptr);
            (*m_function)(i_ostream, i_dest);
        }

      private:
        using Function = void (*)(std::ostream & i_ostream, const void * i_dest);
        Function const m_function;
        constexpr f_ostream(Function i_function) noexcept : m_function(i_function) {}
        template <typename TARGET_TYPE>
        static void invoke(std::ostream & i_ostream, const void * i_dest)
        {
            const auto derived = static_cast<const TARGET_TYPE *>(i_dest);
            i_ostream << *derived;
        }
    };

    template <
      typename... FEATURES,
      typename =
        typename std::enable_if<has_features<feature_list<FEATURES...>, f_istream>::value>::type>
    inline std::istream & operator>>(
      std::istream & i_source_stream, const dynamic_reference<runtime_type<FEATURES...>> & i_ptr)
    {
        i_ptr.type().template get_feature<f_istream>()(i_source_stream, i_ptr.address());
        return i_source_stream;
    }

    template <
      typename... FEATURES,
      typename =
        typename std::enable_if<has_features<feature_list<FEATURES...>, f_ostream>::value>::type>
    inline std::ostream & operator<<(
      std::ostream & i_dest_stream, const dynamic_reference<runtime_type<FEATURES...>> & i_ref)
    {
        i_ref.type().template get_feature<f_ostream>()(i_dest_stream, i_ref.address());
        return i_dest_stream;
    }

} // namespace density