concepts.h

Go to the documentation of this file.

#pragma once
#include "utils/type_traits.h"
 
namespace bmb {
 
namespace detail {
 
template <typename T, typename U>
concept SameHelper = is_same_v<T, U>;
 
}  // namespace detail
 
// SameHelper is needed for correct subsuming.
// This is required for all commutative relations.
 
template <typename T, typename U>
concept SameAs = detail::SameHelper<T, U> && detail::SameHelper<U, T>;
 
template <typename T>
concept DefaultConstructible = requires { T(); };
 
template <typename T, typename... Args>
concept ConstructibleFrom = requires { T(declval<Args>()...); };
 
template <typename T, typename... Args>
concept NothrowConstructibleFrom = requires {
    // There is no subsuming with ConstructibleFrom
    { T(declval<Args>()...) } noexcept;
};
 
template <typename T>
concept MoveConstructible = ConstructibleFrom<T, T&&>;
 
template <typename T>
concept NothrowMoveConstructible = NothrowConstructibleFrom<T, T&&>;
 
template <typename T>
concept MoveAssignable = requires(T a) { a = declval<T &&>(); };
 
template <typename T>
concept NothrowMoveAssignable = requires(T a) {
    { a = declval<T &&>() } noexcept;
};
 
template <typename T>
concept CopyConstructible = ConstructibleFrom<T, const T&>;
 
template <typename T>
concept NothrowCopyConstructible = NothrowConstructibleFrom<T, const T&>;
 
template <typename T>
concept CopyAssignable = requires(T a, T b) { a = b; };
 
template <typename T>
concept NothrowCopyAssignable = requires(T a, T b) {
    { a = b } noexcept;
};
 
template <typename From, typename To>
concept ConvertibleTo = requires(From from) { static_cast<To>(from); };
 
template <typename F, typename... Args>
concept Invocable = is_invocable_v<F, Args...>;
 
template <typename F, typename... Args>
concept Predicate
    = Invocable<F, Args...> && ConvertibleTo<invoke_result_t<F, Args...>, bool>;
 
}  // namespace bmb