Line data Source code
1 : #ifndef ALILOG_H
2 : #define ALILOG_H
3 : /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 : * See cxx source for full Copyright notice */
5 :
6 : /* $Id$ */
7 :
8 : #include <TClass.h>
9 : #include <TObjArray.h>
10 : #include <TObject.h>
11 : #include <TString.h>
12 :
13 : using std::ostream;
14 :
15 : // deprecation macro
16 : #if defined(__GNUC__) && (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1))
17 : # define ALIROOT_DEPRECATED(func) func __attribute__ ((deprecated))
18 : #elif defined(_MSC_VER) && _MSC_VER >= 1300
19 : # define ALIROOT_DEPRECATED(func) __declspec(deprecated) func
20 : #else
21 : # define ALIROOT_DEPRECATED(func) func
22 : #endif
23 :
24 : /**
25 : * class for logging debug, info and error messages
26 : */
27 : class AliLog: public TObject
28 : {
29 : public:
30 :
31 : // Log4j log levels: TRACE, DEBUG, INFO, WARN, ERROR, FATAL
32 : enum EType_t {kFatal = 0, kError, kWarning, kInfo, kDebug, kMaxType};
33 : typedef void (*AliLogNotification)(EType_t type, const char* message );
34 :
35 : // NB: singleton constructor & destructor should not be public!
36 : // ALIROOT_DEPRECATED(AliLog());
37 : // ALIROOT_DEPRECATED(virtual ~AliLog());
38 :
39 : // NB: singleton deprecated static instance method
40 : // ALIROOT_DEPRECATED(static AliLog* Instance() {return fgInstance;};)
41 :
42 : // get root logger singleton instance
43 : static AliLog *GetRootLogger();
44 :
45 : // delete root logger singleton instance
46 : static void DeleteRootLogger();
47 :
48 : // NB: the following functions should not be static
49 : // NB: deprecated: logging configuration should be made through to a configuration file
50 : static void EnableCoreDump(Bool_t enabled);
51 : static void MakeCoreDump(const char *fout);
52 : static void EnableDebug(Bool_t enabled);
53 : static void SetGlobalLogLevel(EType_t type);
54 : static Int_t GetGlobalLogLevel();
55 : static void SetGlobalDebugLevel(Int_t level);
56 : static Int_t GetGlobalDebugLevel();
57 : static void SetModuleDebugLevel(const char* module, Int_t level);
58 : static void ClearModuleDebugLevel(const char* module);
59 : static void SetClassDebugLevel(const char* className, Int_t level);
60 : static void ClearClassDebugLevel(const char* className);
61 :
62 : static void SetStandardOutput();
63 : static void SetStandardOutput(EType_t type);
64 : static void SetErrorOutput();
65 : static void SetErrorOutput(EType_t type);
66 : static void SetFileOutput(const char* fileName);
67 : static void SetFileOutput(EType_t type, const char* fileName);
68 : static void SetStreamOutput(ostream* stream);
69 : static void SetStreamOutput(EType_t type, ostream* stream);
70 : static void SetLogNotification(AliLogNotification pCallBack);
71 : static void SetLogNotification(EType_t type, AliLogNotification pCallBack);
72 : static void Flush();
73 :
74 : static void SetHandleRootMessages(Bool_t on);
75 :
76 : static void SetPrintType(Bool_t on);
77 : static void SetPrintType(EType_t type, Bool_t on);
78 : static void SetPrintModule(Bool_t on);
79 : static void SetPrintModule(EType_t type, Bool_t on);
80 : static void SetPrintScope(Bool_t on);
81 : static void SetPrintScope(EType_t type, Bool_t on);
82 : static void SetPrintLocation(Bool_t on);
83 : static void SetPrintLocation(EType_t type, Bool_t on);
84 :
85 : static void SetPrintRepetitions(Bool_t on);
86 :
87 : static void WriteToFile(const char* name, Int_t option = 0);
88 :
89 : // the following public methods are used by the preprocessor macros
90 : // and should not be called directly
91 81525458 : static Bool_t IsDebugEnabled() {return fgDebugEnabled;}
92 : static Int_t GetDebugLevel(const char* module, const char* className);
93 : static void Message(UInt_t level, const char* message,
94 : const char* module, const char* className,
95 : const char* function, const char* file, Int_t line);
96 : static void Debug(UInt_t level, const char* message,
97 : const char* module, const char* className,
98 : const char* function, const char* file, Int_t line);
99 :
100 : static Int_t RedirectStdoutTo(EType_t type, UInt_t level, const char* module,
101 : const char* className, const char* function,
102 : const char* file, Int_t line, Bool_t print);
103 : static Int_t RedirectStderrTo(EType_t type, UInt_t level, const char* module,
104 : const char* className, const char* function,
105 : const char* file, Int_t line, Bool_t print);
106 : static void RestoreStdout(Int_t original);
107 : static void RestoreStderr(Int_t original);
108 :
109 : static ostream& Stream(EType_t type, UInt_t level,
110 : const char* module, const char* className,
111 : const char* function, const char* file, Int_t line);
112 : static void TestException(Int_t level=10);
113 : private:
114 :
115 : // constructor is made private for implementing a singleton
116 : AliLog();
117 : virtual ~AliLog();
118 :
119 : // NOT IMPLEMENTED?
120 : AliLog(const AliLog& log);
121 : AliLog& operator = (const AliLog& log);
122 :
123 : void ReadEnvSettings();
124 :
125 : static void RootErrorHandler(Int_t level, Bool_t abort,
126 : const char* location, const char* message);
127 :
128 : void CloseFile(Int_t type);
129 : FILE* GetOutputStream(Int_t type);
130 :
131 : UInt_t GetLogLevel(const char* module, const char* className) const;
132 : void PrintMessage(UInt_t type, const char* message,
133 : const char* module, const char* className,
134 : const char* function,
135 : const char* file, Int_t line);
136 :
137 : void PrintString(Int_t type, FILE* stream, const char* format, ...);
138 : void PrintRepetitions();
139 :
140 : Int_t RedirectTo(FILE* stream, EType_t type, UInt_t level,
141 : const char* module, const char* className,
142 : const char* function,
143 : const char* file, Int_t line, Bool_t print);
144 :
145 : ostream& GetStream(EType_t type, UInt_t level,
146 : const char* module, const char* className,
147 : const char* function, const char* file, Int_t line);
148 :
149 : enum {kDebugOffset = kDebug-1};
150 :
151 : static AliLog* fgInstance; //! pointer to current instance
152 : static Bool_t fgDebugEnabled; // flag for debug en-/disabling
153 : static Bool_t fgCoreEnabled; // flag for core dump en-/disabling
154 :
155 : UInt_t fGlobalLogLevel; // global logging level
156 : TObjArray fModuleDebugLevels; // debug levels for modules
157 : TObjArray fClassDebugLevels; // debug levels for classes
158 :
159 : Int_t fOutputTypes[kMaxType]; // types of output streams
160 : TString fFileNames[kMaxType]; // file names
161 : FILE* fOutputFiles[kMaxType]; //! log output files
162 : ostream* fOutputStreams[kMaxType]; //! log output streams
163 :
164 : Bool_t fPrintType[kMaxType]; // print type on/off
165 : Bool_t fPrintModule[kMaxType]; // print module on/off
166 : Bool_t fPrintScope[kMaxType]; // print scope/class name on/off
167 : Bool_t fPrintLocation[kMaxType]; // print file and line on/off
168 :
169 : Bool_t fPrintRepetitions; // print number of repetitions instead of repeated message on/off
170 :
171 : Int_t fRepetitions; //! counter of repetitions
172 : UInt_t fLastType; //! type of last message
173 : TString fLastMessage; //! last message
174 : TString fLastModule; //! module name of last message
175 : TString fLastClassName; //! class name of last message
176 : TString fLastFunction; //! function name of last message
177 : TString fLastFile; //! file name of last message
178 : Int_t fLastLine; //! line number of last message
179 : AliLogNotification fCallBacks[kMaxType]; //! external notification callback
180 :
181 176 : ClassDef(AliLog, 1) // class for logging debug, info and error messages
182 : };
183 :
184 :
185 : // module name macro
186 : #ifdef _MODULE_
187 : # define MODULENAME() _MODULE_
188 : #else
189 : # define MODULENAME() "NoModule"
190 : #endif
191 :
192 : // function name macro
193 : #if defined(__GNUC__) || defined(__ICC) || defined(__ECC) || defined(__APPLE__)
194 : # define FUNCTIONNAME() __FUNCTION__
195 : // #elif defined(__HP_aCC) || defined(__alpha) || defined(__DECCXX)
196 : // #define FUNCTIONNAME() __FUNC__
197 : #else
198 : # define FUNCTIONNAME() "???"
199 : #endif
200 :
201 : // redirection
202 : /**
203 : * Redirect output to std::cout to specified log stream
204 : *
205 : * @param type Type of stream to re-direct to
206 : * @param level Level of output
207 : * @param scope Scope
208 : * @param whatever Any code that will output to std::cout
209 : */
210 : #define REDIRECTSTDOUT(type, level, scope, whatever) \
211 : do {Int_t originalStdout = AliLog::RedirectStdoutTo(type, level, MODULENAME(), scope, FUNCTIONNAME(), __FILE__, __LINE__, kFALSE); \
212 : whatever; AliLog::RestoreStdout(originalStdout);} while(false)
213 : /**
214 : * Redirect output to std::cerr to specified log stream
215 : *
216 : * @param type Type of stream to re-direct to
217 : * @param level Level of output
218 : * @param scope Scope
219 : * @param whatever Any code that will output to std::cout
220 : */
221 : #define REDIRECTSTDERR(type, level, scope, whatever) \
222 : do {Int_t originalStderr = AliLog::RedirectStderrTo(type, level, MODULENAME(), scope, FUNCTIONNAME(), __FILE__, __LINE__, kFALSE); \
223 : whatever; AliLog::RestoreStderr(originalStderr);} while(false)
224 : /**
225 : * Redirect output to std::cout and std::cerr to specified log stream
226 : *
227 : * @param type Type of stream to re-direct to
228 : * @param level Level of output
229 : * @param scope Scope
230 : * @param whatever Any code that will output to std::cout or std::cerr
231 : */
232 : #define REDIRECTSTDOUTANDSTDERR(type, level, scope, whatever) \
233 : do {Int_t originalStdout = AliLog::RedirectStdoutTo(type, level, MODULENAME(), scope, FUNCTIONNAME(), __FILE__, __LINE__, kFALSE); \
234 : Int_t originalStderr = AliLog::RedirectStderrTo(type, level, MODULENAME(), scope, FUNCTIONNAME(), __FILE__, __LINE__, kFALSE); \
235 : whatever; AliLog::RestoreStderr(originalStderr); AliLog::RestoreStdout(originalStdout);} while(false)
236 :
237 :
238 : // debug level
239 : #ifdef LOG_NO_DEBUG
240 : # define AliDebugLevel() -1
241 : # define AliDebugLevelClass() -1
242 : # define AliDebugLevelGeneral(scope) -1
243 : #else
244 : /**
245 : * Get the object scope debug level
246 : */
247 : # define AliDebugLevel() ((AliLog::IsDebugEnabled()) ? AliLog::GetDebugLevel(MODULENAME(), ClassName()) : -1)
248 : /**
249 : * Get the class (ROOT-enabled) debug level
250 : */
251 : # define AliDebugLevelClass() ((AliLog::IsDebugEnabled()) ? AliLog::GetDebugLevel(MODULENAME(), Class()->GetName()) : -1)
252 : /**
253 : * Get the debug level associated with scope
254 : * @param scope Scope
255 : */
256 : # define AliDebugLevelGeneral(scope) ((AliLog::IsDebugEnabled()) ? AliLog::GetDebugLevel(MODULENAME(), scope) : -1)
257 : #endif
258 :
259 : // debug messages
260 : #ifdef LOG_NO_DEBUG
261 : # define AliDebug(level, message) do { } while (false)
262 : # define AliDebugClass(level, message) do { } while (false)
263 : # define AliDebugGeneral(scope, level, message) do { } while (false)
264 : # define AliDebugF(level, message,...) do { } while (false)
265 : # define AliDebugClassF(level, message,...) do { } while (false)
266 : # define AliDebugGeneralF(scope, level, message,...) do { } while (false)
267 : #else
268 :
269 : // inspired by log4cxx code (see log4cxx/Logger.h)
270 : // implements GCC branch prediction for increasing logging performance
271 : # if !defined(ALIROOT_UNLIKELY)
272 : # if defined(__GNUC__) && (__GNUC__ >= 3)
273 : /**
274 : * Provides optimization hint to the compiler
275 : * to optimize for the expression being false.
276 : * @param expr boolean expression.
277 : * @returns value of expression.
278 : */
279 : # define ALIROOT_UNLIKELY(expr) __builtin_expect(expr, 0)
280 : # else
281 : /**
282 : * Provides optimization hint to the compiler
283 : * to optimize for the expression being false.
284 : * @param expr boolean expression.
285 : * @returns value of expression.
286 : */
287 : # define ALIROOT_UNLIKELY(expr) expr
288 : # endif
289 : # endif
290 :
291 : /**
292 : *
293 : * Logs a message to a specified logger with the DEBUG level.
294 : *
295 : * @param logLevel the debug level.
296 : * @param message message to print in the following format: Form(message).
297 : * Note, that message should contain balanced parenthesis, like
298 : * <code>AliDebug(1, Form("Failed to decode line %d of %s", line, filename));</code>
299 : */
300 : # define AliDebug(logLevel, message) \
301 : do { if (ALIROOT_UNLIKELY(AliLog::IsDebugEnabled() && AliLog::GetDebugLevel(MODULENAME(), ClassName()) >= logLevel)) {\
302 : AliLog::Debug(logLevel, message, MODULENAME(), ClassName(), FUNCTIONNAME(), __FILE__, __LINE__); }} while (0)
303 : /**
304 : *
305 : * Logs a message to a specified logger with the DEBUG level. For use
306 : * in static member functions of a class
307 : *
308 : * @param logLevel the debug level.
309 : * @param message message to print in the following format: Form(message).
310 : * Note, that message should contain balanced parenthesis, like
311 : * <code>AliDebug(1, Form("Failed to decode line %d of %s", line, filename));</code>
312 : */
313 : # define AliDebugClass(logLevel, message) \
314 : do { if (ALIROOT_UNLIKELY(AliLog::IsDebugEnabled() && AliLog::GetDebugLevel(MODULENAME(), Class()->GetName()) >= logLevel)) {\
315 : AliLog::Debug(logLevel, message, MODULENAME(), Class()->GetName(), FUNCTIONNAME(), __FILE__, __LINE__); }} while (0)
316 :
317 : /**
318 : * Logs a message to a specified logger with the DEBUG level. For use
319 : * in non-ROOT-enabled-class scope.
320 : *
321 : * @param scope the logging scope.
322 : * @param logLevel the debug level.
323 : * @param message message to print in the following format: Form(message).
324 : * Note, that message should contain balanced parenthesis, like
325 : * <code>AliDebug(1, Form("Failed to decode line %d of %s", line, filename));</code>
326 : */
327 : # define AliDebugGeneral(scope, logLevel, message) \
328 : do { if (ALIROOT_UNLIKELY(AliLog::IsDebugEnabled() && AliLog::GetDebugLevel(MODULENAME(), scope) >= logLevel)) {\
329 : AliLog::Debug(logLevel, message, MODULENAME(), scope, FUNCTIONNAME(), __FILE__, __LINE__); }} while (0)
330 : /**
331 : * Macro to output debugging information. This excepts a printf-like
332 : * format statement. Note, at least 3 arguments (in total) must be
333 : * passed.
334 : *
335 : * @param logLevel Debug level
336 : * @param format Printf-like format.
337 : */
338 : # define AliDebugF(logLevel,format,...) \
339 : do { if (ALIROOT_UNLIKELY(AliLog::IsDebugEnabled() && AliLog::GetDebugLevel(MODULENAME(), ClassName()) >= logLevel)) { \
340 : TString m;m.Form(format,__VA_ARGS__); \
341 : AliLog::Debug(logLevel, m, MODULENAME(), ClassName(), FUNCTIONNAME(), __FILE__, __LINE__); }} while (0)
342 : /**
343 : * Outut debug information, filtered on debug level. For use in
344 : * static member function of a ROOT-enabled class. This excepts a
345 : * printf-like format statement. Note, at least 3 arguments (in
346 : * total) must be passed.
347 : *
348 : * @param logLevel Debug level
349 : * @param format Printf-like format
350 : *
351 : * @return
352 : */
353 : # define AliDebugClassF(logLevel,format,...) \
354 : do { if (ALIROOT_UNLIKELY(AliLog::IsDebugEnabled() && AliLog::GetDebugLevel(MODULENAME(), Class()->GetName()) >= logLevel)) { \
355 : TString m;m.Form(format,__VA_ARGS__); \
356 : AliLog::Debug(logLevel, m, MODULENAME(), Class()->GetName(), FUNCTIONNAME(), __FILE__, __LINE__); }} while (0)
357 : /**
358 : * Outut debug information, filtered on debug level. For use in
359 : * static member function of a non-ROOT-enabled class-scope. This
360 : * excepts a printf-like format statement. Note, at least 3 arguments
361 : * (in total) must be passed.
362 : *
363 : * @param scope Scope
364 : * @param logLevel Debug level
365 : * @param format Printf-like format
366 : *
367 : * @return
368 : */
369 : # define AliDebugGeneralF(scope,logLevel,format,...) \
370 : do { if (ALIROOT_UNLIKELY(AliLog::IsDebugEnabled() && AliLog::GetDebugLevel(MODULENAME(), scope) >= logLevel)) { \
371 : TString m;m.Form(format,__VA_ARGS__); \
372 : AliLog::Debug(logLevel, m, MODULENAME(), scope, FUNCTIONNAME(), __FILE__, __LINE__); }} while (0)
373 :
374 : #endif
375 :
376 : // redirection to debug
377 : #define StdoutToAliDebug(level, whatever) REDIRECTSTDOUT(AliLog::kDebug, level, ClassName(), whatever)
378 : #define StderrToAliDebug(level, whatever) REDIRECTSTDERR(AliLog::kDebug, level, ClassName(), whatever)
379 : #define ToAliDebug(level, whatever) REDIRECTSTDOUTANDSTDERR(AliLog::kDebug, level, ClassName(), whatever)
380 : #define StdoutToAliDebugClass(level, whatever) REDIRECTSTDOUT(AliLog::kDebug, level, Class()->GetName(), whatever)
381 : #define StderrToAliDebugClass(level, whatever) REDIRECTSTDERR(AliLog::kDebug, level, Class()->GetName(), whatever)
382 : #define ToAliDebugClass(level, whatever) REDIRECTSTDOUTANDSTDERR(AliLog::kDebug, level, Class()->GetName(), whatever)
383 : #define StdoutToAliDebugGeneral(scope, level, whatever) REDIRECTSTDOUT(AliLog::kDebug, level, scope, whatever)
384 : #define StderrToAliDebugGeneral(scope, level, whatever) REDIRECTSTDERR(AliLog::kDebug, level, scope, whatever)
385 : #define ToAliDebugGeneral(scope, level, whatever) REDIRECTSTDOUTANDSTDERR(AliLog::kDebug, level, scope, whatever)
386 :
387 : // debug stream objects
388 : #define AliDebugStream(level) AliLog::Stream(AliLog::kDebug, level, MODULENAME(), ClassName(), FUNCTIONNAME(), __FILE__, __LINE__)
389 : #define AliDebugClassStream(level) AliLog::Stream(AliLog::kDebug, level, MODULENAME(), Class()->GetName(), FUNCTIONNAME(), __FILE__, __LINE__)
390 : #define AliDebugGeneralStream(scope, level) AliLog::Stream(AliLog::kDebug, level, MODULENAME(), scope, FUNCTIONNAME(), __FILE__, __LINE__)
391 :
392 :
393 : /**
394 : * Macro that will output stuff using the logging facilities.
395 : *
396 : * @param lvl Message level
397 : * @param message Message to show
398 : */
399 : #define AliMessage(lvl,message) do { \
400 : AliLog::Message(lvl, message, MODULENAME(), ClassName(), FUNCTIONNAME(), __FILE__, __LINE__);} while(false)
401 : /**
402 : * Macro that will output stuff using the logging facilities.
403 : * For use in static member function of ROOT-enabled class-scope.
404 : *
405 : * @param lvl Message level
406 : * @param message Message to show
407 : */
408 : #define AliMessageClass(lvl,message) do { \
409 : AliLog::Message(lvl, message, MODULENAME(), Class()->GetName(), FUNCTIONNAME(), __FILE__, __LINE__);} while(false)
410 : /**
411 : * Macro that will output stuff using the logging facilities.
412 : * For use in non-ROOT-enabled class-scope.
413 : *
414 : * @param scope Scope
415 : * @param lvl Message level
416 : * @param message Message to show
417 : */
418 : #define AliMessageGeneral(scope,lvl,message) do { \
419 : AliLog::Message(lvl, message, MODULENAME(), scope, FUNCTIONNAME(), __FILE__, __LINE__);} while(false)
420 : /**
421 : * Print a message using the AliLog logging facility. This macro
422 : * accepts printf-like format arguments. Note, at least 3 arguments
423 : * must be passed.
424 : * @code
425 : * AliMessageF(1, "foo"); // <-- Failes
426 : * AliMessageF(1, "foo %d", 42); // <-- OK
427 : * @endcode
428 : *
429 : * @param lvl Message level
430 : * @param format printf-like format
431 : */
432 : #define AliMessageF(lvl,format,...) do { \
433 : TString m; m.Form(format,__VA_ARGS__); \
434 : AliLog::Message(lvl, m, MODULENAME(), ClassName(), FUNCTIONNAME(), __FILE__, __LINE__);} while(false)
435 : /**
436 : * Print a message using the AliLog logging facility. This macro
437 : * accepts printf-like format arguments. Note, at least 3 arguments
438 : * must be passed.
439 : * @code
440 : * AliMessageF(1, "foo"); // <-- Failes
441 : * AliMessageF(1, "foo %d", 42); // <-- OK
442 : * @endcode
443 : *
444 : * This is for static member function in for ROOT-enabled class-scope
445 : *
446 : * @param lvl Message level
447 : * @param format printf-like format
448 : */
449 : #define AliMessageClassF(lvl,format,...) do { \
450 : TString m; m.Form(format,__VA_ARGS__); \
451 : AliLog::Message(lvl, m, MODULENAME(), Class()->GetName(), FUNCTIONNAME(), __FILE__, __LINE__);} while(false)
452 : /**
453 : * Print a message using the AliLog logging facility. This macro
454 : * accepts printf-like format arguments. Note, at least 3 arguments
455 : * must be passed.
456 : * @code
457 : * AliMessageF(1, "foo"); // <-- Failes
458 : * AliMessageF(1, "foo %d", 42); // <-- OK
459 : * @endcode
460 : *
461 : * This is for non-ROOT-enabled class-scope
462 : *
463 : * @param scope Scope
464 : * @param lvl Message level
465 : * @param format printf-like format
466 : */
467 : #define AliMessageGeneralF(scope,lvl,format,...) do { \
468 : TString m; m.Form(format,__VA_ARGS__); \
469 : AliLog::Message(lvl, m, MODULENAME(), scope, FUNCTIONNAME(), __FILE__, __LINE__);} while(false)
470 :
471 : // info messages
472 : #ifdef LOG_NO_INFO
473 : # define AliInfo(message) do { } while (false)
474 : # define AliInfoClass(message) do { } while (false)
475 : # define AliInfoGeneral(scope, message) do { } while (false)
476 : # define AliInfoF(message,...) do { } while (false)
477 : # define AliInfoClassF(message,...) do { } while (false)
478 : # define AliInfoGeneralF(scope, message,...) do { } while (false)
479 : #else
480 : /**
481 : * Forwards to AliMessage with log level of AliLog::kInfo
482 : * @see AliMessage
483 : */
484 : # define AliInfo(message) AliMessage(AliLog::kInfo, message)
485 : /**
486 : * Forwards to AliMessageClass with log level of AliLog::kInfo
487 : * @see AliMessageClass
488 : */
489 : # define AliInfoClass(message) AliMessageClass(AliLog::kInfo, message)
490 : /**
491 : * Forwards to AliMessageGeneral with log level of AliLog::kInfo
492 : * @see AliMessageGeneral
493 : */
494 : # define AliInfoGeneral(scope, message) AliMessageGeneral(scope, AliLog::kInfo, message)
495 : /**
496 : * Forwards to AliMessageF with log level of AliLog::kInfo
497 : * @see AliMessageF
498 : */
499 : # define AliInfoF(message,...) AliMessageF(AliLog::kInfo, message, __VA_ARGS__)
500 : /**
501 : * Forwards to AliMessageClassF with log level of AliLog::kInfo
502 : * @see AliMessageClassF
503 : */
504 : # define AliInfoClassF(message,...) AliMessageClassF(AliLog::kInfo, message, __VA_ARGS__)
505 : /**
506 : * Forwards to AliMessageGeneralF with log level of AliLog::kInfo
507 : * @see AliMessageGeneralF
508 : */
509 : # define AliInfoGeneralF(scope,message,...) AliMessageGeneralF(scope, AliLog::kInfo, message, __VA_ARGS__)
510 : #endif
511 :
512 : // redirection to info
513 : #define StdoutToAliInfo(whatever) REDIRECTSTDOUT(AliLog::kInfo, 0, ClassName(), whatever)
514 : #define StderrToAliInfo(whatever) REDIRECTSTDERR(AliLog::kInfo, 0, ClassName(), whatever)
515 : #define ToAliInfo(whatever) REDIRECTSTDOUTANDSTDERR(AliLog::kInfo, 0, ClassName(), whatever)
516 : #define StdoutToAliInfoClass(whatever) REDIRECTSTDOUT(AliLog::kInfo, 0, Class()->GetName(), whatever)
517 : #define StderrToAliInfoClass(whatever) REDIRECTSTDERR(AliLog::kInfo, 0, Class()->GetName(), whatever)
518 : #define ToAliInfoClass(whatever) REDIRECTSTDOUTANDSTDERR(AliLog::kInfo, 0, Class()->GetName(), whatever)
519 : #define StdoutToAliInfoGeneral(scope, whatever) REDIRECTSTDOUT(AliLog::kInfo, 0, scope, whatever)
520 : #define StderrToAliInfoGeneral(scope, whatever) REDIRECTSTDERR(AliLog::kInfo, 0, scope, whatever)
521 : #define ToAliInfoGeneral(scope, whatever) REDIRECTSTDOUTANDSTDERR(AliLog::kInfo, 0, scope, whatever)
522 :
523 : // info stream objects
524 : #define AliInfoStream() AliLog::Stream(AliLog::kInfo, 0, MODULENAME(), ClassName(), FUNCTIONNAME(), __FILE__, __LINE__)
525 : #define AliInfoClassStream() AliLog::Stream(AliLog::kInfo, 0, MODULENAME(), Class()->GetName(), FUNCTIONNAME(), __FILE__, __LINE__)
526 : #define AliInfoGeneralStream(scope) AliLog::Stream(AliLog::kInfo, 0, MODULENAME(), scope, FUNCTIONNAME(), __FILE__, __LINE__)
527 :
528 : // warning messages
529 : #ifdef LOG_NO_WARNING
530 : # define AliWarning(message) do { } while (false)
531 : # define AliWarningClass(message) do { } while (false)
532 : # define AliWarningGeneral(scope, message) do { } while (false)
533 : # define AliWarningF(message,...) do { } while (false)
534 : # define AliWarningClassF(message,...) do { } while (false)
535 : # define AliWarningGeneralF(scope, message,...) do { } while (false)
536 : #else
537 : /**
538 : * Forwards to AliMessage with log level of AliLog::kWarning
539 : * @see AliMessage
540 : */
541 : # define AliWarning(message) AliMessage(AliLog::kWarning, message)
542 : /**
543 : * Forwards to AliMessageClass with log level of AliLog::kWarning
544 : * @see AliMessageClass
545 : */
546 : # define AliWarningClass(message) AliMessageClass(AliLog::kWarning, message)
547 : /**
548 : * Forwards to AliMessageGeneral with log level of AliLog::kWarning
549 : * @see AliMessageGeneral
550 : */
551 : # define AliWarningGeneral(scope, message) AliMessageGeneral(scope, AliLog::kWarning, message)
552 : /**
553 : * Forwards to AliMessageF with log level of AliLog::kWarning
554 : * @see AliMessageF
555 : */
556 : # define AliWarningF(message,...) AliMessageF(AliLog::kWarning, message, __VA_ARGS__)
557 : /**
558 : * Forwards to AliMessageClassF with log level of AliLog::kWarning
559 : * @see AliMessageClassF
560 : */
561 : # define AliWarningClassF(message,...) AliMessageClassF(AliLog::kWarning, message, __VA_ARGS__)
562 : /**
563 : * Forwards to AliMessageGeneralF with log level of AliLog::kWarning
564 : * @see AliMessageGeneralF
565 : */
566 : # define AliWarningGeneralF(scope,message,...) AliMessageGeneralF(scope, AliLog::kWarning, message, __VA_ARGS__)
567 : #endif
568 :
569 : // redirection to warning
570 : #define StdoutToAliWarning(whatever) REDIRECTSTDOUT(AliLog::kWarning, 0, ClassName(), whatever)
571 : #define StderrToAliWarning(whatever) REDIRECTSTDERR(AliLog::kWarning, 0, ClassName(), whatever)
572 : #define ToAliWarning(whatever) REDIRECTSTDOUTANDSTDERR(AliLog::kWarning, 0, ClassName(), whatever)
573 : #define StdoutToAliWarningClass(whatever) REDIRECTSTDOUT(AliLog::kWarning, 0, Class()->GetName(), whatever)
574 : #define StderrToAliWarningClass(whatever) REDIRECTSTDERR(AliLog::kWarning, 0, Class()->GetName(), whatever)
575 : #define ToAliWarningClass(whatever) REDIRECTSTDOUTANDSTDERR(AliLog::kWarning, 0, Class()->GetName(), whatever)
576 : #define StdoutToAliWarningGeneral(scope, whatever) REDIRECTSTDOUT(AliLog::kWarning, 0, scope, whatever)
577 : #define StderrToAliWarningGeneral(scope, whatever) REDIRECTSTDERR(AliLog::kWarning, 0, scope, whatever)
578 : #define ToAliWarningGeneral(scope, whatever) REDIRECTSTDOUTANDSTDERR(AliLog::kWarning, 0, scope, whatever)
579 :
580 : // warning stream objects
581 : #define AliWarningStream() AliLog::Stream(AliLog::kWarning, 0, MODULENAME(), ClassName(), FUNCTIONNAME(), __FILE__, __LINE__)
582 : #define AliWarningClassStream() AliLog::Stream(AliLog::kWarning, 0, MODULENAME(), Class()->GetName(), FUNCTIONNAME(), __FILE__, __LINE__)
583 : #define AliWarningGeneralStream(scope) AliLog::Stream(AliLog::kWarning, 0, MODULENAME(), scope, FUNCTIONNAME(), __FILE__, __LINE__)
584 :
585 :
586 : // error messages
587 : /**
588 : * Forwards to AliMessage with log level of AliLog::kError
589 : * @see AliMessage
590 : */
591 : #define AliError(message) AliMessage(AliLog::kError, message)
592 : /**
593 : * Forwards to AliMessageClass with log level of AliLog::kError
594 : * @see AliMessageClass
595 : */
596 : #define AliErrorClass(message) AliMessageClass(AliLog::kError, message)
597 : /**
598 : * Forwards to AliMessageGeneral with log level of AliLog::kError
599 : * @see AliMessageGeneral
600 : */
601 : #define AliErrorGeneral(scope, message) AliMessageGeneral(scope, AliLog::kError, message)
602 : /**
603 : * Forwards to AliMessageF with log level of AliLog::kError
604 : * @see AliMessageF
605 : */
606 : #define AliErrorF(message,...) AliMessageF(AliLog::kError, message, __VA_ARGS__)
607 : /**
608 : * Forwards to AliMessageClassF with log level of AliLog::kError
609 : * @see AliMessageClassF
610 : */
611 : #define AliErrorClassF(message,...) AliMessageClassF(AliLog::kError, message, __VA_ARGS__)
612 : /**
613 : * Forwards to AliMessageGeneralF with log level of AliLog::kError
614 : * @see AliMessageGeneralF
615 : */
616 : #define AliErrorGeneralF(scope,message,...) AliMessageGeneralF(scope, AliLog::kError, message, __VA_ARGS__)
617 :
618 : // redirection to error
619 : #define StdoutToAliError(whatever) REDIRECTSTDOUT(AliLog::kError, 0, ClassName(), whatever)
620 : #define StderrToAliError(whatever) REDIRECTSTDERR(AliLog::kError, 0, ClassName(), whatever)
621 : #define ToAliError(whatever) REDIRECTSTDOUTANDSTDERR(AliLog::kError, 0, ClassName(), whatever)
622 : #define StdoutToAliErrorClass(whatever) REDIRECTSTDOUT(AliLog::kError, 0, Class()->GetName(), whatever)
623 : #define StderrToAliErrorClass(whatever) REDIRECTSTDERR(AliLog::kError, 0, Class()->GetName(), whatever)
624 : #define ToAliErrorClass(whatever) REDIRECTSTDOUTANDSTDERR(AliLog::kError, 0, Class()->GetName(), whatever)
625 : #define StdoutToAliErrorGeneral(scope, whatever) REDIRECTSTDOUT(AliLog::kError, 0, scope, whatever)
626 : #define StderrToAliErrorGeneral(scope, whatever) REDIRECTSTDERR(AliLog::kError, 0, scope, whatever)
627 : #define ToAliErrorGeneral(scope, whatever) REDIRECTSTDOUTANDSTDERR(AliLog::kError, 0, scope, whatever)
628 :
629 : // error stream objects
630 : #define AliErrorStream() AliLog::Stream(AliLog::kError, 0, MODULENAME(), ClassName(), FUNCTIONNAME(), __FILE__, __LINE__)
631 : #define AliErrorClassStream() AliLog::Stream(AliLog::kError, 0, MODULENAME(), Class()->GetName(), FUNCTIONNAME(), __FILE__, __LINE__)
632 : #define AliErrorGeneralStream(scope) AliLog::Stream(AliLog::kError, 0, MODULENAME(), scope, FUNCTIONNAME(), __FILE__, __LINE__)
633 :
634 :
635 : // fatal messages
636 : /**
637 : * Forwards to AliMessage with log level of AliLog::kFatal
638 : * @see AliMessage
639 : */
640 : #define AliFatal(message) AliMessage(AliLog::kFatal, message)
641 : /**
642 : * Forwards to AliMessageClass with log level of AliLog::kFatal
643 : * @see AliMessageClass
644 : */
645 : #define AliFatalClass(message) AliMessageClass(AliLog::kFatal, message)
646 : /**
647 : * Forwards to AliMessageGeneral with log level of AliLog::kFatal
648 : * @see AliMessageGeneral
649 : */
650 : #define AliFatalGeneral(scope, message) AliMessageGeneral(scope, AliLog::kFatal, message)
651 : /**
652 : * Forwards to AliMessageF with log level of AliLog::kFatal
653 : * @see AliMessageF
654 : */
655 : #define AliFatalF(message,...) AliMessageF(AliLog::kFatal, message, __VA_ARGS__)
656 : /**
657 : * Forwards to AliMessageClassF with log level of AliLog::kFatal
658 : * @see AliMessageClassF
659 : */
660 : #define AliFatalClassF(message,...) AliMessageClassF(AliLog::kFatal, message, __VA_ARGS__)
661 : /**
662 : * Forwards to AliMessageGeneralF with log level of AliLog::kFatal
663 : * @see AliMessageGeneralF
664 : */
665 : #define AliFatalGeneralF(scope,message,...) AliMessageGeneralF(scope, AliLog::kFatal, message, __VA_ARGS__)
666 :
667 : #endif
|
