[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: pre-commit-ci[bot]

atom/extra/asio/CMakeLists.txt

@@ -95,15 +95,15 @@ set(ASIO_SOURCES
     concurrency/memory_manager.hpp
     concurrency/concurrency.hpp
     concurrency/concurrency.cpp
-    
+
     # Enhanced MQTT implementation
     mqtt/client.cpp
     mqtt/client.hpp
     mqtt/packet.cpp
     mqtt/packet.hpp
     mqtt/protocol.hpp
     mqtt/types.hpp
-    
+
     # Enhanced SSE implementation
     sse/event.cpp
     sse/event.hpp
@@ -126,7 +126,7 @@ set(ASIO_SOURCES
     sse/server/server.hpp
     sse/server/server_config.cpp
     sse/server/server_config.hpp
-    
+
     # Core compatibility layer
     asio_compatibility.hpp
 )
@@ -191,20 +191,20 @@ endif()
 option(ATOM_ASIO_BUILD_TESTS "Build ASIO tests" OFF)
 if(ATOM_ASIO_BUILD_TESTS)
     find_package(GTest REQUIRED)
-    
+
     add_executable(atom-asio-tests
         mqtt/test_client.hpp
         mqtt/test_packet.hpp
         mqtt/test_protocol.hpp
         mqtt/test_types.hpp
     )
-    
+
     target_link_libraries(atom-asio-tests
         PRIVATE
             atom-asio-advanced
             GTest::gtest_main
     )
-    
+
     # Enable testing
     enable_testing()
     add_test(NAME AsioTests COMMAND atom-asio-tests)
@@ -214,13 +214,13 @@ endif()
 option(ATOM_ASIO_BUILD_BENCHMARKS "Build ASIO benchmarks" OFF)
 if(ATOM_ASIO_BUILD_BENCHMARKS)
     find_package(benchmark REQUIRED)
-    
+
     add_executable(atom-asio-benchmarks
         benchmarks/mqtt_benchmark.cpp
         benchmarks/sse_benchmark.cpp
         benchmarks/concurrency_benchmark.cpp
     )
-    
+
     target_link_libraries(atom-asio-benchmarks
         PRIVATE
             atom-asio-advanced

atom/extra/asio/concurrency/adaptive_spinlock.hpp

@@ -15,14 +15,14 @@ namespace atom::extra::asio::concurrency {
 
 /**
  * @brief Adaptive spinlock with exponential backoff for optimal performance
- * 
+ *
  * This spinlock implementation adapts its behavior based on contention levels,
  * using CPU pause instructions for short waits and yielding for longer waits.
  */
 class adaptive_spinlock {
 private:
     cache_aligned<std::atomic<bool>> locked_{false};
-    
+
     // Backoff parameters
     static constexpr std::size_t initial_pause_count = 4;
     static constexpr std::size_t max_pause_count = 64;
@@ -34,7 +34,7 @@ class adaptive_spinlock {
      * @brief Construct an unlocked adaptive spinlock
      */
     adaptive_spinlock() = default;
-    
+
     // Non-copyable, non-movable
     adaptive_spinlock(const adaptive_spinlock&) = delete;
     adaptive_spinlock& operator=(const adaptive_spinlock&) = delete;
@@ -47,7 +47,7 @@ class adaptive_spinlock {
     void lock() noexcept {
         std::size_t pause_count = initial_pause_count;
         std::size_t iteration = 0;
-        
+
         while (true) {
             // Fast path: try to acquire immediately
             if (!locked_.get().exchange(true, std::memory_order_acquire)) {
@@ -56,14 +56,14 @@ class adaptive_spinlock {
                 }
                 return;
             }
-            
+
             // Adaptive backoff strategy
             if (iteration < yield_threshold) {
                 // Phase 1: CPU pause with exponential backoff
                 for (std::size_t i = 0; i < pause_count; ++i) {
                     cpu_pause();
                 }
-                
+
                 // Exponential backoff up to maximum
                 if (pause_count < max_pause_count) {
                     pause_count *= 2;
@@ -74,12 +74,12 @@ class adaptive_spinlock {
             } else {
                 // Phase 3: Brief sleep for heavily contended locks
                 std::this_thread::sleep_for(sleep_threshold);
-                
+
                 if (iteration % 1000 == 0) {
                     spdlog::warn("Adaptive spinlock heavily contended, iteration: {}", iteration);
                 }
             }
-            
+
             ++iteration;
         }
     }
@@ -144,14 +144,14 @@ class adaptive_lock_guard {
 
 /**
  * @brief Reader-writer spinlock with priority inheritance
- * 
+ *
  * Optimized for scenarios with many readers and few writers,
  * providing excellent read performance while ensuring writer fairness.
  */
 class reader_writer_spinlock {
 private:
     cache_aligned<std::atomic<std::int32_t>> state_{0};
-    
+
     // State encoding: positive = reader count, -1 = writer, 0 = unlocked
     static constexpr std::int32_t writer_flag = -1;
     static constexpr std::int32_t max_readers = std::numeric_limits<std::int32_t>::max();
@@ -173,26 +173,26 @@ class reader_writer_spinlock {
      */
     void lock_shared() noexcept {
         std::size_t iteration = 0;
-        
+
         while (true) {
             std::int32_t current = state_.get().load(std::memory_order_acquire);
-            
+
             // Can acquire read lock if no writer and not at max readers
             if (current >= 0 && current < max_readers) {
-                if (state_.get().compare_exchange_weak(current, current + 1, 
+                if (state_.get().compare_exchange_weak(current, current + 1,
                                                       std::memory_order_acquire)) {
                     spdlog::trace("Reader lock acquired, reader count: {}", current + 1);
                     return;
                 }
             }
-            
+
             // Adaptive backoff for readers
             if (iteration < 32) {
                 cpu_pause();
             } else {
                 std::this_thread::yield();
             }
-            
+
             ++iteration;
         }
     }
@@ -210,15 +210,15 @@ class reader_writer_spinlock {
      */
     void lock() noexcept {
         std::size_t iteration = 0;
-        
+
         while (true) {
             std::int32_t expected = 0;
-            if (state_.get().compare_exchange_weak(expected, writer_flag, 
+            if (state_.get().compare_exchange_weak(expected, writer_flag,
                                                   std::memory_order_acquire)) {
                 spdlog::trace("Writer lock acquired");
                 return;
             }
-            
+
             // Adaptive backoff for writers
             if (iteration < 16) {
                 cpu_pause();
@@ -227,7 +227,7 @@ class reader_writer_spinlock {
             } else {
                 std::this_thread::sleep_for(std::chrono::microseconds(1));
             }
-            
+
             ++iteration;
         }
     }
@@ -245,12 +245,12 @@ class reader_writer_spinlock {
      */
     bool try_lock_shared() noexcept {
         std::int32_t current = state_.get().load(std::memory_order_acquire);
-        
+
         if (current >= 0 && current < max_readers) {
-            return state_.get().compare_exchange_strong(current, current + 1, 
+            return state_.get().compare_exchange_strong(current, current + 1,
                                                        std::memory_order_acquire);
         }
-        
+
         return false;
     }
 
@@ -259,7 +259,7 @@ class reader_writer_spinlock {
      */
     bool try_lock() noexcept {
         std::int32_t expected = 0;
-        return state_.get().compare_exchange_strong(expected, writer_flag, 
+        return state_.get().compare_exchange_strong(expected, writer_flag,
                                                    std::memory_order_acquire);
     }
 };

atom/extra/asio/concurrency/concurrency.cpp

@@ -6,7 +6,7 @@ namespace atom::extra::asio::concurrency {
 std::unique_ptr<concurrency_manager> concurrency_manager::instance_;
 std::once_flag concurrency_manager::init_flag_;
 
-// Static member definitions for memory_manager  
+// Static member definitions for memory_manager
 std::unique_ptr<memory_manager> memory_manager::instance_;
 std::once_flag memory_manager::init_flag_;
 

atom/extra/asio/concurrency/concurrency.hpp

@@ -3,7 +3,7 @@
 /**
  * @file concurrency.hpp
  * @brief Comprehensive concurrency framework with cutting-edge C++23 primitives
- * 
+ *
  * This header provides access to all advanced concurrency components:
  * - Lock-free data structures with hazard pointers
  * - Adaptive synchronization primitives
@@ -56,14 +56,14 @@ class concurrent_object_pool {
             spdlog::trace("Object acquired from pool");
             return std::move(obj.value());
         }
-        
+
         // Allocate new object
         auto* raw_ptr = memory_pool_.allocate(std::forward<Args>(args)...);
         auto obj = std::unique_ptr<T>(raw_ptr);
-        
+
         total_allocated_.get().fetch_add(1, std::memory_order_relaxed);
         total_in_use_.get().fetch_add(1, std::memory_order_relaxed);
-        
+
         spdlog::trace("New object allocated for pool");
         return obj;
     }
@@ -104,7 +104,7 @@ class concurrency_manager {
 private:
     std::unique_ptr<work_stealing_thread_pool> thread_pool_;
     performance_monitor& perf_monitor_;
-    
+
     // Singleton instance
     static std::unique_ptr<concurrency_manager> instance_;
     static std::once_flag init_flag_;
@@ -113,9 +113,9 @@ class concurrency_manager {
         // Initialize with optimal thread count
         auto thread_count = std::thread::hardware_concurrency();
         if (thread_count == 0) thread_count = 4;
-        
+
         thread_pool_ = std::make_unique<work_stealing_thread_pool>(thread_count);
-        
+
         spdlog::info("Concurrency manager initialized with {} threads", thread_count);
     }
 
@@ -169,9 +169,9 @@ class concurrency_manager {
         spdlog::info("Thread pool size: {}", thread_pool_->size());
         spdlog::info("Pending tasks: {}", thread_pool_->pending_tasks());
         spdlog::info("Performance counters: {}", perf_monitor_.counter_count());
-        
+
         perf_monitor_.log_statistics();
-        
+
         spdlog::info("====================================");
     }
 };