GNU Radio 3.6.5.1 C++ API
gr_logger.h
Go to the documentation of this file.
1 /* -*- c++ -*- */
2 /*
3  * Copyright 2012-2013 Free Software Foundation, Inc.
4  *
5  * This file is part of GNU Radio
6  *
7  * GNU Radio is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3, or (at your option)
10  * any later version.
11  *
12  * GNU Radio is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with GNU Radio; see the file COPYING. If not, write to
19  * the Free Software Foundation, Inc., 51 Franklin Street,
20  * Boston, MA 02110-1301, USA.
21  */
22 
23 /*******************************************************************************
24 * Author: Mark Plett
25 * Description:
26 * The gr_logger module wraps the log4cpp library for logging in gnuradio
27 *******************************************************************************/
28 
29 #ifndef INCLUDED_GR_LOGGER_H
30 #define INCLUDED_GR_LOGGER_H
31 
32 /*!
33 * \file gr_logger.h
34 * \ingroup logging
35 * \brief GNURADIO logging wrapper for log4cpp library (C++ port of log4j)
36 *
37 */
38 
39 #include <gr_core_api.h>
40 #include <assert.h>
41 #include <iostream>
42 #include <boost/format.hpp>
43 
44 #ifdef ENABLE_GR_LOG
45 
46 // We have three configurations... first logging to stdout/stderr
47 #ifndef HAVE_LOG4CPP
48 //#warning GR logging Enabled and using std::cout
49 
50 typedef std::string gr_logger_ptr;
51 
52 #define GR_LOG_DECLARE_LOGPTR(logger)
53 #define GR_LOG_ASSIGN_LOGPTR(logger,name)
54 #define GR_CONFIG_LOGGER(config)
55 #define GR_CONFIG_AND_WATCH_LOGGER(config,period)
56 #define GR_LOG_GETLOGGER(logger, name)
57 #define GR_SET_LEVEL(name, level)
58 #define GR_LOG_SET_LEVEL(logger, level)
59 #define GR_GET_LEVEL(name, level)
60 #define GR_LOG_GET_LEVEL(logger, level)
61 #define GR_ADD_CONSOLE_APPENDER(logger,target,pattern)
62 #define GR_LOG_ADD_CONSOLE_APPENDER(logger,target,pattern)
63 #define GR_ADD_FILE_APPENDER(name,filename,append,pattern)
64 #define GR_LOG_ADD_FILE_APPENDER(logger,filename,append,pattern)
65 #define GR_ADD_ROLLINGFILE_APPENDER(name,filename,filesize,bkup_index,append,mode,pattern)
66 #define GR_LOG_ADD_ROLLINGFILE_APPENDER(logger,filename,filesize,bkup_index,append,mode,pattern)
67 #define GR_GET_LOGGER_NAMES(names)
68 #define GR_RESET_CONFIGURATION()
69 #define GR_DEBUG(name, msg) std::cout<<"DEBUG: "<<msg<<std::endl
70 #define GR_INFO(name, msg) std::cout<<"INFO: "<<msg<<std::endl
71 #define GR_NOTICE(name, msg) std::cout<<"NOTICE: "<<msg<<std::endl
72 #define GR_WARN(name, msg) std::cerr<<"WARN: "<<msg<<std::endl
73 #define GR_ERROR(name, msg) std::cerr<<"ERROR: "<<msg<<std::endl
74 #define GR_ALERT(name, msg) std::cerr<<"ERROR: "<<msg<<std::endl
75 #define GR_CRIT(name, msg) std::cerr<<"ERROR: "<<msg<<std::endl
76 #define GR_FATAL(name, msg) std::cerr<<"FATAL: "<<msg<<std::endl
77 #define GR_EMERG(name, msg) std::cerr<<"EMERG: "<<msg<<std::endl
78 #define GR_ERRORIF(name, cond, msg) if((cond)) std::cerr<<"ERROR: "<<msg<<std::endl
79 #define GR_ASSERT(name, cond, msg) if(!(cond)) std::cerr<<"ERROR: "<<msg<<std::endl; assert(cond)
80 #define GR_LOG_DEBUG(logger, msg) std::cout<<"DEBUG: "<<msg<<std::endl
81 #define GR_LOG_INFO(logger, msg) std::cout<<"INFO: "<<msg<<std::endl
82 #define GR_LOG_NOTICE(logger, msg) std::cout<<"NOTICE: "<<msg<<std::endl
83 #define GR_LOG_WARN(logger, msg) std::cerr<<"WARN: "<<msg<<std::endl
84 #define GR_LOG_ERROR(logger, msg) std::cerr<<"ERROR: "<<msg<<std::endl
85 #define GR_LOG_ALERT(logger, msg) std::cerr<<"ALERT: "<<msg<<std::endl
86 #define GR_LOG_CRIT(logger, msg) std::cerr<<"CRIT: "<<msg<<std::endl
87 #define GR_LOG_FATAL(logger, msg) std::cerr<<"FATAL: "<<msg<<std::endl
88 #define GR_LOG_EMERG(logger, msg) std::cerr<<"EMERG: "<<msg<<std::endl
89 #define GR_LOG_ERRORIF(logger, cond, msg) if((cond)) std::cerr<<"ERROR: "<<msg<<std::endl
90 #define GR_LOG_ASSERT(logger, cond, msg) std::cerr<<"ERROR: "<<msg<<std::endl; assert(cond)
91 
92 #else /* HAVE_LOG4CPP */
93 // Second configuration...logging to log4cpp
94 
95 #include <log4cpp/Category.hh>
96 #include <log4cpp/PropertyConfigurator.hh>
97 #include <log4cpp/FileAppender.hh>
98 #include <log4cpp/RollingFileAppender.hh>
99 #include <log4cpp/OstreamAppender.hh>
100 #include <log4cpp/PatternLayout.hh>
101 
102 /*!
103  * \brief GR_LOG macros
104  * \ingroup logging
105  *
106  * These macros wrap the standard LOG4CPP_LEVEL macros. The availablie macros
107  * are:
108  * GR_LOG_DEBUG
109  * GR_LOG_INFO
110  * GR_LOG_WARN
111  * GR_LOG_TRACE
112  * GR_LOG_ERROR
113  * GR_LOG_ALERT
114  * GR_LOG_CRIT
115  * GR_LOG_FATAL
116  * GR_LOG_EMERG
117  */
118 typedef log4cpp::Category* gr_logger_ptr;
119 
120 /* Macros for Programmatic Configuration */
121 #define GR_LOG_DECLARE_LOGPTR(logger) \
122  gr_logger_ptr logger;
123 
124 #define GR_LOG_ASSIGN_LOGPTR(logger,name) \
125  logger = gr_logger::getLogger(name);
126 
127 #define GR_CONFIG_LOGGER(config) \
128  logger_load_config(config)
129 
130 #define GR_CONFIG_AND_WATCH_LOGGER(config,period) \
131  logger_load_config_and_watch(config,period)
132 
133 #define GR_LOG_GETLOGGER(logger, name) \
134  gr_logger_ptr logger = gr_logger::getLogger(name);
135 
136 #define GR_SET_LEVEL(name, level){ \
137  gr_logger_ptr logger = gr_logger::getLogger(name);\
138  logger_set_level(logger,level);}
139 
140 #define GR_LOG_SET_LEVEL(logger, level) \
141  logger_set_level(logger, level);
142 
143 #define GR_GET_LEVEL(name, level){ \
144  gr_logger_ptr logger = gr_logger::getLogger(name);\
145  logger_get_level(logger,level);}
146 
147 #define GR_LOG_GET_LEVEL(logger, level) \
148  logger_get_level(logger,level);
149 
150 #define GR_ADD_CONSOLE_APPENDER(name,target,pattern){\
151  gr_logger_ptr logger = gr_logger::getLogger(name);\
152  logger_add_console_appender(logger,target,pattern);}
153 
154 #define GR_LOG_ADD_CONSOLE_APPENDER(logger,target,pattern){\
155  logger_add_console_appender(logger,target,pattern);}
156 
157 #define GR_ADD_FILE_APPENDER(name,filename,append,pattern){\
158  gr_logger_ptr logger = gr_logger::getLogger(name);\
159  logger_add_file_appender(logger,filename,append,pattern);}
160 
161 #define GR_LOG_ADD_FILE_APPENDER(logger,filename,append,pattern){\
162  logger_add_file_appender(logger,filename,append,pattern);}
163 
164 #define GR_ADD_ROLLINGFILE_APPENDER(name,filename,filesize,bkup_index,append,mode,pattern){\
165  gr_logger_ptr logger = gr_logger::getLogger(name);\
166  logger_add_rollingfile_appender(logger,filename,filesize,bkup_index,append,mode,pattern);}
167 
168 #define GR_LOG_ADD_ROLLINGFILE_APPENDER(logger,filename,filesize,bkup_index,append,mode,pattern){\
169  logger_add_rollingfile_appender(logger,filename,filesize,bkup_index,append,mode,pattern);}
170 
171 #define GR_GET_LOGGER_NAMES(names){ \
172  logger_get_logger_names(names);}
173 
174 #define GR_RESET_CONFIGURATION(){ \
175  logger_reset_config();}
176 
177 /* Logger name referenced macros */
178 #define GR_DEBUG(name, msg) { \
179  gr_logger_ptr logger = gr_logger::getLogger(name);\
180  *logger<< log4cpp::Priority::DEBUG << msg << log4cpp::eol;}
181 
182 #define GR_INFO(name, msg) { \
183  gr_logger_ptr logger = gr_logger::getLogger(name);\
184  *logger<< log4cpp::Priority::INFO << msg << log4cpp::eol;}
185 
186 #define GR_NOTICE(name, msg) { \
187  gr_logger_ptr logger = gr_logger::getLogger(name);\
188  *logger << log4cpp::Priority::NOTICE << msg;}
189 
190 #define GR_WARN(name, msg) { \
191  gr_logger_ptr logger = gr_logger::getLogger(name);\
192  *logger<< log4cpp::Priority::WARN << msg << log4cpp::eol;}
193 
194 #define GR_ERROR(name, msg) { \
195  gr_logger_ptr logger = gr_logger::getLogger(name);\
196  *logger<< log4cpp::Priority::ERROR << msg << log4cpp::eol;}
197 
198 #define GR_CRIT(name, msg) { \
199  gr_logger_ptr logger = gr_logger::getLogger(name);\
200  *logger<< log4cpp::Priority::CRIT << msg << log4cpp::eol;}
201 
202 #define GR_ALERT(name, msg) { \
203  gr_logger_ptr logger = gr_logger::getLogger(name);\
204  *logger<< log4cpp::Priority::ALERT << msg << log4cpp::eol;}
205 
206 #define GR_FATAL(name, msg) { \
207  gr_logger_ptr logger = gr_logger::getLogger(name);\
208  *logger<< log4cpp::Priority::FATAL << msg << log4cpp::eol;}
209 
210 #define GR_EMERG(name, msg) { \
211  gr_logger_ptr logger = gr_logger::getLogger(name);\
212  *logger<< log4cpp::Priority::EMERG << msg << log4cpp::eol;}
213 
214 #define GR_ERRORIF(name, cond, msg) { \
215 if((cond)){\
216  gr_logger_ptr logger = gr_logger::getLogger(name);\
217  *logger<< log4cpp::Priority::ERROR << msg << log4cpp::eol;};\
218 };
219 
220 #define GR_ASSERT(name, cond, msg) { \
221 if((!cond)){\
222  gr_logger_ptr logger = gr_logger::getLogger(name);\
223  *logger<< log4cpp::Priority::EMERG << msg << log4cpp::eol;};\
224  assert(0);\
225 };
226 
227 /* LoggerPtr Referenced Macros */
228 #define GR_LOG_DEBUG(logger, msg) { \
229  *logger << log4cpp::Priority::DEBUG << msg << log4cpp::eol;}
230 
231 #define GR_LOG_INFO(logger, msg) { \
232  *logger << log4cpp::Priority::INFO << msg << log4cpp::eol;}
233 
234 #define GR_LOG_NOTICE(logger, msg) { \
235  *logger << log4cpp::Priority::NOTICE << msg << log4cpp::eol;}
236 
237 #define GR_LOG_WARN(logger, msg) { \
238  *logger << log4cpp::Priority::WARN << msg << log4cpp::eol;}
239 
240 #define GR_LOG_ERROR(logger, msg) { \
241  *logger << log4cpp::Priority::ERROR << msg << log4cpp::eol;}
242 
243 #define GR_LOG_CRIT(logger, msg) { \
244  *logger << log4cpp::Priority::CRIT << msg << log4cpp::eol;}
245 
246 #define GR_LOG_ALERT(logger, msg) { \
247  *logger << log4cpp::Priority::ALERT << msg << log4cpp::eol;}
248 
249 #define GR_LOG_FATAL(logger, msg) { \
250  *logger << log4cpp::Priority::FATAL << msg << log4cpp::eol;}
251 
252 #define GR_LOG_EMERG(logger, msg) { \
253  *logger << log4cpp::Priority::EMERG << msg << log4cpp::eol;}
254 
255 #define GR_LOG_ERRORIF(logger,cond, msg) { \
256 if((!cond)){\
257  *logger<< log4cpp::Priority::ERROR << msg << log4cpp::eol;};\
258  assert(0);\
259 };
260 
261 #define GR_LOG_ASSERT(logger, cond, msg) { \
262 if((!cond)){\
263  *logger<< log4cpp::Priority::EMERG << msg << log4cpp::eol;};\
264  assert(0);\
265 };
266 
267 /*!
268  * \brief Load logger's configuration file.
269  *
270  * Initialize the GNU Radio logger by loading the configuration file
271  * \p config_filename.
272  *
273  * \param config_filename The configuration file. Set to "" for the
274  * basic logger that outputs to the console.
275  */
276 GR_CORE_API void logger_load_config(const std::string &config_filename="");
277 
278 
279 GR_CORE_API void logger_load_config_and_watch(const std::string &config_filename,
280  unsigned int watch_period);
281 
282 GR_CORE_API void logger_reset_config(void);
283 
284 /*!
285  * \brief Set the logger's output level.
286  *
287  * Sets the level of the logger. This takes a string that is
288  * translated to the standard levels and can be (case insensitive):
289  *
290  * \li off , notset
291  * \li debug
292  * \li info
293  * \li notice
294  * \li warn
295  * \li error
296  * \li crit
297  * \li alert
298  * \li fatal
299  * \li emerg
300  *
301  * \param logger the logger to set the level of.
302  * \param level string to set the level to.
303  */
304 GR_CORE_API void logger_set_level(gr_logger_ptr logger, const std::string &level);
305 
306 /*!
307  * \brief Set the logger's output level.
308  *
309  * Sets the level of the logger. This takes the actual Log4cpp::Priority
310  * data type, which can be:
311  *
312  * \li log4cpp::Priority::NOTSET
313  * \li log4cpp::Priority::DEBUG
314  * \li log4cpp::Priority::INFO
315  * \li log4cpp::Priority::NOTICE
316  * \li log4cpp::Priority::WARN
317  * \li log4cpp::Priority::ERROR
318  * \li log4cpp::Priority::CRIT
319  * \li log4cpp::Priority::ALERT
320  * \li log4cpp::Priority::FATAL
321  * \li log4cpp::Priority::EMERG
322  *
323  * \param logger the logger to set the level of.
324  * \param level new logger level of type Log4cpp::Priority
325  */
326 void logger_set_level(gr_logger_ptr logger, log4cpp::Priority::Value level);
327 
328 
329 /*!
330  * \brief Get the logger's output level.
331  *
332  * Gets the level of the logger. This returns a string that
333  * corresponds to the standard levels and can be (case insensitive):
334  *
335  * \li notset
336  * \li debug
337  * \li info
338  * \li notice
339  * \li warn
340  * \li error
341  * \li crit
342  * \li alert
343  * \li fatal
344  * \li emerg
345  *
346  * \param logger the logger to get the level of.
347  * \param level string to get the level into.
348  */
349 GR_CORE_API void logger_get_level(gr_logger_ptr logger, std::string &level);
350 
351 /*!
352  * \brief Get the logger's output level.
353  *
354  * Gets the level of the logger. This returns the actual Log4cpp::Level
355  * data type, which can be:
356  *
357  * \li log4cpp::Priority::NOTSET
358  * \li log4cpp::Priority::DEBUG
359  * \li log4cpp::Priority::INFO
360  * \li log4cpp::Priority::NOTICE
361  * \li log4cpp::Priority::WARN
362  * \li log4cpp::Priority::ERROR
363  * \li log4cpp::Priority::CRIT
364  * \li log4cpp::Priority::ALERT
365  * \li log4cpp::Priority::FATAL
366  * \li log4cpp::Priority::EMERG
367  *
368  * \param logger the logger to get the level of.
369  * \param level of the logger.
370  */
371 GR_CORE_API void logger_get_level(gr_logger_ptr logger, log4cpp::Priority::Value &level);
372 
373 GR_CORE_API void logger_add_console_appender(gr_logger_ptr logger,std::string target,std::string pattern);
374 
375 GR_CORE_API void logger_add_file_appender(gr_logger_ptr logger,std::string filename,bool append,std::string pattern);
376 
377 GR_CORE_API void logger_add_rollingfile_appender(gr_logger_ptr logger,std::string filename,
378  size_t filesize,int bkup_index,bool append,mode_t mode,std::string pattern);
379 
380 GR_CORE_API void logger_get_logger_names(std::vector<std::string>& names);
381 
382 /*!
383  * \brief instantiate (configure) logger.
384  * \ingroup logging
385  *
386  */
387 class gr_logger
388 {
389  public:
390  /*!
391  * \brief contructor take log configuration file and configures loggers.
392  */
393  gr_logger(std::string config_filename)
394  {
395  // Load configuration file
396  logger_load_config(config_filename);
397  };
398 
399  /*!
400  * \brief contructor take log configuration file and watchtime and configures
401  */
402  gr_logger(std::string config_filename, int watchPeriodSec)
403  {
404  // Load configuration file
405  logger_load_config_and_watch(config_filename,watchPeriodSec);
406 
407  };
408 
409  static gr_logger_ptr getLogger(std::string name)
410  {
411  if(log4cpp::Category::exists(name)){
412  gr_logger_ptr logger = &log4cpp::Category::getInstance(name);
413  return logger;
414  }
415  else
416  {
417  gr_logger_ptr logger = &log4cpp::Category::getInstance(name);
418  logger->setPriority(log4cpp::Priority::NOTSET);
419  return logger;
420  };
421  };
422 
423  // Wrappers for logging macros
424  /*! \brief inline function, wrapper to set the logger level */
425  void set_level(std::string name,std::string level){GR_SET_LEVEL(name,level);}
426 
427  /*! \brief inline function, wrapper to get the logger level */
428  void get_level(std::string name,std::string &level){GR_GET_LEVEL(name,level);}
429 
430  /*! \brief inline function, wrapper for DEBUG message */
431  void debug(std::string name,std::string msg){GR_DEBUG(name,msg);};
432 
433  /*! \brief inline function, wrapper for INFO message */
434  void info(std::string name,std::string msg){GR_INFO(name,msg);};
435 
436  /*! \brief inline function, wrapper for NOTICE message */
437  void notice(std::string name,std::string msg){GR_NOTICE(name,msg);};
438 
439  /*! \brief inline function, wrapper for WARN message */
440  void warn(std::string name,std::string msg){GR_WARN(name,msg);};
441 
442  /*! \brief inline function, wrapper for ERROR message */
443  void error(std::string name,std::string msg){GR_ERROR(name,msg);};
444 
445  /*! \brief inline function, wrapper for CRIT message */
446  void crit(std::string name,std::string msg){GR_CRIT(name,msg);};
447 
448  /*! \brief inline function, wrapper for ALERT message */
449  void alert(std::string name,std::string msg){GR_ALERT(name,msg);};
450 
451  /*! \brief inline function, wrapper for FATAL message */
452  void fatal(std::string name,std::string msg){GR_FATAL(name,msg);};
453 
454  /*! \brief inline function, wrapper for EMERG message */
455  void emerg(std::string name,std::string msg){GR_EMERG(name,msg);};
456 
457  /*! \brief inline function, wrapper for LOG4CPP_ASSERT for conditional ERROR message */
458  void errorIF(std::string name,bool cond,std::string msg){GR_ERRORIF(name,cond,msg);};
459 
460  /*! \brief inline function, wrapper for LOG4CPP_ASSERT for conditional ERROR message */
461  void gr_assert(std::string name,bool cond,std::string msg){GR_ASSERT(name,cond,msg);};
462 
463  // Wrappers for Logger Pointer referenced functions
464  /*! \brief inline function, wrapper to set the logger level */
465  void set_log_level(gr_logger_ptr logger,std::string level){GR_LOG_SET_LEVEL(logger,level);}
466 
467  /*! \brief inline function, wrapper to get the logger level */
468  void get_log_level(gr_logger_ptr logger,std::string &level){GR_LOG_GET_LEVEL(logger,level);}
469 
470  /*! \brief inline function, wrapper for LOG4CPP_DEBUG for DEBUG message */
471  void log_debug(gr_logger_ptr logger,std::string msg){GR_LOG_DEBUG(logger,msg);};
472 
473  /*! \brief inline function, wrapper for LOG4CPP_INFO for INFO message */
474  void log_info(gr_logger_ptr logger,std::string msg){GR_LOG_INFO(logger,msg);};
475 
476  /*! \brief inline function, wrapper for NOTICE message */
477  void log_notice(gr_logger_ptr logger,std::string msg){GR_LOG_NOTICE(logger,msg);};
478 
479  /*! \brief inline function, wrapper for LOG4CPP_WARN for WARN message */
480  void log_warn(gr_logger_ptr logger,std::string msg){GR_LOG_WARN(logger,msg);};
481 
482  /*! \brief inline function, wrapper for LOG4CPP_ERROR for ERROR message */
483  void log_error(gr_logger_ptr logger,std::string msg){GR_LOG_ERROR(logger,msg);};
484 
485  /*! \brief inline function, wrapper for NOTICE message */
486  void log_crit(gr_logger_ptr logger,std::string msg){GR_LOG_CRIT(logger,msg);};
487 
488  /*! \brief inline function, wrapper for ALERT message */
489  void log_alert(gr_logger_ptr logger,std::string msg){GR_LOG_ALERT(logger,msg);};
490 
491  /*! \brief inline function, wrapper for FATAL message */
492  void log_fatal(gr_logger_ptr logger,std::string msg){GR_LOG_FATAL(logger,msg);};
493 
494  /*! \brief inline function, wrapper for EMERG message */
495  void log_emerg(gr_logger_ptr logger,std::string msg){GR_LOG_EMERG(logger,msg);};
496 
497  /*! \brief inline function, wrapper for LOG4CPP_ASSERT for conditional ERROR message */
498  void log_errorIF(gr_logger_ptr logger,bool cond,std::string msg){GR_LOG_ERRORIF(logger,cond,msg);};
499 
500  /*! \brief inline function, wrapper for LOG4CPP_ASSERT for conditional ERROR message */
501  void log_assert(gr_logger_ptr logger,bool cond,std::string msg){GR_LOG_ASSERT(logger,cond,msg);};
502 };
503 
504 
505 #endif /* HAVE_LOG4CPP */
506 
507 // If Logger disable do nothing
508 #else /* ENABLE_GR_LOG */
509 
510 typedef void* gr_logger_ptr;
511 
512 #define GR_LOG_DECLARE_LOGPTR(logger)
513 #define GR_LOG_ASSIGN_LOGPTR(logger,name)
514 #define GR_CONFIG_LOGGER(config)
515 #define GR_CONFIG_AND_WATCH_LOGGER(config,period)
516 #define GR_LOG_GETLOGGER(logger, name)
517 #define GR_SET_LEVEL(name, level)
518 #define GR_LOG_SET_LEVEL(logger, level)
519 #define GR_GET_LEVEL(name, level)
520 #define GR_LOG_GET_LEVEL(logger, level)
521 #define GR_ADD_CONSOLE_APPENDER(logger,target,pattern)
522 #define GR_LOG_ADD_CONSOLE_APPENDER(logger,target,pattern)
523 #define GR_ADD_FILE_APPENDER(name,filename,append,pattern)
524 #define GR_LOG_ADD_FILE_APPENDER(logger,filename,append,pattern)
525 #define GR_ADD_ROLLINGFILE_APPENDER(name,filename,filesize,bkup_index,append,mode,pattern)
526 #define GR_LOG_ADD_ROLLINGFILE_APPENDER(logger,filename,filesize,bkup_index,append,mode,pattern)
527 #define GR_GET_LOGGER_NAMES(names)
528 #define GR_RESET_CONFIGURATION()
529 #define GR_DEBUG(name, msg)
530 #define GR_INFO(name, msg)
531 #define GR_NOTICE(name, msg)
532 #define GR_WARN(name, msg)
533 #define GR_ERROR(name, msg)
534 #define GR_ALERT(name, msg)
535 #define GR_CRIT(name, msg)
536 #define GR_FATAL(name, msg)
537 #define GR_EMERG(name, msg)
538 #define GR_ERRORIF(name, cond, msg)
539 #define GR_ASSERT(name, cond, msg)
540 #define GR_LOG_DEBUG(logger, msg)
541 #define GR_LOG_INFO(logger, msg)
542 #define GR_LOG_NOTICE(logger, msg)
543 #define GR_LOG_WARN(logger, msg)
544 #define GR_LOG_ERROR(logger, msg)
545 #define GR_LOG_ALERT(logger, msg)
546 #define GR_LOG_CRIT(logger, msg)
547 #define GR_LOG_FATAL(logger, msg)
548 #define GR_LOG_EMERG(logger, msg)
549 #define GR_LOG_ERRORIF(logger, cond, msg)
550 #define GR_LOG_ASSERT(logger, cond, msg)
551 
552 #endif /* ENABLE_GR_LOG */
553 #endif /* INCLUDED_GR_LOGGER_H */