apps/elftosb/common/Logging.h

/*
 * File:    Logging.h
 *
 * Copyright (c) Freescale Semiconductor, Inc. All rights reserved.
 * See included license file for license details.
 */
#if !defined(_Logging_h_)
#define _Logging_h_

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

class Logger
{
public:
    enum log_level_t
    {
        URGENT = 0, 
        ERROR,      
        WARNING,    
        INFO,       
        INFO2,      
        DEBUG,      
        DEBUG2      
    };

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

    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);

protected:
    static Logger *s_logger; 

public:
    class SetOutputLevel
    {
    public:
        SetOutputLevel(Logger::log_level_t level)
            : m_logger(Log::getLogger())
            , m_saved(Logger::INFO)
        {
            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);
};

#endif // _Logging_h_