Add project files

include/acrux/coroutines/Predicate.h

@@ -0,0 +1,117 @@
+#pragma once
+
+// ============================================================================
+// Predicate.hpp — small-buffer-optimized type-erased bool() callable.
+//
+// Stores any callable (lambda, functor) up to kBufferSize bytes INLINE — no
+// heap allocation — which is exactly what you need for the common case of a
+// lambda capturing `this` and/or a couple of coroutine-local values, e.g.:
+//
+//     WaitUntil([this]{ return this->targetInRange; })
+//     WaitUntil([hp = enemy->hp]{ return hp() <= 0; })
+// ============================================================================
+
+#include <cstddef>
+#include <new>
+#include <type_traits>
+#include <utility>
+#include <cassert>
+
+namespace acrux::coroutines
+{
+	class Predicate
+	{
+	public:
+		Predicate() noexcept = default;
+
+		template <typename F, typename = std::enable_if_t<!std::is_same_v<std::decay_t<F>, Predicate>>>
+		Predicate(F&& f)
+		{
+			using Fn = std::decay_t<F>;
+			static_assert(sizeof(Fn) <= BufferSize,
+				"Predicate: captured callable is too large for the inline buffer. "
+				"Capture by pointer/reference (e.g. [this]) instead of by value, "
+				"or increase Predicate::kBufferSize.");
+			static_assert(alignof(Fn) <= alignof(std::max_align_t),
+				"Predicate: captured callable's alignment exceeds max_align_t.");
+
+			::new (static_cast<void*>(&m_storage)) Fn(std::forward<F>(f));
+			m_vtable = &VTableFor<Fn>::table;
+		}
+
+		Predicate(const Predicate&) = delete;
+		Predicate& operator=(const Predicate&) = delete;
+
+		Predicate(Predicate&& other) noexcept { moveFrom(other); }
+
+		Predicate& operator=(Predicate&& other) noexcept
+		{
+			if (this != &other)
+			{
+				destroy();
+				moveFrom(other);
+			}
+			return *this;
+		}
+
+		~Predicate() { destroy(); }
+
+		bool operator()() const
+		{
+			assert(m_vtable && "Predicate invoked while empty");
+			return m_vtable->invoke(&m_storage);
+		}
+
+		explicit operator bool() const noexcept { return m_vtable != nullptr; }
+
+	private:
+		static constexpr size_t BufferSize = 32;
+
+		struct VTable
+		{
+			bool (*invoke)(const void*);
+			void (*move)(void* dst, void* src);
+			void (*destroy)(void*);
+		};
+
+		template <typename Fn>
+		struct VTableFor
+		{
+			static bool invoke(const void* p)
+			{
+				return (*reinterpret_cast<const Fn*>(p))();
+			}
+			static void move(void* dst, void* src)
+			{
+				::new (dst) Fn(std::move(*reinterpret_cast<Fn*>(src)));
+				reinterpret_cast<Fn*>(src)->~Fn();
+			}
+			static void destroy(void* p)
+			{
+				reinterpret_cast<Fn*>(p)->~Fn();
+			}
+			static inline const VTable table{ &invoke, &move, &destroy };
+		};
+
+		void moveFrom(Predicate& other) noexcept
+		{
+			m_vtable = other.m_vtable;
+			if (m_vtable)
+			{
+				m_vtable->move(&m_storage, &other.m_storage);
+				other.m_vtable = nullptr;
+			}
+		}
+		void destroy() noexcept
+		{
+			if (m_vtable)
+			{
+				m_vtable->destroy(&m_storage);
+				m_vtable = nullptr;
+			}
+		}
+
+		alignas(std::max_align_t) unsigned char m_storage[BufferSize];
+		const VTable* m_vtable = nullptr;
+	};
+}