3e5cad971222d4f6595f724166c642432d49e905
[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 #include "AliHLTStdIncludes.h"
30 #include "AliHLTLogging.h"
31
32 // global logging buffer
33 #define LOG_BUFFER_SIZE 100
34 char gAliHLTLoggingBuffer[LOG_BUFFER_SIZE]="";
35 char gAliHLTLoggingOriginBuffer[LOG_BUFFER_SIZE]="";
36
37 /** ROOT macro for the implementation of ROOT specific class methods */
38 ClassImp(AliHLTLogging)
39
40 AliHLTLogging::AliHLTLogging()
41   :
42   fpDefaultKeyword(NULL),
43   fpCurrentKeyword(NULL),
44   //fLocalLogFilter(kHLTLogDefault),
45   fLocalLogFilter(kHLTLogAll)
46 {
47 }
48
49 AliHLTLogging::AliHLTLogging(const AliHLTLogging&)
50   :
51   fpDefaultKeyword(NULL),
52   fpCurrentKeyword(NULL),
53   fLocalLogFilter(kHLTLogAll)
54 {
55   HLTFatal("copy constructor untested");
56 }
57
58 AliHLTLogging& AliHLTLogging::operator=(const AliHLTLogging&)
59
60   HLTFatal("assignment operator untested");
61   return *this;
62 }
63
64 AliHLTComponent_LogSeverity AliHLTLogging::fGlobalLogFilter=kHLTLogAll;
65 AliHLTfctLogging AliHLTLogging::fLoggingFunc=NULL;
66
67 AliHLTLogging::~AliHLTLogging()
68 {
69 }
70
71 int AliHLTLogging::Init(AliHLTfctLogging pFun) 
72
73   if (fLoggingFunc!=NULL && fLoggingFunc!=pFun) {
74     (*fLoggingFunc)(NULL/*fParam*/, kHLTLogWarning, "AliHLTLogging::Init", "no key", "overriding previously initialized logging function");    
75   }
76   fLoggingFunc=pFun; 
77   return 0;
78 }
79
80 int AliHLTLogging::Message(void *param, AliHLTComponent_LogSeverity severity, const char* origin, const char* keyword, const char* message) {
81   int iResult=0;
82   const char* strSeverity="";
83   switch (severity) {
84   case kHLTLogBenchmark: 
85     strSeverity="benchmark";
86     break;
87   case kHLTLogDebug:
88     strSeverity="debug";
89     break;
90   case kHLTLogInfo:
91     strSeverity="info";
92     break;
93   case kHLTLogWarning:
94     strSeverity="warning";
95     break;
96   case kHLTLogError:
97     strSeverity="error";
98     break;
99   case kHLTLogFatal:
100     strSeverity="fatal";
101     break;
102   default:
103     break;
104   }
105   cout << "HLT Log " << strSeverity << ": " << origin << " " << message;
106   if (strcmp(keyword, HLT_DEFAULT_LOG_KEYWORD)!=0)
107     cout << " (" << keyword << ")";
108   cout << endl;
109   return iResult;
110 }
111
112 const char* AliHLTLogging::BuildLogString(const char *format, va_list ap) {
113   int tgtLen=0;
114   int iBufferSize=LOG_BUFFER_SIZE;
115   char* tgtBuffer=gAliHLTLoggingBuffer;
116   tgtBuffer[tgtLen]=0;
117
118 #if (defined LOG_PREFIX)
119   tgtLen = snprintf(tgtBuffer, iBufferSize, LOG_PREFIX); // add logging prefix
120 #endif
121   if (tgtLen>=0) {
122     tgtBuffer+=tgtLen; iBufferSize-=tgtLen;
123     tgtLen = vsnprintf(tgtBuffer, iBufferSize, format, ap);
124     if (tgtLen>0) {
125       tgtBuffer+=tgtLen;
126 //       if (tgtLen<LOG_BUFFER_SIZE-1) {
127 //      *tgtBuffer++='\n'; // add newline if space in buffer
128 //      }
129       *tgtBuffer=0; // terminate the buffer
130     }
131   }
132   return gAliHLTLoggingBuffer;
133 }
134
135 int AliHLTLogging::Logging(AliHLTComponent_LogSeverity severity, const char* origin, const char* keyword, const char* format, ... ) {
136   int iResult=CheckFilter(severity);
137   if (iResult>0) {
138     va_list args;
139     va_start(args, format);
140     if (fLoggingFunc) {
141       iResult = (*fLoggingFunc)(NULL/*fParam*/, severity, origin, keyword, AliHLTLogging::BuildLogString(format, args ));
142     } else {
143       iResult = Message(NULL/*fParam*/, severity, origin, keyword, AliHLTLogging::BuildLogString(format, args ));
144     }
145   }
146   return iResult;
147 }
148
149 int AliHLTLogging::LoggingVarargs( AliHLTComponent_LogSeverity severity, const char* origin_class, const char* origin_func,  ... ) const
150 {
151   int iResult=CheckFilter(severity);
152   if (iResult>0) {
153     int iMaxSize=LOG_BUFFER_SIZE-1;
154     int iPos=0;
155     const char* separator="";
156     gAliHLTLoggingOriginBuffer[iPos]=0;
157     if (origin_class) {
158       if ((int)strlen(origin_class)<iMaxSize-iPos) {
159         strcpy(&gAliHLTLoggingOriginBuffer[iPos], origin_class);
160         iPos+=strlen(origin_class);
161         separator="::";
162       }
163     }
164     if (origin_func) {
165       if ((int)strlen(origin_func)+(int)strlen(separator)<iMaxSize-iPos) {
166         strcpy(&gAliHLTLoggingOriginBuffer[iPos], separator);
167         iPos+=strlen(separator);
168         strcpy(&gAliHLTLoggingOriginBuffer[iPos], origin_func);
169         iPos+=strlen(origin_func);
170       }
171     }
172     va_list args;
173     va_start(args, origin_func);
174     const char* format = va_arg(args, const char*);
175
176     const char* message=format;
177     char* qualifier=NULL;
178     if ((qualifier=strchr(format, '%'))!=NULL) {
179       message=AliHLTLogging::BuildLogString(format, args);
180     }
181     if (fLoggingFunc) {
182       iResult=(*fLoggingFunc)(NULL/*fParam*/, severity, gAliHLTLoggingOriginBuffer, GetKeyword(), message);
183     } else {
184       iResult=Message(NULL/*fParam*/, severity, gAliHLTLoggingOriginBuffer, GetKeyword(), message);
185     }
186     va_end(args);
187   }
188   return iResult;
189 }
190
191 int AliHLTLogging::CheckFilter(AliHLTComponent_LogSeverity severity) const
192 {
193   int iResult=severity==kHLTLogNone || (severity&fGlobalLogFilter)>0 && (severity&fLocalLogFilter)>0;
194   return iResult;
195 }