TypeTraits.hh

// -*- C++ -*-
#ifndef RIVET_TypeTraits_HH
#define RIVET_TypeTraits_HH
 
#include <type_traits>
#include <iterator>
 
namespace Rivet {
 
 
 
 
  struct RefType { };
 
  struct PtrType { };
 
  template <typename T>
  struct TypeTraits;
 
  template <typename U>
  struct TypeTraits<const U&> {
    using ArgType = RefType;
  };
 
  template <typename U>
  struct TypeTraits<const U*> {
    using ArgType = PtrType;
  };
 
  template<typename T>
  struct TypeIdentity { using type = T; };
 
 
  template<typename T>
  using sign_if_integral = std::conditional_t<(std::is_integral_v<T> && !std::is_same_v<T,bool>),
                                        std::make_signed<T>, TypeIdentity<T>>;
  //
  template<typename T>
  using sign_if_integral_t = typename sign_if_integral<T>::type;
 
  template<typename... Args>
  using all_unsigned = std::conjunction<std::is_unsigned<Args>...>;
 
  template<typename... Args>
  using signed_if_mixed_t = std::conditional_t<all_unsigned<Args...>::value,
                                               std::common_type_t<Args...>,
                                               std::common_type_t<sign_if_integral_t<Args>...>>;
 
 
  template <typename T, typename=void>
  struct Derefable : std::false_type {};
  //
  template <typename T>
  struct Derefable<T, std::void_t< decltype(*std::declval<T>())> > : std::true_type {};
 
 
  template<typename T, typename = void>
  struct Iterable : std::false_type { };
  //
  template<typename T>
  struct Iterable<T, std::void_t<std::decay_t<decltype(std::begin(std::declval<const T&>()))>,
                                 std::decay_t<decltype(std::end(std::declval<const T&>()))>>>  : std::true_type { };
 
  template<typename T>
  inline constexpr bool is_iterable_v = Iterable<T>::value;
 
  //template<typename... T>
  //inline constexpr bool isIterable = std::conjunction<Iterable<T>...>::value;
  template<typename T>
  using isIterable = std::enable_if_t<Iterable<T>::value>;
 
 
  // SFINAE struct to check for const_iterator concept
  template<typename T, typename = void>
  struct CIterable : std::false_type { };
 
  template<typename T>
  struct CIterable<T, std::void_t<decltype(std::declval<typename std::decay_t<T>::const_iterator>())>> : std::true_type { };
 
  template<typename T>
  inline constexpr bool is_citerable_v = CIterable<T>::value;
 
  //template<typename... T>
  //inline constexpr bool isCIterable = std::conjunction<CIterable<T>...>::value;
  template<typename... Args>
  using isCIterable = std::enable_if_t<(CIterable<Args>::value && ...)>;
 
  // SFINAE struct to check for cstr
  template<typename T>
  struct isCString : std::false_type { };
 
  template<>
  struct isCString<char[]> : std::true_type { };
 
  template<size_t N>
  struct isCString<char[N]> : std::true_type { };
 
  template <typename T>
  inline constexpr bool is_cstring_v = isCString<T>::value;
 
 
  template<typename T, typename = void>
  struct hasBinning : std::false_type { };
  //
  template<typename T>
  struct hasBinning<T, std::void_t<decltype(std::declval<T>().binning())>> : std::true_type { };
 
 
  template<typename T, typename = void>
  struct isFillable : std::false_type { };
  //
  template<typename T>
  struct isFillable<T, std::void_t<decltype(typename T::FillType{})>> : std::true_type { };
 
 
  // SFINAE struct to check if U can be used as an argument of T
  template<typename T, typename U, typename = void>
  struct isArgumentOf : std::false_type { };
  //
  template<typename T, typename U>
  struct isArgumentOf<T, U, std::void_t<decltype(T(std::declval<U>()))>>
                  : std::true_type { };
 
  template <typename T, typename... Us>
  using allArgumentsOf = typename std::conjunction<isArgumentOf<T, Us>...>;
 
  template <typename T, typename=void>
  struct HasXYZ : std::false_type {};
  template <typename T>
  struct HasXYZ<T, std::void_t< decltype(std::declval<T>().x() + std::declval<T>().y() +
                                         std::declval<T>().z())> > : std::true_type {};
 
 
  template <typename T, typename=void>
  struct HasXYZT : std::false_type {};
  template <typename T>
  struct HasXYZT<T, std::void_t< decltype(std::declval<T>().x() +  std::declval<T>().y() +
                                          std::declval<T>().z() +  std::declval<T>().t())> > : std::true_type {};
 
 
 
}
 
#endif