pion-net  4.0.9
PionLogger.hpp
1 // -----------------------------------------------------------------------
2 // pion-common: a collection of common libraries used by the Pion Platform
3 // -----------------------------------------------------------------------
4 // Copyright (C) 2007-2008 Atomic Labs, Inc. (http://www.atomiclabs.com)
5 //
6 // Distributed under the Boost Software License, Version 1.0.
7 // See http://www.boost.org/LICENSE_1_0.txt
8 //
9 
10 #ifndef __PION_PIONLOGGER_HEADER__
11 #define __PION_PIONLOGGER_HEADER__
12 
13 #include <pion/PionConfig.hpp>
14 
15 
16 #if defined(PION_USE_LOG4CXX)
17 
18  // unfortunately, the current version of log4cxx has many problems that
19  // produce very annoying warnings
20 
21  // log4cxx headers
22  #include <log4cxx/logger.h>
23 #ifdef _MSC_VER
24  #pragma warning(push)
25  #pragma warning(disable: 4231) // nonstandard extension used : 'extern' before template explicit instantiation
26 #endif
27  #include <log4cxx/basicconfigurator.h>
28  #include <log4cxx/propertyconfigurator.h>
29 #ifdef _MSC_VER
30  #pragma warning(pop)
31 #endif
32 
33  #if defined _MSC_VER
34  #if defined _DEBUG
35  #pragma comment(lib, "log4cxxd")
36  #else
37  #pragma comment(lib, "log4cxx")
38  #endif
39  #pragma comment(lib, "odbc32")
40  #endif
41 
42  namespace pion {
43  typedef log4cxx::LoggerPtr PionLogger;
44  typedef log4cxx::AppenderSkeleton PionLogAppender;
45  typedef PionLogAppender * PionLogAppenderPtr;
46  }
47 
48  #define PION_HAS_LOG_APPENDER 1
49  #define PION_LOG_CONFIG_BASIC log4cxx::BasicConfigurator::configure();
50  #define PION_LOG_CONFIG(FILE) log4cxx::PropertyConfigurator::configure(FILE);
51  #define PION_GET_LOGGER(NAME) log4cxx::Logger::getLogger(NAME)
52 
53  #define PION_LOG_SETLEVEL_DEBUG(LOG) LOG->setLevel(log4cxx::Level::toLevel(log4cxx::Level::DEBUG_INT));
54  #define PION_LOG_SETLEVEL_INFO(LOG) LOG->setLevel(log4cxx::Level::toLevel(log4cxx::Level::INFO_INT));
55  #define PION_LOG_SETLEVEL_WARN(LOG) LOG->setLevel(log4cxx::Level::toLevel(log4cxx::Level::WARN_INT));
56  #define PION_LOG_SETLEVEL_ERROR(LOG) LOG->setLevel(log4cxx::Level::toLevel(log4cxx::Level::ERROR_INT));
57  #define PION_LOG_SETLEVEL_FATAL(LOG) LOG->setLevel(log4cxx::Level::toLevel(log4cxx::Level::FATAL_INT));
58  #define PION_LOG_SETLEVEL_UP(LOG) LOG->setLevel(LOG->getLevel()->toInt()+1);
59  #define PION_LOG_SETLEVEL_DOWN(LOG) LOG->setLevel(LOG->getLevel()->toInt()-1);
60 
61  #define PION_LOG_DEBUG LOG4CXX_DEBUG
62  #define PION_LOG_INFO LOG4CXX_INFO
63  #define PION_LOG_WARN LOG4CXX_WARN
64  #define PION_LOG_ERROR LOG4CXX_ERROR
65  #define PION_LOG_FATAL LOG4CXX_FATAL
66 
67 #elif defined(PION_USE_LOG4CPLUS)
68 
69 
70  // log4cplus headers
71  #include <log4cplus/logger.h>
72  #include <log4cplus/configurator.h>
73  #include <log4cplus/appender.h>
74  #include <log4cplus/spi/loggingevent.h>
75  #include <log4cplus/loglevel.h>
76 
77  #include <boost/circular_buffer.hpp>
78  #include <boost/thread/mutex.hpp>
79 
80  #if defined _MSC_VER
81  #if defined _DEBUG
82  #pragma comment(lib, "log4cplusD")
83  #else
84  #pragma comment(lib, "log4cplus")
85  #endif
86  #endif
87 
88  namespace pion {
89  typedef log4cplus::Logger PionLogger;
90  typedef log4cplus::Appender PionLogAppender;
91  typedef log4cplus::SharedAppenderPtr PionLogAppenderPtr;
92 
96  class CircularBufferAppender : public log4cplus::Appender
97  {
98  public:
99  typedef boost::circular_buffer<log4cplus::spi::InternalLoggingEvent> LogEventBuffer;
100 
101  // default constructor and destructor
102  CircularBufferAppender(void) : m_log_events(1000) {};
103  virtual ~CircularBufferAppender() {}
104 
106  const LogEventBuffer& getLogIterator() const {
107  return m_log_events;
108  }
109 
110  public:
111  // member functions inherited from the Appender interface class
112  virtual void close() {}
113  protected:
114  virtual void append(const log4cplus::spi::InternalLoggingEvent& event) {
115  boost::mutex::scoped_lock log_lock(m_log_mutex);
116  m_log_events.push_back(*event.clone());
117  }
118 
119  private:
121  LogEventBuffer m_log_events;
122 
124  boost::mutex m_log_mutex;
125  };
126  }
127 
128  #define PION_HAS_LOG_APPENDER 1
129  #define PION_LOG_CONFIG_BASIC log4cplus::BasicConfigurator::doConfigure();
130  #define PION_LOG_CONFIG(FILE) log4cplus::PropertyConfigurator::doConfigure(FILE);
131  #define PION_GET_LOGGER(NAME) log4cplus::Logger::getInstance(NAME)
132 
133  #define PION_LOG_SETLEVEL_DEBUG(LOG) LOG.setLogLevel(log4cplus::DEBUG_LOG_LEVEL);
134  #define PION_LOG_SETLEVEL_INFO(LOG) LOG.setLogLevel(log4cplus::INFO_LOG_LEVEL);
135  #define PION_LOG_SETLEVEL_WARN(LOG) LOG.setLogLevel(log4cplus::WARN_LOG_LEVEL);
136  #define PION_LOG_SETLEVEL_ERROR(LOG) LOG.setLogLevel(log4cplus::ERROR_LOG_LEVEL);
137  #define PION_LOG_SETLEVEL_FATAL(LOG) LOG.setLogLevel(log4cplus::FATAL_LOG_LEVEL);
138  #define PION_LOG_SETLEVEL_UP(LOG) LOG.setLogLevel(LOG.getLogLevel()+1);
139  #define PION_LOG_SETLEVEL_DOWN(LOG) LOG.setLogLevel(LOG.getLogLevel()-1);
140 
141  #define PION_LOG_DEBUG LOG4CPLUS_DEBUG
142  #define PION_LOG_INFO LOG4CPLUS_INFO
143  #define PION_LOG_WARN LOG4CPLUS_WARN
144  #define PION_LOG_ERROR LOG4CPLUS_ERROR
145  #define PION_LOG_FATAL LOG4CPLUS_FATAL
146 
147 
148 #elif defined(PION_USE_LOG4CPP)
149 
150 
151  // log4cpp headers
152  #include <log4cpp/Category.hh>
153  #include <log4cpp/BasicLayout.hh>
154  #include <log4cpp/OstreamAppender.hh>
155  #include <log4cpp/AppenderSkeleton.hh>
156  #include <log4cpp/PropertyConfigurator.hh>
157 
158  namespace pion {
159  typedef log4cpp::Category* PionLogger;
160  typedef log4cpp::AppenderSkeleton PionLogAppender;
161  typedef PionLogAppender * PionLogAppenderPtr;
162  }
163 
164  #define PION_HAS_LOG_APPENDER 1
165  #define PION_LOG_CONFIG_BASIC { log4cpp::OstreamAppender *app = new log4cpp::OstreamAppender("cout", &std::cout); app->setLayout(new log4cpp::BasicLayout()); log4cpp::Category::getRoot().setAppender(app); }
166  #define PION_LOG_CONFIG(FILE) { log4cpp::PropertyConfigurator::configure(FILE); }
167  #define PION_GET_LOGGER(NAME) (&log4cpp::Category::getInstance(NAME))
168 
169  #define PION_LOG_SETLEVEL_DEBUG(LOG) { LOG->setPriority(log4cpp::Priority::DEBUG); }
170  #define PION_LOG_SETLEVEL_INFO(LOG) { LOG->setPriority(log4cpp::Priority::INFO); }
171  #define PION_LOG_SETLEVEL_WARN(LOG) { LOG->setPriority(log4cpp::Priority::WARN); }
172  #define PION_LOG_SETLEVEL_ERROR(LOG) { LOG->setPriority(log4cpp::Priority::ERROR); }
173  #define PION_LOG_SETLEVEL_FATAL(LOG) { LOG->setPriority(log4cpp::Priority::FATAL); }
174  #define PION_LOG_SETLEVEL_UP(LOG) { LOG->setPriority(LOG.getPriority()+1); }
175  #define PION_LOG_SETLEVEL_DOWN(LOG) { LOG->setPriority(LOG.getPriority()-1); }
176 
177  #define PION_LOG_DEBUG(LOG, MSG) if (LOG->getPriority()>=log4cpp::Priority::DEBUG) { LOG->debugStream() << MSG; }
178  #define PION_LOG_INFO(LOG, MSG) if (LOG->getPriority()>=log4cpp::Priority::INFO) { LOG->infoStream() << MSG; }
179  #define PION_LOG_WARN(LOG, MSG) if (LOG->getPriority()>=log4cpp::Priority::WARN) { LOG->warnStream() << MSG; }
180  #define PION_LOG_ERROR(LOG, MSG) if (LOG->getPriority()>=log4cpp::Priority::ERROR) { LOG->errorStream() << MSG; }
181  #define PION_LOG_FATAL(LOG, MSG) if (LOG->getPriority()>=log4cpp::Priority::FATAL) { LOG->fatalStream() << MSG; }
182 
183 #elif defined(PION_DISABLE_LOGGING)
184 
185  // Logging is disabled -> add do-nothing stubs for logging
186  namespace pion {
187  typedef int PionLogger;
188  typedef int PionLogAppender;
189  typedef PionLogAppender * PionLogAppenderPtr;
190  }
191 
192  #undef PION_HAS_LOG_APPENDER
193  #define PION_LOG_CONFIG_BASIC {}
194  #define PION_LOG_CONFIG(FILE) {}
195  #define PION_GET_LOGGER(NAME) 0
196 
197  // use "++LOG" to avoid warnings about LOG not being used
198  #define PION_LOG_SETLEVEL_DEBUG(LOG) { if (false) ++LOG; }
199  #define PION_LOG_SETLEVEL_INFO(LOG) { if (false) ++LOG; }
200  #define PION_LOG_SETLEVEL_WARN(LOG) { if (false) ++LOG; }
201  #define PION_LOG_SETLEVEL_ERROR(LOG) { if (false) ++LOG; }
202  #define PION_LOG_SETLEVEL_FATAL(LOG) { if (false) ++LOG; }
203  #define PION_LOG_SETLEVEL_UP(LOG) { if (false) ++LOG; }
204  #define PION_LOG_SETLEVEL_DOWN(LOG) { if (false) ++LOG; }
205 
206  // use "++LOG" to avoid warnings about LOG not being used
207  #define PION_LOG_DEBUG(LOG, MSG) { if (false) ++LOG; }
208  #define PION_LOG_INFO(LOG, MSG) { if (false) ++LOG; }
209  #define PION_LOG_WARN(LOG, MSG) { if (false) ++LOG; }
210  #define PION_LOG_ERROR(LOG, MSG) { if (false) ++LOG; }
211  #define PION_LOG_FATAL(LOG, MSG) { if (false) ++LOG; }
212 
213 #else
214 
215  #define PION_USE_OSTREAM_LOGGING
216 
217  // Logging uses std::cout and std::cerr
218  #include <iostream>
219  #include <string>
220  #include <ctime>
221 
222  namespace pion {
223  struct PION_COMMON_API PionLogger {
224  enum PionPriorityType {
225  LOG_LEVEL_DEBUG, LOG_LEVEL_INFO, LOG_LEVEL_WARN,
226  LOG_LEVEL_ERROR, LOG_LEVEL_FATAL
227  };
228  ~PionLogger() {}
229  PionLogger(void) : m_name("pion") {}
230  PionLogger(const std::string& name) : m_name(name) {}
231  PionLogger(const PionLogger& p) : m_name(p.m_name) {}
232  std::string m_name;
233  static PionPriorityType m_priority;
234  };
235  typedef int PionLogAppender;
236  typedef PionLogAppender * PionLogAppenderPtr;
237  }
238 
239  #undef PION_HAS_LOG_APPENDER
240  #define PION_LOG_CONFIG_BASIC {}
241  #define PION_LOG_CONFIG(FILE) {}
242  #define PION_GET_LOGGER(NAME) pion::PionLogger(NAME)
243 
244  #define PION_LOG_SETLEVEL_DEBUG(LOG) { LOG.m_priority = pion::PionLogger::LOG_LEVEL_DEBUG; }
245  #define PION_LOG_SETLEVEL_INFO(LOG) { LOG.m_priority = pion::PionLogger::LOG_LEVEL_INFO; }
246  #define PION_LOG_SETLEVEL_WARN(LOG) { LOG.m_priority = pion::PionLogger::LOG_LEVEL_WARN; }
247  #define PION_LOG_SETLEVEL_ERROR(LOG) { LOG.m_priority = pion::PionLogger::LOG_LEVEL_ERROR; }
248  #define PION_LOG_SETLEVEL_FATAL(LOG) { LOG.m_priority = pion::PionLogger::LOG_LEVEL_FATAL; }
249  #define PION_LOG_SETLEVEL_UP(LOG) { ++LOG.m_priority; }
250  #define PION_LOG_SETLEVEL_DOWN(LOG) { --LOG.m_priority; }
251 
252  #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; }
253  #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; }
254  #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; }
255  #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; }
256  #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; }
257 
258 #endif
259 
260 #endif
pion
the following enables use of the lock-free cache
Definition: PionAdminRights.hpp:19
Generated by   doxygen 1.8.11