Rename BufferSize to ArenaSize

Signed-off-by: Pavel Artsishevsky <polter.rnd@gmail.com>

include/log/logger.h

@@ -20,8 +20,8 @@
 
 namespace PlainCloud::Log {
 
-/** Default buffer size is equal to typical memory page size */
-static constexpr size_t DefaultBufferSize = 4096;
+/** Default arena size is equal to typical memory page size */
+static constexpr size_t DefaultArenaSize = 4096;
 
 /** @cond */
 namespace Detail {
@@ -75,21 +75,19 @@ using UnderlyingCharType = typename UnderlyingChar<T>::Type;
  *              Deduced automatically for standard C++ string types and for plain C strings.
  * @tparam ThreadingPolicy Threading policy used for operating over sinks and log level
  *                         (e.g. SingleThreadedPolicy or MultiThreadedPolicy).
- * @tparam StaticBufferSize Size of internal pre-allocated buffer. Defaults to 4096 bytes.
+ * @tparam ArenaSize Size of internal pre-allocated arena. Defaults to 4096 bytes.
  */
 template<
     typename String,
     typename Char = Detail::UnderlyingCharType<String>,
     typename ThreadingPolicy = MultiThreadedPolicy<>,
-    size_t StaticBufferSize = DefaultBufferSize>
+    size_t ArenaSize = DefaultArenaSize>
 class Logger {
 public:
     /** @brief String type for log messages. */
     using StringType = String;
     /** @brief Char type for log messages. */
     using CharType = Char;
-    /** @brief Size of internal pre-allocatied buffer. */
-    static constexpr auto BufferSize = StaticBufferSize;
 
     Logger(Logger const&) = delete;
     Logger(Logger&&) = delete;
@@ -326,9 +324,9 @@ class Logger {
     std::shared_ptr<Logger> m_parent;
     String m_category;
     LevelDriver<ThreadingPolicy> m_level;
-    SinkDriver<Logger, ThreadingPolicy> m_sinks;
+    SinkDriver<Logger, ThreadingPolicy, ArenaSize> m_sinks;
 
-    template<typename Logger, typename Policy>
+    template<typename, typename, size_t>
     friend class SinkDriver;
 };
 

include/log/sink.h

@@ -13,6 +13,7 @@
 
 #include <array>
 #include <atomic>
+#include <cstddef>
 #include <initializer_list>
 #include <memory>
 #include <memory_resource>
@@ -201,34 +202,33 @@ class Sink : public std::enable_shared_from_this<Sink<Logger>> {
 /**
  * @brief Basic log sink driver class.
  *
- * @tparam String Base string type used for log messages.
+ * @tparam Logger Base string type used for log messages.
  * @tparam ThreadingPolicy Threading policy used for operating over sinks
  *                         (e.g. SingleThreadedPolicy or MultiThreadedPolicy).
+ * @tparam ArenaSize Size of internal pre-allocated arena. Defaults to 4096 bytes.
  *
  * @note Class doesn't have a virtual destructor
  *       as the intended usage scenario is to
  *       use it as a private base class explicitly
  *       moving access functions to public part of a base class.
  */
-template<typename String, typename ThreadingPolicy>
+template<typename Logger, typename ThreadingPolicy, size_t ArenaSize>
 class SinkDriver final { };
 
 /**
  * @brief Single-threaded log sink driver.
  *
  * Handles sinks access without any synchronization.
- *
- * @tparam String Base string type used for log messages.
  */
-template<typename Logger>
-class SinkDriver<Logger, SingleThreadedPolicy> final {
+template<typename Logger, size_t ArenaSize>
+class SinkDriver<Logger, SingleThreadedPolicy, ArenaSize> final {
 public:
     /** @brief Char type for log messages. */
     using CharType = typename Logger::CharType;
     /** @brief Buffer used for log message formatting. */
     using FormatBufferType = typename Sink<Logger>::FormatBufferType;
     /** @brief Arena for internal memory allocations. */
-    using ArenaType = typename std::array<char, Logger::BufferSize>;
+    using ArenaType = typename std::array<std::byte, ArenaSize>;
 
     /**
      * @brief Add existing sink.
@@ -435,25 +435,28 @@ class SinkDriver<Logger, SingleThreadedPolicy> final {
  * @brief Multi-threaded log sink driver.
  *
  * Handles sinks access with locking a mutex.
- *
- * @tparam String Base string type used for log messages.
  */
 template<
     typename Logger,
     typename Mutex,
     typename ReadLock,
     typename WriteLock,
     std::memory_order LoadOrder,
-    std::memory_order StoreOrder>
-class SinkDriver<Logger, MultiThreadedPolicy<Mutex, ReadLock, WriteLock, LoadOrder, StoreOrder>>
+    std::memory_order StoreOrder,
+    size_t ArenaSize>
+class SinkDriver<
+    Logger,
+    MultiThreadedPolicy<Mutex, ReadLock, WriteLock, LoadOrder, StoreOrder>,
+    ArenaSize>
     final {
 public:
     /** @brief Char type for log messages. */
     using CharType = typename Logger::CharType;
     /** @brief Buffer used for log message formatting. */
-    using FormatBufferType = typename SinkDriver<Logger, SingleThreadedPolicy>::FormatBufferType;
+    using FormatBufferType =
+        typename SinkDriver<Logger, SingleThreadedPolicy, ArenaSize>::FormatBufferType;
     /** @brief Arena for internal memory allocations. */
-    using ArenaType = typename std::array<char, Logger::BufferSize>;
+    using ArenaType = typename std::array<std::byte, ArenaSize>;
 
     /**
      * @brief Add existing sink.
@@ -571,9 +574,9 @@ class SinkDriver<Logger, MultiThreadedPolicy<Mutex, ReadLock, WriteLock, LoadOrd
 
 private:
     mutable Mutex m_mutex;
-    SinkDriver<Logger, SingleThreadedPolicy> m_sinks;
+    SinkDriver<Logger, SingleThreadedPolicy, ArenaSize> m_sinks;
 
-    friend class SinkDriver<Logger, SingleThreadedPolicy>;
+    friend class SinkDriver<Logger, SingleThreadedPolicy, ArenaSize>;
 };
 
 } // namespace PlainCloud::Log