GaudiException.h

Go to the documentation of this file.

// $Id: GaudiException.h,v 1.6 2007/12/20 18:28:33 marcocle Exp $
#ifndef GAUDIKERNEL_GAUDIEXCEPTION_H
#define GAUDIKERNEL_GAUDIEXCEPTION_H

// Include files
#include "GaudiKernel/Kernel.h"
#include "GaudiKernel/StatusCode.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/System.h"

#include <string> 
#include <iostream> 
#include <exception> 


class GaudiException : virtual public std::exception  {
  // friends 
  friend inline std::ostream& operator<< ( std::ostream& os ,
                                           const GaudiException&   ge ) ;
  friend inline std::ostream& operator<< ( std::ostream& os ,
                                           const GaudiException*  pge ) ;   
  friend inline MsgStream&    operator<< ( MsgStream&    os ,
                                           const GaudiException&   ge ) ; 
  friend inline MsgStream&    operator<< ( MsgStream&    os ,
                                           const GaudiException*  pge ) ; 
  
public: 
  GaudiException( const std::string& Message, 
                  const std::string& Tag, 
                  const StatusCode & Code ) 
    : m_message    ( Message    ) 
    , m_tag        ( Tag        )  
    , m_code       ( Code       ) 
    , m_previous   (     0      ) 
    {}
  
  GaudiException( const std::string&     Message    , 
                  const std::string&     Tag        , 
                  const StatusCode &     Code       , 
                  const GaudiException&  Exception  )
    : m_message    ( Message            ) 
    , m_tag        ( Tag                )  
    , m_code       ( Code               ) 
    , m_previous   ( Exception.clone()  ) 
    {}
  
  GaudiException( const std::string&     Message    , 
                  const std::string&     Tag        , 
                  const StatusCode &     Code       , 
                  const std::exception&  Exception  )
    : m_message    ( Message    ) 
    , m_tag        ( Tag        )  
    , m_code       ( Code       ) 
    , m_previous   (     0      ) 
    {
      m_message += ": " + System::typeinfoName(typeid(Exception)) + ", " +
                   Exception.what();
    } 
    
  GaudiException( const GaudiException& Exception ) : std::exception(Exception)
  {
    m_message  =   Exception.message() ;  
    m_tag      =   Exception.tag    () ;     
    m_code     =   Exception.code   () ; 
    m_previous = ( 0 == Exception.previous() ) ?
      0 : Exception.previous()->clone() ; 
  }  

  virtual ~GaudiException() throw() {
    if( 0 != m_previous ) { delete m_previous ; m_previous = 0 ; }
  } 
  
  GaudiException& operator=( const GaudiException& Exception ) {
    if ( &Exception == this ) { return *this; } 
    m_message  =   Exception.message() ;  
    m_tag      =   Exception.tag    () ;     
    m_code     =   Exception.code   () ; 
    if( 0 != m_previous ) { delete m_previous; m_previous = 0 ; } 
    m_previous = ( 0 == Exception.previous() ) ?
      0 : Exception.previous()->clone() ; 
    return *this; 
  }

  virtual const std::string&    message   () const { return m_message; }  
  
  virtual const std::string&    setMessage( const std::string& newMessage ) {
    m_message = newMessage; return message() ;
  }  
  
  virtual const std::string&    tag       () const { return m_tag; }  
  
  virtual const std::string&    setTag    ( const std::string& newTag     ) {
    m_tag = newTag ; return tag() ;
  }
  
  virtual const StatusCode&     code      () const { return m_code; }  
  
  virtual const StatusCode&     setCode   ( const StatusCode& newStatus  ) {
    m_code = newStatus; return code() ;
  } 
  
  virtual GaudiException*       previous  () const { return m_previous ; } 
  
  virtual std::ostream& printOut  ( std::ostream& os = std::cerr ) const {
    os << tag() << " \t " << message() ; 
    switch( code() ) {
      case StatusCode::SUCCESS : os << "\t StatusCode=SUCCESS"    ;  break ; 
      case StatusCode::FAILURE : os << "\t StatusCode=FAILURE"    ;  break ; 
      default                  : os << "\t StatusCode=" << code() ;  break ; 
    }
    return ( 0 != previous() ) ? previous()->printOut( os << std::endl ) : os ;
  }; 
  
  virtual MsgStream& printOut ( MsgStream& os ) const {
    os << tag() << "\t" << message() ; 
    switch( code() ) {
            case StatusCode::SUCCESS : os << "\t StatusCode=SUCCESS"    ;  break ; 
            case StatusCode::FAILURE : os << "\t StatusCode=FAILURE"    ;  break ; 
            default                  : os << "\t StatusCode=" << code().getCode() ;  break ; 
    }
    return ( 0 != previous() ) ? previous()->printOut( os << endreq ) : os ;   
  }
  
  virtual GaudiException* clone() const { return new GaudiException(*this); }; 
  
  virtual const char* what () const throw() { return message().c_str() ; }  
protected:
  mutable std::string     m_message ;  
  mutable std::string     m_tag     ;  
  mutable StatusCode      m_code    ;  
  mutable GaudiException* m_previous;  
};

std::ostream& operator<< ( std::ostream& os , const GaudiException&   ge ) {
  return ge.printOut( os );
} 
std::ostream& operator<< ( std::ostream& os , const GaudiException*  pge ) 
{ return (0 == pge) ?
    ( os << " GaudiException* points to NULL!" ) : ( os << *pge ); } 

MsgStream&    operator<< ( MsgStream& os    , const GaudiException&   ge ) { 
  return ge.printOut( os ); 
} 
MsgStream&    operator<< ( MsgStream& os    , const GaudiException*  pge ) { 
  return (0 == pge) ?
    ( os << " GaudiException* points to NULL!" ) : ( os << *pge );
} 

#endif  // GAUDIKERNEL_GAUDIEXCEPTION_H