Refactored td to properly use Concepts

Author: NicholasBerryman

Allocator/Arena_ULL.ixx

@@ -4,6 +4,7 @@
 
 module;
 #include <type_traits>
+#include <concepts>
 #include "include/Allocator.h"
 
 export module SG_Allocator:Arena;
@@ -23,11 +24,13 @@ export namespace SG_Allocator {
 	 * @tparam blockSize Number of bytes per block
 	 * @tparam maxSublifetimes Max number of simultaneously open sublifetimes
 	 */
-	template<arenaSize_t blockSize, localSize_t maxSublifetimes>
-    class Arena_ULL : private BaseArena {
+	template<std::integral auto blockSize, localSize_t maxSublifetimes, std::integral arenaSize_t_ = defaultArenaSize_t>
+    class Arena_ULL {
         static_assert(blockSize > 0, "Blocksize must be > 0");
 
         public:
+		using arenaSize_t = arenaSize_t_;
+
 		Arena_ULL();
 		Arena_ULL(const Arena_ULL&) = delete;
 
@@ -57,17 +60,18 @@ export namespace SG_Allocator {
                 arenaSize_t initialLength;
             };
 
-			ULL<PseudoArena, char> impl;
+			ULL<PseudoArena<>, char> impl;
     		LocalDataStructures::Stack<Sublifetime, maxSublifetimes> sublifetimeStack;
     };
-
+	static_assert(OptionalArena_c<Arena_ULL<100,100>, char, char>);
+	static_assert(OptionalArena_c<Arena_ULL<100,100>, int, int>);
 }
 
 /**
  * @brief Constructs an arena object with an Unrolled Linked List backend
  */
-template<SG_Allocator::arenaSize_t blockSize, localSize_t maxSublifetimes>
-SG_Allocator::Arena_ULL<blockSize, maxSublifetimes>::Arena_ULL():
+template<std::integral auto blockSize, localSize_t maxSublifetimes, std::integral arenaSize_t_>
+SG_Allocator::Arena_ULL<blockSize, maxSublifetimes, arenaSize_t_>::Arena_ULL():
 	impl(globalPseudoArena, blockSize),
 	sublifetimeStack()
 {}
@@ -77,9 +81,9 @@ SG_Allocator::Arena_ULL<blockSize, maxSublifetimes>::Arena_ULL():
  * @tparam T Type to allocate space for
  * @return Pointer to allocated memory of type T*
  */
-template<SG_Allocator::arenaSize_t blockSize, localSize_t maxSublifetimes>
+template<std::integral auto blockSize, localSize_t maxSublifetimes, std::integral arenaSize_t_>
 template<typename T>
-T * SG_Allocator::Arena_ULL<blockSize, maxSublifetimes>::alloc() {
+T * SG_Allocator::Arena_ULL<blockSize, maxSublifetimes, arenaSize_t_>::alloc() {
 #ifdef DISABLE_NONFUNDAMENTAL_ALLOC
 #ifndef NDEBUG
 	static_assert(std::is_fundamental_v<T> || (std::is_standard_layout_v<T> && std::is_trivially_default_constructible_v<T> && std::is_trivially_copyable_v<T>) || std::is_pointer_v<T>);
@@ -94,9 +98,9 @@ T * SG_Allocator::Arena_ULL<blockSize, maxSublifetimes>::alloc() {
  * @param arrayLength Length of array to allocate
  * @return Pointer to allocated array (address of first element)
  */
-template<SG_Allocator::arenaSize_t blockSize, localSize_t maxSublifetimes>
+template<std::integral auto blockSize, localSize_t maxSublifetimes, std::integral arenaSize_t_>
 template<typename T>
-T * SG_Allocator::Arena_ULL<blockSize, maxSublifetimes>::allocArray(const arenaSize_t& arrayLength) {
+T * SG_Allocator::Arena_ULL<blockSize, maxSublifetimes, arenaSize_t_>::allocArray(const arenaSize_t& arrayLength) {
 	return impl.allocArray<T>(arrayLength);
 }
 
@@ -107,9 +111,9 @@ T * SG_Allocator::Arena_ULL<blockSize, maxSublifetimes>::allocArray(const arenaS
  * @param args Values of constructor args (can be empty)
  * @return Pointer to allocated memory of type T*
  */
-template<SG_Allocator::arenaSize_t blockSize, localSize_t maxSublifetimes>
+template<std::integral auto blockSize, localSize_t maxSublifetimes, std::integral arenaSize_t_>
 template<typename T, typename ... ConstructorArgs>
-T * SG_Allocator::Arena_ULL<blockSize, maxSublifetimes>::allocConstruct(ConstructorArgs&&... args) {
+T * SG_Allocator::Arena_ULL<blockSize, maxSublifetimes, arenaSize_t_>::allocConstruct(ConstructorArgs&&... args) {
 	return new (impl.alloc<T>()) T(args...);
 }
 
@@ -121,9 +125,9 @@ T * SG_Allocator::Arena_ULL<blockSize, maxSublifetimes>::allocConstruct(Construc
  * @param args Values of constructor args (can be empty)
  * @return Pointer to allocated array (address of first element)
  */
-template<SG_Allocator::arenaSize_t blockSize, localSize_t maxSublifetimes>
+template<std::integral auto blockSize, localSize_t maxSublifetimes, std::integral arenaSize_t_>
 template<typename T, typename ... ConstructorArgs>
-T * SG_Allocator::Arena_ULL<blockSize, maxSublifetimes>::allocConstructArray(const arenaSize_t& arrayLength, ConstructorArgs&&... args) {
+T * SG_Allocator::Arena_ULL<blockSize, maxSublifetimes, arenaSize_t_>::allocConstructArray(const arenaSize_t& arrayLength, ConstructorArgs&&... args) {
 	T* out = allocArray<T>(arrayLength);
 	for (auto i = 0; i < arrayLength; i++) new (&out[i]) T(args...);
 	return out;
@@ -132,17 +136,17 @@ T * SG_Allocator::Arena_ULL<blockSize, maxSublifetimes>::allocConstructArray(con
 /**
  * @brief Marks all memory in arena as overwritable, and deallocates non-root blocks - DOES NOT CALL DESTRUCTORS
  */
-template<SG_Allocator::arenaSize_t blockSize, localSize_t maxSublifetimes>
-void SG_Allocator::Arena_ULL<blockSize, maxSublifetimes>::clear() {
+template<std::integral auto blockSize, localSize_t maxSublifetimes, std::integral arenaSize_t_>
+void SG_Allocator::Arena_ULL<blockSize, maxSublifetimes, arenaSize_t_>::clear() {
 	impl.clear();
 	sublifetimeStack.clear();
 }
 
 /**
  * @brief Marks all memory in arena as overwritable, but does not deallocate non-root blocks - DOES NOT CALL DESTRUCTORS
  */
-template<SG_Allocator::arenaSize_t blockSize, localSize_t maxSublifetimes>
-void SG_Allocator::Arena_ULL<blockSize, maxSublifetimes>::softClear() {
+template<std::integral auto blockSize, localSize_t maxSublifetimes, std::integral arenaSize_t_>
+void SG_Allocator::Arena_ULL<blockSize, maxSublifetimes, arenaSize_t_>::softClear() {
 	impl.softClear();
 	sublifetimeStack.clear();
 }
@@ -151,58 +155,56 @@ void SG_Allocator::Arena_ULL<blockSize, maxSublifetimes>::softClear() {
  * @brief Pre-allocates enough blocks to fit the specified number of bytes
  * @param newSize Size to allocate space up to
  */
-template<SG_Allocator::arenaSize_t blockSize, localSize_t maxSublifetimes>
-void SG_Allocator::Arena_ULL<blockSize, maxSublifetimes>::expand(const arenaSize_t& newSize) {
+template<std::integral auto blockSize, localSize_t maxSublifetimes, std::integral arenaSize_t_>
+void SG_Allocator::Arena_ULL<blockSize, maxSublifetimes, arenaSize_t_>::expand(const arenaSize_t& newSize) {
 	impl.expand(newSize);
 }
 
 /**
  *
  * @return Max number of bytes that can be allocated before a new block is required
  */
-template<SG_Allocator::arenaSize_t blockSize, localSize_t maxSublifetimes>
-SG_Allocator::arenaSize_t SG_Allocator::Arena_ULL<blockSize, maxSublifetimes>::maxSize() const {
+template<std::integral auto blockSize, localSize_t maxSublifetimes, std::integral arenaSize_t_>
+SG_Allocator::Arena_ULL<blockSize, maxSublifetimes, arenaSize_t_>::arenaSize_t SG_Allocator::Arena_ULL<blockSize, maxSublifetimes, arenaSize_t_>::maxSize() const {
 	return impl.maxSize();
 }
 
 /**
  *
  * @return Current number of bytes that have been allocated within the Arena. Includes fragmented memory that may occur at block tails
  */
-template<SG_Allocator::arenaSize_t blockSize, localSize_t maxSublifetimes>
-SG_Allocator::arenaSize_t SG_Allocator::Arena_ULL<blockSize, maxSublifetimes>::usedSpace() const {
+template<std::integral auto blockSize, localSize_t maxSublifetimes, std::integral arenaSize_t_>
+SG_Allocator::Arena_ULL<blockSize, maxSublifetimes, arenaSize_t_>::arenaSize_t SG_Allocator::Arena_ULL<blockSize, maxSublifetimes, arenaSize_t_>::usedSpace() const {
 	return impl.length();
 }
 
 /**
  * @brief Begin a sublifetime and add it to the top of the sublifetime stack
  */
-template<SG_Allocator::arenaSize_t blockSize, localSize_t maxSublifetimes>
-void SG_Allocator::Arena_ULL<blockSize, maxSublifetimes>::sublifetime_open() {
+template<std::integral auto blockSize, localSize_t maxSublifetimes, std::integral arenaSize_t_>
+void SG_Allocator::Arena_ULL<blockSize, maxSublifetimes, arenaSize_t_>::sublifetime_open() {
 	Sublifetime sl;
 	sl.initialLength = impl.length();
-	sl.rootNode = NodeExaminer<PseudoArena, char>::currentTail(impl);
+	sl.rootNode = NodeExaminer<PseudoArena<>, char>::currentTail(impl);
 	sublifetimeStack.push(sl);
 }
 
 /**
  * @brief Pop a sublifetime from the sublifetime stack and deallocate memory allocated and blocks created since it opened. DOES NOT CALL DESTRUCTORS
  */
-template<SG_Allocator::arenaSize_t blockSize, localSize_t maxSublifetimes>
-void SG_Allocator::Arena_ULL<blockSize, maxSublifetimes>::sublifetime_rollback(){
+template<std::integral auto blockSize, localSize_t maxSublifetimes, std::integral arenaSize_t_>
+void SG_Allocator::Arena_ULL<blockSize, maxSublifetimes, arenaSize_t_>::sublifetime_rollback(){
 	Sublifetime rollback = sublifetimeStack.pop();
-	NodeExaminer<PseudoArena, char>::setTail(impl, rollback.rootNode, rollback.initialLength);
-	NodeExaminer<PseudoArena, char>::shrink(impl);
+	NodeExaminer<PseudoArena<>, char>::setTail(impl, rollback.rootNode, rollback.initialLength);
+	NodeExaminer<PseudoArena<>, char>::shrink(impl);
 }
 
 /**
  * Pop a sublifetime from the sublifetime stack and deallocate memory allocated but not blocks created since it opened. DOES NOT CALL DESTRUCTORS
  */
-template<SG_Allocator::arenaSize_t blockSize, localSize_t maxSublifetimes>
-void SG_Allocator::Arena_ULL<blockSize, maxSublifetimes>::sublifetime_softRollback(){
+template<std::integral auto blockSize, localSize_t maxSublifetimes, std::integral arenaSize_t_>
+void SG_Allocator::Arena_ULL<blockSize, maxSublifetimes, arenaSize_t_>::sublifetime_softRollback(){
 	Sublifetime rollback = sublifetimeStack.pop();
-	NodeExaminer<PseudoArena, char>::setTail(impl, rollback.rootNode, rollback.initialLength);
+	NodeExaminer<PseudoArena<>, char>::setTail(impl, rollback.rootNode, rollback.initialLength);
 }
 
-
-

Allocator/BaseArena.ixx

@@ -1,17 +1,47 @@
 //
 // Created by nickberryman on 1/12/25.
 //
+module;
+#include <concepts>
+
 export module SG_Allocator:BaseArena;
 import SG_AllocatorConfigs;
 import Logger;
 
 export namespace SG_Allocator {
+    template <typename T, typename canAlloc, typename... canAllocArgs>
+    concept BaseArena_c  = requires(T t, canAlloc a, typename T::arenaSize_t siz, canAllocArgs... args)
+    {
+        typename T::arenaSize_t;
+        {t.template alloc<canAlloc>()} -> std::same_as<canAlloc*>;
+        {t.template allocArray<canAlloc>(3)} -> std::same_as<canAlloc*>;
+        {t.template allocConstruct<canAlloc>(args...)} -> std::same_as<canAlloc*>;
+        {t.template allocConstructArray<canAlloc>(3, args...)} -> std::same_as<canAlloc*>;
+        {t.sublifetime_open()};
+        {t.sublifetime_rollback()};
+        {t.sublifetime_softRollback()};
+        {t.clear()};
+        {t.softClear()};
+        {t.expand(siz)};
+        {t.maxSize()} -> std::same_as<typename T::arenaSize_t>;
+        {t.usedSpace()} -> std::same_as<typename T::arenaSize_t>;
+    };
+
+    template <typename T, typename canAlloc, typename... canAllocArgs>
+    concept OptionalArena_c  = requires(T t, canAlloc* a)
+    {
+        {t.softDelete(a)};
+        {t.softDeleteArray(a)};
+    } && BaseArena_c<T, canAlloc, canAllocArgs...>;
+
     /**
-     * @brief Base class for arena allocators. Should only be inhereted from, never used directly
-     * 
+     * @brief Base class for arena allocators. Should only be inherited from, never used directly
+     *
      */
     class BaseArena {
     public:
+        using arenaSize_t = defaultArenaSize_t;
+
         template<typename T> inline T* alloc(){Logging::assert_except(0); return nullptr;};
         template<typename T> inline T* allocArray(arenaSize_t arrayLength){Logging::assert_except(0); return nullptr;};
 		template<typename T, typename... ConstructorArgs> inline T* allocConstruct(ConstructorArgs... args){Logging::assert_except(0); return nullptr;};