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 GAUDI_API 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 ) ;
  friend class StatusCode;

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      )
    { s_proc = true; }

  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      )
    {
      s_proc = true;
      m_message += ": " + System::typeinfoName(typeid(Exception)) + ", " +
                   Exception.what();
    }

  GaudiException( const GaudiException& Exception ) : std::exception(Exception)
  {
    s_proc     = true;
    m_message  =   Exception.message() ;
    m_tag      =   Exception.tag    () ;
    m_code     =   Exception.code   () ;
    m_previous = ( 0 == Exception.previous() ) ?
      0 : Exception.previous()->clone() ;
  }

  virtual ~GaudiException() throw() {
    m_code.setChecked();
    if( 0 != m_previous ) { delete m_previous ; m_previous = 0 ; }
    s_proc = false;
  }

  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 << endmsg ) : 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;  
  static bool             s_proc;
};

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