Line data    Source code

       1             : //-*- Mode: C++ -*-
       2             : // $Id$
       3             : 
       4             : #ifndef ALIHLTERRORGUARD_H
       5             : #define ALIHLTERRORGUARD_H
       6             : //* This file is property of and copyright by the ALICE HLT Project        * 
       7             : //* ALICE Experiment at CERN, All rights reserved.                         *
       8             : //* See cxx source for full Copyright notice                               *
       9             : 
      10             : /// @file   AliHLTErrorGuard.h
      11             : /// @author Matthias Richter
      12             : /// @date   01.07.2010
      13             : /// @brief  Helper class for suppression of error floods.
      14             : 
      15             : #include "AliHLTLogging.h"
      16             : #include "TString.h"
      17             : #include "Varargs.h"
      18             : 
      19             : /**
      20             :  * @class AliHLTErrorGuard
      21             :  * Helper class for suppression of error message floods caused by error messages
      22             :  * occurring rather frequently, e.g. for every event. The class suppresses the
      23             :  * printout after an adjustable number of occurences and prints an error summary
      24             :  * when the instance gets out of scope.
      25             :  *
      26             :  * Examples:
      27             :  * <pre>
      28             :  * if (nastyerror) {
      29             :  *   ALIHLTERRORGUARD(5, "nasty error, first occurence in event %d", event);
      30             :  * }
      31             :  * </pre>
      32             :  * <pre>
      33             :  * if (nastyerror) {
      34             :  *   static AliHLTErrorGuard g("classname", "functionname", "message");
      35             :  *   (++g).Throw(5);
      36             :  * }
      37             :  * </pre>
      38             :  * Both examples will throw the error for the first 5 occurrences. The macro
      39             :  * ALIHLTERRORGUARD handles also class and function name, source file and line
      40             :  * number, and supports variable messages through variadic macros.
      41             :  *
      42             :  * The second example illustrates usage of the class directly. The 'static'
      43             :  * attribute causes the object not to be destroyed at run time, only when the
      44             :  * program is terminated the object is deleted. This will print the error summary
      45             :  * at the very end of the program execution.
      46             :  *
      47             :  * @ingroup alihlt_base
      48             :  */
      49             : class AliHLTErrorGuard : public AliHLTLogging {
      50             :  public:
      51             :   /// constructor
      52           0 :  AliHLTErrorGuard(const char* classname, const char* functionname, const char* message, const char* file=NULL, int line=0)
      53           0 :    : fClass(classname), fFunction(functionname), fFile(file?file:""), fMessage(message), fLine(line), fOccurrence(0) {}
      54             : 
      55             :   /// set variable message
      56             :   void SetMessage( int dummy, ... )
      57             :   {
      58           0 :     va_list args;
      59           0 :     va_start(args, dummy);
      60           0 :     fMessage=AliHLTLogging::BuildLogString(NULL, args );
      61           0 :     va_end(args);
      62           0 :   }
      63             : 
      64             :   /// destructor
      65           0 :   virtual ~AliHLTErrorGuard() {
      66           0 :     Throw(-1, "Postponed message: %s - %d time(s)");
      67           0 :   }
      68             : 
      69             :   /// prefix increment operator
      70           0 :   AliHLTErrorGuard& operator++() {fOccurrence++; return *this;}
      71             : 
      72           0 :   int GetOccurrence() const {return fOccurrence;}
      73             : 
      74             :   void Throw(int maxoccurrence=1, const char* format="%s") {
      75           0 :     if (fOccurrence<=maxoccurrence || maxoccurrence<0) 
      76           0 :       LoggingVarargs(kHLTLogError, fClass.Data(), fFunction.Data(), fFile.Data(), fLine, format, fMessage.Data(), GetOccurrence());
      77           0 :   }
      78             : 
      79             :  protected:
      80             : 
      81             :  private:
      82             :   /** standard constructor prohibited */
      83             :   AliHLTErrorGuard();
      84             :   /** copy constructor prohibited */
      85             :   AliHLTErrorGuard(const AliHLTErrorGuard&);
      86             :   /** assignment operator prohibited */
      87             :   AliHLTErrorGuard& operator=(const AliHLTErrorGuard&);
      88             : 
      89             :   TString fClass; //! transient
      90             :   TString fFunction; //! transient
      91             :   TString fFile; //! transient
      92             :   TString fMessage; //! transient
      93             :   int fLine; //!transient
      94             :   int fOccurrence; //!transient
      95             : 
      96         126 :   ClassDef(AliHLTErrorGuard, 0)
      97             : };
      98             : 
      99             : #define ALIHLTERRORGUARD( max, ... )  {                                                \
     100             :     static AliHLTErrorGuard g(Class_Name() , FUNCTIONNAME() , "", __FILE__, __LINE__); \
     101             :   if (g.GetOccurrence()==0) g.SetMessage( 0, __VA_ARGS__ );                            \
     102             :   (++g).Throw(max);                                                                    \
     103             : }
     104             : 
     105             : #endif