/home/raskolnikov/dev/psynth/trunk/src/psynth/base/logger.hpp

Go to the documentation of this file.

/*
 *  Copyright (C) 2007, 2008, 2009 Juan Pedro Bolívar Puente
 *
 *  This file is part of Psychosynth.
 *   
 *  Psychosynth is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  Psychosynth is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef PSYNTH_BASE_LOGGER_H
#define PSYNTH_BASE_LOGGER_H

#include <map>
#include <list>
#include <iostream>
#include <fstream>
#include <sstream>

#include <psynth/base/singleton.hpp>
#include <psynth/base/tree.hpp>
#include <psynth/base/compat.hpp>
#include <psynth/base/logger_fwd.hpp>

namespace psynth
{
namespace base
{

class log_stream_adapter
{
public:
    inline log_stream_adapter (log& l);
    inline log_stream_adapter (const log_stream_adapter&);
    inline log_stream_adapter (log_stream_adapter&&);
    
    inline ~log_stream_adapter ();

    void set_level (int level)
    { _level = level; } 

    int level () const { return _level; }

    const std::string message () const { return _str.str (); }
    
    inline void flush ();

    inline void dump ();

private:
    log&               _log;
    int                _level;
    std::ostringstream _str;

    template <typename T>
    friend log_stream_adapter& operator<< (log_stream_adapter&, const T&);
    friend log_stream_adapter& operator<< (
        log_stream_adapter&, log_stream_adapter&(*)(log_stream_adapter&));
};

inline log_stream_adapter& flush (log_stream_adapter& s)
{
    s.flush ();
    return s;
}

class log_stream_adapter_wrapper : public boost::noncopyable
{
public:
    log_stream_adapter_wrapper (log_stream_adapter& s)
        : _stream (&s)
    {}

    log_stream_adapter_wrapper (log_stream_adapter_wrapper&& s)
        : _stream (s._stream)
    {
        s._stream = 0;
    }

    ~log_stream_adapter_wrapper ()
    {
        if (_stream)
            *_stream << flush;
    }

    log_stream_adapter& wrapped ()
    {
        return *_stream;
    }
    
private:
    log_stream_adapter* _stream;
};

template<typename T> inline
log_stream_adapter_wrapper operator<< (log_stream_adapter_wrapper s, T p)
{
    s.wrapped () << p;
    return std::move (s);
}

class log_sink
{
public:
    
    virtual void dump (log& log, int level, const std::string& msg) = 0;
};

class log : public tree_node <log>,
            public PSYNTH_DEFAULT_THREADING <log>
{
public:
    enum level
    {
        debug,   
        info,    
        warning, 
        error,   
        fatal    
    };

    static const char* level_name (int level)
    {
        switch(level) {
        case debug:
            return "DEBUG";
        case info:
            return "INFO";
        case warning:
            return "WARNING";
        case error:
            return "ERROR";
        case fatal:
            return "FATAL";
        default:
            return "UNKNOWN";
        };
    };

    log ()
        : _stream (*this)
    {}
    
    ~log ();

    void add_sink (log_sink_ptr d);
        
    void del_sink (log_sink_ptr d);

    void operator () (const std::string& child, int level, const std::string& msg)
    {
        lock lock (this);
        path (child) (level, msg);
    }

    void operator () (int level, const std::string& msg)
    {
        lock lock (this);
        operator () (*this, level, msg);
    };

    log_stream_adapter_wrapper stream ()
    {
        return log_stream_adapter_wrapper (_stream);
    }
    
private:
    void operator () (log& log, int level, const std::string& msg);

    log_stream_adapter      _stream; // TODO: We want to avoid the
                                     // ostringstream instance here :(
    std::list<log_sink_ptr> _dumpers;
};

struct logger : public singleton_holder<log> {};
    
class log_std_sink : public log_sink
{
public:
    void dump (log& l, int level, const std::string& msg)
    {
        (level > log::info ? std::cerr : std::cout)
            << '['
            << l.path_name ()
            << "] "
            << log::level_name (level)
            << ": "
            << msg
            << std::endl;
    }
};

class log_stream_sink : public log_sink
{
public:
    log_stream_sink ()
        : _output (0)
    {}

    log_stream_sink (const log_stream_sink& s)
        : _output (s._output)
    {}

    log_stream_sink (std::ostream& os)
        : _output (&os)
    {}
    
    void dump (log& l, int level, const std::string& msg)
    {
        if (_output)
            *(_output)
                << '['
                << l.path_name ()
                << "] "
                << log::level_name (level)
                << ": "
                << msg
                << std::endl;
    }

protected:
    void set_stream (std::ostream& os)
    {
        _output = &os;
    }
    
private:
    std::ostream* _output;
};

class log_file_sink : public log_stream_sink
{
public:
    log_file_sink (const char* file,
                   std::ios_base::openmode mode =
                   std::ios_base::out | std::ios_base::app)
        : _file (file, mode)
    {
        set_stream (_file);
    }

private:
    std::ofstream _file;
};

void log_stream_adapter::flush ()
{
    _log (_level, _str.str ());
    _str.str ("");
}

void log_stream_adapter::dump ()
{
    _log (_level, _str.str ());
}

inline
log_stream_adapter& operator<< (log_stream_adapter& s, log::level x)
{
    s.set_level (x);
    return s;
}

template <class T> inline
log_stream_adapter& operator<< (log_stream_adapter& s, const T& x)
{
    s._str << x;
    return s;
}

inline log_stream_adapter& operator<< (
    log_stream_adapter& stm,
    log_stream_adapter&(*func)(log_stream_adapter&))
{
    return func (stm);
}

log_stream_adapter::log_stream_adapter (log& l)
    : _log (l)
    , _level (log::info)
{}

log_stream_adapter::log_stream_adapter (const log_stream_adapter& l)
    : _log (l._log)
    , _level (l._level)
{
    _str << l._str.str ();
}

log_stream_adapter::log_stream_adapter (log_stream_adapter&& l)
    : _log (l._log)
    , _level (l._level)
{
    _str << l._str.str (); // FIXME: SLOW!!!
}

log_stream_adapter::~log_stream_adapter ()
{
    // *this << log_msg;
}

#define PSYNTH_LOG \
    ::psynth::base::logger::self ().path (PSYNTH_MODULE_NAME).stream ()

#if PSYNTH_DEBUG
#define PSYNTH_LOG_DEBUG \
    ::psynth::base::logger::self ().path (PSYNTH_MODULE_NAME).stream () \
    << ::psynth::base::log::debug
#else
#define PSYNTH_LOG_DEBUG ::psynth::base::nop_ostream ()
#endif

extern template class tree_node <log>;
extern template class PSYNTH_DEFAULT_THREADING <log>;
extern template class singleton_holder <log>;

} /* namespace base */
} /* namespace psynth */

#endif /* PSYNTH_BASE_LOGGER_H */