revert sink accepting only char* and size_t

README.md

@@ -14,24 +14,17 @@ Just copy the files to your build tree and use a C++11 compiler
 * mingw with g++ 4.9.x
 
 ##Features
-* Very fast - performance is the primary goal (see becnhmarks below).
+* Very fast - performance is the primary goal (see becnhmarks below)
-* Headers only.
+* Headers only
-* No dependencies.
+* No dependencies
-* Cross platform - Linux / Windows on 32/64 bits.
+* Cross platform - Linux / Windows on 32/64 bits
-* Variadic-template/stream call styles: ```logger.info("variadic", x, y) << "or stream" << x << y;```
+* Multi/Single threaded loggers
-* [Custom](https://github.com/gabime/spdlog/wiki/Custom-formatting) formatting.
+* Rotating log files
-* Multi/Single threaded loggers.
+* Daily log files
-* Various log targets:
+* Console logging
-    * Rotating log files.
+* Optional async logging 
-    * Daily log files.
+* Logging levels
-    * Console logging.
+* Custom formatting with user defined patterns
-    * Linux syslog.
-    * Easily extendable with custom log targets  (just implement a single function in the [sink](include/spdlog/sinks/sink.h) interface).
-* Optional async logging .
-* Log levels.
-
-
-
 
 ## Benchmarks
 

include/spdlog/details/file_helper.h

@@ -82,10 +82,10 @@ public:
 
     void reopen()
     {
-        if(_filename.empty())
+       if(_filename.empty())
-            throw spdlog_ex("Failed re opening file - was not opened before");
+          throw spdlog_ex("Failed re opening file - was not opened before");
-        open(_filename);
+       open(_filename);	
-
+       
     }
 
     void close()
@@ -97,11 +97,11 @@ public:
         }
     }
 
-    void write(const char* data, size_t size)
+    void write(const log_msg& msg)
     {
-
+        auto& buf = msg.formatted.buf();
-
+        size_t size = buf.size();
-        if(std::fwrite(data, sizeof(char), size, _fd) != size)
+        if(std::fwrite(buf.data(), sizeof(char), size, _fd) != size)
             throw spdlog_ex("Failed writing to file " + _filename);
 
         if(--_flush_countdown == 0)

include/spdlog/details/logger_impl.h

@@ -184,8 +184,7 @@ inline void spdlog::logger::_variadic_log(spdlog::details::line_logger& l, const
 inline void spdlog::logger::_log_msg(details::log_msg& msg)
 {
     _formatter->format(msg);
-    auto buf = msg.formatted.buf();
     for (auto &sink : _sinks)
-        sink->sink_it(buf.data(), buf.size());
+        sink->log(msg);
 }
 

include/spdlog/sinks/async_sink.h

@@ -53,8 +53,7 @@ namespace sinks
 class async_sink : public base_sink < details::null_mutex >
 {
 public:
-    using data_type = std::pair < const char*, size_t > ;
+    using q_type = details::blocking_queue < details::log_msg > ;
-    using q_type = details::blocking_queue < data_type > ;
 
     explicit async_sink(const q_type::size_type max_queue_size);
 
@@ -69,7 +68,7 @@ public:
 
 
 protected:
-    void _sink_it(const char*, size_t) override;
+    void _sink_it(const details::log_msg& msg) override;
     void _thread_loop();
 
 private:
@@ -107,12 +106,10 @@ inline spdlog::sinks::async_sink::~async_sink()
     _join();
 }
 
-inline void spdlog::sinks::async_sink::_sink_it(const char* data, size_t size)
+inline void spdlog::sinks::async_sink::_sink_it(const details::log_msg& msg)
 {
     _push_sentry();
-    auto data_copy = new char[size];
+    _q.push(msg);
-    std::memcpy(data_copy, data, size);
-    _q.push(data_type(data_copy, size));
 }
 
 
@@ -123,35 +120,31 @@ inline void spdlog::sinks::async_sink::_thread_loop()
     while (_active)
     {
         q_type::item_type msg;
-        if (!_q.pop(msg, pop_timeout))
+        if (_q.pop(msg, pop_timeout))
-            continue;
-
-
-        if (!_active)
-            return;
-
-        for (auto &s : _sinks)
         {
-            try
+            if (!_active)
+                return;
+            for (auto &s : _sinks)
             {
-                s->sink_it(msg.first, msg.second);
+                try
-            }
+                {
+                    s->log(msg);
+                }
 
-            catch (const std::exception& ex)
+                catch (const std::exception& ex)
-            {
+                {
-                _last_backthread_ex = std::make_shared<spdlog_ex>(ex.what());
+                    _last_backthread_ex = std::make_shared<spdlog_ex>(ex.what());
-            }
+                }
-            catch (...)
+                catch (...)
-            {
+                {
-                _last_backthread_ex = std::make_shared<spdlog_ex>("Unknown exception");
+                    _last_backthread_ex = std::make_shared<spdlog_ex>("Unknown exception");
-            }
+                }
 
+            }
         }
-        delete[] msg.first;
     }
 }
 
-
 inline void spdlog::sinks::async_sink::add_sink(spdlog::sink_ptr s)
 {
     std::lock_guard<std::mutex> guard(_mutex);

include/spdlog/sinks/base_sink.h

@@ -52,15 +52,15 @@ public:
     base_sink(const base_sink&) = delete;
     base_sink& operator=(const base_sink&) = delete;
 
-    void sink_it(const char* data, size_t size) override
+    void log(const details::log_msg& msg) override
     {
         std::lock_guard<Mutex> lock(_mutex);
-        _sink_it(data, size);
+        _sink_it(msg);
     };
 
 
 protected:
-    virtual void _sink_it(const char* data, size_t size) = 0;
+    virtual void _sink_it(const details::log_msg& msg) = 0;
     Mutex _mutex;
 };
 }

include/spdlog/sinks/file_sinks.h

@@ -52,9 +52,9 @@ public:
     }
 
 protected:
-    void _sink_it(const char* data, size_t size) override
+    void _sink_it(const details::log_msg& msg) override
     {
-        _file_helper.write(data, size);
+        _file_helper.write(msg);
     }
 private:
     details::file_helper _file_helper;
@@ -85,15 +85,15 @@ public:
 
 
 protected:
-    void _sink_it(const char* data, size_t size) override
+    void _sink_it(const details::log_msg& msg) override
     {
-        _current_size += size;
+        _current_size += msg.formatted.size();
         if (_current_size  > _max_size)
         {
             _rotate();
-            _current_size = size;
+            _current_size = msg.formatted.size();
         }
-        _file_helper.write(data, size);
+        _file_helper.write(msg);
     }
 
 
@@ -125,12 +125,12 @@ private:
             std::string target = calc_filename(_base_filename, i, _extension);
 
             if (details::file_helper::file_exists(target))
-            {
+	      {
-                if (std::remove(target.c_str()) != 0)
+		if (std::remove(target.c_str()) != 0)
-                {
+		  {
-                    throw spdlog_ex("rotating_file_sink: failed removing " + target);
+		    throw spdlog_ex("rotating_file_sink: failed removing " + target);
-                }
+		  }
-            }
+	      }
             if (details::file_helper::file_exists(src) && std::rename(src.c_str(), target.c_str()))
             {
                 throw spdlog_ex("rotating_file_sink: failed renaming " + src + " to " + target);
@@ -169,7 +169,7 @@ public:
 
 
 protected:
-    void _sink_it(const char* data, size_t size) override
+    void _sink_it(const details::log_msg& msg) override
     {
         if (std::chrono::system_clock::now() >= _midnight_tp)
         {
@@ -177,7 +177,7 @@ protected:
             _file_helper.open(calc_filename(_base_filename, _extension));
             _midnight_tp = _calc_midnight_tp();
         }
-        _file_helper.write(data, size);
+        _file_helper.write(msg);
     }
 
 private:

include/spdlog/sinks/null_sink.h

@@ -37,7 +37,7 @@ template <class Mutex>
 class null_sink : public base_sink < Mutex >
 {
 protected:
-    void _sink_it(const char*, size_t) override
+    void _sink_it(const details::log_msg&) override
     {}
 
 };

include/spdlog/sinks/ostream_sink.h

@@ -45,9 +45,10 @@ public:
     virtual ~ostream_sink() = default;
 
 protected:
-    void _sink_it(const char* data, size_t size) override
+    virtual void _sink_it(const details::log_msg& msg) override
     {
-        _ostream.write(data, size);
+        auto& buf = msg.formatted.buf();
+        _ostream.write(buf.data(), buf.size());
     }
     std::ostream& _ostream;
 };

include/spdlog/sinks/sink.h

@@ -24,6 +24,7 @@
 
 #pragma once
 
+#include "../details/log_msg.h"
 
 namespace spdlog
 {
@@ -33,7 +34,7 @@ class sink
 {
 public:
     virtual ~sink() {}
-    virtual void sink_it(const char* data, size_t size) = 0;
+    virtual void log(const details::log_msg& msg) = 0;
 };
 }
 }