Release 0.1.1: change allocate_object to allocate; change free_object to free

Author: kzhdev

CHANGELOG

@@ -5,7 +5,13 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [0.1.0] - 2025-01-23
+## [0.1.1] - 2025-11-12
+
+### Changed function signitures
+- Changed allocate_object() to allocate()
+- Changed free_object() to free()
+
+## [0.1.0] - 2025-10-23
 
 ### Added
 - Initial release of slick_object_pool
@@ -27,8 +33,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Features
 - `ObjectPool<T>` class template for type-safe object pooling
-- `allocate_object()` method for O(1) object allocation
-- `free_object()` method for O(1) object deallocation
+- `allocate()` method for O(1) object allocation
+- `free()` method for O(1) object deallocation
 - `size()` method to query pool capacity
 - Namespace: `slick::ObjectPool<T>`
 - Include path: `<slick/object_pool.h>`

CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.25)
 
-set(BUILD_VERSION 0.1.0)
+set(BUILD_VERSION 0.1.1)
 project(slick_object_pool VERSION ${BUILD_VERSION} LANGUAGES CXX)
 
 set(CMAKE_CXX_STANDARD 20)

DOCUMENTATION.md

@@ -73,15 +73,15 @@ Comprehensive documentation covering:
    - Pool size query
    - Power-of-2 note
 
-2. **T* allocate_object()**
+2. **T* allocate()**
    - Comprehensive documentation
    - Behavior under different conditions
    - Performance characteristics
    - Thread safety guarantees
    - Usage examples
    - Important warnings
 
-3. **void free_object(T* obj)**
+3. **void free(T* obj)**
    - Dual behavior (pool vs heap)
    - Automatic detection mechanism
    - Performance notes
@@ -219,7 +219,7 @@ All member variables are documented with inline comments (`///`):
 
 Focus on:
 - Constructor documentation
-- `allocate_object()` and `free_object()` methods
+- `allocate()` and `free()` methods
 - Thread safety guarantees
 - Code examples
 - Warnings and notes
@@ -270,15 +270,15 @@ Full documentation including:
  * @par Example
  * @code
  * slick::ObjectPool<MyStruct> pool(1024);
- * MyStruct* obj = pool.allocate_object();
+ * MyStruct* obj = pool.allocate();
  * obj->field = value;
- * pool.free_object(obj);
+ * pool.free(obj);
  * @endcode
  *
- * @note Must be paired with free_object() to avoid memory leaks
+ * @note Must be paired with free() to avoid memory leaks
  * @note Returned object is NOT automatically initialized
  */
-T* allocate_object();
+T* allocate();
 ```
 
 ### Key Elements

README.md

@@ -94,12 +94,12 @@ int main() {
     slick::ObjectPool<MyObject> pool(1024);
 
     // Allocate object from pool
-    MyObject* obj = pool.allocate_object();
+    MyObject* obj = pool.allocate();
     obj->id = 42;
     obj->value = 3.14;
 
     // Return object to pool
-    pool.free_object(obj);
+    pool.free(obj);
 
     return 0;
 }
@@ -170,15 +170,15 @@ int main() {
     slick::ObjectPool<Message> pool(512);
 
     // Allocate from pool
-    Message* msg = pool.allocate_object();
+    Message* msg = pool.allocate();
     msg->id = 1;
     std::strcpy(msg->data, "Hello, World!");
 
     // Use the object...
     std::cout << "Message: " << msg->data << std::endl;
 
     // Return to pool when done
-    pool.free_object(msg);
+    pool.free(msg);
 
     return 0;
 }
@@ -199,14 +199,14 @@ struct WorkItem {
 void worker_thread(slick::ObjectPool<WorkItem>& pool, int thread_id) {
     for (int i = 0; i < 10000; ++i) {
         // Allocate from pool (lock-free)
-        WorkItem* item = pool.allocate_object();
+        WorkItem* item = pool.allocate();
 
         // Do work
         item->task_id = thread_id * 10000 + i;
         process_work(*item);
 
         // Return to pool (lock-free)
-        pool.free_object(item);
+        pool.free(item);
     }
 }
 
@@ -235,8 +235,8 @@ int main() {
 
 The pool uses atomic compare-and-swap (CAS) operations to coordinate multiple producers and consumers without locks:
 
-- **Producers** (threads calling `allocate_object()`) atomically reserve slots from the pool
-- **Consumers** (threads calling `free_object()`) atomically return objects to the pool
+- **Producers** (threads calling `allocate()`) atomically reserve slots from the pool
+- **Consumers** (threads calling `free()`) atomically return objects to the pool
 - **Ring buffer** wrapping is handled atomically without blocking
 - **No spinlocks, no mutexes** - truly wait-free for successful operations
 
@@ -315,13 +315,13 @@ ObjectPool(uint32_t size);
 
 ```cpp
 // Allocate an object from the pool
-T* allocate_object();
+T* allocate();
 ```
 Returns a pointer to an object from the pool. If pool is exhausted, allocates a new object from heap.
 
 ```cpp
 // Return an object to the pool
-void free_object(T* obj);
+void free(T* obj);
 ```
 Returns an object to the pool if it belongs to the pool, otherwise deletes it.
 
@@ -454,8 +454,8 @@ sudo cmake --install .
 
 ### Guarantees
 
-- ✅ **Multiple producers** can call `allocate_object()` concurrently
-- ✅ **Multiple consumers** can call `free_object()` concurrently
+- ✅ **Multiple producers** can call `allocate()` concurrently
+- ✅ **Multiple consumers** can call `free()` concurrently
 - ✅ **Mixed operations** (allocate + free) are safe
 - ❌ **reset()** is NOT thread-safe (use when no other threads are active)
 
@@ -488,11 +488,11 @@ slick::ObjectPool<T> pool(1000);
 ### Pool Exhaustion Handling
 
 ```cpp
-// When pool is exhausted, allocate_object() allocates from heap
-T* obj = pool.allocate_object();  // May return heap-allocated object
+// When pool is exhausted, allocate() allocates from heap
+T* obj = pool.allocate();  // May return heap-allocated object
 
 // free_object() detects and handles both cases
-pool.free_object(obj);  // Works for pool or heap objects
+pool.free(obj);  // Works for pool or heap objects
 ```
 
 ### Type Design
@@ -536,7 +536,7 @@ struct FixedType {
 ## FAQ
 
 **Q: What happens when the pool is exhausted?**
-A: `allocate_object()` automatically allocates from heap. `free_object()` detects and deletes heap-allocated objects.
+A: `allocate()` automatically allocates from heap. `free()` detects and deletes heap-allocated objects.
 
 **Q: Can I use std::string or std::vector in pooled objects?**
 A: Yes! The pool works with any default constructible type, including std::string, std::vector, and other standard containers.

include/slick/object_pool.h

@@ -43,16 +43,16 @@ namespace slick {
  * @endcode
  *
  * @section thread_safety Thread Safety
- * - Multiple threads can call allocate_object() concurrently (lock-free)
- * - Multiple threads can call free_object() concurrently (lock-free)
+ * - Multiple threads can call allocate() concurrently (lock-free)
+ * - Multiple threads can call free() concurrently (lock-free)
  * - reset() is NOT thread-safe
  *
  * @section example Example Usage
  * @code
  * slick::ObjectPool<MyStruct> pool(1024);
- * auto* obj = pool.allocate_object();
+ * auto* obj = pool.allocate();
  * obj->field = value;
- * pool.free_object(obj);
+ * pool.free(obj);
  * @endcode
  *
  * @tparam T Object type to pool
@@ -193,11 +193,11 @@ class ObjectPool {
      *
      * @par Example
      * @code
-     * auto* obj = pool.allocate_object();
+     * auto* obj = pool.allocate();
      * obj->value = 42;
      * @endcode
      */
-    T* allocate_object() {
+    T* allocate() {
         auto [obj, size] = consume();
         if (!obj) {
             // Pool exhausted - allocate from heap
@@ -232,7 +232,7 @@ class ObjectPool {
      * @warning Do not free the same object twice
      * @warning Do not access object after calling free_object()
      */
-    void free_object(T* obj) {
+    void free(T* obj) {
         auto o = reinterpret_cast<intptr_t>(obj);
         if (o >= lower_bound_ && o <= upper_bound_) {
             // Object belongs to pool - return it

tests/CMakeLists.txt

@@ -6,7 +6,8 @@ if(NOT GTest_FOUND)
     include(FetchContent)
     FetchContent_Declare(
         googletest
-        URL https://github.com/google/googletest/archive/03597a01ee50ed33e9dfd640b249b4be3799d395.zip
+        GIT_REPOSITORY https://github.com/google/googletest.git
+        GIT_TAG v1.17.0
     )
     # For Windows: Prevent overriding the parent project's compiler/linker settings
     set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)