logger.h

/*
Copyright (C) 2012 Intel Corporation

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.

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 LOGGER_H
#define LOGGER_H

#include <fstream>
#include <ostream>
#include <string>
#include <sstream>
#include <sys/time.h>
#include <sys/types.h>

// Comment this line if you don't need multithread support
#define LOGGER_MULTITHREAD
#ifdef LOGGER_MULTITHREAD
#include <pthread.h>
#endif

namespace CUtil {

class Logger
{
    enum loggerConf_    {L_nofile_  =   1 << 0,
                L_file_     =   1 << 1,
                L_noscreen_ =   1 << 2,
                L_screen_   =   1 << 3};

#ifdef LOGGER_MULTITHREAD

    static pthread_mutex_t lock_;
#endif

    bool configured_;

    static Logger* m_;

    std::string logFile_;

    std::string logFileName_;

    loggerConf_ configuration_;

    std::ofstream out_;

    int64_t initialTime_usec_;

    unsigned int fileVerbosityLevel_;

    unsigned int screenVerbosityLevel_;

    Logger();
    ~Logger();

    inline static void lock();

    inline static void unlock();

public:

    enum Level {
        EError = 0,
        EWarning,
        EMessage,
        EInfo,
        ETrace,
        EDebug
    };

    #define DEBUG_CONF(outputFile, \
            configuration, \
            fileVerbosityLevel, \
            screenVerbosityLevel) { \
                CUtil::Logger::getInstance().configure(outputFile, \
                            configuration, \
                            fileVerbosityLevel, \
                            screenVerbosityLevel); \
            }

    #define LOGGER(priority, msg) { \
        std::ostringstream __debug_stream__; \
        __debug_stream__ << msg; \
        CUtil::Logger::getInstance().print(priority, __FILE__, __LINE__, \
                __debug_stream__.str()); \
        }

    #ifndef _LOGGER_NO_LOG

    #define LOG_ERROR(M)        LOGGER(CUtil::Logger::EError, M)

    #define LOG_WARNING(M)      LOGGER(CUtil::Logger::EWarning, M)

    #define LOG_MESSAGE(M)      LOGGER(CUtil::Logger::EMessage, M)

    #define LOG_INFO(M)         LOGGER(CUtil::Logger::EInfo, M)

    #define LOG_TRACE(M)        LOGGER(CUtil::Logger::ETrace, M)

    #define LOG_DEBUG(M)        LOGGER(CUtil::Logger::EDebug, M)

    #else

    #define LOG_ERROR(M)        {}
    #define LOG_WARNING(M)      {}
    #define LOG_MESSAGE(M)      {}
    #define LOG_INFO(M)         {}
    #define LOG_TRACE(M)        {}
    #define LOG_DEBUG(M)        {}

    #endif

    typedef loggerConf_ loggerConf;
    static const loggerConf file_on=    L_nofile_;
    static const loggerConf file_off=   L_file_;
    static const loggerConf screen_on=  L_noscreen_;
    static const loggerConf screen_off= L_screen_;

    static Logger& getInstance();

    void print(const unsigned int       verbosityLevel,
            const std::string&  sourceFile,
            const int       codeLine,
            const std::string&  message);

    void configure (const std::string&  outputFile,
            const loggerConf    configuration,
            const int       fileVerbosityLevel,
            const int       screenVerbosityLevel);

    inline void flush()
    {
        out_.flush();
    }
};

inline Logger::loggerConf operator|
    (Logger::loggerConf __a, Logger::loggerConf __b)
{
    return Logger::loggerConf(static_cast<int>(__a) |
        static_cast<int>(__b));
}

inline Logger::loggerConf operator&
    (Logger::loggerConf __a, Logger::loggerConf __b)
{
    return Logger::loggerConf(static_cast<int>(__a) &
        static_cast<int>(__b)); }

}

#endif /* LOGGER_H */