meta.h

Go to the documentation of this file.

/* Copyright 2020 CNRS-AIST JRL */
 
#pragma once
 
#include <type_traits>
 
namespace jrl::qp::internal
{
template<template<typename...> class Base>
struct is_base
{
  template<typename... T>
  static std::true_type check(Base<T...> const volatile &);
  static std::false_type check(...);
};
 
template<typename T, template<typename...> class Base>
constexpr bool derives_from()
{
  return decltype(is_base<Base>::check(std::declval<const T &>()))::value;
}
 
template<typename T, typename Base>
constexpr bool derives_from()
{
  return std::is_base_of_v<Base, T>;
}
 
template<typename T, typename... Base>
using enable_for_t = std::enable_if_t<(... || (std::is_same_v<T, Base> || derives_from<T, Base>())), int>;
 
template<typename T, template<typename...> class... Base>
using enable_for_templated_t = std::enable_if_t<(... || derives_from<T, Base>()), int>;
 
template<typename T>
class always_true : public std::true_type
{
};
 
template<typename T>
class always_false : public std::false_type
{
};
 
struct identity
{
  template<typename T>
  constexpr auto operator()(T && v) const noexcept -> decltype(std::forward<T>(v))
  {
    return std::forward<T>(v);
  }
};
 
struct to_underlying_type
{
  template<typename T>
  constexpr auto operator()(const T & v) const noexcept
  {
    static_assert(std::is_enum_v<T>, "This is needed before C++20.");
    return static_cast<std::underlying_type_t<T>>(v);
  }
};
 
template<typename T>
using cast_as_underlying_if_enum = std::conditional_t<std::is_enum_v<T>, to_underlying_type, identity>;
 
} // namespace jrl::qp::internal