/home/tobi/workspace/solarpowerlog/src/configuration/ILogger.h

Go to the documentation of this file.

/* ----------------------------------------------------------------------------
 solarpowerlog
 Copyright (C) 2009  Tobias Frost

 This file is part of solarpowerlog.

 Solarpowerlog is free software; However, it is dual-licenced
 as described in the file "COPYING".

 For this file (ILogger.h), the license terms are:

 You can redistribute it and/or  modify it under the terms of the GNU Lesser
 General Public License (LGPL) as published by the Free Software Foundation;
 either version 3 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
 Lesser General Public License for more details.

 You should have received a copy of the GNU Library General Public
 License along with this proramm; if not, see
 <http://www.gnu.org/licenses/>.
 ----------------------------------------------------------------------------
 */

#ifndef ILOGGER_H_
#define ILOGGER_H_

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <string>
#include <ostream>


#ifdef HAVE_LIBLOG4CXX
#include <log4cxx/logger.h>
#endif


#ifdef HAVE_LIBLOG4CXX

#define LOGFATAL(logger, message)  do \
     {\
          if (logger.IsEnabled(ILogger::LL_FATAL)) { \
               std::stringstream ss;\
               ss << message;\
               logger << ss;\
          }\
     } while(0)

#define LOGERROR(logger, message)  do \
     {\
          if (logger.IsEnabled(ILogger::LL_ERROR)) { \
               std::stringstream ss;\
               ss << message;\
               logger << ss;\
          }\
     } while(0)

#define LOGWARN(logger, message)   do \
     {\
          if (logger.IsEnabled(ILogger::LL_WARN)) { \
               std::stringstream ss;\
               ss << message;\
               logger << ss;\
          }\
     } while(0)

#define LOGINFO(logger, message)   do \
     {\
          if (logger.IsEnabled(ILogger::LL_INFO)) { \
               std::stringstream ss;\
               ss << message;\
               logger << ss;\
          }\
     } while(0)

#define LOGDEBUG(logger, message)   do \
     {\
          if (logger.IsEnabled(ILogger::LL_DEBUG)) { \
               std::stringstream ss;\
               ss << message;\
               logger << ss;\
          }\
     } while(0)

#define LOGTRACE(logger, message)   do \
     {\
          if (logger.IsEnabled(ILogger::LL_TRACE)) { \
               std::stringstream ss;\
               ss << message;\
               logger << ss;\
          }\
     } while(0)

#define LOGALL(logger, message)   do \
     {\
          if (logger.IsEnabled(ILogger::LL_ALL)) { \
               std::stringstream ss;\
               ss << message;\
               logger << ss;\
          }\
     } while(0)

#else

#define LOGFATAL(logger, message) do { \
     cerr << message << endl;\
} while(0)

#define LOGERROR(logger, message) do { \
     cerr << message << endl;\
} while(0)

#define LOGWARN(logger, message)

#define LOGINFO(logger, message)

#define LOGDEBUG(logger, message)

#define LOGTRACE(logger, message)

#define LOGALL(logger, message)

#endif


#ifdef HAVE_LIBLOG4CXX

class ILogger /*: public std::ostream*/
{
public:

     enum level
     {
          LL_OFF = log4cxx::Level::OFF_INT,
          LL_FATAL = log4cxx::Level::FATAL_INT,
          LL_ERROR = log4cxx::Level::ERROR_INT,
          LL_WARN = log4cxx::Level::WARN_INT,
          LL_INFO = log4cxx::Level::INFO_INT,
          LL_DEBUG = log4cxx::Level::DEBUG_INT,
          LL_TRACE = log4cxx::Level::TRACE_INT,
          LL_ALL = log4cxx::Level::ALL_INT
     };

     void Setup( const std::string &name, const std::string &configuration,
          const std::string& section );

     void Setup( const std::string &parent,
          const std::string &specialization );

     ILogger();

     virtual ~ILogger();

     inline std::string getLoggername() const
     {
          return loggername_;
     }

     inline bool IsEnabled( int loglevel )
     {
          if (loglevel >= currentloggerlevel_) {
               currentlevel = loglevel;
               return true;
          } else
               return false;
     }

     inline void SetLogLevel( int loglevel )
     {
          currentlevel = loglevel;
     }

     inline void Log( int loglevel, const std::string &log )
     {
          if (IsEnabled(loglevel))
               loggerptr_->log(log4cxx::Level::toLevel(loglevel),log);
     }

     std::string & operator <<( std::string &os )
     {
          if (currentlevel >= currentloggerlevel_) {
               loggerptr_->forcedLog(log4cxx::Level::toLevel(
                    currentlevel), os);
          }
          return os;
     }

     std::stringstream & operator <<( std::stringstream &os )
     {
          if (currentlevel >= currentloggerlevel_) {
               std::string s = os.str();
               loggerptr_->forcedLog(log4cxx::Level::toLevel(
                    currentlevel), s);
          }
          return os;
     }

private:

     std::string config_;

     std::string loggername_;

     log4cxx::LoggerPtr loggerptr_;

     int currentlevel;

     int currentloggerlevel_;


};

#endif // HAVE_LIBLOG4CXX
#ifndef HAVE_LIBLOG4CXX

class ILogger /*: public std::ostream*/
{
public:

     enum level
     {
          LL_OFF = 0,
          LL_FATAL ,
          LL_ERROR ,
          LL_WARN ,
          LL_INFO ,
          LL_DEBUG ,
          LL_TRACE ,
          LL_ALL
     };
     void Setup( const std::string &, const std::string &,
          const std::string&  ) { };

     void Setup( const std::string &,
               const std::string & ) {};

     ILogger() {};

     virtual ~ILogger() {};

     std::string getLoggername() const
     {
          return "";
     }

     inline bool IsEnabled( int )
     {
          return false;
     }

     inline void SetLogLevel( int )
     {
     }

     inline void Log( int , std::string )
     {
     }

     std::string & operator <<( std::string &os )
     {
          return os;
     }

     std::stringstream & operator <<( std::stringstream &os )
     {
          return os;
     }

};
#endif // !HAVE_LIBLOG4CXX



#endif /* ILOGGER_H_ */