Logger.h

/*
 * Copyright (C) 2005-2010 by Dr. Marc Boris Duerner
 * Copyright (C) 2010-2010 by Aloysius Indrayanto
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * As a special exception, you may use this file as part of a free
 * software library without restriction. Specifically, if other files
 * instantiate templates or use macros or inline functions from this
 * file, or you compile this file and link it with other files to
 * produce an executable, this file does not by itself cause the
 * resulting executable to be covered by the GNU General Public
 * License. This exception does not however invalidate any other
 * reasons why the executable file might be covered by the GNU Library
 * General Public License.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
#ifndef Pt_System_Logger_h
#define Pt_System_Logger_h
 
#include <Pt/System/Api.h>
#include <Pt/System/LogLevel.h>
#include <Pt/System/LogTarget.h>
#include <Pt/System/LogRecord.h>
#include <Pt/System/Plugin.h>
#include <Pt/NonCopyable.h>
#include <string>
 
namespace Pt {
 
class Settings;
 
namespace System {

class PT_SYSTEM_API Logger : protected Pt::NonCopyable
{
    friend class LogManager;
 
    public:
        Logger(const std::string& name);

        Logger(const char* name);

        ~Logger();

        static void loadPlugin(const std::string& sym, const Path& path);

        static void registerPlugin(Plugin<LogChannel>& plugin);

        static void unregisterPlugin(Plugin<LogChannel>& plugin);

        static void init(const std::string& file);

        static void initTargets()
        { init("log.properties"); }
 
        // TODO: init with Settings::ConstEntry, so a section in the
        //       application settings can be used. 

        static void init(const Settings& settings);

        static void setPattern(const std::string& pattern);

        static void setLogLevel(const std::string& target, LogLevel level)
        { LogTarget::get(target).setLogLevel(level); }

        static void setChannel(const std::string& target, const std::string& url)
        { LogTarget::get(target).setChannel(url); }

        static void reset(const std::string& target)
        { LogTarget::get(target).reset(); }

        bool enabled(LogLevel level) const
        {
            return level <= _target->logLevel();
        }

        bool enabled(const LogRecord& record) const
        {
            return record.logLevel() <= _target->logLevel();
        }

        void log(const LogRecord& record, bool always = false)
        {
            if( always || this->enabled( record.logLevel() ) )
            {
                _target->log( record );
            }
        }

        LogTarget& target() const
        { return *_target; }
 
    protected:
        Logger(LogTarget& t)
        : _target( &t )
        {}
 
    private:
        LogTarget& initLogger(const std::string& name);
 
    private:
        LogTarget* _target;
};

class LogMessage : protected Pt::NonCopyable
{
    public:
        LogMessage(Logger& logger, const LogLevel& level, bool always = false)
        : _record(level)
        , _logger(&logger)
        , _enabled(always)
        { }

        ~LogMessage()
        {}
        
        const LogRecord& record() const
        { return _record; }

        void log()
        { 
            _logger->log( _record, _enabled ); 
            _enabled = false;
        }

        bool enabled() const
        { return _logger->enabled( _record.logLevel() ); }

        operator bool() const
        { return enabled(); }

        bool operator!() const
        { return ! enabled(); }

        template <typename T>
        LogMessage& operator<<(const T& value)
        {
            _record << value;
            return *this;
        }

        LogMessage& operator<<( std::ostream& (*op)(std::ostream&) )
        {
            _record << op;
            return *this;
        }

        LogMessage& operator<<( std::ios& (*op)(std::ios&) )
        {
            _record << op;
            return *this;
        }

        LogMessage& operator<<( std::ios_base& (*op)(std::ios_base&) )
        {
            _record << op;
            return *this;
        }

        LogMessage& operator<<( LogMessage& (*pf)(LogMessage&) )
        {
            return pf(*this);
        }
 
    private:
        LogRecord _record;
        
        Logger* _logger;
        
        bool _enabled;
};

inline LogMessage& endlog(LogMessage& msg)
{
    msg.log();
    return msg;
}
 
struct LoggerStaticInit
{
    template <typename F>
    LoggerStaticInit(F initfunc)
    { initfunc(); }
};
 
} // namespace System
 
} // namespace Pt

#define PT_LOGGER_BEGIN_IMPL(logger, level)         \
    if( ! logger.enabled( Pt::System::level ) )     \
        ;                                           \
    else Pt::System::LogMessage(static_cast<Pt::System::Logger&>(logger), Pt::System::level, true)
 
#ifdef NLOG
    #define PT_LOG_INIT(file)
    #define PT_LOG_DEFINE_IMPL(instance, category)
    #define PT_LOG_TO_IMPL(instance, level, message)
    #define PT_LOGGER_LOG_IMPL(logger, level, expr)
#else
    #define PT_LOG_INIT(settings) Pt::System::Logger::init(settings);

    #define PT_LOG_DEFINE_IMPL(instance, category)                \
    inline static Pt::System::Logger& instance()                  \
    {                                                             \
        static Pt::System::Logger instance##_instance(category);  \
        return instance##_instance;                               \
    }                                                             \
    static const Pt::System::LoggerStaticInit instance##_static_init( &instance );

    #define PT_LOG_TO_IMPL(instance, level, expr) PT_LOGGER_LOG_IMPL(instance(), level, expr)

    #define PT_LOGGER_LOG_IMPL(logger, level, expr) PT_LOGGER_BEGIN_IMPL(logger, level) << expr << Pt::System::endlog
#endif
 
#define PT_LOG_DEFINE(category) PT_LOG_DEFINE_IMPL(static_logger, category)
#define PT_LOG_FATAL(expr) PT_LOG_TO_IMPL(static_logger, Fatal, expr)
#define PT_LOG_ERROR(expr) PT_LOG_TO_IMPL(static_logger, Error, expr)
#define PT_LOG_WARN(expr)  PT_LOG_TO_IMPL(static_logger, Warn, expr)
#define PT_LOG_INFO(expr)  PT_LOG_TO_IMPL(static_logger, Info, expr)
#define PT_LOG_DEBUG(expr) PT_LOG_TO_IMPL(static_logger, Debug, expr)
#define PT_LOG_TRACE(expr) PT_LOG_TO_IMPL(static_logger, Trace, expr)
 
#define PT_LOG_DEFINE_INSTANCE(instance, category) PT_LOG_DEFINE_IMPL(instance, category)
#define PT_LOG_FATAL_TO(instance, expr) PT_LOG_TO_IMPL(instance, Fatal, expr)
#define PT_LOG_ERROR_TO(instance, expr) PT_LOG_TO_IMPL(instance, Error, expr)
#define PT_LOG_WARN_TO(instance, expr)  PT_LOG_TO_IMPL(instance, Warn, expr)
#define PT_LOG_INFO_TO(instance, expr)  PT_LOG_TO_IMPL(instance, Info, expr)
#define PT_LOG_DEBUG_TO(instance, expr) PT_LOG_TO_IMPL(instance, Debug, expr)
#define PT_LOG_TRACE_TO(instance, expr) PT_LOG_TO_IMPL(instance, Trace, expr)
 
#define PT_LOGGER_LOG_FATAL(logger, expr) PT_LOGGER_LOG_IMPL(logger, Fatal, expr)
#define PT_LOGGER_LOG_ERROR(logger, expr) PT_LOGGER_LOG_IMPL(logger, Error, expr)
#define PT_LOGGER_LOG_WARN(logger, expr)  PT_LOGGER_LOG_IMPL(logger, Warn, expr)
#define PT_LOGGER_LOG_INFO(logger, expr)  PT_LOGGER_LOG_IMPL(logger, Info, expr)
#define PT_LOGGER_LOG_DEBUG(logger, expr) PT_LOGGER_LOG_IMPL(logger, Debug, expr)
#define PT_LOGGER_LOG_TRACE(logger, expr) PT_LOGGER_LOG_IMPL(logger, Trace, expr)
 
#define PT_LOGGER_BEGIN_FATAL(logger) PT_LOGGER_BEGIN_IMPL(logger, Fatal)
#define PT_LOGGER_BEGIN_ERROR(logger) PT_LOGGER_BEGIN_IMPL(logger, Error)
#define PT_LOGGER_BEGIN_WARN(logger) PT_LOGGER_BEGIN_IMPL(logger, Warn)
#define PT_LOGGER_BEGIN_INFO(logger) PT_LOGGER_BEGIN_IMPL(logger, Info)
#define PT_LOGGER_BEGIN_DEBUG(logger) PT_LOGGER_BEGIN_IMPL(logger, Debug)
#define PT_LOGGER_BEGIN_TRACE(logger) PT_LOGGER_BEGIN_IMPL(logger, Trace)
 
#endif // Pt_System_Logger_h