basedOpinionated utility library |
| git clone git://git.dimitrijedobrota.com/based.git |
| Log | Files | Refs | README | LICENSE | HACKING | CONTRIBUTING | CODE_OF_CONDUCT | BUILDING |
| commit | 1519665e81a8f2258b93df0c56063887058e0bd9 |
| parent | 185d19a48385c7c85f80f391939f9ab0af97b43a |
| author | Dimitrije Dobrota < mail@dimitrijedobrota.com > |
| date | Sat, 21 Jun 2025 10:42:37 +0200 |
Improve naming consistency
76 files changed, 668 insertions(+), 694 deletions(-)
diff --git a/ .clang-tidy b/ .clang-tidy
@@ -153,7 +153,7 @@
CheckOptions:
- key: 'readability-identifier-naming.TypeAliasCase'
value: 'CamelCase'
- key: 'readability-identifier-naming.TypeAliasIgnoredRegexp'
value: '(difference_type|value_type|pointer|const_pointer|reference|const_reference|iterator|const_iterator|reverse_iterator|const_reverse_iterator)'
value: '(size_type|value_type|difference_type|pointer|const_pointer|reference|const_reference|iterator|const_iterator|reverse_iterator|const_reverse_iterator)'
- key: 'readability-identifier-naming.TypedefCase'
value: 'lower_case'
- key: 'readability-identifier-naming.TypeTemplateParameterCase'
diff --git a/ include/based/algorithm/clamp.hpp b/ include/based/algorithm/clamp.hpp
@@ -13,10 +13,10 @@
namespace based
// clamp a value between low and high
template<
trait::BareRegular T,
trait::BareRegular U,
trait::BareRegular V,
RegularProcedure<bool, T, T> Rel>
trait::IsRegularBare T,
trait::IsRegularBare U,
trait::IsRegularBare V,
trait::IsProcedureRegular<bool, T, T> Rel>
requires(trait::IsSameBare<T, U> && trait::IsSameBare<T, V>)
constexpr decltype(auto) clamp(T&& value, U&& low, V&& high, Rel rel)
{
@@ -28,7 +28,7 @@
constexpr decltype(auto) clamp(T&& value, U&& low, V&& high, Rel rel)
}
// clamp a value between low and high
template<trait::BareRegular T, trait::BareRegular U, trait::BareRegular V>
template<trait::IsRegularBare T, trait::IsRegularBare U, trait::IsRegularBare V>
requires(trait::IsSameBare<T, U> && trait::IsSameBare<T, V>)
constexpr decltype(auto) clamp(T&& value, U&& low, V&& high)
{
diff --git a/ include/based/algorithm/max.hpp b/ include/based/algorithm/max.hpp
@@ -11,9 +11,9 @@
namespace based
// returns max element, second if equal
template<
trait::BareRegular T,
trait::BareRegular U,
RegularProcedure<bool, T, T> Rel>
trait::IsRegularBare T,
trait::IsRegularBare U,
trait::IsProcedureRegular<bool, T, T> Rel>
requires trait::IsSameBare<T, U>
constexpr decltype(auto) max(T&& lhs, U&& rhs, Rel rel)
{
@@ -21,7 +21,7 @@
constexpr decltype(auto) max(T&& lhs, U&& rhs, Rel rel)
}
// returns max element, second if equal
template<trait::BareRegular T, trait::BareRegular U>
template<trait::IsRegularBare T, trait::IsRegularBare U>
requires trait::IsSameBare<T, U>
constexpr decltype(auto) max(T&& lhs, U&& rhs)
{
diff --git a/ include/based/algorithm/min.hpp b/ include/based/algorithm/min.hpp
@@ -10,9 +10,9 @@
namespace based
{
template<
trait::BareRegular T,
trait::BareRegular U,
RegularProcedure<bool, T, T> Rel>
trait::IsRegularBare T,
trait::IsRegularBare U,
trait::IsProcedureRegular<bool, T, T> Rel>
requires trait::IsSameBare<T, U>
constexpr decltype(auto) min(T&& lhs, U&& rhs, Rel rel)
{
@@ -20,7 +20,7 @@
constexpr decltype(auto) min(T&& lhs, U&& rhs, Rel rel)
}
// returns min element, first if equal
template<trait::BareRegular T, trait::BareRegular U>
template<trait::IsRegularBare T, trait::IsRegularBare U>
requires trait::IsSameBare<T, U>
constexpr decltype(auto) min(T&& lhs, U&& rhs)
{
diff --git a/ include/based/character/mapper.hpp b/ include/based/character/mapper.hpp
@@ -8,7 +8,7 @@
namespace based
{
template<Predicate<Character> Predicate>
template<trait::IsPredicate<Character> Predicate>
class Mapper
{
static constexpr auto size = limits<U8>::max;
diff --git a/ include/based/concept/callable.hpp b/ include/based/concept/callable.hpp
@@ -5,38 +5,38 @@
#include "based/trait/remove_pointer.hpp"
#include "based/trait/signature.hpp"
namespace based
namespace based::trait
{
template<typename T>
struct callable;
template<class T>
struct IsCallableHelper;
template<typename T>
requires(trait::IsFunction<T>)
struct callable<T> : public Signature<trait::Decay<T>>
template<class T>
requires(IsFunction<T>)
struct IsCallableHelper<T> : public Signature<Decay<T>>
{
};
template<typename T>
requires(requires { &trait::Decay<T>::operator(); })
struct callable<T> : public Signature<decltype(&T::operator())>
template<class T>
requires(requires { &Decay<T>::operator(); })
struct IsCallableHelper<T> : public Signature<decltype(&T::operator())>
{
};
template<typename T>
requires(std::is_member_function_pointer_v<trait::Decay<T>>)
struct callable<T> : public Signature<trait::RemovePointer<T>>
template<class T>
requires(std::is_member_function_pointer_v<Decay<T>>)
struct IsCallableHelper<T> : public Signature<RemovePointer<T>>
{
};
template<typename T>
template<class T>
// concept Callable = is_instantiable_v<callable, T>;
concept Callable = true;
concept IsCallable = true;
template<Callable T>
using CallableSigT = typename callable<T>::Signature::SigType;
template<IsCallable T>
using CallableSigT = typename IsCallableHelper<T>::Signature::SigType;
template<Callable T>
using CallableRetT = typename callable<T>::Signature::RetType;
template<IsCallable T>
using CallableRetT = typename IsCallableHelper<T>::Signature::RetType;
} // namespace based
} // namespace based::trait
diff --git a/ include/based/concept/comparable/equal.hpp b/ include/based/concept/comparable/equal.hpp
@@ -3,19 +3,17 @@
#include "based/concept/is_same.hpp"
#include "based/trait/remove_reference.hpp"
namespace based
namespace based::trait
{
// clang-format off
template<typename T>
concept EqualComparable = requires(
const trait::RemoveReference<T>& lhs, const trait::RemoveReference<T>& rhs
) {
{ lhs == rhs } -> trait::IsSame<bool>;
{ rhs == lhs } -> trait::IsSame<bool>;
template<class T>
concept EqualComparable = requires
(const RemoveReference<T>& lhs, const RemoveReference<T>& rhs)
{
{ lhs == rhs } -> IsSame<bool>;
{ rhs == lhs } -> IsSame<bool>;
};
// clang-format on
} // namespace based
} // namespace based::trait
diff --git a/ include/based/concept/comparable/equality.hpp b/ include/based/concept/comparable/equality.hpp
@@ -3,17 +3,15 @@
#include "based/concept/comparable/equal.hpp"
#include "based/concept/comparable/not_equal.hpp"
namespace based
namespace based::trait
{
// clang-format off
template<typename T>
template<class T>
concept EqualityComparable = requires {
requires(EqualComparable<T>);
requires(NotEqualComparable<T>);
};
// clang-format on
} // namespace based
} // namespace based::trait
diff --git a/ include/based/concept/comparable/greater.hpp b/ include/based/concept/comparable/greater.hpp
@@ -3,19 +3,17 @@
#include "based/concept/is_same.hpp"
#include "based/trait/remove_reference.hpp"
namespace based
namespace based::trait
{
// clang-format off
template<typename T>
template<class T>
concept GreaterComparable = requires
(const trait::RemoveReference<T>& lhs, const trait::RemoveReference<T>& rhs)
(const RemoveReference<T>& lhs, const RemoveReference<T>& rhs)
{
{lhs > rhs} -> trait::IsSame<bool>;
{rhs > lhs} -> trait::IsSame<bool>;
{lhs > rhs} -> IsSame<bool>;
{rhs > lhs} -> IsSame<bool>;
};
// clang-format on
} // namespace based
} // namespace based::trait
diff --git a/ include/based/concept/comparable/greater_equal.hpp b/ include/based/concept/comparable/greater_equal.hpp
@@ -3,19 +3,17 @@
#include "based/concept/is_same.hpp"
#include "based/trait/remove_reference.hpp"
namespace based
namespace based::trait
{
// clang-format off
template<typename T>
template<class T>
concept LessEqualComparable = requires
(const trait::RemoveReference<T>& lhs, const trait::RemoveReference<T>& rhs)
(const RemoveReference<T>& lhs, const RemoveReference<T>& rhs)
{
{lhs <= rhs} -> trait::IsSame<bool>;
{rhs <= lhs} -> trait::IsSame<bool>;
{lhs <= rhs} -> IsSame<bool>;
{rhs <= lhs} -> IsSame<bool>;
};
// clang-format on
} // namespace based
} // namespace based::trait
diff --git a/ include/based/concept/comparable/less.hpp b/ include/based/concept/comparable/less.hpp
@@ -3,19 +3,17 @@
#include "based/concept/is_same.hpp"
#include "based/trait/remove_reference.hpp"
namespace based
namespace based::trait
{
// clang-format off
template<typename T>
template<class T>
concept LessComparable = requires
(const trait::RemoveReference<T>& lhs, const trait::RemoveReference<T>& rhs)
(const RemoveReference<T>& lhs, const RemoveReference<T>& rhs)
{
{lhs < rhs} -> trait::IsSame<bool>;
{rhs < lhs} -> trait::IsSame<bool>;
{lhs < rhs} -> IsSame<bool>;
{rhs < lhs} -> IsSame<bool>;
};
// clang-format on
} // namespace based
} // namespace based::trait
diff --git a/ include/based/concept/comparable/less_equal.hpp b/ include/based/concept/comparable/less_equal.hpp
@@ -3,19 +3,17 @@
#include "based/concept/is_same.hpp"
#include "based/trait/remove_reference.hpp"
namespace based
namespace based::trait
{
// clang-format off
template<typename T>
template<class T>
concept GreaterEqualComparable = requires
(const trait::RemoveReference<T>& lhs, const trait::RemoveReference<T>& rhs)
(const RemoveReference<T>& lhs, const RemoveReference<T>& rhs)
{
{lhs >= rhs} -> trait::IsSame<bool>;
{rhs >= lhs} -> trait::IsSame<bool>;
{lhs >= rhs} -> IsSame<bool>;
{rhs >= lhs} -> IsSame<bool>;
};
// clang-format on
} // namespace based
} // namespace based::trait
diff --git a/ include/based/concept/comparable/not_equal.hpp b/ include/based/concept/comparable/not_equal.hpp
@@ -3,19 +3,17 @@
#include "based/concept/is_same.hpp"
#include "based/trait/remove_reference.hpp"
namespace based
namespace based::trait
{
// clang-format off
template<typename T>
template<class T>
concept NotEqualComparable = requires
(const trait::RemoveReference<T>& lhs, const trait::RemoveReference<T>& rhs)
(const RemoveReference<T>& lhs, const RemoveReference<T>& rhs)
{
{lhs != rhs} -> trait::IsSame<bool>;
{rhs != lhs} -> trait::IsSame<bool>;
{lhs != rhs} -> IsSame<bool>;
{rhs != lhs} -> IsSame<bool>;
};
// clang-format on
} // namespace based
} // namespace based::trait
diff --git a/ include/based/concept/is_arithmetic.hpp b/ include/based/concept/is_arithmetic.hpp
@@ -2,7 +2,6 @@
#include "based/concept/is_floating_point.hpp"
#include "based/concept/is_integral.hpp"
#include "based/trait/integral_constant.hpp"
namespace based::trait
{
diff --git a/ include/based/concept/is_array.hpp b/ include/based/concept/is_array.hpp
@@ -11,15 +11,15 @@
namespace detail
// clang-format off
// NOLINTBEGIN(*array*)
template<class T> struct IsArray : FalseType {};
template<class T> struct IsArray<T[]> : TrueType {};
template<class T, SizeT n> struct IsArray<T[n]> : TrueType {};
template<class T> struct IsArrayHelper : FalseType {};
template<class T> struct IsArrayHelper<T[]> : TrueType {};
template<class T, SizeT n> struct IsArrayHelper<T[n]> : TrueType {};
// NOLINTEND(*array*)
// clang-format on
} // namespace detail
template<class T>
concept IsArray = detail::IsArray<T>::value;
concept IsArray = detail::IsArrayHelper<T>::value;
} // namespace based::trait
diff --git a/ include/based/concept/is_const.hpp b/ include/based/concept/is_const.hpp
@@ -9,13 +9,13 @@
namespace detail
{
// clang-format off
template<class T> struct IsConst : FalseType {};
template<class T> struct IsConst<const T> : TrueType {};
template<class T> struct IsConstHelper : FalseType {};
template<class T> struct IsConstHelper<const T> : TrueType {};
// clang-format on
} // namespace detail
template<class T>
concept IsConst = detail::IsConst<T>::value;
concept IsConst = detail::IsConstHelper<T>::value;
} // namespace based::trait
diff --git a/ include/based/concept/is_function.hpp b/ include/based/concept/is_function.hpp
@@ -10,82 +10,82 @@
namespace detail
// clang-format off
template<typename>
struct IsFunction : FalseType {};
template<class>
struct IsFunctionHelper : FalseType {};
template<typename Ret, bool ne, typename... Args>
struct IsFunction<Ret(Args...) noexcept(ne)> : TrueType {};
template<class Ret, bool ne, class... Args>
struct IsFunctionHelper<Ret(Args...) noexcept(ne)> : TrueType {};
template<typename Ret, bool ne, typename... Args>
struct IsFunction<Ret(Args...) & noexcept(ne)> : TrueType {};
template<class Ret, bool ne, class... Args>
struct IsFunctionHelper<Ret(Args...) & noexcept(ne)> : TrueType {};
template<typename Ret, bool ne, typename... Args>
struct IsFunction<Ret(Args...) && noexcept(ne)> : TrueType {};
template<class Ret, bool ne, class... Args>
struct IsFunctionHelper<Ret(Args...) && noexcept(ne)> : TrueType {};
template<typename Ret, bool ne, typename... Args>
struct IsFunction<Ret(Args...) const noexcept(ne)> : TrueType {};
template<class Ret, bool ne, class... Args>
struct IsFunctionHelper<Ret(Args...) const noexcept(ne)> : TrueType {};
template<typename Ret, bool ne, typename... Args>
struct IsFunction<Ret(Args...) const & noexcept(ne)> : TrueType {};
template<class Ret, bool ne, class... Args>
struct IsFunctionHelper<Ret(Args...) const & noexcept(ne)> : TrueType {};
template<typename Ret, bool ne, typename... Args>
struct IsFunction<Ret(Args...) const && noexcept(ne)> : TrueType {};
template<class Ret, bool ne, class... Args>
struct IsFunctionHelper<Ret(Args...) const && noexcept(ne)> : TrueType {};
template<typename Ret, bool ne, typename... Args>
struct IsFunction<Ret(Args...) volatile noexcept(ne)> : TrueType {};
template<class Ret, bool ne, class... Args>
struct IsFunctionHelper<Ret(Args...) volatile noexcept(ne)> : TrueType {};
template<typename Ret, bool ne, typename... Args>
struct IsFunction<Ret(Args...) volatile & noexcept(ne)> : TrueType {};
template<class Ret, bool ne, class... Args>
struct IsFunctionHelper<Ret(Args...) volatile & noexcept(ne)> : TrueType {};
template<typename Ret, bool ne, typename... Args>
struct IsFunction<Ret(Args...) volatile && noexcept(ne)> : TrueType {};
template<class Ret, bool ne, class... Args>
struct IsFunctionHelper<Ret(Args...) volatile && noexcept(ne)> : TrueType {};
template<typename Ret, bool ne, typename... Args>
struct IsFunction<Ret(Args...) const volatile noexcept(ne)> : TrueType {};
template<class Ret, bool ne, class... Args>
struct IsFunctionHelper<Ret(Args...) const volatile noexcept(ne)> : TrueType {};
template<typename Ret, bool ne, typename... Args>
struct IsFunction<Ret(Args...) const volatile & noexcept(ne)> : TrueType {};
template<class Ret, bool ne, class... Args>
struct IsFunctionHelper<Ret(Args...) const volatile & noexcept(ne)> : TrueType {};
template<typename Ret, bool ne, typename... Args>
struct IsFunction<Ret(Args...) const volatile && noexcept(ne)> : TrueType {};
template<class Ret, bool ne, class... Args>
struct IsFunctionHelper<Ret(Args...) const volatile && noexcept(ne)> : TrueType {};
// NOLINTBEGIN(*ambiguous-ellipsis*)
template<typename Ret, bool ne, typename... Args>
struct IsFunction<Ret(Args......) noexcept(ne)> : TrueType {};
template<class Ret, bool ne, class... Args>
struct IsFunctionHelper<Ret(Args......) noexcept(ne)> : TrueType {};
template<typename Ret, bool ne, typename... Args>
struct IsFunction<Ret(Args......) & noexcept(ne)> : TrueType {};
template<class Ret, bool ne, class... Args>
struct IsFunctionHelper<Ret(Args......) & noexcept(ne)> : TrueType {};
template<typename Ret, bool ne, typename... Args>
struct IsFunction<Ret(Args......) && noexcept(ne)> : TrueType {};
template<class Ret, bool ne, class... Args>
struct IsFunctionHelper<Ret(Args......) && noexcept(ne)> : TrueType {};
template<typename Ret, bool ne, typename... Args>
struct IsFunction<Ret(Args......) const noexcept(ne)> : TrueType {};
template<class Ret, bool ne, class... Args>
struct IsFunctionHelper<Ret(Args......) const noexcept(ne)> : TrueType {};
template<typename Ret, bool ne, typename... Args>
struct IsFunction<Ret(Args......) const & noexcept(ne)> : TrueType {};
template<class Ret, bool ne, class... Args>
struct IsFunctionHelper<Ret(Args......) const & noexcept(ne)> : TrueType {};
template<typename Ret, bool ne, typename... Args>
struct IsFunction<Ret(Args......) const && noexcept(ne)> : TrueType {};
template<class Ret, bool ne, class... Args>
struct IsFunctionHelper<Ret(Args......) const && noexcept(ne)> : TrueType {};
template<typename Ret, bool ne, typename... Args>
struct IsFunction<Ret(Args......) volatile noexcept(ne)> : TrueType {};
template<class Ret, bool ne, class... Args>
struct IsFunctionHelper<Ret(Args......) volatile noexcept(ne)> : TrueType {};
template<typename Ret, bool ne, typename... Args>
struct IsFunction<Ret(Args......) volatile & noexcept(ne)> : TrueType {};
template<class Ret, bool ne, class... Args>
struct IsFunctionHelper<Ret(Args......) volatile & noexcept(ne)> : TrueType {};
template<typename Ret, bool ne, typename... Args>
struct IsFunction<Ret(Args......) volatile && noexcept(ne)> : TrueType {};
template<class Ret, bool ne, class... Args>
struct IsFunctionHelper<Ret(Args......) volatile && noexcept(ne)> : TrueType {};
template<typename Ret, bool ne, typename... Args>
struct IsFunction<Ret(Args......) const volatile noexcept(ne)> : TrueType {};
template<class Ret, bool ne, class... Args>
struct IsFunctionHelper<Ret(Args......) const volatile noexcept(ne)> : TrueType {};
template<typename Ret, bool ne, typename... Args>
struct IsFunction<Ret(Args......) const volatile & noexcept(ne)> : TrueType {};
template<class Ret, bool ne, class... Args>
struct IsFunctionHelper<Ret(Args......) const volatile & noexcept(ne)> : TrueType {};
template<typename Ret, bool ne, typename... Args>
struct IsFunction<Ret(Args......) const volatile && noexcept(ne)> : TrueType {};
template<class Ret, bool ne, class... Args>
struct IsFunctionHelper<Ret(Args......) const volatile && noexcept(ne)> : TrueType {};
// NOLINTEND(*ambiguous-ellipsis*)
@@ -94,6 +94,6 @@
struct IsFunction<Ret(Args......) const volatile && noexcept(ne)> : TrueType {};
} // namespace detail
template<class T>
concept IsFunction = detail::IsFunction<T>::value;
concept IsFunction = detail::IsFunctionHelper<T>::value;
} // namespace based::trait
diff --git a/ include/based/concept/is_invocable.hpp b/ include/based/concept/is_invocable.hpp
@@ -5,10 +5,10 @@
namespace based::trait
{
template<typename P, typename... Args>
template<class P, class... Args>
concept IsInvocable = std::is_invocable_v<P, Args...>;
template<typename P, typename... Args>
template<class P, class... Args>
concept IsNothrowInvocable = std::is_nothrow_invocable_v<P, Args...>;
} // namespace based::trait
diff --git a/ include/based/concept/is_lvalue_reference.hpp b/ include/based/concept/is_lvalue_reference.hpp
@@ -9,13 +9,13 @@
namespace detail
{
// clang-format off
template<class T> struct IsLvalueReference : FalseType {};
template<class T> struct IsLvalueReference<T&> : TrueType {};
template<class T> struct IsLValueRefeHelper : FalseType {};
template<class T> struct IsLValueRefeHelper<T&> : TrueType {};
// clang-format on
} // namespace detail
template<class T>
concept IsLvalueReference = detail::IsLvalueReference<T>::value;
concept IsLValueRef = detail::IsLValueRefeHelper<T>::value;
} // namespace based::trait
diff --git a/ include/based/concept/is_member_pointer.hpp b/ include/based/concept/is_member_pointer.hpp
@@ -10,13 +10,13 @@
namespace detail
{
// clang-format off
template<class T> struct IsMemberPointer : FalseType {};
template<class T, class U> struct IsMemberPointer<T U::*> : TrueType {};
template<class T> struct IsMemberPointerHelper : FalseType {};
template<class T, class U> struct IsMemberPointerHelper<T U::*> : TrueType {};
// clang-format on
} // namespace detail
template<class T>
concept IsMemberPointer = detail::IsMemberPointer<RemoveCv<T>>::value;
concept IsMemberPointer = detail::IsMemberPointerHelper<RemoveCv<T>>::value;
} // namespace based::trait
diff --git a/ include/based/concept/is_pointer.hpp b/ include/based/concept/is_pointer.hpp
@@ -9,16 +9,16 @@
namespace detail
{
// clang-format off
template<class T> struct IsPointer : FalseType {};
template<class T> struct IsPointer<T*> : TrueType {};
template<class T> struct IsPointer<T* const> : TrueType {};
template<class T> struct IsPointer<T* volatile> : TrueType {};
template<class T> struct IsPointer<T* const volatile> : TrueType {};
template<class T> struct IsPointerHelper : FalseType {};
template<class T> struct IsPointerHelper<T*> : TrueType {};
template<class T> struct IsPointerHelper<T* const> : TrueType {};
template<class T> struct IsPointerHelper<T* volatile> : TrueType {};
template<class T> struct IsPointerHelper<T* const volatile> : TrueType {};
// clang-format on
} // namespace detail
template<class T>
concept IsPointer = detail::IsPointer<T>::value;
concept IsPointer = detail::IsPointerHelper<T>::value;
} // namespace based::trait
diff --git a/ include/based/concept/is_reference_wrapper.hpp b/ include/based/concept/is_reference_wrapper.hpp
@@ -9,13 +9,13 @@
namespace detail
{
// clang-format off
template<class T> struct IsReferenceWrapper : FalseType {};
template<class U> struct IsReferenceWrapper<ReferenceWrapper<U>> : TrueType {};
template<class T> struct IsRefWrapperHelper : FalseType {};
template<class U> struct IsRefWrapperHelper<RefWrapper<U>> : TrueType {};
// clang-format on
} // namespace detail
template<class T>
concept IsReferenceWrapper = detail::IsReferenceWrapper<T>::value;
concept IsRefWrapper = detail::IsRefWrapperHelper<T>::value;
} // namespace based::trait
diff --git a/ include/based/concept/is_regular.hpp b/ include/based/concept/is_regular.hpp
@@ -7,10 +7,10 @@
namespace based::trait
{
template<typename T>
concept Regular = std::regular<T>;
template<class T>
concept IsRegular = std::regular<T>;
template<typename T>
concept BareRegular = Regular<RemoveCvref<T>>;
template<class T>
concept IsRegularBare = IsRegular<RemoveCvref<T>>;
} // namespace based::trait
diff --git a/ include/based/concept/is_rvalue_reference.hpp b/ include/based/concept/is_rvalue_reference.hpp
@@ -9,13 +9,13 @@
namespace detail
{
// clang-format off
template<class T> struct IsRvalueReference : FalseType {};
template<class T> struct IsRvalueReference<T&&> : TrueType {};
template<class T> struct IsRValueRefHelper : FalseType {};
template<class T> struct IsRValueRefHelper<T&&> : TrueType {};
// clang-format on
} // namespace detail
template<class T>
concept IsRvalueReference = detail::IsRvalueReference<T>::value;
concept IsRValueRef = detail::IsRValueRefHelper<T>::value;
} // namespace based::trait
diff --git a/ include/based/concept/is_same.hpp b/ include/based/concept/is_same.hpp
@@ -10,14 +10,15 @@
namespace detail
{
// clang-format off
template<class T, class U> struct IsSame : FalseType {};
template<class T> struct IsSame<T, T> : TrueType {};
template<class T, class U> struct IsSameHelper : FalseType {};
template<class T> struct IsSameHelper<T, T> : TrueType {};
// clang-format on
} // namespace detail
template<class T, class U>
concept IsSame = detail::IsSame<T, U>::value && detail::IsSame<U, T>::value;
concept IsSame =
detail::IsSameHelper<T, U>::value && detail::IsSameHelper<U, T>::value;
template<class T, class U>
concept IsSameBare = IsSame<RemoveCvref<T>, RemoveCvref<U>>;
diff --git a/ include/based/concept/is_semiregular.hpp b/ include/based/concept/is_semiregular.hpp
@@ -7,10 +7,10 @@
namespace based::trait
{
template<typename T>
concept Semiregular = std::semiregular<T>;
template<class T>
concept IsSemiregular = std::semiregular<T>;
template<typename T>
concept BareSemiregular = Semiregular<RemoveCvref<T>>;
template<class T>
concept IsSemiregularBare = IsSemiregular<RemoveCvref<T>>;
} // namespace based::trait
diff --git a/ include/based/concept/iterator.hpp b/ include/based/concept/iterator.hpp
@@ -4,48 +4,48 @@
#include "based/concept/is_same.hpp"
#include "based/trait/iterator.hpp"
namespace based
namespace based::trait
{
// clang-format off
template<typename T>
concept Readable = requires(T val) {
requires(trait::Regular<T>);
typename iter_value_t<T>;
template<class T>
concept IsReadable = requires(T val) {
requires(IsRegular<T>);
typename IterValueT<T>;
{
*val
} -> trait::IsSameBare<iter_value_t<T>>;
} -> IsSameBare<IterValueT<T>>;
};
template<typename T>
concept Iterator = requires(T val) {
requires(trait::Regular<T>);
typename iter_dist_t<T>;
template<class T>
concept IsIterator = requires(T val) {
requires(IsRegular<T>);
typename IterDistT<T>;
{
++val
} -> trait::IsSameBare<T>;
} -> IsSameBare<T>;
// successor is not necessarily regular
};
template<typename T>
concept ForwardIterator = requires {
requires(Iterator<T>);
template<class T>
concept IsIteratorForward = requires {
requires(IsIterator<T>);
// successor is regular
};
template<typename T>
concept ReadableIterator = requires {
requires(Iterator<T>);
requires(Readable<T>);
template<class T>
concept IsIteratorReadable = requires {
requires(IsIterator<T>);
requires(IsReadable<T>);
};
template<typename T>
concept ReadableForwardIterator = requires {
requires(ForwardIterator<T>);
requires(Readable<T>);
template<class T>
concept IsIteratorForwardReadable = requires {
requires(IsIteratorForward<T>);
requires(IsReadable<T>);
};
// clang-format on
} // namespace based
} // namespace based::trait
diff --git a/ include/based/concept/ordered/totally.hpp b/ include/based/concept/ordered/totally.hpp
@@ -6,20 +6,16 @@
#include "based/concept/comparable/less.hpp"
#include "based/concept/comparable/less_equal.hpp"
namespace based
namespace based::trait
{
// clang-format off
template<typename T>
template<class T>
concept TotallyOrdered = requires {
requires(EqualityComparable<T>);
requires(LessComparable<T>);
requires(GreaterComparable<T>);
requires(LessEqualComparable<T>);
requires(GreaterEqualComparable<T>);
requires(EqualityComparable<T>);
requires(LessComparable<T>);
requires(GreaterComparable<T>);
requires(LessEqualComparable<T>);
requires(GreaterEqualComparable<T>);
};
// clang-format on
} // namespace based
} // namespace based::trait
diff --git a/ include/based/concept/procedure/domain.hpp b/ include/based/concept/procedure/domain.hpp
@@ -12,32 +12,30 @@
#include "based/trait/remove_pointer.hpp"
#include "based/trait/remove_reference.hpp"
namespace based
namespace based::trait
{
template<typename T>
concept Input = trait::IsSame<T, trait::RemoveCvref<trait::RemovePointer<T>>>
|| trait::IsConst<trait::RemoveReference<T>>
|| trait::IsConst<trait::RemovePointer<T>>;
template<class T>
concept IsInput = IsSame<T, RemoveCvref<RemovePointer<T>>>
|| IsConst<RemoveReference<T>> || IsConst<RemovePointer<T>>;
template<SizeT idx, typename... Args>
template<SizeT idx, class... Args>
requires(idx < sizeof...(Args))
using ElemT = std::tuple_element_t<idx, std::tuple<Args...>>;
template<typename... Args>
concept SemiregularDomain =
(trait::Semiregular<trait::RemoveCvref<Args>> && ...);
template<class... Args>
concept IsDomainSemiregular = (IsSemiregular<RemoveCvref<Args>> && ...);
template<typename... Args>
concept RegularDomain = (trait::Regular<trait::RemoveCvref<Args>> && ...);
template<class... Args>
concept IsDomainRegular = (IsRegular<RemoveCvref<Args>> && ...);
template<typename... Args>
concept InputDomain = (Input<Args> && ...);
template<class... Args>
concept IsDomainInput = (IsInput<Args> && ...);
template<typename... Args>
concept HomogeneousDomain = (trait::IsSame<ElemT<0, Args...>, Args> && ...);
template<class... Args>
concept IsDomainHomogeneous = (IsSame<ElemT<0, Args...>, Args> && ...);
template<typename P, typename... Args>
using RetT = InvokeResultT<P, Args...>;
template<class P, class... Args>
using RetT = InvokeResult<P, Args...>;
} // namespace based
} // namespace based::trait
diff --git a/ include/based/concept/procedure/function.hpp b/ include/based/concept/procedure/function.hpp
@@ -3,26 +3,26 @@
#include "based/concept/procedure/domain.hpp"
#include "based/concept/procedure/procedure.hpp"
namespace based
namespace based::trait
{
template<typename P, typename Ret, typename... Args>
concept FunctionalProcedure = requires {
requires(RegularProcedure<P, Ret, Args...>);
requires(InputDomain<Args...>);
template<class P, class Ret, class... Args>
concept IsProcedureFunctional = requires {
requires(IsProcedureRegular<P, Ret, Args...>);
requires(IsDomainInput<Args...>);
};
template<typename P, typename Ret, typename Arg>
concept UnaryFunction = requires {
requires(FunctionalProcedure<P, Ret, Arg>);
requires(UnaryProcedure<P, Ret, Arg>);
template<class P, class Ret, class Arg>
concept IsFunctionUnary = requires {
requires(IsProcedureFunctional<P, Ret, Arg>);
requires(IsProcedureUnary<P, Ret, Arg>);
};
template<typename P, typename Ret, typename... Args>
concept HomogeneousFunction = requires {
requires(FunctionalProcedure<P, Ret, Args...>);
template<class P, class Ret, class... Args>
concept IsFunctionHomogeneous = requires {
requires(IsProcedureFunctional<P, Ret, Args...>);
requires(sizeof...(Args) > 0);
requires(HomogeneousDomain<Args...>);
requires(IsDomainHomogeneous<Args...>);
};
} // namespace based
} // namespace based::trait
diff --git a/ include/based/concept/procedure/function_iter.hpp b/ include/based/concept/procedure/function_iter.hpp
@@ -3,25 +3,25 @@
#include "based/concept/iterator.hpp"
#include "based/concept/procedure/function.hpp"
namespace based
namespace based::trait
{
template<typename P, typename Ret, typename I>
concept IterFunctionalProcedure = requires {
requires(Iterator<I>);
requires(FunctionalProcedure<P, Ret, iter_value_t<I>>);
template<class P, class Ret, class I>
concept IsProcedureFunctionalIter = requires {
requires(IsIterator<I>);
requires(IsProcedureFunctional<P, Ret, IterValueT<I>>);
};
template<typename P, typename Ret, typename I>
concept IterUnaryFunction = requires {
requires(Iterator<I>);
requires(UnaryFunction<P, Ret, iter_value_t<I>>);
template<class P, class Ret, class I>
concept IsFunctionUnaryIter = requires {
requires(IsIterator<I>);
requires(IsFunctionUnary<P, Ret, IterValueT<I>>);
};
template<typename P, typename Ret, typename I>
concept IterHomogeneousFunction = requires {
requires(Iterator<I>);
requires(HomogeneousFunction<P, Ret, iter_value_t<I>>);
template<class P, class Ret, class I>
concept IsFunctionHomogeneousIter = requires {
requires(IsIterator<I>);
requires(IsFunctionHomogeneous<P, Ret, IterValueT<I>>);
};
} // namespace based
} // namespace based::trait
diff --git a/ include/based/concept/procedure/operation.hpp b/ include/based/concept/procedure/operation.hpp
@@ -2,22 +2,19 @@
#include "based/concept/procedure/function.hpp"
namespace based
namespace based::trait
{
template<typename P, typename... Args>
concept Operation = HomogeneousFunction<P, elem_t<0, Args...>, Args...>;
template<class P, class... Args>
concept IsOperation = IsFunctionHomogeneous<P, ElemT<0, Args...>, Args...>;
template<typename P, typename Ret, typename Arg>
concept Transformation = requires {
requires(Operation<P, Ret, Arg>);
requires(UnaryFunction<P, Ret, Arg>);
template<class P, class Ret, class Arg>
concept IsTransformation = requires {
requires(IsOperation<P, Ret, Arg>);
requires(IsFunctionUnary<P, Ret, Arg>);
};
template<typename P, typename Arg>
concept BinaryOperation = Operation<P, Arg, Arg>;
template<class P, class Arg>
concept IsOperationBinary = IsOperation<P, Arg, Arg>;
template<typename P, typename Arg>
concept AssociativeBinaryOperation = Operation<P, Arg, Arg>;
} // namespace based
} // namespace based::trait
diff --git a/ include/based/concept/procedure/operation_iter.hpp b/ include/based/concept/procedure/operation_iter.hpp
@@ -3,19 +3,19 @@
#include "based/concept/iterator.hpp"
#include "based/concept/procedure/operation.hpp"
namespace based
namespace based::trait
{
template<typename P, typename Ret, typename... I>
concept IterOperation = requires {
requires(Iterator<I> && ...);
requires(Operation<P, iter_value_t<I>...>);
template<class P, class Ret, class... I>
concept IsOperationIter = requires {
requires(IsIterator<I> && ...);
requires(IsOperation<P, IterValueT<I>...>);
};
template<typename P, typename Ret, typename I>
concept IterBinaryOperation = requires {
requires(Iterator<I>);
requires(BinaryOperation<P, iter_value_t<I>>);
template<class P, class Ret, class I>
concept IsBinaryOperationIter = requires {
requires(IsIterator<I>);
requires(IsOperationBinary<P, IterValueT<I>>);
};
} // namespace based
} // namespace based::trait
diff --git a/ include/based/concept/procedure/predicate.hpp b/ include/based/concept/procedure/predicate.hpp
@@ -2,25 +2,25 @@
#include "based/concept/procedure/function.hpp"
namespace based
namespace based::trait
{
template<typename P, typename... Args>
concept Predicate = FunctionalProcedure<P, bool, Args...>;
template<class P, class... Args>
concept IsPredicate = IsProcedureFunctional<P, bool, Args...>;
template<typename P, typename... Args>
concept HomogeneousPredicate = requires {
requires(Predicate<P, Args...>);
requires(HomogeneousFunction<P, bool, Args...>);
template<class P, class... Args>
concept IsPredicateHomogeneous = requires {
requires(IsPredicate<P, Args...>);
requires(IsFunctionHomogeneous<P, bool, Args...>);
};
template<typename P, typename Arg>
concept UnaryPredicate = requires {
requires(Predicate<P, Arg>);
requires(UnaryFunction<P, bool, Arg>);
template<class P, class Arg>
concept IsPredicateUnary = requires {
requires(IsPredicate<P, Arg>);
requires(IsFunctionUnary<P, bool, Arg>);
};
template<typename P, typename Arg>
concept Relation = HomogeneousPredicate<P, Arg, Arg>;
template<class P, class Arg>
concept IsRelation = IsPredicateHomogeneous<P, Arg, Arg>;
} // namespace based
} // namespace based::trait
diff --git a/ include/based/concept/procedure/predicate_iter.hpp b/ include/based/concept/procedure/predicate_iter.hpp
@@ -3,31 +3,31 @@
#include "based/concept/iterator.hpp"
#include "based/concept/procedure/predicate.hpp"
namespace based
namespace based::trait
{
template<typename P, typename... I>
concept IterPredicate = requires {
requires(Iterator<I> && ...);
requires(Predicate<P, iter_value_t<I>...>);
template<class P, class... I>
concept IsPredicateIter = requires {
requires(IsIterator<I> && ...);
requires(IsPredicate<P, IterValueT<I>...>);
};
template<typename P, typename... I>
concept IterHomogeneousPredicate = requires {
requires(Iterator<I> && ...);
requires(HomogeneousPredicate<P, iter_value_t<I>...>);
template<class P, class... I>
concept IsPredicateHomogeneousIter = requires {
requires(IsIterator<I> && ...);
requires(IsPredicateHomogeneous<P, IterValueT<I>...>);
};
template<typename P, typename I>
concept IterUnaryPredicate = requires {
requires(Iterator<I>);
requires(UnaryPredicate<P, iter_value_t<I>>);
template<class P, class I>
concept IsPredicateUnaryIter = requires {
requires(IsIterator<I>);
requires(IsPredicateUnary<P, IterValueT<I>>);
};
template<typename P, typename I>
concept IterRelation = requires {
requires(Iterator<I>);
requires(Relation<P, iter_value_t<I>>);
template<class P, class I>
concept IsRelationIter = requires {
requires(IsIterator<I>);
requires(IsRelation<P, IterValueT<I>>);
};
} // namespace based
} // namespace based::trait
diff --git a/ include/based/concept/procedure/procedure.hpp b/ include/based/concept/procedure/procedure.hpp
@@ -7,7 +7,7 @@
#include "based/trait/integral_constant.hpp"
#include "based/trait/invoke_result.hpp"
namespace based
namespace based::trait
{
namespace detail
@@ -15,34 +15,31 @@
namespace detail
// clang-format off
template<typename P, typename Sig> struct Procedure : public FalseType {};
template<class P, class Sig> struct IsProcedureHelper : public FalseType {};
template<typename P, typename Ret, typename... Args>
requires (trait::IsInvocable<P, Args...> && trait::IsConvertible<InvokeResultT<P, Args...>, Ret>)
struct Procedure<P, Ret(Args...)> : public TrueType {};
template<class P, class Ret, class... Args>
requires (IsInvocable<P, Args...> && IsConvertible<InvokeResult<P, Args...>, Ret>)
struct IsProcedureHelper<P, Ret(Args...)> : public TrueType {};
template<typename P, typename... Args>
requires (trait::IsInvocable<P, Args...>)
struct Procedure<P, void(Args...)> : public TrueType {};
template<typename P, typename Ret, typename... Args>
static constexpr bool procedure_v = Procedure<P, Ret(Args...)>::value;
template<class P, class... Args>
requires (IsInvocable<P, Args...>)
struct IsProcedureHelper<P, void(Args...)> : public TrueType {};
// clang-format on
} // namespace detail
template<typename P, typename Ret, typename... Args>
concept Procedure = detail::procedure_v<P, Ret, Args...>;
template<class P, class Ret, class... Args>
concept IsProcedure = detail::IsProcedureHelper<P, Ret(Args...)>::value;
template<typename P, typename Ret, typename Arg>
concept UnaryProcedure = Procedure<P, Ret, Arg>;
template<class P, class Ret, class Arg>
concept IsProcedureUnary = IsProcedure<P, Ret, Arg>;
template<typename P, typename Ret, typename... Args>
concept RegularProcedure = requires {
requires(Procedure<P, Ret, Args...>);
requires(RegularDomain<Args...>);
requires(trait::Regular<RetT<P, Args...>>);
template<class P, class Ret, class... Args>
concept IsProcedureRegular = requires {
requires(IsProcedure<P, Ret, Args...>);
requires(IsDomainRegular<Args...>);
requires(IsRegular<RetT<P, Args...>>);
};
} // namespace based
} // namespace based::trait
diff --git a/ include/based/concept/procedure/procedure_iter.hpp b/ include/based/concept/procedure/procedure_iter.hpp
@@ -3,25 +3,25 @@
#include "based/concept/iterator.hpp"
#include "based/concept/procedure/procedure.hpp"
namespace based
namespace based::trait
{
template<typename P, typename Ret, typename I>
concept IterProcedure = requires {
requires(Iterator<I>);
requires(Procedure<P, Ret, iter_value_t<I>>);
template<class P, class Ret, class I>
concept IsProcedureIter = requires {
requires(IsIterator<I>);
requires(IsProcedure<P, Ret, IterValueT<I>>);
};
template<typename P, typename Ret, typename I>
concept IterUnaryProcedure = requires {
requires(Iterator<I>);
requires(UnaryProcedure<P, Ret, iter_value_t<I>>);
template<class P, class Ret, class I>
concept IsProcedureUnaryIter = requires {
requires(IsIterator<I>);
requires(IsProcedureUnary<P, Ret, IterValueT<I>>);
};
template<typename P, typename Ret, typename I>
concept Itertrait::RegularProcedure = requires {
requires(Iterator<I>);
requires(trait::RegularProcedure<P, Ret, iter_value_t<I>>);
template<class P, class Ret, class I>
concept IsProcedureRegularIter = requires {
requires(IsIterator<I>);
requires(trait::IsProcedureRegular<P, Ret, IterValueT<I>>);
};
} // namespace based
} // namespace based::trait
diff --git a/ include/based/functional/reference_wrapper.hpp b/ include/based/functional/reference_wrapper.hpp
@@ -22,7 +22,7 @@
template<class T> void fun(T&&) = delete;
} // namespace detail
template<class T>
class ReferenceWrapper
class RefWrapper
{
public:
// types
@@ -32,23 +32,23 @@
public:
template<class U>
requires(requires {
detail::fun<T>(declval<U>());
requires(!trait::IsSame<ReferenceWrapper, trait::RemoveCvref<U>>);
requires(!trait::IsSame<RefWrapper, trait::RemoveCvref<U>>);
})
// NOLINTNEXTLINE(*explicit*)
constexpr ReferenceWrapper(U&& obj
constexpr RefWrapper(U&& obj
) noexcept(noexcept(detail::fun<T>(based::forward<U>(obj))))
: m_ptr(addressof(detail::fun<T>(based::forward<U>(obj))))
{
}
ReferenceWrapper(const ReferenceWrapper&) noexcept = default;
ReferenceWrapper& operator=(const ReferenceWrapper& x) noexcept = default;
RefWrapper(const RefWrapper&) noexcept = default;
RefWrapper& operator=(const RefWrapper& x) noexcept = default;
ReferenceWrapper(ReferenceWrapper&&) noexcept = delete;
ReferenceWrapper& operator=(ReferenceWrapper&& x) noexcept = delete;
RefWrapper(RefWrapper&&) noexcept = delete;
RefWrapper& operator=(RefWrapper&& x) noexcept = delete;
~ReferenceWrapper() = default;
~RefWrapper() = default;
// NOLINTBEGIN(*explicit*)
constexpr operator T&() const noexcept { return *m_ptr; }
@@ -68,6 +68,6 @@
private:
// deduction guides
template<class T>
ReferenceWrapper(T&) -> ReferenceWrapper<T>;
RefWrapper(T&) -> RefWrapper<T>;
} // namespace based
diff --git a/ include/based/trait/add_lvalue_reference.hpp b/ include/based/trait/add_lvalue_reference.hpp
@@ -15,13 +15,13 @@
template<class T> // Handle T = cv void case
auto try_add(...) -> TypeIdentity<T>;
template<class T>
struct AddLvalueReference : decltype(detail::try_add<T>(0))
struct AddLvalueReferenceHelper : decltype(detail::try_add<T>(0))
{
};
} // namespace detail
template<class T>
using AddLvalueReference = detail::AddLvalueReference<T>::Type;
using AddLvalueReference = typename detail::AddLvalueReferenceHelper<T>::Type;
} // namespace based::trait
diff --git a/ include/based/trait/add_pointer.hpp b/ include/based/trait/add_pointer.hpp
@@ -10,19 +10,19 @@
namespace detail
{
template<class T>
auto try_add_pointer(int) -> TypeIdentity<trait::RemoveReference<T>*>;
auto try_add_pointer(int) -> TypeIdentity<RemoveReference<T>*>;
template<class T>
auto try_add_pointer(...) -> TypeIdentity<T>;
template<class T>
struct AddPointer : decltype(detail::try_add_pointer<T>(0))
struct AddPointerHelper : decltype(detail::try_add_pointer<T>(0))
{
};
} // namespace detail
template<class T>
using AddPointer = typename detail::AddPointer<T>::Type;
using AddPointer = typename detail::AddPointerHelper<T>::Type;
} // namespace based::trait
diff --git a/ include/based/trait/add_rvalue_reference.hpp b/ include/based/trait/add_rvalue_reference.hpp
@@ -17,13 +17,13 @@
template<class T>
auto try_add(...) -> TypeIdentity<T>;
template<class T>
struct AddRvalueReference : decltype(detail::try_add<T>(0))
struct AddRvalueReferenceHelper : decltype(detail::try_add<T>(0))
{
};
} // namespace detail
template<class T>
using AddRvalueReference = detail::AddRvalueReference<T>::Type;
using AddRvalueReference = typename detail::AddRvalueReferenceHelper<T>::Type;
} // namespace based::trait
diff --git a/ include/based/trait/conditional.hpp b/ include/based/trait/conditional.hpp
@@ -7,13 +7,13 @@
namespace detail
{
// clang-format off
template<bool b, class T, class F> struct Conditional { using Type = T; };
template<class T, class F> struct Conditional<false, T, F> { using Type = F; };
template<bool b, class T, class F> struct ConditionalHelper { using Type = T; };
template<class T, class F> struct ConditionalHelper<false, T, F> { using Type = F; };
// clang-format on
} // namespace detail
template<bool b, class T, class F>
using Conditional = typename detail::Conditional<b, T, F>::Type;
using Conditional = typename detail::ConditionalHelper<b, T, F>::Type;
} // namespace based::trait
diff --git a/ include/based/trait/decay.hpp b/ include/based/trait/decay.hpp
@@ -14,21 +14,21 @@
namespace detail
{
template<class U>
struct Decay
struct DecayHelper
{
using Type = trait::RemoveCv<U>;
};
template<class U>
requires trait::IsArray<U>
struct Decay<U>
struct DecayHelper<U>
{
using Type = trait::AddPointer<trait::RemoveExtent<U>>;
};
template<class U>
requires trait::IsFunction<U>
struct Decay<U>
struct DecayHelper<U>
{
using Type = trait::AddPointer<U>;
};
@@ -36,6 +36,6 @@
struct Decay<U>
} // namespace detail
template<class T>
using Decay = typename detail::Decay<RemoveReference<T>>::Type;
using Decay = typename detail::DecayHelper<RemoveReference<T>>::Type;
} // namespace based::trait
diff --git a/ include/based/trait/enable_if.hpp b/ include/based/trait/enable_if.hpp
@@ -1,15 +1,19 @@
#pragma once
namespace based
namespace based::trait
{
// clang-format off
namespace detail
{
template<bool b, class T = void> struct EnableIf {};
template<class T> struct EnableIf<true, T> { using Type = T; };
// clang-format off
template<bool b, class T = void> struct EnableIfHelper {};
template<class T> struct EnableIfHelper<true, T> { using Type = T; };
// clang-format on
template<bool b, class T = void> using EnableIfT = typename EnableIf<b, T>::type;
} // namespace detail
// clang-format on
template<bool b, class T = void>
using EnableIfT = typename detail::EnableIfHelper<b, T>::type;
} // namespace based
} // namespace based::trait
diff --git a/ include/based/trait/invoke_result.hpp b/ include/based/trait/invoke_result.hpp
@@ -5,7 +5,7 @@
#include "based/trait/decay.hpp"
#include "based/utility/forward.hpp"
namespace based
namespace based::trait
{
namespace detail
@@ -27,11 +27,11 @@
struct InvokeImpl<MT B::*>
static auto get(T&& obj) -> T&&;
template<class T>
requires(trait::IsReferenceWrapper<trait::Decay<T>>)
requires(trait::IsRefWrapper<trait::Decay<T>>)
static auto get(T&& obj) -> decltype(obj.get());
template<class T>
requires(!trait::IsBaseOf<B, trait::Decay<T>> && !trait::IsReferenceWrapper<trait::Decay<T>>)
requires(!trait::IsBaseOf<B, trait::Decay<T>> && !trait::IsRefWrapper<trait::Decay<T>>)
static auto get(T&& obj) -> decltype(*based::forward<T>(obj));
template<class T, class... Args, class MT1>
@@ -58,12 +58,12 @@
namespace detail
{
template<typename AlwaysVoid, typename, typename...>
struct InvokeResult
struct InvokeResultHelperHelper
{
};
template<typename F, typename... Args>
struct InvokeResult<
struct InvokeResultHelperHelper<
decltype(void(detail::invoke_f(declval<F>(), declval<Args>()...))),
F,
Args...>
@@ -71,14 +71,14 @@
struct InvokeResult<
using Type = decltype(detail::invoke_f(declval<F>(), declval<Args>()...));
};
} // namespace detail
template<class F, class... Args>
struct InvokeResult : detail::InvokeResult<void, F, Args...>
struct InvokeResultHelper : detail::InvokeResultHelperHelper<void, F, Args...>
{
};
} // namespace detail
template<class F, class... Args>
using InvokeResultT = typename InvokeResult<F, Args...>::Type;
using InvokeResult = typename detail::InvokeResultHelper<F, Args...>::Type;
} // namespace based
} // namespace based::trait
diff --git a/ include/based/trait/iterator.hpp b/ include/based/trait/iterator.hpp
@@ -4,16 +4,17 @@
#include "based/integral/types.hpp"
namespace based
namespace based::trait
{
namespace detail
{
template<typename I>
struct IteratorTraits
{
using value_type = I;
using distance_type = u64;
using distance_type = U64; // NOLINT(*identifier*)
using PointerType = I&;
using ReferenceType = I*;
};
@@ -42,4 +43,4 @@
using IterPtrT = detail::IteratorTraits<T>::pointer;
template<typename T>
using IterRefT = detail::IteratorTraits<T>::reference;
} // namespace based
} // namespace based::trait
diff --git a/ include/based/trait/remove_const.hpp b/ include/based/trait/remove_const.hpp
@@ -7,13 +7,13 @@
namespace detail
{
template<class T>
struct RemoveConst
struct RemoveConstHelper
{
using Type = T;
};
template<class T>
struct RemoveConst<const T>
struct RemoveConstHelper<const T>
{
using Type = T;
};
@@ -21,6 +21,6 @@
struct RemoveConst<const T>
} // namespace detail
template<class T>
using RemoveConst = typename detail::RemoveConst<T>::Type;
using RemoveConst = typename detail::RemoveConstHelper<T>::Type;
} // namespace based::trait
diff --git a/ include/based/trait/remove_cv.hpp b/ include/based/trait/remove_cv.hpp
@@ -7,15 +7,15 @@
namespace detail
{
// clang-format off
template<class T> struct RemoveCv { using Type = T; };
template<class T> struct RemoveCv<const T> { using Type = T; };
template<class T> struct RemoveCv<volatile T> { using Type = T; };
template<class T> struct RemoveCv<const volatile T> { using Type = T; };
template<class T> struct RemoveCvHelper { using Type = T; };
template<class T> struct RemoveCvHelper<const T> { using Type = T; };
template<class T> struct RemoveCvHelper<volatile T> { using Type = T; };
template<class T> struct RemoveCvHelper<const volatile T> { using Type = T; };
// clang-format on
} // namespace detail
template<class T>
using RemoveCv = typename detail::RemoveCv<T>::Type;
using RemoveCv = typename detail::RemoveCvHelper<T>::Type;
} // namespace based::trait
diff --git a/ include/based/trait/remove_cvref.hpp b/ include/based/trait/remove_cvref.hpp
@@ -1,7 +1,7 @@
#pragma once
#include "based/trait/remove_reference.hpp"
#include "based/trait/remove_cv.hpp"
#include "based/trait/remove_reference.hpp"
namespace based::trait
{
@@ -10,14 +10,14 @@
namespace detail
{
template<class T>
struct RemoveCvref
struct RemoveCvrefHelper
{
using Type = trait::RemoveCv<trait::RemoveReference<T>>;
using Type = RemoveCv<RemoveReference<T>>;
};
} // namespace detail
template<class T>
using RemoveCvref = typename detail::RemoveCvref<T>::Type;
using RemoveCvref = typename detail::RemoveCvrefHelper<T>::Type;
} // namespace based::trait
diff --git a/ include/based/trait/remove_extent.hpp b/ include/based/trait/remove_extent.hpp
@@ -10,15 +10,15 @@
namespace detail
// NOLINTBEGIN(*array*)
// clang-format off
template<class T> struct RemoveExtent { using Type = T; };
template<class T> struct RemoveExtent<T[]> { using Type = T; };
template<class T, SizeT n> struct RemoveExtent<T[n]> { using Type = T; };
template<class T> struct RemoveExtentHelper { using Type = T; };
template<class T> struct RemoveExtentHelper<T[]> { using Type = T; };
template<class T, SizeT n> struct RemoveExtentHelper<T[n]> { using Type = T; };
// NOLINTEND(*array*)
// clang-format on
} // namespace detail
template<class T>
using RemoveExtent = typename detail::RemoveExtent<T>::Type;
using RemoveExtent = typename detail::RemoveExtentHelper<T>::Type;
} // namespace based::trait
diff --git a/ include/based/trait/remove_pointer.hpp b/ include/based/trait/remove_pointer.hpp
@@ -7,16 +7,16 @@
namespace detail
{
// clang-format off
template<class T> struct RemovePointer { using Type = T; };
template<class T> struct RemovePointer<T*> { using Type = T; };
template<class T> struct RemovePointer<T* const> { using Type = T; };
template<class T> struct RemovePointer<T* volatile> { using Type = T; };
template<class T> struct RemovePointer<T* const volatile> { using Type = T; };
template<class T> struct RemovePointerHelper { using Type = T; };
template<class T> struct RemovePointerHelper<T*> { using Type = T; };
template<class T> struct RemovePointerHelper<T* const> { using Type = T; };
template<class T> struct RemovePointerHelper<T* volatile> { using Type = T; };
template<class T> struct RemovePointerHelper<T* const volatile> { using Type = T; };
// clang-format on
} // namespace detail
template<class T>
using RemovePointer = typename detail::RemovePointer<T>::Type;
using RemovePointer = typename detail::RemovePointerHelper<T>::Type;
} // namespace based::trait
diff --git a/ include/based/trait/remove_reference.hpp b/ include/based/trait/remove_reference.hpp
@@ -7,14 +7,14 @@
namespace detail
{
// clang-format off
template<class T> struct RemoveReference { using Type = T; };
template<class T> struct RemoveReference<T&> { using Type = T; };
template<class T> struct RemoveReference<T&&> { using Type = T; };
template<class T> struct RemoveReferenceHelper { using Type = T; };
template<class T> struct RemoveReferenceHelper<T&> { using Type = T; };
template<class T> struct RemoveReferenceHelper<T&&> { using Type = T; };
// clang-format on
} // namespace detail
template<class T>
using RemoveReference = typename detail::RemoveReference<T>::Type;
using RemoveReference = typename detail::RemoveReferenceHelper<T>::Type;
} // namespace based::trait
diff --git a/ include/based/trait/remove_volatile.hpp b/ include/based/trait/remove_volatile.hpp
@@ -7,13 +7,13 @@
namespace detail
{
// clang-format off
template<class T> struct RemoveVolatile { using Type = T; };
template<class T> struct RemoveVolatile<volatile T> { using Type = T; };
template<class T> struct RemoveVolatileHelper { using Type = T; };
template<class T> struct RemoveVolatileHelper<volatile T> { using Type = T; };
// clang-format on
} // namespace detail
template<class T>
using RemoveVolatile = typename detail::RemoveVolatile<T>::Type;
using RemoveVolatile = typename detail::RemoveVolatileHelper<T>::Type;
} // namespace based::trait
diff --git a/ include/based/trait/type_identity.hpp b/ include/based/trait/type_identity.hpp
@@ -3,16 +3,10 @@
namespace based::trait
{
namespace detail
{
// clang-format off
template<class T> struct TypeIdentity { using Type = T; };
// clang-format on
} // namespace detail
template<class T>
using TypeIdentity = detail::TypeIdentity<T>::Type;
struct TypeIdentity
{
using Type = T;
};
} // namespace based::trait
diff --git a/ include/based/utility/forward.hpp b/ include/based/utility/forward.hpp
@@ -16,7 +16,7 @@
template<class T>
// NOLINTNEXTLINE(*move*)
constexpr decltype(auto) forward(trait::RemoveReference<T>&& tmp) noexcept
{
static_assert(!trait::IsLvalueReference<T>);
static_assert(!trait::IsLValueRef<T>);
return static_cast<T&&>(tmp);
}
diff --git a/ test/CMakeLists.txt b/ test/CMakeLists.txt
@@ -35,15 +35,6 @@
add_test(integral literals_test)
## ----- Trait -----
add_test(trait invoke_result_test)
add_test(trait is_array_test)
add_test(trait is_base_of_test)
add_test(trait is_class_test)
add_test(trait is_const_test)
add_test(trait is_enum_test)
add_test(trait is_lvalue_reference_test)
add_test(trait is_null_pointer_test)
add_test(trait is_rvalue_reference_test)
add_test(trait is_void_test)
add_test(trait remove_const_test)
add_test(trait remove_cvref_test)
add_test(trait remove_cv_test)
@@ -55,6 +46,15 @@
add_test(trait signature_test)
## ----- Concept -----
add_test(concept callable_test)
add_test(concept is_array_test)
add_test(concept is_base_of_test)
add_test(concept is_class_test)
add_test(concept is_const_test)
add_test(concept is_enum_test)
add_test(concept is_lvalue_reference_test)
add_test(concept is_null_pointer_test)
add_test(concept is_rvalue_reference_test)
add_test(concept is_void_test)
## ----- Algorithm -----
diff --git a/ test/source/concept/callable_test.cpp b/ test/source/concept/callable_test.cpp
@@ -19,16 +19,16 @@
int free_func(int a, double b)
using based::trait::IsSame;
TEST_CASE("free function", "[concept/callable]")
TEST_CASE("free function", "[concept/IsCallable]")
{
using TypeT = decltype(free_func);
STATIC_REQUIRE(based::Callable<TypeT>);
STATIC_REQUIRE(IsSame<based::CallableSigT<TypeT>, int(int, double)>);
STATIC_REQUIRE(IsSame<based::CallableRetT<TypeT>, int>);
STATIC_REQUIRE(based::trait::IsCallable<TypeT>);
STATIC_REQUIRE(IsSame<based::trait::CallableSigT<TypeT>, int(int, double)>);
STATIC_REQUIRE(IsSame<based::trait::CallableRetT<TypeT>, int>);
}
TEST_CASE("lambda", "[concept/callable]")
TEST_CASE("lambda", "[concept/IsCallable]")
{
const auto func = [](int a, double b)
{
@@ -36,9 +36,9 @@
TEST_CASE("lambda", "[concept/callable]")
};
using TypeT = decltype(func);
STATIC_REQUIRE(based::Callable<TypeT>);
STATIC_REQUIRE(IsSame<based::CallableSigT<TypeT>, int(int, double)>);
STATIC_REQUIRE(IsSame<based::CallableRetT<TypeT>, int>);
STATIC_REQUIRE(based::trait::IsCallable<TypeT>);
STATIC_REQUIRE(IsSame<based::trait::CallableSigT<TypeT>, int(int, double)>);
STATIC_REQUIRE(IsSame<based::trait::CallableRetT<TypeT>, int>);
}
struct Func
@@ -47,13 +47,13 @@
struct Func
};
/*
TEST_CASE("member function", "[concept/callable]")
TEST_CASE("member function", "[concept/IsCallable]")
{
// [&](auto&&... args) -> decltype(auto) { return
// f(based::forward<decltype(args)>(args)...); }
// based::error_template<decltype(&func::template operator()<int, double>)>();
STATIC_REQUIRE(based::Callable<Func>);
STATIC_REQUIRE(based::IsCallable<Func>);
STATIC_REQUIRE(IsSame<based::CallableSigT<Func>, int(int, double)>);
STATIC_REQUIRE(IsSame<based::CallableRetT<Func>, int>);
}
diff --git a/ test/source/concept/is_array_test.cpp b/ test/source/concept/is_array_test.cpp
@@ -0,0 +1,23 @@
#define CATCH_CONFIG_RUNTIME_STATIC_REQUIRE
#include "based/concept/is_array.hpp"
#include <catch2/catch_test_macros.hpp>
TEST_CASE("IsArray", "[concept/IsArray]")
{
// clang-format off
struct Test {};
// NOLINTBEGIN(*array*)
STATIC_REQUIRE(based::trait::IsArray<int[]>);
STATIC_REQUIRE(based::trait::IsArray<int[3]>);
STATIC_REQUIRE(based::trait::IsArray<Test[]>);
STATIC_REQUIRE(based::trait::IsArray<Test[3]>);
STATIC_REQUIRE(not based::trait::IsArray<float>);
STATIC_REQUIRE(not based::trait::IsArray<int>);
STATIC_REQUIRE(not based::trait::IsArray<std::array<int, 3>>);
STATIC_REQUIRE(not based::trait::IsArray<Test>);
// clang-format on
// NOLINTEND(*array*)
}
diff --git a/ test/source/concept/is_base_of_test.cpp b/ test/source/concept/is_base_of_test.cpp
@@ -0,0 +1,25 @@
#define CATCH_CONFIG_RUNTIME_STATIC_REQUIRE
#include "based/concept/is_base_of.hpp"
#include <catch2/catch_test_macros.hpp>
TEST_CASE("IsBaseOf", "[concept/IsBaseOf]")
{
// clang-format off
class A {};
class B : A {};
class C : B {};
class D {};
union e {};
using I = int;
STATIC_REQUIRE(based::trait::IsBaseOf<A, A>);
STATIC_REQUIRE(based::trait::IsBaseOf<A, B>);
STATIC_REQUIRE(based::trait::IsBaseOf<A, C>);
STATIC_REQUIRE(not based::trait::IsBaseOf<A, D>);
STATIC_REQUIRE(not based::trait::IsBaseOf<B, A>);
STATIC_REQUIRE(not based::trait::IsBaseOf<e, e>);
STATIC_REQUIRE(not based::trait::IsBaseOf<I, I>);
// clang-format on
}
diff --git a/ test/source/concept/is_class_test.cpp b/ test/source/concept/is_class_test.cpp
@@ -0,0 +1,25 @@
#define CATCH_CONFIG_RUNTIME_STATIC_REQUIRE
#include "based/concept/is_class.hpp"
#include <catch2/catch_test_macros.hpp>
TEST_CASE("IsClass", "[concept/IsClass]")
{
// clang-format off
struct A {};
class B {};
enum class e {};
union u { class Uc {}; };
STATIC_REQUIRE(based::trait::IsClass<A>);
STATIC_REQUIRE(based::trait::IsClass<B>);
STATIC_REQUIRE(based::trait::IsClass<const B>);
STATIC_REQUIRE(based::trait::IsClass<u::Uc>);
STATIC_REQUIRE(not based::trait::IsClass<B&>);
STATIC_REQUIRE(not based::trait::IsClass<B*>);
STATIC_REQUIRE(not based::trait::IsClass<e>);
STATIC_REQUIRE(not based::trait::IsClass<int>);
STATIC_REQUIRE(not based::trait::IsClass<u>);
// clang-format on
}
diff --git a/ test/source/concept/is_const_test.cpp b/ test/source/concept/is_const_test.cpp
@@ -0,0 +1,36 @@
#define CATCH_CONFIG_RUNTIME_STATIC_REQUIRE
#include "based/concept/is_const.hpp"
#include <catch2/catch_test_macros.hpp>
TEST_CASE("IsConst", "[concept/IsConst]")
{
// clang-format off
struct Test {};
// NOLINTBEGIN(*array*)
STATIC_REQUIRE(based::trait::IsConst<const int>);
STATIC_REQUIRE(based::trait::IsConst<const int[2]>);
STATIC_REQUIRE(based::trait::IsConst<const volatile int>);
STATIC_REQUIRE(based::trait::IsConst<const volatile int[2]>);
STATIC_REQUIRE(not based::trait::IsConst<const int&>);
STATIC_REQUIRE(not based::trait::IsConst<const int(&)[2]>);
STATIC_REQUIRE(not based::trait::IsConst<const volatile int&>);
STATIC_REQUIRE(not based::trait::IsConst<const volatile int(&)[2]>);
STATIC_REQUIRE(not based::trait::IsConst<int&&>);
STATIC_REQUIRE(not based::trait::IsConst<int&>);
STATIC_REQUIRE(not based::trait::IsConst<int>);
STATIC_REQUIRE(not based::trait::IsConst<int(&&)[2]>);
STATIC_REQUIRE(not based::trait::IsConst<int(&)[2]>);
STATIC_REQUIRE(not based::trait::IsConst<int[2]>);
STATIC_REQUIRE(not based::trait::IsConst<int(int)>);
STATIC_REQUIRE(not based::trait::IsConst<volatile int&&>);
STATIC_REQUIRE(not based::trait::IsConst<volatile int&>);
STATIC_REQUIRE(not based::trait::IsConst<volatile int>);
STATIC_REQUIRE(not based::trait::IsConst<volatile int(&&)[2]>);
STATIC_REQUIRE(not based::trait::IsConst<volatile int(&)[2]>);
STATIC_REQUIRE(not based::trait::IsConst<volatile int[2]>);
// clang-format on
// NOLINTEND(*array*)
}
diff --git a/ test/source/concept/is_enum_test.cpp b/ test/source/concept/is_enum_test.cpp
@@ -0,0 +1,20 @@
#define CATCH_CONFIG_RUNTIME_STATIC_REQUIRE
#include "based/concept/is_enum.hpp"
#include <catch2/catch_test_macros.hpp>
TEST_CASE("IsEnum", "[concept/IsEnum]")
{
// clang-format off
struct A { enum e {}; };
enum e {};
enum class ec : int {};
STATIC_REQUIRE(based::trait::IsEnum<A::e>);
STATIC_REQUIRE(based::trait::IsEnum<e>);
STATIC_REQUIRE(based::trait::IsEnum<ec>);
STATIC_REQUIRE(not based::trait::IsEnum<A>);
STATIC_REQUIRE(not based::trait::IsEnum<int>);
// clang-format not on
}
diff --git a/ test/source/concept/is_lvalue_reference_test.cpp b/ test/source/concept/is_lvalue_reference_test.cpp
@@ -0,0 +1,34 @@
#define CATCH_CONFIG_RUNTIME_STATIC_REQUIRE
#include "based/concept/is_lvalue_reference.hpp"
#include <catch2/catch_test_macros.hpp>
TEST_CASE("IsLValueReference", "[concept/IsLValueReference]")
{
// clang-format off
// NOLINTBEGIN(*array*)
STATIC_REQUIRE(based::trait::IsLValueRef<const int&>);
STATIC_REQUIRE(based::trait::IsLValueRef<const int(&)[2]>);
STATIC_REQUIRE(based::trait::IsLValueRef<const volatile int&>);
STATIC_REQUIRE(based::trait::IsLValueRef<const volatile int(&)[2]>);
STATIC_REQUIRE(based::trait::IsLValueRef<int&>);
STATIC_REQUIRE(based::trait::IsLValueRef<int(&)[2]>);
STATIC_REQUIRE(based::trait::IsLValueRef<volatile int&>);
STATIC_REQUIRE(based::trait::IsLValueRef<volatile int(&)[2]>);
STATIC_REQUIRE(not based::trait::IsLValueRef<const int>);
STATIC_REQUIRE(not based::trait::IsLValueRef<const int[2]>);
STATIC_REQUIRE(not based::trait::IsLValueRef<const volatile int>);
STATIC_REQUIRE(not based::trait::IsLValueRef<const volatile int[2]>);
STATIC_REQUIRE(not based::trait::IsLValueRef<int&&>);
STATIC_REQUIRE(not based::trait::IsLValueRef<int>);
STATIC_REQUIRE(not based::trait::IsLValueRef<int(&&)[2]>);
STATIC_REQUIRE(not based::trait::IsLValueRef<int[2]>);
STATIC_REQUIRE(not based::trait::IsLValueRef<int(int)>);
STATIC_REQUIRE(not based::trait::IsLValueRef<volatile int&&>);
STATIC_REQUIRE(not based::trait::IsLValueRef<volatile int>);
STATIC_REQUIRE(not based::trait::IsLValueRef<volatile int(&&)[2]>);
STATIC_REQUIRE(not based::trait::IsLValueRef<volatile int[2]>);
// NOLINTEND(*array*)
// clang-format on
}
diff --git a/ test/source/concept/is_null_pointer_test.cpp b/ test/source/concept/is_null_pointer_test.cpp
@@ -0,0 +1,23 @@
#define CATCH_CONFIG_RUNTIME_STATIC_REQUIRE
#include "based/concept/is_null_pointer.hpp"
#include <catch2/catch_test_macros.hpp>
TEST_CASE("IsNullPointer", "[concept/IsNullPointer]")
{
double const test = 0;
// clang-format off
// NOLINTBEGIN(*array*)
STATIC_REQUIRE(based::trait::IsNullPointer<decltype(nullptr)>);
STATIC_REQUIRE(not based::trait::IsNullPointer<void>);
STATIC_REQUIRE(not based::trait::IsNullPointer<const void>);
STATIC_REQUIRE(not based::trait::IsNullPointer<volatile void>);
STATIC_REQUIRE(not based::trait::IsNullPointer<void*>);
STATIC_REQUIRE(not based::trait::IsNullPointer<int>);
STATIC_REQUIRE(not based::trait::IsNullPointer<decltype(test)>);
STATIC_REQUIRE(not based::trait::IsNullPointer<void>);
// NOLINTEND(*array*)
// clang-format on
}
diff --git a/ test/source/concept/is_rvalue_reference_test.cpp b/ test/source/concept/is_rvalue_reference_test.cpp
@@ -0,0 +1,34 @@
#define CATCH_CONFIG_RUNTIME_STATIC_REQUIRE
#include "based/concept/is_rvalue_reference.hpp"
#include <catch2/catch_test_macros.hpp>
TEST_CASE("IsRValueRefence", "[concept/IsRValueRefence]")
{
// clang-format off
// NOLINTBEGIN(*array*)
STATIC_REQUIRE(based::trait::IsRValueRef<int&&>);
STATIC_REQUIRE(based::trait::IsRValueRef<int(&&)[2]>);
STATIC_REQUIRE(based::trait::IsRValueRef<volatile int&&>);
STATIC_REQUIRE(based::trait::IsRValueRef<volatile int(&&)[2]>);
STATIC_REQUIRE(not based::trait::IsRValueRef<const int&>);
STATIC_REQUIRE(not based::trait::IsRValueRef<const int>);
STATIC_REQUIRE(not based::trait::IsRValueRef<const int(&)[2]>);
STATIC_REQUIRE(not based::trait::IsRValueRef<const int[2]>);
STATIC_REQUIRE(not based::trait::IsRValueRef<const volatile int&>);
STATIC_REQUIRE(not based::trait::IsRValueRef<const volatile int>);
STATIC_REQUIRE(not based::trait::IsRValueRef<const volatile int(&)[2]>);
STATIC_REQUIRE(not based::trait::IsRValueRef<const volatile int[2]>);
STATIC_REQUIRE(not based::trait::IsRValueRef<int&>);
STATIC_REQUIRE(not based::trait::IsRValueRef<int>);
STATIC_REQUIRE(not based::trait::IsRValueRef<int(&)[2]>);
STATIC_REQUIRE(not based::trait::IsRValueRef<int[2]>);
STATIC_REQUIRE(not based::trait::IsRValueRef<int(int)>);
STATIC_REQUIRE(not based::trait::IsRValueRef<volatile int&>);
STATIC_REQUIRE(not based::trait::IsRValueRef<volatile int>);
STATIC_REQUIRE(not based::trait::IsRValueRef<volatile int(&)[2]>);
STATIC_REQUIRE(not based::trait::IsRValueRef<volatile int[2]>);
// NOLINTEND(*array*)
// clang-format on
}
diff --git a/ test/source/concept/is_void_test.cpp b/ test/source/concept/is_void_test.cpp
@@ -0,0 +1,21 @@
#define CATCH_CONFIG_RUNTIME_STATIC_REQUIRE
#include "based/concept/is_void.hpp"
#include <catch2/catch_test_macros.hpp>
TEST_CASE("IsVoid", "[concept/IsVoid]")
{
double const test = 0;
// clang-format off
// NOLINTBEGIN(*array*)
STATIC_REQUIRE(based::trait::IsVoid<void>);
STATIC_REQUIRE(based::trait::IsVoid<const void>);
STATIC_REQUIRE(based::trait::IsVoid<volatile void>);
STATIC_REQUIRE(not based::trait::IsVoid<void*>);
STATIC_REQUIRE(not based::trait::IsVoid<int>);
STATIC_REQUIRE(not based::trait::IsVoid<decltype(test)>);
// NOLINTEND(*array*)
// clang-format on
}
diff --git a/ test/source/trait/invoke_result_test.cpp b/ test/source/trait/invoke_result_test.cpp
@@ -15,7 +15,8 @@
int func(double);
} // namespace
template<class Res, class T, class... Args>
concept Test = based::trait::IsSame<based::InvokeResultT<T, Args...>, Res>;
concept Test =
based::trait::IsSame<based::trait::InvokeResult<T, Args...>, Res>;
TEST_CASE("invoke_result", "[trait/invoke_result]")
{
diff --git a/ test/source/trait/is_array_test.cpp b/ test/source/trait/is_array_test.cpp
@@ -1,23 +0,0 @@
#define CATCH_CONFIG_RUNTIME_STATIC_REQUIRE
#include <catch2/catch_test_macros.hpp>
#include "based/concept/is_array.hpp"
TEST_CASE("IsArray", "[concept/IsArray]")
{
// clang-format off
struct Test {};
// NOLINTBEGIN(*array*)
STATIC_REQUIRE(!based::trait::IsArray<Test>);
STATIC_REQUIRE(based::trait::IsArray<Test[]>);
STATIC_REQUIRE(based::trait::IsArray<Test[3]>);
STATIC_REQUIRE(!based::trait::IsArray<float>);
STATIC_REQUIRE(!based::trait::IsArray<int>);
STATIC_REQUIRE(based::trait::IsArray<int[]>);
STATIC_REQUIRE(based::trait::IsArray<int[3]>);
STATIC_REQUIRE(!based::trait::IsArray<std::array<int, 3>>);
// clang-format on
// NOLINTEND(*array*)
}
diff --git a/ test/source/trait/is_base_of_test.cpp b/ test/source/trait/is_base_of_test.cpp
@@ -1,25 +0,0 @@
#define CATCH_CONFIG_RUNTIME_STATIC_REQUIRE
#include <catch2/catch_test_macros.hpp>
#include "based/concept/is_base_of.hpp"
TEST_CASE("IsBaseOf", "[concept/IsBaseOf]")
{
// clang-format off
class A {};
class B : A {};
class C : B {};
class D {};
union e {};
using I = int;
STATIC_REQUIRE(based::trait::IsBaseOf<A, A>);
STATIC_REQUIRE(based::trait::IsBaseOf<A, B>);
STATIC_REQUIRE(based::trait::IsBaseOf<A, C>);
STATIC_REQUIRE(!based::trait::IsBaseOf<A, D>);
STATIC_REQUIRE(!based::trait::IsBaseOf<B, A>);
STATIC_REQUIRE(!based::trait::IsBaseOf<e, e>);
STATIC_REQUIRE(!based::trait::IsBaseOf<I, I>);
// clang-format on
}
diff --git a/ test/source/trait/is_class_test.cpp b/ test/source/trait/is_class_test.cpp
@@ -1,25 +0,0 @@
#define CATCH_CONFIG_RUNTIME_STATIC_REQUIRE
#include <catch2/catch_test_macros.hpp>
#include "based/concept/is_class.hpp"
TEST_CASE("IsClass", "[concept/IsClass]")
{
// clang-format off
struct A {};
class B {};
enum class e {};
union u { class Uc {}; };
STATIC_REQUIRE(based::trait::IsClass<A>);
STATIC_REQUIRE(based::trait::IsClass<B>);
STATIC_REQUIRE(!based::trait::IsClass<B*>);
STATIC_REQUIRE(!based::trait::IsClass<B&>);
STATIC_REQUIRE(based::trait::IsClass<const B>);
STATIC_REQUIRE(!based::trait::IsClass<e>);
STATIC_REQUIRE(!based::trait::IsClass<u>);
STATIC_REQUIRE(based::trait::IsClass<u::Uc>);
STATIC_REQUIRE(!based::trait::IsClass<int>);
// clang-format on
}
diff --git a/ test/source/trait/is_const_test.cpp b/ test/source/trait/is_const_test.cpp
@@ -1,36 +0,0 @@
#define CATCH_CONFIG_RUNTIME_STATIC_REQUIRE
#include <catch2/catch_test_macros.hpp>
#include "based/concept/is_const.hpp"
TEST_CASE("IsConst", "[concept/IsConst]")
{
// clang-format off
struct Test {};
// NOLINTBEGIN(*array*)
STATIC_REQUIRE(!based::trait::IsConst<int>);
STATIC_REQUIRE(!based::trait::IsConst<int&>);
STATIC_REQUIRE(!based::trait::IsConst<int&&>);
STATIC_REQUIRE(!based::trait::IsConst<int[2]>);
STATIC_REQUIRE(!based::trait::IsConst<int(&)[2]>);
STATIC_REQUIRE(!based::trait::IsConst<int(&&)[2]>);
STATIC_REQUIRE(based::trait::IsConst<const int>);
STATIC_REQUIRE(!based::trait::IsConst<const int&>);
STATIC_REQUIRE(based::trait::IsConst<const int[2]>);
STATIC_REQUIRE(!based::trait::IsConst<const int(&)[2]>);
STATIC_REQUIRE(!based::trait::IsConst<int(int)>);
STATIC_REQUIRE(!based::trait::IsConst<volatile int>);
STATIC_REQUIRE(!based::trait::IsConst<volatile int&>);
STATIC_REQUIRE(!based::trait::IsConst<volatile int&&>);
STATIC_REQUIRE(!based::trait::IsConst<volatile int[2]>);
STATIC_REQUIRE(!based::trait::IsConst<volatile int(&)[2]>);
STATIC_REQUIRE(!based::trait::IsConst<volatile int(&&)[2]>);
STATIC_REQUIRE(based::trait::IsConst<const volatile int>);
STATIC_REQUIRE(!based::trait::IsConst<const volatile int&>);
STATIC_REQUIRE(based::trait::IsConst<const volatile int[2]>);
STATIC_REQUIRE(!based::trait::IsConst<const volatile int(&)[2]>);
// clang-format on
// NOLINTEND(*array*)
}
diff --git a/ test/source/trait/is_enum_test.cpp b/ test/source/trait/is_enum_test.cpp
@@ -1,20 +0,0 @@
#define CATCH_CONFIG_RUNTIME_STATIC_REQUIRE
#include <catch2/catch_test_macros.hpp>
#include "based/concept/is_enum.hpp"
TEST_CASE("IsEnum", "[concept/IsEnum]")
{
// clang-format off
struct A { enum e {}; };
enum e {};
enum class ec : int {};
STATIC_REQUIRE(!based::trait::IsEnum<A>);
STATIC_REQUIRE(based::trait::IsEnum<A::e>);
STATIC_REQUIRE(based::trait::IsEnum<e>);
STATIC_REQUIRE(based::trait::IsEnum<ec>);
STATIC_REQUIRE(!based::trait::IsEnum<int>);
// clang-format !on
}
diff --git a/ test/source/trait/is_lvalue_reference_test.cpp b/ test/source/trait/is_lvalue_reference_test.cpp
@@ -1,34 +0,0 @@
#define CATCH_CONFIG_RUNTIME_STATIC_REQUIRE
#include <catch2/catch_test_macros.hpp>
#include "based/concept/is_lvalue_reference.hpp"
TEST_CASE("IsLvalueReference", "[concept/IsLvalueReference]")
{
// NOLINTBEGIN(*array*)
// clang-format off
STATIC_REQUIRE(!based::trait::IsLvalueReference<int>);
STATIC_REQUIRE(based::trait::IsLvalueReference<int&>);
STATIC_REQUIRE(!based::trait::IsLvalueReference<int&&>);
STATIC_REQUIRE(!based::trait::IsLvalueReference<int[2]>);
STATIC_REQUIRE(based::trait::IsLvalueReference<int(&)[2]>);
STATIC_REQUIRE(!based::trait::IsLvalueReference<int(&&)[2]>);
STATIC_REQUIRE(!based::trait::IsLvalueReference<const int>);
STATIC_REQUIRE(based::trait::IsLvalueReference<const int&>);
STATIC_REQUIRE(!based::trait::IsLvalueReference<const int[2]>);
STATIC_REQUIRE(based::trait::IsLvalueReference<const int(&)[2]>);
STATIC_REQUIRE(!based::trait::IsLvalueReference<int(int)>);
STATIC_REQUIRE(!based::trait::IsLvalueReference<volatile int>);
STATIC_REQUIRE(based::trait::IsLvalueReference<volatile int&>);
STATIC_REQUIRE(!based::trait::IsLvalueReference<volatile int&&>);
STATIC_REQUIRE(!based::trait::IsLvalueReference<volatile int[2]>);
STATIC_REQUIRE(based::trait::IsLvalueReference<volatile int(&)[2]>);
STATIC_REQUIRE(!based::trait::IsLvalueReference<volatile int(&&)[2]>);
STATIC_REQUIRE(!based::trait::IsLvalueReference<const volatile int>);
STATIC_REQUIRE(based::trait::IsLvalueReference<const volatile int&>);
STATIC_REQUIRE(!based::trait::IsLvalueReference<const volatile int[2]>);
STATIC_REQUIRE(based::trait::IsLvalueReference<const volatile int(&)[2]>);
// clang-format on
// NOLINTEND(*array*)
}
diff --git a/ test/source/trait/is_null_pointer_test.cpp b/ test/source/trait/is_null_pointer_test.cpp
@@ -1,23 +0,0 @@
#define CATCH_CONFIG_RUNTIME_STATIC_REQUIRE
#include <catch2/catch_test_macros.hpp>
#include "based/concept/is_null_pointer.hpp"
TEST_CASE("IsNullPointer", "[concept/IsNullPointer]")
{
double const test = 0;
// clang-format off
// NOLINTBEGIN(*array*)
STATIC_REQUIRE(based::trait::IsNullPointer<decltype(nullptr)>);
STATIC_REQUIRE(!based::trait::IsNullPointer<void>);
STATIC_REQUIRE(!based::trait::IsNullPointer<const void>);
STATIC_REQUIRE(!based::trait::IsNullPointer<volatile void>);
STATIC_REQUIRE(!based::trait::IsNullPointer<void*>);
STATIC_REQUIRE(!based::trait::IsNullPointer<int>);
STATIC_REQUIRE(!based::trait::IsNullPointer<decltype(test)>);
STATIC_REQUIRE(!based::trait::IsNullPointer<void>);
// NOLINTEND(*array*)
// clang-format on
}
diff --git a/ test/source/trait/is_rvalue_reference_test.cpp b/ test/source/trait/is_rvalue_reference_test.cpp
@@ -1,34 +0,0 @@
#define CATCH_CONFIG_RUNTIME_STATIC_REQUIRE
#include <catch2/catch_test_macros.hpp>
#include "based/concept/is_rvalue_reference.hpp"
TEST_CASE("IsRvalueReference", "[concept/IsRvalueReference]")
{
// clang-format off
// NOLINTBEGIN(*array*)
STATIC_REQUIRE(!based::trait::IsRvalueReference<int>);
STATIC_REQUIRE(!based::trait::IsRvalueReference<int&>);
STATIC_REQUIRE(based::trait::IsRvalueReference<int&&>);
STATIC_REQUIRE(!based::trait::IsRvalueReference<int[2]>);
STATIC_REQUIRE(!based::trait::IsRvalueReference<int(&)[2]>);
STATIC_REQUIRE(based::trait::IsRvalueReference<int(&&)[2]>);
STATIC_REQUIRE(!based::trait::IsRvalueReference<const int>);
STATIC_REQUIRE(!based::trait::IsRvalueReference<const int&>);
STATIC_REQUIRE(!based::trait::IsRvalueReference<const int[2]>);
STATIC_REQUIRE(!based::trait::IsRvalueReference<const int(&)[2]>);
STATIC_REQUIRE(!based::trait::IsRvalueReference<int(int)>);
STATIC_REQUIRE(!based::trait::IsRvalueReference<volatile int>);
STATIC_REQUIRE(!based::trait::IsRvalueReference<volatile int&>);
STATIC_REQUIRE(based::trait::IsRvalueReference<volatile int&&>);
STATIC_REQUIRE(!based::trait::IsRvalueReference<volatile int[2]>);
STATIC_REQUIRE(!based::trait::IsRvalueReference<volatile int(&)[2]>);
STATIC_REQUIRE(based::trait::IsRvalueReference<volatile int(&&)[2]>);
STATIC_REQUIRE(!based::trait::IsRvalueReference<const volatile int>);
STATIC_REQUIRE(!based::trait::IsRvalueReference<const volatile int&>);
STATIC_REQUIRE(!based::trait::IsRvalueReference<const volatile int[2]>);
STATIC_REQUIRE(!based::trait::IsRvalueReference<const volatile int(&)[2]>);
// NOLINTEND(*array*)
// clang-format on
}
diff --git a/ test/source/trait/is_void_test.cpp b/ test/source/trait/is_void_test.cpp
@@ -1,21 +0,0 @@
#define CATCH_CONFIG_RUNTIME_STATIC_REQUIRE
#include <catch2/catch_test_macros.hpp>
#include "based/concept/is_void.hpp"
TEST_CASE("IsVoid", "[concept/IsVoid]")
{
double const test = 0;
// clang-format off
// NOLINTBEGIN(*array*)
STATIC_REQUIRE(based::trait::IsVoid<void>);
STATIC_REQUIRE(based::trait::IsVoid<const void>);
STATIC_REQUIRE(based::trait::IsVoid<volatile void>);
STATIC_REQUIRE(!based::trait::IsVoid<void*>);
STATIC_REQUIRE(!based::trait::IsVoid<int>);
STATIC_REQUIRE(!based::trait::IsVoid<decltype(test)>);
// NOLINTEND(*array*)
// clang-format on
}