dynamic_reference.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/runtime_type.h>
#include <type_traits>

namespace density
{
    enum class cv_qual
    {
        no_qual             = 0, 
        const_qual          = 1, 
        volatile_qual       = 2, 
        const_volatile_qual = 3, 
    };

    template <typename TYPE> struct cv_qual_of
    {
        static constexpr cv_qual value = cv_qual::no_qual;
    };
    template <typename TYPE> struct cv_qual_of<const TYPE>
    {
        static constexpr cv_qual value = cv_qual::const_qual;
    };
    template <typename TYPE> struct cv_qual_of<volatile TYPE>
    {
        static constexpr cv_qual value = cv_qual::volatile_qual;
    };
    template <typename TYPE> struct cv_qual_of<const volatile TYPE>
    {
        static constexpr cv_qual value = cv_qual::const_volatile_qual;
    };

    constexpr bool is_less_or_equal_cv_qualified(cv_qual i_first, cv_qual i_second) noexcept
    {
        return (static_cast<unsigned>(i_first) & ~static_cast<unsigned>(i_second)) == 0;
    }

    constexpr bool is_less_cv_qualified(cv_qual i_first, cv_qual i_second) noexcept
    {
        return i_first != i_second && is_less_or_equal_cv_qualified(i_first, i_second);
    }

    template <typename TYPE, cv_qual CV> struct add_cv_qual
    {
        using type = TYPE;
    };
    template <typename TYPE> struct add_cv_qual<TYPE, cv_qual::const_qual>
    {
        using type = const TYPE;
    };
    template <typename TYPE> struct add_cv_qual<TYPE, cv_qual::volatile_qual>
    {
        using type = volatile TYPE;
    };
    template <typename TYPE> struct add_cv_qual<TYPE, cv_qual::const_volatile_qual>
    {
        using type = const volatile TYPE;
    };

    template <typename TYPE, cv_qual CV> using add_cv_qual_t = typename add_cv_qual<TYPE, CV>::type;

    template <typename RUNTIME_TYPE = runtime_type<>, cv_qual = cv_qual::no_qual>
    class dynamic_reference;

    template <typename RUNTIME_TYPE = runtime_type<>>
    using const_dynamic_reference = dynamic_reference<RUNTIME_TYPE, cv_qual::const_qual>;

    template <typename RUNTIME_TYPE = runtime_type<>>
    using volatile_dynamic_reference = dynamic_reference<RUNTIME_TYPE, cv_qual::volatile_qual>;

    template <typename RUNTIME_TYPE = runtime_type<>>
    using const_volatile_dynamic_reference =
      dynamic_reference<RUNTIME_TYPE, cv_qual::const_volatile_qual>;

    template <typename> struct is_dynamic_reference : std::false_type
    {
    };
    template <typename RUNTIME_TYPE, cv_qual CV_QUAL>
    struct is_dynamic_reference<dynamic_reference<RUNTIME_TYPE, CV_QUAL>> : std::true_type
    {
    };

    template <typename RUNTIME_TYPE, cv_qual CV_QUALIFIER> class dynamic_reference
    {
      public:
        dynamic_reference() = delete;

#ifdef DOXYGEN_DOC_GENERATION
        template <typename TARGET_TYPE>
#else
        template <
          typename TARGET_TYPE,
          typename std::enable_if<
            !is_dynamic_reference<TARGET_TYPE>::value &&
            is_less_or_equal_cv_qualified(cv_qual_of<TARGET_TYPE>::value, CV_QUALIFIER)>::type * =
            nullptr>
#endif
        dynamic_reference(TARGET_TYPE & i_target_object)
            : dynamic_reference(
                RUNTIME_TYPE::template make<typename std::remove_cv<TARGET_TYPE>::type>(),
                &i_target_object)
        {
        }

        constexpr dynamic_reference(
          const RUNTIME_TYPE & i_target_type, add_cv_qual_t<void, CV_QUALIFIER> * i_target_address)
            : m_address(i_target_address), m_type(i_target_type)
        {
        }

#ifdef DOXYGEN_DOC_GENERATION
        template <cv_qual OTHER_CV>
#else
        template <
          cv_qual OTHER_CV,
          typename std::enable_if<is_less_or_equal_cv_qualified(OTHER_CV, CV_QUALIFIER)>::type * =
            nullptr>
#endif
        constexpr dynamic_reference(const dynamic_reference<RUNTIME_TYPE, OTHER_CV> & i_source)
            : dynamic_reference(i_source.type(), i_source.address())

        {
        }

        dynamic_reference & operator=(const dynamic_reference & i_source) = delete;

        constexpr const RUNTIME_TYPE & type() const noexcept { return m_type; }

        constexpr add_cv_qual_t<void, CV_QUALIFIER> * address() const noexcept { return m_address; }

        template <typename TYPE> constexpr bool is() const noexcept
        {
            return is_less_or_equal_cv_qualified(CV_QUALIFIER, cv_qual_of<TYPE>::value) &&
                   m_type.template is<TYPE>();
        }

        template <typename TYPE>
        DENSITY_CPP14_CONSTEXPR add_cv_qual_t<TYPE, CV_QUALIFIER> & as() const noexcept
        {
            assert(m_type.template is<TYPE>());
            return *static_cast<add_cv_qual_t<TYPE, CV_QUALIFIER> *>(m_address);
        }

      private:
        add_cv_qual_t<void, CV_QUALIFIER> * const m_address = nullptr;
        RUNTIME_TYPE const                        m_type;
    };

} // namespace density