common/include/pion/PionLogger.hpp

00001 // -----------------------------------------------------------------------
00002 // pion-common: a collection of common libraries used by the Pion Platform
00003 // -----------------------------------------------------------------------
00004 // Copyright (C) 2007-2008 Atomic Labs, Inc.  (http://www.atomiclabs.com)
00005 //
00006 // Distributed under the Boost Software License, Version 1.0.
00007 // See http://www.boost.org/LICENSE_1_0.txt
00008 //
00009 
00010 #ifndef __PION_PIONLOGGER_HEADER__
00011 #define __PION_PIONLOGGER_HEADER__
00012 
00013 #include <pion/PionConfig.hpp>
00014 
00015 
00016 #if defined(PION_USE_LOG4CXX)
00017 
00018     // unfortunately, the current version of log4cxx has many problems that
00019     // produce very annoying warnings
00020 
00021     // log4cxx headers
00022     #include <log4cxx/logger.h>
00023 #ifdef _MSC_VER
00024     #pragma warning(push)
00025     #pragma warning(disable: 4231) // nonstandard extension used : 'extern' before template explicit instantiation
00026 #endif
00027     #include <log4cxx/basicconfigurator.h>
00028     #include <log4cxx/propertyconfigurator.h>
00029 #ifdef _MSC_VER
00030     #pragma warning(pop)
00031 #endif
00032 
00033     #if defined _MSC_VER
00034         #if defined _DEBUG
00035             #pragma comment(lib, "log4cxxd")
00036         #else
00037             #pragma comment(lib, "log4cxx")
00038         #endif
00039         #pragma comment(lib, "odbc32")
00040     #endif 
00041 
00042     namespace pion {
00043         typedef log4cxx::LoggerPtr  PionLogger;
00044     }
00045 
00046     #define PION_LOG_CONFIG_BASIC   log4cxx::BasicConfigurator::configure();
00047     #define PION_LOG_CONFIG(FILE)   log4cxx::PropertyConfigurator::configure(FILE);
00048     #define PION_GET_LOGGER(NAME)   log4cxx::Logger::getLogger(NAME)
00049 
00050     #define PION_LOG_SETLEVEL_DEBUG(LOG)    LOG->setLevel(log4cxx::Level::toLevel(log4cxx::Level::DEBUG_INT));
00051     #define PION_LOG_SETLEVEL_INFO(LOG)     LOG->setLevel(log4cxx::Level::toLevel(log4cxx::Level::INFO_INT));
00052     #define PION_LOG_SETLEVEL_WARN(LOG)     LOG->setLevel(log4cxx::Level::toLevel(log4cxx::Level::WARN_INT));
00053     #define PION_LOG_SETLEVEL_ERROR(LOG)    LOG->setLevel(log4cxx::Level::toLevel(log4cxx::Level::ERROR_INT));
00054     #define PION_LOG_SETLEVEL_FATAL(LOG)    LOG->setLevel(log4cxx::Level::toLevel(log4cxx::Level::FATAL_INT));
00055     #define PION_LOG_SETLEVEL_UP(LOG)       LOG->setLevel(LOG->getLevel()->toInt()+1);
00056     #define PION_LOG_SETLEVEL_DOWN(LOG)     LOG->setLevel(LOG->getLevel()->toInt()-1);
00057 
00058     #define PION_LOG_DEBUG  LOG4CXX_DEBUG
00059     #define PION_LOG_INFO   LOG4CXX_INFO
00060     #define PION_LOG_WARN   LOG4CXX_WARN
00061     #define PION_LOG_ERROR  LOG4CXX_ERROR
00062     #define PION_LOG_FATAL  LOG4CXX_FATAL
00063 
00064 #elif defined(PION_USE_LOG4CPLUS)
00065 
00066 
00067     // log4cplus headers
00068     #include <log4cplus/logger.h>
00069     #include <log4cplus/configurator.h>
00070     #include <log4cplus/appender.h>
00071     #include <log4cplus/spi/loggingevent.h>
00072 
00073     #include <boost/circular_buffer.hpp>
00074     #include <boost/thread/mutex.hpp>
00075 
00076     #if defined _MSC_VER
00077         #if defined _DEBUG
00078             #pragma comment(lib, "log4cplusD")
00079         #else
00080             #pragma comment(lib, "log4cplus")
00081         #endif
00082     #endif 
00083 
00084     namespace pion {
00085         typedef log4cplus::Logger   PionLogger;
00086 
00090         class CircularBufferAppender : public log4cplus::Appender
00091         {
00092         public:
00093             typedef boost::circular_buffer<log4cplus::spi::InternalLoggingEvent> LogEventBuffer;
00094 
00095             // default constructor and destructor
00096             CircularBufferAppender(void) : m_log_events(1000) {};
00097             virtual ~CircularBufferAppender() {}
00098             
00100             const LogEventBuffer& getLogIterator() const {
00101                 return m_log_events;
00102             }
00103 
00104         public:
00105             // member functions inherited from the Appender interface class
00106             virtual void close() {}
00107         protected:
00108             virtual void append(const log4cplus::spi::InternalLoggingEvent& event) {
00109                 boost::mutex::scoped_lock log_lock(m_log_mutex);
00110                 m_log_events.push_back(*event.clone());
00111             }
00112 
00113         private:
00115             LogEventBuffer  m_log_events;
00116 
00118             boost::mutex    m_log_mutex;
00119         };
00120     }
00121 
00122     #define PION_LOG_CONFIG_BASIC   log4cplus::BasicConfigurator::doConfigure();
00123     #define PION_LOG_CONFIG(FILE)   log4cplus::PropertyConfigurator::doConfigure(FILE);
00124     #define PION_GET_LOGGER(NAME)   log4cplus::Logger::getInstance(NAME)
00125 
00126     #define PION_LOG_SETLEVEL_DEBUG(LOG)    LOG.setLogLevel(log4cplus::DEBUG_LOG_LEVEL);
00127     #define PION_LOG_SETLEVEL_INFO(LOG)     LOG.setLogLevel(log4cplus::INFO_LOG_LEVEL);
00128     #define PION_LOG_SETLEVEL_WARN(LOG)     LOG.setLogLevel(log4cplus::WARN_LOG_LEVEL);
00129     #define PION_LOG_SETLEVEL_ERROR(LOG)    LOG.setLogLevel(log4cplus::ERROR_LOG_LEVEL);
00130     #define PION_LOG_SETLEVEL_FATAL(LOG)    LOG.setLogLevel(log4cplus::FATAL_LOG_LEVEL);
00131     #define PION_LOG_SETLEVEL_UP(LOG)       LOG.setLogLevel(LOG.getLogLevel()+1);
00132     #define PION_LOG_SETLEVEL_DOWN(LOG)     LOG.setLogLevel(LOG.getLogLevel()-1);
00133 
00134     #define PION_LOG_DEBUG  LOG4CPLUS_DEBUG
00135     #define PION_LOG_INFO   LOG4CPLUS_INFO
00136     #define PION_LOG_WARN   LOG4CPLUS_WARN
00137     #define PION_LOG_ERROR  LOG4CPLUS_ERROR
00138     #define PION_LOG_FATAL  LOG4CPLUS_FATAL
00139 
00140 
00141 #elif defined(PION_USE_LOG4CPP)
00142 
00143 
00144     // log4cpp headers
00145     #include <log4cpp/Category.hh>
00146     #include <log4cpp/BasicLayout.hh>
00147     #include <log4cpp/OstreamAppender.hh>
00148 
00149     namespace pion {
00150         typedef log4cpp::Category*  PionLogger;
00151     }
00152 
00153     #define PION_LOG_CONFIG_BASIC   { log4cpp::OstreamAppender *app = new log4cpp::OstreamAppender("cout", &std::cout); app->setLayout(new log4cpp::BasicLayout()); log4cpp::Category::getRoot().setAppender(app); }
00154     #define PION_LOG_CONFIG(FILE)   { log4cpp::PropertyConfigurator::configure(FILE); }
00155     #define PION_GET_LOGGER(NAME)   (&log4cpp::Category::getInstance(NAME))
00156 
00157     #define PION_LOG_SETLEVEL_DEBUG(LOG)    { LOG->setPriority(log4cpp::Priority::DEBUG); }
00158     #define PION_LOG_SETLEVEL_INFO(LOG)     { LOG->setPriority(log4cpp::Priority::INFO); }
00159     #define PION_LOG_SETLEVEL_WARN(LOG)     { LOG->setPriority(log4cpp::Priority::WARN); }
00160     #define PION_LOG_SETLEVEL_ERROR(LOG)    { LOG->setPriority(log4cpp::Priority::ERROR); }
00161     #define PION_LOG_SETLEVEL_FATAL(LOG)    { LOG->setPriority(log4cpp::Priority::FATAL); }
00162     #define PION_LOG_SETLEVEL_UP(LOG)       { LOG->setPriority(LOG.getPriority()+1); }
00163     #define PION_LOG_SETLEVEL_DOWN(LOG)     { LOG->setPriority(LOG.getPriority()-1); }
00164 
00165     #define PION_LOG_DEBUG(LOG, MSG)    if (LOG->getPriority()>=log4cpp::Priority::DEBUG) { LOG->debugStream() << MSG; }
00166     #define PION_LOG_INFO(LOG, MSG)     if (LOG->getPriority()>=log4cpp::Priority::INFO) { LOG->infoStream() << MSG; }
00167     #define PION_LOG_WARN(LOG, MSG)     if (LOG->getPriority()>=log4cpp::Priority::WARN) { LOG->warnStream() << MSG; }
00168     #define PION_LOG_ERROR(LOG, MSG)    if (LOG->getPriority()>=log4cpp::Priority::ERROR) { LOG->errorStream() << MSG; }
00169     #define PION_LOG_FATAL(LOG, MSG)    if (LOG->getPriority()>=log4cpp::Priority::FATAL) { LOG->fatalStream() << MSG; }
00170 
00171 #elif defined(PION_DISABLE_LOGGING)
00172 
00173     // Logging is disabled -> add do-nothing stubs for logging
00174     namespace pion {
00175         typedef int     PionLogger;
00176     }
00177 
00178     #define PION_LOG_CONFIG_BASIC   {}
00179     #define PION_LOG_CONFIG(FILE)   {}
00180     #define PION_GET_LOGGER(NAME)   0
00181 
00182     // use "++LOG" to avoid warnings about LOG not being used
00183     #define PION_LOG_SETLEVEL_DEBUG(LOG)    { if (false) ++LOG; }
00184     #define PION_LOG_SETLEVEL_INFO(LOG)     { if (false) ++LOG; }
00185     #define PION_LOG_SETLEVEL_WARN(LOG)     { if (false) ++LOG; }
00186     #define PION_LOG_SETLEVEL_ERROR(LOG)    { if (false) ++LOG; }
00187     #define PION_LOG_SETLEVEL_FATAL(LOG)    { if (false) ++LOG; }
00188     #define PION_LOG_SETLEVEL_UP(LOG)       { if (false) ++LOG; }
00189     #define PION_LOG_SETLEVEL_DOWN(LOG)     { if (false) ++LOG; }
00190 
00191     // use "++LOG" to avoid warnings about LOG not being used
00192     #define PION_LOG_DEBUG(LOG, MSG)    { if (false) ++LOG; }
00193     #define PION_LOG_INFO(LOG, MSG)     { if (false) ++LOG; }
00194     #define PION_LOG_WARN(LOG, MSG)     { if (false) ++LOG; }
00195     #define PION_LOG_ERROR(LOG, MSG)    { if (false) ++LOG; }
00196     #define PION_LOG_FATAL(LOG, MSG)    { if (false) ++LOG; }
00197 
00198 #else
00199 
00200     #define PION_USE_OSTREAM_LOGGING
00201 
00202     // Logging uses std::cout and std::cerr
00203     #include <iostream>
00204     #include <string>
00205     #include <ctime>
00206 
00207     namespace pion {
00208         struct PION_COMMON_API PionLogger {
00209             enum PionPriorityType {
00210                 LOG_LEVEL_DEBUG, LOG_LEVEL_INFO, LOG_LEVEL_WARN,
00211                 LOG_LEVEL_ERROR, LOG_LEVEL_FATAL
00212             };
00213             ~PionLogger() {}
00214             PionLogger(void) : m_name("pion") {}
00215             PionLogger(const std::string& name) : m_name(name) {}
00216             PionLogger(const PionLogger& p) : m_name(p.m_name) {}
00217             std::string                 m_name;
00218             static PionPriorityType     m_priority;
00219         };
00220     }
00221 
00222     #define PION_LOG_CONFIG_BASIC   {}
00223     #define PION_LOG_CONFIG(FILE)   {}
00224     #define PION_GET_LOGGER(NAME)   pion::PionLogger(NAME)
00225 
00226     #define PION_LOG_SETLEVEL_DEBUG(LOG)    { LOG.m_priority = pion::PionLogger::LOG_LEVEL_DEBUG; }
00227     #define PION_LOG_SETLEVEL_INFO(LOG)     { LOG.m_priority = pion::PionLogger::LOG_LEVEL_INFO; }
00228     #define PION_LOG_SETLEVEL_WARN(LOG)     { LOG.m_priority = pion::PionLogger::LOG_LEVEL_WARN; }
00229     #define PION_LOG_SETLEVEL_ERROR(LOG)    { LOG.m_priority = pion::PionLogger::LOG_LEVEL_ERROR; }
00230     #define PION_LOG_SETLEVEL_FATAL(LOG)    { LOG.m_priority = pion::PionLogger::LOG_LEVEL_FATAL; }
00231     #define PION_LOG_SETLEVEL_UP(LOG)       { ++LOG.m_priority; }
00232     #define PION_LOG_SETLEVEL_DOWN(LOG)     { --LOG.m_priority; }
00233 
00234     #define PION_LOG_DEBUG(LOG, MSG)    if (LOG.m_priority <= pion::PionLogger::LOG_LEVEL_DEBUG) { std::cout << time(NULL) << " DEBUG " << LOG.m_name << ' ' << MSG << std::endl; }
00235     #define PION_LOG_INFO(LOG, MSG)     if (LOG.m_priority <= pion::PionLogger::LOG_LEVEL_INFO) { std::cout << time(NULL) << " INFO " << LOG.m_name << ' ' << MSG << std::endl; }
00236     #define PION_LOG_WARN(LOG, MSG)     if (LOG.m_priority <= pion::PionLogger::LOG_LEVEL_WARN) { std::cerr << time(NULL) << " WARN " << LOG.m_name << ' ' << MSG << std::endl; }
00237     #define PION_LOG_ERROR(LOG, MSG)    if (LOG.m_priority <= pion::PionLogger::LOG_LEVEL_ERROR) { std::cerr << time(NULL) << " ERROR " << LOG.m_name << ' ' << MSG << std::endl; }
00238     #define PION_LOG_FATAL(LOG, MSG)    if (LOG.m_priority <= pion::PionLogger::LOG_LEVEL_FATAL) { std::cerr << time(NULL) << " FATAL " << LOG.m_name << ' ' << MSG << std::endl; }
00239 
00240 #endif
00241 
00242 #endif

Generated on Tue Mar 8 13:42:14 2011 for pion-net by  doxygen 1.4.7