concepts.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-2-Clause
 
#ifndef pRC_CORE_BASIC_CONCEPTS_H
#define pRC_CORE_BASIC_CONCEPTS_H
 
#include <concepts>
 
#include <prc/core/basic/basics.hpp>
 
namespace pRC
{
    template<class T, class U>
    concept HasCommon = std::common_with<T, U>;
 
    template<class T>
    concept IsDefined = requires { sizeof(T); };
 
    template<class T>
    concept IsReference = std::is_reference_v<T>;
 
    template<class T>
    concept IsPointer = std::is_pointer_v<T>;
 
    template<class T>
    concept IsConst = std::is_const_v<T>;
 
    template<class T, class U>
    concept IsSame = std::same_as<T, U>;
 
    template<class F, class... Args>
    concept IsInvocable = std::invocable<F, Args...>;
 
    template<class F, class... Args>
    concept IsPredicate = std::predicate<F, Args...>;
 
    template<class T, class... Args>
    concept IsConstructible = std::constructible_from<T, Args...>;
 
    template<class L, class R = L>
    concept IsAssignable = requires { declval<L>() = declval<R>(); };
 
    template<class F, class T>
    concept IsConvertible = std::convertible_to<F, T>;
 
    template<class D, class B>
    concept IsDerivedFrom = std::derived_from<D, B>;
 
    template<class B, class D>
    concept IsBaseOf = IsDerivedFrom<D, B>;
 
    template<class T>
    concept IsStandardLayout = std::is_standard_layout_v<T>;
 
    template<class T>
    concept IsVoid = IsSame<RemoveConst<T>, Void>;
 
    template<class T>
    concept IsBool = IsSame<RemoveConst<T>, Bool>;
 
    template<class T>
    concept IsSize = IsSame<RemoveConst<T>, Size>;
 
    template<class T>
    concept IsIndex = IsSame<RemoveConst<T>, Index>;
 
    template<class T>
    concept IsSeed = IsSame<RemoveConst<T>, Seed>;
 
    template<class T>
    concept IsIntegral = !IsBool<T> && std::integral<T>;
 
    template<class T>
    concept IsSignedIntegral = IsIntegral<T> && std::is_signed_v<T>;
 
    template<class T>
    concept IsUnsignedIntegral = IsIntegral<T> && !std::is_signed_v<T>;
 
    template<class T>
    concept IsConstant = !IsReference<T> && requires {
        {
            []<class U, U V>(Constant<U, V> const &&)
            {
            }(std::declval<T>())
        };
    };
 
}
#endif // pRC_CORE_BASIC_CONCEPTS_H