1. renamed lib to to spitlog

2. Rotating bugfix

include/c11log/details/logger_impl.h

@@ -1,163 +0,0 @@
-#pragma once
-//
-// Logger implementation
-//
-
-
-#include "./line_logger.h"
-
-
-inline c11log::logger::logger(const std::string& logger_name, sinks_init_list sinks_list) :
-    _name(logger_name),
-    _sinks(sinks_list)
-{
-    // no support under vs2013 for member initialization for std::atomic
-    _level = level::INFO;
-}
-
-template<class It>
-inline c11log::logger::logger(const std::string& logger_name, const It& begin, const It& end) :
-    _name(logger_name),
-    _sinks(begin, end)
-{}
-
-
-inline void c11log::logger::set_formatter(c11log::formatter_ptr msg_formatter)
-{
-    _formatter = msg_formatter;
-}
-
-inline void c11log::logger::set_format(const std::string& format)
-{
-    _formatter = std::make_shared<pattern_formatter>(format);
-}
-
-inline c11log::formatter_ptr c11log::logger::get_formatter() const
-{
-    return _formatter;
-}
-
-
-template <typename... Args>
-inline c11log::details::line_logger c11log::logger::log(level::level_enum lvl, const Args&... args) {
-    bool msg_enabled = should_log(lvl);
-    details::line_logger l(this, lvl, msg_enabled);
-    if (msg_enabled)
-        _variadic_log(l, args...);
-    return l;
-}
-
-template <typename... Args>
-inline c11log::details::line_logger c11log::logger::trace(const Args&... args)
-{
-    return log(level::TRACE, args...);
-}
-
-template <typename... Args>
-inline c11log::details::line_logger c11log::logger::debug(const Args&... args)
-{
-    return log(level::DEBUG, args...);
-}
-
-template <typename... Args>
-inline c11log::details::line_logger c11log::logger::info(const Args&... args)
-{
-    return log(level::INFO, args...);
-}
-
-template <typename... Args>
-inline c11log::details::line_logger c11log::logger::warn(const Args&... args)
-{
-    return log(level::WARN, args...);
-}
-
-template <typename... Args>
-inline c11log::details::line_logger c11log::logger::error(const Args&... args)
-{
-    return log(level::ERR, args...);
-}
-
-template <typename... Args>
-inline c11log::details::line_logger c11log::logger::critical(const Args&... args)
-{
-    return log(level::CRITICAL, args...);
-}
-
-inline const std::string& c11log::logger::name() const
-{
-    return _name;
-}
-
-inline void c11log::logger::set_level(c11log::level::level_enum log_level)
-{
-    _level.store(log_level);
-}
-
-inline c11log::level::level_enum c11log::logger::level() const
-{
-    return static_cast<c11log::level::level_enum>(_level.load());
-}
-
-inline bool c11log::logger::should_log(c11log::level::level_enum msg_level) const
-{
-    return msg_level >= _level.load();
-}
-
-inline void c11log::logger::_variadic_log(c11log::details::line_logger&) {}
-
-template <typename First, typename... Rest>
-void c11log::logger::_variadic_log(c11log::details::line_logger& l, const First& first, const Rest&... rest)
-{
-    l.write(first);
-    l.write(' ');
-    _variadic_log(l, rest...);
-}
-
-inline void c11log::logger::_log_msg(details::log_msg& msg)
-{
-    //Use default formatter if not set
-    if (!_formatter)
-        _formatter = std::make_shared<pattern_formatter>("%+");
-    _formatter->format(msg);
-    for (auto &sink : _sinks)
-        sink->log(msg);
-}
-
-//
-// Global registry functions
-//
-#include "./registry.h"
-inline std::shared_ptr<c11log::logger> c11log::get(const std::string& name)
-{
-    return details::registry::instance().get(name);
-}
-
-inline std::shared_ptr<c11log::logger> c11log::create(const std::string& logger_name, c11log::sinks_init_list sinks)
-{
-    return details::registry::instance().create(logger_name, sinks);
-}
-
-
-template <typename Sink, typename... Args>
-inline std::shared_ptr<c11log::logger> c11log::create(const std::string& logger_name, const Args&... args)
-{
-    sink_ptr sink = std::make_shared<Sink>(args...);
-    return details::registry::instance().create(logger_name, { sink });
-}
-
-
-template<class It>
-inline std::shared_ptr<c11log::logger> c11log::create(const std::string& logger_name, const It& sinks_begin, const It& sinks_end)
-{
-    return details::registry::instance().create(logger_name, std::forward(sinks_begin), std::forward(sinks_end));
-}
-
-inline void c11log::set_formatter(c11log::formatter_ptr f)
-{
-    details::registry::instance().formatter(f);
-}
-
-inline void c11log::set_format(const std::string& format_string)
-{
-    return details::registry::instance().set_format(format_string);
-}

include/spitlog/common.h

@@ -3,7 +3,7 @@
 #include<initializer_list>
 #include<chrono>
 
-namespace c11log
+namespace spitlog
 {
 class formatter;
 namespace sinks {
@@ -14,7 +14,7 @@ class sink;
 using log_clock = std::chrono::system_clock;
 using sink_ptr = std::shared_ptr < sinks::sink > ;
 using sinks_init_list = std::initializer_list < sink_ptr > ;
-using formatter_ptr = std::shared_ptr<c11log::formatter>;
+using formatter_ptr = std::shared_ptr<spitlog::formatter>;
 
 //Log level enum
 namespace level
@@ -31,7 +31,7 @@ typedef enum
 } level_enum;
 
 static const char* level_names[] { "trace", "debug", "info", "warning", "error", "critical", "fatal" };
-inline const char* to_str(c11log::level::level_enum l)
+inline const char* to_str(spitlog::level::level_enum l)
 {
     return level_names[l];
 }
@@ -52,4 +52,4 @@ private:
 
 };
 
-} //c11log
+} //spitlog

include/spitlog/details/blocking_queue.h

@@ -10,7 +10,7 @@
 #include <mutex>
 #include <condition_variable>
 
-namespace c11log
+namespace spitlog
 {
 namespace details
 {

include/spitlog/details/fast_istostr.h

@@ -5,7 +5,7 @@
 //Source: http://stackoverflow.com/a/4351484/192001
 //Modified version to pad zeros according to padding arg
 
-namespace c11log {
+namespace spitlog {
 namespace details {
 
 const char digit_pairs[201] = {

include/spitlog/details/fast_oss.h

@@ -9,7 +9,7 @@
 #include "stack_buf.h"
 #include<iostream>
 
-namespace c11log
+namespace spitlog
 {
 namespace details
 {

include/spitlog/details/file_helper.h

@@ -16,7 +16,7 @@
 
 
 
-namespace c11log
+namespace spitlog
 {
 namespace details
 {
@@ -70,7 +70,7 @@ public:
         auto& buf = msg.formatted.buf();
         size_t size = buf.size();
         if(std::fwrite(buf.data(), sizeof(char), size, _fd) != size)
-            throw fflog_exception("Failed writing to  file " + _filename);
+            throw fflog_exception("Failed writing to file " + _filename);
 
         if(--_flush_countdown == 0)
         {
@@ -79,6 +79,25 @@ public:
         }
     }
 
+    const std::string& filename() const
+    {
+        return _filename;
+    }
+
+    static bool file_exists(const std::string& name)
+    {
+        FILE* file;
+        if (!os::fopen_s(&file, name.c_str(), "r"))
+        {
+            fclose(file);
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+    }
+
 private:
     FILE* _fd;
     std::string _filename;

include/spitlog/details/line_logger.h

@@ -8,7 +8,7 @@
 // Line logger class - aggregates operator<< calls to fast ostream
 // and logs upon destruction
 
-namespace c11log
+namespace spitlog
 {
 namespace details
 {
@@ -76,4 +76,4 @@ private:
     bool _enabled;
 };
 } //Namespace details
-} // Namespace c11log
+} // Namespace spitlog

include/spitlog/details/log_msg.h

@@ -3,7 +3,7 @@
 #include "../common.h"
 #include "./fast_oss.h"
 
-namespace c11log
+namespace spitlog
 {
 namespace details
 {

include/spitlog/details/logger_impl.h

@@ -0,0 +1,163 @@
+#pragma once
+//
+// Logger implementation
+//
+
+
+#include "./line_logger.h"
+
+
+inline spitlog::logger::logger(const std::string& logger_name, sinks_init_list sinks_list) :
+    _name(logger_name),
+    _sinks(sinks_list)
+{
+    // no support under vs2013 for member initialization for std::atomic
+    _level = level::INFO;
+}
+
+template<class It>
+inline spitlog::logger::logger(const std::string& logger_name, const It& begin, const It& end) :
+    _name(logger_name),
+    _sinks(begin, end)
+{}
+
+
+inline void spitlog::logger::set_formatter(spitlog::formatter_ptr msg_formatter)
+{
+    _formatter = msg_formatter;
+}
+
+inline void spitlog::logger::set_format(const std::string& format)
+{
+    _formatter = std::make_shared<pattern_formatter>(format);
+}
+
+inline spitlog::formatter_ptr spitlog::logger::get_formatter() const
+{
+    return _formatter;
+}
+
+
+template <typename... Args>
+inline spitlog::details::line_logger spitlog::logger::log(level::level_enum lvl, const Args&... args) {
+    bool msg_enabled = should_log(lvl);
+    details::line_logger l(this, lvl, msg_enabled);
+    if (msg_enabled)
+        _variadic_log(l, args...);
+    return l;
+}
+
+template <typename... Args>
+inline spitlog::details::line_logger spitlog::logger::trace(const Args&... args)
+{
+    return log(level::TRACE, args...);
+}
+
+template <typename... Args>
+inline spitlog::details::line_logger spitlog::logger::debug(const Args&... args)
+{
+    return log(level::DEBUG, args...);
+}
+
+template <typename... Args>
+inline spitlog::details::line_logger spitlog::logger::info(const Args&... args)
+{
+    return log(level::INFO, args...);
+}
+
+template <typename... Args>
+inline spitlog::details::line_logger spitlog::logger::warn(const Args&... args)
+{
+    return log(level::WARN, args...);
+}
+
+template <typename... Args>
+inline spitlog::details::line_logger spitlog::logger::error(const Args&... args)
+{
+    return log(level::ERR, args...);
+}
+
+template <typename... Args>
+inline spitlog::details::line_logger spitlog::logger::critical(const Args&... args)
+{
+    return log(level::CRITICAL, args...);
+}
+
+inline const std::string& spitlog::logger::name() const
+{
+    return _name;
+}
+
+inline void spitlog::logger::set_level(spitlog::level::level_enum log_level)
+{
+    _level.store(log_level);
+}
+
+inline spitlog::level::level_enum spitlog::logger::level() const
+{
+    return static_cast<spitlog::level::level_enum>(_level.load());
+}
+
+inline bool spitlog::logger::should_log(spitlog::level::level_enum msg_level) const
+{
+    return msg_level >= _level.load();
+}
+
+inline void spitlog::logger::_variadic_log(spitlog::details::line_logger&) {}
+
+template <typename First, typename... Rest>
+void spitlog::logger::_variadic_log(spitlog::details::line_logger& l, const First& first, const Rest&... rest)
+{
+    l.write(first);
+    l.write(' ');
+    _variadic_log(l, rest...);
+}
+
+inline void spitlog::logger::_log_msg(details::log_msg& msg)
+{
+    //Use default formatter if not set
+    if (!_formatter)
+        _formatter = std::make_shared<pattern_formatter>("%+");
+    _formatter->format(msg);
+    for (auto &sink : _sinks)
+        sink->log(msg);
+}
+
+//
+// Global registry functions
+//
+#include "./registry.h"
+inline std::shared_ptr<spitlog::logger> spitlog::get(const std::string& name)
+{
+    return details::registry::instance().get(name);
+}
+
+inline std::shared_ptr<spitlog::logger> spitlog::create(const std::string& logger_name, spitlog::sinks_init_list sinks)
+{
+    return details::registry::instance().create(logger_name, sinks);
+}
+
+
+template <typename Sink, typename... Args>
+inline std::shared_ptr<spitlog::logger> spitlog::create(const std::string& logger_name, const Args&... args)
+{
+    sink_ptr sink = std::make_shared<Sink>(args...);
+    return details::registry::instance().create(logger_name, { sink });
+}
+
+
+template<class It>
+inline std::shared_ptr<spitlog::logger> spitlog::create(const std::string& logger_name, const It& sinks_begin, const It& sinks_end)
+{
+    return details::registry::instance().create(logger_name, std::forward(sinks_begin), std::forward(sinks_end));
+}
+
+inline void spitlog::set_formatter(spitlog::formatter_ptr f)
+{
+    details::registry::instance().formatter(f);
+}
+
+inline void spitlog::set_format(const std::string& format_string)
+{
+    return details::registry::instance().set_format(format_string);
+}

include/spitlog/details/null_mutex.h

@@ -2,7 +2,7 @@
 
 // null, no cost mutex
 
-namespace c11log {
+namespace spitlog {
 namespace details {
 struct null_mutex
 {

include/spitlog/details/os.h

@@ -7,7 +7,7 @@
 #include <Windows.h>
 #endif
 
-namespace c11log
+namespace spitlog
 {
 namespace details
 {
@@ -123,7 +123,7 @@ inline int utc_minutes_offset(const std::tm& tm = localtime())
 
 } //os
 } //details
-} //c11log
+} //spitlog
 
 
 

include/spitlog/details/pattern_formatter_impl.h

@@ -10,7 +10,7 @@
 #include "./fast_oss.h"
 #include "./os.h"
 
-namespace c11log
+namespace spitlog
 {
 namespace details {
 class flag_formatter
@@ -377,12 +377,12 @@ class full_formatter :public flag_formatter
 ///////////////////////////////////////////////////////////////////////////////
 // pattern_formatter inline impl
 ///////////////////////////////////////////////////////////////////////////////
-inline c11log::pattern_formatter::pattern_formatter(const std::string& pattern)
+inline spitlog::pattern_formatter::pattern_formatter(const std::string& pattern)
 {
     compile_pattern(pattern);
 }
 
-inline void c11log::pattern_formatter::compile_pattern(const std::string& pattern)
+inline void spitlog::pattern_formatter::compile_pattern(const std::string& pattern)
 {
     auto end = pattern.end();
     std::unique_ptr<details::aggregate_formatter> user_chars;
@@ -411,7 +411,7 @@ inline void c11log::pattern_formatter::compile_pattern(const std::string& patter
     }
 
 }
-inline void c11log::pattern_formatter::handle_flag(char flag)
+inline void spitlog::pattern_formatter::handle_flag(char flag)
 {
     switch (flag)
     {
@@ -523,7 +523,7 @@ inline void c11log::pattern_formatter::handle_flag(char flag)
 }
 
 
-inline void c11log::pattern_formatter::format(details::log_msg& msg)
+inline void spitlog::pattern_formatter::format(details::log_msg& msg)
 {
     for (auto &f : _formatters)
     {

include/spitlog/details/registry.h

@@ -10,7 +10,7 @@
 #include "../logger.h"
 #include "../common.h"
 
-namespace c11log {
+namespace spitlog {
 namespace details {
 class registry {
 public:

include/spitlog/details/stack_buf.h

@@ -7,7 +7,7 @@
 
 
 // Fast memory storage on the stack when possible or in std::vector
-namespace c11log
+namespace spitlog
 {
 namespace details
 {
@@ -108,4 +108,4 @@ private:
 };
 
 }
-} //namespace c11log { namespace details {
+} //namespace spitlog { namespace details {

include/spitlog/formatter.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include "details/log_msg.h"
-namespace c11log
+namespace spitlog
 {
 namespace details {
 class flag_formatter;

include/spitlog/logger.h

@@ -15,7 +15,7 @@
 #include "sinks/base_sink.h"
 #include "common.h"
 
-namespace c11log
+namespace spitlog
 {
 
 namespace details
@@ -70,14 +70,14 @@ private:
 //
 // Registry functions for easy loggers creation and retrieval
 // example
-// auto console_logger = c11log::create("my_logger", c11log::sinks<stdout_sink_mt>);
-// auto same_logger = c11log::get("my_logger");
+// auto console_logger = spitlog::create("my_logger", spitlog::sinks<stdout_sink_mt>);
+// auto same_logger = spitlog::get("my_logger");
 // auto file_logger = c11
 //
 std::shared_ptr<logger> get(const std::string& name);
 std::shared_ptr<logger> create(const std::string& logger_name, sinks_init_list sinks);
 template <typename Sink, typename... Args>
-std::shared_ptr<c11log::logger> create(const std::string& logger_name, const Args&... args);
+std::shared_ptr<spitlog::logger> create(const std::string& logger_name, const Args&... args);
 template<class It>
 std::shared_ptr<logger> create(const std::string& logger_name, const It& sinks_begin, const It& sinks_end);
 
@@ -89,13 +89,13 @@ void set_format(const std::string& format_string);
 // Trace & debug macros
 //
 #ifdef FFLOG_ENABLE_TRACE
-#define FFLOG_TRACE(logger, ...) logger->log(c11log::level::TRACE, __FILE__, " #", __LINE__,": " __VA_ARGS__)
+#define FFLOG_TRACE(logger, ...) logger->log(spitlog::level::TRACE, __FILE__, " #", __LINE__,": " __VA_ARGS__)
 #else
 #define FFLOG_TRACE(logger, ...) {}
 #endif
 
 #ifdef FFLOG_ENABLE_DEBUG
-#define FFLOG_DEBUG(logger, ...) logger->log(c11log::level::DEBUG, __VA_ARGS__)
+#define FFLOG_DEBUG(logger, ...) logger->log(spitlog::level::DEBUG, __VA_ARGS__)
 #else
 #define FFLOG_DEBUG(logger, ...) {}
 #endif

include/spitlog/sinks/async_sink.h

@@ -13,7 +13,7 @@
 
 #include<iostream>
 
-namespace c11log
+namespace spitlog
 {
 namespace sinks
 {
@@ -53,26 +53,26 @@ private:
 ///////////////////////////////////////////////////////////////////////////////
 // async_sink class implementation
 ///////////////////////////////////////////////////////////////////////////////
-inline c11log::sinks::async_sink::async_sink(const q_type::size_type max_queue_size)
+inline spitlog::sinks::async_sink::async_sink(const q_type::size_type max_queue_size)
     :_sinks(),
      _active(true),
      _q(max_queue_size),
      _back_thread(&async_sink::_thread_loop, this)
 {}
 
-inline c11log::sinks::async_sink::~async_sink()
+inline spitlog::sinks::async_sink::~async_sink()
 {
     _shutdown();
 }
 
-inline void c11log::sinks::async_sink::_sink_it(const details::log_msg& msg)
+inline void spitlog::sinks::async_sink::_sink_it(const details::log_msg& msg)
 {
     if(!_active)
         return;
     _q.push(msg);
 }
 
-inline void c11log::sinks::async_sink::_thread_loop()
+inline void spitlog::sinks::async_sink::_thread_loop()
 {
     static std::chrono::seconds  pop_timeout { 1 };
     while (_active)
@@ -90,27 +90,27 @@ inline void c11log::sinks::async_sink::_thread_loop()
     }
 }
 
-inline void c11log::sinks::async_sink::add_sink(c11log::sink_ptr s)
+inline void spitlog::sinks::async_sink::add_sink(spitlog::sink_ptr s)
 {
     std::lock_guard<std::mutex> guard(_mutex);
     _sinks.push_back(s);
 }
 
 
-inline void c11log::sinks::async_sink::remove_sink(c11log::sink_ptr s)
+inline void spitlog::sinks::async_sink::remove_sink(spitlog::sink_ptr s)
 {
     std::lock_guard<std::mutex> guard(_mutex);
     _sinks.erase(std::remove(_sinks.begin(), _sinks.end(), s), _sinks.end());
 }
 
 
-inline c11log::sinks::async_sink::q_type& c11log::sinks::async_sink::q()
+inline spitlog::sinks::async_sink::q_type& spitlog::sinks::async_sink::q()
 {
     return _q;
 }
 
 
-inline void c11log::sinks::async_sink::shutdown(const std::chrono::milliseconds& timeout)
+inline void spitlog::sinks::async_sink::shutdown(const std::chrono::milliseconds& timeout)
 {
     if(timeout > std::chrono::milliseconds::zero())
     {
@@ -124,7 +124,7 @@ inline void c11log::sinks::async_sink::shutdown(const std::chrono::milliseconds&
 }
 
 
-inline void c11log::sinks::async_sink::_shutdown()
+inline void spitlog::sinks::async_sink::_shutdown()
 {
     std::lock_guard<std::mutex> guard(_mutex);
     if(_active)

include/spitlog/sinks/base_sink.h

@@ -14,7 +14,7 @@
 #include "../details/log_msg.h"
 
 
-namespace c11log
+namespace spitlog
 {
 namespace sinks
 {

include/spitlog/sinks/file_sinks.h

@@ -1,15 +1,16 @@
 #pragma once
 
-#include <sstream>
+
 #include <mutex>
 #include "./base_sink.h"
 
 #include "../details/null_mutex.h"
 #include "../details/file_helper.h"
+#include "../details/fast_oss.h"
 
 
 
-namespace c11log
+namespace spitlog
 {
 namespace sinks
 {
@@ -56,7 +57,7 @@ public:
         _current_size(0),
         _file_helper(flush_inverval)
     {
-        _file_helper.open(_calc_filename(_base_filename, 0, _extension));
+        _file_helper.open(calc_filename(_base_filename, 0, _extension));
     }
 
 protected:
@@ -73,9 +74,9 @@ protected:
 
 
 private:
-    static std::string _calc_filename(const std::string& filename, std::size_t index, const std::string& extension)
+    static std::string calc_filename(const std::string& filename, std::size_t index, const std::string& extension)
     {
-        std::ostringstream oss;
+        details::fast_oss oss;
         if (index)
             oss << filename << "." << index << "." << extension;
         else
@@ -96,11 +97,19 @@ private:
         _file_helper.close();
         for (auto i = _max_files; i > 0; --i)
         {
-            std::string src = _calc_filename(_base_filename, i - 1, _extension);
-            std::string target = _calc_filename(_base_filename, i, _extension);
-            std::rename(src.c_str(), target.c_str());
+            std::string src = calc_filename(_base_filename, i - 1, _extension);
+            std::string target = calc_filename(_base_filename, i, _extension);
+
+            if (details::file_helper::file_exists(target))
+                std::remove(target.c_str());
+            if (details::file_helper::file_exists(src) && std::rename(src.c_str(), target.c_str()))
+            {
+                throw fflog_exception("rotating_file_sink: failed renaming " + src + " to " + target);
+            }
         }
-        _file_helper.open(_calc_filename(_base_filename, 0, _extension));
+        auto cur_name = _file_helper.filename();
+        std::remove(cur_name.c_str());
+        _file_helper.open(cur_name);
     }
     std::string _base_filename;
     std::string _extension;
@@ -128,7 +137,7 @@ public:
         _midnight_tp (_calc_midnight_tp() ),
         _file_helper(flush_inverval)
     {
-        _file_helper.open(_calc_filename(_base_filename, _extension));
+        _file_helper.open(calc_filename(_base_filename, _extension));
     }
 
 protected:
@@ -137,7 +146,7 @@ protected:
         if (std::chrono::system_clock::now() >= _midnight_tp)
         {
             _file_helper.close();
-            _file_helper.open(_calc_filename(_base_filename, _extension));
+            _file_helper.open(calc_filename(_base_filename, _extension));
             _midnight_tp = _calc_midnight_tp();
         }
         _file_helper.write(msg);
@@ -150,17 +159,17 @@ private:
         using namespace std::chrono;
         auto now = system_clock::now();
         time_t tnow = std::chrono::system_clock::to_time_t(now);
-        tm date = c11log::details::os::localtime(tnow);
+        tm date = spitlog::details::os::localtime(tnow);
         date.tm_hour = date.tm_min = date.tm_sec = 0;
         auto midnight = std::chrono::system_clock::from_time_t(std::mktime(&date));
         return system_clock::time_point(midnight + hours(24));
     }
 
     //Create filename for the form basename.YYYY-MM-DD.extension
-    static std::string _calc_filename(const std::string& basename, const std::string& extension)
+    static std::string calc_filename(const std::string& basename, const std::string& extension)
     {
-        std::tm tm = c11log::details::os::localtime();
-        std::ostringstream oss;
+        std::tm tm = spitlog::details::os::localtime();
+        fast_oss oss;
         oss << basename << '.';
         oss << tm.tm_year + 1900 << '-' << std::setw(2) << std::setfill('0') << tm.tm_mon + 1 << '-' << tm.tm_mday;
         oss << '.' << extension;

include/spitlog/sinks/null_sink.h

@@ -4,7 +4,7 @@
 #include "../details/null_mutex.h"
 
 
-namespace c11log {
+namespace spitlog {
 namespace sinks {
 
 template <class Mutex>

include/spitlog/sinks/ostream_sink.h

@@ -7,7 +7,7 @@
 #include "../details/null_mutex.h"
 #include "./base_sink.h"
 
-namespace c11log
+namespace spitlog
 {
 namespace sinks
 {

include/spitlog/sinks/sink.h

@@ -2,7 +2,7 @@
 
 #include "../details/log_msg.h"
 
-namespace c11log
+namespace spitlog
 {
 namespace sinks
 {

include/spitlog/sinks/stdout_sinks.h

@@ -5,7 +5,7 @@
 #include "./ostream_sink.h"
 #include "../details/null_mutex.h"
 
-namespace c11log
+namespace spitlog
 {
 namespace sinks
 {