TypeTraits.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file TypeTraits.hpp

// This file is part of the Acts project.
//
// Copyright (C) 2019 CERN for the benefit of the Acts project
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#pragma once

#include <functional>
#include <string>
#include <type_traits>

namespace Acts {

namespace detail {


struct nonesuch {
  ~nonesuch() = delete;
  nonesuch(nonesuch const&) = delete;
  void operator=(nonesuch const&) = delete;
};

template <class Default, class AlwaysVoid, template <class...> class Op,
          class... Args>
struct detector {
  using value_t = std::false_type;
  using type = Default;
};

template <class Default, template <class...> class Op, class... Args>
struct detector<Default, std::void_t<Op<Args...>>, Op, Args...> {
  // Note that std::void_t is a C++17 feature
  using value_t = std::true_type;
  using type = Op<Args...>;
};

}  // namespace detail

namespace Concepts {

template <template <class...> class Op, class... Args>
using is_detected =
    typename detail::detector<detail::nonesuch, void, Op, Args...>::value_t;

template <template <class...> class Op, class... Args>
using detected_t =
    typename detail::detector<detail::nonesuch, void, Op, Args...>::type;

template <class Expected, template <class...> class Op, class... Args>
using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>;

template <class To, template <class...> class Op, class... Args>
using is_detected_convertible =
    std::is_convertible<detected_t<Op, Args...>, To>;

template <class Default, template <class...> class Op, class... Args>
using detected_or = detail::detector<Default, void, Op, Args...>;


template <bool... Bs>
constexpr bool require = std::conjunction<std::bool_constant<Bs>...>::value;

template <bool... Bs>
constexpr bool either = std::disjunction<std::bool_constant<Bs>...>::value;

template <bool... Bs>
constexpr bool disallow = not require<Bs...>;

template <template <class...> class Op, class... Args>
constexpr bool exists = is_detected<Op, Args...>::value;

template <class To, template <class...> class Op, class... Args>
constexpr bool converts_to = is_detected_convertible<To, Op, Args...>::value;

template <class Exact, template <class...> class Op, class... Args>
constexpr bool identical_to = is_detected_exact<Exact, Op, Args...>::value;

template <typename T, typename R, template <class...> class M,
          typename... Arguments>
constexpr bool has_method = M<T, R, Arguments...>::template tv<T>::value;

template <typename T, template <class...> class M, typename V>
constexpr bool has_member = identical_to<V, M, T>;

}  // namespace Concepts
}  // namespace Acts



#define METHOD_TRAIT(trait_name, method_name)                                  \
  template <class T, typename R, typename... Arguments>                        \
  struct trait_name {                                                          \
    /* Meta function to check if a type has a const qualifier*/                \
    /* (by stripping it and seeing if something changed */                     \
    template <typename T_>                                                     \
    static constexpr bool is_const =                                           \
        not std::is_same_v<std::remove_const_t<T_>, T_>;                       \
                                                                               \
    /*These following meta-functions basically to this: they check whether or  \
     * not the actual function pointer extracted through ``&T::method_name``   \
     * can                                                                     \
     * be assigned to a prepared function pointer type with the given          \
     * signature. This checks the exact signature, and not just callability    \
     * and validity of the expression. */                                      \
                                                                               \
    /* Meta function which constructs the right type to check a function       \
     * pointer, non-const version*/                                            \
    template <typename T_, typename = int>                                     \
    struct fptr_meta {                                                         \
      template <typename... Arguments_>                                        \
      using type = typename std::integral_constant<                            \
          decltype(std::declval<T_>().method_name(                             \
              std::declval<Arguments_>()...)) (T_::*)(Arguments_...),          \
          &T_::method_name>::value_type;                                       \
    };                                                                         \
                                                                               \
    /* Meta function which constructs the right type to check a function       \
     * pointer, const version*/                                                \
    /* The ``const`` needs to be put in there in one specific spot, that's why \
     * the metafunction is needed*/                                            \
    template <typename T_>                                                     \
    struct fptr_meta<T_, std::enable_if_t<is_const<T_>, int>> {                \
      template <typename... Arguments_>                                        \
      using type = typename std::integral_constant<                            \
          decltype(std::declval<T_>().method_name(                             \
              std::declval<Arguments_>()...)) (T_::*)(Arguments_...) const,    \
          &T_::method_name>::value_type;                                       \
    };                                                                         \
                                                                               \
    /* Helper on top of the function pointer metafunction */                   \
    template <typename T_, typename... Arguments_>                             \
    using fptr_meta_t = typename fptr_meta<T_>::template type<Arguments_...>;  \
                                                                               \
    /* Trait check for the qualifier and the return type of the function */    \
    /* This does not check the const qualifier at all */                       \
    template <typename T_, typename... Arguments_>                             \
    using qual_ret = decltype(std::declval<T_>().method_name(                  \
        std::declval<Arguments_>()...));                                       \
                                                                               \
    /* The problem is this: while the above is fine with and without const,    \
     * and with and without exact argument type match, the assignment to the   \
     * function pointer fails hard if there is no method at all with the given \
     * name. That is undesirable. The following first uses the expression      \
     * validity check to assert that there is in fact a method of the given    \
     * name, and only if that is the case, try to compile the function pointer \
     * based signature check. That way, there is no hard failures, only        \
     * substitution failures and we're happy. */                               \
    template <typename T_, typename = int>                                     \
    struct tv {                                                                \
      static constexpr bool value = false;                                     \
    };                                                                         \
    template <typename T_>                                                     \
    struct tv<T_, std::enable_if_t<Acts::Concepts::is_detected_exact<          \
                                       R, qual_ret, T_, Arguments...>::value,  \
                                   int>> {                                     \
      /* This is only ever evaluate if the method exists!*/                    \
      static constexpr bool value =                                            \
          Acts::Concepts::is_detected<fptr_meta_t, T, Arguments...>::value;    \
    };                                                                         \
  }