Except::Base Class Reference

#include <AlcapExcept.h>

Inheritance diagram for Except::Base:

List of all members.

Public Member Functions
	Base ()
virtual	~Base () throw ()
const char *	what (void) const throw ()
const char *	bt (void) const throw ()
void	AppendWhat (const char *child)
void	AppendWhat (const char *child, const char *message)
void	AppendWhat (const char *child, const char *file, int line)
Static Public Attributes
static unsigned int	gBacktraceSymbols = 5
	The number of backtrace symbols to add to the "what" string.
Private Attributes
char	fTrace [2048]
	The backtrace when the exception was thrown;.
char	fWhat [256]
	What exception generated this object.

---

Detailed Description

The root exception for all exceptions explicitly thrown by the AlCap offline analysis code. All exceptions declared by this library should be derived from this class, and not std::exception. New exceptions can be derived from Except::Base by creating a new class

 namespace Exception {
   class Child;
 };

 class Exception::Child : public Except::Base {
 public:
     Child() {AppendWhat("Child");};
 };

But the prefered way to create derived exception classes is to use the MAKE_EXCEPTION macro. This is used as follows

 MAKE_EXCEPTION(Child,Base);
 MAKE_EXCEPTION(GrandChild,Child);
 ...
 try {
   throw Except::Child();
 }
 catch (Except::Base& ex) {
   std::cout << ex.what << std::endl;
 }

This can add a backtrace at the point of the exception. The number of backtrace frames to be shown is controlled with the Except::Base::gBacktraceSymbols static variable.

In addition ther are two variant ways to construct an exception

 // Throw an exception with a debugging message 
 try {
   throw Except::Child("your message here");
 }
  
  // Throw an exception with the source code location
  try {
    throw Except::Child(LOCATION)
  }

LOCATION is an auxillary macro that evaluates as `__FILE__ , __LINE__` this form is not usually needed, as it is usually obvious from the backtrace

Definition at line 63 of file AlcapExcept.h.

---

Constructor & Destructor Documentation

Except::Base::Base

(

)

Definition at line 15 of file AlcapExcept.cpp.

References fTrace, fWhat, and gBacktraceSymbols.

                 {
  fTrace[0] = 0;
  fWhat[0] = 0;
#ifdef _GNU_SOURCE
  if (gBacktraceSymbols>0) {
    const unsigned int bufferSize=100;
    if (gBacktraceSymbols>bufferSize) gBacktraceSymbols = bufferSize;
    void *buffer[bufferSize];
    unsigned int frames = bufferSize;
    if (gBacktraceSymbols<frames) frames = gBacktraceSymbols;
    int nFrames = backtrace(buffer,frames);
    char **symbols = backtrace_symbols(buffer,nFrames);
    if (symbols != NULL) {
      unsigned int len = 0;
      std::strcat(fTrace,"Backtrace:\n");
      for (int i = 0; i<nFrames; ++i) {
        std::string sym(symbols[i]);
        std::string lib;
        std::string::size_type s = sym.find_last_of('/');
        if (s != std::string::npos) sym = sym.substr(s+1);
        s = sym.find_first_of('(');
        if (s != std::string::npos) lib = sym.substr(0,s);
        sym = sym.substr(s+1);
        std::string::size_type t = sym.find_first_of(')');
        if (s != std::string::npos
            && t != std::string::npos) sym = sym.substr(0,t);
        else sym="";
        if (lib.empty() && sym.empty()) continue;
        len += lib.length();
        len += sym.length() + 6;
        if (2*len>sizeof(fTrace)) break;
        std::strcat(fTrace," --> ");
        if (!lib.empty()) std::strcat(fTrace,lib.c_str());
        if (!sym.empty()) {
          std::strcat(fTrace,": ");
          std::strcat(fTrace,sym.c_str());
        }
        std::strcat(fTrace,"\n");
      }
      std::free(symbols);
    }
  }
#endif
  std::strcat(fWhat,"Except::Base");
}

virtual Except::Base::~Base

(

)

throw () [inline, virtual]

Definition at line 74 of file AlcapExcept.h.

{}

---

Member Function Documentation

void Except::Base::AppendWhat	(	const char *	child,
		const char *	file,
		int	line
	)

Used in conjunction with the LOCATION macro, see documentation of Except::Base

Definition at line 81 of file AlcapExcept.cpp.

References AppendWhat(), and fWhat.

                                                                         {
  AppendWhat (child);
  unsigned int wLen = std::strlen(fWhat);
  unsigned int fLen = std::strlen(file);
  if (fLen+wLen < sizeof(fWhat)-16) {
    char buf[16];
    buf[0]=0;
    snprintf(buf,16,":%d)", line);
    std::strcat(fWhat," (");
    std::strcat(fWhat,file);
    std::strcat(fWhat,buf);
  }
}

void Except::Base::AppendWhat	(	const char *	child,
		const char *	message
	)

Used in constructors of classes which inherit from Except::Base to add message text to the What() string.

Definition at line 70 of file AlcapExcept.cpp.

References AppendWhat(), and fWhat.

                                                                  {
  AppendWhat(child);
  unsigned int wLen = std::strlen(fWhat);
  unsigned int mLen = std::strlen(message);
  if (wLen+mLen < sizeof(fWhat)-9) {
    std::strcat(fWhat,"  \"");
    std::strcat(fWhat,message);
    std::strcat(fWhat,"\"");
  }
}

void Except::Base::AppendWhat

(

const char *

child

)

Used in constructors of classes which inherit from Except::Base to add text to the What() string.

Definition at line 61 of file AlcapExcept.cpp.

References fWhat.

Referenced by AppendWhat().

                                             {
  unsigned int wLen = std::strlen(fWhat);
  unsigned int cLen = std::strlen(child);
  if (wLen+cLen < sizeof(fWhat)-5) {
    std::strcat(fWhat,"::");
    std::strcat(fWhat,child);
  }
}

const char* Except::Base::bt

(

void

)

const throw () [inline]

Inherited from exception to return the name of the exception as a null terminated string.

Definition at line 82 of file AlcapExcept.h.

References fTrace.

Referenced by LoopSequence::Run().

{return fTrace;}

const char* Except::Base::what

(

void

)

const throw () [inline]

Inherited from exception to return the name of the exception as a null terminated string.

Definition at line 78 of file AlcapExcept.h.

References fWhat.

Referenced by LoopSequence::Run().

{return fWhat;}

---

Member Data Documentation

char Except::Base::fTrace[2048] [private]

The backtrace when the exception was thrown;.

Definition at line 65 of file AlcapExcept.h.

Referenced by Base(), and bt().

char Except::Base::fWhat[256] [private]

What exception generated this object.

Definition at line 67 of file AlcapExcept.h.

Referenced by AppendWhat(), Base(), and what().

unsigned int Except::Base::gBacktraceSymbols = 5 [static]

The number of backtrace symbols to add to the "what" string.

Definition at line 71 of file AlcapExcept.h.

Referenced by Base().

---

The documentation for this class was generated from the following files:

• rootana/src/framework/AlcapExcept.h
• rootana/src/framework/AlcapExcept.cpp