Feature/thread safe logging

src/eckit/log/Channel.cc

@@ -17,18 +17,17 @@ namespace eckit {
 
 //----------------------------------------------------------------------------------------------------------------------
 
-Channel::Channel(LogTarget* target) :
-    std::ostream(new ChannelBuffer()), buffer_(dynamic_cast<ChannelBuffer*>(rdbuf())) {
+Channel::Channel(ChannelBuffer* buffer): std::ostream(buffer), buffer_(buffer) { }
+
+Channel::Channel(LogTarget* target): Channel(new ChannelBuffer()) {
     ASSERT(buffer_);
-    if (target) {
-        buffer_->setTarget(target);
-    }
-    //    std::cerr << "Channel::Channel()" << std::endl;
+    if (target) { buffer_->setTarget(target); }
 }
 
+Channel::Channel(VoidBuffer* dummy): std::ostream(nullptr), buffer_(dummy) { }
 
 Channel::~Channel() {
-    //    std::cerr << "Channel::~Channel() " << *this << std::endl;
+    buffer_->sync();
     delete buffer_;
 }
 
@@ -69,7 +68,6 @@ void Channel::addStream(std::ostream& out) {
     buffer_->addStream(out);
 }
 
-
 void Channel::setFile(const std::string& path) {
     buffer_->setFile(path);
 }
@@ -96,4 +94,8 @@ void Channel::unindent() {
 
 //----------------------------------------------------------------------------------------------------------------------
 
+EmptyChannel::EmptyChannel(): Channel(new VoidBuffer()) { }
+
+//----------------------------------------------------------------------------------------------------------------------
+
 }  // namespace eckit

src/eckit/log/Channel.h

@@ -20,6 +20,7 @@
 
 namespace eckit {
 
+class VoidBuffer;
 class ChannelBuffer;
 class LogTarget;
 
@@ -29,8 +30,7 @@ typedef void (*channel_callback_t)(void* data, const char* msg);
 
 /// Output channel that is an std::ostream but more functional
 
-class Channel : public std::ostream, private NonCopyable {
-
+class Channel: public std::ostream, private NonCopyable {
 public:  // methods
     Channel(LogTarget* = 0);
 
@@ -39,7 +39,7 @@ class Channel : public std::ostream, private NonCopyable {
     bool operator!() const;
     operator bool() const;
 
-    void indent(const char* prefix = "");
+    void indent(const char* space = "");
     void unindent();
 
     void setStream(std::ostream& out);
@@ -51,40 +51,56 @@ class Channel : public std::ostream, private NonCopyable {
     void setCallback(channel_callback_t cb, void* data = 0);
     void addCallback(channel_callback_t cb, void* data = 0);
 
-    void setTarget(LogTarget*);
-    void addTarget(LogTarget*);
+    void setTarget(LogTarget* target);
+    void addTarget(LogTarget* target);
 
     void reset();
 
-private:  // members
+protected:  // methods
+    explicit Channel(VoidBuffer* dummy);
+
+private:  // methods
+    explicit Channel(ChannelBuffer* buffer);
+
+    virtual void print(std::ostream& s) const;
+
     friend std::ostream& operator<<(std::ostream& os, const Channel& c) {
         c.print(os);
         return os;
     }
 
-    void print(std::ostream& s) const;
-
-    ChannelBuffer* buffer_;
+private:  // members
+    ChannelBuffer* buffer_ {nullptr};
 
     friend class Log;
 };
 
-
 //----------------------------------------------------------------------------------------------------------------------
 
-
 class AutoIndent {
-
     Channel& channel_;
 
 public:
-    AutoIndent(Channel& channel, const char* prefix = "") :
-        channel_(channel) { channel_.indent(prefix); }
+    AutoIndent(Channel& channel, const char* prefix = ""): channel_(channel) { channel_.indent(prefix); }
     ~AutoIndent() { channel_.unindent(); }
 };
 
 //----------------------------------------------------------------------------------------------------------------------
 
+class EmptyChannel: public Channel {
+public:  // methods
+    EmptyChannel();
+
+    ~EmptyChannel() = default;
+
+private:  // methods
+    void print(std::ostream& s) const override { s << "EmptyChannel()"; }
+
+    friend class Log;
+};
+
+//----------------------------------------------------------------------------------------------------------------------
+
 }  // namespace eckit
 
 #endif

src/eckit/log/ChannelBuffer.cc

@@ -23,20 +23,25 @@ namespace eckit {
 
 //----------------------------------------------------------------------------------------------------------------------
 
-ChannelBuffer::ChannelBuffer(std::size_t size) : std::streambuf(), target_(0), buffer_(size) {
-    ASSERT(size);
+ChannelBuffer::ChannelBuffer(const std::size_t size): buffer_(size) {
+    init();
+}
+
+void ChannelBuffer::init() {
     setp(buffer_.data(), buffer_.data() + buffer_.size());
 }
 
 ChannelBuffer::~ChannelBuffer() {
-    reset();
+    if (target_) {
+        target_->detach();
+        target_ = nullptr;
+    }
 }
 
 bool ChannelBuffer::active() const {
     return target_ != 0;
 }
 
-
 void ChannelBuffer::setTarget(LogTarget* target) {
     ASSERT(target);
 
@@ -72,7 +77,7 @@ bool ChannelBuffer::dumpBuffer() {
         // Explicitly check that `pptr()` is not larger than end of buffer. Racecondition can end up adding larger values.
         target_->write(buffer_.data(), std::min(pptr(), buffer_.data() + buffer_.size()));
     }
-    setp(buffer_.data(), buffer_.data() + buffer_.size());
+    init();
     return true;
 }
 
@@ -108,11 +113,11 @@ void ChannelBuffer::setStream(std::ostream& out) {
     setTarget(new OStreamTarget(out));
 }
 
-void ChannelBuffer::addFile(const std::string& path, size_t bufferSize) {
+void ChannelBuffer::addFile(const std::string& path, const std::size_t bufferSize) {
     setTarget(new TeeTarget(target_, new FileTarget(path, bufferSize)));
 }
 
-void ChannelBuffer::setFile(const std::string& path, size_t bufferSize) {
+void ChannelBuffer::setFile(const std::string& path, const std::size_t bufferSize) {
     setTarget(new FileTarget(path, bufferSize));
 }
 
@@ -144,4 +149,26 @@ void ChannelBuffer::print(std::ostream& s) const {
 
 //----------------------------------------------------------------------------------------------------------------------
 
+VoidBuffer::VoidBuffer(): ChannelBuffer(0) { }
+
+VoidBuffer::~VoidBuffer() = default;
+
+bool VoidBuffer::dumpBuffer() {
+    return true;
+}
+
+std::streambuf::int_type VoidBuffer::overflow(std::streambuf::int_type ch) {
+    return ch;
+}
+
+std::streambuf::int_type VoidBuffer::sync() {
+    return 0;
+}
+
+void VoidBuffer::print(std::ostream& os) const {
+    os << "VoidBuffer";
+}
+
+//----------------------------------------------------------------------------------------------------------------------
+
 }  // namespace eckit

src/eckit/log/ChannelBuffer.h

@@ -16,7 +16,10 @@
 #ifndef eckit_log_ChannelBuffer_h
 #define eckit_log_ChannelBuffer_h
 
+#include <cstddef>
+#include <ostream>
 #include <streambuf>
+#include <string>
 #include <vector>
 
 #include "eckit/log/Channel.h"
@@ -28,15 +31,12 @@ namespace eckit {
 
 class LogTarget;
 
-/// Stream buffer to be usedby Channel
+/// Stream buffer to be used by Channel
 class ChannelBuffer : public std::streambuf, private NonCopyable {
+private:  // types
+    static constexpr const std::size_t DEFAULT_SIZE = 1024;
 
 private:  // methods
-    /// constructor, taking ownership of stream
-    ChannelBuffer(std::size_t size = 1024);
-
-    ~ChannelBuffer() override;
-
     bool active() const;
 
     void reset();
@@ -50,13 +50,19 @@ class ChannelBuffer : public std::streambuf, private NonCopyable {
     void setStream(std::ostream& out);
     void addStream(std::ostream& out);
 
-    void setFile(const std::string& path, size_t bufferSize = 4 * 1024);
-    void addFile(const std::string& path, size_t bufferSize = 4 * 1024);
+    void setFile(const std::string& path, std::size_t bufferSize = 4 * 1024);
+    void addFile(const std::string& path, std::size_t bufferSize = 4 * 1024);
 
     void setCallback(channel_callback_t cb, void* data = 0);
     void addCallback(channel_callback_t cb, void* data = 0);
 
 protected:  // methods
+    ChannelBuffer(std::size_t size = DEFAULT_SIZE);
+
+    ~ChannelBuffer() override;
+
+    void init();
+
     /// override this to change buffer behavior
     /// @returns true if no error occured
     virtual bool dumpBuffer();
@@ -69,24 +75,45 @@ class ChannelBuffer : public std::streambuf, private NonCopyable {
     /// @see dumpBuffer
     int_type sync() override;
 
-protected:  // members
-    LogTarget* target_;
-
-    std::vector<char> buffer_;
-
-private:
     friend std::ostream& operator<<(std::ostream& os, const ChannelBuffer& c) {
         c.print(os);
         return os;
     }
 
-    void print(std::ostream& s) const;
+    virtual void print(std::ostream& s) const;
+
+protected:  // members
+    LogTarget* target_ {nullptr};
+
+    std::vector<char> buffer_;
 
     friend class Channel;
 };
 
 //----------------------------------------------------------------------------------------------------------------------
 
+/// Channel buffer that voidify output streams
+class VoidBuffer: public ChannelBuffer {
+private:  // methods
+    VoidBuffer();
+
+    ~VoidBuffer();
+
+protected:  // methods
+    bool dumpBuffer() override;
+
+    int_type overflow(int_type ch) override;
+
+    int_type sync() override;
+
+private:  // methods
+    void print(std::ostream& os) const override;
+
+    friend class EmptyChannel;
+};
+
+//----------------------------------------------------------------------------------------------------------------------
+
 }  // namespace eckit
 
 #endif