devel/libmdw/trunk/libmdw/src/Logger.h

/***************************************************************************
 *   Copyright (C) 2010 by Jean-Baptiste Wons   *
 *   wonsjb@gmail.com   *
 *                                                                         *
 *   This program 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 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program 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, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#ifndef MDWLOGGER_H
#define MDWLOGGER_H

#include <string>
#include "Stream.h"

namespace mdw
{

class Logger
{
public:
    typedef enum
    {
        Fatal_e, Error_e, Warn_e, Info_e, Debug_e
    } LogType_t;

    class LevelWrap
    {
    public:
        LevelWrap (int l) : level (l) {}
        int level;
    };
    class LineWrap
    {
    public:
        LineWrap (int l) : line (l) {}
        int line;
    };
    class FileWrap
    {
    public:
        FileWrap (const char * f) : file (f) {}
        const char * file;
    };

    class LogStream : public Stream
    {
    public:
        virtual void output (const char * buff, int size)
        {
            _logger.log (_logType, buff, size, _level, false, _file, _line);
        }
        LogStream & operator<< (LogType_t type)
        {
            _logType = type;
            return *this;
        }
        LogStream & operator<< (LevelWrap level)
        {
            _level = level.level;
            return *this;
        }
        LogStream & operator<< (LineWrap line)
        {
            _line = line.line;
            return *this;
        }
        Stream & operator<< (FileWrap file)
        {
            _file = file.file;
            return *this;
        }
        LogStream & operator<< (Endl e)
        {
            _logger.log (_logType, "", 0, _level, true, _file, _line);
            return *this;
        }
        friend class Logger;
    private:
        LogStream (Logger &l) : _logger (l) {}
        int _level;
        LogType_t _logType;
        Logger &_logger;
        int _line;
        const char * _file;
    };

    static void initialise (Stream &s);
    static Logger &getInstance();
    void setDebugMode (const std::string &className, bool active, int level);
    void log (LogType_t type, const std::string &message, int level, bool end, const char* file, int line);
    void log (LogType_t type, const char * buff, int size, int level, bool end, const char* file, int line);
    LogStream &getStreamInt();
    Stream &getStream();
    Logger (Stream &s);
    ~Logger();
private:

    Stream &_underlyer;
    void init();
    void logStart (LogType_t, const char* file, int line);
    static Logger *_instance;
    LogStream _stream;
    bool _start;
};

}

#define LOG_LEVEL(a, l, t){mdw::Logger::getInstance().getStreamInt() << mdw::Logger::l << mdw::Logger::LevelWrap(t) << \
    mdw::Logger::LineWrap(__LINE__) << mdw::Logger::FileWrap(__FILE__) << a << mdw::endl; }
#define LOG_FATAL(a) LOG_LEVEL(a, Fatal_e, 0)
#define LOG_ERROR(a) LOG_LEVEL(a, Error_e, 0)
#define LOG_ERRNO(a, e){char buff[1024]; strerror_r(e, buff, 1024); mdw::Logger::getInstance().getStreamInt() \
    << mdw::Logger::Error_e << mdw::Logger::LevelWrap(0) << mdw::Logger::LineWrap(__LINE__) << mdw::Logger::FileWrap(__FILE__) \
    << a << " - Errno is " <<  buff << mdw::endl; }
#define LOG_WARN(a) LOG_LEVEL(a, Warn_e, 0)
#define LOG_INFO(a) LOG_LEVEL(a, Info_e, 0)
#define LOG_DEBUG(a,t) LOG_LEVEL(a, Debug_e, t)

#endif

---