ILogger.hxx

#pragma once
 
// C++
#include <iosfwd>
#include <sstream>
#include <string_view>
 
// cosmos
#include <cosmos/io/colors.hxx>
 
namespace cosmos {
 
 
class COSMOS_API ILogger {
public: // functions
 
        virtual ~ILogger() {};
 
        std::ostream& error() { return getStream(m_err); }
        std::ostream& warn() { return getStream(m_warn); }
        std::ostream& info() { return getStream(m_info); }
        std::ostream& debug() { return getStream(m_debug); }
 
        void setChannels(const bool error, const bool warning, const bool info, const bool debug) {
                m_err.enabled = error;
                m_warn.enabled = warning;
                m_info.enabled = info;
                m_debug.enabled = debug;
        }
 
        void setPrefix(const std::string_view prefix) {
                m_common_prefix = prefix;
        }
 
protected: // types
 
        struct StreamState {
                StreamState(const std::string_view p, const term::ColorSpec &c) :
                        prefix{p}, color{c} {}
 
                std::ostream *stream = nullptr;
                bool enabled = false;
                bool is_tty = false;
                const std::string_view prefix;
                const term::ColorSpec color;
        };
 
protected: // functions
 
        ILogger();
 
        std::ostream& getStream(StreamState &state) {
                auto &out = state.enabled ? *state.stream : getNoopStream();
 
                if (state.is_tty)
                        out << state.color;
 
                out << m_common_prefix;
 
                out << state.prefix;
 
                if (state.is_tty)
                        out << term::TermControl::DEFAULT_FG_COLOR;
 
                return out;
        }
 
        std::ostream& getNoopStream() {
                // a real noop implementation of an ostream buffer will still
                // be cheaper than this, but at least it doesn't involve
                // system calls
                //
                // seek the start of the stringstream, to avoid the buffer
                // growing too much
                m_null.seekp(m_null.beg);
                return m_null;
        }
 
        static bool isTTY(const std::ostream &o);
 
        void setStreams(
                std::ostream &debug,
                std::ostream &info,
                std::ostream &warn,
                std::ostream &error
        );
 
        void setStream(std::ostream &s, StreamState &state);
 
protected: // data
 
        std::stringstream m_null; 
 
        StreamState m_err;
        StreamState m_warn;
        StreamState m_info;
        StreamState m_debug;
 
        std::string m_common_prefix; 
};
 
} // end ns