summaryrefslogtreecommitdiff
path: root/asl/base
diff options
context:
space:
mode:
Diffstat (limited to 'asl/base')
-rw-r--r--asl/base/assert.cpp5
-rw-r--r--asl/base/defer.hpp6
-rw-r--r--asl/base/functional.hpp22
-rw-r--r--asl/base/utility.hpp69
-rw-r--r--asl/base/utility_tests.cpp44
5 files changed, 89 insertions, 57 deletions
diff --git a/asl/base/assert.cpp b/asl/base/assert.cpp
index ecda20d..b96836b 100644
--- a/asl/base/assert.cpp
+++ b/asl/base/assert.cpp
@@ -4,7 +4,12 @@
#include "asl/base/assert.hpp"
+#include "asl/base/meta.hpp"
+
+// NOLINTNEXTLINE(*-non-const-global-variables)
static asl::AssertFailureHandler* s_handler = nullptr;
+
+// NOLINTNEXTLINE(*-non-const-global-variables)
static void* s_user = nullptr;
void asl::set_assert_failure_handler(AssertFailureHandler handler, void* user)
diff --git a/asl/base/defer.hpp b/asl/base/defer.hpp
index bc5d078..c9c08ba 100644
--- a/asl/base/defer.hpp
+++ b/asl/base/defer.hpp
@@ -18,14 +18,14 @@ class DeferCallback
public:
template<typename T>
- explicit DeferCallback(T&& callback) : m_callback(ASL_FWD(callback))
+ explicit DeferCallback(T&& callback) : m_callback(std::forward<T>(callback))
{
}
ASL_DELETE_COPY(DeferCallback);
DeferCallback(DeferCallback&& other) :
- m_callback(ASL_MOVE(other.m_callback)), m_moved(exchange(other.m_moved, true))
+ m_callback(std::move(other.m_callback)), m_moved(exchange(other.m_moved, true))
{
}
@@ -42,7 +42,7 @@ struct DeferFactory
template<invocable Callback>
DeferCallback<Callback> operator<<(Callback&& callback) const
{
- return DeferCallback<Callback>(ASL_FWD(callback));
+ return DeferCallback<Callback>(std::forward<Callback>(callback));
}
};
diff --git a/asl/base/functional.hpp b/asl/base/functional.hpp
index 9aeb485..509a2b2 100644
--- a/asl/base/functional.hpp
+++ b/asl/base/functional.hpp
@@ -11,22 +11,22 @@ namespace asl {
template<typename... Args, typename C>
constexpr auto invoke(is_func auto C::* f, auto&& self, Args&&... args)
- -> decltype((self.*f)(ASL_FWD(args)...))
+ -> decltype((self.*f)(std::forward<Args>(args)...))
requires requires {
- (self.*f)(ASL_FWD(args)...);
+ (self.*f)(std::forward<Args>(args)...);
}
{
- return (ASL_FWD(self).*f)(ASL_FWD(args)...);
+ return (std::forward<decltype(self)>(self).*f)(std::forward<Args>(args)...);
}
template<typename... Args, typename C>
constexpr auto invoke(is_func auto C::* f, auto* self, Args&&... args)
- -> decltype((self->*f)(ASL_FWD(args)...))
+ -> decltype((self->*f)(std::forward<Args>(args)...))
requires requires {
- (self->*f)(ASL_FWD(args)...);
+ (self->*f)(std::forward<Args>(args)...);
}
{
- return (self->*f)(ASL_FWD(args)...);
+ return (self->*f)(std::forward<Args>(args)...);
}
template<typename... Args, typename C>
@@ -37,7 +37,7 @@ constexpr auto invoke(is_object auto C::* m, auto&& self, Args&&...)
requires { self.*m; }
)
{
- return ASL_FWD(self).*m;
+ return std::forward<decltype(self)>(self).*m;
}
template<typename... Args, typename C>
@@ -53,12 +53,12 @@ constexpr auto invoke(is_object auto C::* m, auto* self, Args&&...)
template<typename... Args>
constexpr auto invoke(auto&& f, Args&&... args)
- -> decltype(f(ASL_FWD(args)...))
+ -> decltype(f(std::forward<Args>(args)...))
requires requires {
- f(ASL_FWD(args)...);
+ f(std::forward<Args>(args)...);
}
{
- return ASL_FWD(f)(ASL_FWD(args)...);
+ return std::forward<decltype(f)>(f)(std::forward<Args>(args)...);
}
template<typename Void, typename F, typename... Args>
@@ -76,7 +76,7 @@ using invoke_result_t = _invoke_result_helper<void, F, Args...>::type;
template<typename F, typename... Args>
concept invocable = requires (F&& f, Args&&... args)
{
- invoke(ASL_FWD(f), ASL_FWD(args)...);
+ invoke(std::forward<F>(f), std::forward<Args>(args)...);
};
} // namespace asl
diff --git a/asl/base/utility.hpp b/asl/base/utility.hpp
index 63f16b1..07f8b51 100644
--- a/asl/base/utility.hpp
+++ b/asl/base/utility.hpp
@@ -7,11 +7,36 @@
#include "asl/base/meta.hpp"
#include "asl/base/assert.hpp"
-#define ASL_MOVE(...) (static_cast<::asl::un_ref_t<decltype(__VA_ARGS__)>&&>(__VA_ARGS__))
+namespace std
+{
+
+template<typename T>
+constexpr asl::un_ref_t<T>&& move(T&& t) noexcept // NOLINT
+{
+ return static_cast<asl::un_ref_t<T>&&>(t);
+}
+
+template<typename T>
+constexpr T&& forward(asl::un_ref_t<T>& t) noexcept // NOLINT
+{
+ return static_cast<T&&>(t);
+}
+
+template< class T >
+constexpr T&& forward(asl::un_ref_t<T>&& t) noexcept // NOLINT
+{
+ return static_cast<T&&>(t);
+}
+
+template<typename T, typename U>
+constexpr auto forward_like(U&& x) noexcept -> asl::copy_cref_t<T, U> // NOLINT
+{
+ using return_type = asl::copy_cref_t<T, U&&>;
+ return static_cast<return_type>(x);
+}
-#define ASL_FWD(expr_) (static_cast<decltype(expr_)&&>(expr_))
+} // namespace std
-#define ASL_FWD_LIKE(ref_, expr_) (static_cast<::asl::copy_cref_t<ref_, decltype(expr_)&&>>(expr_))
namespace asl
{
@@ -22,16 +47,16 @@ static constexpr in_place_t in_place{};
template<moveable T>
constexpr void swap(T& a, T& b)
{
- T tmp{ASL_MOVE(a)};
- a = ASL_MOVE(b);
- b = ASL_MOVE(tmp);
+ T tmp{std::move(a)};
+ a = std::move(b);
+ b = std::move(tmp);
}
template<typename T, typename U>
T exchange(T& obj, U&& new_value)
{
- T old_value = ASL_MOVE(obj);
- obj = ASL_FWD(new_value);
+ T old_value = std::move(obj);
+ obj = std::forward<U>(new_value);
return old_value;
}
@@ -59,44 +84,46 @@ constexpr uint64_t round_up_pow2(uint64_t v)
v -= 1;
- v |= v >> 1;
- v |= v >> 2;
- v |= v >> 4;
- v |= v >> 8;
- v |= v >> 16;
- v |= v >> 32;
+ v |= v >> 1U;
+ v |= v >> 2U;
+ v |= v >> 4U;
+ v |= v >> 8U;
+ v |= v >> 16U;
+ v |= v >> 32U;
return v + 1;
}
constexpr bool is_pow2(isize_t v)
{
- return v > 0 && ((v - 1) & v) == 0;
+ return v > 0 && ((v - 1) & v) == 0; // NOLINT
}
+// NOLINTBEGIN(*-macro-parentheses)
#define ASL_DELETE_COPY(T) \
T(const T&) = delete; \
- T& operator=(const T&) = delete;
+ T& operator=(const T&) = delete
#define ASL_DELETE_MOVE(T) \
T(T&&) = delete; \
- T& operator=(T&&) = delete;
+ T& operator=(T&&) = delete
#define ASL_DELETE_COPY_MOVE(T) \
- ASL_DELETE_COPY(T) \
+ ASL_DELETE_COPY(T); \
ASL_DELETE_MOVE(T)
#define ASL_DEFAULT_COPY(T) \
T(const T&) = default; \
- T& operator=(const T&) = default;
+ T& operator=(const T&) = default
#define ASL_DEFAULT_MOVE(T) \
T(T&&) = default; \
- T& operator=(T&&) = default;
+ T& operator=(T&&) = default
#define ASL_DEFAULT_COPY_MOVE(T) \
- ASL_DEFAULT_COPY(T) \
+ ASL_DEFAULT_COPY(T); \
ASL_DEFAULT_MOVE(T)
+// NOLINTEND(*-macro-parentheses)
#define ASL_CONCAT2(A, B) A##B
#define ASL_CONCAT(A, B) ASL_CONCAT2(A, B)
diff --git a/asl/base/utility_tests.cpp b/asl/base/utility_tests.cpp
index 20cdf97..7e54bb2 100644
--- a/asl/base/utility_tests.cpp
+++ b/asl/base/utility_tests.cpp
@@ -12,28 +12,28 @@ template<typename T> static constexpr int identify(T&&) { return 4; }
struct IdentifySelf
{
- constexpr int get(this auto&& self) { return identify(ASL_FWD(self)); }
+ constexpr int get(this auto&& self) { return identify(std::forward<decltype(self)>(self)); }
};
-static int get_const_lref(const IdentifySelf& i) { return ASL_FWD(i).get(); }
-static int get_const_rref(const IdentifySelf&& i) { return ASL_FWD(i).get(); }
-static int get_lref(IdentifySelf& i) { return ASL_FWD(i).get(); }
-static int get_rref(IdentifySelf&& i) { return ASL_FWD(i).get(); }
+static int get_const_lref(const IdentifySelf& i) { return i.get(); }
+static int get_const_rref(const IdentifySelf&& i) { return std::move(i).get(); } // NOLINT
+static int get_lref(IdentifySelf& i) { return i.get(); }
+static int get_rref(IdentifySelf&& i) { return std::move(i).get(); } // NOLINT
ASL_TEST(forward)
{
- IdentifySelf id;
- ASL_TEST_EXPECT(get_const_lref(id) == 1);
+ IdentifySelf id{};
+ ASL_TEST_EXPECT(get_const_lref(IdentifySelf{}) == 1);
ASL_TEST_EXPECT(get_lref(id) == 3);
- ASL_TEST_EXPECT(get_const_rref(ASL_MOVE(id)) == 2);
- ASL_TEST_EXPECT(get_rref(ASL_MOVE(id)) == 4);
+ ASL_TEST_EXPECT(get_const_rref(IdentifySelf{}) == 2);
+ ASL_TEST_EXPECT(get_rref(IdentifySelf{}) == 4);
}
ASL_TEST(move)
{
IdentifySelf id;
ASL_TEST_EXPECT(id.get() == 3);
- ASL_TEST_EXPECT(ASL_MOVE(id).get() == 4);
+ ASL_TEST_EXPECT(IdentifySelf{}.get() == 4);
}
struct Level1
@@ -51,33 +51,33 @@ struct Level3
Level2 deeper;
};
-static int get_const_lref(const Level3& i) { return ASL_FWD(i).deeper.deeper.id.get(); }
-static int get_const_rref(const Level3&& i) { return ASL_FWD(i).deeper.deeper.id.get(); }
-static int get_lref(Level3& i) { return ASL_FWD(i).deeper.deeper.id.get(); }
-static int get_rref(Level3&& i) { return ASL_FWD(i).deeper.deeper.id.get(); }
+static int get_const_lref(const Level3& i) { return i.deeper.deeper.id.get(); }
+static int get_const_rref(const Level3&& i) { return std::move(i).deeper.deeper.id.get(); }
+static int get_lref(Level3& i) { return i.deeper.deeper.id.get(); }
+static int get_rref(Level3&& i) { return std::move(i).deeper.deeper.id.get(); }
ASL_TEST(forward2)
{
Level3 id{};
ASL_TEST_EXPECT(get_const_lref(id) == 1);
ASL_TEST_EXPECT(get_lref(id) == 3);
- ASL_TEST_EXPECT(get_const_rref(ASL_MOVE(id)) == 2);
- ASL_TEST_EXPECT(get_rref(ASL_MOVE(id)) == 4);
+ ASL_TEST_EXPECT(get_const_rref(Level3{}) == 2);
+ ASL_TEST_EXPECT(get_rref(Level3{}) == 4);
}
template<typename T>
-static int test_fwd_like(T&& t)
+static int test_fwd_like(T) // NOLINT
{
- IdentifySelf id;
- return ASL_FWD_LIKE(decltype(t), id).get();
+ const IdentifySelf id;
+ return std::forward_like<T>(id).get();
}
ASL_TEST(forward_like)
{
int x{};
- ASL_TEST_EXPECT(test_fwd_like<const int&>(x) == 1);
+ ASL_TEST_EXPECT(test_fwd_like<const int&>(7) == 1);
ASL_TEST_EXPECT(test_fwd_like<int&>(x) == 3);
- ASL_TEST_EXPECT(test_fwd_like<const int&&>(ASL_MOVE(x)) == 2);
- ASL_TEST_EXPECT(test_fwd_like<int&&>(ASL_MOVE(x)) == 4);
+ ASL_TEST_EXPECT(test_fwd_like<const int&&>(8) == 2);
+ ASL_TEST_EXPECT(test_fwd_like<int&&>(9) == 4);
}
generated by cgit (git 2.34.1) at 2025-06-01 21:15:35 +0000