X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=HLT%2FBASE%2FAliHLTLogging.cxx;h=564f1ad7f48d29a33b3f2c1028b17d623c2b3755;hb=b9f858e15e8d5ab3f5f0dd3f06adc99d8e3dec1d;hp=3e5cad971222d4f6595f724166c642432d49e905;hpb=5f1685a0a0dc975e0b91f3b4b6047af123ee980c;p=u%2Fmrichter%2FAliRoot.git

diff --git a/HLT/BASE/AliHLTLogging.cxx b/HLT/BASE/AliHLTLogging.cxx
index 3e5cad97122..564f1ad7f48 100644
--- a/HLT/BASE/AliHLTLogging.cxx
+++ b/HLT/BASE/AliHLTLogging.cxx
@@ -1,11 +1,11 @@
-// $Id: 
+// @(#) $Id$
 
 /**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * This file is property of and copyright by the ALICE HLT Project        * 
+ * ALICE Experiment at CERN, All rights reserved.                         *
  *                                                                        *
- * Authors: Matthias Richter <Matthias.Richter@ift.uib.no>                *
- *          Timm Steinbeck <timm@kip.uni-heidelberg.de>                   *
- *          for The ALICE Off-line Project.                               *
+ * Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
+ *                  for The ALICE HLT Project.                            *
  *                                                                        *
  * Permission to use, copy, modify and distribute this software and its   *
  * documentation strictly for non-commercial purposes is hereby granted   *
@@ -28,57 +28,149 @@ using namespace std;
 
 #include "AliHLTStdIncludes.h"
 #include "AliHLTLogging.h"
-
-// global logging buffer
-#define LOG_BUFFER_SIZE 100
-char gAliHLTLoggingBuffer[LOG_BUFFER_SIZE]="";
-char gAliHLTLoggingOriginBuffer[LOG_BUFFER_SIZE]="";
+#include "AliHLTComponentHandler.h"
+#include "TString.h"
+#include "Varargs.h"
+#include <string>
+#include <sstream>
+#include <iostream>
 
 /** ROOT macro for the implementation of ROOT specific class methods */
-ClassImp(AliHLTLogging)
+ClassImp(AliHLTLogging);
 
 AliHLTLogging::AliHLTLogging()
   :
-  fpDefaultKeyword(NULL),
-  fpCurrentKeyword(NULL),
   //fLocalLogFilter(kHLTLogDefault),
-  fLocalLogFilter(kHLTLogAll)
+  fLocalLogFilter(kHLTLogAll),
+  fpDefaultKeyword(NULL),
+  fpCurrentKeyword(NULL)
 {
+  // see header file for class documentation
+  // or
+  // refer to README to build package
+  // or
+  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
 }
 
 AliHLTLogging::AliHLTLogging(const AliHLTLogging&)
   :
+  fLocalLogFilter(kHLTLogAll),
   fpDefaultKeyword(NULL),
-  fpCurrentKeyword(NULL),
-  fLocalLogFilter(kHLTLogAll)
+  fpCurrentKeyword(NULL)
 {
+  // see header file for class documentation
   HLTFatal("copy constructor untested");
 }
 
 AliHLTLogging& AliHLTLogging::operator=(const AliHLTLogging&)
 { 
+  // see header file for class documentation
   HLTFatal("assignment operator untested");
   return *this;
 }
 
-AliHLTComponent_LogSeverity AliHLTLogging::fGlobalLogFilter=kHLTLogAll;
-AliHLTfctLogging AliHLTLogging::fLoggingFunc=NULL;
+ostringstream AliHLTLogging::fgLogstr;
+AliHLTComponentLogSeverity AliHLTLogging::fgGlobalLogFilter=kHLTLogAll;
+AliHLTfctLogging AliHLTLogging::fgLoggingFunc=NULL;
+AliHLTLogging::AliHLTDynamicMessage AliHLTLogging::fgAliLoggingFunc=NULL;
+int AliHLTLogging::fgUseAliLog=1;
+
+TString AliHLTLogging::fgBlackList="";
+TString AliHLTLogging::fgWhiteList="";
 
 AliHLTLogging::~AliHLTLogging()
 {
+  // see header file for class documentation
 }
 
+// the array will be grown dynamically, this is just an initial size 
+TArrayC AliHLTLogging::fgAliHLTLoggingTarget(200);
+// the maximum size of the array
+const int AliHLTLogging::fgkALIHLTLOGGINGMAXBUFFERSIZE=10000;
+
 int AliHLTLogging::Init(AliHLTfctLogging pFun) 
-{ 
-  if (fLoggingFunc!=NULL && fLoggingFunc!=pFun) {
-    (*fLoggingFunc)(NULL/*fParam*/, kHLTLogWarning, "AliHLTLogging::Init", "no key", "overriding previously initialized logging function");    
+{
+  // see header file for class documentation
+  if (fgLoggingFunc!=NULL && fgLoggingFunc!=pFun) {
+    (*fgLoggingFunc)(NULL/*fParam*/, kHLTLogWarning, "AliHLTLogging::Init", "no key", "overriding previously initialized logging function");    
   }
-  fLoggingFunc=pFun; 
+  fgLoggingFunc=pFun;
+  
   return 0;
 }
 
-int AliHLTLogging::Message(void *param, AliHLTComponent_LogSeverity severity, const char* origin, const char* keyword, const char* message) {
+int AliHLTLogging::InitAliLogTrap(AliHLTComponentHandler* pHandler)
+{
+  // see header file for class documentation
+  // init the AliRoot logging trap
+  // AliLog messages are redirected to PubSub,
+  int iResult=0;
+  if (pHandler) {
+    // set temporary loglevel of component handler
+    AliHLTComponentLogSeverity loglevel=pHandler->GetLocalLoggingLevel();
+    pHandler->SetLocalLoggingLevel(kHLTLogError);
+
+    // load library containing AliRoot dependencies and initialization handler
+    pHandler->LoadLibrary(ALILOG_WRAPPER_LIBRARY, 0/* do not activate agents */);
+
+    // restore loglevel
+    pHandler->SetLocalLoggingLevel(loglevel);
+
+    // find the symbol
+    InitAliDynamicMessageCallback pFunc=(InitAliDynamicMessageCallback)pHandler->FindSymbol(ALILOG_WRAPPER_LIBRARY, "InitAliDynamicMessageCallback"); 
+    if (pFunc) {
+      iResult=(*pFunc)();
+    } else {
+      Message(NULL, kHLTLogError, "AliHLTLogging::InitAliLogTrap", "init logging",
+	      "can not initialize AliLog callback");
+      iResult=-ENOSYS;
+    }
+  } else {
+    iResult=-EINVAL;
+  }
+  
+  return iResult;
+}
+
+int AliHLTLogging::InitAliLogFunc(AliHLTComponentHandler* pHandler)
+{
+  // see header file for class documentation
   int iResult=0;
+  if (pHandler) {
+    // set temporary loglevel of component handler
+    AliHLTComponentLogSeverity loglevel=pHandler->GetLocalLoggingLevel();
+    pHandler->SetLocalLoggingLevel(kHLTLogError);
+
+    // load library containing AliRoot dependencies and initialization handler
+    pHandler->LoadLibrary(ALILOG_WRAPPER_LIBRARY, 0/* do not activate agents */);
+
+    // restore loglevel
+    pHandler->SetLocalLoggingLevel(loglevel);
+
+    // find the symbol
+    fgAliLoggingFunc=(AliHLTLogging::AliHLTDynamicMessage)pHandler->FindSymbol(ALILOG_WRAPPER_LIBRARY, "AliDynamicMessage");
+    if (fgAliLoggingFunc==NULL) {
+      Message(NULL, kHLTLogError, "AliHLTLogging::InitAliLogFunc", "init logging",
+	      "symbol lookp failure: can not find AliDynamicMessage, switching to HLT logging system");
+      iResult=-ENOSYS;
+    }
+  } else {
+    iResult=-EINVAL;
+  }
+  
+  return iResult;
+}
+
+int AliHLTLogging::Message(void *param, AliHLTComponentLogSeverity severity,
+			   const char* origin, const char* keyword,
+			   const char* message) 
+{
+  // see header file for class documentation
+  int iResult=0;
+  if (param==NULL) {
+    // this is currently just to get rid of the warning "unused parameter"
+  }
+
   const char* strSeverity="";
   switch (severity) {
   case kHLTLogBenchmark: 
@@ -99,97 +191,225 @@ int AliHLTLogging::Message(void *param, AliHLTComponent_LogSeverity severity, co
   case kHLTLogFatal:
     strSeverity="fatal";
     break;
+  case kHLTLogImportant:
+    strSeverity="notify";
+    break;
   default:
     break;
   }
-  cout << "HLT Log " << strSeverity << ": " << origin << " " << message;
-  if (strcmp(keyword, HLT_DEFAULT_LOG_KEYWORD)!=0)
-    cout << " (" << keyword << ")";
-  cout << endl;
+  TString out="HLT Log ";
+  out+=strSeverity;
+  if (origin && origin[0]!=0) {out+=": <"; out+=origin; out+="> ";}
+  out+=" "; out+=message;
+  if (keyword!=NULL && strcmp(keyword, HLT_DEFAULT_LOG_KEYWORD)!=0) {
+    out+=" ("; out+=keyword; out +=")";
+  }
+  cout << out.Data() << endl;
   return iResult;
 }
 
-const char* AliHLTLogging::BuildLogString(const char *format, va_list ap) {
-  int tgtLen=0;
-  int iBufferSize=LOG_BUFFER_SIZE;
-  char* tgtBuffer=gAliHLTLoggingBuffer;
-  tgtBuffer[tgtLen]=0;
+#if 0
+int AliHLTLogging::AliMessage(AliHLTComponentLogSeverity severity, 
+			      const char* originClass, const char* originFunc,
+			      const char* file, int line, const char* message) 
+{
+  // see header file for class documentation
 
-#if (defined LOG_PREFIX)
-  tgtLen = snprintf(tgtBuffer, iBufferSize, LOG_PREFIX); // add logging prefix
+  switch (severity) {
+  case kHLTLogBenchmark: 
+    AliLog::Message(AliLog::kInfo, message, "HLT", originClass, originFunc, file, line);
+    break;
+  case kHLTLogDebug:
+    AliLog::Message(AliLog::kDebug, message, "HLT", originClass, originFunc, file, line);
+    break;
+  case kHLTLogInfo:
+    AliLog::Message(AliLog::kInfo, message, "HLT", originClass, originFunc, file, line);
+    break;
+  case kHLTLogWarning:
+    AliLog::Message(AliLog::kWarning, message, "HLT", originClass, originFunc, file, line);
+    break;
+  case kHLTLogError:
+    AliLog::Message(AliLog::kError, message, "HLT", originClass, originFunc, file, line);
+    break;
+  case kHLTLogFatal:
+    AliLog::Message(AliLog::kWarning, message, "HLT", originClass, originFunc, file, line);
+    break;
+  default:
+    break;
+  }
+  return 0;
+}
 #endif
-  if (tgtLen>=0) {
-    tgtBuffer+=tgtLen; iBufferSize-=tgtLen;
-    tgtLen = vsnprintf(tgtBuffer, iBufferSize, format, ap);
-    if (tgtLen>0) {
-      tgtBuffer+=tgtLen;
-//       if (tgtLen<LOG_BUFFER_SIZE-1) {
-// 	*tgtBuffer++='\n'; // add newline if space in buffer
-//      }
-      *tgtBuffer=0; // terminate the buffer
+
+const char* AliHLTLogging::BuildLogString(const char *format, va_list ap) 
+{
+  // see header file for class documentation
+
+  int iResult=0;
+#ifdef R__VA_COPY
+  va_list bap;
+  R__VA_COPY(bap, ap);
+#endif //R__VA_COPY
+
+  // take the first argument from the list as format string if no
+  // format was given
+  const char* fmt = format;
+  if (fmt==NULL) fmt=va_arg(ap, const char*);
+
+  fgAliHLTLoggingTarget[0]=0;
+  while (fmt!=NULL) {
+    iResult=vsnprintf(fgAliHLTLoggingTarget.GetArray(), fgAliHLTLoggingTarget.GetSize(), fmt, ap);
+    if (iResult==-1)
+      // for compatibility with older version of vsnprintf
+      iResult=fgAliHLTLoggingTarget.GetSize()*2;
+    else if (iResult<fgAliHLTLoggingTarget.GetSize())
+      break;
+
+    // terminate if buffer is already at the limit
+    if (fgAliHLTLoggingTarget.GetSize()>=fgkALIHLTLOGGINGMAXBUFFERSIZE) 
+    {
+      fgAliHLTLoggingTarget[fgAliHLTLoggingTarget.GetSize()-1]=0;
+      break;
     }
-  }
-  return gAliHLTLoggingBuffer;
+
+    // check limitation and grow the buffer
+    if (iResult>fgkALIHLTLOGGINGMAXBUFFERSIZE) iResult=fgkALIHLTLOGGINGMAXBUFFERSIZE;
+    fgAliHLTLoggingTarget.Set(iResult+1);
+
+    // copy the original list and skip the first argument if this was the format string
+#ifdef R__VA_COPY
+    va_end(ap);
+    R__VA_COPY(ap, bap);
+#else
+    fgAliHLTLoggingTarget[fgAliHLTLoggingTarget.GetSize()-1]=0;
+    break;
+#endif //R__VA_COPY
+    if (format==NULL) va_arg(ap, const char*);
+  }     
+#ifdef R__VA_COPY
+  va_end(bap);
+#endif //R__VA_COPY
+
+  return fgAliHLTLoggingTarget.GetArray();
 }
 
-int AliHLTLogging::Logging(AliHLTComponent_LogSeverity severity, const char* origin, const char* keyword, const char* format, ... ) {
+int AliHLTLogging::Logging(AliHLTComponentLogSeverity severity,
+			   const char* origin, const char* keyword,
+			   const char* format, ... ) 
+{
+  // see header file for class documentation
   int iResult=CheckFilter(severity);
   if (iResult>0) {
     va_list args;
     va_start(args, format);
-    if (fLoggingFunc) {
-      iResult = (*fLoggingFunc)(NULL/*fParam*/, severity, origin, keyword, AliHLTLogging::BuildLogString(format, args ));
+    if (fgLoggingFunc) {
+      iResult = (*fgLoggingFunc)(NULL/*fParam*/, severity, origin, keyword, AliHLTLogging::BuildLogString(format, args ));
     } else {
-      iResult = Message(NULL/*fParam*/, severity, origin, keyword, AliHLTLogging::BuildLogString(format, args ));
+      if (fgUseAliLog!=0 && fgAliLoggingFunc!=NULL)
+	iResult=(*fgAliLoggingFunc)(severity, NULL, origin, NULL, 0, AliHLTLogging::BuildLogString(format, args ));
+      else
+        iResult=Message(NULL/*fParam*/, severity, origin, keyword, AliHLTLogging::BuildLogString(format, args ));
     }
+    va_end(args);
   }
   return iResult;
 }
 
-int AliHLTLogging::LoggingVarargs( AliHLTComponent_LogSeverity severity, const char* origin_class, const char* origin_func,  ... ) const
+int AliHLTLogging::LoggingVarargs(AliHLTComponentLogSeverity severity, 
+				  const char* originClass, const char* originFunc,
+				  const char* file, int line,  ... ) const
 {
-  int iResult=CheckFilter(severity);
+  // see header file for class documentation
+
+  if (file==NULL && line==0) {
+    // this is currently just to get rid of the warning "unused parameter"
+  }
+  int iResult=1; //CheckFilter(severity); // check moved to makro
   if (iResult>0) {
-    int iMaxSize=LOG_BUFFER_SIZE-1;
-    int iPos=0;
     const char* separator="";
-    gAliHLTLoggingOriginBuffer[iPos]=0;
-    if (origin_class) {
-      if ((int)strlen(origin_class)<iMaxSize-iPos) {
-	strcpy(&gAliHLTLoggingOriginBuffer[iPos], origin_class);
-	iPos+=strlen(origin_class);
+    TString origin;
+    if (originClass) {
+	origin+=originClass;
 	separator="::";
-      }
     }
-    if (origin_func) {
-      if ((int)strlen(origin_func)+(int)strlen(separator)<iMaxSize-iPos) {
-	strcpy(&gAliHLTLoggingOriginBuffer[iPos], separator);
-	iPos+=strlen(separator);
-	strcpy(&gAliHLTLoggingOriginBuffer[iPos], origin_func);
-	iPos+=strlen(origin_func);
-      }
+    if (originFunc) {
+	origin+=separator;
+	origin+=originFunc;
     }
     va_list args;
-    va_start(args, origin_func);
-    const char* format = va_arg(args, const char*);
+    va_start(args, line);
 
-    const char* message=format;
-    char* qualifier=NULL;
-    if ((qualifier=strchr(format, '%'))!=NULL) {
-      message=AliHLTLogging::BuildLogString(format, args);
-    }
-    if (fLoggingFunc) {
-      iResult=(*fLoggingFunc)(NULL/*fParam*/, severity, gAliHLTLoggingOriginBuffer, GetKeyword(), message);
+    if (fgLoggingFunc) {
+      iResult=(*fgLoggingFunc)(NULL/*fParam*/, severity, origin.Data(), GetKeyword(), AliHLTLogging::BuildLogString(NULL, args ));
     } else {
-      iResult=Message(NULL/*fParam*/, severity, gAliHLTLoggingOriginBuffer, GetKeyword(), message);
+      if (fgUseAliLog!=0 && fgAliLoggingFunc!=NULL)
+	iResult=(*fgAliLoggingFunc)(severity, originClass, originFunc, file, line, AliHLTLogging::BuildLogString(NULL, args ));
+      else
+	iResult=Message(NULL/*fParam*/, severity, origin.Data(), GetKeyword(), AliHLTLogging::BuildLogString(NULL, args ));
     }
     va_end(args);
   }
   return iResult;
 }
 
-int AliHLTLogging::CheckFilter(AliHLTComponent_LogSeverity severity) const
+int AliHLTLogging::CheckFilter(AliHLTComponentLogSeverity severity) const
 {
-  int iResult=severity==kHLTLogNone || (severity&fGlobalLogFilter)>0 && (severity&fLocalLogFilter)>0;
+  // see header file for class documentation
+
+  int iResult=severity==kHLTLogNone || (severity&fgGlobalLogFilter)>0 && (severity&fLocalLogFilter)>0;
   return iResult;
 }
+
+void AliHLTLogging::SetGlobalLoggingLevel(AliHLTComponentLogSeverity level)
+{
+  // see header file for class documentation
+
+  fgGlobalLogFilter=level;
+}
+
+AliHLTComponentLogSeverity AliHLTLogging::GetGlobalLoggingLevel()
+{
+  // see header file for class documentation
+
+  return fgGlobalLogFilter;
+}
+
+void AliHLTLogging::SetLocalLoggingLevel(AliHLTComponentLogSeverity level)
+{
+  // see header file for class documentation
+
+  fLocalLogFilter=level;
+}
+
+
+AliHLTComponentLogSeverity AliHLTLogging::GetLocalLoggingLevel()
+{
+  // see header file for class documentation
+
+  return fLocalLogFilter;
+}
+
+int AliHLTLogging::CheckGroup(const char* /*originClass*/) const
+{
+  // see header file for class documentation
+
+  return 1;
+}
+
+int AliHLTLogging::SetBlackList(const char* classnames)
+{
+  // see header file for class documentation
+
+  if (classnames)
+    fgBlackList=classnames;
+  return 0;
+}
+
+int AliHLTLogging::SetWhiteList(const char* classnames)
+{
+  // see header file for class documentation
+
+  if (classnames)
+    fgWhiteList=classnames;
+  return 0;
+}