runtime_type.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/detail/runtime_type_internals.h>
#include <functional> // for std::hash
#include <limits>
#include <stdexcept>
#include <tuple>
#include <type_traits>
#include <typeinfo>
#include <utility>

namespace density
{
    template <typename... FEATURES> struct feature_list;
    template <> struct feature_list<> /* an empty feature_list gives an empty tuple */
    {
        using tuple_type = std::tuple<>;
    };
    template <typename FIRST_FEATURE, typename... OTHER_FEATURES>
    struct feature_list<FIRST_FEATURE, OTHER_FEATURES...> /* the generic case, to 
        handle types satisfying [TypeFeature](TypeFeature_requirements.html) */
    {
        static_assert(
          !std::is_void<FIRST_FEATURE>::value, "[cv-qualified] void does not satisfy TypeFeature");

        static_assert(
          std::is_literal_type<FIRST_FEATURE>::value, "a TypeFeature must be a literal type");

        using tuple_type = detail::Tuple_Merge_t<

          // add FIRST_FEATURE to the tuple
          std::tuple<FIRST_FEATURE>,

          /* use recursively feature_list to add the other features, but removes 
             FIRST_FEATURE from the result */
          detail::
            Tuple_Remove_t<typename feature_list<OTHER_FEATURES...>::tuple_type, FIRST_FEATURE>>;
    };
    template <typename... GROUPED_FEATURES, typename... OTHER_FEATURES>
    struct feature_list<feature_list<GROUPED_FEATURES...>, OTHER_FEATURES...> /* handle 
        nesting of feature_list's */
    {
        using tuple_type = detail::Tuple_Merge_t<

          // add to the tuple GROUPED_FEATURES (the nested features)
          typename feature_list<GROUPED_FEATURES...>::tuple_type,

          // add to the tuple the remaining features with the features already in GROUPED_FEATURES removed
          detail::Tuple_Diff_t<
            typename feature_list<OTHER_FEATURES...>::tuple_type,
            typename feature_list<GROUPED_FEATURES...>::tuple_type>

          >;
    };
    template <typename... OTHER_FEATURES>
    struct feature_list<f_none, OTHER_FEATURES...> /* strip f_none from the feature list*/
    {
        using tuple_type = typename feature_list<OTHER_FEATURES...>::tuple_type;
    };

    struct f_none
    {
    };

    class f_size
    {
      public:
        template <typename TARGET_TYPE> constexpr static f_size make() noexcept
        {
            // constraining the size of types allows to reduce the runtime checks to detect pointer arithmetic overflow
            static_assert(
              sizeof(TARGET_TYPE) < (std::numeric_limits<uintptr_t>::max)() / 4,
              "Type with size >= 1/4 of the address space are not supported");

            return f_size{sizeof(TARGET_TYPE)};
        }

        DENSITY_NODISCARD constexpr size_t operator()() const noexcept { return m_size; }

      private:
        constexpr f_size(size_t i_size) noexcept : m_size(i_size) {}
        size_t const m_size;
    };

    class f_alignment
    {
      public:
        template <typename TARGET_TYPE> constexpr static f_alignment make() noexcept
        {
            // constraining the alignment of types allows to reduce the runtime checks to detect pointer arithmetic overflow
            static_assert(
              alignof(TARGET_TYPE) < (std::numeric_limits<uintptr_t>::max)() / 4,
              "Type with alignment >= 1/4 of the address space are not supported");

            return f_alignment{alignof(TARGET_TYPE)};
        }

        DENSITY_NODISCARD constexpr size_t operator()() const noexcept { return m_alignment; }

      private:
        constexpr f_alignment(size_t i_alignment) noexcept : m_alignment(i_alignment) {}
        size_t const m_alignment;
    };

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

        void operator()(void * i_dest) const { (*m_function)(i_dest); }

      private:
        using Function = void (*)(void * i_dest);
        Function const m_function;
        constexpr f_default_construct(Function i_function) : m_function(i_function) {}
        template <typename TARGET_TYPE> static void invoke(void * i_dest)
        {
            DENSITY_ASSUME(i_dest != nullptr);
            new (i_dest) TARGET_TYPE();
        }
    };

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

        void operator()(void * i_dest, const void * i_source) const
        {
            (*m_function)(i_dest, i_source);
        }

      private:
        using Function = void (*)(void * i_dest, const void * i_source);
        Function const m_function;
        constexpr f_copy_construct(Function i_function) : m_function(i_function) {}
        template <typename TARGET_TYPE> static void invoke(void * i_dest, const void * i_source)
        {
            DENSITY_ASSUME(i_dest != nullptr);
            DENSITY_ASSUME(i_source != nullptr);
            const TARGET_TYPE & source = *static_cast<const TARGET_TYPE *>(i_source);
            new (i_dest) TARGET_TYPE(source);
        }
    };

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

        void operator()(void * i_dest, void * i_source) const { (*m_function)(i_dest, i_source); }

      private:
        using Function = void (*)(void * i_dest, void * i_source);
        Function const m_function;
        constexpr f_move_construct(Function i_function) : m_function(i_function) {}
        template <typename TARGET_TYPE> static void invoke(void * i_dest, void * i_source)
        {
            DENSITY_ASSUME(i_dest != nullptr);
            DENSITY_ASSUME(i_source != nullptr);
            TARGET_TYPE & source = *static_cast<TARGET_TYPE *>(i_source);
            new (i_dest) TARGET_TYPE(std::move(source));
        }
    };

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

        void operator()(void * i_dest, const void * i_source) const
        {
            (*m_function)(i_dest, i_source);
        }

      private:
        using Function = void (*)(void * i_dest, const void * i_source);
        Function const m_function;
        constexpr f_copy_assign(Function i_function) : m_function(i_function) {}
        template <typename TARGET_TYPE> static void invoke(void * i_dest, const void * i_source)
        {
            DENSITY_ASSERT(i_dest != nullptr);
            DENSITY_ASSERT(i_source != nullptr);
            const TARGET_TYPE & source = *static_cast<const TARGET_TYPE *>(i_source);
            TARGET_TYPE &       dest   = *static_cast<TARGET_TYPE *>(i_dest);
            dest                       = source;
        }
    };

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

        void operator()(void * i_dest, void * i_source) const { (*m_function)(i_dest, i_source); }

      private:
        using Function = void (*)(void * i_dest, void * i_source);
        Function const m_function;
        constexpr f_move_assign(Function i_function) : m_function(i_function) {}
        template <typename TARGET_TYPE> static void invoke(void * i_dest, void * i_source)
        {
            DENSITY_ASSERT(i_dest != nullptr);
            DENSITY_ASSERT(i_source != nullptr);
            const TARGET_TYPE & source = *static_cast<TARGET_TYPE *>(i_source);
            TARGET_TYPE &       dest   = *static_cast<TARGET_TYPE *>(i_dest);
            dest                       = std::move(source);
        }
    };

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

        void operator()(void * i_object) const noexcept { return (*m_function)(i_object); }

      private:
        using Function = void (*)(void * i_dest) DENSITY_CPP17_NOEXCEPT;
        Function const m_function;
        constexpr f_destroy(Function i_function) : m_function(i_function) {}
        template <typename TARGET_TYPE> static void invoke(void * i_object) noexcept
        {
            DENSITY_ASSUME(i_object != nullptr);
            TARGET_TYPE * obj = static_cast<TARGET_TYPE *>(i_object);
            static_assert(
              noexcept(obj->TARGET_TYPE::~TARGET_TYPE()),
              "TARGET_TYPE must be nothrow destructible");
            obj->TARGET_TYPE::~TARGET_TYPE();
        }
    };

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

        bool operator()(void const * i_first, void const * i_second) const noexcept
        {
            return (*m_function)(i_first, i_second);
        }

      private:
        using Function = bool (*)(void const * i_first, void const * i_second)
          DENSITY_CPP17_NOEXCEPT;
        Function const m_function;
        constexpr f_equal(Function i_function) : m_function(i_function) {}
        template <typename TARGET_TYPE>
        static bool invoke(void const * i_first, void const * i_second) noexcept
        {
            DENSITY_ASSUME(i_first != nullptr);
            DENSITY_ASSUME(i_second != nullptr);
            auto const & first  = *static_cast<TARGET_TYPE const *>(i_first);
            auto const & second = *static_cast<TARGET_TYPE const *>(i_second);
            bool const   result = first == second;
            return result;
        }
    };

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

        bool operator()(void const * i_first, void const * i_second) const
        {
            return (*m_function)(i_first, i_second);
        }

      private:
        using Function = bool (*)(void const * i_first, void const * i_second)
          DENSITY_CPP17_NOEXCEPT;
        Function const m_function;
        constexpr f_less(Function i_function) : m_function(i_function) {}
        template <typename TARGET_TYPE>
        static bool invoke(void const * i_first, void const * i_second) noexcept
        {
            DENSITY_ASSUME(i_first != nullptr);
            DENSITY_ASSUME(i_second != nullptr);
            auto const & first  = *static_cast<TARGET_TYPE const *>(i_first);
            auto const & second = *static_cast<TARGET_TYPE const *>(i_second);
            bool const   result = first < second;
            return result;
        }
    };

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

        DENSITY_NODISCARD size_t operator()(const void * i_source) const noexcept
        {
            return (*m_function)(i_source);
        }

      private:
        using Function = size_t (*)(const void * i_source) DENSITY_CPP17_NOEXCEPT;
        Function const m_function;
        constexpr f_hash(Function i_function) noexcept : m_function(i_function) {}
        template <typename TARGET_TYPE> static size_t invoke(const void * i_source) noexcept
        {
            DENSITY_ASSUME(i_source != nullptr);
            static_assert(
              noexcept(std::hash<TARGET_TYPE>()(*static_cast<const TARGET_TYPE *>(i_source))),
              "Specializations of std::hash must be nothrow constructible and invokable");
            return std::hash<TARGET_TYPE>()(*static_cast<const TARGET_TYPE *>(i_source));
        }
    };

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

        DENSITY_NODISCARD std::type_info const & operator()() const noexcept
        {
            return (*m_function)();
        }

      private:
        using Function = std::type_info const & (*)() DENSITY_CPP17_NOEXCEPT;
        Function const m_function;
        constexpr f_rtti(Function i_function) noexcept : m_function(i_function) {}
        template <typename TARGET_TYPE> static const std::type_info & invoke() noexcept
        {
            return typeid(TARGET_TYPE);
        }
    };

    using default_type_features =
      feature_list<f_size, f_alignment, f_copy_construct, f_move_construct, f_rtti, f_destroy>;

    template <typename FEATURE_LIST, typename... TARGET_FEATURES> struct has_features;
    template <typename FEATURE_LIST>
    struct has_features<FEATURE_LIST> : std::integral_constant<bool, true>
    {
    };
    template <typename FEATURE_LIST, typename FIRST_FEATURE, typename... OTHER_FEATURES>
    struct has_features<FEATURE_LIST, FIRST_FEATURE, OTHER_FEATURES...>
        : std::integral_constant<
            bool,

            (detail::Tuple_FindFirst<typename FEATURE_LIST::tuple_type, FIRST_FEATURE>::index <
             std::tuple_size<typename FEATURE_LIST::tuple_type>::value) &&
              has_features<FEATURE_LIST, OTHER_FEATURES...>::value

            >
    {
    };

    template <typename... FEATURES> class runtime_type
    {
      public:
        using feature_list_type = typename std::conditional<
          (sizeof...(FEATURES) > 0),
          feature_list<FEATURES...>,
          default_type_features>::type;

        using tuple_type = typename feature_list_type::tuple_type;

        template <typename TARGET_TYPE> constexpr static runtime_type make() noexcept
        {
            return runtime_type(
              &detail::FeatureTable<tuple_type, typename std::decay<TARGET_TYPE>::type>::s_table);
        }

        constexpr runtime_type() noexcept = default;

        template <typename... OTHER_FEATURES>
        constexpr runtime_type(
          const runtime_type<OTHER_FEATURES...> & i_source
#ifndef DOXYGEN_DOC_GENERATION
          ,
          typename std::enable_if<
            std::is_same<
              typename runtime_type::tuple_type,
              typename runtime_type<OTHER_FEATURES...>::tuple_type>::value,
            int>::type = 0
#endif
          ) noexcept
            : m_feature_table(i_source.m_feature_table)
        {
        }

        template <typename... OTHER_FEATURES>
        DENSITY_CPP14_CONSTEXPR
#ifndef DOXYGEN_DOC_GENERATION
          typename std::enable_if<
            std::is_same<
              typename runtime_type::tuple_type,
              typename runtime_type<OTHER_FEATURES...>::tuple_type>::value,
            runtime_type>::type &
#else
          runtime_type &
#endif
          operator=(const runtime_type<OTHER_FEATURES...> & i_source) noexcept
        {
            m_feature_table = i_source.m_feature_table;
            return *this;
        }

        friend void swap(runtime_type & i_first, runtime_type & i_second) noexcept
        {
            std::swap(i_first.m_feature_table, i_second.m_feature_table);
        }

        constexpr bool empty() const noexcept { return m_feature_table == nullptr; }

        DENSITY_CPP14_CONSTEXPR void clear() noexcept { m_feature_table = nullptr; }

        constexpr size_t size() const noexcept { return get_feature<f_size>()(); }

        constexpr size_t alignment() const noexcept { return get_feature<f_alignment>()(); }

        void default_construct(void * i_dest) const
        {
            DENSITY_ASSERT(!empty());
            get_feature<f_default_construct>()(i_dest);
        }

        void copy_construct(void * i_dest, const void * i_source) const
        {
            DENSITY_ASSERT(!empty());
            get_feature<f_copy_construct>()(i_dest, i_source);
        }

        void move_construct(void * i_dest, void * i_source) const
        {
            DENSITY_ASSERT(!empty());
            get_feature<f_move_construct>()(i_dest, i_source);
        }

        void destroy(void * i_dest) const noexcept
        {
            DENSITY_ASSERT(!empty());
            get_feature<f_destroy>()(i_dest);
        }

        const std::type_info & type_info() const noexcept
        {
            DENSITY_ASSERT(!empty());
            return get_feature<f_rtti>()();
        }

        bool are_equal(const void * i_first, const void * i_second) const noexcept
        {
            DENSITY_ASSERT(i_first != nullptr && i_second != nullptr && !empty());
            return get_feature<f_equal>()(i_first, i_second);
        }

        /* Returns the instance of a feature associated to the target type.

            \b Requires:
                - If the feature FEATURE is not supported by this specialization a compile
                    error is reported (this function is not SFINAE-friendly).

            \b Precoditions:
               The behavior is undefined if any of these conditions is not satisfied:
                - The runtime_type is not empty

            \b Throws: nothing. */
        template <typename FEATURE> const FEATURE & get_feature() const noexcept
        {
            static_assert(has_features<feature_list_type, FEATURE>::value, "feature not found");
            return std::get<detail::Tuple_FindFirst<tuple_type, FEATURE>::index>(*m_feature_table);
        }

        constexpr bool operator==(const runtime_type & i_other) const noexcept
        {
            return m_feature_table == i_other.m_feature_table;
        }

        constexpr bool operator!=(const runtime_type & i_other) const noexcept
        {
            return m_feature_table != i_other.m_feature_table;
        }

        template <typename TARGET_TYPE> constexpr bool is() const noexcept
        {
            return m_feature_table ==
                   &detail::FeatureTable<tuple_type, typename std::decay<TARGET_TYPE>::type>::
                     s_table;
        }

      private:
        constexpr runtime_type(const tuple_type * i_feature_table) noexcept
            : m_feature_table(i_feature_table)
        {
        }

      private:
#ifndef DOXYGEN_DOC_GENERATION
        template <typename...> friend class runtime_type;
        friend struct std::hash<density::runtime_type<FEATURES...>>;
#endif
        const tuple_type * m_feature_table = nullptr;
    };
} // namespace density

namespace std
{
    template <typename... FEATURES> struct hash<density::runtime_type<FEATURES...>>
    {
        size_t operator()(const density::runtime_type<FEATURES...> & i_runtime_type) const noexcept
        {
            return std::hash<const void *>()(i_runtime_type.m_feature_table);
        }
    };

} // namespace std