based

Opinionated utility library
git clone git://git.dimitrijedobrota.com/based.git
Log | Files | Refs | README | LICENSE | HACKING | CONTRIBUTING | CODE_OF_CONDUCT | BUILDING
commit 57b03dfca931b87573f74b581d097b1de4455527
parent 7e9b1cb5f8670c2f019f21e8fc55a969c46ba312
author Dimitrije Dobrota < mail@dimitrijedobrota.com >
date Thu, 1 May 2025 09:36:06 +0200

Move signature to type_traits.hpp

Diffstat:
M include/based/template.hpp | +++++ -----------------------------------------------------------------------------
M include/based/type_traits.hpp | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -------------
M test/source/signature_test.cpp | +++++++++++++++++++++++++++ ---------------------------

3 files changed, 312 insertions(+), 301 deletions(-)

diff --git a/ include/based/template.hpp b/ include/based/template.hpp

@@ -7,218 +7,12 @@

#include <type_traits>
#include <utility>

#include "based/type_traits.hpp"
#include "based/utility.hpp"

namespace based
{

/* ----- Function Signature ----- */

template<typename>
struct signature;

template<typename Ret, bool ne, typename... Args>
struct signature<Ret(Args...) noexcept(ne)>
{
using sig_type = Ret(Args...);
using arg_type = std::tuple<Args...>;
using ret_type = Ret;

using noexcept_val = std::integral_constant<bool, ne>;
};

template<typename Ret, typename Obj, bool ne, typename... Args>
struct signature<Ret (Obj::*)(Args...) noexcept(ne)>
{
using sig_type = Ret(Args...);
using arg_type = std::tuple<Args...>;
using ret_type = Ret;

using const_val = std::false_type;
using volatile_val = std::false_type;

using lvalref_val = std::false_type;
using rvalref_val = std::false_type;

using noexcept_val = std::integral_constant<bool, ne>;
};

template<typename Ret, typename Obj, bool ne, typename... Args>
struct signature<Ret (Obj::*)(Args...) & noexcept(ne)>
{
using sig_type = Ret(Args...);
using arg_type = std::tuple<Args...>;
using ret_type = Ret;

using const_val = std::false_type;
using volatile_val = std::false_type;

using lvalref_val = std::true_type;
using rvalref_val = std::false_type;

using noexcept_val = std::integral_constant<bool, ne>;
};

template<typename Ret, typename Obj, bool ne, typename... Args>
struct signature<Ret (Obj::*)(Args...) && noexcept(ne)>
{
using sig_type = Ret(Args...);
using arg_type = std::tuple<Args...>;
using ret_type = Ret;

using const_val = std::false_type;
using volatile_val = std::false_type;

using lvalref_val = std::false_type;
using rvalref_val = std::true_type;

using noexcept_val = std::integral_constant<bool, ne>;
};

template<typename Ret, typename Obj, bool ne, typename... Args>
struct signature<Ret (Obj::*)(Args...) const noexcept(ne)>
{
using sig_type = Ret(Args...);
using arg_type = std::tuple<Args...>;
using ret_type = Ret;

using const_val = std::true_type;
using volatile_val = std::false_type;

using lvalref_val = std::false_type;
using rvalref_val = std::false_type;

using noexcept_val = std::integral_constant<bool, ne>;
};

template<typename Ret, typename Obj, bool ne, typename... Args>
struct signature<Ret (Obj::*)(Args...) const & noexcept(ne)>
{
using sig_type = Ret(Args...);
using arg_type = std::tuple<Args...>;
using ret_type = Ret;

using const_val = std::true_type;
using volatile_val = std::false_type;

using lvalref_val = std::true_type;
using rvalref_val = std::false_type;

using noexcept_val = std::integral_constant<bool, ne>;
};

template<typename Ret, typename Obj, bool ne, typename... Args>
struct signature<Ret (Obj::*)(Args...) const && noexcept(ne)>
{
using sig_type = Ret(Args...);
using arg_type = std::tuple<Args...>;
using ret_type = Ret;

using const_val = std::true_type;
using volatile_val = std::false_type;

using lvalref_val = std::false_type;
using rvalref_val = std::true_type;

using noexcept_val = std::integral_constant<bool, ne>;
};

template<typename Ret, typename Obj, bool ne, typename... Args>
struct signature<Ret (Obj::*)(Args...) volatile noexcept(ne)>
{
using sig_type = Ret(Args...);
using arg_type = std::tuple<Args...>;
using ret_type = Ret;

using const_val = std::false_type;
using volatile_val = std::true_type;

using lvalref_val = std::false_type;
using rvalref_val = std::false_type;

using noexcept_val = std::integral_constant<bool, ne>;
};

template<typename Ret, typename Obj, bool ne, typename... Args>
struct signature<Ret (Obj::*)(Args...) volatile & noexcept(ne)>
{
using sig_type = Ret(Args...);
using arg_type = std::tuple<Args...>;
using ret_type = Ret;

using const_val = std::false_type;
using volatile_val = std::true_type;

using lvalref_val = std::true_type;
using rvalref_val = std::false_type;

using noexcept_val = std::integral_constant<bool, ne>;
};

template<typename Ret, typename Obj, bool ne, typename... Args>
struct signature<Ret (Obj::*)(Args...) volatile && noexcept(ne)>
{
using sig_type = Ret(Args...);
using arg_type = std::tuple<Args...>;
using ret_type = Ret;

using const_val = std::false_type;
using volatile_val = std::true_type;

using lvalref_val = std::false_type;
using rvalref_val = std::true_type;

using noexcept_val = std::integral_constant<bool, ne>;
};

template<typename Ret, typename Obj, bool ne, typename... Args>
struct signature<Ret (Obj::*)(Args...) const volatile noexcept(ne)>
{
using sig_type = Ret(Args...);
using arg_type = std::tuple<Args...>;
using ret_type = Ret;

using const_val = std::true_type;
using volatile_val = std::true_type;

using lvalref_val = std::false_type;
using rvalref_val = std::false_type;

using noexcept_val = std::integral_constant<bool, ne>;
};

template<typename Ret, typename Obj, bool ne, typename... Args>
struct signature<Ret (Obj::*)(Args...) const volatile & noexcept(ne)>
{
using sig_type = Ret(Args...);
using arg_type = std::tuple<Args...>;
using ret_type = Ret;

using const_val = std::true_type;
using volatile_val = std::true_type;

using lvalref_val = std::true_type;
using rvalref_val = std::false_type;

using noexcept_val = std::integral_constant<bool, ne>;
};

template<typename Ret, typename Obj, bool ne, typename... Args>
struct signature<Ret (Obj::*)(Args...) const volatile && noexcept(ne)>
{
using sig_type = Ret(Args...);
using arg_type = std::tuple<Args...>;
using ret_type = Ret;

using const_val = std::true_type;
using volatile_val = std::true_type;

using lvalref_val = std::false_type;
using rvalref_val = std::true_type;

using noexcept_val = std::integral_constant<bool, ne>;
};

/* ----- Buffer used for Local Buffer Optimization ----- */

template<size_t size, size_t alignment = alignof(void*)>

@@ -302,15 +96,15 @@ class function;

template<
std::size_t size,
std::size_t alignment,
typename Res,
typename Ret,
typename... Args>
class function<Res(Args...), size, alignment>
class function<Ret(Args...), size, alignment>
{
buffer<size, alignment> m_space;

using executor_t = Res (*)(Args..., void*);
using executor_t = Ret (*)(Args..., void*);

static constexpr Res default_executor(Args... /* args */, void* /* func */)
static constexpr Ret default_executor(Args... /* args */, void* /* func */)
{
throw std::bad_function_call();
}

@@ -319,7 +113,7 @@ class function<Res(Args...), size, alignment>

executor_t m_executor = m_default_executor;

template<typename Callable>
static Res executor(Args... args, void* func)
static Ret executor(Args... args, void* func)
{
return std::invoke(
*static_cast<function*>(func)->m_space.template as<Callable>(),

@@ -348,7 +142,7 @@ public:

}

template<typename... CallArgs>
Res operator()(CallArgs&&... callargs) const
Ret operator()(CallArgs&&... callargs) const
{
return this->m_executor(
std::forward<CallArgs>(callargs)...,

@@ -357,19 +151,11 @@ public:

}
};

// operator()
template<typename T>
function(T) -> function<typename signature<decltype(&T::operator())>::sig_type>;

// free function
template<typename T>
function(T) -> function<typename signature<std::remove_pointer_t<T>>::sig_type>;
template<typename Ret, typename... Args>
function(Ret (*)(Args...)) -> function<Ret(Args...)>;

/*
// member procedure
template<typename T>
function(T) -> function<typename signature<std::decay_t<T>>::sig_type>;
*/
template<typename F, typename Sig = signature_t<F, decltype(&F::operator())>>
function(F) -> function<Sig>;

template<typename Func, bool on_success = false, bool on_failure = false>
class scopeguard

diff --git a/ include/based/type_traits.hpp b/ include/based/type_traits.hpp

@@ -45,28 +45,28 @@ concept BareSameAs = SameAs<bare_t<T>, bare_t<U>>;


/* ----- Iterator ----- */

// clang-format off

namespace detail {
template<typename I>
struct iterator_traits {
using value_type = I;
using distance_type = std::uint64_t; using pointer_type = I&;
using reference_type = I*;
};

template<typename I>
requires std::input_or_output_iterator<I>
struct iterator_traits<I> {
using value_type = std::iterator_traits<I>::value_type;
using distance_type = std::iterator_traits<I>::difference_type;
using pointer_type = std::iterator_traits<I>::pointer;
using reference_type = std::iterator_traits<I>::reference;
};

namespace detail
{
template<typename I>
struct iterator_traits
{
using value_type = I;
using distance_type = std::uint64_t;
using pointer_type = I&;
using reference_type = I*;
};

} // namespace detail
template<typename I>
requires std::input_or_output_iterator<I>
struct iterator_traits<I>
{
using value_type = std::iterator_traits<I>::value_type;
using distance_type = std::iterator_traits<I>::difference_type;
using pointer_type = std::iterator_traits<I>::pointer;
using reference_type = std::iterator_traits<I>::reference;
};

} // namespace detail

template<typename T>
using iter_value_t = detail::iterator_traits<T>::value_type;

@@ -84,73 +84,298 @@ template<typename T>

concept Readable = requires(T val) {
requires(Regular<T>);
typename iter_value_t<T>;
{ *val } -> BareSameAs<iter_value_t<T>>;
{
*val
} -> BareSameAs<iter_value_t<T>>;
};

template<typename T>
concept Iterator = requires(T val) {
requires(Regular<T>);
typename iter_dist_t<T>;
// requires(Integer<iter_dist_t<T>>);
{ ++val } -> BareSameAs<T>;
// successor is not necessarily regular

requires(Regular<T>);
typename iter_dist_t<T>;
// requires(Integer<iter_dist_t<T>>);
{
++val
} -> BareSameAs<T>;
// successor is not necessarily regular
};

template<typename T>
concept ForwardIterator = requires {
requires(Iterator<T>);
// successor is regular
requires(Iterator<T>);
// successor is regular
};

template<typename T>
concept ReadableIterator = requires {
requires(Iterator<T>);
requires(Readable<T>);
requires(Iterator<T>);
requires(Readable<T>);
};

template<typename T>
concept ReadableForwardIterator = requires {
requires(ForwardIterator<T>);
requires(Readable<T>);
requires(ForwardIterator<T>);
requires(Readable<T>);
};

// clang-format on
/* ----- Function Signature ----- */

template<typename T>
concept Input = std::is_same_v<T, std::remove_cvref_t<std::remove_pointer_t<T>>>
|| std::is_const_v<std::remove_reference_t<T>>
|| std::is_const_v<std::remove_pointer_t<T>>;
template<typename>
struct signature;

namespace detail
template<typename Ret, bool ne, typename... Args>
struct signature<Ret(Args...) noexcept(ne)>
{
using sig_type = Ret(Args...);
using arg_type = std::tuple<Args...>;
using ret_type = Ret;

template<typename... Args>
struct is_homogeneous_domain : std::false_type
using noexcept_val = std::integral_constant<bool, ne>;
};

template<typename Ret, typename Obj, bool ne, typename... Args>
struct signature<Ret (Obj::*)(Args...) noexcept(ne)>
{
using sig_type = Ret(Args...);
using arg_type = std::tuple<Args...>;
using ret_type = Ret;

using const_val = std::false_type;
using volatile_val = std::false_type;

using lvalref_val = std::false_type;
using rvalref_val = std::false_type;

using noexcept_val = std::integral_constant<bool, ne>;
};

template<typename Head, typename... Args>
requires(std::same_as<Head, Args> && ...)
struct is_homogeneous_domain<Head, Args...> : std::true_type
template<typename Ret, typename Obj, bool ne, typename... Args>
struct signature<Ret (Obj::*)(Args...) & noexcept(ne)>
{
using sig_type = Ret(Args...);
using arg_type = std::tuple<Args...>;
using ret_type = Ret;

using const_val = std::false_type;
using volatile_val = std::false_type;

using lvalref_val = std::true_type;
using rvalref_val = std::false_type;

using noexcept_val = std::integral_constant<bool, ne>;
};

} // namespace detail
template<typename Ret, typename Obj, bool ne, typename... Args>
struct signature<Ret (Obj::*)(Args...) && noexcept(ne)>
{
using sig_type = Ret(Args...);
using arg_type = std::tuple<Args...>;
using ret_type = Ret;

using const_val = std::false_type;
using volatile_val = std::false_type;

using lvalref_val = std::false_type;
using rvalref_val = std::true_type;

using noexcept_val = std::integral_constant<bool, ne>;
};

template<typename Ret, typename Obj, bool ne, typename... Args>
struct signature<Ret (Obj::*)(Args...) const noexcept(ne)>
{
using sig_type = Ret(Args...);
using arg_type = std::tuple<Args...>;
using ret_type = Ret;

using const_val = std::true_type;
using volatile_val = std::false_type;

using lvalref_val = std::false_type;
using rvalref_val = std::false_type;

using noexcept_val = std::integral_constant<bool, ne>;
};

template<typename Ret, typename Obj, bool ne, typename... Args>
struct signature<Ret (Obj::*)(Args...) const & noexcept(ne)>
{
using sig_type = Ret(Args...);
using arg_type = std::tuple<Args...>;
using ret_type = Ret;

using const_val = std::true_type;
using volatile_val = std::false_type;

using lvalref_val = std::true_type;
using rvalref_val = std::false_type;

using noexcept_val = std::integral_constant<bool, ne>;
};

template<typename Ret, typename Obj, bool ne, typename... Args>
struct signature<Ret (Obj::*)(Args...) const && noexcept(ne)>
{
using sig_type = Ret(Args...);
using arg_type = std::tuple<Args...>;
using ret_type = Ret;

using const_val = std::true_type;
using volatile_val = std::false_type;

using lvalref_val = std::false_type;
using rvalref_val = std::true_type;

using noexcept_val = std::integral_constant<bool, ne>;
};

template<typename Ret, typename Obj, bool ne, typename... Args>
struct signature<Ret (Obj::*)(Args...) volatile noexcept(ne)>
{
using sig_type = Ret(Args...);
using arg_type = std::tuple<Args...>;
using ret_type = Ret;

using const_val = std::false_type;
using volatile_val = std::true_type;

using lvalref_val = std::false_type;
using rvalref_val = std::false_type;

using noexcept_val = std::integral_constant<bool, ne>;
};

template<typename Ret, typename Obj, bool ne, typename... Args>
struct signature<Ret (Obj::*)(Args...) volatile & noexcept(ne)>
{
using sig_type = Ret(Args...);
using arg_type = std::tuple<Args...>;
using ret_type = Ret;

using const_val = std::false_type;
using volatile_val = std::true_type;

using lvalref_val = std::true_type;
using rvalref_val = std::false_type;

using noexcept_val = std::integral_constant<bool, ne>;
};

template<typename Ret, typename Obj, bool ne, typename... Args>
struct signature<Ret (Obj::*)(Args...) volatile && noexcept(ne)>
{
using sig_type = Ret(Args...);
using arg_type = std::tuple<Args...>;
using ret_type = Ret;

using const_val = std::false_type;
using volatile_val = std::true_type;

using lvalref_val = std::false_type;
using rvalref_val = std::true_type;

using noexcept_val = std::integral_constant<bool, ne>;
};

template<typename Ret, typename Obj, bool ne, typename... Args>
struct signature<Ret (Obj::*)(Args...) const volatile noexcept(ne)>
{
using sig_type = Ret(Args...);
using arg_type = std::tuple<Args...>;
using ret_type = Ret;

using const_val = std::true_type;
using volatile_val = std::true_type;

using lvalref_val = std::false_type;
using rvalref_val = std::false_type;

using noexcept_val = std::integral_constant<bool, ne>;
};

template<typename Ret, typename Obj, bool ne, typename... Args>
struct signature<Ret (Obj::*)(Args...) const volatile & noexcept(ne)>
{
using sig_type = Ret(Args...);
using arg_type = std::tuple<Args...>;
using ret_type = Ret;

using const_val = std::true_type;
using volatile_val = std::true_type;

using lvalref_val = std::true_type;
using rvalref_val = std::false_type;

using noexcept_val = std::integral_constant<bool, ne>;
};

template<typename Ret, typename Obj, bool ne, typename... Args>
struct signature<Ret (Obj::*)(Args...) const volatile && noexcept(ne)>
{
using sig_type = Ret(Args...);
using arg_type = std::tuple<Args...>;
using ret_type = Ret;

using const_val = std::true_type;
using volatile_val = std::true_type;

using lvalref_val = std::false_type;
using rvalref_val = std::true_type;

using noexcept_val = std::integral_constant<bool, ne>;
};

template<typename StaticCallOp>
struct signature_static
{
};

template<typename Ret, bool ne, typename... Args>
struct signature_static<Ret (*)(Args...) noexcept(ne)>
{
using sig_type = Ret(Args...);
};

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;

/*
template<typename Sig>
class function;

template<typename Ret, typename... Args>
class function<Ret(Args...)>
{
};

template<typename Ret, typename... Args>
function(Ret (*)(Args...)) -> function<Ret(Args...)>;

template<typename F, typename Sig = signature_t<F, decltype(&F::operator())>>
function(F) -> function<Sig>;
*/

/* ----- Function Concepts ----- */

template<typename T>
concept Input = std::is_same_v<T, std::remove_cvref_t<std::remove_pointer_t<T>>>
|| std::is_const_v<std::remove_reference_t<T>>
|| std::is_const_v<std::remove_pointer_t<T>>;

template<std::size_t idx, typename... Args>
requires(idx < sizeof...(Args))
using elem_t = std::tuple_element_t<idx, std::tuple<Args...>>;

template<typename... Args>
concept RegularDomain =
requires { requires(Regular<std::remove_cvref_t<Args>> && ...); };
concept RegularDomain = (Regular<std::remove_cvref_t<Args>> && ...);

template<typename... Args>
concept InputDomain = requires { requires(Input<Args> && ...); };
concept InputDomain = (Input<Args> && ...);

template<typename... Args>
concept HomogeneousDomain = detail::is_homogeneous_domain<Args...>::value;
concept HomogeneousDomain = (std::same_as<elem_t<0, Args...>, Args> && ...);

template<typename P, typename Ret, typename... Args>
concept Procedure = requires {

diff --git a/ test/source/signature_test.cpp b/ test/source/signature_test.cpp

@@ -2,7 +2,7 @@


#include <catch2/catch_test_macros.hpp>

#include "based/template.hpp"
#include "based/type_traits.hpp"

// NOLINTBEGIN cognitive-complexity

@@ -22,7 +22,7 @@ int free_func_noexcept(const double& a, int&& b) noexcept(true


} // namespace

TEST_CASE("free function", "[template/signature]")
TEST_CASE("free function", "[type_traits/signature]")
{
using sig = based::signature<decltype(free_func)>;
STATIC_REQUIRE(std::same_as<int(const double&, int&&), sig::sig_type>);

@@ -31,7 +31,7 @@ TEST_CASE("free function", "[template/signature]")

STATIC_REQUIRE(std::same_as<std::false_type, sig::noexcept_val>);
}

TEST_CASE("free function noexcept", "[template/signature]")
TEST_CASE("free function noexcept", "[type_traits/signature]")
{
using sig = based::signature<decltype(free_func_noexcept)>;
STATIC_REQUIRE(std::same_as<int(const double&, int&&), sig::sig_type>);

@@ -40,7 +40,7 @@ TEST_CASE("free function noexcept", "[template/signature]")

STATIC_REQUIRE(std::same_as<std::true_type, sig::noexcept_val>);
}

TEST_CASE("empty", "[template/signature]")
TEST_CASE("empty", "[type_traits/signature]")
{
struct test
{

@@ -58,7 +58,7 @@ TEST_CASE("empty", "[template/signature]")

STATIC_REQUIRE(std::same_as<std::false_type, sig::noexcept_val>);
}

TEST_CASE("const", "[template/signature]")
TEST_CASE("const", "[type_traits/signature]")
{
struct test
{

@@ -76,7 +76,7 @@ TEST_CASE("const", "[template/signature]")

STATIC_REQUIRE(std::same_as<std::false_type, sig::noexcept_val>);
}

TEST_CASE("volatile", "[template/signature]")
TEST_CASE("volatile", "[type_traits/signature]")
{
struct test
{

@@ -94,7 +94,7 @@ TEST_CASE("volatile", "[template/signature]")

STATIC_REQUIRE(std::same_as<std::false_type, sig::noexcept_val>);
}

TEST_CASE("const volatile", "[template/signature]")
TEST_CASE("const volatile", "[type_traits/signature]")
{
struct test
{

@@ -112,7 +112,7 @@ TEST_CASE("const volatile", "[template/signature]")

STATIC_REQUIRE(std::same_as<std::false_type, sig::noexcept_val>);
}

TEST_CASE("noexcept", "[template/signature]")
TEST_CASE("noexcept", "[type_traits/signature]")
{
struct test
{

@@ -130,7 +130,7 @@ TEST_CASE("noexcept", "[template/signature]")

STATIC_REQUIRE(std::same_as<std::true_type, sig::noexcept_val>);
}

TEST_CASE("const noexcept", "[template/signature]")
TEST_CASE("const noexcept", "[type_traits/signature]")
{
struct test
{

@@ -148,7 +148,7 @@ TEST_CASE("const noexcept", "[template/signature]")

STATIC_REQUIRE(std::same_as<std::true_type, sig::noexcept_val>);
}

TEST_CASE("volatile noexcept", "[template/signature]")
TEST_CASE("volatile noexcept", "[type_traits/signature]")
{
struct test
{

@@ -166,7 +166,7 @@ TEST_CASE("volatile noexcept", "[template/signature]")

STATIC_REQUIRE(std::same_as<std::true_type, sig::noexcept_val>);
}

TEST_CASE("const volatile noexcept", "[template/signature]")
TEST_CASE("const volatile noexcept", "[type_traits/signature]")
{
struct test
{

@@ -184,7 +184,7 @@ TEST_CASE("const volatile noexcept", "[template/signature]")

STATIC_REQUIRE(std::same_as<std::true_type, sig::noexcept_val>);
}

TEST_CASE("lvalref", "[template/signature]")
TEST_CASE("lvalref", "[type_traits/signature]")
{
struct test
{

@@ -202,7 +202,7 @@ TEST_CASE("lvalref", "[template/signature]")

STATIC_REQUIRE(std::same_as<std::false_type, sig::noexcept_val>);
}

TEST_CASE("const lvalref", "[template/signature]")
TEST_CASE("const lvalref", "[type_traits/signature]")
{
struct test
{

@@ -220,7 +220,7 @@ TEST_CASE("const lvalref", "[template/signature]")

STATIC_REQUIRE(std::same_as<std::false_type, sig::noexcept_val>);
}

TEST_CASE("volatile lvalref", "[template/signature]")
TEST_CASE("volatile lvalref", "[type_traits/signature]")
{
struct test
{

@@ -238,7 +238,7 @@ TEST_CASE("volatile lvalref", "[template/signature]")

STATIC_REQUIRE(std::same_as<std::false_type, sig::noexcept_val>);
}

TEST_CASE("const volatile lvalref", "[template/signature]")
TEST_CASE("const volatile lvalref", "[type_traits/signature]")
{
struct test
{

@@ -256,7 +256,7 @@ TEST_CASE("const volatile lvalref", "[template/signature]")

STATIC_REQUIRE(std::same_as<std::false_type, sig::noexcept_val>);
}

TEST_CASE("noexcept lvalref", "[template/signature]")
TEST_CASE("noexcept lvalref", "[type_traits/signature]")
{
struct test
{

@@ -274,7 +274,7 @@ TEST_CASE("noexcept lvalref", "[template/signature]")

STATIC_REQUIRE(std::same_as<std::true_type, sig::noexcept_val>);
}

TEST_CASE("const noexcept lvalref", "[template/signature]")
TEST_CASE("const noexcept lvalref", "[type_traits/signature]")
{
struct test
{

@@ -292,7 +292,7 @@ TEST_CASE("const noexcept lvalref", "[template/signature]")

STATIC_REQUIRE(std::same_as<std::true_type, sig::noexcept_val>);
}

TEST_CASE("volatile noexcept lvalref", "[template/signature]")
TEST_CASE("volatile noexcept lvalref", "[type_traits/signature]")
{
struct test
{

@@ -310,7 +310,7 @@ TEST_CASE("volatile noexcept lvalref", "[template/signature]")

STATIC_REQUIRE(std::same_as<std::true_type, sig::noexcept_val>);
}

TEST_CASE("const volatile noexcept lvalref", "[template/signature]")
TEST_CASE("const volatile noexcept lvalref", "[type_traits/signature]")
{
struct test
{

@@ -328,7 +328,7 @@ TEST_CASE("const volatile noexcept lvalref", "[template/signature]")

STATIC_REQUIRE(std::same_as<std::true_type, sig::noexcept_val>);
}

TEST_CASE("rvalref", "[template/signature]")
TEST_CASE("rvalref", "[type_traits/signature]")
{
struct test
{

@@ -346,7 +346,7 @@ TEST_CASE("rvalref", "[template/signature]")

STATIC_REQUIRE(std::same_as<std::false_type, sig::noexcept_val>);
}

TEST_CASE("const rvalref", "[template/signature]")
TEST_CASE("const rvalref", "[type_traits/signature]")
{
struct test
{

@@ -364,7 +364,7 @@ TEST_CASE("const rvalref", "[template/signature]")

STATIC_REQUIRE(std::same_as<std::false_type, sig::noexcept_val>);
}

TEST_CASE("volatile rvalref", "[template/signature]")
TEST_CASE("volatile rvalref", "[type_traits/signature]")
{
struct test
{

@@ -382,7 +382,7 @@ TEST_CASE("volatile rvalref", "[template/signature]")

STATIC_REQUIRE(std::same_as<std::false_type, sig::noexcept_val>);
}

TEST_CASE("const volatile rvalref", "[template/signature]")
TEST_CASE("const volatile rvalref", "[type_traits/signature]")
{
struct test
{

@@ -400,7 +400,7 @@ TEST_CASE("const volatile rvalref", "[template/signature]")

STATIC_REQUIRE(std::same_as<std::false_type, sig::noexcept_val>);
}

TEST_CASE("noexcept rvalref", "[template/signature]")
TEST_CASE("noexcept rvalref", "[type_traits/signature]")
{
struct test
{

@@ -418,7 +418,7 @@ TEST_CASE("noexcept rvalref", "[template/signature]")

STATIC_REQUIRE(std::same_as<std::true_type, sig::noexcept_val>);
}

TEST_CASE("const noexcept rvalref", "[template/signature]")
TEST_CASE("const noexcept rvalref", "[type_traits/signature]")
{
struct test
{

@@ -436,7 +436,7 @@ TEST_CASE("const noexcept rvalref", "[template/signature]")

STATIC_REQUIRE(std::same_as<std::true_type, sig::noexcept_val>);
}

TEST_CASE("volatile noexcept rvalref", "[template/signature]")
TEST_CASE("volatile noexcept rvalref", "[type_traits/signature]")
{
struct test
{

@@ -454,7 +454,7 @@ TEST_CASE("volatile noexcept rvalref", "[template/signature]")

STATIC_REQUIRE(std::same_as<std::true_type, sig::noexcept_val>);
}

TEST_CASE("const volatile noexcept rvalref", "[template/signature]")
TEST_CASE("const volatile noexcept rvalref", "[type_traits/signature]")
{
struct test
{