MetaUtils.h

Go to the documentation of this file.

#ifndef LARCOREALG_COREUTILS_METAUTILS_H
#define LARCOREALG_COREUTILS_METAUTILS_H

// C/C++ standard libraries
#include <array>
#include <functional> // std::reference_wrapper<>
#include <memory>     // std::addressof()
#include <string>
#include <string_view>
#include <type_traits>

namespace util {

  //--- BEGIN MetaprogrammingBase ----------------------------------------------

  namespace details {

    template <typename T>
    struct ClassNameStaticDumper;

  } // namespace details

  //----------------------------------------------------------------------------
  template <typename T>
  struct self_type {
    using type = T;
  };

  template <typename T>
  using self_t = typename self_type<T>::type;

  //----------------------------------------------------------------------------
  template <typename>
  struct always_false_type : public std::false_type {};

  //----------------------------------------------------------------------------
  template <typename>
  constexpr bool always_false_v = false;

  template <typename>
  struct always_true_type : public std::true_type {};

  template <typename>
  constexpr bool always_true_v = true;

  template <typename A, typename B>
  using is_not_same = std::negation<std::is_same<A, B>>;

  //----------------------------------------------------------------------------
  template <typename T, std::size_t StartFrom, typename... Types>
  struct find_next_type;

  template <typename T, std::size_t StartFrom, typename... Types>
  constexpr std::size_t find_next_type_v = find_next_type<T, StartFrom, Types...>::value;

  //----------------------------------------------------------------------------
  template <typename T, typename... Types>
  using find_type = find_next_type<T, 0U, Types...>;

  template <typename T, typename... Types>
  constexpr std::size_t find_type_v = find_type<T, Types...>::value;

  //----------------------------------------------------------------------------
  template <typename T, typename... Types>
  struct is_any_of;

  template <typename T, typename... Types>
  constexpr bool is_any_of_v = is_any_of<T, Types...>::value;

  //----------------------------------------------------------------------------
  template <typename T, typename U>
  constexpr auto is_same_decay_v = std::is_same_v<std::decay_t<T>, std::decay_t<U>>;

  //----------------------------------------------------------------------------
  // @{
  template <typename T>
  void staticDumpClassName();

  template <typename T>
  void staticDumpClassName(T)
  {
    staticDumpClassName<T>();
  }
  // @}

  //--- END MetaprogrammingBase ------------------------------------------------

  //--- BEGIN Type identification ----------------------------------------------

  //----------------------------------------------------------------------------

  template <template <typename...> typename Template, typename T>
  struct is_instance_of;

  template <template <typename...> typename Template, typename T>
  constexpr bool is_instance_of_v = is_instance_of<Template, T>::value;

  //----------------------------------------------------------------------------
  template <typename T>
  struct is_STLarray;

  template <typename T>
  constexpr bool is_STLarray_v = is_STLarray<T>::value;

  //----------------------------------------------------------------------------
  template <typename T>
  using is_reference_wrapper = is_instance_of<std::reference_wrapper, T>;

  template <typename T>
  constexpr bool is_reference_wrapper_v = is_reference_wrapper<T>::value;

  //----------------------------------------------------------------------------
  template <typename T>
  using is_unique_ptr = is_instance_of<std::unique_ptr, T>;

  template <typename T>
  constexpr bool is_unique_ptr_v = is_unique_ptr<T>::value;

  //----------------------------------------------------------------------------
  template <typename T>
  struct is_character_type;

  template <typename T>
  constexpr bool is_character_type_v = is_character_type<T>::value;

  //----------------------------------------------------------------------------
  template <typename T>
  struct is_string_type;

  template <typename T>
  constexpr bool is_string_type_v = is_string_type<T>::value;

  //----------------------------------------------------------------------------
  template <typename T>
  struct is_basic_string_type;

  template <typename T>
  constexpr bool is_basic_string_type_v = is_basic_string_type<T>::value;

  //----------------------------------------------------------------------------
  template <typename T>
  struct is_basic_string_view_type;

  template <typename T>
  constexpr bool is_basic_string_view_type_v = is_basic_string_view_type<T>::value;

  //--- END Type identification ------------------------------------------------

  //--- BEGIN Type manipulation ------------------------------------------------

  //----------------------------------------------------------------------------
  template <typename Base, typename Key>
  struct with_const_as;

  template <typename Base, typename Key>
  using with_const_as_t = typename with_const_as<Base, Key>::type;

  //----------------------------------------------------------------------------
  template <typename T>
  struct strip_referenceness_type;

  template <typename T>
  using strip_referenceness_t = typename strip_referenceness_type<T>::type;

  //----------------------------------------------------------------------------
  template <typename Ref>
  auto referenced_address(Ref&& ref);

  //----------------------------------------------------------------------------
  struct reference_addresser {
    template <typename Ref>
    decltype(auto) operator()(Ref&& ref) const
    {
      return addressof(std::forward<Ref>(ref));
    }

    template <typename Ref>
    static decltype(auto) addressof(Ref&& ref)
    {
      return referenced_address(std::forward<Ref>(ref));
    }

  }; // struct reference_addresser

  //----------------------------------------------------------------------------
  template <typename T>
  struct lvalue_reference_into_wrapper_type;

  template <typename T>
  using lvalue_reference_into_wrapper_t = typename lvalue_reference_into_wrapper_type<T>::type;

  template <typename T>
  auto lvalue_reference_into_wrapper(T&& obj)
  {
    return util::lvalue_reference_into_wrapper_t<T>(obj);
  }

  //----------------------------------------------------------------------------

  //--- END Type manipulation --------------------------------------------------

} // namespace util

//------------------------------------------------------------------------------
//---  Template implementation
//------------------------------------------------------------------------------
namespace util {

  //----------------------------------------------------------------------------
  namespace details {

    //--------------------------------------------------------------------------
    template <std::size_t Index, std::size_t Skip, typename T, typename... Types>
    struct find_type_impl;

    template <std::size_t Index, std::size_t Skip, typename T, typename Type, typename... Others>
    struct find_type_impl<Index, Skip, T, Type, Others...>
      : std::integral_constant<
          std::size_t,
          (Skip == 0) && std::is_same_v<T, Type> ?
            Index :
            find_type_impl<Index + 1U, ((Skip > 0U) ? Skip - 1U : 0U), T, Others...>::value> {};

    template <std::size_t Index, std::size_t Skip, typename T>
    struct find_type_impl<Index, Skip, T> : std::integral_constant<std::size_t, Index> {};

    //--------------------------------------------------------------------------
    template <typename T, typename = void>
    struct is_character_type_impl
      : std::bool_constant<util::is_any_of_v<std::decay_t<T>,
                                             signed char,
                                             unsigned char,
                                             char,
                                             wchar_t,
#ifdef __cpp_char8_t // C++20
                                             char8_t,
#endif                                                 // __cpp_char8_t
                                             char16_t, // this is defined unsigned
                                             char32_t  // this is defined unsigned
                                             >> {
    };

    //--------------------------------------------------------------------------
    template <typename T, typename = void>
    struct is_string_type_impl : std::false_type {};

    template <typename T>
    struct is_string_type_impl<
      T,
      std::enable_if_t<is_character_type_impl<typename T::value_type>::value>> : std::true_type {};

    template <typename T>
    struct is_string_type_impl<
      T,
      std::enable_if_t<std::is_pointer_v<std::decay_t<T>> &&
                       is_character_type_impl<std::remove_pointer_t<std::decay_t<T>>>::value>>
      : std::true_type {};

    template <typename T>
    struct is_string_type_impl<
      T,
      std::enable_if_t<std::is_array_v<std::decay_t<T>> &&
                       is_character_type_impl<std::remove_extent_t<std::decay_t<T>>>::value>>
      : std::true_type {};

    //--------------------------------------------------------------------------
    template <typename T>
    struct is_basic_string_type_impl : std::false_type {};

    template <typename... Args>
    struct is_basic_string_type_impl<std::basic_string<Args...>> : std::true_type {};

    //--------------------------------------------------------------------------
    template <typename T>
    struct is_basic_string_view_type_impl : std::false_type {};

    template <typename... Args>
    struct is_basic_string_view_type_impl<std::basic_string_view<Args...>> : std::true_type {};

    //--------------------------------------------------------------------------
    template <typename T>
    struct ClassNameStaticDumper {
      static_assert(util::always_false_type<T>(),
                    "ClassNameStaticDumper<T>: look for T in the error message context");
    }; // struct ClassNameStaticDumper

    //--------------------------------------------------------------------------
    // implementation for `with_const_as`

    // - final implementation:
    template <typename Base, typename /* Key */, typename = void>
    struct with_const_as_impl {
      using type = std::remove_const_t<Base>;
    };

    template <typename Base, typename Key>
    struct with_const_as_impl<Base, Key, std::enable_if_t<std::is_const_v<Key>>> {
      using type = std::add_const_t<Base>;
    };

    // - implementation dispatcher for reference types
    //   - pass through for not-reference types
    template <typename Base, typename Key, typename = void>
    struct with_const_as_dispatch_ref : with_const_as_impl<Base, Key> {};
    //   - lvalue reference
    template <typename Base, typename Key>
    struct with_const_as_dispatch_ref<Base,
                                      Key,
                                      std::enable_if_t<std::is_lvalue_reference_v<Base>>> {
      using type = std::add_lvalue_reference_t<
        typename with_const_as_impl<std::remove_reference_t<Base>, Key>::type>;
    };
    //   - rvalue reference
    template <typename Base, typename Key>
    struct with_const_as_dispatch_ref<Base,
                                      Key,
                                      std::enable_if_t<std::is_rvalue_reference_v<Base>>> {
      using type = std::add_rvalue_reference_t<
        typename with_const_as_impl<std::remove_reference_t<Base>, Key>::type>;
    };

    // - key management
    template <typename Base, typename Key>
    struct with_const_as_dispatch_keyref
      : with_const_as_dispatch_ref<Base, std::remove_reference_t<Key>> {};

    // - top level implementation dispatcher
    template <typename Base, typename Key>
    struct with_const_as_dispatcher : with_const_as_dispatch_keyref<Base, Key> {};

    //--------------------------------------------------------------------------
    //--- implementation of `is_instance_of`
    template <template <typename...> typename Template, typename T>
    struct is_instance_of_impl : std::false_type {};

    template <template <typename...> typename Template, typename... Args>
    struct is_instance_of_impl<Template, Template<Args...>> : std::true_type {};

    //--------------------------------------------------------------------------
    //--- implementation of `strip_referenceness_type`

    template <typename T>
    struct strip_referenceness_type_impl;

    // implementation layer dealing with `std::reference_wrapper`
    template <typename T, typename = void>
    struct strip_referenceness_type_impl_wrapref {
      using type = T;
    }; // exit here

    // - handle any constantness and volatility
    template <typename T>
    struct strip_referenceness_type_impl_wrapref<
      T,
      std::enable_if_t<util::is_reference_wrapper_v<std::remove_cv_t<T>>>>
      : strip_referenceness_type_impl<typename T::type> // back to square one
    {};

    // implementation layer dealing with C++ references
    template <typename T>
    struct strip_referenceness_type_impl_ref : strip_referenceness_type_impl_wrapref<T> {};

    template <typename T>
    struct strip_referenceness_type_impl_ref<T&> : strip_referenceness_type_impl_wrapref<T> {};

    template <typename T>
    struct strip_referenceness_type_impl_ref<T&&> : strip_referenceness_type_impl_wrapref<T> {};

    // entry point: start by dealing with C++ references
    template <typename T>
    struct strip_referenceness_type_impl : strip_referenceness_type_impl_ref<T> {};

    //--------------------------------------------------------------------------
    //--- implementation of `referenced_address()`

    template <typename T, typename = void>
    struct referenced_address_impl {
      static auto addressof(T& obj) { return std::addressof(obj); }
    };

    template <typename T>
    struct referenced_address_impl<T, std::enable_if_t<util::is_reference_wrapper_v<T>>> {
      static auto addressof(T& obj) { return std::addressof(obj.get()); }
    };

    //--------------------------------------------------------------------------
    //--- implementation of `lvalue_reference_into_wrapper_type`
    /*
     * The implementation develops across levels:
     *  1. any kind of `std::reference_wrapper` is handled
     *  2. l-value references are handled
     */
    template <typename T>
    struct lvalue_reference_into_wrapper_type_impl_final {
      using type = std::remove_reference_t<T>;
    };

    template <typename T>
    struct lvalue_reference_into_wrapper_type_impl_final<T&> {
      using type = std::reference_wrapper<T>;
    };

    template <typename T, typename = void>
    struct lvalue_reference_into_wrapper_type_impl_wrapper {
      using type = typename lvalue_reference_into_wrapper_type_impl_final<T>::type;
    };

    template <typename T>
    struct lvalue_reference_into_wrapper_type_impl_wrapper<
      T,
      std::enable_if_t<util::is_reference_wrapper_v<T>>> {
      using type = std::remove_reference_t<T>;
    };

    template <typename T>
    struct lvalue_reference_into_wrapper_type_impl
      : lvalue_reference_into_wrapper_type_impl_wrapper<T> {};

    //--------------------------------------------------------------------------

  } // namespace details

  //----------------------------------------------------------------------------
  template <template <typename...> typename Template, typename T>
  struct is_instance_of : details::is_instance_of_impl<Template, std::decay_t<T>> {};

  //----------------------------------------------------------------------------
  template <typename T, std::size_t StartFrom, typename... Types>
  struct find_next_type : details::find_type_impl<0U, StartFrom, T, Types...> {};

  //----------------------------------------------------------------------------
  template <typename T, typename... Types>
  struct is_any_of : std::bool_constant<((find_type_v<T, Types...>) < sizeof...(Types))> {};

  //----------------------------------------------------------------------------
  template <typename T>
  struct is_character_type : details::is_character_type_impl<T> {};

  //----------------------------------------------------------------------------
  template <typename T>
  struct is_string_type : details::is_string_type_impl<T> {};

  //----------------------------------------------------------------------------
  template <typename T>
  struct is_basic_string_type : details::is_basic_string_type_impl<std::decay_t<T>> {};

  //----------------------------------------------------------------------------
  template <typename T>
  struct is_basic_string_view_type : details::is_basic_string_view_type_impl<std::decay_t<T>> {};

  //----------------------------------------------------------------------------
  template <typename T>
  void staticDumpClassName()
  {
    (void)details::ClassNameStaticDumper<T>();
  }

  //----------------------------------------------------------------------------
  template <typename>
  struct is_STLarray : public std::false_type {};

  template <typename T, std::size_t N>
  struct is_STLarray<std::array<T, N>> : public std::true_type {};

  //----------------------------------------------------------------------------
  template <typename Base, typename Key>
  struct with_const_as : public details::with_const_as_dispatcher<Base, Key> {};

  //----------------------------------------------------------------------------
  template <typename T>
  struct strip_referenceness_type : public details::strip_referenceness_type_impl<T> {};

  //----------------------------------------------------------------------------
  template <typename T>
  struct lvalue_reference_into_wrapper_type
    : public details::lvalue_reference_into_wrapper_type_impl<T> {};

  //----------------------------------------------------------------------------
  template <typename Ref>
  auto referenced_address(Ref&& ref)
  {
    return details::referenced_address_impl<Ref>::addressof(ref);
  }

  //----------------------------------------------------------------------------

} // namespace util

//------------------------------------------------------------------------------

#endif // LARCOREALG_COREUTILS_METAUTILS_H