traits.h

Go to the documentation of this file.

#pragma once
 
#include <type_traits>
#include <utility>
#include <cstddef>
 
namespace ph
{
 
// TODO: variants that ignores return type
 
template<typename A, typename B, typename C>
concept CCanAdd = requires (A a, B b, C c)
{
    c = a + b;
};
 
template<typename A, typename B, typename C>
concept CCanSubtract = requires (A a, B b, C c)
{
    c = a - b;
};
 
template<typename A, typename B, typename C>
concept CCanMultiply = requires (A a, B b, C c)
{
    c = a * b;
};
 
template<typename A, typename B, typename C>
concept CCanDivide = requires (A a, B b, C c)
{
    c = a / b;
};
 
 
template<typename Built, typename From, typename = void>
struct IsBuildable : std::false_type {};
 
template<typename Built, typename From>
struct IsBuildable
<
    Built, From,
    std::enable_if_t
    <
        std::is_convertible_v<From, Built> || 
        std::is_constructible_v<Built, From>
    >
> : std::true_type {};
 
template<typename ObjType>
concept CSubscriptable = requires (ObjType obj, std::size_t index)
{
    obj[index];
};
 
template<CSubscriptable Ts>
using TSubscriptedTypeOf = decltype(std::declval<Ts>()[0]);
 
template<typename EnumType>
concept CEnum = std::is_enum_v<EnumType>;
 
template<typename EnumType>
concept CEnumWithSizeInfo = CEnum<EnumType> && requires
{
    { EnumType::SIZE } -> std::convertible_to<EnumType>;
};
 
template<typename T>
concept CNumber = std::is_arithmetic_v<T>;
 
template<typename TypeA, typename TypeB>
concept CSame = std::same_as<TypeA, TypeB>;
 
template<typename TypeA, typename TypeB>
concept CNotSame = !CSame<TypeA, TypeB>;
 
template<typename DerivedType, typename BaseType>
concept CDerived = std::derived_from<DerivedType, BaseType>;
 
template<typename BaseType, typename DerivedType>
concept CBase = std::derived_from<DerivedType, BaseType>;
 
}// end namespace ph