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/MsgStream.h"
#include "GaudiKernel/StatusCode.h"
#include "GaudiKernel/System.h"

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

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() << "\t StatusCode=" << code();
    return ( 0 != previous() ) ? previous()->printOut( os << std::endl ) : os;
  }

  virtual MsgStream& printOut( MsgStream& os ) const
  {
    os << tag() << " \t " << message() << "\t StatusCode=" << code();
    return ( 0 != previous() ) ? previous()->printOut( os << endmsg ) : os;
  }

  virtual GaudiException* clone() const { return new GaudiException( *this ); }

  const char* what() const throw() override { 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