AugerException.h

Go to the documentation of this file.

#ifndef _utl_AugerException_h_
#define _utl_AugerException_h_

#include <exception>
#include <string>
#include <sstream>
#include <map>


namespace utl {

  class AugerException : public std::exception {
  public:
    AugerException(const std::string& message = std::string())
      : fMessage(message) { }

    virtual ~AugerException() throw() { }

    virtual std::string GetExceptionName() const
    { return "Generic Exception in the Auger Offline Software"; }

    const std::string& GetMessage() const { return fMessage; }

    const char* what() const throw() { return fMessage.c_str(); }

  protected:
    std::string fMessage;
  };


  class NonExistentComponentException : public AugerException {
  public:
    NonExistentComponentException(const std::string& message = std::string())
      : AugerException(message) { }

    virtual std::string GetExceptionName() const
    { return "Access to non-existent sub-component exception"; }
  };


  class IOFailureException : public AugerException {
  public:
    IOFailureException(const std::string& message = std::string())
      : AugerException(message) { }

    virtual std::string GetExceptionName() const
    { return "IO failure exception"; }
  };


  class InvalidIteratorException : public AugerException {
  public:
    InvalidIteratorException(const std::string& message = std::string())
      : AugerException(message) { }

    virtual std::string GetExceptionName() const
    { return "Invalid Iterator Exception"; }
  };


  class OutOfBoundException : public AugerException {
  public:
    OutOfBoundException(const std::string& message = std::string())
      : AugerException(message) { }

    virtual std::string GetExceptionName() const
    { return "Out of Bounds Exception"; }
  };


  class InitSequenceException : public AugerException {
  public:
    InitSequenceException(const std::string& message = std::string())
      : AugerException(message) { }

    virtual std::string GetExceptionName() const
    { return "Invalid order of initialisation and/or use"; }
  };


  class ModuleSequenceException : public AugerException {
  public:
    ModuleSequenceException(const std::string& message = std::string())
      : AugerException(message) { }

    virtual std::string GetExceptionName() const
    { return "Error during module sequencing"; }
  };

  class NoDataForModelException : public AugerException {
  public:
    NoDataForModelException(const std::string& message = std::string())
      : AugerException(message) { }

    virtual std::string GetExceptionName() const
    { return "Atmosphere model could not find data needed to perform "
             "requested calculation."; }
  };


   class DataNotFoundInDBException : public AugerException {
   public:
     DataNotFoundInDBException(const std::string& table,
                               const std::string& column,
                               const std::map<std::string, std::string>& indexMap,
                               const std::string& time) :
       fTableName(table),
       fColumnName(column),
       fIndexMap(indexMap),
       fTime(time)
     {
       std::ostringstream msg;
       msg << "Did not find requested data for:\n"
              "Component name    : " << fTableName << "\n"
              "Component property: " << fColumnName << '\n';

       for (std::map<std::string, std::string>::const_iterator it = fIndexMap.begin();
            it != fIndexMap.end(); ++it)
         msg << "   '" << it->first << "' = '" << it->second << "',\n";

       msg << "Detector time = " << fTime;

       fMessage = msg.str();
     }

     DataNotFoundInDBException(const std::string& message = std::string())
       : AugerException(message) { }

     virtual std::string GetExceptionName() const
     { return "Could not locate requested data in the database"; }

     virtual ~DataNotFoundInDBException() throw() { }

   private:
     std::string fTableName;
     std::string fColumnName;
     std::map<std::string, std::string> fIndexMap;
     std::string fTime;
   };


  class XMLParseException : public AugerException {
  public:
    XMLParseException(const std::string& message = std::string())
      : AugerException(message) { }

    virtual std::string GetExceptionName() const
    { return "XML Parse Exception"; }
  };

  class XMLValidationException : public AugerException {
  public:
    XMLValidationException(const std::string& message = std::string())
      : AugerException(message) { }

    virtual std::string GetExceptionName() const
    { return "XML Validation Exception"; }
  };


  class MissingEventDataException : public AugerException {
  public:
    MissingEventDataException(const std::string& message = std::string())
      : AugerException(message) { }

    virtual std::string GetExceptionName() const
    { return "Required data not present in the Event"; }
  };


  class InvalidConfigurationException : public AugerException {
  public:
    InvalidConfigurationException(const std::string& message = std::string())
      : AugerException(message) { }

    virtual std::string GetExceptionName() const
    { return "Invalid configuration."; }
  };


  class DoesNotComputeException : public AugerException {
  public:
    DoesNotComputeException(const std::string& message = std::string())
      : AugerException(message) { }

    virtual std::string GetExceptionName() const
    { return "I'm sorry Dave, I'm afraid I can't do that."; }
  };

}


#endif