hello

CMakeLists.txt

@@ -27,7 +27,7 @@ macro(compile_options target_name)
     sanitizers(${target_name})
 endmacro()
 
-project(blt-gp VERSION 0.2.8)
+project(blt-gp VERSION 0.2.9)
 
 include(CTest)
 

include/blt/gp/stack.h

@@ -47,9 +47,10 @@ namespace blt::gp
     {
         constexpr static blt::size_t PAGE_SIZE = 0x100;
         constexpr static blt::size_t MAX_ALIGNMENT = 8;
-            template<typename T>
+        template <typename T>
         using NO_REF_T = std::remove_cv_t<std::remove_reference_t<T>>;
         using Allocator = aligned_allocator;
+
     public:
         static Allocator& get_allocator();
 
@@ -64,13 +65,15 @@ namespace blt::gp
                 stream << "[";
                 stream << data.total_used_bytes << " / " << data.total_size_bytes;
                 stream << " ("
-                           << (data.total_size_bytes != 0 ? (static_cast<double>(data.total_used_bytes) / static_cast<double>(data.total_size_bytes) *
+                    << (data.total_size_bytes != 0
-                                                             100) : 0) << "%); space left: " << data.total_remaining_bytes << "]";
+                            ? (static_cast<double>(data.total_used_bytes) / static_cast<double>(data.total_size_bytes) *
+                                100)
+                            : 0) << "%); space left: " << data.total_remaining_bytes << "]";
                 return stream;
             }
         };
 
-            template<typename T>
+        template <typename T>
         static inline constexpr blt::size_t aligned_size() noexcept
         {
             return aligned_size(sizeof(NO_REF_T<T>));
@@ -94,7 +97,8 @@ namespace blt::gp
 
         stack_allocator(stack_allocator&& move) noexcept:
             data_(std::exchange(move.data_, nullptr)), bytes_stored(std::exchange(move.bytes_stored, 0)), size_(std::exchange(move.size_, 0))
-            {}
+        {
+        }
 
         stack_allocator& operator=(const stack_allocator& copy) = delete;
 
@@ -148,7 +152,7 @@ namespace blt::gp
             std::memcpy(data, data_ + (bytes_stored - bytes), bytes);
         }
 
-            template<typename T, typename NO_REF = NO_REF_T<T>>
+        template <typename T, typename NO_REF = NO_REF_T<T>>
         void push(const T& t)
         {
             static_assert(std::is_trivially_copyable_v<NO_REF> && "Type must be bitwise copyable!");
@@ -157,7 +161,7 @@ namespace blt::gp
             std::memcpy(ptr, &t, sizeof(NO_REF));
         }
 
-            template<typename T, typename NO_REF = NO_REF_T<T>>
+        template <typename T, typename NO_REF = NO_REF_T<T>>
         T pop()
         {
             static_assert(std::is_trivially_copyable_v<NO_REF> && "Type must be bitwise copyable!");
@@ -181,7 +185,7 @@ namespace blt::gp
             return data_ + (bytes_stored - bytes);
         }
 
-            template<typename T, typename NO_REF = NO_REF_T<T>>
+        template <typename T, typename NO_REF = NO_REF_T<T>>
         T& from(blt::size_t bytes)
         {
             static_assert(std::is_trivially_copyable_v<NO_REF> && "Type must be bitwise copyable!");
@@ -211,7 +215,7 @@ namespace blt::gp
             pop_bytes(alg);
         }
 
-            template<typename... Args>
+        template <typename... Args>
         void call_destructors()
         {
             if constexpr (sizeof...(Args) > 0)
@@ -316,22 +320,38 @@ namespace blt::gp
             return aligned_ptr;
         }
 
-            template<typename T>
+        template <typename T>
         inline void call_drop(blt::size_t offset)
         {
             if constexpr (detail::has_func_drop_v<T>)
             {
-                    from<NO_REF_T<T >>(offset).drop();
+                from<NO_REF_T<T>>(offset).drop();
             }
         }
 
-            blt::u8* data_ = nullptr;
+        u8* data_ = nullptr;
         // place in the data_ array which has a free spot.
-            blt::size_t bytes_stored = 0;
+        size_t bytes_stored = 0;
-            blt::size_t size_ = 0;
+        size_t size_ = 0;
     };
 
+    template <size_t Size>
+    struct ref_counted_type
+    {
+        explicit ref_counted_type(size_t* ref_count): ref_count(ref_count)
+        {
+        }
 
+        size_t* ref_count = nullptr;
+        u8 storage[Size]{};
+
+        static size_t* access(const void* ptr)
+        {
+            ref_counted_type<1> type{nullptr};
+            std::memcpy(&type, ptr, sizeof(size_t*));
+            return type.ref_count;
+        }
+    };
 }
 
 #endif //BLT_GP_STACK_H