basedOpinionated utility library |
| git clone git://git.dimitrijedobrota.com/based.git |
| Log | Files | Refs | README | LICENSE | HACKING | CONTRIBUTING | CODE_OF_CONDUCT | BUILDING |
| commit | 55da0463f98cbe0f2d5fc39a77faf8ee8d28f7cc |
| parent | 1a6c111687493524bdc0a76890662e8db9dba621 |
| author | Dimitrije Dobrota < mail@dimitrijedobrota.com > |
| date | Fri, 20 Jun 2025 07:25:25 +0200 |
Change naming scheme
86 files changed, 1752 insertions(+), 1751 deletions(-)
diff --git a/ .clang-tidy b/ .clang-tidy
@@ -57,15 +57,17 @@
CheckOptions:
value: 'true'
# These seem to be the most common identifier styles
- key: 'readability-identifier-naming.AbstractClassCase'
value: 'lower_case'
value: 'CamelCase'
- key: 'readability-identifier-naming.ClassCase'
value: 'lower_case'
value: 'CamelCase'
- key: 'readability-identifier-naming.ClassConstantCase'
value: 'lower_case'
- key: 'readability-identifier-naming.ClassMemberCase'
value: 'lower_case'
- key: 'readability-identifier-naming.ClassMethodCase'
value: 'lower_case'
- key: 'readability-identifier-naming.ConceptCase'
value: 'CamelCase'
- key: 'readability-identifier-naming.ConstantCase'
value: 'lower_case'
- key: 'readability-identifier-naming.ConstantMemberCase'
@@ -143,7 +145,7 @@
CheckOptions:
- key: 'readability-identifier-naming.StaticVariableCase'
value: 'lower_case'
- key: 'readability-identifier-naming.StructCase'
value: 'lower_case'
value: 'CamelCase'
- key: 'readability-identifier-naming.TemplateParameterCase'
value: 'CamelCase'
- key: 'readability-identifier-naming.TemplateTemplateParameterCase'
diff --git a/ include/based/character/mapper.hpp b/ include/based/character/mapper.hpp
@@ -8,22 +8,22 @@
namespace based
{
template<Predicate<character> Predicate>
class mapper
template<Predicate<Character> Predicate>
class Mapper
{
static constexpr auto size = limits<u8>::max;
using mapped_type = u8;
static constexpr auto size = limits<U8>::max;
using mapped_type = U8;
static constexpr Predicate m_predicate = {};
using direct_t = array<mapped_type, u8, size>;
using direct_t = Array<mapped_type, U8, size>;
static constexpr direct_t direct = []
{
direct_t res = {};
mapped_type count = 0_u8;
for (auto idx = 0_u8; idx < size; idx++) {
if (m_predicate(character::cast(idx))) {
if (m_predicate(Character::cast(idx))) {
res[idx] = count++;
}
}
@@ -31,25 +31,25 @@
class mapper
return res;
}();
static constexpr const u8 count = []
static constexpr const U8 count = []
{
mapped_type count = 0_u8;
for (auto idx = 0_u8; idx < size; idx++) {
if (m_predicate(character::cast(idx))) {
if (m_predicate(Character::cast(idx))) {
count++;
}
}
return count;
}();
using reverse_t = array<character, u8, count>;
using reverse_t = Array<Character, U8, count>;
static constexpr reverse_t reverse = []
{
reverse_t res = {};
mapped_type count = 0_u8;
for (auto idx = 0_u8; idx < size; idx++) {
const auto chr = character::cast(idx);
const auto chr = Character::cast(idx);
if (m_predicate(chr)) {
res[count++] = chr;
}
@@ -59,9 +59,9 @@
class mapper
}();
public:
static constexpr bool predicate(character chr) { return m_predicate(chr); }
static constexpr character map(mapped_type value) { return reverse[value]; }
static constexpr mapped_type map(character chr) { return direct[chr.ord()]; }
static constexpr bool predicate(Character chr) { return m_predicate(chr); }
static constexpr Character map(mapped_type value) { return reverse[value]; }
static constexpr mapped_type map(Character chr) { return direct[chr.ord()]; }
};
} // namespace based
diff --git a/ include/based/character/type.hpp b/ include/based/character/type.hpp
@@ -5,46 +5,46 @@
namespace based
{
struct character : public strong_type<char, character>
struct Character : public StrongType<char, Character>
{
using strong_type::strong_type;
using strong_type::operator=;
using StrongType::StrongType;
using StrongType::operator=;
constexpr character(char chr) // NOLINT(*explicit*)
: strong_type(chr)
constexpr Character(char chr) // NOLINT(*explicit*)
: StrongType(chr)
{
}
explicit constexpr character(u8 ord)
: strong_type(static_cast<char>(ord.value))
explicit constexpr Character(U8 ord)
: StrongType(static_cast<char>(ord.value))
{
}
[[nodiscard]] char chr() const { return value; }
[[nodiscard]] u8 ord() const { return u8::underlying_cast(value); }
[[nodiscard]] U8 ord() const { return U8::underlying_cast(value); }
friend constexpr bool operator==(character lhs, char rhs)
friend constexpr bool operator==(Character lhs, char rhs)
{
return lhs.value == rhs;
}
friend constexpr bool operator==(char lhs, character rhs)
friend constexpr bool operator==(char lhs, Character rhs)
{
return lhs == rhs.value;
}
friend constexpr auto operator<=>(character lhs, char rhs)
friend constexpr auto operator<=>(Character lhs, char rhs)
{
return lhs.value <=> rhs;
}
friend constexpr auto operator<=>(char lhs, character rhs)
friend constexpr auto operator<=>(char lhs, Character rhs)
{
return lhs <=> rhs.value;
}
};
auto compare(character, character) -> bool;
auto order(character, character) -> bool;
auto compare(Character, Character) -> bool;
auto order(Character, Character) -> bool;
} // namespace based
diff --git a/ include/based/concept/callable.hpp b/ include/based/concept/callable.hpp
@@ -1,5 +1,7 @@
#pragma once
#include "based/trait/decay.hpp"
#include "based/trait/is/function.hpp"
#include "based/trait/remove/pointer.hpp"
#include "based/trait/signature.hpp"
@@ -10,20 +12,20 @@
template<typename T>
struct callable;
template<typename T>
requires(std::is_function_v<T>)
struct callable<T> : public signature<std::decay_t<T>>
requires(is_function_v<T>)
struct callable<T> : public Signature<decay_t<T>>
{
};
template<typename T>
requires(requires { &std::decay_t<T>::operator(); })
struct callable<T> : public signature<decltype(&T::operator())>
requires(requires { &decay_t<T>::operator(); })
struct callable<T> : public Signature<decltype(&T::operator())>
{
};
template<typename T>
requires(std::is_member_function_pointer_v<std::decay_t<T>>)
struct callable<T> : public signature<remove_pointer_t<T>>
requires(std::is_member_function_pointer_v<decay_t<T>>)
struct callable<T> : public Signature<remove_pointer_t<T>>
{
};
@@ -32,9 +34,9 @@
template<typename T>
concept Callable = true;
template<Callable T>
using callable_sig_t = typename callable<T>::signature::sig_type;
using callable_sig_t = typename callable<T>::Signature::sig_type;
template<Callable T>
using callable_ret_t = typename callable<T>::signature::ret_type;
using callable_ret_t = typename callable<T>::Signature::ret_type;
} // namespace based
diff --git a/ include/based/concept/ordered/totally.hpp b/ include/based/concept/ordered/totally.hpp
@@ -12,7 +12,7 @@
namespace based
// clang-format off
template<typename T>
concept totally_ordered = requires {
concept TotallyOrdered = requires {
requires(EqualityComparable<T>);
requires(LessComparable<T>);
requires(GreaterComparable<T>);
diff --git a/ include/based/concept/procedure/procedure.hpp b/ include/based/concept/procedure/procedure.hpp
@@ -15,18 +15,18 @@
namespace detail
// clang-format off
template<typename P, typename Sig> struct procedure : public false_type {};
template<typename P, typename Sig> struct Procedure : public false_type {};
template<typename P, typename Ret, typename... Args>
requires (Invocable<P, Args...> && ConvertibleTo<invoke_result_t<P, Args...>, Ret>)
struct procedure<P, Ret(Args...)> : public true_type {};
struct Procedure<P, Ret(Args...)> : public true_type {};
template<typename P, typename... Args>
requires (Invocable<P, Args...>)
struct procedure<P, void(Args...)> : public true_type {};
struct Procedure<P, void(Args...)> : public true_type {};
template<typename P, typename Ret, typename... Args>
static constexpr bool procedure_v = procedure<P, Ret(Args...)>::value;
static constexpr bool procedure_v = Procedure<P, Ret(Args...)>::value;
// clang-format on
diff --git a/ include/based/container/array.hpp b/ include/based/container/array.hpp
@@ -8,9 +8,9 @@
namespace based
{
template<class T, class U, U n>
class array : public std::array<T, u64::cast(n).value>
class Array : public std::array<T, U64::cast(n).value>
{
using base = std::array<T, u64::cast(n).value>;
using base = std::array<T, U64::cast(n).value>;
static constexpr auto cast(U pos)
{
diff --git a/ include/based/container/list.hpp b/ include/based/container/list.hpp
@@ -12,29 +12,29 @@
namespace based
template<typename T, typename N>
// T semiregular
// N integral
class list_pool
class ListPool
{
public:
using value_type = T;
using list_type = N;
private:
struct node_t
struct NodeT
{
value_type value {};
list_type next;
};
std::vector<node_t> m_pool;
std::vector<NodeT> m_pool{};
list_type m_free_list;
[[nodiscard]] const node_t& node(list_type x) const
[[nodiscard]] const NodeT& node(list_type x) const
{
assert(x != list_type(0));
return m_pool[(x - list_type(1)).value];
}
[[nodiscard]] node_t& node(list_type x)
[[nodiscard]] NodeT& node(list_type x)
{
assert(x != list_type(0));
return m_pool[(x - list_type(1)).value];
@@ -42,12 +42,12 @@
private:
[[nodiscard]] list_type new_node()
{
m_pool.push_back(node_t());
m_pool.push_back(NodeT());
return list_type {static_cast<list_type::basic_type>(m_pool.size())};
}
public:
list_pool()
ListPool()
: m_free_list(node_empty())
{
}
@@ -55,19 +55,19 @@
public:
struct iterator
{
using iterator_category = std::forward_iterator_tag;
using difference_type = list_pool::list_type;
using value_type = list_pool::value_type;
using difference_type = ListPool::list_type;
using value_type = ListPool::value_type;
using reference = value_type&;
using pointer = value_type*;
iterator() = default;
explicit iterator(list_pool& pool)
explicit iterator(ListPool& pool)
: iterator(pool, pool.node_empty())
{
}
iterator(list_pool& pool, list_pool::list_type node)
iterator(ListPool& pool, ListPool::list_type node)
: m_pool(&pool)
, m_node(node)
{
@@ -101,26 +101,26 @@
public:
}
private:
list_pool* m_pool;
list_pool::list_type m_node;
ListPool* m_pool;
ListPool::list_type m_node;
};
struct const_iterator
{
using iterator_category = std::forward_iterator_tag;
using difference_type = list_pool::list_type;
using value_type = list_pool::value_type;
using difference_type = ListPool::list_type;
using value_type = ListPool::value_type;
using reference = const value_type&;
using pointer = const value_type*;
const_iterator() = default;
explicit const_iterator(const list_pool& pool)
explicit const_iterator(const ListPool& pool)
: const_iterator(pool, pool.node_empty())
{
}
const_iterator(const list_pool& pool, list_pool::list_type node)
const_iterator(const ListPool& pool, ListPool::list_type node)
: m_pool(&pool)
, m_node(node)
{
@@ -154,8 +154,8 @@
public:
}
private:
const list_pool* m_pool;
list_pool::list_type m_node;
const ListPool* m_pool;
ListPool::list_type m_node;
};
[[nodiscard]] bool is_empty(list_type x) const { return x == node_empty(); }
@@ -252,7 +252,7 @@
public:
};
template<typename T, typename N>
void free_list(list_pool<T, N>& pool, typename list_pool<T, N>::list_type x)
void free_list(ListPool<T, N>& pool, typename ListPool<T, N>::list_type x)
{
while (!pool.is_empty(x)) {
x = pool.free(x);
diff --git a/ include/based/container/vector.hpp b/ include/based/container/vector.hpp
@@ -6,7 +6,7 @@
namespace based
{
template<class T, class U, class Allocator = std::allocator<T>>
class vector : public std::vector<T, Allocator>
class Vector : public std::vector<T, Allocator>
{
using base = std::vector<T, Allocator>;
diff --git a/ include/based/enum/enum.hpp b/ include/based/enum/enum.hpp
@@ -16,7 +16,7 @@
namespace category
* Conversion is equivalent to static_cast
* Unspecified enum_traits use this category
*/
struct def
struct Def
{
};
@@ -33,7 +33,7 @@
struct def
* Additional operators:
* - operator!
*/
struct standard
struct Standard
{
};
@@ -52,7 +52,7 @@
struct standard
* - operator++
* - operator--
*/
struct linear
struct Linear
{
};
@@ -76,7 +76,7 @@
struct linear
* - operator^=
* - operator~
*/
struct bitmask
struct Bitmask
{
};
@@ -94,7 +94,7 @@
struct bitmask
* - operator!
*/
template<class Enum, Enum... vals>
struct discrete
struct Discrete
{
};
@@ -116,7 +116,7 @@
namespace enum_traits
template<class T>
requires IsScopedEnum<T>
// TODO: check for proper int type
struct traits
struct Traits
{
/* TODO (provide defaults)
using category = enum_default;
@@ -125,84 +125,84 @@
struct traits
};
template<class Enum>
concept has_category = requires { typename traits<Enum>::category; };
concept HasCategory = requires { typename Traits<Enum>::category; };
template<class Enum>
concept has_value_type = requires { typename traits<Enum>::value_type; };
concept HasValueType = requires { typename Traits<Enum>::value_type; };
template<has_category Enum>
using category_type = typename traits<Enum>::category;
template<HasCategory Enum>
using category_type = typename Traits<Enum>::category;
template<has_value_type Enum>
using value_type = typename traits<Enum>::value_type;
template<HasValueType Enum>
using value_type = typename Traits<Enum>::value_type;
template<has_value_type Enum>
using basic_type = typename traits<Enum>::value_type::basic_type;
template<HasValueType Enum>
using basic_type = typename Traits<Enum>::value_type::basic_type;
template<class Enum>
concept has_none = requires {
concept HasNone = requires {
{
Enum::none
};
};
template<class Enum>
concept has_min = requires {
concept HasMin = requires {
{
Enum::min
};
};
template<class Enum>
concept has_max = requires {
concept HasMax = requires {
{
Enum::max
};
};
template<has_none Enum>
template<HasNone Enum>
static constexpr Enum none = Enum::none;
template<has_min Enum>
template<HasMin Enum>
static constexpr Enum min = Enum::min;
template<has_max Enum>
template<HasMin Enum>
static constexpr Enum max = Enum::max;
template<class Enum, class Category>
concept is_category = requires {
requires(has_category<Enum>);
concept IsCategory = requires {
requires(HasCategory<Enum>);
requires(SameAs<Category, category_type<Enum>>);
};
template<class Enum>
concept is_default = is_category<Enum, category::def>;
concept IsDefault = IsCategory<Enum, category::Def>;
template<class Enum>
concept is_standard = requires {
requires(is_category<Enum, category::standard>);
requires(has_none<Enum>);
concept IsStandard = requires {
requires(IsCategory<Enum, category::Standard>);
requires(HasNone<Enum>);
requires(
!has_min<Enum> || !has_max<Enum>
!HasMin<Enum> || !HasMin<Enum>
|| !(min<Enum> <= none<Enum> && none<Enum> <= max<Enum>)
);
};
template<class Enum>
concept is_linear = requires {
requires(is_category<Enum, category::linear>);
requires(has_none<Enum>);
concept IsLinear = requires {
requires(IsCategory<Enum, category::Linear>);
requires(HasNone<Enum>);
requires(
!has_min<Enum> || !has_max<Enum>
!HasMin<Enum> || !HasMin<Enum>
|| !(min<Enum> <= none<Enum> && none<Enum> <= max<Enum>)
);
};
template<class Enum>
concept is_bitmask = requires {
requires(is_category<Enum, category::bitmask>);
requires(has_min<Enum>);
requires(has_max<Enum>);
concept IsBitmask = requires {
requires(IsCategory<Enum, category::Bitmask>);
requires(HasMin<Enum>);
requires(HasMin<Enum>);
};
} // namespace enum_traits
@@ -255,20 +255,20 @@
namespace category_traits
* Maps a given value to the enumeration type
*/
template<class Category>
struct traits;
struct Traits;
template<>
struct traits<category::def>
struct Traits<category::Def>
{
using category = category::def;
using category = category::Def;
template<enum_traits::is_category<category> Enum>
template<enum_traits::IsCategory<category> Enum>
static constexpr bool valid() noexcept
{
return true;
}
template<enum_traits::is_category<category> Enum>
template<enum_traits::IsCategory<category> Enum>
static constexpr Enum enum_cast(enum_traits::value_type<Enum> value) noexcept
{
return static_cast<Enum>(value);
@@ -276,14 +276,14 @@
struct traits<category::def>
};
template<>
struct traits<category::standard>
struct Traits<category::Standard>
{
using category = category::standard;
using category = category::Standard;
template<enum_traits::is_category<category> Enum>
template<enum_traits::IsCategory<category> Enum>
static constexpr bool valid() noexcept
{
if constexpr (enum_traits::has_none<Enum>) {
if constexpr (enum_traits::HasNone<Enum>) {
constexpr auto xnone = detail::value_cast_impl(enum_traits::none<Enum>);
constexpr auto xmin = detail::value_cast_impl(enum_traits::min<Enum>);
constexpr auto xmax = detail::value_cast_impl(enum_traits::max<Enum>);
@@ -293,7 +293,7 @@
struct traits<category::standard>
return false;
}
template<enum_traits::is_category<category> Enum>
template<enum_traits::IsCategory<category> Enum>
static constexpr Enum enum_cast(enum_traits::value_type<Enum> value) noexcept
{
constexpr auto xnone = detail::value_cast_impl(enum_traits::none<Enum>);
@@ -306,14 +306,14 @@
struct traits<category::standard>
};
template<>
struct traits<category::linear>
struct Traits<category::Linear>
{
using category = category::linear;
using category = category::Linear;
template<enum_traits::is_category<category> Enum>
template<enum_traits::IsCategory<category> Enum>
static constexpr bool valid() noexcept
{
if constexpr (enum_traits::has_none<Enum>) {
if constexpr (enum_traits::HasNone<Enum>) {
constexpr auto xnone = detail::value_cast_impl(enum_traits::none<Enum>);
constexpr auto xmin = detail::value_cast_impl(enum_traits::min<Enum>);
constexpr auto xmax = detail::value_cast_impl(enum_traits::max<Enum>);
@@ -323,7 +323,7 @@
struct traits<category::linear>
}
}
template<enum_traits::is_category<category> Enum>
template<enum_traits::IsCategory<category> Enum>
static constexpr Enum enum_cast(enum_traits::value_type<Enum> x) noexcept
{
constexpr auto xnone = detail::value_cast_impl(enum_traits::none<Enum>);
@@ -336,18 +336,18 @@
struct traits<category::linear>
};
template<>
struct traits<category::bitmask>
struct Traits<category::Bitmask>
{
using category = category::bitmask;
using category = category::Bitmask;
template<enum_traits::is_category<category> Enum>
template<enum_traits::IsCategory<category> Enum>
static constexpr bool valid() noexcept
{
constexpr auto xmin = detail::value_cast_impl(enum_traits::min<Enum>);
constexpr auto xmax = detail::value_cast_impl(enum_traits::max<Enum>);
if constexpr ((xmin & xmax) == xmin) {
if constexpr (enum_traits::has_none<Enum>) {
if constexpr (enum_traits::HasNone<Enum>) {
constexpr auto xnone = detail::value_cast_impl(enum_traits::none<Enum>);
return xnone != detail::bitwise_clamp(xnone, xmin, xmax);
}
@@ -357,13 +357,13 @@
struct traits<category::bitmask>
return false;
}
template<enum_traits::is_category<category> Enum>
template<enum_traits::IsCategory<category> Enum>
static constexpr Enum enum_cast(enum_traits::value_type<Enum> value) noexcept
{
constexpr auto xmin = detail::value_cast_impl(enum_traits::min<Enum>);
constexpr auto xmax = detail::value_cast_impl(enum_traits::max<Enum>);
if constexpr (!enum_traits::has_none<Enum>) {
if constexpr (!enum_traits::HasNone<Enum>) {
return detail::enum_cast_impl<Enum>(
detail::bitwise_clamp<decltype(xmin)>(value, xmin, xmax)
);
@@ -379,22 +379,22 @@
struct traits<category::bitmask>
};
template<class Enum, Enum... vals>
struct traits<category::discrete<Enum, vals...>>
struct Traits<category::Discrete<Enum, vals...>>
{
using category = category::discrete<Enum, vals...>;
using category = category::Discrete<Enum, vals...>;
template<enum_traits::is_category<category> EnumI>
template<enum_traits::IsCategory<category> EnumI>
requires SameAs<Enum, EnumI>
static constexpr bool valid() noexcept
{
if constexpr (enum_traits::has_none<Enum>) {
if constexpr (enum_traits::HasNone<Enum>) {
return !(... || (vals == Enum::none));
} else {
return false;
}
}
template<enum_traits::is_category<category> EnumI>
template<enum_traits::IsCategory<category> EnumI>
requires SameAs<Enum, EnumI>
static constexpr Enum enum_cast(enum_traits::value_type<Enum> value) noexcept
{
@@ -408,13 +408,13 @@
struct traits<category::discrete<Enum, vals...>>
template<class Enum>
static constexpr auto valid() noexcept
{
return traits<enum_traits::category_type<Enum>>::template valid<Enum>();
return Traits<enum_traits::category_type<Enum>>::template valid<Enum>();
}
template<class Enum>
static constexpr auto enum_cast(enum_traits::value_type<Enum> value) noexcept
{
return traits<enum_traits::category_type<Enum>>::template enum_cast<Enum>(
return Traits<enum_traits::category_type<Enum>>::template enum_cast<Enum>(
value
);
}
@@ -445,7 +445,7 @@
constexpr Enum enum_cast(Enum value) noexcept
inline namespace operators
{
template<enum_traits::has_none Enum>
template<enum_traits::HasNone Enum>
constexpr bool operator!(const Enum& lhs) noexcept
{
return lhs == enum_traits::none<Enum>;
@@ -454,7 +454,7 @@
constexpr bool operator!(const Enum& lhs) noexcept
inline namespace op_inc
{
template<enum_traits::is_linear Enum>
template<enum_traits::IsLinear Enum>
constexpr Enum& operator++(Enum& lhs) noexcept
{
if (!(!lhs || lhs == enum_traits::max<Enum>)) {
@@ -463,7 +463,7 @@
constexpr Enum& operator++(Enum& lhs) noexcept
return lhs;
}
template<enum_traits::is_linear Enum>
template<enum_traits::IsLinear Enum>
constexpr Enum operator++(const Enum& lhs, int) noexcept
{
Enum ret = lhs;
@@ -476,7 +476,7 @@
constexpr Enum operator++(const Enum& lhs, int) noexcept
inline namespace op_dec
{
template<enum_traits::is_linear Enum>
template<enum_traits::IsLinear Enum>
constexpr Enum& operator--(Enum& lhs) noexcept
{
if (!(!lhs || lhs == enum_traits::min<Enum>)) {
@@ -485,7 +485,7 @@
constexpr Enum& operator--(Enum& lhs) noexcept
return lhs;
}
template<enum_traits::is_linear Enum>
template<enum_traits::IsLinear Enum>
constexpr Enum operator--(const Enum& lhs, int) noexcept
{
Enum ret = lhs;
@@ -498,10 +498,10 @@
constexpr Enum operator--(const Enum& lhs, int) noexcept
inline namespace op_or
{
template<enum_traits::is_bitmask Enum>
template<enum_traits::IsBitmask Enum>
constexpr Enum operator|(const Enum& lhs, const Enum& rhs) noexcept
{
if constexpr (enum_traits::has_none<Enum>) {
if constexpr (enum_traits::HasNone<Enum>) {
if (!lhs || !rhs) {
return enum_traits::none<Enum>;
}
@@ -509,10 +509,10 @@
constexpr Enum operator|(const Enum& lhs, const Enum& rhs) noexcept
return enum_cast<Enum>(value_cast(lhs) | value_cast(rhs));
}
template<enum_traits::is_bitmask Enum>
template<enum_traits::IsBitmask Enum>
constexpr Enum& operator|=(Enum& lhs, const Enum& rhs) noexcept
{
if constexpr (enum_traits::has_none<Enum>) {
if constexpr (enum_traits::HasNone<Enum>) {
if (!(!lhs || !rhs)) {
return lhs = enum_cast<Enum>(value_cast(lhs) | value_cast(rhs));
}
@@ -527,10 +527,10 @@
constexpr Enum& operator|=(Enum& lhs, const Enum& rhs) noexcept
inline namespace op_and
{
template<enum_traits::is_bitmask Enum>
template<enum_traits::IsBitmask Enum>
constexpr Enum operator&(const Enum& lhs, const Enum& rhs) noexcept
{
if constexpr (enum_traits::has_none<Enum>) {
if constexpr (enum_traits::HasNone<Enum>) {
if (!lhs || !rhs) {
return enum_traits::none<Enum>;
}
@@ -538,10 +538,10 @@
constexpr Enum operator&(const Enum& lhs, const Enum& rhs) noexcept
return enum_cast<Enum>(value_cast(lhs) & value_cast(rhs));
}
template<enum_traits::is_bitmask Enum>
template<enum_traits::IsBitmask Enum>
constexpr Enum& operator&=(Enum& lhs, const Enum& rhs) noexcept
{
if constexpr (enum_traits::has_none<Enum>) {
if constexpr (enum_traits::HasNone<Enum>) {
if (!(!lhs || !rhs)) {
return lhs = enum_cast<Enum>(value_cast(lhs) & value_cast(rhs));
}
@@ -556,10 +556,10 @@
constexpr Enum& operator&=(Enum& lhs, const Enum& rhs) noexcept
inline namespace op_xor
{
template<enum_traits::is_bitmask Enum>
template<enum_traits::IsBitmask Enum>
constexpr Enum operator^(const Enum& lhs, const Enum& rhs) noexcept
{
if constexpr (enum_traits::has_none<Enum>) {
if constexpr (enum_traits::HasNone<Enum>) {
if (!lhs || !rhs) {
return enum_traits::none<Enum>;
}
@@ -567,10 +567,10 @@
constexpr Enum operator^(const Enum& lhs, const Enum& rhs) noexcept
return enum_cast<Enum>(value_cast(lhs) ^ value_cast(rhs));
}
template<enum_traits::is_bitmask Enum>
template<enum_traits::IsBitmask Enum>
constexpr Enum& operator^=(Enum& lhs, const Enum& rhs) noexcept
{
if constexpr (enum_traits::has_none<Enum>) {
if constexpr (enum_traits::HasNone<Enum>) {
if (!(!lhs || !rhs)) {
return lhs = enum_cast<Enum>(value_cast(lhs) ^ value_cast(rhs));
}
@@ -585,10 +585,10 @@
constexpr Enum& operator^=(Enum& lhs, const Enum& rhs) noexcept
inline namespace op_not
{
template<enum_traits::is_bitmask Enum>
template<enum_traits::IsBitmask Enum>
constexpr Enum operator~(const Enum& lhs) noexcept
{
if constexpr (enum_traits::has_none<Enum>) {
if constexpr (enum_traits::HasNone<Enum>) {
if (!lhs) {
return enum_traits::none<Enum>;
}
@@ -601,37 +601,37 @@
constexpr Enum operator~(const Enum& lhs) noexcept
inline namespace shorthand
{
template<enum_traits::is_bitmask Enum>
template<enum_traits::IsBitmask Enum>
constexpr Enum& set(Enum& lhs, const Enum& rhs) noexcept
{
return lhs |= rhs;
}
template<enum_traits::is_bitmask Enum>
template<enum_traits::IsBitmask Enum>
constexpr Enum& mask(Enum& lhs, const Enum& rhs) noexcept
{
return lhs &= rhs;
}
template<enum_traits::is_bitmask Enum>
template<enum_traits::IsBitmask Enum>
constexpr Enum& tgl(Enum& lhs, const Enum& rhs) noexcept
{
return lhs ^= rhs;
}
template<enum_traits::is_bitmask Enum>
template<enum_traits::IsBitmask Enum>
constexpr Enum& neg(Enum& lhs) noexcept
{
return lhs = ~lhs;
}
template<enum_traits::is_bitmask Enum>
template<enum_traits::IsBitmask Enum>
constexpr Enum& clear(Enum& lhs, const Enum& rhs) noexcept
{
return lhs &= ~rhs;
}
template<enum_traits::is_bitmask Enum>
template<enum_traits::IsBitmask Enum>
constexpr bool test(const Enum& lhs, const Enum& rhs) noexcept
{
return (lhs & rhs) == rhs;
@@ -647,31 +647,31 @@
constexpr bool test(const Enum& lhs, const Enum& rhs) noexcept
#define BASED_ENUM_TRAITS(Name, Type, Category) \
template<> \
struct based::enumeration::enum_traits::traits<Name> \
struct based::enumeration::enum_traits::Traits<Name> \
{ \
using category = Category; \
using value_type = Type; \
};
#define BASED_ENUM_TRAITS_STANDARD(Name, Type) \
BASED_ENUM_TRAITS(Name, Type, based::enumeration::category::standard)
BASED_ENUM_TRAITS(Name, Type, based::enumeration::category::Standard)
#define BASED_ENUM_TRAITS_LINEAR(Name, Type) \
BASED_ENUM_TRAITS(Name, Type, based::enumeration::category::linear)
BASED_ENUM_TRAITS(Name, Type, based::enumeration::category::Linear)
#define BASED_ENUM_TRAITS_BITMASK(Name, Type) \
BASED_ENUM_TRAITS(Name, Type, based::enumeration::category::bitmask)
BASED_ENUM_TRAITS(Name, Type, based::enumeration::category::Bitmask)
#define BASED_ENUM(Name, Type, Category) \
enum class Name : typename Type::basic_type
#define BASED_ENUM_STANDARD(Name, Type) \
BASED_ENUM(Name, Type, based::enumeration::category::standard)
BASED_ENUM(Name, Type, based::enumeration::category::Standard)
#define BASED_ENUM_LINEAR(Name, Type) \
BASED_ENUM(Name, Type, based::enumeration::category::linear)
BASED_ENUM(Name, Type, based::enumeration::category::Linear)
#define BASED_ENUM_BITMASK(Name, Type) \
BASED_ENUM(Name, Type, based::enumeration::category::bitmask)
BASED_ENUM(Name, Type, based::enumeration::category::Bitmask)
// NOLINTEND(*macro*)
diff --git a/ include/based/functional/curry.hpp b/ include/based/functional/curry.hpp
@@ -9,22 +9,22 @@
namespace based
{
template<typename Function, typename... CapturedArgs>
class curried
class Curried
{
template<typename FFunction, typename... FCapturedArgs>
friend class curried;
friend class Curried;
Function m_function;
std::tuple<CapturedArgs...> m_captured;
curried(Function function, std::tuple<CapturedArgs...> args)
Curried(Function function, std::tuple<CapturedArgs...> args)
: m_function(function)
, m_captured(based::move(args))
{
}
public:
curried(Function function, CapturedArgs&&... args) // NOLINT(*explicit*)
Curried(Function function, CapturedArgs&&... args) // NOLINT(*explicit*)
: m_function(function)
, m_captured(based::forward<CapturedArgs>(args)...)
{
@@ -40,7 +40,7 @@
public:
if constexpr (std::is_invocable_v<Function, CapturedArgs..., NewArgs...>) {
return std::apply(m_function, based::move(all_args));
} else {
return curried<Function, CapturedArgs..., NewArgs...> {
return Curried<Function, CapturedArgs..., NewArgs...> {
m_function, based::move(all_args)
};
}
diff --git a/ include/based/functional/function.hpp b/ include/based/functional/function.hpp
@@ -22,7 +22,7 @@
class function;
template<size_t size, size_t alignment, typename Ret, typename... Args>
class function<Ret(Args...), size, alignment>
{
buffer<size, alignment> m_space;
Buffer<size, alignment> m_space{};
using executor_t = Ret (*)(Args..., void*);
diff --git a/ include/based/functional/invoke.hpp b/ include/based/functional/invoke.hpp
@@ -19,8 +19,8 @@
constexpr decltype(auto) invoke_memptr(
{
using object_t = remove_cvref_t<Object>;
constexpr bool is_member_function = is_function_v<Pointed>;
constexpr bool is_wrapped = is_reference_wrapper_v<object_t>;
constexpr bool is_derived_object =
constexpr bool is_wrapped = false = is_reference_wrapper_v<object_t>;
constexpr bool is_derived_object = false =
is_same_v<C, object_t> || is_base_of_v<C, object_t>;
if constexpr (is_member_function) {
diff --git a/ include/based/functional/overload.hpp b/ include/based/functional/overload.hpp
@@ -6,12 +6,12 @@
namespace based
/* ----- Overload Lambdas ----- */
template<typename... F>
struct overload : public F...
struct Overload : public F...
{
using F::operator()...;
};
template<typename... F>
overload(F&&...) -> overload<F...>;
Overload(F&&...) -> Overload<F...>;
} // namespace based
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 reference_wrapper
class ReferenceWrapper
{
public:
// types
@@ -32,23 +32,23 @@
public:
template<class U>
requires(requires {
detail::fun<T>(declval<U>());
requires(!is_same_v<reference_wrapper, remove_cvref_t<U>>);
requires(!is_same_v<ReferenceWrapper, remove_cvref_t<U>>);
})
// NOLINTNEXTLINE(*explicit*)
constexpr reference_wrapper(U&& obj
constexpr ReferenceWrapper(U&& obj
) noexcept(noexcept(detail::fun<T>(based::forward<U>(obj))))
: m_ptr(addressof(detail::fun<T>(based::forward<U>(obj))))
{
}
reference_wrapper(const reference_wrapper&) noexcept = default;
reference_wrapper& operator=(const reference_wrapper& x) noexcept = default;
ReferenceWrapper(const ReferenceWrapper&) noexcept = default;
ReferenceWrapper& operator=(const ReferenceWrapper& x) noexcept = default;
reference_wrapper(reference_wrapper&&) noexcept = delete;
reference_wrapper& operator=(reference_wrapper&& x) noexcept = delete;
ReferenceWrapper(ReferenceWrapper&&) noexcept = delete;
ReferenceWrapper& operator=(ReferenceWrapper&& x) noexcept = delete;
~reference_wrapper() = default;
~ReferenceWrapper() = default;
// NOLINTBEGIN(*explicit*)
constexpr operator T&() const noexcept { return *m_ptr; }
@@ -68,6 +68,6 @@
private:
// deduction guides
template<class T>
reference_wrapper(T&) -> reference_wrapper<T>;
ReferenceWrapper(T&) -> ReferenceWrapper<T>;
} // namespace based
diff --git a/ include/based/instrumentation/instrumented.hpp b/ include/based/instrumentation/instrumented.hpp
@@ -15,11 +15,11 @@
namespace based
{
struct instrumented_base
struct InstrumentedBase
{
BASED_DECLARE_ENUM(
based_declare_enum(
op,
based::bu8,
based::u8,
0,
n,
ctor_default,
@@ -31,21 +31,21 @@
struct instrumented_base
destructor,
equality,
comparison
)
);
static op::enum_type::array<double> counts;
static void initialize(size_t size)
{
std::fill(std::begin(counts), std::end(counts), 0.0);
counts[op::n] = static_cast<double>(size);
std::count[op::n] = static_cast<double>(size);
}
};
BASED_DEFINE_ENUM_CLASS(
instrumented_base,
op,
bu8,
u8,
0,
n,
ctor_default,
@@ -208,7 +208,7 @@
void count_operations(
instrumented_base::op::enum_type::array<double> values;
static constexpr int width = 12;
table tbl(width);
table const tbl(width);
tbl.print_header(
std::begin(instrumented::op::enum_type::names),
std::end(instrumented::op::enum_type::names)
diff --git a/ include/based/instrumentation/registry.hpp b/ include/based/instrumentation/registry.hpp
@@ -6,7 +6,7 @@
namespace based
{
template<typename D>
class registry
class Registry
{
public:
static size_t count;
@@ -14,13 +14,13 @@
public:
D* prev;
D* next;
registry(registry&&) = delete;
Registry(Registry&&) = delete;
registry& operator=(const registry&) = delete;
registry& operator=(registry&&) = delete;
Registry& operator=(const Registry&) = delete;
Registry& operator=(Registry&&) = delete;
private:
registry()
Registry()
: prev(nullptr)
, next(head)
{
@@ -31,12 +31,12 @@
private:
}
}
registry(const registry& /* reg */)
: registry()
Registry(const Registry& /* reg */)
: Registry()
{
}
~registry()
~Registry()
{
--count;
if (prev != nullptr) {
@@ -54,9 +54,9 @@
private:
};
template<typename D>
size_t registry<D>::count(0);
size_t Registry<D>::count(0);
template<typename D>
D* registry<D>::head(nullptr);
D* Registry<D>::head(nullptr);
} // namespace based
diff --git a/ include/based/instrumentation/table.hpp b/ include/based/instrumentation/table.hpp
@@ -8,10 +8,10 @@
namespace based
{
class table
class Table
{
public:
explicit table(size_t min_wth)
explicit Table(size_t min_wth)
: m_min_wth(min_wth)
{
}
diff --git a/ include/based/instrumentation/timer.hpp b/ include/based/instrumentation/timer.hpp
@@ -7,23 +7,23 @@
namespace based
{
class timer
class Timer
{
public:
using clock_t = std::chrono::high_resolution_clock;
using duration_t = std::chrono::microseconds;
timer()
Timer()
: m_startp(clock_t::now())
{
}
timer(const timer&) = delete;
timer(timer&&) = delete;
timer& operator=(const timer&) = delete;
timer& operator=(timer&&) = delete;
Timer(const Timer&) = delete;
Timer(Timer&&) = delete;
Timer& operator=(const Timer&) = delete;
Timer& operator=(Timer&&) = delete;
~timer()
~Timer()
{
stop();
std::cout << std::flush;
diff --git a/ include/based/integral/literals.hpp b/ include/based/integral/literals.hpp
@@ -12,27 +12,27 @@
namespace literals
consteval auto operator""_i(unsigned long long val)
{
return i::underlying_cast(val);
return I::underlying_cast(val);
}
consteval i8 operator""_i8(unsigned long long val)
consteval I8 operator""_i8(unsigned long long val)
{
return i::underlying_cast(val);
return I::underlying_cast(val);
}
consteval i16 operator""_i16(unsigned long long val)
consteval I16 operator""_I16(unsigned long long val)
{
return i::underlying_cast(val);
return I::underlying_cast(val);
}
consteval i32 operator""_i32(unsigned long long val)
consteval I32 operator""_I32(unsigned long long val)
{
return i::underlying_cast(val);
return I::underlying_cast(val);
}
consteval i64 operator""_i64(unsigned long long val)
consteval I64 operator""_I64(unsigned long long val)
{
return i::underlying_cast(val);
return I::underlying_cast(val);
}
} // namespace literals
@@ -44,27 +44,27 @@
namespace literals
consteval auto operator""_u(unsigned long long val)
{
return u::underlying_cast(val);
return U::underlying_cast(val);
}
consteval u8 operator""_u8(unsigned long long val)
consteval U8 operator""_u8(unsigned long long val)
{
return u::underlying_cast(val);
return U::underlying_cast(val);
}
consteval u16 operator""_u16(unsigned long long val)
consteval U16 operator""_U16(unsigned long long val)
{
return u::underlying_cast(val);
return U::underlying_cast(val);
}
consteval u32 operator""_u32(unsigned long long val)
consteval U32 operator""_U32(unsigned long long val)
{
return u::underlying_cast(val);
return U::underlying_cast(val);
}
consteval u64 operator""_u64(unsigned long long val)
consteval U64 operator""_U64(unsigned long long val)
{
return u::underlying_cast(val);
return U::underlying_cast(val);
}
} // namespace literals
diff --git a/ include/based/integral/strong.hpp b/ include/based/integral/strong.hpp
@@ -17,33 +17,33 @@
namespace based
template<class V, class Tag>
// NOLINTBEGIN(*crtp*)
struct strong_type
struct StrongType
{
using value_type = strong_type;
using value_type = StrongType;
using basic_type = V;
using tag_type = Tag;
basic_type value;
constexpr ~strong_type() = default;
constexpr ~StrongType() = default;
explicit constexpr strong_type()
explicit constexpr StrongType()
: value(0)
{
}
explicit constexpr strong_type(basic_type val)
explicit constexpr StrongType(basic_type val)
: value(val)
{
}
explicit constexpr operator basic_type() const { return value; }
constexpr strong_type(const strong_type&) = default;
constexpr strong_type(strong_type&&) = default;
constexpr StrongType(const StrongType&) = default;
constexpr StrongType(StrongType&&) = default;
constexpr strong_type& operator=(const strong_type&) = default;
constexpr strong_type& operator=(strong_type&&) = default;
constexpr StrongType& operator=(const StrongType&) = default;
constexpr StrongType& operator=(StrongType&&) = default;
template<class T>
static constexpr Tag underlying_cast(T value)
@@ -58,32 +58,31 @@
struct strong_type
}
};
// NOLINTEND(*crtp*)
template<class LHS, class RHS>
concept comparable = requires(LHS lhs, RHS rhs) { compare(lhs, rhs); };
concept Comparable = requires(LHS lhs, RHS rhs) { compare(lhs, rhs); };
template<class LHS, class RHS>
requires comparable<LHS, RHS>
requires Comparable<LHS, RHS>
constexpr bool operator==(LHS lhs, RHS rhs)
{
return lhs.value == rhs.value;
}
template<class LHS, class RHS>
concept ordered = requires(LHS lhs, RHS rhs) { order(lhs, rhs); };
concept Ordered = requires(LHS lhs, RHS rhs) { order(lhs, rhs); };
template<class LHS, class RHS>
requires ordered<LHS, RHS>
requires Ordered<LHS, RHS>
constexpr auto operator<=>(LHS lhs, RHS rhs)
{
return lhs.value <=> rhs.value;
}
template<class LHS, class RHS>
concept addable = requires(LHS lhs, RHS rhs) { add(lhs, rhs); };
concept Addable = requires(LHS lhs, RHS rhs) { add(lhs, rhs); };
template<class LHS, class RHS>
requires addable<LHS, RHS>
requires Addable<LHS, RHS>
constexpr auto operator+(LHS lhs, RHS rhs)
{
return BASED_DETAIL_MACRO(add(lhs, rhs), lhs.value + rhs.value);
@@ -91,7 +90,7 @@
constexpr auto operator+(LHS lhs, RHS rhs)
template<class LHS, class RHS>
requires(requires(LHS lhs, RHS rhs) {
requires addable<LHS, RHS>;
requires Addable<LHS, RHS>;
requires SameAs<LHS, decltype(add(lhs, rhs))>;
})
constexpr auto& operator+=(LHS& lhs, RHS rhs)
@@ -100,10 +99,10 @@
constexpr auto& operator+=(LHS& lhs, RHS rhs)
}
template<class LHS, class RHS>
concept subtractable = requires(LHS lhs, RHS rhs) { sub(lhs, rhs); };
concept Subtractable = requires(LHS lhs, RHS rhs) { sub(lhs, rhs); };
template<class LHS, class RHS>
requires subtractable<LHS, RHS>
requires Subtractable<LHS, RHS>
constexpr auto operator-(LHS lhs, RHS rhs)
{
return BASED_DETAIL_MACRO(sub(lhs, rhs), lhs.value - rhs.value);
@@ -111,7 +110,7 @@
constexpr auto operator-(LHS lhs, RHS rhs)
template<class LHS, class RHS>
requires(requires(LHS lhs, RHS rhs) {
requires subtractable<LHS, RHS>;
requires Subtractable<LHS, RHS>;
requires SameAs<LHS, decltype(sub(lhs, rhs))>;
})
constexpr auto& operator-=(LHS& lhs, RHS rhs)
@@ -120,10 +119,10 @@
constexpr auto& operator-=(LHS& lhs, RHS rhs)
}
template<class LHS, class RHS>
concept multiplyable = requires(LHS lhs, RHS rhs) { mul(lhs, rhs); };
concept Multiplyable = requires(LHS lhs, RHS rhs) { mul(lhs, rhs); };
template<class LHS, class RHS>
requires multiplyable<LHS, RHS>
requires Multiplyable<LHS, RHS>
constexpr auto operator*(LHS lhs, RHS rhs)
{
return BASED_DETAIL_MACRO(mul(lhs, rhs), lhs.value * rhs.value);
@@ -131,7 +130,7 @@
constexpr auto operator*(LHS lhs, RHS rhs)
template<class LHS, class RHS>
requires(requires(LHS lhs, RHS rhs) {
requires multiplyable<LHS, RHS>;
requires Multiplyable<LHS, RHS>;
requires SameAs<LHS, decltype(mul(lhs, rhs))>;
})
constexpr auto& operator*=(LHS& lhs, RHS rhs)
@@ -140,10 +139,10 @@
constexpr auto& operator*=(LHS& lhs, RHS rhs)
}
template<class LHS, class RHS>
concept divisible = requires(LHS lhs, RHS rhs) { div(lhs, rhs); };
concept Divisible = requires(LHS lhs, RHS rhs) { div(lhs, rhs); };
template<class LHS, class RHS>
requires divisible<LHS, RHS>
requires Divisible<LHS, RHS>
constexpr auto operator/(LHS lhs, RHS rhs)
{
return BASED_DETAIL_MACRO(div(lhs, rhs), lhs.value / rhs.value);
@@ -151,7 +150,7 @@
constexpr auto operator/(LHS lhs, RHS rhs)
template<class LHS, class RHS>
requires(requires(LHS lhs, RHS rhs) {
requires divisible<LHS, RHS>;
requires Divisible<LHS, RHS>;
requires SameAs<LHS, decltype(div(lhs, rhs))>;
})
constexpr auto& operator/=(LHS& lhs, RHS rhs)
@@ -160,10 +159,10 @@
constexpr auto& operator/=(LHS& lhs, RHS rhs)
}
template<class LHS, class RHS>
concept modable = requires(LHS lhs, RHS rhs) { mod(lhs, rhs); };
concept Modable = requires(LHS lhs, RHS rhs) { mod(lhs, rhs); };
template<class LHS, class RHS>
requires modable<LHS, RHS>
requires Modable<LHS, RHS>
constexpr auto operator%(LHS lhs, RHS rhs)
{
return BASED_DETAIL_MACRO(mod(lhs, rhs), lhs.value % rhs.value);
@@ -171,7 +170,7 @@
constexpr auto operator%(LHS lhs, RHS rhs)
template<class LHS, class RHS>
requires(requires(LHS lhs, RHS rhs) {
requires modable<LHS, RHS>;
requires Modable<LHS, RHS>;
requires SameAs<LHS, decltype(mod(lhs, rhs))>;
})
constexpr auto& operator%=(LHS& lhs, RHS rhs)
@@ -180,10 +179,10 @@
constexpr auto& operator%=(LHS& lhs, RHS rhs)
}
template<class LHS, class RHS>
concept lshiftable = requires(LHS lhs, RHS rhs) { lshift(lhs, rhs); };
concept Lshiftable = requires(LHS lhs, RHS rhs) { lshift(lhs, rhs); };
template<class LHS, class RHS>
requires lshiftable<LHS, RHS>
requires Lshiftable<LHS, RHS>
constexpr auto operator<<(LHS lhs, RHS rhs)
{
return BASED_DETAIL_MACRO(lshift(lhs, rhs), lhs.value << rhs.value);
@@ -191,7 +190,7 @@
constexpr auto operator<<(LHS lhs, RHS rhs)
template<class LHS, class RHS>
requires(requires(LHS lhs, RHS rhs) {
requires lshiftable<LHS, RHS>;
requires Lshiftable<LHS, RHS>;
requires SameAs<LHS, decltype(lshift(lhs, rhs))>;
})
constexpr auto& operator<<=(LHS& lhs, RHS rhs)
@@ -200,10 +199,10 @@
constexpr auto& operator<<=(LHS& lhs, RHS rhs)
}
template<class LHS, class RHS>
concept rshiftable = requires(LHS lhs, RHS rhs) { rshift(lhs, rhs); };
concept Rshiftable = requires(LHS lhs, RHS rhs) { rshift(lhs, rhs); };
template<class LHS, class RHS>
requires rshiftable<LHS, RHS>
requires Rshiftable<LHS, RHS>
constexpr auto operator>>(LHS lhs, RHS rhs)
{
return BASED_DETAIL_MACRO(rshift(lhs, rhs), lhs.value >> rhs.value);
@@ -211,7 +210,7 @@
constexpr auto operator>>(LHS lhs, RHS rhs)
template<class LHS, class RHS>
requires(requires(LHS lhs, RHS rhs) {
requires rshiftable<LHS, RHS>;
requires Rshiftable<LHS, RHS>;
requires SameAs<LHS, decltype(rshift(lhs, rhs))>;
})
constexpr auto& operator>>=(LHS& lhs, RHS rhs)
@@ -220,10 +219,10 @@
constexpr auto& operator>>=(LHS& lhs, RHS rhs)
}
template<class LHS, class RHS>
concept andable = requires(LHS lhs, RHS rhs) { land(lhs, rhs); };
concept Andable = requires(LHS lhs, RHS rhs) { land(lhs, rhs); };
template<class LHS, class RHS>
requires andable<LHS, RHS>
requires Andable<LHS, RHS>
constexpr auto operator&(LHS lhs, RHS rhs)
{
return BASED_DETAIL_MACRO(land(lhs, rhs), lhs.value & rhs.value);
@@ -231,7 +230,7 @@
constexpr auto operator&(LHS lhs, RHS rhs)
template<class LHS, class RHS>
requires(requires(LHS lhs, RHS rhs) {
requires andable<LHS, RHS>;
requires Andable<LHS, RHS>;
requires SameAs<LHS, decltype(land(lhs, rhs))>;
})
constexpr auto& operator&=(LHS& lhs, RHS rhs)
@@ -240,10 +239,10 @@
constexpr auto& operator&=(LHS& lhs, RHS rhs)
}
template<class LHS, class RHS>
concept orable = requires(LHS lhs, RHS rhs) { lor(lhs, rhs); };
concept Orable = requires(LHS lhs, RHS rhs) { lor(lhs, rhs); };
template<class LHS, class RHS>
requires orable<LHS, RHS>
requires Orable<LHS, RHS>
constexpr auto operator|(LHS lhs, RHS rhs)
{
return BASED_DETAIL_MACRO(lor(lhs, rhs), lhs.value | rhs.value);
@@ -251,7 +250,7 @@
constexpr auto operator|(LHS lhs, RHS rhs)
template<class LHS, class RHS>
requires(requires(LHS lhs, RHS rhs) {
requires orable<LHS, RHS>;
requires Orable<LHS, RHS>;
requires SameAs<LHS, decltype(lor(lhs, rhs))>;
})
constexpr auto& operator|=(LHS& lhs, RHS rhs)
@@ -260,10 +259,10 @@
constexpr auto& operator|=(LHS& lhs, RHS rhs)
}
template<class LHS, class RHS>
concept xorable = requires(LHS lhs, RHS rhs) { lxor(lhs, rhs); };
concept Xorable = requires(LHS lhs, RHS rhs) { lxor(lhs, rhs); };
template<class LHS, class RHS>
requires xorable<LHS, RHS>
requires Xorable<LHS, RHS>
constexpr auto operator^(LHS lhs, RHS rhs)
{
return BASED_DETAIL_MACRO(lxor(lhs, rhs), lhs.value ^ rhs.value);
@@ -271,7 +270,7 @@
constexpr auto operator^(LHS lhs, RHS rhs)
template<class LHS, class RHS>
requires(requires(LHS lhs, RHS rhs) {
requires xorable<LHS, RHS>;
requires Xorable<LHS, RHS>;
requires SameAs<LHS, decltype(lxor(lhs, rhs))>;
})
constexpr auto& operator^=(LHS& lhs, RHS rhs)
@@ -280,10 +279,10 @@
constexpr auto& operator^=(LHS& lhs, RHS rhs)
}
template<class LHS>
concept lnotable = requires(LHS lhs) { lnot(lhs); };
concept Lnotable = requires(LHS lhs) { lnot(lhs); };
template<class LHS>
requires lnotable<LHS>
requires Lnotable<LHS>
constexpr auto operator~(LHS lhs)
{
lhs.value = ~lhs.value;
@@ -291,27 +290,27 @@
constexpr auto operator~(LHS lhs)
}
template<class LHS>
concept unariable = requires(LHS lhs) { unary(lhs); };
concept Unariable = requires(LHS lhs) { unary(lhs); };
template<class LHS>
requires unariable<LHS>
requires Unariable<LHS>
constexpr auto operator+(LHS lhs)
{
return decltype(lhs)(+lhs.value);
}
template<class LHS>
requires unariable<LHS>
requires Unariable<LHS>
constexpr auto operator-(LHS lhs)
{
return decltype(lhs)(-lhs.value);
}
template<class LHS>
concept preincable = requires(LHS lhs) { preinc(lhs); };
concept Preincable = requires(LHS lhs) { preinc(lhs); };
template<class LHS>
requires preincable<LHS>
requires Preincable<LHS>
constexpr auto& operator++(LHS& lhs)
{
++lhs.value;
@@ -319,20 +318,20 @@
constexpr auto& operator++(LHS& lhs)
}
template<class LHS>
concept postincable = requires(LHS lhs) { postinc(lhs); };
concept Postincable = requires(LHS lhs) { postinc(lhs); };
template<class LHS>
requires postincable<LHS>
requires Postincable<LHS>
constexpr auto operator++(LHS& lhs, int)
{
return BASED_DETAIL_MACRO(postinc(lhs), lhs.value++);
}
template<class LHS>
concept predecable = requires(LHS lhs) { predec(lhs); };
concept Predecable = requires(LHS lhs) { predec(lhs); };
template<class LHS>
requires predecable<LHS>
requires Predecable<LHS>
constexpr auto operator--(LHS& lhs)
{
--lhs.value;
@@ -340,10 +339,10 @@
constexpr auto operator--(LHS& lhs)
}
template<class LHS>
concept postdecable = requires(LHS lhs) { postdec(lhs); };
concept Postdecable = requires(LHS lhs) { postdec(lhs); };
template<class LHS>
requires postdecable<LHS>
requires Postdecable<LHS>
constexpr auto operator--(LHS& lhs, int)
{
return BASED_DETAIL_MACRO(postdec(lhs), lhs.value--);
diff --git a/ include/based/integral/types.hpp b/ include/based/integral/types.hpp
@@ -44,252 +44,252 @@
using size_t = unsigned long long int;
template<class T>
struct limits;
struct i64 : strong_type<signed long long int, i64>
struct I64 : StrongType<signed long long int, I64>
{
using strong_type::strong_type;
using strong_type::operator=;
using StrongType::StrongType;
using StrongType::operator=;
};
struct i32 : strong_type<signed int, i32>
struct I32 : StrongType<signed int, I32>
{
using strong_type::strong_type;
using strong_type::operator=;
using StrongType::StrongType;
using StrongType::operator=;
explicit constexpr operator i64() { return i64::underlying_cast(value); }
explicit constexpr operator I64() { return I64::underlying_cast(value); }
[[nodiscard]] constexpr i64 to_i64() const { return i64::cast(*this); }
[[nodiscard]] constexpr I64 to_i64() const { return I64::cast(*this); }
};
struct i16 : strong_type<signed short int, i16>
struct I16 : StrongType<signed short int, I16>
{
using strong_type::strong_type;
using strong_type::operator=;
using StrongType::StrongType;
using StrongType::operator=;
explicit constexpr operator i64() { return i64::underlying_cast(value); }
explicit constexpr operator i32() { return i32::underlying_cast(value); }
explicit constexpr operator I64() { return I64::underlying_cast(value); }
explicit constexpr operator I32() { return I32::underlying_cast(value); }
[[nodiscard]] constexpr i64 to_i64() const { return i64::cast(*this); }
[[nodiscard]] constexpr i32 to_i32() const { return i32::cast(*this); }
[[nodiscard]] constexpr I64 to_i64() const { return I64::cast(*this); }
[[nodiscard]] constexpr I32 to_i32() const { return I32::cast(*this); }
};
struct i8 : strong_type<signed char, i8>
struct I8 : StrongType<signed char, I8>
{
using strong_type::strong_type;
using strong_type::operator=;
using StrongType::StrongType;
using StrongType::operator=;
explicit constexpr operator i64() { return i64::underlying_cast(value); }
explicit constexpr operator i32() { return i32::underlying_cast(value); }
explicit constexpr operator i16() { return i16::underlying_cast(value); }
explicit constexpr operator I64() { return I64::underlying_cast(value); }
explicit constexpr operator I32() { return I32::underlying_cast(value); }
explicit constexpr operator I16() { return I16::underlying_cast(value); }
[[nodiscard]] constexpr i64 to_i64() const { return i64::cast(*this); }
[[nodiscard]] constexpr i32 to_i32() const { return i32::cast(*this); }
[[nodiscard]] constexpr i16 to_i16() const { return i16::cast(*this); }
[[nodiscard]] constexpr I64 to_i64() const { return I64::cast(*this); }
[[nodiscard]] constexpr I32 to_i32() const { return I32::cast(*this); }
[[nodiscard]] constexpr I16 to_i16() const { return I16::cast(*this); }
};
template<>
struct limits<i8>
struct limits<I8>
{
static constexpr bool is_integer = true;
static constexpr bool is_signed = true;
static constexpr auto min = i8::underlying_cast(0x80);
static constexpr auto max = i8::underlying_cast(0x7F);
static constexpr auto min = I8::underlying_cast(0x80);
static constexpr auto max = I8::underlying_cast(0x7F);
};
template<>
struct limits<i16>
struct limits<I16>
{
static constexpr bool is_integer = true;
static constexpr bool is_signed = true;
static constexpr auto min = i16::underlying_cast(0x8000);
static constexpr auto max = i16::underlying_cast(0x7FFF);
static constexpr auto min = I16::underlying_cast(0x8000);
static constexpr auto max = I16::underlying_cast(0x7FFF);
};
template<>
struct limits<i32>
struct limits<I32>
{
static constexpr bool is_integer = true;
static constexpr bool is_signed = true;
static constexpr auto min = i32::underlying_cast(0x80000000);
static constexpr auto max = i32::underlying_cast(0x7FFFFFFF);
static constexpr auto min = I32::underlying_cast(0x80000000);
static constexpr auto max = I32::underlying_cast(0x7FFFFFFF);
};
template<>
struct limits<i64>
struct limits<I64>
{
static constexpr bool is_integer = true;
static constexpr bool is_signed = true;
static constexpr auto min = i64::underlying_cast(0x8000000000000000);
static constexpr auto max = i64::underlying_cast(0x7FFFFFFFFFFFFFFF);
static constexpr auto min = I64::underlying_cast(0x8000000000000000);
static constexpr auto max = I64::underlying_cast(0x7FFFFFFFFFFFFFFF);
};
struct i : strong_type<signed long long int, i>
struct I : StrongType<signed long long int, I>
{
using strong_type::strong_type;
using strong_type::operator=;
using StrongType::StrongType;
using StrongType::operator=;
consteval operator i8() const // NOLINT(*explicit*)
consteval operator I8() const // NOLINT(*explicit*)
{
BASED_ASSERT(value >= limits<i8>::min.value);
BASED_ASSERT(value <= limits<i8>::max.value);
return i8::underlying_cast(value);
BASED_ASSERT(value >= limits<I8>::min.value);
BASED_ASSERT(value <= limits<I8>::max.value);
return I8::underlying_cast(value);
}
consteval operator i16() const // NOLINT(*explicit*)
consteval operator I16() const // NOLINT(*explicit*)
{
BASED_ASSERT(value >= limits<i16>::min.value);
BASED_ASSERT(value <= limits<i16>::max.value);
return i16::underlying_cast(value);
BASED_ASSERT(value >= limits<I16>::min.value);
BASED_ASSERT(value <= limits<I16>::max.value);
return I16::underlying_cast(value);
}
consteval operator i32() const // NOLINT(*explicit*)
consteval operator I32() const // NOLINT(*explicit*)
{
BASED_ASSERT(value >= limits<i32>::min.value);
BASED_ASSERT(value <= limits<i32>::max.value);
return i32::underlying_cast(value);
BASED_ASSERT(value >= limits<I32>::min.value);
BASED_ASSERT(value <= limits<I32>::max.value);
return I32::underlying_cast(value);
}
consteval operator i64() const // NOLINT(*explicit*)
consteval operator I64() const // NOLINT(*explicit*)
{
BASED_ASSERT(value >= limits<i64>::min.value);
BASED_ASSERT(value <= limits<i64>::max.value);
return i64::underlying_cast(value);
BASED_ASSERT(value >= limits<I64>::min.value);
BASED_ASSERT(value <= limits<I64>::max.value);
return I64::underlying_cast(value);
}
};
auto unary(i) -> i;
auto unary(I) -> I;
struct u64 : strong_type<unsigned long long int, u64>
struct U64 : StrongType<unsigned long long int, U64>
{
using strong_type::strong_type;
using strong_type::operator=;
using StrongType::StrongType;
using StrongType::operator=;
};
struct u32 : strong_type<unsigned int, u32>
struct U32 : StrongType<unsigned int, U32>
{
using strong_type::strong_type;
using strong_type::operator=;
using StrongType::StrongType;
using StrongType::operator=;
explicit constexpr operator u64() { return u64::underlying_cast(value); }
explicit constexpr operator U64() { return U64::underlying_cast(value); }
[[nodiscard]] constexpr u64 to_u64() const { return u64::cast(*this); }
[[nodiscard]] constexpr U64 to_u64() const { return U64::cast(*this); }
};
struct u16 : strong_type<unsigned short int, u16>
struct U16 : StrongType<unsigned short int, U16>
{
using strong_type::strong_type;
using strong_type::operator=;
using StrongType::StrongType;
using StrongType::operator=;
explicit constexpr operator u64() { return u64::underlying_cast(value); }
explicit constexpr operator u32() { return u32::underlying_cast(value); }
explicit constexpr operator U64() { return U64::underlying_cast(value); }
explicit constexpr operator U32() { return U32::underlying_cast(value); }
[[nodiscard]] constexpr u64 to_u64() const { return u64::cast(*this); }
[[nodiscard]] constexpr u32 to_u32() const { return u32::cast(*this); }
[[nodiscard]] constexpr U64 to_u64() const { return U64::cast(*this); }
[[nodiscard]] constexpr U32 to_u32() const { return U32::cast(*this); }
};
struct u8 : strong_type<unsigned char, u8>
struct U8 : StrongType<unsigned char, U8>
{
using strong_type::strong_type;
using strong_type::operator=;
using StrongType::StrongType;
using StrongType::operator=;
explicit constexpr operator u64() { return u64::underlying_cast(value); }
explicit constexpr operator u32() { return u32::underlying_cast(value); }
explicit constexpr operator u16() { return u16::underlying_cast(value); }
explicit constexpr operator U64() { return U64::underlying_cast(value); }
explicit constexpr operator U32() { return U32::underlying_cast(value); }
explicit constexpr operator U16() { return U16::underlying_cast(value); }
[[nodiscard]] constexpr u64 to_u64() const { return u64::cast(*this); }
[[nodiscard]] constexpr u32 to_u32() const { return u32::cast(*this); }
[[nodiscard]] constexpr u16 to_u16() const { return u16::cast(*this); }
[[nodiscard]] constexpr U64 to_u64() const { return U64::cast(*this); }
[[nodiscard]] constexpr U32 to_u32() const { return U32::cast(*this); }
[[nodiscard]] constexpr U16 to_u16() const { return U16::cast(*this); }
};
template<>
struct limits<u8>
struct limits<U8>
{
static constexpr bool is_integer = true;
static constexpr bool is_signed = false;
static constexpr auto min = u8::underlying_cast(0x00);
static constexpr auto max = u8::underlying_cast(0xFF);
static constexpr auto min = U8::underlying_cast(0x00);
static constexpr auto max = U8::underlying_cast(0xFF);
};
template<>
struct limits<u16>
struct limits<U16>
{
static constexpr bool is_integer = true;
static constexpr bool is_signed = false;
static constexpr auto min = u16::underlying_cast(0x0000);
static constexpr auto max = u16::underlying_cast(0xFFFF);
static constexpr auto min = U16::underlying_cast(0x0000);
static constexpr auto max = U16::underlying_cast(0xFFFF);
};
template<>
struct limits<u32>
struct limits<U32>
{
static constexpr bool is_integer = true;
static constexpr bool is_signed = false;
static constexpr auto min = u32::underlying_cast(0x00000000);
static constexpr auto max = u32::underlying_cast(0xFFFFFFFF);
static constexpr auto min = U32::underlying_cast(0x00000000);
static constexpr auto max = U32::underlying_cast(0xFFFFFFFF);
};
template<>
struct limits<u64>
struct limits<U64>
{
static constexpr bool is_integer = true;
static constexpr bool is_signed = false;
static constexpr auto min = u64::underlying_cast(0x0000000000000000);
static constexpr auto max = u64::underlying_cast(0xFFFFFFFFFFFFFFFF);
static constexpr auto min = U64::underlying_cast(0x0000000000000000);
static constexpr auto max = U64::underlying_cast(0xFFFFFFFFFFFFFFFF);
};
struct u : strong_type<unsigned long long int, u>
struct U : StrongType<unsigned long long int, U>
{
using strong_type::strong_type;
using StrongType::StrongType;
consteval operator u8() const // NOLINT(*explicit*)
consteval operator U8() const // NOLINT(*explicit*)
{
BASED_ASSERT(value >= limits<u8>::min.value);
BASED_ASSERT(value <= limits<u8>::max.value);
return u8::underlying_cast(value);
BASED_ASSERT(value >= limits<U8>::min.value);
BASED_ASSERT(value <= limits<U8>::max.value);
return U8::underlying_cast(value);
}
consteval operator u16() const // NOLINT(*explicit*)
consteval operator U16() const // NOLINT(*explicit*)
{
BASED_ASSERT(value >= limits<u16>::min.value);
BASED_ASSERT(value <= limits<u16>::max.value);
return u16::underlying_cast(value);
BASED_ASSERT(value >= limits<U16>::min.value);
BASED_ASSERT(value <= limits<U16>::max.value);
return U16::underlying_cast(value);
}
consteval operator u32() const // NOLINT(*explicit*)
consteval operator U32() const // NOLINT(*explicit*)
{
BASED_ASSERT(value >= limits<u32>::min.value);
BASED_ASSERT(value <= limits<u32>::max.value);
return u32::underlying_cast(value);
BASED_ASSERT(value >= limits<U32>::min.value);
BASED_ASSERT(value <= limits<U32>::max.value);
return U32::underlying_cast(value);
}
consteval operator u64() const // NOLINT(*explicit*)
consteval operator U64() const // NOLINT(*explicit*)
{
BASED_ASSERT(value >= limits<u64>::min.value);
BASED_ASSERT(value <= limits<u64>::max.value);
return u64::underlying_cast(value);
BASED_ASSERT(value >= limits<U64>::min.value);
BASED_ASSERT(value <= limits<U64>::max.value);
return U64::underlying_cast(value);
}
};
BASED_FOREACH_1(
i, BASED_DETAIL_OP_UNARY, unary, preinc, postinc, predec, postdec
I, BASED_DETAIL_OP_UNARY, unary, preinc, postinc, predec, postdec
)
BASED_FOREACH_1(
i, BASED_DETAIL_OP_BINARY, compare, order, add, sub, mul, div, mod
I, BASED_DETAIL_OP_BINARY, compare, order, add, sub, mul, div, mod
)
BASED_FOREACH_1(
u, BASED_DETAIL_OP_UNARY, preinc, postinc, predec, postdec, lnot
U, BASED_DETAIL_OP_UNARY, preinc, postinc, predec, postdec, lnot
)
BASED_FOREACH_1(
u,
U,
BASED_DETAIL_OP_BINARY,
compare,
order,
diff --git a/ include/based/string/literal.hpp b/ include/based/string/literal.hpp
@@ -8,10 +8,10 @@
namespace based
{
template<size_t n>
struct string_literal
struct StringLiteral
{
// NOLINTNEXTLINE(*explicit*, *array*)
constexpr string_literal(const char (&str)[n])
constexpr StringLiteral(const char (&str)[n])
: m_value(std::to_array(str))
{
}
diff --git a/ include/based/trait/add/lvalue_reference.hpp b/ include/based/trait/add/lvalue_reference.hpp
@@ -18,9 +18,9 @@
template<class T> auto try_add(...) -> type_identity<T>;
} // namespace detail
template<class T> struct add_lvalue_reference : decltype(detail::try_add<T>(0)) {};
template<class T> struct AddLvalueReference : decltype(detail::try_add<T>(0)) {};
template<class T> using add_lvalue_reference_t = add_lvalue_reference<T>::type;
template<class T> using add_lvalue_reference_t = AddLvalueReference<T>::type;
// clang-format on
diff --git a/ include/based/trait/add/pointer.hpp b/ include/based/trait/add/pointer.hpp
@@ -11,14 +11,14 @@
namespace based
namespace detail
{
template<class T> type_identity<remove_reference_t<T>*> try_add_pointer(int);
template<class T> type_identity<T> try_add_pointer(...);
template<class T> TypeIdentity<remove_reference_t<T>*> try_add_pointer(int);
template<class T> TypeIdentity<T> try_add_pointer(...);
} // namespace detail
template<class T> struct add_pointer : decltype(detail::try_add_pointer<T>(0)) {};
template<class T> struct AddPointer : decltype(detail::try_add_pointer<T>(0)) {};
template<class T> using add_pointer_t = add_pointer<T>::type;
template<class T> using add_pointer_t = AddPointer<T>::type;
// clang-format on
diff --git a/ include/based/trait/add/rvalue_reference.hpp b/ include/based/trait/add/rvalue_reference.hpp
@@ -11,16 +11,16 @@
namespace detail
{
// Note that “cv void&&” is a substitution failure
template<class T> auto try_add(int) -> type_identity<T&&>;
template<class T> auto try_add(int) -> std::type_identity<T&&>;
// Handle T = cv void case
template<class T> auto try_add(...) -> type_identity<T>;
template<class T> auto try_add(...) -> std::type_identity<T>;
} // namespace detail
template<class T> struct add_rvalue_reference : decltype(detail::try_add<T>(0)) {};
template<class T> struct AddRvalueReference : decltype(detail::try_add<T>(0)) {};
template<class T> using add_rvalue_reference_t = add_rvalue_reference<T>::type;
template<class T> using add_rvalue_reference_t = AddRvalueReference<T>::type;
// clang-format on
diff --git a/ include/based/trait/conditional.hpp b/ include/based/trait/conditional.hpp
@@ -5,10 +5,10 @@
namespace based
// 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 Conditional { using type = T; };
template<class T, class F> struct Conditional<false, T, F> { using type = F; };
template<bool b, class T, class F> using conditional_t = conditional<b, T, F>::type;
template<bool b, class T, class F> using conditional_t = Conditional<b, T, F>::type;
// clang-format on
diff --git a/ include/based/trait/decay.hpp b/ include/based/trait/decay.hpp
@@ -14,7 +14,7 @@
namespace based
// clang-format off
template<class T>
struct decay
struct Decay
{
private:
using u = remove_reference_t<T>;
@@ -30,7 +30,7 @@
public:
>;
};
template<class T> using decay_t = typename decay<T>::type;
template<class T> using decay_t = typename Decay<T>::type;
// clang-format on
diff --git a/ include/based/trait/enable_if.hpp b/ include/based/trait/enable_if.hpp
@@ -5,10 +5,10 @@
namespace based
// clang-format off
template<bool b, class T = void> struct enable_if {};
template<class T> struct enable_if<true, T> { using type = T; };
template<bool b, class T = void> struct EnableIf {};
template<class T> struct EnableIf<true, T> { using type = T; };
template<bool b, class T = void> using enable_if_t = typename enable_if<b, T>::type;
template<bool b, class T = void> using enable_if_t = typename EnableIf<b, T>::type;
// clang-format on
diff --git a/ include/based/trait/integral_constant.hpp b/ include/based/trait/integral_constant.hpp
@@ -4,12 +4,12 @@
namespace based
{
template<class T, T v>
struct integral_constant
struct IntegralConstant
{
static constexpr T value = v;
using value_type = T;
using type = integral_constant;
using type = IntegralConstant;
// NOLINTNEXTLINE(*explicit*)
constexpr operator value_type() const noexcept { return value; }
@@ -17,7 +17,7 @@
struct integral_constant
};
template<bool b>
using bool_constant = integral_constant<bool, b>;
using bool_constant = IntegralConstant<bool, b>;
using true_type = bool_constant<true>;
using false_type = bool_constant<false>;
diff --git a/ include/based/trait/invoke_result.hpp b/ include/based/trait/invoke_result.hpp
@@ -12,7 +12,7 @@
namespace detail
{
template<class T>
struct invoke_impl
struct InvokeImpl
{
template<class F, class... Args>
static auto call(F&& func, Args&&... args)
@@ -20,7 +20,7 @@
struct invoke_impl
};
template<class B, class MT>
struct invoke_impl<MT B::*>
struct InvokeImpl<MT B::*>
{
template<class T>
requires(is_base_of_v<B, decay_t<T>>)
@@ -31,25 +31,26 @@
struct invoke_impl<MT B::*>
static auto get(T&& obj) -> decltype(obj.get());
template<class T>
requires(!is_base_of_v<B, decay_t<T>> && !is_reference_wrapper_v<decay<T>>)
requires(!is_base_of_v<B, decay_t<T>> && !is_reference_wrapper_v<decay_t<T>>)
static auto get(T&& obj) -> decltype(*based::forward<T>(obj));
template<class T, class... Args, class MT1>
requires(is_function_v<MT1>)
static auto call(MT1 B::* pmf, T&& obj, Args&&... args)
-> decltype((invoke_impl::get(based::forward<T>(obj)).*pmf)(
-> decltype((InvokeImpl::get(based::forward<T>(obj)).*pmf)(
based::forward<Args>(args)...
));
template<class T>
static auto call(MT B::* pmd, T&& obj)
-> decltype(invoke_impl::get(based::forward<T>(obj)).*pmd);
-> decltype(InvokeImpl::get(based::forward<T>(obj)).*pmd);
};
template<class F, class... Args>
auto INVOKE(F&& func, Args&&... args) -> decltype(invoke_impl<decay_t<F>>::call(
based::forward<F>(func), based::forward<Args>(args)...
));
auto invoke_f(F&& func, Args&&... args)
-> decltype(InvokeImpl<decay_t<F>>::call(
based::forward<F>(func), based::forward<Args>(args)...
));
} // namespace detail
@@ -57,27 +58,27 @@
namespace detail
{
template<typename AlwaysVoid, typename, typename...>
struct invoke_result
struct InvokeResult
{
};
template<typename F, typename... Args>
struct invoke_result<
decltype(void(detail::INVOKE(declval<F>(), declval<Args>()...))),
struct InvokeResult<
decltype(void(detail::invoke_f(declval<F>(), declval<Args>()...))),
F,
Args...>
{
using type = decltype(detail::INVOKE(declval<F>(), declval<Args>()...));
using type = decltype(detail::invoke_f(declval<F>(), declval<Args>()...));
};
} // namespace detail
template<class F, class... Args>
struct invoke_result : detail::invoke_result<void, F, Args...>
struct InvokeResult : detail::InvokeResult<void, F, Args...>
{
};
template<class F, class... Args>
using invoke_result_t = typename invoke_result<F, Args...>::type;
using invoke_result_t = typename InvokeResult<F, Args...>::type;
} // namespace based
diff --git a/ include/based/trait/is/arithmetic.hpp b/ include/based/trait/is/arithmetic.hpp
@@ -8,11 +8,11 @@
namespace based
{
template<class T>
struct is_arithmetic : bool_constant<is_integral_v<T> || is_floating_point_v<T>>
struct IsArithmetic : bool_constant<is_integral_v<T> || is_floating_point_v<T>>
{
};
template<class T>
constexpr bool is_arithmetic_v = is_arithmetic<T>::value;
constexpr bool is_arithmetic_v = IsArithmetic<T>::value;
} // namespace based
diff --git a/ include/based/trait/is/array.hpp b/ include/based/trait/is/array.hpp
@@ -8,22 +8,22 @@
namespace based
// NOLINTBEGIN(*array*)
template<class T>
struct is_array : false_type
struct IsArray : false_type
{
};
template<class T>
struct is_array<T[]> : true_type
struct IsArray<T[]> : true_type
{
};
template<class T, size_t n>
struct is_array<T[n]> : true_type
struct IsArray<T[n]> : true_type
{
};
// NOLINTEND(*array*)
template<class T>
constexpr bool is_array_v = is_array<T>::value;
constexpr bool is_array_v = IsArray<T>::value;
} // namespace based
diff --git a/ include/based/trait/is/base_of.hpp b/ include/based/trait/is/base_of.hpp
@@ -25,7 +25,7 @@
auto test_is_base_of(...) -> true_type; // private or ambiguous base
} // namespace details
template<class Base, class Derived>
struct is_base_of : false_type
struct IsBaseOf : false_type
{
};
@@ -34,11 +34,11 @@
template<class Base, class Derived>
is_class_v<Base> && is_class_v<Derived>
&& decltype(details::test_is_base_of<Base, Derived>(0))::value
)
struct is_base_of<Base, Derived> : true_type
struct IsBaseOf<Base, Derived> : true_type
{
};
template<class Base, class Derived>
constexpr bool is_base_of_v = is_base_of<Base, Derived>::value;
constexpr bool is_base_of_v = IsBaseOf<Base, Derived>::value;
} // namespace based
diff --git a/ include/based/trait/is/class.hpp b/ include/based/trait/is/class.hpp
@@ -18,11 +18,11 @@
false_type test(...);
} // namespace detail
template<class T>
struct is_class : decltype(detail::test<T>(nullptr))
struct IsClass : decltype(detail::test<T>(nullptr))
{
};
template<class T>
constexpr bool is_class_v = is_class<T>::value;
constexpr bool is_class_v = IsClass<T>::value;
} // namespace based
diff --git a/ include/based/trait/is/const.hpp b/ include/based/trait/is/const.hpp
@@ -6,16 +6,16 @@
namespace based
{
template<class T>
struct is_const : false_type
struct IsConst : false_type
{
};
template<class T>
struct is_const<const T> : true_type
struct IsConst<const T> : true_type
{
};
template<class T>
constexpr bool is_const_v = is_const<T>::value;
constexpr bool is_const_v = IsConst<T>::value;
} // namespace based
diff --git a/ include/based/trait/is/floating_point.hpp b/ include/based/trait/is/floating_point.hpp
@@ -8,17 +8,17 @@
namespace based
{
template<class T>
struct is_floating_point : false_type
struct IsFloatingPoint : false_type
{
};
template<class T>
requires(is_same_v<float, remove_cv_t<T>> || is_same_v<double, remove_cv_t<T>> || is_same_v<long double, remove_cv_t<T>>)
struct is_floating_point<T> : true_type
struct IsFloatingPoint<T> : true_type
{
};
template<class T>
constexpr bool is_floating_point_v = is_floating_point<T>::value;
constexpr bool is_floating_point_v = IsFloatingPoint<T>::value;
} // namespace based
diff --git a/ include/based/trait/is/function.hpp b/ include/based/trait/is/function.hpp
@@ -8,85 +8,85 @@
namespace based
// clang-format off
template<typename>
struct is_function : false_type {};
struct IsFunction : false_type {};
template<typename Ret, bool ne, typename... Args>
struct is_function<Ret(Args...) noexcept(ne)> : true_type {};
struct IsFunction<Ret(Args...) noexcept(ne)> : true_type {};
template<typename Ret, bool ne, typename... Args>
struct is_function<Ret(Args...) & noexcept(ne)> : true_type {};
struct IsFunction<Ret(Args...) & noexcept(ne)> : true_type {};
template<typename Ret, bool ne, typename... Args>
struct is_function<Ret(Args...) && noexcept(ne)> : true_type {};
struct IsFunction<Ret(Args...) && noexcept(ne)> : true_type {};
template<typename Ret, bool ne, typename... Args>
struct is_function<Ret(Args...) const noexcept(ne)> : true_type {};
struct IsFunction<Ret(Args...) const noexcept(ne)> : true_type {};
template<typename Ret, bool ne, typename... Args>
struct is_function<Ret(Args...) const & noexcept(ne)> : true_type {};
struct IsFunction<Ret(Args...) const & noexcept(ne)> : true_type {};
template<typename Ret, bool ne, typename... Args>
struct is_function<Ret(Args...) const && noexcept(ne)> : true_type {};
struct IsFunction<Ret(Args...) const && noexcept(ne)> : true_type {};
template<typename Ret, bool ne, typename... Args>
struct is_function<Ret(Args...) volatile noexcept(ne)> : true_type {};
struct IsFunction<Ret(Args...) volatile noexcept(ne)> : true_type {};
template<typename Ret, bool ne, typename... Args>
struct is_function<Ret(Args...) volatile & noexcept(ne)> : true_type {};
struct IsFunction<Ret(Args...) volatile & noexcept(ne)> : true_type {};
template<typename Ret, bool ne, typename... Args>
struct is_function<Ret(Args...) volatile && noexcept(ne)> : true_type {};
struct IsFunction<Ret(Args...) volatile && noexcept(ne)> : true_type {};
template<typename Ret, bool ne, typename... Args>
struct is_function<Ret(Args...) const volatile noexcept(ne)> : true_type {};
struct IsFunction<Ret(Args...) const volatile noexcept(ne)> : true_type {};
template<typename Ret, bool ne, typename... Args>
struct is_function<Ret(Args...) const volatile & noexcept(ne)> : true_type {};
struct IsFunction<Ret(Args...) const volatile & noexcept(ne)> : true_type {};
template<typename Ret, bool ne, typename... Args>
struct is_function<Ret(Args...) const volatile && noexcept(ne)> : true_type {};
struct IsFunction<Ret(Args...) const volatile && noexcept(ne)> : true_type {};
// NOLINTBEGIN(*ambiguous-ellipsis*)
template<typename Ret, bool ne, typename... Args>
struct is_function<Ret(Args......) noexcept(ne)> : true_type {};
struct IsFunction<Ret(Args......) noexcept(ne)> : true_type {};
template<typename Ret, bool ne, typename... Args>
struct is_function<Ret(Args......) & noexcept(ne)> : true_type {};
struct IsFunction<Ret(Args......) & noexcept(ne)> : true_type {};
template<typename Ret, bool ne, typename... Args>
struct is_function<Ret(Args......) && noexcept(ne)> : true_type {};
struct IsFunction<Ret(Args......) && noexcept(ne)> : true_type {};
template<typename Ret, bool ne, typename... Args>
struct is_function<Ret(Args......) const noexcept(ne)> : true_type {};
struct IsFunction<Ret(Args......) const noexcept(ne)> : true_type {};
template<typename Ret, bool ne, typename... Args>
struct is_function<Ret(Args......) const & noexcept(ne)> : true_type {};
struct IsFunction<Ret(Args......) const & noexcept(ne)> : true_type {};
template<typename Ret, bool ne, typename... Args>
struct is_function<Ret(Args......) const && noexcept(ne)> : true_type {};
struct IsFunction<Ret(Args......) const && noexcept(ne)> : true_type {};
template<typename Ret, bool ne, typename... Args>
struct is_function<Ret(Args......) volatile noexcept(ne)> : true_type {};
struct IsFunction<Ret(Args......) volatile noexcept(ne)> : true_type {};
template<typename Ret, bool ne, typename... Args>
struct is_function<Ret(Args......) volatile & noexcept(ne)> : true_type {};
struct IsFunction<Ret(Args......) volatile & noexcept(ne)> : true_type {};
template<typename Ret, bool ne, typename... Args>
struct is_function<Ret(Args......) volatile && noexcept(ne)> : true_type {};
struct IsFunction<Ret(Args......) volatile && noexcept(ne)> : true_type {};
template<typename Ret, bool ne, typename... Args>
struct is_function<Ret(Args......) const volatile noexcept(ne)> : true_type {};
struct IsFunction<Ret(Args......) const volatile noexcept(ne)> : true_type {};
template<typename Ret, bool ne, typename... Args>
struct is_function<Ret(Args......) const volatile & noexcept(ne)> : true_type {};
struct IsFunction<Ret(Args......) const volatile & noexcept(ne)> : true_type {};
template<typename Ret, bool ne, typename... Args>
struct is_function<Ret(Args......) const volatile && noexcept(ne)> : true_type {};
struct IsFunction<Ret(Args......) const volatile && noexcept(ne)> : true_type {};
// NOLINTEND(*ambiguous-ellipsis*)
template<class T> constexpr bool is_function_v = is_function<T>::value;
template<class T> constexpr bool is_function_v = IsFunction<T>::value;
// clang-format on
diff --git a/ include/based/trait/is/integral.hpp b/ include/based/trait/is/integral.hpp
@@ -6,7 +6,7 @@
namespace based
{
template<class T>
struct is_integral : false_type
struct IsIntegral : false_type
{
};
@@ -21,11 +21,11 @@
template<class T>
ptr + obj; // Exclude everything not yet excluded but integral types
}
)
struct is_integral<T> : true_type
struct IsIntegral<T> : true_type
{
};
template<class T>
constexpr bool is_integral_v = is_integral<T>::value;
constexpr bool is_integral_v = IsIntegral<T>::value;
} // namespace based
diff --git a/ include/based/trait/is/lvalue_reference.hpp b/ include/based/trait/is/lvalue_reference.hpp
@@ -6,16 +6,16 @@
namespace based
{
template<class T>
struct is_lvalue_reference : false_type
struct IsLvalueReference : false_type
{
};
template<class T>
struct is_lvalue_reference<T&> : true_type
struct IsLvalueReference<T&> : true_type
{
};
template<class T>
constexpr bool is_lvalue_reference_v = is_lvalue_reference<T>::value;
constexpr bool is_lvalue_reference_v = IsLvalueReference<T>::value;
} // namespace based
diff --git a/ include/based/trait/is/member_pointer.hpp b/ include/based/trait/is/member_pointer.hpp
@@ -10,23 +10,21 @@
namespace detail
{
template<class T>
struct is_member_pointer_helper : false_type
{
};
struct IsMemberPointerHelper : false_type { };
template<class T, class U>
struct is_member_pointer_helper<T U::*> : true_type
struct IsMemberPointerHelper<T U::*> : true_type
{
};
} // namespace detail
template<class T>
struct is_member_pointer : detail::is_member_pointer_helper<remove_cv_t<T>>
struct IsMemberPointer : detail::IsMemberPointerHelper<remove_cv_t<T>>
{
};
template<class T>
constexpr bool is_member_pointer_v = is_member_pointer<T>::value;
constexpr bool is_member_pointer_v = IsMemberPointer<T>::value;
} // namespace based
diff --git a/ include/based/trait/is/null_pointer.hpp b/ include/based/trait/is/null_pointer.hpp
@@ -1,18 +1,18 @@
#pragma once
#include "based/memory/nullptr.hpp"
#include "based/trait/is/same.hpp"
#include "based/trait/remove/cv.hpp"
#include "based/memory/nullptr.hpp"
namespace based
{
template<class T>
struct is_null_pointer : is_same<nullptr_t, remove_cv_t<T>>
struct IsNullPointer : IsSame<nullptr_t, remove_cv_t<T>>
{
};
template<class T>
constexpr bool is_null_pointer_v = is_null_pointer<T>::value;
constexpr bool is_null_pointer_v = IsNullPointer<T>::value;
} // namespace based
diff --git a/ include/based/trait/is/object.hpp b/ include/based/trait/is/object.hpp
@@ -10,17 +10,17 @@
namespace based
{
template<class T>
struct is_object : false_type
struct IsObject : false_type
{
};
template<class T>
requires(is_scalar_v<T> || is_array_v<T> || is_union_v<T> || is_class_v<T>)
struct is_object<T> : true_type
struct IsObject<T> : true_type
{
};
template<class T>
constexpr bool is_object_v = is_object<T>::value;
constexpr bool is_object_v = IsObject<T>::value;
} // namespace based
diff --git a/ include/based/trait/is/pointer.hpp b/ include/based/trait/is/pointer.hpp
@@ -6,31 +6,31 @@
namespace based
{
template<class T>
struct is_pointer : false_type
struct IsPointer : false_type
{
};
template<class T>
struct is_pointer<T*> : true_type
struct IsPointer<T*> : true_type
{
};
template<class T>
struct is_pointer<T* const> : true_type
struct IsPointer<T* const> : true_type
{
};
template<class T>
struct is_pointer<T* volatile> : true_type
struct IsPointer<T* volatile> : true_type
{
};
template<class T>
struct is_pointer<T* const volatile> : true_type
struct IsPointer<T* const volatile> : true_type
{
};
template<class T>
constexpr bool is_pointer_v = is_pointer<T>::value;
constexpr bool is_pointer_v = IsPointer<T>::value;
} // namespace based
diff --git a/ include/based/trait/is/reference_wrapper.hpp b/ include/based/trait/is/reference_wrapper.hpp
@@ -6,16 +6,16 @@
namespace based
{
template<class T>
struct is_reference_wrapper : false_type
struct IsReferenceWrapper : false_type
{
};
template<class U>
struct is_reference_wrapper<reference_wrapper<U>> : true_type
struct IsReferenceWrapper<ReferenceWrapper<U>> : true_type
{
};
template<class T>
constexpr bool is_reference_wrapper_v = is_reference_wrapper<T>::value;
constexpr bool is_reference_wrapper_v = IsReferenceWrapper<T>::value;
} // namespace based
diff --git a/ include/based/trait/is/rvalue_reference.hpp b/ include/based/trait/is/rvalue_reference.hpp
@@ -6,16 +6,16 @@
namespace based
{
template<class T>
struct is_rvalue_reference : false_type
struct IsRvalueReference : false_type
{
};
template<class T>
struct is_rvalue_reference<T&&> : true_type
struct IsRvalueReference<T&&> : true_type
{
};
template<class T>
constexpr bool is_rvalue_reference_v = is_rvalue_reference<T>::value;
constexpr bool is_rvalue_reference_v = IsRvalueReference<T>::value;
} // namespace based
diff --git a/ include/based/trait/is/same.hpp b/ include/based/trait/is/same.hpp
@@ -6,16 +6,16 @@
namespace based
{
template<class T, class U>
struct is_same : false_type
struct IsSame : false_type
{
};
template<class T>
struct is_same<T, T> : true_type
struct IsSame<T, T> : true_type
{
};
template<class T, class U>
constexpr bool is_same_v = is_same<T, U>::value;
constexpr bool is_same_v = IsSame<T, U>::value;
} // namespace based
diff --git a/ include/based/trait/is/scalar.hpp b/ include/based/trait/is/scalar.hpp
@@ -11,17 +11,17 @@
namespace based
{
template<class T>
struct is_scalar : false_type
struct IsScalar : false_type
{
};
template<class T>
requires(is_arithmetic_v<T> || is_enum_v<T> || is_pointer_v<T> || is_member_pointer_v<T> || is_null_pointer_v<T>)
struct is_scalar<T>
struct IsScalar<T>
{
};
template<class T>
constexpr bool is_scalar_v = is_scalar<T>::value;
constexpr bool is_scalar_v = IsScalar<T>::value;
} // namespace based
diff --git a/ include/based/trait/is/void.hpp b/ include/based/trait/is/void.hpp
@@ -7,11 +7,11 @@
namespace based
{
template<class T>
struct is_void : is_same<void, remove_cv_t<T>>
struct IsVoid : IsSame<void, remove_cv_t<T>>
{
};
template<class T>
constexpr bool is_void_v = is_void<T>::value;
constexpr bool is_void_v = IsVoid<T>::value;
} // namespace based
diff --git a/ include/based/trait/iterator.hpp b/ include/based/trait/iterator.hpp
@@ -10,7 +10,7 @@
namespace based
namespace detail
{
template<typename I>
struct iterator_traits
struct IteratorTraits
{
using value_type = I;
using distance_type = u64;
@@ -20,7 +20,7 @@
struct iterator_traits
template<typename I>
requires std::input_or_output_iterator<I>
struct iterator_traits<I>
struct IteratorTraits<I>
{
using value_type = std::iterator_traits<I>::value_type;
using distance_type = std::iterator_traits<I>::difference_type;
@@ -31,15 +31,15 @@
struct iterator_traits<I>
} // namespace detail
template<typename T>
using iter_value_t = detail::iterator_traits<T>::value_type;
using iter_value_t = detail::IteratorTraits<T>::value_type;
template<typename T>
using iter_dist_t = detail::iterator_traits<T>::distance_type;
using iter_dist_t = detail::IteratorTraits<T>::distance_type;
template<typename T>
using iter_ptr_t = detail::iterator_traits<T>::pointer;
using iter_ptr_t = detail::IteratorTraits<T>::pointer;
template<typename T>
using iter_ref_t = detail::iterator_traits<T>::reference;
using iter_ref_t = detail::IteratorTraits<T>::reference;
} // namespace based
diff --git a/ include/based/trait/remove/const.hpp b/ include/based/trait/remove/const.hpp
@@ -5,10 +5,10 @@
namespace based
// clang-format off
template<class T> struct remove_const { using type = T; };
template<class T> struct remove_const<const T> { using type = T; };
template<class T> struct RemoveConst { using type = T; };
template<class T> struct RemoveConst<const T> { using type = T; };
template<class T> using remove_const_t = typename remove_const<T>::type;
template<class T> using remove_const_t = typename RemoveConst<T>::type;
// clang-format on
diff --git a/ include/based/trait/remove/cv.hpp b/ include/based/trait/remove/cv.hpp
@@ -5,12 +5,12 @@
namespace based
// clang-format off
template<class T> struct remove_cv { using type = T; };
template<class T> struct remove_cv<const T> { using type = T; };
template<class T> struct remove_cv<volatile T> { using type = T; };
template<class T> struct remove_cv<const volatile T> { using type = T; };
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> using remove_cv_t = typename remove_cv<T>::type;
template<class T> using remove_cv_t = typename RemoveCv<T>::type;
// clang-format on
diff --git a/ include/based/trait/remove/cvref.hpp b/ include/based/trait/remove/cvref.hpp
@@ -8,11 +8,11 @@
namespace based
// clang-format off
template<class T> struct remove_cvref {
template<class T> struct RemoveCvref {
using type = remove_cv_t<remove_reference_t<T>>;
};
template<class T> using remove_cvref_t = typename remove_cvref<T>::type;
template<class T> using remove_cvref_t = typename RemoveCvref<T>::type;
// clang-format on
diff --git a/ include/based/trait/remove/extent.hpp b/ include/based/trait/remove/extent.hpp
@@ -9,16 +9,16 @@
namespace based
// clang-format off
template<class T>
struct remove_extent { using type = T; };
struct RemoveExtent { using type = T; };
template<class T>
struct remove_extent<T[]> { using type = T; };
struct RemoveExtent<T[]> { using type = T; };
template<class T, size_t n>
struct remove_extent<T[n]> { using type = T; };
struct RemoveExtent<T[n]> { using type = T; };
template<class T> using remove_extent_t = remove_extent<T>::type;
template<class T> using remove_extent_t = RemoveExtent<T>::type;
// NOLINTEND(*array*)
// clang-format on
diff --git a/ include/based/trait/remove/pointer.hpp b/ include/based/trait/remove/pointer.hpp
@@ -5,13 +5,13 @@
namespace based
// clang-format off
template<class T> struct remove_pointer { using type = T; };
template<class T> struct remove_pointer<T*> { using type = T; };
template<class T> struct remove_pointer<T* const> { using type = T; };
template<class T> struct remove_pointer<T* volatile> { using type = T; };
template<class T> struct remove_pointer<T* const volatile> { using type = T; };
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> using remove_pointer_t = typename remove_pointer<T>::type;
template<class T> using remove_pointer_t = typename RemovePointer<T>::type;
// clang-format on
diff --git a/ include/based/trait/remove/reference.hpp b/ include/based/trait/remove/reference.hpp
@@ -5,11 +5,11 @@
namespace based
// clang-format off
template<class T> struct remove_reference { using type = T; };
template<class T> struct remove_reference<T&> { using type = T; };
template<class T> struct remove_reference<T&&> { using type = T; };
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> using remove_reference_t = typename remove_reference<T>::type;
template<class T> using remove_reference_t = typename RemoveReference<T>::type;
// clang-format on
diff --git a/ include/based/trait/remove/volatile.hpp b/ include/based/trait/remove/volatile.hpp
@@ -5,10 +5,10 @@
namespace based
// clang-format off
template<class T> struct remove_volatile { using type = T; };
template<class T> struct remove_volatile<volatile T> { using type = T; };
template<class T> struct RemoveVolatile { using type = T; };
template<class T> struct RemoveVolatile<volatile T> { using type = T; };
template<class T> using remove_volatile_t = typename remove_volatile<T>::type;
template<class T> using remove_volatile_t = typename RemoveVolatile<T>::type;
// clang-format on
diff --git a/ include/based/trait/signature.hpp b/ include/based/trait/signature.hpp
@@ -8,30 +8,30 @@
namespace based
{
template<typename>
struct signature;
struct Signature;
template<typename Ret, bool ne, typename... Args>
struct signature<Ret(Args...) noexcept(ne)>
struct Signature<Ret(Args...) noexcept(ne)>
{
using sig_type = Ret(Args...);
using arg_type = std::tuple<Args...>;
using ret_type = Ret;
using noexcept_val = integral_constant<bool, ne>;
using noexcept_val = IntegralConstant<bool, ne>;
};
template<typename Ret, bool ne, typename... Args>
struct signature<Ret (*)(Args...) noexcept(ne)>
struct Signature<Ret (*)(Args...) noexcept(ne)>
{
using sig_type = Ret(Args...);
using arg_type = std::tuple<Args...>;
using ret_type = Ret;
using noexcept_val = integral_constant<bool, ne>;
using noexcept_val = IntegralConstant<bool, ne>;
};
template<typename Ret, typename Obj, bool ne, typename... Args>
struct signature<Ret (Obj::*)(Args...) noexcept(ne)>
struct Signature<Ret (Obj::*)(Args...) noexcept(ne)>
{
using sig_type = Ret(Args...);
using arg_type = std::tuple<Args...>;
@@ -43,11 +43,11 @@
struct signature<Ret (Obj::*)(Args...) noexcept(ne)>
using lvalref_val = false_type;
using rvalref_val = false_type;
using noexcept_val = integral_constant<bool, ne>;
using noexcept_val = IntegralConstant<bool, ne>;
};
template<typename Ret, typename Obj, bool ne, typename... Args>
struct signature<Ret (Obj::*)(Args...) & noexcept(ne)>
struct Signature<Ret (Obj::*)(Args...) & noexcept(ne)>
{
using sig_type = Ret(Args...);
using arg_type = std::tuple<Args...>;
@@ -59,11 +59,11 @@
struct signature<Ret (Obj::*)(Args...) & noexcept(ne)>
using lvalref_val = true_type;
using rvalref_val = false_type;
using noexcept_val = integral_constant<bool, ne>;
using noexcept_val = IntegralConstant<bool, ne>;
};
template<typename Ret, typename Obj, bool ne, typename... Args>
struct signature<Ret (Obj::*)(Args...) && noexcept(ne)>
struct Signature<Ret (Obj::*)(Args...) && noexcept(ne)>
{
using sig_type = Ret(Args...);
using arg_type = std::tuple<Args...>;
@@ -75,11 +75,11 @@
struct signature<Ret (Obj::*)(Args...) && noexcept(ne)>
using lvalref_val = false_type;
using rvalref_val = true_type;
using noexcept_val = integral_constant<bool, ne>;
using noexcept_val = IntegralConstant<bool, ne>;
};
template<typename Ret, typename Obj, bool ne, typename... Args>
struct signature<Ret (Obj::*)(Args...) const noexcept(ne)>
struct Signature<Ret (Obj::*)(Args...) const noexcept(ne)>
{
using sig_type = Ret(Args...);
using arg_type = std::tuple<Args...>;
@@ -91,11 +91,11 @@
struct signature<Ret (Obj::*)(Args...) const noexcept(ne)>
using lvalref_val = false_type;
using rvalref_val = false_type;
using noexcept_val = integral_constant<bool, ne>;
using noexcept_val = IntegralConstant<bool, ne>;
};
template<typename Ret, typename Obj, bool ne, typename... Args>
struct signature<Ret (Obj::*)(Args...) const & noexcept(ne)>
struct Signature<Ret (Obj::*)(Args...) const & noexcept(ne)>
{
using sig_type = Ret(Args...);
using arg_type = std::tuple<Args...>;
@@ -107,11 +107,11 @@
struct signature<Ret (Obj::*)(Args...) const & noexcept(ne)>
using lvalref_val = true_type;
using rvalref_val = false_type;
using noexcept_val = integral_constant<bool, ne>;
using noexcept_val = IntegralConstant<bool, ne>;
};
template<typename Ret, typename Obj, bool ne, typename... Args>
struct signature<Ret (Obj::*)(Args...) const && noexcept(ne)>
struct Signature<Ret (Obj::*)(Args...) const && noexcept(ne)>
{
using sig_type = Ret(Args...);
using arg_type = std::tuple<Args...>;
@@ -123,11 +123,11 @@
struct signature<Ret (Obj::*)(Args...) const && noexcept(ne)>
using lvalref_val = false_type;
using rvalref_val = true_type;
using noexcept_val = integral_constant<bool, ne>;
using noexcept_val = IntegralConstant<bool, ne>;
};
template<typename Ret, typename Obj, bool ne, typename... Args>
struct signature<Ret (Obj::*)(Args...) volatile noexcept(ne)>
struct Signature<Ret (Obj::*)(Args...) volatile noexcept(ne)>
{
using sig_type = Ret(Args...);
using arg_type = std::tuple<Args...>;
@@ -139,11 +139,11 @@
struct signature<Ret (Obj::*)(Args...) volatile noexcept(ne)>
using lvalref_val = false_type;
using rvalref_val = false_type;
using noexcept_val = integral_constant<bool, ne>;
using noexcept_val = IntegralConstant<bool, ne>;
};
template<typename Ret, typename Obj, bool ne, typename... Args>
struct signature<Ret (Obj::*)(Args...) volatile & noexcept(ne)>
struct Signature<Ret (Obj::*)(Args...) volatile & noexcept(ne)>
{
using sig_type = Ret(Args...);
using arg_type = std::tuple<Args...>;
@@ -155,11 +155,11 @@
struct signature<Ret (Obj::*)(Args...) volatile & noexcept(ne)>
using lvalref_val = true_type;
using rvalref_val = false_type;
using noexcept_val = integral_constant<bool, ne>;
using noexcept_val = IntegralConstant<bool, ne>;
};
template<typename Ret, typename Obj, bool ne, typename... Args>
struct signature<Ret (Obj::*)(Args...) volatile && noexcept(ne)>
struct Signature<Ret (Obj::*)(Args...) volatile && noexcept(ne)>
{
using sig_type = Ret(Args...);
using arg_type = std::tuple<Args...>;
@@ -171,11 +171,11 @@
struct signature<Ret (Obj::*)(Args...) volatile && noexcept(ne)>
using lvalref_val = false_type;
using rvalref_val = true_type;
using noexcept_val = integral_constant<bool, ne>;
using noexcept_val = IntegralConstant<bool, ne>;
};
template<typename Ret, typename Obj, bool ne, typename... Args>
struct signature<Ret (Obj::*)(Args...) const volatile noexcept(ne)>
struct Signature<Ret (Obj::*)(Args...) const volatile noexcept(ne)>
{
using sig_type = Ret(Args...);
using arg_type = std::tuple<Args...>;
@@ -187,11 +187,11 @@
struct signature<Ret (Obj::*)(Args...) const volatile noexcept(ne)>
using lvalref_val = false_type;
using rvalref_val = false_type;
using noexcept_val = integral_constant<bool, ne>;
using noexcept_val = IntegralConstant<bool, ne>;
};
template<typename Ret, typename Obj, bool ne, typename... Args>
struct signature<Ret (Obj::*)(Args...) const volatile & noexcept(ne)>
struct Signature<Ret (Obj::*)(Args...) const volatile & noexcept(ne)>
{
using sig_type = Ret(Args...);
using arg_type = std::tuple<Args...>;
@@ -203,11 +203,11 @@
struct signature<Ret (Obj::*)(Args...) const volatile & noexcept(ne)>
using lvalref_val = true_type;
using rvalref_val = false_type;
using noexcept_val = integral_constant<bool, ne>;
using noexcept_val = IntegralConstant<bool, ne>;
};
template<typename Ret, typename Obj, bool ne, typename... Args>
struct signature<Ret (Obj::*)(Args...) const volatile && noexcept(ne)>
struct Signature<Ret (Obj::*)(Args...) const volatile && noexcept(ne)>
{
using sig_type = Ret(Args...);
using arg_type = std::tuple<Args...>;
@@ -219,16 +219,16 @@
struct signature<Ret (Obj::*)(Args...) const volatile && noexcept(ne)>
using lvalref_val = false_type;
using rvalref_val = true_type;
using noexcept_val = integral_constant<bool, ne>;
using noexcept_val = IntegralConstant<bool, ne>;
};
template<typename StaticCallOp>
struct signature_static
struct SignatureStatic
{
};
template<typename Ret, bool ne, typename... Args>
struct signature_static<Ret (*)(Args...) noexcept(ne)>
struct SignatureStatic<Ret (*)(Args...) noexcept(ne)>
{
using sig_type = Ret(Args...);
};
@@ -236,7 +236,7 @@
struct signature_static<Ret (*)(Args...) noexcept(ne)>
template<typename F, typename Op>
using signature_t = typename std::conditional_t<requires(F& func) {
(void)func.operator();
}, signature_static<Op>, signature<Op>>::sig_type;
}, SignatureStatic<Op>, Signature<Op>>::sig_type;
/*
template<typename Sig>
diff --git a/ include/based/trait/type_identity.hpp b/ include/based/trait/type_identity.hpp
@@ -5,9 +5,9 @@
namespace based
// clang-format off
template<class T> struct type_identity { using type = T; };
template<class T> struct TypeIdentity { using type = T; };
template<class T> using type_dentity_t = type_identity<T>::type;
template<class T> using type_dentity_t = TypeIdentity<T>::type;
// clang-format on
diff --git a/ include/based/utility/buffer.hpp b/ include/based/utility/buffer.hpp
@@ -13,7 +13,7 @@
namespace based
/* ----- Buffer used for Local Buffer Optimization ----- */
template<size_t size, size_t alignment = alignof(void*)>
struct buffer
struct Buffer
{
template<typename T>
static constexpr bool valid_type()
@@ -23,11 +23,11 @@
struct buffer
alignas(alignment) char m_space[size] = {0}; // NOLINT(*array*)
buffer() = default;
Buffer() = default;
template<typename T, typename... Args>
requires(valid_type<T>() && std::constructible_from<T, Args...>)
explicit buffer(
explicit Buffer(
std::in_place_type_t<T> /* t */, Args&&... args
) noexcept(std::is_nothrow_constructible_v<T, Args...>)
{
@@ -59,10 +59,10 @@
struct buffer
requires(valid_type<T>())
[[nodiscard]] const T* as() const noexcept
{
return const_cast<buffer*>(this)->as<T>(); // NOLINT(*const-cast*)
return const_cast<Buffer*>(this)->as<T>(); // NOLINT(*const-cast*)
}
void swap(buffer& that) noexcept
void swap(Buffer& that) noexcept
{
// NOLINTBEGIN(*array*)
alignas(alignment) char tmp[size];
diff --git a/ include/based/utility/scopeguard.hpp b/ include/based/utility/scopeguard.hpp
@@ -7,13 +7,13 @@
namespace based
{
template<typename Func, bool on_success = false, bool on_failure = false>
class scopeguard
class Scopeguard
{
uncaught_exception_detector m_detector;
UncaughtExceptionDetector m_detector;
Func m_func;
public:
scopeguard(Func&& func) // NOLINT(*explicit*)
Scopeguard(Func&& func) // NOLINT(*explicit*)
: m_func(based::move(func))
{
}
@@ -25,13 +25,13 @@
public:
}
*/
scopeguard(const scopeguard&) = delete;
scopeguard& operator=(const scopeguard&) = delete;
Scopeguard(const Scopeguard&) = delete;
Scopeguard& operator=(const Scopeguard&) = delete;
scopeguard(scopeguard&&) = delete;
scopeguard& operator=(scopeguard&&) = delete;
Scopeguard(Scopeguard&&) = delete;
Scopeguard& operator=(Scopeguard&&) = delete;
~scopeguard()
~Scopeguard()
{
if ((on_success && !m_detector) || (on_failure && m_detector)) {
m_func();
@@ -40,13 +40,13 @@
public:
};
template<typename Func>
class scopeguard<Func, false, false>
class Scopeguard<Func, false, false>
{
bool m_commit = false;
Func m_func;
public:
scopeguard(Func&& func) // NOLINT(*explicit*)
Scopeguard(Func&& func) // NOLINT(*explicit*)
: m_func(based::move(func))
{
}
@@ -58,13 +58,13 @@
public:
}
*/
scopeguard(const scopeguard&) = delete;
scopeguard& operator=(const scopeguard&) = delete;
Scopeguard(const Scopeguard&) = delete;
Scopeguard& operator=(const Scopeguard&) = delete;
scopeguard(scopeguard&&) = delete;
scopeguard& operator=(scopeguard&&) = delete;
Scopeguard(Scopeguard&&) = delete;
Scopeguard& operator=(Scopeguard&&) = delete;
~scopeguard()
~Scopeguard()
{
if (m_commit) {
m_func();
@@ -74,12 +74,12 @@
public:
};
template<typename Func>
using scopeguard_exit = scopeguard<Func, true, true>;
using scopeguard_exit = Scopeguard<Func, true, true>;
template<typename Func>
using scopeguard_success = scopeguard<Func, true, false>;
using scopeguard_success = Scopeguard<Func, true, false>;
template<typename Func>
using scopeguard_failure = scopeguard<Func, false, true>;
using scopeguard_failure = Scopeguard<Func, false, true>;
} // namespace based
diff --git a/ include/based/utility/static_view.hpp b/ include/based/utility/static_view.hpp
@@ -11,7 +11,7 @@
namespace based
{
template<class T>
struct oversized_array
struct OversizedArray
{
static constexpr auto oversized_size = static_cast<std::size_t>(10 * 1024);
@@ -36,7 +36,7 @@
struct oversized_array
template<class Data>
consteval auto to_oversized_array(const Data& str)
{
oversized_array<typename Data::value_type> result;
OversizedArray<typename Data::value_type> result;
std::ranges::copy(str, std::begin(result));
result.size = str.size();
return result;
diff --git a/ include/based/utility/uncaught_exception.hpp b/ include/based/utility/uncaught_exception.hpp
@@ -5,12 +5,12 @@
namespace based
{
class uncaught_exception_detector
class UncaughtExceptionDetector
{
int m_count;
public:
uncaught_exception_detector()
UncaughtExceptionDetector()
: m_count(std::uncaught_exceptions())
{
}
diff --git a/ test/CMakeLists.txt b/ test/CMakeLists.txt
@@ -50,7 +50,7 @@
add_test(trait remove_cv_test)
add_test(trait remove_pointer_test)
add_test(trait remove_reference_test)
add_test(trait remove_volatile_test)
add_test(trait signature_test_test)
add_test(trait signature_test)
## ----- Concept -----
diff --git a/ test/source/character/mapper_test.cpp b/ test/source/character/mapper_test.cpp
@@ -6,12 +6,12 @@
#include "based/character/type.hpp"
struct test
struct Test
{
constexpr bool operator()(based::character chr) const { return chr >= '\0'; }
constexpr bool operator()(based::Character chr) const { return chr >= '\0'; }
};
template class based::mapper<test>;
template class based::Mapper<Test>;
TEST_CASE("mapper", "[character/mapper]")
{
diff --git a/ test/source/container/list_test.cpp b/ test/source/container/list_test.cpp
@@ -6,14 +6,14 @@
#include "based/integral/literals.hpp"
template class based::list_pool<based::u8, based::u8>;
template class based::ListPool<based::U8, based::U8>;
// NOLINTBEGIN(*complexity*)
TEST_CASE("list_pool", "[container/list_pool]")
TEST_CASE("ListPool", "[container/ListPool]")
{
using namespace based::literals; // NOLINT(*namespace*)
using list_pool = based::list_pool<based::u8, based::u8>;
using list_pool = based::ListPool<based::U8, based::U8>;
auto pool = list_pool();
auto head = pool.node_empty();
@@ -65,10 +65,10 @@
TEST_CASE("list_pool", "[container/list_pool]")
REQUIRE(pool.node_empty() == head);
}
TEST_CASE("list_pool iterator", "[container/list_pool]")
TEST_CASE("ListPool iterator", "[container/ListPool]")
{
using namespace based::literals; // NOLINT(*namespace*)
using list_pool = based::list_pool<based::u8, based::u8>;
using list_pool = based::ListPool<based::U8, based::U8>;
auto pool = list_pool();
auto head = pool.node_empty();
@@ -82,13 +82,13 @@
TEST_CASE("list_pool iterator", "[container/list_pool]")
{
using iter = list_pool::iterator;
auto sum = 0_u32;
auto sum = 0_U32;
for (auto it = iter(pool, head); it != iter(pool); it++) {
sum += *it.operator->();
sum += *it;
}
REQUIRE(sum == 255_u32 * 254_u32);
REQUIRE(sum == 255_U32 * 254_U32);
}
SECTION("accumulate")
@@ -98,23 +98,23 @@
TEST_CASE("list_pool iterator", "[container/list_pool]")
const auto sum = std::accumulate(
iter(pool, head),
iter(pool),
based::u32 {0},
based::U32 {0},
[](auto a, auto b)
{
return a + b;
}
);
REQUIRE(sum == 255_u32 * 254_u32 / 2_u32);
REQUIRE(sum == 255_U32 * 254_U32 / 2_U32);
}
based::free_list(pool, head);
}
TEST_CASE("list_pool const iterator", "[container/list_pool]")
TEST_CASE("ListPool const iterator", "[container/ListPool]")
{
using namespace based::literals; // NOLINT(*namespace*)
using list_pool = based::list_pool<based::u8, based::u8>;
using list_pool = based::ListPool<based::U8, based::U8>;
auto pool = list_pool();
auto head = pool.node_empty();
@@ -128,13 +128,13 @@
TEST_CASE("list_pool const iterator", "[container/list_pool]")
{
using iter = list_pool::const_iterator;
auto sum = 0_u32;
auto sum = 0_U32;
for (auto it = iter(pool, head); it != iter(pool); it++) {
sum += *it.operator->();
sum += *it;
}
REQUIRE(sum == 255_u32 * 254_u32);
REQUIRE(sum == 255_U32 * 254_U32);
}
SECTION("const accumulate")
@@ -147,7 +147,7 @@
TEST_CASE("list_pool const iterator", "[container/list_pool]")
return std::accumulate(
iter(lpool, lhead),
iter(lpool),
based::u32 {0},
based::U32 {0},
[](auto a, auto b)
{
return a + b;
@@ -155,15 +155,15 @@
TEST_CASE("list_pool const iterator", "[container/list_pool]")
);
};
REQUIRE(sum(pool, head) == 255_u32 * 254_u32 / 2_u32);
REQUIRE(sum(pool, head) == 255_U32 * 254_U32 / 2_U32);
}
based::free_list(pool, head);
}
TEST_CASE("list_pool queue", "[container/list_pool/queue]")
TEST_CASE("ListPool queue", "[container/ListPool/queue]")
{
using list_pool = based::list_pool<based::u8, based::u8>;
using list_pool = based::ListPool<based::U8, based::U8>;
using iter = list_pool::iterator;
auto pool = list_pool();
@@ -195,14 +195,14 @@
TEST_CASE("list_pool queue", "[container/list_pool/queue]")
}
}
auto sum = 0_u64;
auto sum = 0_U64;
for (auto it = iter(pool, queue.first); it != iter(pool); ++it) {
sum += *it;
}
pool.free(queue);
REQUIRE(sum == 21717_u64);
REQUIRE(sum == 21717_U64);
}
}
diff --git a/ test/source/enum/bitmask_test.cpp b/ test/source/enum/bitmask_test.cpp
@@ -7,14 +7,14 @@
#include "based/concept/is/same.hpp"
#include "based/integral/types.hpp"
BASED_ENUM_BITMASK(var, based::u8) {
BASED_ENUM_BITMASK(var, based::U8) {
a = 1,
b = 2,
c = 4,
min = 0,
max = a | b | c, // NOLINT
};
BASED_ENUM_TRAITS_BITMASK(var, based::u8)
BASED_ENUM_TRAITS_BITMASK(var, based::U8)
TEST_CASE("types", "[enum/enum_flag]")
{
diff --git a/ test/source/enum/standard_test.cpp b/ test/source/enum/standard_test.cpp
@@ -6,9 +6,9 @@
#include "based/enum/enum.hpp"
#include "based/integral/types.hpp"
struct test
struct Test
{
BASED_ENUM_STANDARD(var, based::i8) {
BASED_ENUM_STANDARD(var, based::I8) {
a,
b,
c,
@@ -25,9 +25,9 @@
private:
int m_c = 3;
};
BASED_ENUM_TRAITS_STANDARD(test::var, based::u8)
BASED_ENUM_TRAITS_STANDARD(Test::var, based::I8)
inline int test::get_var(var req) const
inline int Test::get_var(var req) const
{
switch (based::enumeration::enum_cast<var>(req)) {
case var::a:
@@ -43,24 +43,24 @@
inline int test::get_var(var req) const
TEST_CASE("types", "[enum/standard]")
{
STATIC_REQUIRE(requires { typename test::var; });
STATIC_REQUIRE(requires { typename Test::var; });
STATIC_REQUIRE(requires { test::var::a; });
STATIC_REQUIRE(requires { test::var::b; });
STATIC_REQUIRE(requires { test::var::c; });
STATIC_REQUIRE(requires { test::var::min; });
STATIC_REQUIRE(requires { test::var::max; });
STATIC_REQUIRE(requires { test::var::none; });
STATIC_REQUIRE(requires { Test::var::a; });
STATIC_REQUIRE(requires { Test::var::b; });
STATIC_REQUIRE(requires { Test::var::c; });
STATIC_REQUIRE(requires { Test::var::min; });
STATIC_REQUIRE(requires { Test::var::max; });
STATIC_REQUIRE(requires { Test::var::none; });
}
TEST_CASE("safety", "[enum/standard]")
{
const test crnt;
const Test crnt;
REQUIRE(crnt.get_var(test::var::a) == 1);
REQUIRE(crnt.get_var(test::var::b) == 2);
REQUIRE(crnt.get_var(test::var::c) == 3);
REQUIRE(crnt.get_var(Test::var::a) == 1);
REQUIRE(crnt.get_var(Test::var::b) == 2);
REQUIRE(crnt.get_var(Test::var::c) == 3);
REQUIRE(!based::Invocable<decltype(&test::get_var), based::u8>);
REQUIRE(!based::Invocable<decltype(&test::get_var), int>);
REQUIRE(!based::Invocable<decltype(&Test::get_var), based::U8>);
REQUIRE(!based::Invocable<decltype(&Test::get_var), int>);
}
diff --git a/ test/source/functional/curry_test.cpp b/ test/source/functional/curry_test.cpp
@@ -16,7 +16,7 @@
auto free_func(int a, double b, int c, double d)
TEST_CASE("free function", "[functional/curry]")
{
const based::curried curried = free_func;
const based::Curried curried = free_func;
REQUIRE(curried(1)(2.0)(3)(4.0) == 10);
REQUIRE(curried(1)(2.0, 3)(4.0) == 10);
@@ -28,7 +28,7 @@
TEST_CASE("free function", "[functional/curry]")
TEST_CASE("lambda", "[functional/curry]")
{
const based::curried curried = [](int a, double b, int c, double d)
const based::Curried curried = [](int a, double b, int c, double d)
{
return static_cast<int>(a + b + c + d);
};
@@ -45,7 +45,7 @@
TEST_CASE("lambda", "[functional/curry]")
TEST_CASE("member function", "[functional/curry]")
{
struct test
struct Test
{
[[nodiscard]] auto func(int a, double b, int c, double d) const
{
@@ -55,8 +55,8 @@
TEST_CASE("member function", "[functional/curry]")
int m_x = 0;
};
const based::curried curried = &test::func;
test tmp;
const based::Curried curried = &Test::func;
Test tmp;
REQUIRE(curried(std::ref(tmp))(1)(2.0)(3)(4.0) == 10);
REQUIRE(curried(std::ref(tmp))(1)(2.0)(3, 4.0) == 10);
diff --git a/ test/source/integral/limits_test.cpp b/ test/source/integral/limits_test.cpp
@@ -8,26 +8,26 @@
using based::limits;
TEST_CASE("unsigned", "[integral/literals]")
{
STATIC_REQUIRE(limits<based::u8>::min.value == 0ULL);
STATIC_REQUIRE(limits<based::u16>::min.value == 0ULL);
STATIC_REQUIRE(limits<based::u32>::min.value == 0ULL);
STATIC_REQUIRE(limits<based::u64>::min.value == 0ULL);
STATIC_REQUIRE(limits<based::U8>::min.value == 0ULL);
STATIC_REQUIRE(limits<based::U16>::min.value == 0ULL);
STATIC_REQUIRE(limits<based::U32>::min.value == 0ULL);
STATIC_REQUIRE(limits<based::U64>::min.value == 0ULL);
STATIC_REQUIRE(limits<based::u8>::max.value == 255ULL);
STATIC_REQUIRE(limits<based::u16>::max.value == 65535ULL);
STATIC_REQUIRE(limits<based::u32>::max.value == 4294967295ULL);
STATIC_REQUIRE(limits<based::u64>::max.value == 18446744073709551615ULL);
STATIC_REQUIRE(limits<based::U8>::max.value == 255ULL);
STATIC_REQUIRE(limits<based::U16>::max.value == 65535ULL);
STATIC_REQUIRE(limits<based::U32>::max.value == 4294967295ULL);
STATIC_REQUIRE(limits<based::U64>::max.value == 18446744073709551615ULL);
}
TEST_CASE("signed", "[integral/literals]")
{
STATIC_REQUIRE(limits<based::i8>::min.value == -128LL);
STATIC_REQUIRE(limits<based::i16>::min.value == -32768LL);
STATIC_REQUIRE(limits<based::i32>::min.value == -2147483648LL);
STATIC_REQUIRE(limits<based::i64>::min.value == -9223372036854775807LL - 1);
STATIC_REQUIRE(limits<based::I8>::min.value == -128LL);
STATIC_REQUIRE(limits<based::I16>::min.value == -32768LL);
STATIC_REQUIRE(limits<based::I32>::min.value == -2147483648LL);
STATIC_REQUIRE(limits<based::I64>::min.value == -9223372036854775807LL - 1);
STATIC_REQUIRE(limits<based::i8>::max.value == 127LL);
STATIC_REQUIRE(limits<based::i16>::max.value == 32767LL);
STATIC_REQUIRE(limits<based::i32>::max.value == 2147483647LL);
STATIC_REQUIRE(limits<based::i64>::max.value == 9223372036854775807LL);
STATIC_REQUIRE(limits<based::I8>::max.value == 127LL);
STATIC_REQUIRE(limits<based::I16>::max.value == 32767LL);
STATIC_REQUIRE(limits<based::I32>::max.value == 2147483647LL);
STATIC_REQUIRE(limits<based::I64>::max.value == 9223372036854775807LL);
}
diff --git a/ test/source/integral/literals_test.cpp b/ test/source/integral/literals_test.cpp
@@ -12,30 +12,30 @@
using based::CastableTo;
TEST_CASE("unsigned", "[integral/literals]")
{
STATIC_REQUIRE(CastableTo<decltype(0_u), based::u8>);
STATIC_REQUIRE(CastableTo<decltype(255_u), based::u8>);
STATIC_REQUIRE(CastableTo<decltype(256_u), based::u16>);
STATIC_REQUIRE(CastableTo<decltype(65535_u), based::u16>);
STATIC_REQUIRE(CastableTo<decltype(65536_u), based::u32>);
STATIC_REQUIRE(CastableTo<decltype(4294967295_u), based::u32>);
STATIC_REQUIRE(CastableTo<decltype(4294967296_u), based::u64>);
STATIC_REQUIRE(CastableTo<decltype(18446744073709551615_u), based::u64>);
STATIC_REQUIRE(CastableTo<decltype(0_u), based::U8>);
STATIC_REQUIRE(CastableTo<decltype(255_u), based::U8>);
STATIC_REQUIRE(CastableTo<decltype(256_u), based::U16>);
STATIC_REQUIRE(CastableTo<decltype(65535_u), based::U16>);
STATIC_REQUIRE(CastableTo<decltype(65536_u), based::U32>);
STATIC_REQUIRE(CastableTo<decltype(4294967295_u), based::U32>);
STATIC_REQUIRE(CastableTo<decltype(4294967296_u), based::U64>);
STATIC_REQUIRE(CastableTo<decltype(18446744073709551615_u), based::U64>);
}
TEST_CASE("signed", "[integral/literals]")
{
STATIC_REQUIRE(CastableTo<decltype(0_i), based::i8>);
STATIC_REQUIRE(CastableTo<decltype(127_i), based::i8>);
STATIC_REQUIRE(CastableTo<decltype(128_i), based::i16>);
STATIC_REQUIRE(CastableTo<decltype(32767_i), based::i16>);
STATIC_REQUIRE(CastableTo<decltype(2147483647_i), based::i32>);
STATIC_REQUIRE(CastableTo<decltype(2147483648_i), based::i64>);
STATIC_REQUIRE(CastableTo<decltype(9223372036854775807_i), based::i64>);
STATIC_REQUIRE(CastableTo<decltype(-127_i), based::i8>);
STATIC_REQUIRE(CastableTo<decltype(-128_i), based::i16>);
STATIC_REQUIRE(CastableTo<decltype(-32767_i), based::i16>);
STATIC_REQUIRE(CastableTo<decltype(-2147483647_i), based::i32>);
STATIC_REQUIRE(CastableTo<decltype(-2147483648_i), based::i64>);
STATIC_REQUIRE(CastableTo<decltype(-9223372036854775807_i), based::i64>);
STATIC_REQUIRE(CastableTo<decltype(0_i), based::I8>);
STATIC_REQUIRE(CastableTo<decltype(127_i), based::I8>);
STATIC_REQUIRE(CastableTo<decltype(128_i), based::I16>);
STATIC_REQUIRE(CastableTo<decltype(32767_i), based::I16>);
STATIC_REQUIRE(CastableTo<decltype(2147483647_i), based::I32>);
STATIC_REQUIRE(CastableTo<decltype(2147483648_i), based::I64>);
STATIC_REQUIRE(CastableTo<decltype(9223372036854775807_i), based::I64>);
STATIC_REQUIRE(CastableTo<decltype(-127_i), based::I8>);
STATIC_REQUIRE(CastableTo<decltype(-128_i), based::I16>);
STATIC_REQUIRE(CastableTo<decltype(-32767_i), based::I16>);
STATIC_REQUIRE(CastableTo<decltype(-2147483647_i), based::I32>);
STATIC_REQUIRE(CastableTo<decltype(-2147483648_i), based::I64>);
STATIC_REQUIRE(CastableTo<decltype(-9223372036854775807_i), based::I64>);
}
diff --git a/ test/source/integral/strong_type_test.cpp b/ test/source/integral/strong_type_test.cpp
@@ -6,36 +6,36 @@
#include "based/integral/literals.hpp"
struct t1 : based::strong_type<based::u8, t1>
struct T1 : based::StrongType<based::U8, T1>
{
using strong_type::strong_type;
using strong_type::operator=;
using StrongType::StrongType;
using StrongType::operator=;
};
struct t2 : based::strong_type<based::u8, t2>
struct T2 : based::StrongType<based::U8, T2>
{
using strong_type::strong_type;
using strong_type::operator=;
using StrongType::StrongType;
using StrongType::operator=;
};
// NOLINTBEGIN(*needed*,*internal-linkage*)
auto compare(t1, t1) -> bool;
auto compare(t2, t2) -> bool;
auto compare(T1, T1) -> bool;
auto compare(T2, T2) -> bool;
auto add(t1, t1) -> t1;
auto add(t1, t2) -> t1;
auto add(t2, t1) -> t2;
auto add(T1, T1) -> T1;
auto add(T1, T2) -> T1;
auto add(T2, T1) -> T2;
// NOLINTEND(*needed*,*internal-linkage*)
TEST_CASE("strong_type", "[integral/strong_type]")
TEST_CASE("StrongType", "[integral/StrongType]")
{
STATIC_REQUIRE(based::addable<t1, t1>);
STATIC_REQUIRE(!based::addable<t2, t2>);
STATIC_REQUIRE(based::addable<t1, t2>);
STATIC_REQUIRE(based::addable<t2, t1>);
STATIC_REQUIRE(based::Addable<T1, T1>);
STATIC_REQUIRE(!based::Addable<T2, T2>);
STATIC_REQUIRE(based::Addable<T1, T2>);
STATIC_REQUIRE(based::Addable<T2, T1>);
using namespace based::literals; // NOLINT(*namespace*)
REQUIRE(t1 {10_u8} + t1 {20_u8} == t1 {30_u8});
REQUIRE(t1 {10_u8} + t2 {20_u8} == t1 {30_u8});
REQUIRE(t2 {10_u8} + t1 {20_u8} == t2 {30_u8});
REQUIRE(T1 {10_u8} + T1 {20_u8} == T1 {30_u8});
REQUIRE(T1 {10_u8} + T2 {20_u8} == T1 {30_u8});
REQUIRE(T2 {10_u8} + T1 {20_u8} == T2 {30_u8});
}
diff --git a/ test/source/integral/type_test.cpp b/ test/source/integral/type_test.cpp
@@ -6,538 +6,538 @@
#include "based/integral/types.hpp"
using based::SameAs;
using based::u16;
using based::u32;
using based::u64;
using based::u8;
using based::U16;
using based::U32;
using based::U64;
using based::U8;
TEST_CASE("u8", "[integral/types/u8]")
TEST_CASE("U8", "[integral/types/U8]")
{
// clang-format off
STATIC_REQUIRE(requires(u8 lhs, u8 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(u8 lhs, u8 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(u8 lhs, u8 rhs) { { lhs + rhs } -> SameAs<u8>; });
STATIC_REQUIRE(requires(u8 lhs, u8 rhs) { { lhs - rhs } -> SameAs<u8>; });
STATIC_REQUIRE(requires(u8 lhs, u8 rhs) { { lhs * rhs } -> SameAs<u8>; });
STATIC_REQUIRE(requires(u8 lhs, u8 rhs) { { lhs / rhs } -> SameAs<u8>; });
STATIC_REQUIRE(requires(u8 lhs, u8 rhs) { { lhs % rhs } -> SameAs<u8>; });
STATIC_REQUIRE(requires(u8 lhs, u8 rhs) { { lhs & rhs } -> SameAs<u8>; });
STATIC_REQUIRE(requires(u8 lhs, u8 rhs) { { lhs | rhs } -> SameAs<u8>; });
STATIC_REQUIRE(requires(u8 lhs, u8 rhs) { { lhs ^ rhs } -> SameAs<u8>; });
STATIC_REQUIRE(requires(u8 lhs, u8 rhs) { { lhs << rhs } -> SameAs<u8>; });
STATIC_REQUIRE(requires(u8 lhs, u8 rhs) { { lhs >> rhs } -> SameAs<u8>; });
STATIC_REQUIRE(requires(u8 lhs, u8 rhs) { { lhs += rhs } -> SameAs<u8&>; });
STATIC_REQUIRE(requires(u8 lhs, u8 rhs) { { lhs -= rhs } -> SameAs<u8&>; });
STATIC_REQUIRE(requires(u8 lhs, u8 rhs) { { lhs *= rhs } -> SameAs<u8&>; });
STATIC_REQUIRE(requires(u8 lhs, u8 rhs) { { lhs /= rhs } -> SameAs<u8&>; });
STATIC_REQUIRE(requires(u8 lhs, u8 rhs) { { lhs %= rhs } -> SameAs<u8&>; });
STATIC_REQUIRE(requires(u8 lhs, u8 rhs) { { lhs &= rhs } -> SameAs<u8&>; });
STATIC_REQUIRE(requires(u8 lhs, u8 rhs) { { lhs |= rhs } -> SameAs<u8&>; });
STATIC_REQUIRE(requires(u8 lhs, u8 rhs) { { lhs ^= rhs } -> SameAs<u8&>; });
STATIC_REQUIRE(requires(u8 lhs, u8 rhs) { { lhs <<= rhs } -> SameAs<u8&>; });
STATIC_REQUIRE(requires(u8 lhs, u8 rhs) { { lhs >>= rhs } -> SameAs<u8&>; });
STATIC_REQUIRE(requires(u8 lhs, u16 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(u8 lhs, u16 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(u8 lhs, u16 rhs) { { lhs + rhs } -> SameAs<u16>; });
STATIC_REQUIRE(requires(u8 lhs, u16 rhs) { { lhs - rhs } -> SameAs<u16>; });
STATIC_REQUIRE(requires(u8 lhs, u16 rhs) { { lhs * rhs } -> SameAs<u16>; });
STATIC_REQUIRE(requires(u8 lhs, u16 rhs) { { lhs / rhs } -> SameAs<u16>; });
STATIC_REQUIRE(requires(u8 lhs, u16 rhs) { { lhs << rhs } -> SameAs<u16>; });
STATIC_REQUIRE(requires(u8 lhs, u16 rhs) { { lhs >> rhs } -> SameAs<u16>; });
STATIC_REQUIRE(requires(u8 lhs, u16 rhs) { { lhs % rhs } -> SameAs<u16>; });
STATIC_REQUIRE(requires(u8 lhs, u16 rhs) { { lhs & rhs } -> SameAs<u16>; });
STATIC_REQUIRE(requires(u8 lhs, u16 rhs) { { lhs | rhs } -> SameAs<u16>; });
STATIC_REQUIRE(requires(u8 lhs, u16 rhs) { { lhs ^ rhs } -> SameAs<u16>; });
STATIC_REQUIRE(requires(u8 lhs, u32 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(u8 lhs, u32 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(u8 lhs, u32 rhs) { { lhs + rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u8 lhs, u32 rhs) { { lhs - rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u8 lhs, u32 rhs) { { lhs * rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u8 lhs, u32 rhs) { { lhs / rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u8 lhs, u32 rhs) { { lhs % rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u8 lhs, u32 rhs) { { lhs << rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u8 lhs, u32 rhs) { { lhs >> rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u8 lhs, u32 rhs) { { lhs & rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u8 lhs, u32 rhs) { { lhs | rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u8 lhs, u32 rhs) { { lhs ^ rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u8 lhs, u32 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(u8 lhs, u64 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(u8 lhs, u64 rhs) { { lhs + rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u8 lhs, u64 rhs) { { lhs - rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u8 lhs, u64 rhs) { { lhs * rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u8 lhs, u64 rhs) { { lhs / rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u8 lhs, u64 rhs) { { lhs % rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u8 lhs, u64 rhs) { { lhs << rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u8 lhs, u64 rhs) { { lhs >> rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u8 lhs, u64 rhs) { { lhs & rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u8 lhs, u64 rhs) { { lhs | rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u8 lhs, u64 rhs) { { lhs ^ rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(U8 lhs, U8 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(U8 lhs, U8 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(U8 lhs, U8 rhs) { { lhs + rhs } -> SameAs<U8>; });
STATIC_REQUIRE(requires(U8 lhs, U8 rhs) { { lhs - rhs } -> SameAs<U8>; });
STATIC_REQUIRE(requires(U8 lhs, U8 rhs) { { lhs * rhs } -> SameAs<U8>; });
STATIC_REQUIRE(requires(U8 lhs, U8 rhs) { { lhs / rhs } -> SameAs<U8>; });
STATIC_REQUIRE(requires(U8 lhs, U8 rhs) { { lhs % rhs } -> SameAs<U8>; });
STATIC_REQUIRE(requires(U8 lhs, U8 rhs) { { lhs & rhs } -> SameAs<U8>; });
STATIC_REQUIRE(requires(U8 lhs, U8 rhs) { { lhs | rhs } -> SameAs<U8>; });
STATIC_REQUIRE(requires(U8 lhs, U8 rhs) { { lhs ^ rhs } -> SameAs<U8>; });
STATIC_REQUIRE(requires(U8 lhs, U8 rhs) { { lhs << rhs } -> SameAs<U8>; });
STATIC_REQUIRE(requires(U8 lhs, U8 rhs) { { lhs >> rhs } -> SameAs<U8>; });
STATIC_REQUIRE(requires(U8 lhs, U8 rhs) { { lhs += rhs } -> SameAs<U8&>; });
STATIC_REQUIRE(requires(U8 lhs, U8 rhs) { { lhs -= rhs } -> SameAs<U8&>; });
STATIC_REQUIRE(requires(U8 lhs, U8 rhs) { { lhs *= rhs } -> SameAs<U8&>; });
STATIC_REQUIRE(requires(U8 lhs, U8 rhs) { { lhs /= rhs } -> SameAs<U8&>; });
STATIC_REQUIRE(requires(U8 lhs, U8 rhs) { { lhs %= rhs } -> SameAs<U8&>; });
STATIC_REQUIRE(requires(U8 lhs, U8 rhs) { { lhs &= rhs } -> SameAs<U8&>; });
STATIC_REQUIRE(requires(U8 lhs, U8 rhs) { { lhs |= rhs } -> SameAs<U8&>; });
STATIC_REQUIRE(requires(U8 lhs, U8 rhs) { { lhs ^= rhs } -> SameAs<U8&>; });
STATIC_REQUIRE(requires(U8 lhs, U8 rhs) { { lhs <<= rhs } -> SameAs<U8&>; });
STATIC_REQUIRE(requires(U8 lhs, U8 rhs) { { lhs >>= rhs } -> SameAs<U8&>; });
STATIC_REQUIRE(requires(U8 lhs, U16 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(U8 lhs, U16 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(U8 lhs, U16 rhs) { { lhs + rhs } -> SameAs<U16>; });
STATIC_REQUIRE(requires(U8 lhs, U16 rhs) { { lhs - rhs } -> SameAs<U16>; });
STATIC_REQUIRE(requires(U8 lhs, U16 rhs) { { lhs * rhs } -> SameAs<U16>; });
STATIC_REQUIRE(requires(U8 lhs, U16 rhs) { { lhs / rhs } -> SameAs<U16>; });
STATIC_REQUIRE(requires(U8 lhs, U16 rhs) { { lhs << rhs } -> SameAs<U16>; });
STATIC_REQUIRE(requires(U8 lhs, U16 rhs) { { lhs >> rhs } -> SameAs<U16>; });
STATIC_REQUIRE(requires(U8 lhs, U16 rhs) { { lhs % rhs } -> SameAs<U16>; });
STATIC_REQUIRE(requires(U8 lhs, U16 rhs) { { lhs & rhs } -> SameAs<U16>; });
STATIC_REQUIRE(requires(U8 lhs, U16 rhs) { { lhs | rhs } -> SameAs<U16>; });
STATIC_REQUIRE(requires(U8 lhs, U16 rhs) { { lhs ^ rhs } -> SameAs<U16>; });
STATIC_REQUIRE(requires(U8 lhs, U32 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(U8 lhs, U32 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(U8 lhs, U32 rhs) { { lhs + rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U8 lhs, U32 rhs) { { lhs - rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U8 lhs, U32 rhs) { { lhs * rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U8 lhs, U32 rhs) { { lhs / rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U8 lhs, U32 rhs) { { lhs % rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U8 lhs, U32 rhs) { { lhs << rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U8 lhs, U32 rhs) { { lhs >> rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U8 lhs, U32 rhs) { { lhs & rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U8 lhs, U32 rhs) { { lhs | rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U8 lhs, U32 rhs) { { lhs ^ rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U8 lhs, U32 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(U8 lhs, U64 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(U8 lhs, U64 rhs) { { lhs + rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U8 lhs, U64 rhs) { { lhs - rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U8 lhs, U64 rhs) { { lhs * rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U8 lhs, U64 rhs) { { lhs / rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U8 lhs, U64 rhs) { { lhs % rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U8 lhs, U64 rhs) { { lhs << rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U8 lhs, U64 rhs) { { lhs >> rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U8 lhs, U64 rhs) { { lhs & rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U8 lhs, U64 rhs) { { lhs | rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U8 lhs, U64 rhs) { { lhs ^ rhs } -> SameAs<U64>; });
// clang-format on
}
TEST_CASE("u16", "[integral/types/u16]")
TEST_CASE("U16", "[integral/types/U16]")
{
// clang-format off
STATIC_REQUIRE(requires(u16 lhs, u8 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(u16 lhs, u8 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(u16 lhs, u8 rhs) { { lhs + rhs } -> SameAs<u16>; });
STATIC_REQUIRE(requires(u16 lhs, u8 rhs) { { lhs - rhs } -> SameAs<u16>; });
STATIC_REQUIRE(requires(u16 lhs, u8 rhs) { { lhs * rhs } -> SameAs<u16>; });
STATIC_REQUIRE(requires(u16 lhs, u8 rhs) { { lhs / rhs } -> SameAs<u16>; });
STATIC_REQUIRE(requires(u16 lhs, u8 rhs) { { lhs % rhs } -> SameAs<u16>; });
STATIC_REQUIRE(requires(u16 lhs, u8 rhs) { { lhs << rhs } -> SameAs<u16>; });
STATIC_REQUIRE(requires(u16 lhs, u8 rhs) { { lhs >> rhs } -> SameAs<u16>; });
STATIC_REQUIRE(requires(u16 lhs, u8 rhs) { { lhs & rhs } -> SameAs<u16>; });
STATIC_REQUIRE(requires(u16 lhs, u8 rhs) { { lhs | rhs } -> SameAs<u16>; });
STATIC_REQUIRE(requires(u16 lhs, u8 rhs) { { lhs ^ rhs } -> SameAs<u16>; });
STATIC_REQUIRE(requires(u16 lhs, u8 rhs) { { lhs += rhs } -> SameAs<u16&>; });
STATIC_REQUIRE(requires(u16 lhs, u8 rhs) { { lhs -= rhs } -> SameAs<u16&>; });
STATIC_REQUIRE(requires(u16 lhs, u8 rhs) { { lhs *= rhs } -> SameAs<u16&>; });
STATIC_REQUIRE(requires(u16 lhs, u8 rhs) { { lhs /= rhs } -> SameAs<u16&>; });
STATIC_REQUIRE(requires(u16 lhs, u8 rhs) { { lhs %= rhs } -> SameAs<u16&>; });
STATIC_REQUIRE(requires(u16 lhs, u8 rhs) { { lhs &= rhs } -> SameAs<u16&>; });
STATIC_REQUIRE(requires(u16 lhs, u8 rhs) { { lhs |= rhs } -> SameAs<u16&>; });
STATIC_REQUIRE(requires(u16 lhs, u8 rhs) { { lhs ^= rhs } -> SameAs<u16&>; });
STATIC_REQUIRE(requires(u16 lhs, u8 rhs) { { lhs <<= rhs } -> SameAs<u16&>; });
STATIC_REQUIRE(requires(u16 lhs, u8 rhs) { { lhs >>= rhs } -> SameAs<u16&>; });
STATIC_REQUIRE(requires(u16 lhs, u16 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(u16 lhs, u16 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(u16 lhs, u16 rhs) { { lhs + rhs } -> SameAs<u16>; });
STATIC_REQUIRE(requires(u16 lhs, u16 rhs) { { lhs - rhs } -> SameAs<u16>; });
STATIC_REQUIRE(requires(u16 lhs, u16 rhs) { { lhs * rhs } -> SameAs<u16>; });
STATIC_REQUIRE(requires(u16 lhs, u16 rhs) { { lhs / rhs } -> SameAs<u16>; });
STATIC_REQUIRE(requires(u16 lhs, u16 rhs) { { lhs % rhs } -> SameAs<u16>; });
STATIC_REQUIRE(requires(u16 lhs, u16 rhs) { { lhs << rhs } -> SameAs<u16>; });
STATIC_REQUIRE(requires(u16 lhs, u16 rhs) { { lhs >> rhs } -> SameAs<u16>; });
STATIC_REQUIRE(requires(u16 lhs, u16 rhs) { { lhs & rhs } -> SameAs<u16>; });
STATIC_REQUIRE(requires(u16 lhs, u16 rhs) { { lhs | rhs } -> SameAs<u16>; });
STATIC_REQUIRE(requires(u16 lhs, u16 rhs) { { lhs ^ rhs } -> SameAs<u16>; });
STATIC_REQUIRE(requires(u16 lhs, u16 rhs) { { lhs += rhs } -> SameAs<u16&>; });
STATIC_REQUIRE(requires(u16 lhs, u16 rhs) { { lhs -= rhs } -> SameAs<u16&>; });
STATIC_REQUIRE(requires(u16 lhs, u16 rhs) { { lhs *= rhs } -> SameAs<u16&>; });
STATIC_REQUIRE(requires(u16 lhs, u16 rhs) { { lhs /= rhs } -> SameAs<u16&>; });
STATIC_REQUIRE(requires(u16 lhs, u16 rhs) { { lhs %= rhs } -> SameAs<u16&>; });
STATIC_REQUIRE(requires(u16 lhs, u16 rhs) { { lhs &= rhs } -> SameAs<u16&>; });
STATIC_REQUIRE(requires(u16 lhs, u16 rhs) { { lhs |= rhs } -> SameAs<u16&>; });
STATIC_REQUIRE(requires(u16 lhs, u16 rhs) { { lhs ^= rhs } -> SameAs<u16&>; });
STATIC_REQUIRE(requires(u16 lhs, u16 rhs) { { lhs <<= rhs } -> SameAs<u16&>; });
STATIC_REQUIRE(requires(u16 lhs, u16 rhs) { { lhs >>= rhs } -> SameAs<u16&>; });
STATIC_REQUIRE(requires(u16 lhs, u32 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(u16 lhs, u32 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(u16 lhs, u32 rhs) { { lhs + rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u16 lhs, u32 rhs) { { lhs - rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u16 lhs, u32 rhs) { { lhs * rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u16 lhs, u32 rhs) { { lhs / rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u16 lhs, u32 rhs) { { lhs % rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u16 lhs, u32 rhs) { { lhs << rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u16 lhs, u32 rhs) { { lhs >> rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u16 lhs, u32 rhs) { { lhs & rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u16 lhs, u32 rhs) { { lhs | rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u16 lhs, u32 rhs) { { lhs ^ rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u16 lhs, u32 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(u16 lhs, u64 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(u16 lhs, u64 rhs) { { lhs + rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u16 lhs, u64 rhs) { { lhs - rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u16 lhs, u64 rhs) { { lhs * rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u16 lhs, u64 rhs) { { lhs / rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u16 lhs, u64 rhs) { { lhs % rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u16 lhs, u64 rhs) { { lhs << rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u16 lhs, u64 rhs) { { lhs >> rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u16 lhs, u64 rhs) { { lhs & rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u16 lhs, u64 rhs) { { lhs | rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u16 lhs, u64 rhs) { { lhs ^ rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(U16 lhs, U8 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(U16 lhs, U8 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(U16 lhs, U8 rhs) { { lhs + rhs } -> SameAs<U16>; });
STATIC_REQUIRE(requires(U16 lhs, U8 rhs) { { lhs - rhs } -> SameAs<U16>; });
STATIC_REQUIRE(requires(U16 lhs, U8 rhs) { { lhs * rhs } -> SameAs<U16>; });
STATIC_REQUIRE(requires(U16 lhs, U8 rhs) { { lhs / rhs } -> SameAs<U16>; });
STATIC_REQUIRE(requires(U16 lhs, U8 rhs) { { lhs % rhs } -> SameAs<U16>; });
STATIC_REQUIRE(requires(U16 lhs, U8 rhs) { { lhs << rhs } -> SameAs<U16>; });
STATIC_REQUIRE(requires(U16 lhs, U8 rhs) { { lhs >> rhs } -> SameAs<U16>; });
STATIC_REQUIRE(requires(U16 lhs, U8 rhs) { { lhs & rhs } -> SameAs<U16>; });
STATIC_REQUIRE(requires(U16 lhs, U8 rhs) { { lhs | rhs } -> SameAs<U16>; });
STATIC_REQUIRE(requires(U16 lhs, U8 rhs) { { lhs ^ rhs } -> SameAs<U16>; });
STATIC_REQUIRE(requires(U16 lhs, U8 rhs) { { lhs += rhs } -> SameAs<U16&>; });
STATIC_REQUIRE(requires(U16 lhs, U8 rhs) { { lhs -= rhs } -> SameAs<U16&>; });
STATIC_REQUIRE(requires(U16 lhs, U8 rhs) { { lhs *= rhs } -> SameAs<U16&>; });
STATIC_REQUIRE(requires(U16 lhs, U8 rhs) { { lhs /= rhs } -> SameAs<U16&>; });
STATIC_REQUIRE(requires(U16 lhs, U8 rhs) { { lhs %= rhs } -> SameAs<U16&>; });
STATIC_REQUIRE(requires(U16 lhs, U8 rhs) { { lhs &= rhs } -> SameAs<U16&>; });
STATIC_REQUIRE(requires(U16 lhs, U8 rhs) { { lhs |= rhs } -> SameAs<U16&>; });
STATIC_REQUIRE(requires(U16 lhs, U8 rhs) { { lhs ^= rhs } -> SameAs<U16&>; });
STATIC_REQUIRE(requires(U16 lhs, U8 rhs) { { lhs <<= rhs } -> SameAs<U16&>; });
STATIC_REQUIRE(requires(U16 lhs, U8 rhs) { { lhs >>= rhs } -> SameAs<U16&>; });
STATIC_REQUIRE(requires(U16 lhs, U16 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(U16 lhs, U16 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(U16 lhs, U16 rhs) { { lhs + rhs } -> SameAs<U16>; });
STATIC_REQUIRE(requires(U16 lhs, U16 rhs) { { lhs - rhs } -> SameAs<U16>; });
STATIC_REQUIRE(requires(U16 lhs, U16 rhs) { { lhs * rhs } -> SameAs<U16>; });
STATIC_REQUIRE(requires(U16 lhs, U16 rhs) { { lhs / rhs } -> SameAs<U16>; });
STATIC_REQUIRE(requires(U16 lhs, U16 rhs) { { lhs % rhs } -> SameAs<U16>; });
STATIC_REQUIRE(requires(U16 lhs, U16 rhs) { { lhs << rhs } -> SameAs<U16>; });
STATIC_REQUIRE(requires(U16 lhs, U16 rhs) { { lhs >> rhs } -> SameAs<U16>; });
STATIC_REQUIRE(requires(U16 lhs, U16 rhs) { { lhs & rhs } -> SameAs<U16>; });
STATIC_REQUIRE(requires(U16 lhs, U16 rhs) { { lhs | rhs } -> SameAs<U16>; });
STATIC_REQUIRE(requires(U16 lhs, U16 rhs) { { lhs ^ rhs } -> SameAs<U16>; });
STATIC_REQUIRE(requires(U16 lhs, U16 rhs) { { lhs += rhs } -> SameAs<U16&>; });
STATIC_REQUIRE(requires(U16 lhs, U16 rhs) { { lhs -= rhs } -> SameAs<U16&>; });
STATIC_REQUIRE(requires(U16 lhs, U16 rhs) { { lhs *= rhs } -> SameAs<U16&>; });
STATIC_REQUIRE(requires(U16 lhs, U16 rhs) { { lhs /= rhs } -> SameAs<U16&>; });
STATIC_REQUIRE(requires(U16 lhs, U16 rhs) { { lhs %= rhs } -> SameAs<U16&>; });
STATIC_REQUIRE(requires(U16 lhs, U16 rhs) { { lhs &= rhs } -> SameAs<U16&>; });
STATIC_REQUIRE(requires(U16 lhs, U16 rhs) { { lhs |= rhs } -> SameAs<U16&>; });
STATIC_REQUIRE(requires(U16 lhs, U16 rhs) { { lhs ^= rhs } -> SameAs<U16&>; });
STATIC_REQUIRE(requires(U16 lhs, U16 rhs) { { lhs <<= rhs } -> SameAs<U16&>; });
STATIC_REQUIRE(requires(U16 lhs, U16 rhs) { { lhs >>= rhs } -> SameAs<U16&>; });
STATIC_REQUIRE(requires(U16 lhs, U32 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(U16 lhs, U32 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(U16 lhs, U32 rhs) { { lhs + rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U16 lhs, U32 rhs) { { lhs - rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U16 lhs, U32 rhs) { { lhs * rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U16 lhs, U32 rhs) { { lhs / rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U16 lhs, U32 rhs) { { lhs % rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U16 lhs, U32 rhs) { { lhs << rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U16 lhs, U32 rhs) { { lhs >> rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U16 lhs, U32 rhs) { { lhs & rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U16 lhs, U32 rhs) { { lhs | rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U16 lhs, U32 rhs) { { lhs ^ rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U16 lhs, U32 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(U16 lhs, U64 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(U16 lhs, U64 rhs) { { lhs + rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U16 lhs, U64 rhs) { { lhs - rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U16 lhs, U64 rhs) { { lhs * rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U16 lhs, U64 rhs) { { lhs / rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U16 lhs, U64 rhs) { { lhs % rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U16 lhs, U64 rhs) { { lhs << rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U16 lhs, U64 rhs) { { lhs >> rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U16 lhs, U64 rhs) { { lhs & rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U16 lhs, U64 rhs) { { lhs | rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U16 lhs, U64 rhs) { { lhs ^ rhs } -> SameAs<U64>; });
// clang-format on
}
TEST_CASE("u32", "[integral/types/u32]")
TEST_CASE("U32", "[integral/types/U32]")
{
// clang-format off
STATIC_REQUIRE(requires(u32 lhs, u8 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(u32 lhs, u8 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(u32 lhs, u8 rhs) { { lhs + rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u32 lhs, u8 rhs) { { lhs - rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u32 lhs, u8 rhs) { { lhs * rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u32 lhs, u8 rhs) { { lhs / rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u32 lhs, u8 rhs) { { lhs % rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u32 lhs, u8 rhs) { { lhs << rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u32 lhs, u8 rhs) { { lhs >> rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u32 lhs, u8 rhs) { { lhs & rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u32 lhs, u8 rhs) { { lhs | rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u32 lhs, u8 rhs) { { lhs ^ rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u32 lhs, u8 rhs) { { lhs += rhs } -> SameAs<u32&>; });
STATIC_REQUIRE(requires(u32 lhs, u8 rhs) { { lhs -= rhs } -> SameAs<u32&>; });
STATIC_REQUIRE(requires(u32 lhs, u8 rhs) { { lhs *= rhs } -> SameAs<u32&>; });
STATIC_REQUIRE(requires(u32 lhs, u8 rhs) { { lhs /= rhs } -> SameAs<u32&>; });
STATIC_REQUIRE(requires(u32 lhs, u8 rhs) { { lhs %= rhs } -> SameAs<u32&>; });
STATIC_REQUIRE(requires(u32 lhs, u8 rhs) { { lhs &= rhs } -> SameAs<u32&>; });
STATIC_REQUIRE(requires(u32 lhs, u8 rhs) { { lhs |= rhs } -> SameAs<u32&>; });
STATIC_REQUIRE(requires(u32 lhs, u8 rhs) { { lhs ^= rhs } -> SameAs<u32&>; });
STATIC_REQUIRE(requires(u32 lhs, u8 rhs) { { lhs <<= rhs } -> SameAs<u32&>; });
STATIC_REQUIRE(requires(u32 lhs, u8 rhs) { { lhs >>= rhs } -> SameAs<u32&>; });
STATIC_REQUIRE(requires(u32 lhs, u16 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(u32 lhs, u16 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(u32 lhs, u16 rhs) { { lhs + rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u32 lhs, u16 rhs) { { lhs - rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u32 lhs, u16 rhs) { { lhs * rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u32 lhs, u16 rhs) { { lhs / rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u32 lhs, u16 rhs) { { lhs % rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u32 lhs, u16 rhs) { { lhs << rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u32 lhs, u16 rhs) { { lhs >> rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u32 lhs, u16 rhs) { { lhs & rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u32 lhs, u16 rhs) { { lhs | rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u32 lhs, u16 rhs) { { lhs ^ rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u32 lhs, u16 rhs) { { lhs += rhs } -> SameAs<u32&>; });
STATIC_REQUIRE(requires(u32 lhs, u16 rhs) { { lhs -= rhs } -> SameAs<u32&>; });
STATIC_REQUIRE(requires(u32 lhs, u16 rhs) { { lhs *= rhs } -> SameAs<u32&>; });
STATIC_REQUIRE(requires(u32 lhs, u16 rhs) { { lhs /= rhs } -> SameAs<u32&>; });
STATIC_REQUIRE(requires(u32 lhs, u16 rhs) { { lhs %= rhs } -> SameAs<u32&>; });
STATIC_REQUIRE(requires(u32 lhs, u16 rhs) { { lhs &= rhs } -> SameAs<u32&>; });
STATIC_REQUIRE(requires(u32 lhs, u16 rhs) { { lhs |= rhs } -> SameAs<u32&>; });
STATIC_REQUIRE(requires(u32 lhs, u16 rhs) { { lhs ^= rhs } -> SameAs<u32&>; });
STATIC_REQUIRE(requires(u32 lhs, u16 rhs) { { lhs <<= rhs } -> SameAs<u32&>; });
STATIC_REQUIRE(requires(u32 lhs, u16 rhs) { { lhs >>= rhs } -> SameAs<u32&>; });
STATIC_REQUIRE(requires(u32 lhs, u32 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(u32 lhs, u32 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(u32 lhs, u32 rhs) { { lhs + rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u32 lhs, u32 rhs) { { lhs - rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u32 lhs, u32 rhs) { { lhs * rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u32 lhs, u32 rhs) { { lhs / rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u32 lhs, u32 rhs) { { lhs % rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u32 lhs, u32 rhs) { { lhs << rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u32 lhs, u32 rhs) { { lhs >> rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u32 lhs, u32 rhs) { { lhs & rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u32 lhs, u32 rhs) { { lhs | rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u32 lhs, u32 rhs) { { lhs ^ rhs } -> SameAs<u32>; });
STATIC_REQUIRE(requires(u32 lhs, u32 rhs) { { lhs += rhs } -> SameAs<u32&>; });
STATIC_REQUIRE(requires(u32 lhs, u32 rhs) { { lhs -= rhs } -> SameAs<u32&>; });
STATIC_REQUIRE(requires(u32 lhs, u32 rhs) { { lhs *= rhs } -> SameAs<u32&>; });
STATIC_REQUIRE(requires(u32 lhs, u32 rhs) { { lhs /= rhs } -> SameAs<u32&>; });
STATIC_REQUIRE(requires(u32 lhs, u32 rhs) { { lhs %= rhs } -> SameAs<u32&>; });
STATIC_REQUIRE(requires(u32 lhs, u32 rhs) { { lhs &= rhs } -> SameAs<u32&>; });
STATIC_REQUIRE(requires(u32 lhs, u32 rhs) { { lhs |= rhs } -> SameAs<u32&>; });
STATIC_REQUIRE(requires(u32 lhs, u32 rhs) { { lhs ^= rhs } -> SameAs<u32&>; });
STATIC_REQUIRE(requires(u32 lhs, u32 rhs) { { lhs <<= rhs } -> SameAs<u32&>; });
STATIC_REQUIRE(requires(u32 lhs, u32 rhs) { { lhs >>= rhs } -> SameAs<u32&>; });
STATIC_REQUIRE(requires(u32 lhs, u32 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(u32 lhs, u64 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(u32 lhs, u64 rhs) { { lhs + rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u32 lhs, u64 rhs) { { lhs - rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u32 lhs, u64 rhs) { { lhs * rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u32 lhs, u64 rhs) { { lhs / rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u32 lhs, u64 rhs) { { lhs % rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u32 lhs, u64 rhs) { { lhs << rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u32 lhs, u64 rhs) { { lhs >> rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u32 lhs, u64 rhs) { { lhs & rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u32 lhs, u64 rhs) { { lhs | rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u32 lhs, u64 rhs) { { lhs ^ rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(U32 lhs, U8 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(U32 lhs, U8 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(U32 lhs, U8 rhs) { { lhs + rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U32 lhs, U8 rhs) { { lhs - rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U32 lhs, U8 rhs) { { lhs * rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U32 lhs, U8 rhs) { { lhs / rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U32 lhs, U8 rhs) { { lhs % rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U32 lhs, U8 rhs) { { lhs << rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U32 lhs, U8 rhs) { { lhs >> rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U32 lhs, U8 rhs) { { lhs & rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U32 lhs, U8 rhs) { { lhs | rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U32 lhs, U8 rhs) { { lhs ^ rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U32 lhs, U8 rhs) { { lhs += rhs } -> SameAs<U32&>; });
STATIC_REQUIRE(requires(U32 lhs, U8 rhs) { { lhs -= rhs } -> SameAs<U32&>; });
STATIC_REQUIRE(requires(U32 lhs, U8 rhs) { { lhs *= rhs } -> SameAs<U32&>; });
STATIC_REQUIRE(requires(U32 lhs, U8 rhs) { { lhs /= rhs } -> SameAs<U32&>; });
STATIC_REQUIRE(requires(U32 lhs, U8 rhs) { { lhs %= rhs } -> SameAs<U32&>; });
STATIC_REQUIRE(requires(U32 lhs, U8 rhs) { { lhs &= rhs } -> SameAs<U32&>; });
STATIC_REQUIRE(requires(U32 lhs, U8 rhs) { { lhs |= rhs } -> SameAs<U32&>; });
STATIC_REQUIRE(requires(U32 lhs, U8 rhs) { { lhs ^= rhs } -> SameAs<U32&>; });
STATIC_REQUIRE(requires(U32 lhs, U8 rhs) { { lhs <<= rhs } -> SameAs<U32&>; });
STATIC_REQUIRE(requires(U32 lhs, U8 rhs) { { lhs >>= rhs } -> SameAs<U32&>; });
STATIC_REQUIRE(requires(U32 lhs, U16 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(U32 lhs, U16 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(U32 lhs, U16 rhs) { { lhs + rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U32 lhs, U16 rhs) { { lhs - rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U32 lhs, U16 rhs) { { lhs * rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U32 lhs, U16 rhs) { { lhs / rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U32 lhs, U16 rhs) { { lhs % rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U32 lhs, U16 rhs) { { lhs << rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U32 lhs, U16 rhs) { { lhs >> rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U32 lhs, U16 rhs) { { lhs & rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U32 lhs, U16 rhs) { { lhs | rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U32 lhs, U16 rhs) { { lhs ^ rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U32 lhs, U16 rhs) { { lhs += rhs } -> SameAs<U32&>; });
STATIC_REQUIRE(requires(U32 lhs, U16 rhs) { { lhs -= rhs } -> SameAs<U32&>; });
STATIC_REQUIRE(requires(U32 lhs, U16 rhs) { { lhs *= rhs } -> SameAs<U32&>; });
STATIC_REQUIRE(requires(U32 lhs, U16 rhs) { { lhs /= rhs } -> SameAs<U32&>; });
STATIC_REQUIRE(requires(U32 lhs, U16 rhs) { { lhs %= rhs } -> SameAs<U32&>; });
STATIC_REQUIRE(requires(U32 lhs, U16 rhs) { { lhs &= rhs } -> SameAs<U32&>; });
STATIC_REQUIRE(requires(U32 lhs, U16 rhs) { { lhs |= rhs } -> SameAs<U32&>; });
STATIC_REQUIRE(requires(U32 lhs, U16 rhs) { { lhs ^= rhs } -> SameAs<U32&>; });
STATIC_REQUIRE(requires(U32 lhs, U16 rhs) { { lhs <<= rhs } -> SameAs<U32&>; });
STATIC_REQUIRE(requires(U32 lhs, U16 rhs) { { lhs >>= rhs } -> SameAs<U32&>; });
STATIC_REQUIRE(requires(U32 lhs, U32 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(U32 lhs, U32 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(U32 lhs, U32 rhs) { { lhs + rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U32 lhs, U32 rhs) { { lhs - rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U32 lhs, U32 rhs) { { lhs * rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U32 lhs, U32 rhs) { { lhs / rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U32 lhs, U32 rhs) { { lhs % rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U32 lhs, U32 rhs) { { lhs << rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U32 lhs, U32 rhs) { { lhs >> rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U32 lhs, U32 rhs) { { lhs & rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U32 lhs, U32 rhs) { { lhs | rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U32 lhs, U32 rhs) { { lhs ^ rhs } -> SameAs<U32>; });
STATIC_REQUIRE(requires(U32 lhs, U32 rhs) { { lhs += rhs } -> SameAs<U32&>; });
STATIC_REQUIRE(requires(U32 lhs, U32 rhs) { { lhs -= rhs } -> SameAs<U32&>; });
STATIC_REQUIRE(requires(U32 lhs, U32 rhs) { { lhs *= rhs } -> SameAs<U32&>; });
STATIC_REQUIRE(requires(U32 lhs, U32 rhs) { { lhs /= rhs } -> SameAs<U32&>; });
STATIC_REQUIRE(requires(U32 lhs, U32 rhs) { { lhs %= rhs } -> SameAs<U32&>; });
STATIC_REQUIRE(requires(U32 lhs, U32 rhs) { { lhs &= rhs } -> SameAs<U32&>; });
STATIC_REQUIRE(requires(U32 lhs, U32 rhs) { { lhs |= rhs } -> SameAs<U32&>; });
STATIC_REQUIRE(requires(U32 lhs, U32 rhs) { { lhs ^= rhs } -> SameAs<U32&>; });
STATIC_REQUIRE(requires(U32 lhs, U32 rhs) { { lhs <<= rhs } -> SameAs<U32&>; });
STATIC_REQUIRE(requires(U32 lhs, U32 rhs) { { lhs >>= rhs } -> SameAs<U32&>; });
STATIC_REQUIRE(requires(U32 lhs, U32 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(U32 lhs, U64 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(U32 lhs, U64 rhs) { { lhs + rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U32 lhs, U64 rhs) { { lhs - rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U32 lhs, U64 rhs) { { lhs * rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U32 lhs, U64 rhs) { { lhs / rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U32 lhs, U64 rhs) { { lhs % rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U32 lhs, U64 rhs) { { lhs << rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U32 lhs, U64 rhs) { { lhs >> rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U32 lhs, U64 rhs) { { lhs & rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U32 lhs, U64 rhs) { { lhs | rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U32 lhs, U64 rhs) { { lhs ^ rhs } -> SameAs<U64>; });
// clang-format on
}
TEST_CASE("u64", "[integral/types/u64]")
TEST_CASE("U64", "[integral/types/U64]")
{
// clang-format off
STATIC_REQUIRE(requires(u64 lhs, u8 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(u64 lhs, u8 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(u64 lhs, u8 rhs) { { lhs + rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u64 lhs, u8 rhs) { { lhs - rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u64 lhs, u8 rhs) { { lhs * rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u64 lhs, u8 rhs) { { lhs / rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u64 lhs, u8 rhs) { { lhs % rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u64 lhs, u8 rhs) { { lhs << rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u64 lhs, u8 rhs) { { lhs >> rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u64 lhs, u8 rhs) { { lhs & rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u64 lhs, u8 rhs) { { lhs | rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u64 lhs, u8 rhs) { { lhs ^ rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u64 lhs, u8 rhs) { { lhs += rhs } -> SameAs<u64&>; });
STATIC_REQUIRE(requires(u64 lhs, u8 rhs) { { lhs -= rhs } -> SameAs<u64&>; });
STATIC_REQUIRE(requires(u64 lhs, u8 rhs) { { lhs *= rhs } -> SameAs<u64&>; });
STATIC_REQUIRE(requires(u64 lhs, u8 rhs) { { lhs /= rhs } -> SameAs<u64&>; });
STATIC_REQUIRE(requires(u64 lhs, u8 rhs) { { lhs %= rhs } -> SameAs<u64&>; });
STATIC_REQUIRE(requires(u64 lhs, u8 rhs) { { lhs &= rhs } -> SameAs<u64&>; });
STATIC_REQUIRE(requires(u64 lhs, u8 rhs) { { lhs |= rhs } -> SameAs<u64&>; });
STATIC_REQUIRE(requires(u64 lhs, u8 rhs) { { lhs ^= rhs } -> SameAs<u64&>; });
STATIC_REQUIRE(requires(u64 lhs, u8 rhs) { { lhs <<= rhs } -> SameAs<u64&>; });
STATIC_REQUIRE(requires(u64 lhs, u8 rhs) { { lhs >>= rhs } -> SameAs<u64&>; });
STATIC_REQUIRE(requires(u64 lhs, u16 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(u64 lhs, u16 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(u64 lhs, u16 rhs) { { lhs + rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u64 lhs, u16 rhs) { { lhs - rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u64 lhs, u16 rhs) { { lhs * rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u64 lhs, u16 rhs) { { lhs / rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u64 lhs, u16 rhs) { { lhs % rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u64 lhs, u16 rhs) { { lhs << rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u64 lhs, u16 rhs) { { lhs >> rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u64 lhs, u16 rhs) { { lhs & rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u64 lhs, u16 rhs) { { lhs | rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u64 lhs, u16 rhs) { { lhs ^ rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u64 lhs, u16 rhs) { { lhs += rhs } -> SameAs<u64&>; });
STATIC_REQUIRE(requires(u64 lhs, u16 rhs) { { lhs -= rhs } -> SameAs<u64&>; });
STATIC_REQUIRE(requires(u64 lhs, u16 rhs) { { lhs *= rhs } -> SameAs<u64&>; });
STATIC_REQUIRE(requires(u64 lhs, u16 rhs) { { lhs /= rhs } -> SameAs<u64&>; });
STATIC_REQUIRE(requires(u64 lhs, u16 rhs) { { lhs %= rhs } -> SameAs<u64&>; });
STATIC_REQUIRE(requires(u64 lhs, u16 rhs) { { lhs &= rhs } -> SameAs<u64&>; });
STATIC_REQUIRE(requires(u64 lhs, u16 rhs) { { lhs |= rhs } -> SameAs<u64&>; });
STATIC_REQUIRE(requires(u64 lhs, u16 rhs) { { lhs ^= rhs } -> SameAs<u64&>; });
STATIC_REQUIRE(requires(u64 lhs, u16 rhs) { { lhs <<= rhs } -> SameAs<u64&>; });
STATIC_REQUIRE(requires(u64 lhs, u16 rhs) { { lhs >>= rhs } -> SameAs<u64&>; });
STATIC_REQUIRE(requires(u64 lhs, u32 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(u64 lhs, u32 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(u64 lhs, u32 rhs) { { lhs + rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u64 lhs, u32 rhs) { { lhs - rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u64 lhs, u32 rhs) { { lhs * rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u64 lhs, u32 rhs) { { lhs / rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u64 lhs, u32 rhs) { { lhs % rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u64 lhs, u32 rhs) { { lhs << rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u64 lhs, u32 rhs) { { lhs >> rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u64 lhs, u32 rhs) { { lhs & rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u64 lhs, u32 rhs) { { lhs | rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u64 lhs, u32 rhs) { { lhs ^ rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u64 lhs, u32 rhs) { { lhs += rhs } -> SameAs<u64&>; });
STATIC_REQUIRE(requires(u64 lhs, u32 rhs) { { lhs -= rhs } -> SameAs<u64&>; });
STATIC_REQUIRE(requires(u64 lhs, u32 rhs) { { lhs *= rhs } -> SameAs<u64&>; });
STATIC_REQUIRE(requires(u64 lhs, u32 rhs) { { lhs /= rhs } -> SameAs<u64&>; });
STATIC_REQUIRE(requires(u64 lhs, u32 rhs) { { lhs %= rhs } -> SameAs<u64&>; });
STATIC_REQUIRE(requires(u64 lhs, u32 rhs) { { lhs &= rhs } -> SameAs<u64&>; });
STATIC_REQUIRE(requires(u64 lhs, u32 rhs) { { lhs |= rhs } -> SameAs<u64&>; });
STATIC_REQUIRE(requires(u64 lhs, u32 rhs) { { lhs ^= rhs } -> SameAs<u64&>; });
STATIC_REQUIRE(requires(u64 lhs, u32 rhs) { { lhs <<= rhs } -> SameAs<u64&>; });
STATIC_REQUIRE(requires(u64 lhs, u32 rhs) { { lhs >>= rhs } -> SameAs<u64&>; });
STATIC_REQUIRE(requires(u64 lhs, u32 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(u64 lhs, u64 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(u64 lhs, u64 rhs) { { lhs + rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u64 lhs, u64 rhs) { { lhs - rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u64 lhs, u64 rhs) { { lhs * rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u64 lhs, u64 rhs) { { lhs / rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u64 lhs, u64 rhs) { { lhs % rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u64 lhs, u64 rhs) { { lhs << rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u64 lhs, u64 rhs) { { lhs >> rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u64 lhs, u64 rhs) { { lhs & rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u64 lhs, u64 rhs) { { lhs | rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u64 lhs, u64 rhs) { { lhs ^ rhs } -> SameAs<u64>; });
STATIC_REQUIRE(requires(u64 lhs, u64 rhs) { { lhs += rhs } -> SameAs<u64&>; });
STATIC_REQUIRE(requires(u64 lhs, u64 rhs) { { lhs -= rhs } -> SameAs<u64&>; });
STATIC_REQUIRE(requires(u64 lhs, u64 rhs) { { lhs *= rhs } -> SameAs<u64&>; });
STATIC_REQUIRE(requires(u64 lhs, u64 rhs) { { lhs /= rhs } -> SameAs<u64&>; });
STATIC_REQUIRE(requires(u64 lhs, u64 rhs) { { lhs %= rhs } -> SameAs<u64&>; });
STATIC_REQUIRE(requires(u64 lhs, u64 rhs) { { lhs &= rhs } -> SameAs<u64&>; });
STATIC_REQUIRE(requires(u64 lhs, u64 rhs) { { lhs |= rhs } -> SameAs<u64&>; });
STATIC_REQUIRE(requires(u64 lhs, u64 rhs) { { lhs ^= rhs } -> SameAs<u64&>; });
STATIC_REQUIRE(requires(u64 lhs, u64 rhs) { { lhs <<= rhs } -> SameAs<u64&>; });
STATIC_REQUIRE(requires(u64 lhs, u64 rhs) { { lhs >>= rhs } -> SameAs<u64&>; });
STATIC_REQUIRE(requires(U64 lhs, U8 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(U64 lhs, U8 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(U64 lhs, U8 rhs) { { lhs + rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U64 lhs, U8 rhs) { { lhs - rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U64 lhs, U8 rhs) { { lhs * rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U64 lhs, U8 rhs) { { lhs / rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U64 lhs, U8 rhs) { { lhs % rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U64 lhs, U8 rhs) { { lhs << rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U64 lhs, U8 rhs) { { lhs >> rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U64 lhs, U8 rhs) { { lhs & rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U64 lhs, U8 rhs) { { lhs | rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U64 lhs, U8 rhs) { { lhs ^ rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U64 lhs, U8 rhs) { { lhs += rhs } -> SameAs<U64&>; });
STATIC_REQUIRE(requires(U64 lhs, U8 rhs) { { lhs -= rhs } -> SameAs<U64&>; });
STATIC_REQUIRE(requires(U64 lhs, U8 rhs) { { lhs *= rhs } -> SameAs<U64&>; });
STATIC_REQUIRE(requires(U64 lhs, U8 rhs) { { lhs /= rhs } -> SameAs<U64&>; });
STATIC_REQUIRE(requires(U64 lhs, U8 rhs) { { lhs %= rhs } -> SameAs<U64&>; });
STATIC_REQUIRE(requires(U64 lhs, U8 rhs) { { lhs &= rhs } -> SameAs<U64&>; });
STATIC_REQUIRE(requires(U64 lhs, U8 rhs) { { lhs |= rhs } -> SameAs<U64&>; });
STATIC_REQUIRE(requires(U64 lhs, U8 rhs) { { lhs ^= rhs } -> SameAs<U64&>; });
STATIC_REQUIRE(requires(U64 lhs, U8 rhs) { { lhs <<= rhs } -> SameAs<U64&>; });
STATIC_REQUIRE(requires(U64 lhs, U8 rhs) { { lhs >>= rhs } -> SameAs<U64&>; });
STATIC_REQUIRE(requires(U64 lhs, U16 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(U64 lhs, U16 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(U64 lhs, U16 rhs) { { lhs + rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U64 lhs, U16 rhs) { { lhs - rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U64 lhs, U16 rhs) { { lhs * rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U64 lhs, U16 rhs) { { lhs / rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U64 lhs, U16 rhs) { { lhs % rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U64 lhs, U16 rhs) { { lhs << rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U64 lhs, U16 rhs) { { lhs >> rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U64 lhs, U16 rhs) { { lhs & rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U64 lhs, U16 rhs) { { lhs | rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U64 lhs, U16 rhs) { { lhs ^ rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U64 lhs, U16 rhs) { { lhs += rhs } -> SameAs<U64&>; });
STATIC_REQUIRE(requires(U64 lhs, U16 rhs) { { lhs -= rhs } -> SameAs<U64&>; });
STATIC_REQUIRE(requires(U64 lhs, U16 rhs) { { lhs *= rhs } -> SameAs<U64&>; });
STATIC_REQUIRE(requires(U64 lhs, U16 rhs) { { lhs /= rhs } -> SameAs<U64&>; });
STATIC_REQUIRE(requires(U64 lhs, U16 rhs) { { lhs %= rhs } -> SameAs<U64&>; });
STATIC_REQUIRE(requires(U64 lhs, U16 rhs) { { lhs &= rhs } -> SameAs<U64&>; });
STATIC_REQUIRE(requires(U64 lhs, U16 rhs) { { lhs |= rhs } -> SameAs<U64&>; });
STATIC_REQUIRE(requires(U64 lhs, U16 rhs) { { lhs ^= rhs } -> SameAs<U64&>; });
STATIC_REQUIRE(requires(U64 lhs, U16 rhs) { { lhs <<= rhs } -> SameAs<U64&>; });
STATIC_REQUIRE(requires(U64 lhs, U16 rhs) { { lhs >>= rhs } -> SameAs<U64&>; });
STATIC_REQUIRE(requires(U64 lhs, U32 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(U64 lhs, U32 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(U64 lhs, U32 rhs) { { lhs + rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U64 lhs, U32 rhs) { { lhs - rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U64 lhs, U32 rhs) { { lhs * rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U64 lhs, U32 rhs) { { lhs / rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U64 lhs, U32 rhs) { { lhs % rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U64 lhs, U32 rhs) { { lhs << rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U64 lhs, U32 rhs) { { lhs >> rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U64 lhs, U32 rhs) { { lhs & rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U64 lhs, U32 rhs) { { lhs | rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U64 lhs, U32 rhs) { { lhs ^ rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U64 lhs, U32 rhs) { { lhs += rhs } -> SameAs<U64&>; });
STATIC_REQUIRE(requires(U64 lhs, U32 rhs) { { lhs -= rhs } -> SameAs<U64&>; });
STATIC_REQUIRE(requires(U64 lhs, U32 rhs) { { lhs *= rhs } -> SameAs<U64&>; });
STATIC_REQUIRE(requires(U64 lhs, U32 rhs) { { lhs /= rhs } -> SameAs<U64&>; });
STATIC_REQUIRE(requires(U64 lhs, U32 rhs) { { lhs %= rhs } -> SameAs<U64&>; });
STATIC_REQUIRE(requires(U64 lhs, U32 rhs) { { lhs &= rhs } -> SameAs<U64&>; });
STATIC_REQUIRE(requires(U64 lhs, U32 rhs) { { lhs |= rhs } -> SameAs<U64&>; });
STATIC_REQUIRE(requires(U64 lhs, U32 rhs) { { lhs ^= rhs } -> SameAs<U64&>; });
STATIC_REQUIRE(requires(U64 lhs, U32 rhs) { { lhs <<= rhs } -> SameAs<U64&>; });
STATIC_REQUIRE(requires(U64 lhs, U32 rhs) { { lhs >>= rhs } -> SameAs<U64&>; });
STATIC_REQUIRE(requires(U64 lhs, U32 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(U64 lhs, U64 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(U64 lhs, U64 rhs) { { lhs + rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U64 lhs, U64 rhs) { { lhs - rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U64 lhs, U64 rhs) { { lhs * rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U64 lhs, U64 rhs) { { lhs / rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U64 lhs, U64 rhs) { { lhs % rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U64 lhs, U64 rhs) { { lhs << rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U64 lhs, U64 rhs) { { lhs >> rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U64 lhs, U64 rhs) { { lhs & rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U64 lhs, U64 rhs) { { lhs | rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U64 lhs, U64 rhs) { { lhs ^ rhs } -> SameAs<U64>; });
STATIC_REQUIRE(requires(U64 lhs, U64 rhs) { { lhs += rhs } -> SameAs<U64&>; });
STATIC_REQUIRE(requires(U64 lhs, U64 rhs) { { lhs -= rhs } -> SameAs<U64&>; });
STATIC_REQUIRE(requires(U64 lhs, U64 rhs) { { lhs *= rhs } -> SameAs<U64&>; });
STATIC_REQUIRE(requires(U64 lhs, U64 rhs) { { lhs /= rhs } -> SameAs<U64&>; });
STATIC_REQUIRE(requires(U64 lhs, U64 rhs) { { lhs %= rhs } -> SameAs<U64&>; });
STATIC_REQUIRE(requires(U64 lhs, U64 rhs) { { lhs &= rhs } -> SameAs<U64&>; });
STATIC_REQUIRE(requires(U64 lhs, U64 rhs) { { lhs |= rhs } -> SameAs<U64&>; });
STATIC_REQUIRE(requires(U64 lhs, U64 rhs) { { lhs ^= rhs } -> SameAs<U64&>; });
STATIC_REQUIRE(requires(U64 lhs, U64 rhs) { { lhs <<= rhs } -> SameAs<U64&>; });
STATIC_REQUIRE(requires(U64 lhs, U64 rhs) { { lhs >>= rhs } -> SameAs<U64&>; });
// clang-format on
}
using based::i16;
using based::i32;
using based::i64;
using based::i8;
using based::I16;
using based::I32;
using based::I64;
using based::I8;
TEST_CASE("i8", "[integral/types/i8]")
TEST_CASE("I8", "[integral/types/I8]")
{
// clang-format off
STATIC_REQUIRE(requires(i8 lhs, i8 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(i8 lhs, i8 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(i8 lhs, i8 rhs) { { lhs + rhs } -> SameAs<i8>; });
STATIC_REQUIRE(requires(i8 lhs, i8 rhs) { { lhs - rhs } -> SameAs<i8>; });
STATIC_REQUIRE(requires(i8 lhs, i8 rhs) { { lhs * rhs } -> SameAs<i8>; });
STATIC_REQUIRE(requires(i8 lhs, i8 rhs) { { lhs / rhs } -> SameAs<i8>; });
STATIC_REQUIRE(requires(i8 lhs, i8 rhs) { { lhs % rhs } -> SameAs<i8>; });
STATIC_REQUIRE(requires(i8 lhs, i8 rhs) { { lhs += rhs } -> SameAs<i8&>; });
STATIC_REQUIRE(requires(i8 lhs, i8 rhs) { { lhs -= rhs } -> SameAs<i8&>; });
STATIC_REQUIRE(requires(i8 lhs, i8 rhs) { { lhs *= rhs } -> SameAs<i8&>; });
STATIC_REQUIRE(requires(i8 lhs, i8 rhs) { { lhs /= rhs } -> SameAs<i8&>; });
STATIC_REQUIRE(requires(i8 lhs, i8 rhs) { { lhs %= rhs } -> SameAs<i8&>; });
STATIC_REQUIRE(requires(i8 lhs, i16 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(i8 lhs, i16 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(i8 lhs, i16 rhs) { { lhs + rhs } -> SameAs<i16>; });
STATIC_REQUIRE(requires(i8 lhs, i16 rhs) { { lhs - rhs } -> SameAs<i16>; });
STATIC_REQUIRE(requires(i8 lhs, i16 rhs) { { lhs * rhs } -> SameAs<i16>; });
STATIC_REQUIRE(requires(i8 lhs, i16 rhs) { { lhs / rhs } -> SameAs<i16>; });
STATIC_REQUIRE(requires(i8 lhs, i16 rhs) { { lhs % rhs } -> SameAs<i16>; });
STATIC_REQUIRE(requires(i8 lhs, i32 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(i8 lhs, i32 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(i8 lhs, i32 rhs) { { lhs + rhs } -> SameAs<i32>; });
STATIC_REQUIRE(requires(i8 lhs, i32 rhs) { { lhs - rhs } -> SameAs<i32>; });
STATIC_REQUIRE(requires(i8 lhs, i32 rhs) { { lhs * rhs } -> SameAs<i32>; });
STATIC_REQUIRE(requires(i8 lhs, i32 rhs) { { lhs / rhs } -> SameAs<i32>; });
STATIC_REQUIRE(requires(i8 lhs, i32 rhs) { { lhs % rhs } -> SameAs<i32>; });
STATIC_REQUIRE(requires(i8 lhs, i32 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(i8 lhs, i64 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(i8 lhs, i64 rhs) { { lhs + rhs } -> SameAs<i64>; });
STATIC_REQUIRE(requires(i8 lhs, i64 rhs) { { lhs - rhs } -> SameAs<i64>; });
STATIC_REQUIRE(requires(i8 lhs, i64 rhs) { { lhs * rhs } -> SameAs<i64>; });
STATIC_REQUIRE(requires(i8 lhs, i64 rhs) { { lhs / rhs } -> SameAs<i64>; });
STATIC_REQUIRE(requires(i8 lhs, i64 rhs) { { lhs % rhs } -> SameAs<i64>; });
STATIC_REQUIRE(requires(I8 lhs, I8 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(I8 lhs, I8 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(I8 lhs, I8 rhs) { { lhs + rhs } -> SameAs<I8>; });
STATIC_REQUIRE(requires(I8 lhs, I8 rhs) { { lhs - rhs } -> SameAs<I8>; });
STATIC_REQUIRE(requires(I8 lhs, I8 rhs) { { lhs * rhs } -> SameAs<I8>; });
STATIC_REQUIRE(requires(I8 lhs, I8 rhs) { { lhs / rhs } -> SameAs<I8>; });
STATIC_REQUIRE(requires(I8 lhs, I8 rhs) { { lhs % rhs } -> SameAs<I8>; });
STATIC_REQUIRE(requires(I8 lhs, I8 rhs) { { lhs += rhs } -> SameAs<I8&>; });
STATIC_REQUIRE(requires(I8 lhs, I8 rhs) { { lhs -= rhs } -> SameAs<I8&>; });
STATIC_REQUIRE(requires(I8 lhs, I8 rhs) { { lhs *= rhs } -> SameAs<I8&>; });
STATIC_REQUIRE(requires(I8 lhs, I8 rhs) { { lhs /= rhs } -> SameAs<I8&>; });
STATIC_REQUIRE(requires(I8 lhs, I8 rhs) { { lhs %= rhs } -> SameAs<I8&>; });
STATIC_REQUIRE(requires(I8 lhs, I16 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(I8 lhs, I16 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(I8 lhs, I16 rhs) { { lhs + rhs } -> SameAs<I16>; });
STATIC_REQUIRE(requires(I8 lhs, I16 rhs) { { lhs - rhs } -> SameAs<I16>; });
STATIC_REQUIRE(requires(I8 lhs, I16 rhs) { { lhs * rhs } -> SameAs<I16>; });
STATIC_REQUIRE(requires(I8 lhs, I16 rhs) { { lhs / rhs } -> SameAs<I16>; });
STATIC_REQUIRE(requires(I8 lhs, I16 rhs) { { lhs % rhs } -> SameAs<I16>; });
STATIC_REQUIRE(requires(I8 lhs, I32 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(I8 lhs, I32 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(I8 lhs, I32 rhs) { { lhs + rhs } -> SameAs<I32>; });
STATIC_REQUIRE(requires(I8 lhs, I32 rhs) { { lhs - rhs } -> SameAs<I32>; });
STATIC_REQUIRE(requires(I8 lhs, I32 rhs) { { lhs * rhs } -> SameAs<I32>; });
STATIC_REQUIRE(requires(I8 lhs, I32 rhs) { { lhs / rhs } -> SameAs<I32>; });
STATIC_REQUIRE(requires(I8 lhs, I32 rhs) { { lhs % rhs } -> SameAs<I32>; });
STATIC_REQUIRE(requires(I8 lhs, I32 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(I8 lhs, I64 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(I8 lhs, I64 rhs) { { lhs + rhs } -> SameAs<I64>; });
STATIC_REQUIRE(requires(I8 lhs, I64 rhs) { { lhs - rhs } -> SameAs<I64>; });
STATIC_REQUIRE(requires(I8 lhs, I64 rhs) { { lhs * rhs } -> SameAs<I64>; });
STATIC_REQUIRE(requires(I8 lhs, I64 rhs) { { lhs / rhs } -> SameAs<I64>; });
STATIC_REQUIRE(requires(I8 lhs, I64 rhs) { { lhs % rhs } -> SameAs<I64>; });
// clang-format on
}
TEST_CASE("i16", "[integral/types/i16]")
TEST_CASE("I16", "[integral/types/I16]")
{
// clang-format off
STATIC_REQUIRE(requires(i16 lhs, i8 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(i16 lhs, i8 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(i16 lhs, i8 rhs) { { lhs + rhs } -> SameAs<i16>; });
STATIC_REQUIRE(requires(i16 lhs, i8 rhs) { { lhs - rhs } -> SameAs<i16>; });
STATIC_REQUIRE(requires(i16 lhs, i8 rhs) { { lhs * rhs } -> SameAs<i16>; });
STATIC_REQUIRE(requires(i16 lhs, i8 rhs) { { lhs / rhs } -> SameAs<i16>; });
STATIC_REQUIRE(requires(i16 lhs, i8 rhs) { { lhs % rhs } -> SameAs<i16>; });
STATIC_REQUIRE(requires(i16 lhs, i8 rhs) { { lhs += rhs } -> SameAs<i16&>; });
STATIC_REQUIRE(requires(i16 lhs, i8 rhs) { { lhs -= rhs } -> SameAs<i16&>; });
STATIC_REQUIRE(requires(i16 lhs, i8 rhs) { { lhs *= rhs } -> SameAs<i16&>; });
STATIC_REQUIRE(requires(i16 lhs, i8 rhs) { { lhs /= rhs } -> SameAs<i16&>; });
STATIC_REQUIRE(requires(i16 lhs, i8 rhs) { { lhs %= rhs } -> SameAs<i16&>; });
STATIC_REQUIRE(requires(i16 lhs, i16 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(i16 lhs, i16 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(i16 lhs, i16 rhs) { { lhs + rhs } -> SameAs<i16>; });
STATIC_REQUIRE(requires(i16 lhs, i16 rhs) { { lhs - rhs } -> SameAs<i16>; });
STATIC_REQUIRE(requires(i16 lhs, i16 rhs) { { lhs * rhs } -> SameAs<i16>; });
STATIC_REQUIRE(requires(i16 lhs, i16 rhs) { { lhs / rhs } -> SameAs<i16>; });
STATIC_REQUIRE(requires(i16 lhs, i16 rhs) { { lhs % rhs } -> SameAs<i16>; });
STATIC_REQUIRE(requires(i16 lhs, i16 rhs) { { lhs += rhs } -> SameAs<i16&>; });
STATIC_REQUIRE(requires(i16 lhs, i16 rhs) { { lhs -= rhs } -> SameAs<i16&>; });
STATIC_REQUIRE(requires(i16 lhs, i16 rhs) { { lhs *= rhs } -> SameAs<i16&>; });
STATIC_REQUIRE(requires(i16 lhs, i16 rhs) { { lhs /= rhs } -> SameAs<i16&>; });
STATIC_REQUIRE(requires(i16 lhs, i16 rhs) { { lhs %= rhs } -> SameAs<i16&>; });
STATIC_REQUIRE(requires(i16 lhs, i32 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(i16 lhs, i32 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(i16 lhs, i32 rhs) { { lhs + rhs } -> SameAs<i32>; });
STATIC_REQUIRE(requires(i16 lhs, i32 rhs) { { lhs - rhs } -> SameAs<i32>; });
STATIC_REQUIRE(requires(i16 lhs, i32 rhs) { { lhs * rhs } -> SameAs<i32>; });
STATIC_REQUIRE(requires(i16 lhs, i32 rhs) { { lhs / rhs } -> SameAs<i32>; });
STATIC_REQUIRE(requires(i16 lhs, i32 rhs) { { lhs % rhs } -> SameAs<i32>; });
STATIC_REQUIRE(requires(i16 lhs, i32 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(i16 lhs, i64 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(i16 lhs, i64 rhs) { { lhs + rhs } -> SameAs<i64>; });
STATIC_REQUIRE(requires(i16 lhs, i64 rhs) { { lhs - rhs } -> SameAs<i64>; });
STATIC_REQUIRE(requires(i16 lhs, i64 rhs) { { lhs * rhs } -> SameAs<i64>; });
STATIC_REQUIRE(requires(i16 lhs, i64 rhs) { { lhs / rhs } -> SameAs<i64>; });
STATIC_REQUIRE(requires(i16 lhs, i64 rhs) { { lhs % rhs } -> SameAs<i64>; });
STATIC_REQUIRE(requires(I16 lhs, I8 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(I16 lhs, I8 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(I16 lhs, I8 rhs) { { lhs + rhs } -> SameAs<I16>; });
STATIC_REQUIRE(requires(I16 lhs, I8 rhs) { { lhs - rhs } -> SameAs<I16>; });
STATIC_REQUIRE(requires(I16 lhs, I8 rhs) { { lhs * rhs } -> SameAs<I16>; });
STATIC_REQUIRE(requires(I16 lhs, I8 rhs) { { lhs / rhs } -> SameAs<I16>; });
STATIC_REQUIRE(requires(I16 lhs, I8 rhs) { { lhs % rhs } -> SameAs<I16>; });
STATIC_REQUIRE(requires(I16 lhs, I8 rhs) { { lhs += rhs } -> SameAs<I16&>; });
STATIC_REQUIRE(requires(I16 lhs, I8 rhs) { { lhs -= rhs } -> SameAs<I16&>; });
STATIC_REQUIRE(requires(I16 lhs, I8 rhs) { { lhs *= rhs } -> SameAs<I16&>; });
STATIC_REQUIRE(requires(I16 lhs, I8 rhs) { { lhs /= rhs } -> SameAs<I16&>; });
STATIC_REQUIRE(requires(I16 lhs, I8 rhs) { { lhs %= rhs } -> SameAs<I16&>; });
STATIC_REQUIRE(requires(I16 lhs, I16 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(I16 lhs, I16 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(I16 lhs, I16 rhs) { { lhs + rhs } -> SameAs<I16>; });
STATIC_REQUIRE(requires(I16 lhs, I16 rhs) { { lhs - rhs } -> SameAs<I16>; });
STATIC_REQUIRE(requires(I16 lhs, I16 rhs) { { lhs * rhs } -> SameAs<I16>; });
STATIC_REQUIRE(requires(I16 lhs, I16 rhs) { { lhs / rhs } -> SameAs<I16>; });
STATIC_REQUIRE(requires(I16 lhs, I16 rhs) { { lhs % rhs } -> SameAs<I16>; });
STATIC_REQUIRE(requires(I16 lhs, I16 rhs) { { lhs += rhs } -> SameAs<I16&>; });
STATIC_REQUIRE(requires(I16 lhs, I16 rhs) { { lhs -= rhs } -> SameAs<I16&>; });
STATIC_REQUIRE(requires(I16 lhs, I16 rhs) { { lhs *= rhs } -> SameAs<I16&>; });
STATIC_REQUIRE(requires(I16 lhs, I16 rhs) { { lhs /= rhs } -> SameAs<I16&>; });
STATIC_REQUIRE(requires(I16 lhs, I16 rhs) { { lhs %= rhs } -> SameAs<I16&>; });
STATIC_REQUIRE(requires(I16 lhs, I32 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(I16 lhs, I32 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(I16 lhs, I32 rhs) { { lhs + rhs } -> SameAs<I32>; });
STATIC_REQUIRE(requires(I16 lhs, I32 rhs) { { lhs - rhs } -> SameAs<I32>; });
STATIC_REQUIRE(requires(I16 lhs, I32 rhs) { { lhs * rhs } -> SameAs<I32>; });
STATIC_REQUIRE(requires(I16 lhs, I32 rhs) { { lhs / rhs } -> SameAs<I32>; });
STATIC_REQUIRE(requires(I16 lhs, I32 rhs) { { lhs % rhs } -> SameAs<I32>; });
STATIC_REQUIRE(requires(I16 lhs, I32 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(I16 lhs, I64 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(I16 lhs, I64 rhs) { { lhs + rhs } -> SameAs<I64>; });
STATIC_REQUIRE(requires(I16 lhs, I64 rhs) { { lhs - rhs } -> SameAs<I64>; });
STATIC_REQUIRE(requires(I16 lhs, I64 rhs) { { lhs * rhs } -> SameAs<I64>; });
STATIC_REQUIRE(requires(I16 lhs, I64 rhs) { { lhs / rhs } -> SameAs<I64>; });
STATIC_REQUIRE(requires(I16 lhs, I64 rhs) { { lhs % rhs } -> SameAs<I64>; });
// clang-format on
}
TEST_CASE("i32", "[integral/types/i32]")
TEST_CASE("I32", "[integral/types/I32]")
{
// clang-format off
STATIC_REQUIRE(requires(i32 lhs, i8 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(i32 lhs, i8 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(i32 lhs, i8 rhs) { { lhs + rhs } -> SameAs<i32>; });
STATIC_REQUIRE(requires(i32 lhs, i8 rhs) { { lhs - rhs } -> SameAs<i32>; });
STATIC_REQUIRE(requires(i32 lhs, i8 rhs) { { lhs * rhs } -> SameAs<i32>; });
STATIC_REQUIRE(requires(i32 lhs, i8 rhs) { { lhs / rhs } -> SameAs<i32>; });
STATIC_REQUIRE(requires(i32 lhs, i8 rhs) { { lhs % rhs } -> SameAs<i32>; });
STATIC_REQUIRE(requires(i32 lhs, i8 rhs) { { lhs += rhs } -> SameAs<i32&>; });
STATIC_REQUIRE(requires(i32 lhs, i8 rhs) { { lhs -= rhs } -> SameAs<i32&>; });
STATIC_REQUIRE(requires(i32 lhs, i8 rhs) { { lhs *= rhs } -> SameAs<i32&>; });
STATIC_REQUIRE(requires(i32 lhs, i8 rhs) { { lhs /= rhs } -> SameAs<i32&>; });
STATIC_REQUIRE(requires(i32 lhs, i8 rhs) { { lhs %= rhs } -> SameAs<i32&>; });
STATIC_REQUIRE(requires(i32 lhs, i16 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(i32 lhs, i16 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(i32 lhs, i16 rhs) { { lhs + rhs } -> SameAs<i32>; });
STATIC_REQUIRE(requires(i32 lhs, i16 rhs) { { lhs - rhs } -> SameAs<i32>; });
STATIC_REQUIRE(requires(i32 lhs, i16 rhs) { { lhs * rhs } -> SameAs<i32>; });
STATIC_REQUIRE(requires(i32 lhs, i16 rhs) { { lhs / rhs } -> SameAs<i32>; });
STATIC_REQUIRE(requires(i32 lhs, i16 rhs) { { lhs % rhs } -> SameAs<i32>; });
STATIC_REQUIRE(requires(i32 lhs, i16 rhs) { { lhs += rhs } -> SameAs<i32&>; });
STATIC_REQUIRE(requires(i32 lhs, i16 rhs) { { lhs -= rhs } -> SameAs<i32&>; });
STATIC_REQUIRE(requires(i32 lhs, i16 rhs) { { lhs *= rhs } -> SameAs<i32&>; });
STATIC_REQUIRE(requires(i32 lhs, i16 rhs) { { lhs /= rhs } -> SameAs<i32&>; });
STATIC_REQUIRE(requires(i32 lhs, i16 rhs) { { lhs %= rhs } -> SameAs<i32&>; });
STATIC_REQUIRE(requires(i32 lhs, i32 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(i32 lhs, i32 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(i32 lhs, i32 rhs) { { lhs + rhs } -> SameAs<i32>; });
STATIC_REQUIRE(requires(i32 lhs, i32 rhs) { { lhs - rhs } -> SameAs<i32>; });
STATIC_REQUIRE(requires(i32 lhs, i32 rhs) { { lhs * rhs } -> SameAs<i32>; });
STATIC_REQUIRE(requires(i32 lhs, i32 rhs) { { lhs / rhs } -> SameAs<i32>; });
STATIC_REQUIRE(requires(i32 lhs, i32 rhs) { { lhs % rhs } -> SameAs<i32>; });
STATIC_REQUIRE(requires(i32 lhs, i32 rhs) { { lhs += rhs } -> SameAs<i32&>; });
STATIC_REQUIRE(requires(i32 lhs, i32 rhs) { { lhs -= rhs } -> SameAs<i32&>; });
STATIC_REQUIRE(requires(i32 lhs, i32 rhs) { { lhs *= rhs } -> SameAs<i32&>; });
STATIC_REQUIRE(requires(i32 lhs, i32 rhs) { { lhs /= rhs } -> SameAs<i32&>; });
STATIC_REQUIRE(requires(i32 lhs, i32 rhs) { { lhs %= rhs } -> SameAs<i32&>; });
STATIC_REQUIRE(requires(i32 lhs, i32 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(i32 lhs, i64 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(i32 lhs, i64 rhs) { { lhs + rhs } -> SameAs<i64>; });
STATIC_REQUIRE(requires(i32 lhs, i64 rhs) { { lhs - rhs } -> SameAs<i64>; });
STATIC_REQUIRE(requires(i32 lhs, i64 rhs) { { lhs * rhs } -> SameAs<i64>; });
STATIC_REQUIRE(requires(i32 lhs, i64 rhs) { { lhs / rhs } -> SameAs<i64>; });
STATIC_REQUIRE(requires(i32 lhs, i64 rhs) { { lhs % rhs } -> SameAs<i64>; });
STATIC_REQUIRE(requires(I32 lhs, I8 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(I32 lhs, I8 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(I32 lhs, I8 rhs) { { lhs + rhs } -> SameAs<I32>; });
STATIC_REQUIRE(requires(I32 lhs, I8 rhs) { { lhs - rhs } -> SameAs<I32>; });
STATIC_REQUIRE(requires(I32 lhs, I8 rhs) { { lhs * rhs } -> SameAs<I32>; });
STATIC_REQUIRE(requires(I32 lhs, I8 rhs) { { lhs / rhs } -> SameAs<I32>; });
STATIC_REQUIRE(requires(I32 lhs, I8 rhs) { { lhs % rhs } -> SameAs<I32>; });
STATIC_REQUIRE(requires(I32 lhs, I8 rhs) { { lhs += rhs } -> SameAs<I32&>; });
STATIC_REQUIRE(requires(I32 lhs, I8 rhs) { { lhs -= rhs } -> SameAs<I32&>; });
STATIC_REQUIRE(requires(I32 lhs, I8 rhs) { { lhs *= rhs } -> SameAs<I32&>; });
STATIC_REQUIRE(requires(I32 lhs, I8 rhs) { { lhs /= rhs } -> SameAs<I32&>; });
STATIC_REQUIRE(requires(I32 lhs, I8 rhs) { { lhs %= rhs } -> SameAs<I32&>; });
STATIC_REQUIRE(requires(I32 lhs, I16 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(I32 lhs, I16 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(I32 lhs, I16 rhs) { { lhs + rhs } -> SameAs<I32>; });
STATIC_REQUIRE(requires(I32 lhs, I16 rhs) { { lhs - rhs } -> SameAs<I32>; });
STATIC_REQUIRE(requires(I32 lhs, I16 rhs) { { lhs * rhs } -> SameAs<I32>; });
STATIC_REQUIRE(requires(I32 lhs, I16 rhs) { { lhs / rhs } -> SameAs<I32>; });
STATIC_REQUIRE(requires(I32 lhs, I16 rhs) { { lhs % rhs } -> SameAs<I32>; });
STATIC_REQUIRE(requires(I32 lhs, I16 rhs) { { lhs += rhs } -> SameAs<I32&>; });
STATIC_REQUIRE(requires(I32 lhs, I16 rhs) { { lhs -= rhs } -> SameAs<I32&>; });
STATIC_REQUIRE(requires(I32 lhs, I16 rhs) { { lhs *= rhs } -> SameAs<I32&>; });
STATIC_REQUIRE(requires(I32 lhs, I16 rhs) { { lhs /= rhs } -> SameAs<I32&>; });
STATIC_REQUIRE(requires(I32 lhs, I16 rhs) { { lhs %= rhs } -> SameAs<I32&>; });
STATIC_REQUIRE(requires(I32 lhs, I32 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(I32 lhs, I32 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(I32 lhs, I32 rhs) { { lhs + rhs } -> SameAs<I32>; });
STATIC_REQUIRE(requires(I32 lhs, I32 rhs) { { lhs - rhs } -> SameAs<I32>; });
STATIC_REQUIRE(requires(I32 lhs, I32 rhs) { { lhs * rhs } -> SameAs<I32>; });
STATIC_REQUIRE(requires(I32 lhs, I32 rhs) { { lhs / rhs } -> SameAs<I32>; });
STATIC_REQUIRE(requires(I32 lhs, I32 rhs) { { lhs % rhs } -> SameAs<I32>; });
STATIC_REQUIRE(requires(I32 lhs, I32 rhs) { { lhs += rhs } -> SameAs<I32&>; });
STATIC_REQUIRE(requires(I32 lhs, I32 rhs) { { lhs -= rhs } -> SameAs<I32&>; });
STATIC_REQUIRE(requires(I32 lhs, I32 rhs) { { lhs *= rhs } -> SameAs<I32&>; });
STATIC_REQUIRE(requires(I32 lhs, I32 rhs) { { lhs /= rhs } -> SameAs<I32&>; });
STATIC_REQUIRE(requires(I32 lhs, I32 rhs) { { lhs %= rhs } -> SameAs<I32&>; });
STATIC_REQUIRE(requires(I32 lhs, I32 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(I32 lhs, I64 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(I32 lhs, I64 rhs) { { lhs + rhs } -> SameAs<I64>; });
STATIC_REQUIRE(requires(I32 lhs, I64 rhs) { { lhs - rhs } -> SameAs<I64>; });
STATIC_REQUIRE(requires(I32 lhs, I64 rhs) { { lhs * rhs } -> SameAs<I64>; });
STATIC_REQUIRE(requires(I32 lhs, I64 rhs) { { lhs / rhs } -> SameAs<I64>; });
STATIC_REQUIRE(requires(I32 lhs, I64 rhs) { { lhs % rhs } -> SameAs<I64>; });
// clang-format on
}
TEST_CASE("i64", "[integral/types/i64]")
TEST_CASE("I64", "[integral/types/I64]")
{
// clang-format off
STATIC_REQUIRE(requires(i64 lhs, i8 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(i64 lhs, i8 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(i64 lhs, i8 rhs) { { lhs + rhs } -> SameAs<i64>; });
STATIC_REQUIRE(requires(i64 lhs, i8 rhs) { { lhs - rhs } -> SameAs<i64>; });
STATIC_REQUIRE(requires(i64 lhs, i8 rhs) { { lhs * rhs } -> SameAs<i64>; });
STATIC_REQUIRE(requires(i64 lhs, i8 rhs) { { lhs / rhs } -> SameAs<i64>; });
STATIC_REQUIRE(requires(i64 lhs, i8 rhs) { { lhs % rhs } -> SameAs<i64>; });
STATIC_REQUIRE(requires(i64 lhs, i8 rhs) { { lhs += rhs } -> SameAs<i64&>; });
STATIC_REQUIRE(requires(i64 lhs, i8 rhs) { { lhs -= rhs } -> SameAs<i64&>; });
STATIC_REQUIRE(requires(i64 lhs, i8 rhs) { { lhs *= rhs } -> SameAs<i64&>; });
STATIC_REQUIRE(requires(i64 lhs, i8 rhs) { { lhs /= rhs } -> SameAs<i64&>; });
STATIC_REQUIRE(requires(i64 lhs, i8 rhs) { { lhs %= rhs } -> SameAs<i64&>; });
STATIC_REQUIRE(requires(i64 lhs, i16 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(i64 lhs, i16 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(i64 lhs, i16 rhs) { { lhs + rhs } -> SameAs<i64>; });
STATIC_REQUIRE(requires(i64 lhs, i16 rhs) { { lhs - rhs } -> SameAs<i64>; });
STATIC_REQUIRE(requires(i64 lhs, i16 rhs) { { lhs * rhs } -> SameAs<i64>; });
STATIC_REQUIRE(requires(i64 lhs, i16 rhs) { { lhs / rhs } -> SameAs<i64>; });
STATIC_REQUIRE(requires(i64 lhs, i16 rhs) { { lhs % rhs } -> SameAs<i64>; });
STATIC_REQUIRE(requires(i64 lhs, i16 rhs) { { lhs += rhs } -> SameAs<i64&>; });
STATIC_REQUIRE(requires(i64 lhs, i16 rhs) { { lhs -= rhs } -> SameAs<i64&>; });
STATIC_REQUIRE(requires(i64 lhs, i16 rhs) { { lhs *= rhs } -> SameAs<i64&>; });
STATIC_REQUIRE(requires(i64 lhs, i16 rhs) { { lhs /= rhs } -> SameAs<i64&>; });
STATIC_REQUIRE(requires(i64 lhs, i16 rhs) { { lhs %= rhs } -> SameAs<i64&>; });
STATIC_REQUIRE(requires(i64 lhs, i32 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(i64 lhs, i32 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(i64 lhs, i32 rhs) { { lhs + rhs } -> SameAs<i64>; });
STATIC_REQUIRE(requires(i64 lhs, i32 rhs) { { lhs - rhs } -> SameAs<i64>; });
STATIC_REQUIRE(requires(i64 lhs, i32 rhs) { { lhs * rhs } -> SameAs<i64>; });
STATIC_REQUIRE(requires(i64 lhs, i32 rhs) { { lhs / rhs } -> SameAs<i64>; });
STATIC_REQUIRE(requires(i64 lhs, i32 rhs) { { lhs % rhs } -> SameAs<i64>; });
STATIC_REQUIRE(requires(i64 lhs, i32 rhs) { { lhs += rhs } -> SameAs<i64&>; });
STATIC_REQUIRE(requires(i64 lhs, i32 rhs) { { lhs -= rhs } -> SameAs<i64&>; });
STATIC_REQUIRE(requires(i64 lhs, i32 rhs) { { lhs *= rhs } -> SameAs<i64&>; });
STATIC_REQUIRE(requires(i64 lhs, i32 rhs) { { lhs /= rhs } -> SameAs<i64&>; });
STATIC_REQUIRE(requires(i64 lhs, i32 rhs) { { lhs %= rhs } -> SameAs<i64&>; });
STATIC_REQUIRE(requires(i64 lhs, i32 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(i64 lhs, i64 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(i64 lhs, i64 rhs) { { lhs + rhs } -> SameAs<i64>; });
STATIC_REQUIRE(requires(i64 lhs, i64 rhs) { { lhs - rhs } -> SameAs<i64>; });
STATIC_REQUIRE(requires(i64 lhs, i64 rhs) { { lhs * rhs } -> SameAs<i64>; });
STATIC_REQUIRE(requires(i64 lhs, i64 rhs) { { lhs / rhs } -> SameAs<i64>; });
STATIC_REQUIRE(requires(i64 lhs, i64 rhs) { { lhs % rhs } -> SameAs<i64>; });
STATIC_REQUIRE(requires(i64 lhs, i64 rhs) { { lhs += rhs } -> SameAs<i64&>; });
STATIC_REQUIRE(requires(i64 lhs, i64 rhs) { { lhs -= rhs } -> SameAs<i64&>; });
STATIC_REQUIRE(requires(i64 lhs, i64 rhs) { { lhs *= rhs } -> SameAs<i64&>; });
STATIC_REQUIRE(requires(i64 lhs, i64 rhs) { { lhs /= rhs } -> SameAs<i64&>; });
STATIC_REQUIRE(requires(i64 lhs, i64 rhs) { { lhs %= rhs } -> SameAs<i64&>; });
STATIC_REQUIRE(requires(I64 lhs, I8 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(I64 lhs, I8 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(I64 lhs, I8 rhs) { { lhs + rhs } -> SameAs<I64>; });
STATIC_REQUIRE(requires(I64 lhs, I8 rhs) { { lhs - rhs } -> SameAs<I64>; });
STATIC_REQUIRE(requires(I64 lhs, I8 rhs) { { lhs * rhs } -> SameAs<I64>; });
STATIC_REQUIRE(requires(I64 lhs, I8 rhs) { { lhs / rhs } -> SameAs<I64>; });
STATIC_REQUIRE(requires(I64 lhs, I8 rhs) { { lhs % rhs } -> SameAs<I64>; });
STATIC_REQUIRE(requires(I64 lhs, I8 rhs) { { lhs += rhs } -> SameAs<I64&>; });
STATIC_REQUIRE(requires(I64 lhs, I8 rhs) { { lhs -= rhs } -> SameAs<I64&>; });
STATIC_REQUIRE(requires(I64 lhs, I8 rhs) { { lhs *= rhs } -> SameAs<I64&>; });
STATIC_REQUIRE(requires(I64 lhs, I8 rhs) { { lhs /= rhs } -> SameAs<I64&>; });
STATIC_REQUIRE(requires(I64 lhs, I8 rhs) { { lhs %= rhs } -> SameAs<I64&>; });
STATIC_REQUIRE(requires(I64 lhs, I16 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(I64 lhs, I16 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(I64 lhs, I16 rhs) { { lhs + rhs } -> SameAs<I64>; });
STATIC_REQUIRE(requires(I64 lhs, I16 rhs) { { lhs - rhs } -> SameAs<I64>; });
STATIC_REQUIRE(requires(I64 lhs, I16 rhs) { { lhs * rhs } -> SameAs<I64>; });
STATIC_REQUIRE(requires(I64 lhs, I16 rhs) { { lhs / rhs } -> SameAs<I64>; });
STATIC_REQUIRE(requires(I64 lhs, I16 rhs) { { lhs % rhs } -> SameAs<I64>; });
STATIC_REQUIRE(requires(I64 lhs, I16 rhs) { { lhs += rhs } -> SameAs<I64&>; });
STATIC_REQUIRE(requires(I64 lhs, I16 rhs) { { lhs -= rhs } -> SameAs<I64&>; });
STATIC_REQUIRE(requires(I64 lhs, I16 rhs) { { lhs *= rhs } -> SameAs<I64&>; });
STATIC_REQUIRE(requires(I64 lhs, I16 rhs) { { lhs /= rhs } -> SameAs<I64&>; });
STATIC_REQUIRE(requires(I64 lhs, I16 rhs) { { lhs %= rhs } -> SameAs<I64&>; });
STATIC_REQUIRE(requires(I64 lhs, I32 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(I64 lhs, I32 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(I64 lhs, I32 rhs) { { lhs + rhs } -> SameAs<I64>; });
STATIC_REQUIRE(requires(I64 lhs, I32 rhs) { { lhs - rhs } -> SameAs<I64>; });
STATIC_REQUIRE(requires(I64 lhs, I32 rhs) { { lhs * rhs } -> SameAs<I64>; });
STATIC_REQUIRE(requires(I64 lhs, I32 rhs) { { lhs / rhs } -> SameAs<I64>; });
STATIC_REQUIRE(requires(I64 lhs, I32 rhs) { { lhs % rhs } -> SameAs<I64>; });
STATIC_REQUIRE(requires(I64 lhs, I32 rhs) { { lhs += rhs } -> SameAs<I64&>; });
STATIC_REQUIRE(requires(I64 lhs, I32 rhs) { { lhs -= rhs } -> SameAs<I64&>; });
STATIC_REQUIRE(requires(I64 lhs, I32 rhs) { { lhs *= rhs } -> SameAs<I64&>; });
STATIC_REQUIRE(requires(I64 lhs, I32 rhs) { { lhs /= rhs } -> SameAs<I64&>; });
STATIC_REQUIRE(requires(I64 lhs, I32 rhs) { { lhs %= rhs } -> SameAs<I64&>; });
STATIC_REQUIRE(requires(I64 lhs, I32 rhs) { { lhs == rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(I64 lhs, I64 rhs) { { lhs <= rhs } -> SameAs<bool>; });
STATIC_REQUIRE(requires(I64 lhs, I64 rhs) { { lhs + rhs } -> SameAs<I64>; });
STATIC_REQUIRE(requires(I64 lhs, I64 rhs) { { lhs - rhs } -> SameAs<I64>; });
STATIC_REQUIRE(requires(I64 lhs, I64 rhs) { { lhs * rhs } -> SameAs<I64>; });
STATIC_REQUIRE(requires(I64 lhs, I64 rhs) { { lhs / rhs } -> SameAs<I64>; });
STATIC_REQUIRE(requires(I64 lhs, I64 rhs) { { lhs % rhs } -> SameAs<I64>; });
STATIC_REQUIRE(requires(I64 lhs, I64 rhs) { { lhs += rhs } -> SameAs<I64&>; });
STATIC_REQUIRE(requires(I64 lhs, I64 rhs) { { lhs -= rhs } -> SameAs<I64&>; });
STATIC_REQUIRE(requires(I64 lhs, I64 rhs) { { lhs *= rhs } -> SameAs<I64&>; });
STATIC_REQUIRE(requires(I64 lhs, I64 rhs) { { lhs /= rhs } -> SameAs<I64&>; });
STATIC_REQUIRE(requires(I64 lhs, I64 rhs) { { lhs %= rhs } -> SameAs<I64&>; });
// clang-format on
}
diff --git a/ test/source/string/literal_test.cpp b/ test/source/string/literal_test.cpp
@@ -4,7 +4,7 @@
TEST_CASE("empty", "[string/literal]")
{
const based::string_literal sltr = "";
const based::StringLiteral sltr = "";
REQUIRE(sltr.size() == 0);
REQUIRE(std::memcmp(sltr.data(), "", sltr.size()) == 0);
@@ -12,7 +12,7 @@
TEST_CASE("empty", "[string/literal]")
TEST_CASE("nonempty", "[string/literal]")
{
const based::string_literal sltr = "nonempty";
const based::StringLiteral sltr = "nonempty";
REQUIRE(sltr.size() == 8);
REQUIRE(std::memcmp(sltr.data(), "nonempty", sltr.size()) == 0);
@@ -20,12 +20,12 @@
TEST_CASE("nonempty", "[string/literal]")
TEST_CASE("template", "[string/literal]")
{
const auto data = []<based::string_literal l>()
const auto data = []<based::StringLiteral l>()
{
return l.data();
};
const auto size = []<based::string_literal l>()
const auto size = []<based::StringLiteral l>()
{
return l.size();
};
diff --git a/ test/source/trait/invoke_result_test.cpp b/ test/source/trait/invoke_result_test.cpp
@@ -15,16 +15,16 @@
int func(double);
} // namespace
template<class Res, class T, class... Args>
concept test = based::SameAs<based::invoke_result_t<T, Args...>, Res>;
concept Test = based::SameAs<based::invoke_result_t<T, Args...>, Res>;
TEST_CASE("invoke_result", "[trait/invoke_result]")
{
// NOLINTBEGIN(*array*)
// clang-format off
STATIC_REQUIRE(test<int, decltype(func), double>);
STATIC_REQUIRE(test<int, decltype(func), int>);
STATIC_REQUIRE(!test<int, decltype(func), decltype(func)>);
STATIC_REQUIRE(Test<int, decltype(func), double>);
STATIC_REQUIRE(Test<int, decltype(func), int>);
STATIC_REQUIRE(!Test<int, decltype(func), decltype(func)>);
// clang-format on
// NOLINTEND(*array*)
diff --git a/ test/source/trait/is_array_test.cpp b/ test/source/trait/is_array_test.cpp
@@ -7,12 +7,12 @@
TEST_CASE("is_array", "[trait/is_array]")
{
// clang-format off
struct test {};
struct Test {};
// NOLINTBEGIN(*array*)
STATIC_REQUIRE(!based::is_array_v<test>);
STATIC_REQUIRE(based::is_array_v<test[]>);
STATIC_REQUIRE(based::is_array_v<test[3]>);
STATIC_REQUIRE(!based::is_array_v<Test>);
STATIC_REQUIRE(based::is_array_v<Test[]>);
STATIC_REQUIRE(based::is_array_v<Test[3]>);
STATIC_REQUIRE(!based::is_array_v<float>);
STATIC_REQUIRE(!based::is_array_v<int>);
STATIC_REQUIRE(based::is_array_v<int[]>);
diff --git a/ test/source/trait/is_base_of_test.cpp b/ test/source/trait/is_base_of_test.cpp
@@ -7,18 +7,18 @@
TEST_CASE("is_base_of", "[trait/is_base_of]")
{
// clang-format off
class a {};
class b : a {};
class c : b {};
class d {};
class A {};
class B : A {};
class C : B {};
class D {};
union e {};
using i = int;
STATIC_REQUIRE(based::is_base_of_v<a, a>);
STATIC_REQUIRE(based::is_base_of_v<a, b>);
STATIC_REQUIRE(based::is_base_of_v<a, c>);
STATIC_REQUIRE(!based::is_base_of_v<a, d>);
STATIC_REQUIRE(!based::is_base_of_v<b, a>);
STATIC_REQUIRE(based::is_base_of_v<A, A>);
STATIC_REQUIRE(based::is_base_of_v<A, B>);
STATIC_REQUIRE(based::is_base_of_v<A, C>);
STATIC_REQUIRE(!based::is_base_of_v<A, D>);
STATIC_REQUIRE(!based::is_base_of_v<B, A>);
STATIC_REQUIRE(!based::is_base_of_v<e, e>);
STATIC_REQUIRE(!based::is_base_of_v<i, i>);
// clang-format on
diff --git a/ test/source/trait/is_class_test.cpp b/ test/source/trait/is_class_test.cpp
@@ -7,19 +7,19 @@
TEST_CASE("is_class", "[trait/is_class]")
{
// clang-format off
struct a {};
class b {};
struct A {};
class B {};
enum class e {};
union u { class uc {}; };
union u { class Uc {}; };
STATIC_REQUIRE(based::is_class<a>::value);
STATIC_REQUIRE(based::is_class_v<b>);
STATIC_REQUIRE(!based::is_class_v<b*>);
STATIC_REQUIRE(!based::is_class_v<b&>);
STATIC_REQUIRE(based::is_class_v<const b>);
STATIC_REQUIRE(!based::is_class<e>::value);
STATIC_REQUIRE(std::is_class<A>::value);
STATIC_REQUIRE(based::is_class_v<B>);
STATIC_REQUIRE(!based::is_class_v<B*>);
STATIC_REQUIRE(!based::is_class_v<B&>);
STATIC_REQUIRE(based::is_class_v<const B>);
STATIC_REQUIRE(!std::is_class<e>::value);
STATIC_REQUIRE(!based::is_class_v<u>);
STATIC_REQUIRE(based::is_class_v<u::uc>);
STATIC_REQUIRE(based::is_class_v<u::Uc>);
STATIC_REQUIRE(!based::is_class_v<int>);
// clang-format on
}
diff --git a/ test/source/trait/is_const_test.cpp b/ test/source/trait/is_const_test.cpp
@@ -7,7 +7,7 @@
TEST_CASE("is_const", "[trait/is_const]")
{
// clang-format off
struct test {};
struct Test {};
// NOLINTBEGIN(*array*)
STATIC_REQUIRE(!based::is_const_v<int>);
diff --git a/ test/source/trait/is_enum_test.cpp b/ test/source/trait/is_enum_test.cpp
@@ -7,12 +7,12 @@
TEST_CASE("is_enum", "[trait/is_enum]")
{
// clang-format off
struct a { enum e {}; };
struct A { enum e {}; };
enum e {};
enum class ec : int {};
STATIC_REQUIRE(!based::is_enum_v<a>);
STATIC_REQUIRE(based::is_enum_v<a::e>);
STATIC_REQUIRE(!based::is_enum_v<A>);
STATIC_REQUIRE(based::is_enum_v<A::e>);
STATIC_REQUIRE(based::is_enum_v<e>);
STATIC_REQUIRE(based::is_enum_v<ec>);
STATIC_REQUIRE(!based::is_enum_v<int>);
diff --git a/ test/source/trait/is_null_pointer_test.cpp b/ test/source/trait/is_null_pointer_test.cpp
@@ -6,7 +6,7 @@
TEST_CASE("is_null_pointer", "[trait/is_null_pointer]")
{
double test = 0;
double const test = 0;
// NOLINTBEGIN(*array*)
// clang-format off
diff --git a/ test/source/trait/is_void_test.cpp b/ test/source/trait/is_void_test.cpp
@@ -6,7 +6,7 @@
TEST_CASE("is_void", "[trait/is_void]")
{
double test = 0;
double const test = 0;
// NOLINTBEGIN(*array*)
// clang-format off
diff --git a/ test/source/trait/signature_test.cpp b/ test/source/trait/signature_test.cpp
@@ -0,0 +1,479 @@
#define CATCH_CONFIG_RUNTIME_STATIC_REQUIRE
#include "based/trait/signature.hpp"
#include <catch2/catch_test_macros.hpp>
#include "based/concept/is/same.hpp"
// NOLINTBEGIN(*cognitive-complexity*)
namespace
{
// NOLINTNEXTLINE (*needed*)
int free_func(const double& a, int&& b) noexcept(false)
{
return static_cast<int>(a + b);
}
// NOLINTNEXTLINE (*needed*)
int free_func_noexcept(const double& a, int&& b) noexcept(true)
{
return static_cast<int>(a + b);
}
} // namespace
using based::SameAs;
TEST_CASE("free function", "[trait/Signature]")
{
using sig = based::Signature<decltype(free_func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::false_type, sig::noexcept_val>);
}
TEST_CASE("free function noexcept", "[trait/Signature]")
{
using sig = based::Signature<decltype(free_func_noexcept)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::true_type, sig::noexcept_val>);
}
TEST_CASE("empty", "[trait/Signature]")
{
struct Test
{
int func(const double& a, int&& b) noexcept(false);
};
using sig = based::Signature<decltype(&Test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::false_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::noexcept_val>);
}
TEST_CASE("const", "[trait/Signature]")
{
struct Test
{
int func(const double& a, int&& b) const noexcept(false);
};
using sig = based::Signature<decltype(&Test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::true_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::noexcept_val>);
}
TEST_CASE("volatile", "[trait/Signature]")
{
struct Test
{
int func(const double& a, int&& b) volatile noexcept(false);
};
using sig = based::Signature<decltype(&Test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::false_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::noexcept_val>);
}
TEST_CASE("const volatile", "[trait/Signature]")
{
struct Test
{
int func(const double& a, int&& b) const volatile noexcept(false);
};
using sig = based::Signature<decltype(&Test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::true_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::noexcept_val>);
}
TEST_CASE("noexcept", "[trait/Signature]")
{
struct Test
{
int func(const double& a, int&& b) noexcept(true);
};
using sig = based::Signature<decltype(&Test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::false_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::noexcept_val>);
}
TEST_CASE("const noexcept", "[trait/Signature]")
{
struct Test
{
int func(const double& a, int&& b) const noexcept(true);
};
using sig = based::Signature<decltype(&Test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::true_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::noexcept_val>);
}
TEST_CASE("volatile noexcept", "[trait/Signature]")
{
struct Test
{
int func(const double& a, int&& b) volatile noexcept(true);
};
using sig = based::Signature<decltype(&Test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::false_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::noexcept_val>);
}
TEST_CASE("const volatile noexcept", "[trait/Signature]")
{
struct Test
{
int func(const double& a, int&& b) const volatile noexcept(true);
};
using sig = based::Signature<decltype(&Test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::true_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::noexcept_val>);
}
TEST_CASE("lvalref", "[trait/Signature]")
{
struct Test
{
int func(const double& a, int&& b) & noexcept(false);
};
using sig = based::Signature<decltype(&Test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::false_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::noexcept_val>);
}
TEST_CASE("const lvalref", "[trait/Signature]")
{
struct Test
{
int func(const double& a, int&& b) const& noexcept(false);
};
using sig = based::Signature<decltype(&Test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::true_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::noexcept_val>);
}
TEST_CASE("volatile lvalref", "[trait/Signature]")
{
struct Test
{
int func(const double& a, int&& b) volatile& noexcept(false);
};
using sig = based::Signature<decltype(&Test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::false_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::noexcept_val>);
}
TEST_CASE("const volatile lvalref", "[trait/Signature]")
{
struct Test
{
int func(const double& a, int&& b) const volatile& noexcept(false);
};
using sig = based::Signature<decltype(&Test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::true_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::noexcept_val>);
}
TEST_CASE("noexcept lvalref", "[trait/Signature]")
{
struct Test
{
int func(const double& a, int&& b) & noexcept(true);
};
using sig = based::Signature<decltype(&Test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::false_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::noexcept_val>);
}
TEST_CASE("const noexcept lvalref", "[trait/Signature]")
{
struct Test
{
int func(const double& a, int&& b) const& noexcept(true);
};
using sig = based::Signature<decltype(&Test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::true_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::noexcept_val>);
}
TEST_CASE("volatile noexcept lvalref", "[trait/Signature]")
{
struct Test
{
int func(const double& a, int&& b) volatile& noexcept(true);
};
using sig = based::Signature<decltype(&Test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::false_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::noexcept_val>);
}
TEST_CASE("const volatile noexcept lvalref", "[trait/Signature]")
{
struct Test
{
int func(const double& a, int&& b) const volatile& noexcept(true);
};
using sig = based::Signature<decltype(&Test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::true_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::noexcept_val>);
}
TEST_CASE("rvalref", "[trait/Signature]")
{
struct Test
{
int func(const double& a, int&& b) && noexcept(false);
};
using sig = based::Signature<decltype(&Test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::false_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::noexcept_val>);
}
TEST_CASE("const rvalref", "[trait/Signature]")
{
struct Test
{
int func(const double& a, int&& b) const&& noexcept(false);
};
using sig = based::Signature<decltype(&Test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::true_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::noexcept_val>);
}
TEST_CASE("volatile rvalref", "[trait/Signature]")
{
struct Test
{
int func(const double& a, int&& b) volatile&& noexcept(false);
};
using sig = based::Signature<decltype(&Test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::false_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::noexcept_val>);
}
TEST_CASE("const volatile rvalref", "[trait/Signature]")
{
struct Test
{
int func(const double& a, int&& b) const volatile&& noexcept(false);
};
using sig = based::Signature<decltype(&Test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::true_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::noexcept_val>);
}
TEST_CASE("noexcept rvalref", "[trait/Signature]")
{
struct Test
{
int func(const double& a, int&& b) && noexcept(true);
};
using sig = based::Signature<decltype(&Test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::false_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::noexcept_val>);
}
TEST_CASE("const noexcept rvalref", "[trait/Signature]")
{
struct Test
{
int func(const double& a, int&& b) const&& noexcept(true);
};
using sig = based::Signature<decltype(&Test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::true_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::noexcept_val>);
}
TEST_CASE("volatile noexcept rvalref", "[trait/Signature]")
{
struct Test
{
int func(const double& a, int&& b) volatile&& noexcept(true);
};
using sig = based::Signature<decltype(&Test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::false_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::noexcept_val>);
}
TEST_CASE("const volatile noexcept rvalref", "[trait/Signature]")
{
struct Test
{
int func(const double& a, int&& b) const volatile&& noexcept(true);
};
using sig = based::Signature<decltype(&Test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::true_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::noexcept_val>);
}
// NOLINTEND(*cognitive-complexity*)
diff --git a/ test/source/trait/signature_test_test.cpp b/ test/source/trait/signature_test_test.cpp
@@ -1,480 +0,0 @@
#define CATCH_CONFIG_RUNTIME_STATIC_REQUIRE
#include "based/trait/signature.hpp"
#include <catch2/catch_test_macros.hpp>
#include "based/concept/is/same.hpp"
// NOLINTBEGIN(*cognitive-complexity*)
namespace
{
// NOLINTNEXTLINE (*needed*)
int free_func(const double& a, int&& b) noexcept(false)
{
return static_cast<int>(a + b);
}
// NOLINTNEXTLINE (*needed*)
int free_func_noexcept(const double& a, int&& b) noexcept(true)
{
return static_cast<int>(a + b);
}
} // namespace
using based::SameAs;
TEST_CASE("free function", "[trait/signature]")
{
using sig = based::signature<decltype(free_func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::false_type, sig::noexcept_val>);
}
TEST_CASE("free function noexcept", "[trait/signature]")
{
using sig = based::signature<decltype(free_func_noexcept)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::true_type, sig::noexcept_val>);
}
TEST_CASE("empty", "[trait/signature]")
{
struct test
{
int func(const double& a, int&& b) noexcept(false);
};
using sig = based::signature<decltype(&test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::false_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::noexcept_val>);
}
TEST_CASE("const", "[trait/signature]")
{
struct test
{
int func(const double& a, int&& b) const noexcept(false);
};
using sig = based::signature<decltype(&test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::true_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::noexcept_val>);
}
TEST_CASE("volatile", "[trait/signature]")
{
struct test
{
int func(const double& a, int&& b) volatile noexcept(false);
};
using sig = based::signature<decltype(&test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::false_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::noexcept_val>);
}
TEST_CASE("const volatile", "[trait/signature]")
{
struct test
{
int func(const double& a, int&& b) const volatile noexcept(false);
};
using sig = based::signature<decltype(&test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::true_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::noexcept_val>);
}
TEST_CASE("noexcept", "[trait/signature]")
{
struct test
{
int func(const double& a, int&& b) noexcept(true);
};
using sig = based::signature<decltype(&test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::false_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::noexcept_val>);
}
TEST_CASE("const noexcept", "[trait/signature]")
{
struct test
{
int func(const double& a, int&& b) const noexcept(true);
};
using sig = based::signature<decltype(&test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::true_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::noexcept_val>);
}
TEST_CASE("volatile noexcept", "[trait/signature]")
{
struct test
{
int func(const double& a, int&& b) volatile noexcept(true);
};
using sig = based::signature<decltype(&test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::false_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::noexcept_val>);
}
TEST_CASE("const volatile noexcept", "[trait/signature]")
{
struct test
{
int func(const double& a, int&& b) const volatile noexcept(true);
};
using sig = based::signature<decltype(&test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::true_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::noexcept_val>);
}
TEST_CASE("lvalref", "[trait/signature]")
{
struct test
{
int func(const double& a, int&& b) & noexcept(false);
};
using sig = based::signature<decltype(&test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::false_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::noexcept_val>);
}
TEST_CASE("const lvalref", "[trait/signature]")
{
struct test
{
int func(const double& a, int&& b) const& noexcept(false);
};
using sig = based::signature<decltype(&test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::true_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::noexcept_val>);
}
TEST_CASE("volatile lvalref", "[trait/signature]")
{
struct test
{
int func(const double& a, int&& b) volatile& noexcept(false);
};
using sig = based::signature<decltype(&test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::false_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::noexcept_val>);
}
TEST_CASE("const volatile lvalref", "[trait/signature]")
{
struct test
{
int func(const double& a, int&& b) const volatile& noexcept(false);
};
using sig = based::signature<decltype(&test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::true_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::noexcept_val>);
}
TEST_CASE("noexcept lvalref", "[trait/signature]")
{
struct test
{
int func(const double& a, int&& b) & noexcept(true);
};
using sig = based::signature<decltype(&test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::false_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::noexcept_val>);
}
TEST_CASE("const noexcept lvalref", "[trait/signature]")
{
struct test
{
int func(const double& a, int&& b) const& noexcept(true);
};
using sig = based::signature<decltype(&test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::true_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::noexcept_val>);
}
TEST_CASE("volatile noexcept lvalref", "[trait/signature]")
{
struct test
{
int func(const double& a, int&& b) volatile& noexcept(true);
};
using sig = based::signature<decltype(&test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::false_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::noexcept_val>);
}
TEST_CASE("const volatile noexcept lvalref", "[trait/signature]")
{
struct test
{
int func(const double& a, int&& b) const volatile& noexcept(true);
};
using sig = based::signature<decltype(&test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::true_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::noexcept_val>);
}
TEST_CASE("rvalref", "[trait/signature]")
{
struct test
{
int func(const double& a, int&& b) && noexcept(false);
};
using sig = based::signature<decltype(&test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::false_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::noexcept_val>);
}
TEST_CASE("const rvalref", "[trait/signature]")
{
struct test
{
int func(const double& a, int&& b) const&& noexcept(false);
};
using sig = based::signature<decltype(&test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::true_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::noexcept_val>);
}
TEST_CASE("volatile rvalref", "[trait/signature]")
{
struct test
{
int func(const double& a, int&& b) volatile&& noexcept(false);
};
using sig = based::signature<decltype(&test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::false_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::noexcept_val>);
}
TEST_CASE("const volatile rvalref", "[trait/signature]")
{
struct test
{
int func(const double& a, int&& b) const volatile&& noexcept(false);
};
using sig = based::signature<decltype(&test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::true_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::noexcept_val>);
}
TEST_CASE("noexcept rvalref", "[trait/signature]")
{
struct test
{
int func(const double& a, int&& b) && noexcept(true);
};
using sig = based::signature<decltype(&test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::false_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::noexcept_val>);
}
TEST_CASE("const noexcept rvalref", "[trait/signature]")
{
struct test
{
int func(const double& a, int&& b) const&& noexcept(true);
};
using sig = based::signature<decltype(&test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::true_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::noexcept_val>);
}
TEST_CASE("volatile noexcept rvalref", "[trait/signature]")
{
struct test
{
int func(const double& a, int&& b) volatile&& noexcept(true);
};
using sig = based::signature<decltype(&test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::false_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::noexcept_val>);
}
TEST_CASE("const volatile noexcept rvalref", "[trait/signature]")
{
struct test
{
int func(const double& a, int&& b) const volatile&& noexcept(true);
};
using sig = based::signature<decltype(&test::func)>;
STATIC_REQUIRE(SameAs<int(const double&, int&&), sig::sig_type>);
STATIC_REQUIRE(SameAs<std::tuple<const double&, int&&>, sig::arg_type>);
STATIC_REQUIRE(SameAs<int, sig::ret_type>);
STATIC_REQUIRE(SameAs<based::true_type, sig::const_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::volatile_val>);
STATIC_REQUIRE(SameAs<based::false_type, sig::lvalref_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::rvalref_val>);
STATIC_REQUIRE(SameAs<based::true_type, sig::noexcept_val>);
}
// NOLINTEND(*cognitive-complexity*)
diff --git a/ test/source/utility/buffer_test.cpp b/ test/source/utility/buffer_test.cpp
@@ -6,14 +6,14 @@
#include "based/integral/literals.hpp"
template struct based::buffer<sizeof(void*)>;
template struct based::Buffer<sizeof(void*)>;
TEST_CASE("valid type", "[utility/buffer]")
{
SECTION("small buffer")
{
using buffer = based::buffer<sizeof(based::u8)>;
STATIC_REQUIRE(buffer::valid_type<based::u8>());
using buffer = based::Buffer<sizeof(based::U8)>;
STATIC_REQUIRE(buffer::valid_type<based::U8>());
STATIC_REQUIRE_FALSE(buffer::valid_type<based::size_t>());
STATIC_REQUIRE_FALSE(buffer::valid_type<char[5]>()); // NOLINT(*array*)
@@ -21,8 +21,8 @@
TEST_CASE("valid type", "[utility/buffer]")
SECTION("big buffer")
{
using buffer = based::buffer<sizeof(based::size_t), alignof(based::size_t)>;
STATIC_REQUIRE(buffer::valid_type<based::u8>());
using buffer = based::Buffer<sizeof(based::size_t), alignof(based::size_t)>;
STATIC_REQUIRE(buffer::valid_type<based::U8>());
STATIC_REQUIRE(buffer::valid_type<based::size_t>());
STATIC_REQUIRE_FALSE(buffer::valid_type<char[5]>()); // NOLINT(*array*)
@@ -32,39 +32,39 @@
TEST_CASE("valid type", "[utility/buffer]")
TEST_CASE("buffer", "[utility/buffer]")
{
using namespace based::literals; // NOLINT(*namespace*)
using buffer = based::buffer<sizeof(based::size_t)>;
using buffer = based::Buffer<sizeof(based::size_t)>;
static constexpr auto value = 8_u8;
buffer buf(std::in_place_type<based::u8>, value);
buffer buf(std::in_place_type<based::U8>, value);
REQUIRE(*buf.as<based::u8>() == value);
REQUIRE(*buf.as<based::U8>() == value);
SECTION("emplace")
{
static constexpr auto new_value = 10_u16;
buf.emplace<based::u16>(new_value);
static constexpr auto new_value = 10_U16;
buf.emplace<based::U16>(new_value);
REQUIRE(*buf.as<based::u16>() == new_value);
REQUIRE(*buf.as<based::U16>() == new_value);
}
SECTION("swap")
{
static constexpr auto new_value = 10_u16;
buffer new_buf(std::in_place_type<based::u16>, new_value);
static constexpr auto new_value = 10_U16;
buffer new_buf(std::in_place_type<based::U16>, new_value);
buf.swap(new_buf);
REQUIRE(*buf.as<based::u16>() == new_value);
REQUIRE(*new_buf.as<based::u8>() == value);
REQUIRE(*buf.as<based::U16>() == new_value);
REQUIRE(*new_buf.as<based::U8>() == value);
}
}
TEST_CASE("const buffer", "[utility/buffer]")
{
using namespace based::literals; // NOLINT(*namespace*)
using buffer = based::buffer<sizeof(based::size_t)>;
using buffer = based::Buffer<sizeof(based::size_t)>;
static constexpr auto value = 8_u8;
const buffer buf(std::in_place_type<based::u8>, value);
const buffer buf(std::in_place_type<based::U8>, value);
REQUIRE(*buf.as<based::u8>() == value);
REQUIRE(*buf.as<based::U8>() == value);
}
diff --git a/ test/source/utility/scopeguard_test.cpp b/ test/source/utility/scopeguard_test.cpp
@@ -8,9 +8,9 @@
// NOLINTBEGIN(*cognitive-complexity*)
struct set
struct Set
{
explicit set(int& val)
explicit Set(int& val)
: m_val(&val)
{
}
@@ -21,7 +21,7 @@
private:
int* m_val;
};
template class based::scopeguard<set>;
template class based::Scopeguard<Set>;
TEST_CASE("manual", "[utility/scopeguard]")
{
@@ -29,7 +29,7 @@
TEST_CASE("manual", "[utility/scopeguard]")
{
int test = 0;
try {
based::scopeguard guard = set(test);
based::Scopeguard guard = Set(test);
guard.commit();
} catch (...) {
REQUIRE(false);
@@ -42,7 +42,7 @@
TEST_CASE("manual", "[utility/scopeguard]")
{
int test = 0;
try {
based::scopeguard guard = set(test); // NOLINT(*const*)
based::Scopeguard guard = Set(test); // NOLINT(*const*)
} catch (...) {
test *= 1;
}
@@ -56,7 +56,7 @@
TEST_CASE("on success", "[utility/scopeguard]")
{
int test = 0;
try {
const based::scopeguard_success guard = set(test);
const based::scopeguard_success guard = Set(test);
} catch (...) {
test *= 1;
}
@@ -68,7 +68,7 @@
TEST_CASE("on success", "[utility/scopeguard]")
{
int test = 0;
try {
const based::scopeguard_success guard = set(test);
const based::scopeguard_success guard = Set(test);
throw std::runtime_error {"should not leak"};
} catch (...) {
test *= 1;
@@ -83,7 +83,7 @@
TEST_CASE("on failure", "[utility/scopeguard]")
{
int test = 0;
try {
const based::scopeguard_failure guard = set(test);
const based::scopeguard_failure guard = Set(test);
} catch (...) {
test *= 1;
}
@@ -95,7 +95,7 @@
TEST_CASE("on failure", "[utility/scopeguard]")
{
int test = 0;
try {
const based::scopeguard_failure guard = set(test);
const based::scopeguard_failure guard = Set(test);
throw std::runtime_error {"should not leak"};
} catch (...) {
REQUIRE(true);
@@ -110,7 +110,7 @@
TEST_CASE("exit", "[utility/scopeguard]")
{
int test = 0;
try {
const based::scopeguard_exit guard = set(test);
const based::scopeguard_exit guard = Set(test);
} catch (...) {
REQUIRE(false);
}
@@ -122,7 +122,7 @@
TEST_CASE("exit", "[utility/scopeguard]")
{
int test = 0;
try {
const based::scopeguard_exit guard = set(test);
const based::scopeguard_exit guard = Set(test);
throw std::runtime_error {"should not leak"};
} catch (...) {
test *= 1;