/*
* 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>

/*!
* \brief Base logger class.
*
* There are two types of logging levels that are used by this class. First
* there is the filter level. Any log message that is assigned a level
* higher than the current filter level is discarded. Secondly there is the
* current output level. Log messages that do not have their own level
* use the current output level to determine if they should be shown or
* not.
*
* The two methods setFilterLevel() and setOutputLevel() set the filter
* and default output logging levels, respectively. There are corresponding
* getter methods as well. Both the filter and output levels are
* initialized to #INFO during object construction.
*
* Most use of the logger classes is expected to be through the Log
* class. It provides static logging methods that call through to a global
* singleton logger instance. There is also a Log::SetOutputLevel utility
* class that makes it extremely easiy to temporarily change the default
* output logging level.
*
* Of all the overloaded log() methods in this class, none of them are
* really expected to be reimplemented by subclasses. Instead, there is
* the single protected _log() method that takes a simple string pointer.
* The other log methods all wind up calling _log(), so it provides a
* single point to override. In fact, _log() is pure virtual, so subclasses
* must implement it.
*
* \see Log
*/
class Logger
{
public:
       //! \brief Logging levels.
       enum log_level_t
       {
               URGENT = 0,     //!< The lowest level, for messages that must always be logged.
               ERROR,          //!< For fatal error messages.
               WARNING,        //!< For non-fatal warning messages.
               INFO,           //!< The normal log level, for status messages.
               INFO2,          //!< For verbose status messages.
               DEBUG,          //!< For internal reporting.
               DEBUG2          //!< Highest log level; verbose debug logging.
       };

public:
       //! \brief Default constructor.
       Logger() : m_filter(INFO), m_level(INFO) {}

       //! \brief Destructor.
       virtual ~Logger() {}

       //! \name Logging levels
       //@{
       //! \brief Changes the logging level to \a level.
       inline void setFilterLevel(log_level_t level) { m_filter = level; }

       //! \brief Returns the current logging filter level.
       inline log_level_t getFilterLevel() const { return m_filter; }

       //! \brief Changes the logging output level to \a level.
       inline void setOutputLevel(log_level_t level) { m_level = level; }

       //! \brief Returns the current logging output level.
       inline log_level_t getOutputLevel() const { return m_level; }
       //@}

       //! \name Logging
       //@{
       //! \brief Log with format.
       virtual void log(const char * fmt, ...);

       //! \brief Log a string object.
       virtual void log(const std::string & msg) { log(msg.c_str()); }

       //! \brief Log with format at a specific output level.
       virtual void log(log_level_t level, const char * fmt, ...);

       //! \brief Log a string output at a specific output level.
       virtual void log(log_level_t level, const std::string & msg) { log(level, msg.c_str()); }

       //! \brief Log with format using an argument list.
       virtual void log(const char * fmt, va_list args);

       //! \brief Log with format using an argument with a specific output level.
       virtual void log(log_level_t level, const char * fmt, va_list args);
       //@}

protected:
       log_level_t m_filter;   //!< The current logging filter level.
       log_level_t m_level;    //!< The current log output level.

protected:
       //! \brief The base pure virtual logging function implemented by subclasses.
       virtual void _log(const char * msg)=0;
};

/*!
* \brief Wraps a set of static functions for easy global logging access.
*
* This class has a set of static methods that make it easy to access a global
* logger instance without having to worry about extern symbols. It does this
* by keeping a static member variable pointing at the singleton logger instance,
* which is set with the setLogger() static method.
*
* There is also an inner utility class called SetOutputLevel that uses
* C++ scoping rules to temporarily change the output logging level. When the
* SetOutputLevel instance falls out of scope the output level is restored
* to the previous value.
*/
class Log
{
public:
       //! \name Singleton logger access
       //@{
       //! \brief Returns the current global logger singleton.
       static inline Logger * getLogger() { return s_logger; }

       //! \brief Sets the global logger singleton instance.
       static inline void setLogger(Logger * logger) { s_logger = logger; }
       //@}

       //! \name Logging
       //@{
       //! \brief Log with format.
       static void log(const char * fmt, ...);

       //! \brief Log a string object.
       static void log(const std::string & msg);

       //! \brief Log with format at a specific output level.
       static void log(Logger::log_level_t level, const char * fmt, ...);

       //! \brief Log a string output at a specific output level.
       static void log(Logger::log_level_t level, const std::string & msg);
       //@}

protected:
       static Logger * s_logger;       //!< The single global logger instance.

public:
       /*!
        * \brief Utility class to temporarily change the logging output level.
        *
        * This class will change the current logging output level of a given
        * logger instance. Then when it falls out of scope it will set the
        * level back to what it was originally.
        *
        * Use like this:
        * \code
        *              // output level is some value here
        *              {
        *                      Log::SetOutputLevel leveler(Logger::DEBUG);
        *                      // now output level is DEBUG
        *                      Log::log("my debug message 1");
        *                      Log::log("my debug message 2");
        *              }
        *              // output level is restored to previous value
        * \endcode
        */
       class SetOutputLevel
       {
       public:
               //! \brief Default constructor.
               //!
               //! Saves the current logging output level of the global logger,
               //! as managed by the Log class, and sets the new level to \a level.
               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);
               }

               //! \brief Constructor.
               //!
               //! Saves the current logging output level of \a logger and sets
               //! the new level to \a level.
               SetOutputLevel(Logger * logger, Logger::log_level_t level)
               :       m_logger(logger), m_saved(logger->getOutputLevel())
               {
                       assert(m_logger);
                       m_logger->setOutputLevel(level);
               }

               //! \brief Destructor.
               //!
               //! Restores the saved logging output level.
               ~SetOutputLevel()
               {
                       m_logger->setOutputLevel(m_saved);
               }

       protected:
               Logger * m_logger;      //!< The logger instance we're controlling.
               Logger::log_level_t m_saved;    //!< Original logging output level.
       };

};


/*!
* \brief Simple logger that writes to stdout.
*/
class StdoutLogger : public Logger
{
protected:
       //! \brief Logs the message to stdout.
       virtual void _log(const char * msg);
};

#endif // _Logging_h_

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.