[u/mrichter/AliRoot.git] / HLT / BASE / AliHLTLogging.cxx

// @(#) $Id$

/**************************************************************************
 * This file is property of and copyright by the ALICE HLT Project        * 
 * ALICE Experiment at CERN, All rights reserved.                         *
 *                                                                        *
 * 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   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/** @file   AliHLTLogging.cxx
    @author Matthias Richter, Timm Steinbeck
    @date   
    @brief  Implementation of HLT logging primitives.
*/

#if __GNUC__>= 3
using namespace std;
#endif

#include "AliHLTStdIncludes.h"
#include "AliHLTLogging.h"
#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);

AliHLTLogging::AliHLTLogging()
  :
  //fLocalLogFilter(kHLTLogDefault),
  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)
{
  // 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;
}

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) 
{
  // see header file for class documentation
  if (fgLoggingFunc!=NULL && fgLoggingFunc!=pFun) {
    (*fgLoggingFunc)(NULL/*fParam*/, kHLTLogWarning, "AliHLTLogging::Init", "no key", "overriding previously initialized logging function");    
  }
  fgLoggingFunc=pFun;
  
  return 0;
}

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: 
    strSeverity="benchmark";
    break;
  case kHLTLogDebug:
    strSeverity="debug";
    break;
  case kHLTLogInfo:
    strSeverity="info";
    break;
  case kHLTLogWarning:
    strSeverity="warning";
    break;
  case kHLTLogError:
    strSeverity="error";
    break;
  case kHLTLogFatal:
    strSeverity="fatal";
    break;
  case kHLTLogImportant:
    strSeverity="notify";
    break;
  default:
    break;
  }
  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;
}

#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

  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

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;
    }

    // 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(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 (fgLoggingFunc) {
      iResult = (*fgLoggingFunc)(NULL/*fParam*/, severity, origin, keyword, AliHLTLogging::BuildLogString(format, args ));
    } else {
      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(AliHLTComponentLogSeverity severity, 
				  const char* originClass, const char* originFunc,
				  const char* file, int line,  ... ) const
{
  // 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) {
    const char* separator="";
    TString origin;
    if (originClass) {
	origin+=originClass;
	separator="::";
    }
    if (originFunc) {
	origin+=separator;
	origin+=originFunc;
    }
    va_list args;
    va_start(args, line);

    if (fgLoggingFunc) {
      iResult=(*fgLoggingFunc)(NULL/*fParam*/, severity, origin.Data(), GetKeyword(), AliHLTLogging::BuildLogString(NULL, args ));
    } else {
      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(AliHLTComponentLogSeverity severity) const
{
  // 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;
}
Commit	Line	Data
	1	// @(#) $Id$
	2
	3	/**************************************************************************
	4	* This file is property of and copyright by the ALICE HLT Project *
	5	* ALICE Experiment at CERN, All rights reserved. *
	6	* *
	7	* Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no> *
	8	* for The ALICE HLT 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	#include "AliHLTComponentHandler.h"
	32	#include "TString.h"
	33	#include "Varargs.h"
	34	#include <string>
	35	#include <sstream>
	36	#include <iostream>
	37
	38	/** ROOT macro for the implementation of ROOT specific class methods */
	39	ClassImp(AliHLTLogging);
	40
	41	AliHLTLogging::AliHLTLogging()
	42	:
	43	//fLocalLogFilter(kHLTLogDefault),
	44	fLocalLogFilter(kHLTLogAll),
	45	fpDefaultKeyword(NULL),
	46	fpCurrentKeyword(NULL)
	47	{
	48	// see header file for class documentation
	49	// or
	50	// refer to README to build package
	51	// or
	52	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
	53	}
	54
	55	AliHLTLogging::AliHLTLogging(const AliHLTLogging&)
	56	:
	57	fLocalLogFilter(kHLTLogAll),
	58	fpDefaultKeyword(NULL),
	59	fpCurrentKeyword(NULL)
	60	{
	61	// see header file for class documentation
	62	HLTFatal("copy constructor untested");
	63	}
	64
	65	AliHLTLogging& AliHLTLogging::operator=(const AliHLTLogging&)
	66	{
	67	// see header file for class documentation
	68	HLTFatal("assignment operator untested");
	69	return *this;
	70	}
	71
	72	ostringstream AliHLTLogging::fgLogstr;
	73	AliHLTComponentLogSeverity AliHLTLogging::fgGlobalLogFilter=kHLTLogAll;
	74	AliHLTfctLogging AliHLTLogging::fgLoggingFunc=NULL;
	75	AliHLTLogging::AliHLTDynamicMessage AliHLTLogging::fgAliLoggingFunc=NULL;
	76	int AliHLTLogging::fgUseAliLog=1;
	77
	78	TString AliHLTLogging::fgBlackList="";
	79	TString AliHLTLogging::fgWhiteList="";
	80
	81	AliHLTLogging::~AliHLTLogging()
	82	{
	83	// see header file for class documentation
	84	}
	85
	86	// the array will be grown dynamically, this is just an initial size
	87	TArrayC AliHLTLogging::fgAliHLTLoggingTarget(200);
	88	// the maximum size of the array
	89	const int AliHLTLogging::fgkALIHLTLOGGINGMAXBUFFERSIZE=10000;
	90
	91	int AliHLTLogging::Init(AliHLTfctLogging pFun)
	92	{
	93	// see header file for class documentation
	94	if (fgLoggingFunc!=NULL && fgLoggingFunc!=pFun) {
	95	(fgLoggingFunc)(NULL/fParam*/, kHLTLogWarning, "AliHLTLogging::Init", "no key", "overriding previously initialized logging function");
	96	}
	97	fgLoggingFunc=pFun;
	98
	99	return 0;
	100	}
	101
	102	int AliHLTLogging::InitAliLogTrap(AliHLTComponentHandler* pHandler)
	103	{
	104	// see header file for class documentation
	105	// init the AliRoot logging trap
	106	// AliLog messages are redirected to PubSub,
	107	int iResult=0;
	108	if (pHandler) {
	109	// set temporary loglevel of component handler
	110	AliHLTComponentLogSeverity loglevel=pHandler->GetLocalLoggingLevel();
	111	pHandler->SetLocalLoggingLevel(kHLTLogError);
	112
	113	// load library containing AliRoot dependencies and initialization handler
	114	pHandler->LoadLibrary(ALILOG_WRAPPER_LIBRARY, 0/* do not activate agents */);
	115
	116	// restore loglevel
	117	pHandler->SetLocalLoggingLevel(loglevel);
	118
	119	// find the symbol
	120	InitAliDynamicMessageCallback pFunc=(InitAliDynamicMessageCallback)pHandler->FindSymbol(ALILOG_WRAPPER_LIBRARY, "InitAliDynamicMessageCallback");
	121	if (pFunc) {
	122	iResult=(*pFunc)();
	123	} else {
	124	Message(NULL, kHLTLogError, "AliHLTLogging::InitAliLogTrap", "init logging",
	125	"can not initialize AliLog callback");
	126	iResult=-ENOSYS;
	127	}
	128	} else {
	129	iResult=-EINVAL;
	130	}
	131
	132	return iResult;
	133	}
	134
	135	int AliHLTLogging::InitAliLogFunc(AliHLTComponentHandler* pHandler)
	136	{
	137	// see header file for class documentation
	138	int iResult=0;
	139	if (pHandler) {
	140	// set temporary loglevel of component handler
	141	AliHLTComponentLogSeverity loglevel=pHandler->GetLocalLoggingLevel();
	142	pHandler->SetLocalLoggingLevel(kHLTLogError);
	143
	144	// load library containing AliRoot dependencies and initialization handler
	145	pHandler->LoadLibrary(ALILOG_WRAPPER_LIBRARY, 0/* do not activate agents */);
	146
	147	// restore loglevel
	148	pHandler->SetLocalLoggingLevel(loglevel);
	149
	150	// find the symbol
	151	fgAliLoggingFunc=(AliHLTLogging::AliHLTDynamicMessage)pHandler->FindSymbol(ALILOG_WRAPPER_LIBRARY, "AliDynamicMessage");
	152	if (fgAliLoggingFunc==NULL) {
	153	Message(NULL, kHLTLogError, "AliHLTLogging::InitAliLogFunc", "init logging",
	154	"symbol lookp failure: can not find AliDynamicMessage, switching to HLT logging system");
	155	iResult=-ENOSYS;
	156	}
	157	} else {
	158	iResult=-EINVAL;
	159	}
	160
	161	return iResult;
	162	}
	163
	164	int AliHLTLogging::Message(void *param, AliHLTComponentLogSeverity severity,
	165	const char* origin, const char* keyword,
	166	const char* message)
	167	{
	168	// see header file for class documentation
	169	int iResult=0;
	170	if (param==NULL) {
	171	// this is currently just to get rid of the warning "unused parameter"
	172	}
	173
	174	const char* strSeverity="";
	175	switch (severity) {
	176	case kHLTLogBenchmark:
	177	strSeverity="benchmark";
	178	break;
	179	case kHLTLogDebug:
	180	strSeverity="debug";
	181	break;
	182	case kHLTLogInfo:
	183	strSeverity="info";
	184	break;
	185	case kHLTLogWarning:
	186	strSeverity="warning";
	187	break;
	188	case kHLTLogError:
	189	strSeverity="error";
	190	break;
	191	case kHLTLogFatal:
	192	strSeverity="fatal";
	193	break;
	194	case kHLTLogImportant:
	195	strSeverity="notify";
	196	break;
	197	default:
	198	break;
	199	}
	200	TString out="HLT Log ";
	201	out+=strSeverity;
	202	if (origin && origin[0]!=0) {out+=": <"; out+=origin; out+="> ";}
	203	out+=" "; out+=message;
	204	if (keyword!=NULL && strcmp(keyword, HLT_DEFAULT_LOG_KEYWORD)!=0) {
	205	out+=" ("; out+=keyword; out +=")";
	206	}
	207	cout << out.Data() << endl;
	208	return iResult;
	209	}
	210
	211	#if 0
	212	int AliHLTLogging::AliMessage(AliHLTComponentLogSeverity severity,
	213	const char* originClass, const char* originFunc,
	214	const char* file, int line, const char* message)
	215	{
	216	// see header file for class documentation
	217
	218	switch (severity) {
	219	case kHLTLogBenchmark:
	220	AliLog::Message(AliLog::kInfo, message, "HLT", originClass, originFunc, file, line);
	221	break;
	222	case kHLTLogDebug:
	223	AliLog::Message(AliLog::kDebug, message, "HLT", originClass, originFunc, file, line);
	224	break;
	225	case kHLTLogInfo:
	226	AliLog::Message(AliLog::kInfo, message, "HLT", originClass, originFunc, file, line);
	227	break;
	228	case kHLTLogWarning:
	229	AliLog::Message(AliLog::kWarning, message, "HLT", originClass, originFunc, file, line);
	230	break;
	231	case kHLTLogError:
	232	AliLog::Message(AliLog::kError, message, "HLT", originClass, originFunc, file, line);
	233	break;
	234	case kHLTLogFatal:
	235	AliLog::Message(AliLog::kWarning, message, "HLT", originClass, originFunc, file, line);
	236	break;
	237	default:
	238	break;
	239	}
	240	return 0;
	241	}
	242	#endif
	243
	244	const char* AliHLTLogging::BuildLogString(const char *format, va_list ap)
	245	{
	246	// see header file for class documentation
	247
	248	int iResult=0;
	249	#ifdef R__VA_COPY
	250	va_list bap;
	251	R__VA_COPY(bap, ap);
	252	#endif //R__VA_COPY
	253
	254	// take the first argument from the list as format string if no
	255	// format was given
	256	const char* fmt = format;
	257	if (fmt==NULL) fmt=va_arg(ap, const char*);
	258
	259	fgAliHLTLoggingTarget[0]=0;
	260	while (fmt!=NULL) {
	261	iResult=vsnprintf(fgAliHLTLoggingTarget.GetArray(), fgAliHLTLoggingTarget.GetSize(), fmt, ap);
	262	if (iResult==-1)
	263	// for compatibility with older version of vsnprintf
	264	iResult=fgAliHLTLoggingTarget.GetSize()*2;
	265	else if (iResult<fgAliHLTLoggingTarget.GetSize())
	266	break;
	267
	268	// terminate if buffer is already at the limit
	269	if (fgAliHLTLoggingTarget.GetSize()>=fgkALIHLTLOGGINGMAXBUFFERSIZE)
	270	{
	271	fgAliHLTLoggingTarget[fgAliHLTLoggingTarget.GetSize()-1]=0;
	272	break;
	273	}
	274
	275	// check limitation and grow the buffer
	276	if (iResult>fgkALIHLTLOGGINGMAXBUFFERSIZE) iResult=fgkALIHLTLOGGINGMAXBUFFERSIZE;
	277	fgAliHLTLoggingTarget.Set(iResult+1);
	278
	279	// copy the original list and skip the first argument if this was the format string
	280	#ifdef R__VA_COPY
	281	va_end(ap);
	282	R__VA_COPY(ap, bap);
	283	#else
	284	fgAliHLTLoggingTarget[fgAliHLTLoggingTarget.GetSize()-1]=0;
	285	break;
	286	#endif //R__VA_COPY
	287	if (format==NULL) va_arg(ap, const char*);
	288	}
	289	#ifdef R__VA_COPY
	290	va_end(bap);
	291	#endif //R__VA_COPY
	292
	293	return fgAliHLTLoggingTarget.GetArray();
	294	}
	295
	296	int AliHLTLogging::Logging(AliHLTComponentLogSeverity severity,
	297	const char* origin, const char* keyword,
	298	const char* format, ... )
	299	{
	300	// see header file for class documentation
	301	int iResult=CheckFilter(severity);
	302	if (iResult>0) {
	303	va_list args;
	304	va_start(args, format);
	305	if (fgLoggingFunc) {
	306	iResult = (fgLoggingFunc)(NULL/fParam*/, severity, origin, keyword, AliHLTLogging::BuildLogString(format, args ));
	307	} else {
	308	if (fgUseAliLog!=0 && fgAliLoggingFunc!=NULL)
	309	iResult=(*fgAliLoggingFunc)(severity, NULL, origin, NULL, 0, AliHLTLogging::BuildLogString(format, args ));
	310	else
	311	iResult=Message(NULL/fParam/, severity, origin, keyword, AliHLTLogging::BuildLogString(format, args ));
	312	}
	313	va_end(args);
	314	}
	315	return iResult;
	316	}
	317
	318	int AliHLTLogging::LoggingVarargs(AliHLTComponentLogSeverity severity,
	319	const char* originClass, const char* originFunc,
	320	const char* file, int line, ... ) const
	321	{
	322	// see header file for class documentation
	323
	324	if (file==NULL && line==0) {
	325	// this is currently just to get rid of the warning "unused parameter"
	326	}
	327	int iResult=1; //CheckFilter(severity); // check moved to makro
	328	if (iResult>0) {
	329	const char* separator="";
	330	TString origin;
	331	if (originClass) {
	332	origin+=originClass;
	333	separator="::";
	334	}
	335	if (originFunc) {
	336	origin+=separator;
	337	origin+=originFunc;
	338	}
	339	va_list args;
	340	va_start(args, line);
	341
	342	if (fgLoggingFunc) {
	343	iResult=(fgLoggingFunc)(NULL/fParam*/, severity, origin.Data(), GetKeyword(), AliHLTLogging::BuildLogString(NULL, args ));
	344	} else {
	345	if (fgUseAliLog!=0 && fgAliLoggingFunc!=NULL)
	346	iResult=(*fgAliLoggingFunc)(severity, originClass, originFunc, file, line, AliHLTLogging::BuildLogString(NULL, args ));
	347	else
	348	iResult=Message(NULL/fParam/, severity, origin.Data(), GetKeyword(), AliHLTLogging::BuildLogString(NULL, args ));
	349	}
	350	va_end(args);
	351	}
	352	return iResult;
	353	}
	354
	355	int AliHLTLogging::CheckFilter(AliHLTComponentLogSeverity severity) const
	356	{
	357	// see header file for class documentation
	358
	359	int iResult=severity==kHLTLogNone \|\| (severity&fgGlobalLogFilter)>0 && (severity&fLocalLogFilter)>0;
	360	return iResult;
	361	}
	362
	363	void AliHLTLogging::SetGlobalLoggingLevel(AliHLTComponentLogSeverity level)
	364	{
	365	// see header file for class documentation
	366
	367	fgGlobalLogFilter=level;
	368	}
	369
	370	AliHLTComponentLogSeverity AliHLTLogging::GetGlobalLoggingLevel()
	371	{
	372	// see header file for class documentation
	373
	374	return fgGlobalLogFilter;
	375	}
	376
	377	void AliHLTLogging::SetLocalLoggingLevel(AliHLTComponentLogSeverity level)
	378	{
	379	// see header file for class documentation
	380
	381	fLocalLogFilter=level;
	382	}
	383
	384
	385	AliHLTComponentLogSeverity AliHLTLogging::GetLocalLoggingLevel()
	386	{
	387	// see header file for class documentation
	388
	389	return fLocalLogFilter;
	390	}
	391
	392	int AliHLTLogging::CheckGroup(const char* /originClass/) const
	393	{
	394	// see header file for class documentation
	395
	396	return 1;
	397	}
	398
	399	int AliHLTLogging::SetBlackList(const char* classnames)
	400	{
	401	// see header file for class documentation
	402
	403	if (classnames)
	404	fgBlackList=classnames;
	405	return 0;
	406	}
	407
	408	int AliHLTLogging::SetWhiteList(const char* classnames)
	409	{
	410	// see header file for class documentation
	411
	412	if (classnames)
	413	fgWhiteList=classnames;
	414	return 0;
	415	}