exceptions.hpp

Go to the documentation of this file.

//   GAMBIT: Global and Modular BSM Inference Tool
//   *********************************************

#ifndef __exceptions_hpp__
#define __exceptions_hpp__

#include <map>
#include <set>
#include <string>
#include <exception>
#include <vector>
#include <utility>

#include "gambit/Utils/util_macros.hpp"
#include "gambit/Logs/log_tags.hpp"

namespace Gambit
{

  // Forward declaration of functor class.
  class functor;

  class EXPORT_SYMBOLS exception : virtual public std::exception
  {
    public:

      exception(const char*, const char*, const char*, const char*, bool);
      exception(const char*, const char*, const char*, const char*, bool, LogTag);
      exception(const char*, const char*, const char*, const char*, bool, LogTag, LogTag);
      exception(const char*, const char*, const char*, const char*, bool, LogTag, LogTag, LogTag);
      exception(const char*, const char*, const char*, const char*, bool, LogTag, LogTag, LogTag, LogTag);
      exception(const char*, const char*, const char*, const char*, bool, LogTag, LogTag, LogTag, LogTag, LogTag);
      exception(const char*, const char*, const char*, const char*, bool, LogTag, LogTag, LogTag, LogTag, LogTag, LogTag);
      exception(const char*, const char*, const char*, const char*, bool, LogTag, LogTag, LogTag, LogTag, LogTag, LogTag, LogTag);
      exception(const char*, const char*, const char*, const char*, bool, std::set<LogTag>);

      virtual ~exception() throw() {}

      void set_fatal(bool);

      virtual const char* what() const throw();

      void raise(const std::string&, const std::string&);

      void forced_throw(const std::string&, const std::string&);
      void silent_forced_throw();

      static const std::map<const char*,exception*>& all_exceptions();

      static void set_parameters(std::string);

    protected:

      std::set<LogTag> myLogTags;

    private:

      static std::map<const char*,exception*>& exception_map();

      void log_exception(const std::string&, const std::string&);

      void throw_iff_outside_parallel();

      void abort_here_and_now();

      const char* myKind;

      std::string myWhat;

      const std::string myShortWhat;

      const char* myMessage;

      bool isFatal;

      static std::string parameters;

  };


  class EXPORT_SYMBOLS error : public exception
  {

    public:

      error(const char*, const char*);
      error(const char*, const char*, LogTag);
      error(const char*, const char*, LogTag, LogTag);
      error(const char*, const char*, LogTag, LogTag, LogTag);
      error(const char*, const char*, LogTag, LogTag, LogTag, LogTag);
      error(const char*, const char*, LogTag, LogTag, LogTag, LogTag, LogTag);
      error(const char*, const char*, LogTag, LogTag, LogTag, LogTag, LogTag, LogTag);
      error(const char*, const char*, std::set<LogTag>);

  };


  class EXPORT_SYMBOLS warning : public exception
  {

    public:

      warning(const char*, const char*);
      warning(const char*, const char*, LogTag);
      warning(const char*, const char*, LogTag, LogTag);
      warning(const char*, const char*, LogTag, LogTag, LogTag);
      warning(const char*, const char*, LogTag, LogTag, LogTag, LogTag);
      warning(const char*, const char*, LogTag, LogTag, LogTag, LogTag, LogTag);
      warning(const char*, const char*, LogTag, LogTag, LogTag, LogTag, LogTag, LogTag);
      warning(const char*, const char*, std::set<LogTag>);

  };


  class EXPORT_SYMBOLS special_exception : virtual public std::exception
  {
    public:

      special_exception(const char*);

      virtual ~special_exception() throw() {}

      virtual const char* what() const throw();

      std::string message();

      virtual void raise(const std::string&);

    private:

      const char* myWhat;

    protected:

      std::string myMessage;

  };

  class invalid_point_exception : public special_exception
  {

    private:

      functor* myThrower;

      void abort_here_and_now();

    public:

      invalid_point_exception();

      void set_thrower(functor*);

      functor* thrower();

      virtual void raise(const std::string&);

  };

  class Piped_invalid_point
  {
    public:
      Piped_invalid_point() : flag(false), message("") {};

      void request(std::string message);

      void check();

    private:
      bool flag;
      std::string message;
  };

  extern Piped_invalid_point piped_invalid_point;

  class EXPORT_SYMBOLS Piped_exceptions
  {
    public:
      typedef std::pair<std::string,std::string> description;
      Piped_exceptions(size_t maxExceptions) : flag(false), maxExceptions(maxExceptions) {};

      void request(std::string origin, std::string message);
      void request(description desc);

      void check(exception &excep);

      bool inquire();

      bool inquire(std::string);

    private:
      bool flag;
      size_t maxExceptions;
      std::vector<description> exceptions;
  };

  extern Piped_exceptions piped_errors;

  extern Piped_exceptions piped_warnings;

  class SilentShutdownException : public std::exception
  {
    public:
      SilentShutdownException();
      SilentShutdownException(const std::string& message);
      virtual const char* what() const throw();
    private:
      std::string myWhat;
  };
  class SoftShutdownException : public std::exception
  {
    public:
      SoftShutdownException(const std::string& message);
      virtual const char* what() const throw();
    private:
      std::string myWhat;
  };
  class HardShutdownException : public std::exception
  {
    public:
      HardShutdownException(const std::string& message);
      virtual const char* what() const throw();
    private:
      std::string myWhat;
  };
  class MPIShutdownException : public std::exception
  {
    public:
      MPIShutdownException(const std::string& message);
      virtual const char* what() const throw();
    private:
      std::string myWhat;
  };

}


#endif