Exception.h

// -*- C++ -*-
//
// Exception.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 1999-2019 Leif Lonnblad
//
// ThePEG is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef ThePEG_Exception_H
#define ThePEG_Exception_H
// This is the declaration of the Exception class.
 
#include <exception>
#include "ThePEG/Config/ThePEG.h"
#include "Exception.fh"
#include <string>
#include <iosfwd>
 
extern "C" {
  void breakThePEG();
}
 
namespace ThePEG {
 
class Exception: public exception {
 
public:
 
  enum Severity {
    unknown,      
    info,         
    warning,      
    setuperror,   
    eventerror,   
    runerror,     
    maybeabort,   
    abortnow      
  };
 
public:
 
  Exception(const string & str, Severity sev);
 
  Exception() : handled(false), theSeverity(unknown) { breakThePEG(); }
 
  Exception(const Exception & ex) 
    : std::exception(ex), theMessage(ex.message()), 
      handled(ex.handled), theSeverity(ex.severity()) 
  {
    ex.handle();
  }
 
  virtual ~Exception() noexcept;
 
public:
 
  const Exception & operator=(const Exception & ex) {
    handled = ex.handled;
    theMessage << ex.message();
    theSeverity = ex.severity();
    ex.handle();
    return *this;
  }
 
  bool operator==(const Exception & ex) const {
    return ( message() == ex.message() && severity() == ex.severity() );
  }
 
  bool operator<(const Exception & ex) const {
    return ( severity() == ex.severity() ? 
             ( message() < ex.message() ) :
             ( severity() < ex.severity() ) );
  }
 
public:
 
  virtual const char* what() const noexcept {
    static string str;
    str = message();
    return str.c_str();
  }
 
  string message() const {
    string mess = theMessage.str();
    return mess.empty() ? string("Error message not provided.") : mess;
  }
 
  void writeMessage(ostream & os = *errstream) const;
 
  Severity severity() const { return theSeverity; }
 
  void handle() const { handled = true; }
 
  template <typename T>
  Exception & operator<<(const T & t) {
    theMessage << t;
    return *this;
  }
 
  Exception & operator<<(Severity sev) {
    severity(sev);
    return *this;
  }
 
protected:
 
  void severity(Severity);
 
  mutable ostringstream theMessage;
 
private:
 
  mutable bool handled;
 
  Severity theSeverity;
 
  static ostream * errstream;
 
public:
 
  static bool noabort;
 
};
 
}
 
#endif /* ThePEG_Exception_H */