GaudiException.h

Go to the documentation of this file.

#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( std::string Message,
                  std::string Tag,
                  StatusCode  Code )
    : m_message    ( std::move(Message)   )
    , m_tag        ( std::move(Tag)       )
    , m_code       ( std::move(Code)      )
    { s_proc = true; }

  GaudiException( std::string     Message    ,
                  std::string     Tag        ,
                  StatusCode      Code       ,
                  const GaudiException&  Exception  )
    : m_message    ( std::move(Message)            )
    , m_tag        ( std::move(Tag)                )
    , m_code       ( std::move(Code)               )
    , m_previous   ( Exception.clone()  )
    {}

  GaudiException( std::string     Message    ,
                  std::string     Tag        ,
                  StatusCode      Code       ,
                  const std::exception&  Exception  )
    : m_message    ( std::move(Message)   )
    , m_tag        ( std::move(Tag)       )
    , m_code       ( std::move(Code)      )
    {
      s_proc = true;
      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{  Exception.previous() ? Exception.previous()->clone() : nullptr }
  {
    s_proc     = true;
  }

  virtual ~GaudiException() throw() {
    m_code.setChecked();
    s_proc = false;
  }

  GaudiException& operator=( const GaudiException& Exception ) {
    m_message  =   Exception.message() ;
    m_tag      =   Exception.tag    () ;
    m_code     =   Exception.code   () ;
    m_previous.reset( Exception.previous() ? Exception.previous()->clone() : nullptr );
    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.get() ; }

  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 std::unique_ptr<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