log.h

/*****************************************************/
/* lean Logging                 (c) Tobias Zirr 2011 */
/*****************************************************/

#ifndef LEAN_LOGGING_LOG
#define LEAN_LOGGING_LOG

#include "../lean.h"
#include "../tags/noncopyable.h"
#include "../strings/types.h"
#include "../strings/conversions.h"
#include "../concurrent/spin_lock.h"
#include "../concurrent/shareable_spin_lock.h"
#include "log_target.h"
#include <vector>
#include <iosfwd>
#include <ostream>
#include "streamconv.h"

namespace lean
{
namespace logging
{

class log_stream_out;

class log : public noncopyable
{
friend class log_stream_out;

private:
    typedef std::basic_ostream<char> output_stream;
    typedef std::basic_ostringstream<char> string_stream;
    typedef std::vector<string_stream*> stream_vector;
    stream_vector m_streams;

    typedef std::vector<output_stream*> free_stream_vector;
    free_stream_vector m_freeStreams;
    spin_lock<> m_streamLock;

    typedef std::vector<log_target*> target_vector;
    target_vector m_targets;
    shareable_spin_lock<> m_targetLock;

    LEAN_MAYBE_EXPORT output_stream& acquireStream();
    LEAN_MAYBE_EXPORT void flushAndReleaseStream(output_stream &stream);

public:
    LEAN_MAYBE_EXPORT log(log_target *initialTarget = nullptr);
    LEAN_MAYBE_EXPORT ~log();

    LEAN_MAYBE_EXPORT void add_target(log_target *target);
    LEAN_MAYBE_EXPORT void remove_target(log_target *target);

    LEAN_MAYBE_EXPORT void print(const char_ntri &message);
};

class log_stream_out : public noncopyable
{
private:
    log &m_log;
    log::output_stream &m_stream;

public:
    typedef log::output_stream output_stream;
    typedef std::basic_ostream<output_stream::char_type, output_stream::traits_type> basic_output_stream;
    typedef std::basic_ios<output_stream::char_type, output_stream::traits_type> basic_output_ios;

    explicit log_stream_out(log &log)
        : m_log(log),
        m_stream(log.acquireStream()) { }
    ~log_stream_out()
    {
        m_log.flushAndReleaseStream(m_stream);
    }

    template <class Value>
    log_stream_out& operator <<(const Value &value)
    {
        m_stream << value;
        return *this;
    }
    // Passes the given manipulator to this log stream.
    log_stream_out& operator <<(std::ios_base& (*manip)(::std::ios_base&))
    {
        m_stream << manip;
        return *this;
    }
    // Passes the given manipulator to this log stream.
    log_stream_out& operator<<(basic_output_stream& (*manip)(basic_output_stream&))
    {
        m_stream << manip;
        return *this;
    }
    // Passes the given manipulator to this log stream.
    log_stream_out& operator<<(basic_output_ios& (*manip)(basic_output_ios&))
    {
        m_stream << manip;
        return *this;
    }

    output_stream& std()
    {
        return m_stream;
    }
};

LEAN_MAYBE_EXPORT log& error_log();
LEAN_MAYBE_EXPORT log& info_log();

} // namespace

using logging::log;
using logging::log_stream_out;

using logging::error_log;
using logging::info_log;

} // namespace


#define LEAN_LOG(msg) ::lean::log_stream_out(::lean::info_log()) << LEAN_SOURCE_STRING << ": " << msg << ::std::endl

#define LEAN_LOG_BREAK() ::lean::log_stream_out(::lean::info_log()) << ::std::endl

#define LEAN_LOG_ERROR(msg) ::lean::log_stream_out(::lean::error_log()) << LEAN_SOURCE_STRING << ": " << msg << ::std::endl

#define LEAN_LOG_ERROR_BREAK() ::lean::log_stream_out(::lean::error_log()) << ::std::endl


#ifdef LEAN_INCLUDE_LINKED
#include "source/log.cpp"
#endif

#endif