- adapted to AliRoot logging system, messages printed out via AliRoot
[u/mrichter/AliRoot.git] / HLT / BASE / AliHLTLogging.cxx
1 // @(#) $Id$
2
3 /**************************************************************************
4  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
5  *                                                                        *
6  * Authors: Matthias Richter <Matthias.Richter@ift.uib.no>                *
7  *          Timm Steinbeck <timm@kip.uni-heidelberg.de>                   *
8  *          for The ALICE Off-line Project.                               *
9  *                                                                        *
10  * Permission to use, copy, modify and distribute this software and its   *
11  * documentation strictly for non-commercial purposes is hereby granted   *
12  * without fee, provided that the above copyright notice appears in all   *
13  * copies and that both the copyright notice and this permission notice   *
14  * appear in the supporting documentation. The authors make no claims     *
15  * about the suitability of this software for any purpose. It is          *
16  * provided "as is" without express or implied warranty.                  *
17  **************************************************************************/
18
19 /** @file   AliHLTLogging.cxx
20     @author Matthias Richter, Timm Steinbeck
21     @date   
22     @brief  Implementation of HLT logging primitives.
23 */
24
25 #if __GNUC__>= 3
26 using namespace std;
27 #endif
28
29 #ifndef NOALIROOT_LOGGING
30 #include "AliLog.h"
31 #endif
32 #include "AliHLTStdIncludes.h"
33 #include "AliHLTLogging.h"
34 #include "TString.h"
35 #include "TArrayC.h"
36 #include "Varargs.h"
37 #include <string>
38 #include <sstream>
39 #include <iostream>
40
41 /** target stream for AliRoot logging methods */
42 ostringstream gLogstr;
43
44 #ifndef NOALIROOT_LOGGING
45 /**
46  * Notification callback for AliRoot logging methods
47  */
48 void LogNotification(AliLog::EType_t level, const char* message)
49 {
50   cout << "Notification handler: " << gLogstr.str() << endl;
51   AliHLTLogging hltlog;
52   hltlog.SwitchAliLog(0);
53   hltlog.Logging(kHLTLogInfo, "NotificationHandler", "AliLog", gLogstr.str().c_str());
54   gLogstr.clear();
55   string empty("");
56   gLogstr.str(empty);
57 }
58 #endif
59
60 /**
61  * The global logging buffer.
62  * The buffer is created with an initial size and grown dynamically on
63  * demand.
64  */
65 TArrayC gAliHLTLoggingTarget(200);
66
67 /** the maximum size of the buffer */
68 const int gALIHLTLOGGING_MAXBUFFERSIZE=10000;
69
70 /** ROOT macro for the implementation of ROOT specific class methods */
71 ClassImp(AliHLTLogging)
72
73 AliHLTLogging::AliHLTLogging()
74   :
75   //fLocalLogFilter(kHLTLogDefault),
76   fLocalLogFilter(kHLTLogAll),
77   fpDefaultKeyword(NULL),
78   fpCurrentKeyword(NULL)
79 {
80   // see header file for class documentation
81   // or
82   // refer to README to build package
83   // or
84   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
85 }
86
87 AliHLTLogging::AliHLTLogging(const AliHLTLogging&)
88   :
89   fLocalLogFilter(kHLTLogAll),
90   fpDefaultKeyword(NULL),
91   fpCurrentKeyword(NULL)
92 {
93   // see header file for class documentation
94   HLTFatal("copy constructor untested");
95 }
96
97 AliHLTLogging& AliHLTLogging::operator=(const AliHLTLogging&)
98
99   // see header file for class documentation
100   HLTFatal("assignment operator untested");
101   return *this;
102 }
103
104 AliHLTComponentLogSeverity AliHLTLogging::fGlobalLogFilter=kHLTLogAll;
105 AliHLTfctLogging AliHLTLogging::fLoggingFunc=NULL;
106 int AliHLTLogging::fgUseAliLog=1;
107
108 AliHLTLogging::~AliHLTLogging()
109 {
110   // see header file for class documentation
111 }
112
113 int AliHLTLogging::Init(AliHLTfctLogging pFun) 
114
115   // see header file for class documentation
116   if (fLoggingFunc!=NULL && fLoggingFunc!=pFun) {
117     (*fLoggingFunc)(NULL/*fParam*/, kHLTLogWarning, "AliHLTLogging::Init", "no key", "overriding previously initialized logging function");    
118   }
119   fLoggingFunc=pFun;
120 #ifndef NOALIROOT_LOGGING
121   // to be activated when changes to AliLog have been committed
122 //   AliLog* log=new AliLog;
123 //   log->SetLogNotification(LogNotification);
124 //   log->SetStreamOutput(&gLogstr);
125 #endif
126   
127   return 0;
128 }
129
130 int AliHLTLogging::Message(void *param, AliHLTComponentLogSeverity severity,
131                            const char* origin, const char* keyword,
132                            const char* message) 
133 {
134   // see header file for class documentation
135   int iResult=0;
136   if (param==NULL) {
137     // this is currently just to get rid of the warning "unused parameter"
138   }
139
140   const char* strSeverity="";
141   switch (severity) {
142   case kHLTLogBenchmark: 
143     strSeverity="benchmark";
144     break;
145   case kHLTLogDebug:
146     strSeverity="debug";
147     break;
148   case kHLTLogInfo:
149     strSeverity="info";
150     break;
151   case kHLTLogWarning:
152     strSeverity="warning";
153     break;
154   case kHLTLogError:
155     strSeverity="error";
156     break;
157   case kHLTLogFatal:
158     strSeverity="fatal";
159     break;
160   default:
161     break;
162   }
163   TString out="HLT Log ";
164   out+=strSeverity;
165   if (origin) {out+=": "; out+=origin;}
166   out+=" "; out+=message;
167   if (keyword!=NULL && strcmp(keyword, HLT_DEFAULT_LOG_KEYWORD)!=0) {
168     out+=" ("; out+=keyword; out +=")";
169   }
170   cout << out.Data() << endl;
171   return iResult;
172 }
173
174 #ifndef NOALIROOT_LOGGING
175 int AliHLTLogging::AliMessage(AliHLTComponentLogSeverity severity, 
176                               const char* origin_class, const char* origin_func,
177                               const char* file, int line, const char* message) 
178 {
179   // see header file for class documentation
180
181   switch (severity) {
182   case kHLTLogBenchmark: 
183     AliLog::Message(AliLog::kInfo, message, "HLT", origin_class, origin_func, file, line);
184     break;
185   case kHLTLogDebug:
186     AliLog::Message(AliLog::kDebug, message, "HLT", origin_class, origin_func, file, line);
187     break;
188   case kHLTLogInfo:
189     AliLog::Message(AliLog::kInfo, message, "HLT", origin_class, origin_func, file, line);
190     break;
191   case kHLTLogWarning:
192     AliLog::Message(AliLog::kWarning, message, "HLT", origin_class, origin_func, file, line);
193     break;
194   case kHLTLogError:
195     AliLog::Message(AliLog::kError, message, "HLT", origin_class, origin_func, file, line);
196     break;
197   case kHLTLogFatal:
198     AliLog::Message(AliLog::kWarning, message, "HLT", origin_class, origin_func, file, line);
199     break;
200   default:
201     break;
202   }
203   return 0;
204 }
205 #endif
206
207 const char* AliHLTLogging::BuildLogString(const char *format, va_list ap) 
208 {
209   // see header file for class documentation
210
211   int iResult=0;
212   va_list bap;
213   R__VA_COPY(bap, ap);
214
215   // take the first argument from the list as format string if no
216   // format was given
217   const char* fmt = format;
218   if (fmt==NULL) fmt=va_arg(ap, const char*);
219
220   gAliHLTLoggingTarget[0]=0;
221   while (fmt!=NULL) {
222     iResult=vsnprintf(gAliHLTLoggingTarget.GetArray(), gAliHLTLoggingTarget.GetSize(), fmt, ap);
223     if (iResult==-1)
224       // for compatibility with older version of vsnprintf
225       iResult=gAliHLTLoggingTarget.GetSize()*2;
226     else if (iResult<gAliHLTLoggingTarget.GetSize())
227       break;
228
229     // terminate if buffer is already at the limit
230     if (gAliHLTLoggingTarget.GetSize()>=gALIHLTLOGGING_MAXBUFFERSIZE) {
231       gAliHLTLoggingTarget[gAliHLTLoggingTarget.GetSize()-1]=0;
232       break;
233     }
234
235     // check limitation and grow the buffer
236     if (iResult>gALIHLTLOGGING_MAXBUFFERSIZE) iResult=gALIHLTLOGGING_MAXBUFFERSIZE;
237     gAliHLTLoggingTarget.Set(iResult+1);
238
239     // copy the original list and skip the first argument if this was the format string
240     va_end(ap);
241     R__VA_COPY(ap, bap);
242     if (format==NULL) va_arg(ap, const char*);
243   }     
244   va_end(bap);
245
246   return gAliHLTLoggingTarget.GetArray();
247 }
248
249 int AliHLTLogging::Logging(AliHLTComponentLogSeverity severity,
250                            const char* origin, const char* keyword,
251                            const char* format, ... ) 
252 {
253   // see header file for class documentation
254   int iResult=CheckFilter(severity);
255   if (iResult>0) {
256     va_list args;
257     va_start(args, format);
258     if (fLoggingFunc) {
259       iResult = (*fLoggingFunc)(NULL/*fParam*/, severity, origin, keyword, AliHLTLogging::BuildLogString(format, args ));
260     } else {
261 #ifndef NOALIROOT_LOGGING
262       if (fgUseAliLog)
263         iResult=AliMessage(severity, NULL, origin, NULL, 0, AliHLTLogging::BuildLogString(format, args ));
264       else
265 #endif
266         iResult=Message(NULL/*fParam*/, severity, origin, keyword, AliHLTLogging::BuildLogString(format, args ));
267     }
268     va_end(args);
269   }
270   return iResult;
271 }
272
273 int AliHLTLogging::LoggingVarargs(AliHLTComponentLogSeverity severity, 
274                                   const char* origin_class, const char* origin_func,
275                                   const char* file, int line,  ... ) const
276 {
277   // see header file for class documentation
278
279   if (file==NULL && line==0) {
280     // this is currently just to get rid of the warning "unused parameter"
281   }
282   int iResult=CheckFilter(severity);
283   if (iResult>0) {
284     const char* separator="";
285     TString origin;
286     if (origin_class) {
287         origin+=origin_class;
288         separator="::";
289     }
290     if (origin_func) {
291         origin+=separator;
292         origin+=origin_func;
293     }
294     va_list args;
295     va_start(args, line);
296
297     if (fLoggingFunc) {
298       iResult=(*fLoggingFunc)(NULL/*fParam*/, severity, origin.Data(), GetKeyword(), AliHLTLogging::BuildLogString(NULL, args ));
299     } else {
300 #ifndef NOALIROOT_LOGGING
301       if (fgUseAliLog)
302         iResult=AliMessage(severity, origin_class, origin_func, file, line, AliHLTLogging::BuildLogString(NULL, args ));
303       else
304 #endif
305         iResult=Message(NULL/*fParam*/, severity, origin.Data(), GetKeyword(), AliHLTLogging::BuildLogString(NULL, args ));
306     }
307     va_end(args);
308   }
309   return iResult;
310 }
311
312 int AliHLTLogging::CheckFilter(AliHLTComponentLogSeverity severity) const
313 {
314   // see header file for class documentation
315
316   int iResult=severity==kHLTLogNone || (severity&fGlobalLogFilter)>0 && (severity&fLocalLogFilter)>0;
317   return iResult;
318 }
319
320 void AliHLTLogging::SetGlobalLoggingLevel(AliHLTComponentLogSeverity level)
321 {
322   // see header file for class documentation
323
324   fGlobalLogFilter=level;
325 }
326
327 void AliHLTLogging::SetLocalLoggingLevel(AliHLTComponentLogSeverity level)
328 {
329   // see header file for class documentation
330
331   fLocalLogFilter=level;
332 }