Implement reference_wrapper and invoke to allow invoke_result_t implementation

func.hpp

@@ -0,0 +1,95 @@
+#pragma once
+
+#include "util.hpp"
+
+#include "../type/type.hpp"
+
+namespace util {
+
+// <functional>
+
+// clang-format off
+
+namespace detail {
+
+template <typename> constexpr bool is_reference_wrapper_v = false;
+template <typename U> constexpr bool is_reference_wrapper_v<reference_wrapper<U>> = true;
+
+template <typename T, typename Type, typename T1, typename... Args>
+constexpr decltype(auto) INVOKE(Type T::*f, T1 &&t1, Args &&... args)
+{
+	if constexpr (type::is_member_function_pointer_v<decltype(f)>) {
+		if constexpr (type::is_base_of_v<T, type::decay_t<T1>>)
+			return (util::forward<T1>(t1).*f)(util::forward<Args>(args)...);
+		else if constexpr (is_reference_wrapper_v<type::decay_t<T1>>)
+			return (t1.get().*f)(util::forward<Args>(args)...);
+		else
+			return ((*util::forward<T1>(t1)).*f)(util::forward<Args>(args)...);
+	} else {
+		static_assert(type::is_member_object_pointer_v<decltype(f)>);
+		static_assert(sizeof...(args) == 0);
+		if constexpr (type::is_base_of_v<T, type::decay_t<T1>>)
+			return util::forward<T1>(t1).*f;
+		else if constexpr (is_reference_wrapper_v<type::decay_t<T1>>)
+			return t1.get().*f;
+		else
+			return (*util::forward<T1>(t1)).*f;
+	}
+}
+
+template <typename Fn, typename... Args>
+constexpr decltype(auto) INVOKE(Fn &&f, Args &&... args)
+{
+	return util::forward<Fn>(f)(util::forward<Args>(args)...);
+}
+
+template <typename T> constexpr T &FUN(T &t) noexcept { return t; }
+template <typename T> void FUN(T &&) = delete;
+
+} // namespace detail
+
+template <typename Fn, typename... Args>
+constexpr type::invoke_result_t<Fn, Args...> invoke(Fn &&f, Args &&... args)
+	noexcept(type::is_nothrow_invocable_v<Fn, Args...>)
+{
+	return detail::INVOKE(util::forward<Fn>(f), util::forward<Args>(args)...);
+}
+
+template <typename T>
+class reference_wrapper {
+  public:
+	// construct/copy/destroy
+	template <typename U,
+	          typename = decltype(detail::FUN<T>(util::declval<U>()),
+	                              type::enable_if_t<!type::is_same_v<reference_wrapper, type::remove_cvref_t<U>>>())>
+	constexpr reference_wrapper(U &&u) noexcept(noexcept(detail::FUN<T>(util::forward<U>(u))))
+	    : _ptr(util::addressof(detail::FUN<T>(util::forward<U>(u))))
+	{}
+	reference_wrapper(const reference_wrapper &) noexcept = default;
+
+	// assignment
+	reference_wrapper &operator=(const reference_wrapper &) noexcept = default;
+
+	// access
+	constexpr operator T &() const noexcept	{ return *_ptr; }
+	constexpr T &get() const noexcept { return *_ptr; }
+
+	template <typename... ArgTypes>
+	constexpr type::invoke_result_t<T &, ArgTypes...> operator()(ArgTypes &&... args) const
+	{
+		return invoke(get(), util::forward<ArgTypes>(args)...);
+	}
+
+	// types
+	using type = T;
+
+  private:
+	T *_ptr;
+};
+
+// deduction guides
+template <typename T> reference_wrapper(T &) -> reference_wrapper<T>;
+
+// clang-format on
+
+} // namespace util

util.hpp

@@ -1,51 +1,126 @@
 #pragma once
 
-#include <type_traits>
+#include <stdint.h>
-#include <utility>
 
-#include <cstddef>
+#include "../type/type.hpp"
-#include <cstdint>
 
 namespace util {
 
+// <memory>
+
+// clang-format off
+
+template <typename T>
+type::enable_if_t<type::is_object_v<T>, T *> addressof(T &arg) noexcept
+{
+	return reinterpret_cast<T *>(&const_cast<char &>(reinterpret_cast<const volatile char &>(arg)));
+}
+
+template <typename T>
+type::enable_if_t<!type::is_object_v<T>, T *> addressof(T &arg) noexcept
+{
+	return &arg;
+}
+
+// <utility>
+
+template <typename T> type::add_rvalue_reference_t<T> declval() noexcept;
+
+template <typename T>
+inline constexpr type::remove_reference_t<T> &&move(T &&t) noexcept
+{
+	return static_cast<type::remove_reference_t<T> &&>(t);
+}
+
+template <typename T>
+inline constexpr T &&forward(type::remove_reference_t<T> &t) noexcept
+{
+	return static_cast<T &&>(t);
+}
+
+template <typename T>
+inline constexpr T &&forward(type::remove_reference_t<T> &&t) noexcept
+{
+	static_assert(!type::is_lvalue_reference_v<T>, "Can not forward an rvalue as an lvalue.");
+	return static_cast<T &&>(t);
+}
+
+template <typename T, T... Ints>
+struct integer_sequence {
+	using __type = integer_sequence;
+	using value_type = T;
+
+	static constexpr size_t size() noexcept
+	{
+		return sizeof...(Ints);
+	}
+};
+
+template <size_t... Ints> using index_sequence = integer_sequence<size_t, Ints...>;
+
+namespace detail {
+
+template <typename T, typename Seq1, typename Seq2> struct concat;
+
+template <typename T, T... Ints1, T... Ints2>
+struct concat<T, integer_sequence<T, Ints1...>, integer_sequence<T, Ints2...>>
+    : integer_sequence<T, Ints1..., (sizeof...(Ints1) + Ints2)...>
+{};
+
+// uint64_t because this must be able to hold all possible sizes and cannot be T, because then the specialization for 0
+// and 1 are not possible
+template <typename T, uint64_t N>
+struct gen_integer_sequence : detail::concat<T, typename gen_integer_sequence<T, N / 2>::__type,
+                                             typename gen_integer_sequence<T, N - N / 2>::__type>
+{};
+
+template <typename T> struct gen_integer_sequence<T, 0> : integer_sequence<T> {};
+template <typename T> struct gen_integer_sequence<T, 1> : integer_sequence<T, 0> {};
+
+} // namespace detail
+
+template <typename T, T N>
+struct make_integer_sequence : detail::gen_integer_sequence<T, N> {
+	static_assert(N >= 0, "Integer sequence cannot be negative");
+};
+
+template <size_t N> using make_index_sequence = make_integer_sequence<size_t, N>;
+
+template <typename... T> using index_sequence_for = make_index_sequence<sizeof...(T)>;
+
+// Not part of <utility>, but very useful
+
 namespace detail {
 
 template <typename T, T Offset, T... Ints>
-inline constexpr std::integer_sequence<T, (Offset + Ints)...> add_offset(std::integer_sequence<T, Ints...>)
+inline constexpr integer_sequence<T, (Offset + Ints)...> add_offset(integer_sequence<T, Ints...>) {	return {}; }
-{
-	return {};
-}
 
 } // namespace detail
 
 template <typename T, T Offset, T N>
 inline constexpr auto make_offset_integer_sequence()
 {
-	return detail::add_offset<T, Offset>(std::make_integer_sequence<T, N>{});
+	return detail::add_offset<T, Offset>(make_integer_sequence<T, N>{});
 }
 
-template <std::size_t Offset, std::size_t N>
+template <size_t Offset, size_t N>
 inline constexpr auto make_offset_index_sequence()
 {
-	return make_offset_integer_sequence<std::size_t, Offset, N>();
+	return make_offset_integer_sequence<size_t, Offset, N>();
 }
 
-template <typename Fn, std::size_t... Ints>
+template <typename Fn, size_t... Ints>
-constexpr auto for_constexpr(Fn &&func, std::index_sequence<Ints...>)
+auto for_constexpr(Fn &&func, index_sequence<Ints...>)
 {
-	if constexpr (std::is_void_v<std::invoke_result_t<Fn, std::integral_constant<std::size_t, 0>>>) {
+	if constexpr (type::is_void_v<type::invoke_result_t<Fn, type::integral_constant<size_t, 0>>>) {
-		(func(std::integral_constant<std::size_t, Ints>{}), ...);
+		(func(type::integral_constant<size_t, Ints>{}), ...);
 	} else {
-		if ((func(std::integral_constant<std::size_t, Ints>{}) && ...))
+		if ((func(type::integral_constant<size_t, Ints>{}) && ...))
 			return true;
 		return false;
 	}
 }
 
-template <typename...>
+// clang-format on
-struct always_false : std::false_type {
-};
-template <typename... Ts>
-inline constexpr auto always_false_v = always_false<Ts...>::value;
 
 } // namespace util