src/blfwk/Logging.h

/*
 * Copyright (c) 2013-14, Freescale Semiconductor, Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * o Redistributions of source code must retain the above copyright notice, this list
 *   of conditions and the following disclaimer.
 *
 * o Redistributions in binary form must reproduce the above copyright notice, this
 *   list of conditions and the following disclaimer in the documentation and/or
 *   other materials provided with the distribution.
 *
 * o Neither the name of Freescale Semiconductor, Inc. nor the names of its
 *   contributors may be used to endorse or promote products derived from this
 *   software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#if !defined(_Logging_h_)
#define _Logging_h_

#include <string>
#include <assert.h>
#include <stdarg.h>
#include <fstream>


class Logger
{
public:
    enum log_level_t
    {
        kUrgent = 0,     
        kJson,           
        kError,          
        kWarning,        
        kInfo,           
        kInfo2,          
        kDebug,          
        kDebug2,         
        kInfo1 = kInfo,  
        kDebug1 = kDebug 
    };

public:
    Logger()
        : m_filter(kInfo)
        , m_level(kInfo)
    {
    }

    virtual ~Logger() {}

    inline void setFilterLevel(log_level_t level) { m_filter = level; }
    inline log_level_t getFilterLevel() const { return m_filter; }
    inline void setOutputLevel(log_level_t level) { m_level = level; }
    inline log_level_t getOutputLevel() const { return m_level; }


    virtual void log(const char *fmt, ...);

    virtual void log(const std::string &msg) { log(msg.c_str()); }
    virtual void log(log_level_t level, const char *fmt, ...);

    virtual void log(log_level_t level, const std::string &msg) { log(level, msg.c_str()); }
    virtual void log(const char *fmt, va_list args);

    virtual void log(log_level_t level, const char *fmt, va_list args);

protected:
    log_level_t m_filter; 
    log_level_t m_level;  

protected:
    virtual void _log(const char *msg) = 0;
};

class Log
{
public:

    static inline Logger *getLogger() { return s_logger; }
    static inline void setLogger(Logger *logger) { s_logger = logger; }


    static void log(const char *fmt, ...);

    static void log(const std::string &msg);

    static void log(Logger::log_level_t level, const char *fmt, ...);

    static void log(Logger::log_level_t level, const std::string &msg);


    static void urgent(const char *fmt, ...);  
    static void json(const char *fmt, ...);    
    static void error(const char *fmt, ...);   
    static void warning(const char *fmt, ...); 
    static void info(const char *fmt, ...);    
    static void info2(const char *fmt, ...);   
    static void debug(const char *fmt, ...);   
    static void debug2(const char *fmt, ...);  


protected:
    static Logger *s_logger; 

public:
    class SetOutputLevel
    {
    public:
        SetOutputLevel(Logger::log_level_t level)
            : m_logger(Log::getLogger())
            , m_saved(Logger::kInfo)
        {
            assert(m_logger);
            m_saved = m_logger->getOutputLevel();
            m_logger->setOutputLevel(level);
        }

        SetOutputLevel(Logger *logger, Logger::log_level_t level)
            : m_logger(logger)
            , m_saved(logger->getOutputLevel())
        {
            assert(m_logger);
            m_logger->setOutputLevel(level);
        }

        ~SetOutputLevel() { m_logger->setOutputLevel(m_saved); }
    protected:
        Logger *m_logger;            
        Logger::log_level_t m_saved; 
    };
};

class StdoutLogger : public Logger
{
protected:
    virtual void _log(const char *msg);
};

class FileLogger : public Logger
{
public:
    FileLogger(const char *file_path);
    ~FileLogger();

protected:
    virtual void _log(const char *msg);

    const std::string m_file_path;
    std::ofstream m_logFile;
};


#endif // _Logging_h_