GNU CommonC++
applog.h
Go to the documentation of this file.
1// Copyright (C) 2005-2010 Angelo Naselli, Penta Engineering s.r.l.
2//
3// This program is free software; you can redistribute it and/or modify
4// it under the terms of the GNU General Public License as published by
5// the Free Software Foundation; either version 2 of the License, or
6// (at your option) any later version.
7//
8// but WITHOUT ANY WARRANTY; without even the implied warranty of
9// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10// GNU General Public License for more details.
11//
12// You should have received a copy of the GNU General Public License
13// along with this program; if not, write to the Free Software
14// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
15//
16// As a special exception, you may use this file as part of a free software
17// library without restriction. Specifically, if other files instantiate
18// templates or use macros or inline functions from this file, or you compile
19// this file and link it with other files to produce an executable, this
20// file does not by itself cause the resulting executable to be covered by
21// the GNU General Public License. This exception does not however
22// invalidate any other reasons why the executable file might be covered by
23// the GNU General Public License.
24//
25// This exception applies only to the code released under the name GNU
26// Common C++. If you copy code from other releases into a copy of GNU
27// Common C++, as the General Public License permits, the exception does
28// not apply to the code that you add in this way. To avoid misleading
29// anyone as to the status of such modified files, you must delete
30// this exception notice from them.
31//
32// If you write modifications of your own for GNU Common C++, it is your choice
33// whether to permit this exception to apply to your modifications.
34// If you do not wish that, delete this exception notice.
35//
36
43#ifndef ___APPLOG_H___
44#define ___APPLOG_H___
45
46#ifndef CCXX_SLOG_H_
47#include <cc++/slog.h>
48#endif
49
50#include <cc++/exception.h>
51
52#include <string>
53#include <sstream>
54#include <iostream>
55#include <map>
56
57#ifdef CCXX_NAMESPACES
58using namespace std;
59
60namespace ost
61{
62#endif
72{
73 protected:
77 std::string _str;
78
79 public:
80 // max_len: max number of bytes to be printed. 0 prints all.
89 HEXdump(const unsigned char *buffer, int buff_len, int max_len = 200);
90
94 virtual ~HEXdump() { _str = string();}
95
100 const char * c_str() const
101 {
102 return _str.c_str();
103 }
104
108 std::string str()
109 {
110 return _str;
111 }
112
118 friend std::ostream& operator<< (std::ostream& out, const HEXdump &hd)
119 {
120 out << hd.c_str();
121 return out;
122 }
123
124};
125
126#ifdef CCXX_EXCEPTIONS
131class __EXPORT AppLogException : public ost::Exception
132{
133 public:
138 AppLogException(const std::string &what_arg) : ost::Exception(what_arg) {};
139
140};
141#endif
142
143class AppLogPrivate;
144
173class __EXPORT AppLog : protected streambuf, public ostream
174{
175 protected:
176 // d pointer
177 AppLogPrivate *d;
178 void writeLog(bool endOfLine = true);
179 static map<string, Slog::Level> *assoc;
180
181 public:
186 {
187 private:
188 std::string _ident;
189 public:
190
194 Ident() {};
195
199 ~Ident() {};
200
204 Ident(Ident& id) {_ident = id._ident;}
205
209 Ident(const char *str) : _ident(str) {};
210
214 std::string& str() {return _ident;}
215
219 Ident& operator= (std::string &st) {_ident = st; return *this;}
220
224 Ident& operator= (const char str[]) {_ident = str; return *this;}
225
229 const char* c_str() {return _ident.c_str();}
230 };
231
232#ifndef WIN32
240 AppLog(const char* logFileName = NULL, bool logDirectly = false , bool usePipe = false);
241#else
248 AppLog(const char* logFileName = NULL, bool logDirectly = false);
249#endif
253 virtual ~AppLog();
254
259 void subscribe();
260
265
266#ifndef WIN32
274 void logFileName(const char* FileName, bool logDirectly = false, bool usePipe = false);
275#else
282 void logFileName(const char* FileName, bool logDirectly = false);
283#endif
287 void close(void);
288
293 void level(Slog::Level enable);
294
299 void clogEnable(bool en = true);
300
305 void slogEnable(bool en = true);
306
312 void identLevel(const char *ident, Slog::Level level);
313
318 void open(const char *ident);
319
325 virtual int overflow(int c);
326
330 virtual int sync();
331
332#ifdef HAVE_SNPRINTF
333
338 void emerg(const char *format, ...);
339
344 void alert(const char *format, ...);
345
350 void critical(const char *format, ...);
351
356 void error(const char *format, ...);
357
362 void warn(const char *format, ...);
363
368 void notice(const char *format, ...);
369
374 void info(const char *format, ...);
375
380 void debug(const char *format, ...);
381#endif
382
389 AppLog &operator()(const char *ident, Slog::Level level = Slog::levelError);
390
396 inline AppLog& operator()(Ident &ident)
397 {
398 open(ident.c_str());
399 return *this;
400 }
401
408
414 AppLog& operator<< (AppLog& (*pfManipulator)(AppLog&));
415
421 AppLog& operator<< (ostream& (*pfManipulator)(ostream&));
422
423 friend ostream& operator << (ostream &out, AppLog & al)
424 {
425 return al;
426 }
427
433 inline AppLog& operator<< (Ident &ident)
434 {
435 open(ident.c_str());
436 return *this;
437 }
438
439
444 inline AppLog &warn(void)
445 {return operator()(Slog::levelWarning);}
446
452 { return operator()(Slog::levelError);}
453
458 inline AppLog &debug(void)
459 {return operator()(Slog::levelDebug);}
460
465 inline AppLog &emerg(void)
466 {return operator()(Slog::levelEmergency);}
467
472 inline AppLog &alert(void)
473 {return operator()(Slog::levelAlert);}
474
479 inline AppLog &critical(void)
480 {return operator()(Slog::levelCritical);}
481
486 inline AppLog &notice(void)
487 {return operator()(Slog::levelNotice);}
488
493 inline AppLog &info(void)
494 {return operator()(Slog::levelInfo);}
495
511 static Slog::Level levelTranslate(string name)
512 {
513 map<string, Slog::Level>::iterator it = assoc->find(name);
514
515 return (it != assoc->end()) ? it->second : Slog::levelEmergency;
516 }
517
518};
519
526{return sl.operator()(Slog::levelDebug);}
527
534{return sl.operator()(Slog::levelWarning);}
535
542{ return sl.operator()(Slog::levelError);}
543
550{return sl.operator()(Slog::levelEmergency);}
551
558{return sl.operator()(Slog::levelAlert);}
559
566{return sl.operator()(Slog::levelCritical);}
567
574{return sl.operator()(Slog::levelNotice);}
575
582{return sl.operator()(Slog::levelInfo);}
583
587__EXPORT extern AppLog alog;
588
589#ifdef CCXX_NAMESPACES
590} //namespace
591#endif
592
593#endif //___APPLOG_H___
Ident class that represents module name.
Definition applog.h:186
Ident()
Constructor.
Definition applog.h:194
const char * c_str()
const char* cast provided for conveneince.
Definition applog.h:229
std::string & str()
std::string cast.
Definition applog.h:214
~Ident()
Desctructor.
Definition applog.h:199
Ident(Ident &id)
Copy constructor.
Definition applog.h:204
Ident(const char *str)
const char* constructor, provided for convenience.
Definition applog.h:209
Application logger is a class that implements a logger that can be used by applications to save log f...
Definition applog.h:174
AppLog & emerg(void)
emerg level
Definition applog.h:465
void info(const char *format,...)
info level printf style method, provided for convenience.
AppLog & critical(void)
critical level
Definition applog.h:479
void slogEnable(bool en=true)
Enables slog output for error level messages.
AppLog & notice(void)
notice level
Definition applog.h:486
void debug(const char *format,...)
debug level printf style method, provided for convenience.
void notice(const char *format,...)
notice level printf style method, provided for convenience.
AppLog & error(void)
error level
Definition applog.h:451
static Slog::Level levelTranslate(string name)
Translates level from string to Slog::Level, useful for configuration files for instance.
Definition applog.h:511
AppLog & operator()(const char *ident, Slog::Level level=Slog::levelError)
operator to change ident and log level
void subscribe()
Subscribes the current thread to logger, it reserves thread safe buffer for it.
void alert(const char *format,...)
alert level printf style method, provided for convenience.
void critical(const char *format,...)
critical level printf style method, provided for convenience.
AppLog & operator()(Ident &ident)
operator to change ident
Definition applog.h:396
AppLog & alert(void)
alert level
Definition applog.h:472
static map< string, Slog::Level > * assoc
Definition applog.h:179
virtual int sync()
stream sync() overload
AppLog(const char *logFileName=NULL, bool logDirectly=false, bool usePipe=false)
Constructor for a customized logger.
void writeLog(bool endOfLine=true)
virtual ~AppLog()
Destructor.
void identLevel(const char *ident, Slog::Level level)
Sets the level for that ident.
AppLog & operator()(Slog::Level level)
operator to change logging level
AppLog & info(void)
info level
Definition applog.h:493
virtual int overflow(int c)
stream overflow() overload.
void clogEnable(bool en=true)
Enables clog output.
void error(const char *format,...)
error level printf style method, provided for convenience.
void open(const char *ident)
Opens the file if not already and sets ident.
AppLog & debug(void)
debug level
Definition applog.h:458
void emerg(const char *format,...)
emerg level printf style method, provided for convenience.
AppLogPrivate * d
Definition applog.h:177
void level(Slog::Level enable)
Sets the log level.
void logFileName(const char *FileName, bool logDirectly=false, bool usePipe=false)
Allows to set up ost::alog parameters.
void unsubscribe()
Unsubscribes the current thread from logger.
void close(void)
if logDirectly is set it closes the file.
AppLog & warn(void)
warn level
Definition applog.h:444
void warn(const char *format,...)
warn level printf style method, provided for convenience.
Produces a dump of a buffer in a hexdump way with its code Ascii translation and relative buffer addr...
Definition applog.h:72
std::string str()
string cast provided for conveneince.
Definition applog.h:108
std::string _str
output string
Definition applog.h:77
virtual ~HEXdump()
HEXdump destructor.
Definition applog.h:94
const char * c_str() const
const char* cast provided for conveneince.
Definition applog.h:100
HEXdump(const unsigned char *buffer, int buff_len, int max_len=200)
HEXdump constructor.
Level
Definition slog.h:123
@ levelEmergency
Definition slog.h:124
@ levelAlert
Definition slog.h:125
@ levelInfo
Definition slog.h:130
@ levelWarning
Definition slog.h:128
@ levelDebug
Definition slog.h:131
@ levelCritical
Definition slog.h:126
@ levelNotice
Definition slog.h:129
@ levelError
Definition slog.h:127
#define __EXPORT
Definition config.h:1045
GNU Common C++ exception model base classes.
Definition address.h:64
__EXPORT AppLog & debug(AppLog &sl)
Manipulator for debug level.
Definition applog.h:525
__EXPORT AppLog & alert(AppLog &sl)
Manipulator for alert level.
Definition applog.h:557
__EXPORT AppLog & notice(AppLog &sl)
Manipulator for notice level.
Definition applog.h:573
__EXPORT AppLog & info(AppLog &sl)
Manipulator for info level.
Definition applog.h:581
__EXPORT AppLog & warn(AppLog &sl)
Manipulator for warn level.
Definition applog.h:533
__EXPORT AppLog & emerg(AppLog &sl)
Manipulator for emerg level.
Definition applog.h:549
__EXPORT AppLog alog
alog global log stream definition
__EXPORT AppLog & critical(AppLog &sl)
Manipulator for critical level.
Definition applog.h:565
__EXPORT AppLog & error(AppLog &sl)
Manipulator for error level.
Definition applog.h:541
System logging facilities abstraction.