Exception.h

// -*- C++ -*-
//
// Exception.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 1999-2007 Leif Lonnblad
//
// ThePEG is licenced under version 2 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() throw();

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 throw() {
    return message().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;

};

}

#endif /* ThePEG_Exception_H */

---