COMMON/exception.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
   
#ifndef BALL_COMMON_EXCEPTION_H
#define BALL_COMMON_EXCEPTION_H

#ifndef BALL_CONFIG_CONFIG_H
# include <BALL/CONFIG/config.h>
#endif

#ifndef BALL_COMMON_GLOBAL_H
# include <BALL/COMMON/global.h>
#endif

#ifdef BALL_COMPILER_MSVC
  #pragma warning(push)
  #pragma warning( disable : 4251 ) //disable needs to have dll-interface to be used by clients of class 'std::string'
#endif

#include <new>
#include <string>

namespace BALL 
{

  class String;

  namespace Exception 
  {
    
    class BALL_EXPORT GeneralException 
      : public std::exception
    {
      public:


      GeneralException();
      
      GeneralException(const char* file, int line);

      GeneralException
        (const char* file, int line,
         const String& name , const String& message);

      GeneralException(const GeneralException& exception);

      virtual ~GeneralException() throw();

  
      const char* getName() const;

      const char* getMessage() const;

      void setMessage(const std::string& message);

      int getLine() const;
  
      const char* getFile() const;

      protected:
      const char* file_;
      int         line_;

      std::string name_;
      std::string message_;
    };    

    class BALL_EXPORT IndexUnderflow 
      : public GeneralException
    {
      public:

      IndexUnderflow(const char* file, int line, Index index = 0, Size size = 0);


      protected:

      Size size_;
      Index index_;
    };

    class BALL_EXPORT SizeUnderflow 
      : public GeneralException
    {
      public:

      SizeUnderflow(const char* file, int line, Size size = 0);

      protected:
      Size size_;
    };

    class BALL_EXPORT IndexOverflow 
      : public GeneralException
    {
      public:
      IndexOverflow(const char* file, int line, Index index = 0, Size size = 0);

      protected:

      Size size_;
      Index index_;
    };

    class BALL_EXPORT InvalidArgument
      : public GeneralException
    {
      public:
        InvalidArgument(const char* file, int line, const String& arg);
    };

    class BALL_EXPORT InvalidRange 
      : public GeneralException
    {
      public:
      InvalidRange(const char* file, int line, float value);
    };


    class BALL_EXPORT InvalidSize 
      : public GeneralException
    {
      public:

      InvalidSize(const char* file, int line, Size size = 0);

      protected:
      Size size_;
    };


    class BALL_EXPORT OutOfRange 
      : public GeneralException
    {
      public:
      OutOfRange(const char* file, int line);
    };

    class BALL_EXPORT InvalidFormat 
      : public GeneralException
    {
      public:
      InvalidFormat(const char* file, int line, const String& s);
      
      ~InvalidFormat() throw();

      protected:

      std::string format_;
    };

    class BALL_EXPORT IllegalSelfOperation
      : public GeneralException
    {
      public:
      IllegalSelfOperation(const char* file, int line);
    };

    class BALL_EXPORT NullPointer 
      : public GeneralException
    {
      public:
      NullPointer(const char* file, int line);
    };

    class BALL_EXPORT InvalidIterator
      : public GeneralException
    {
      public:
      InvalidIterator(const char* file, int line);
    };

    class BALL_EXPORT IncompatibleIterators
      : public GeneralException
    {
      public:
      IncompatibleIterators(const char* file, int line);
    };

    class BALL_EXPORT NotImplemented
      : public GeneralException
    {
      public:
      NotImplemented(const char* file, int line);
    };

    class BALL_EXPORT IllegalTreeOperation
      : public GeneralException
    {
      public:
      IllegalTreeOperation(const char* file, int line);
    };

    class BALL_EXPORT OutOfMemory
      : public GeneralException, public std::bad_alloc
    {
      public:
      OutOfMemory(const char* file, int line, Size size = 0);
      
      virtual ~OutOfMemory() 
        throw();

      protected:
      Size size_;
    };

    class BALL_EXPORT BufferOverflow 
      : public GeneralException
    {
      public:
      BufferOverflow(const char* file, int line);
    };

    class BALL_EXPORT DivisionByZero 
      : public GeneralException
    {
      public:
      DivisionByZero(const char* file, int line);
    };

    class BALL_EXPORT OutOfGrid 
      : public GeneralException
    {
      public:
      OutOfGrid(const char* file, int line);
    };

    class BALL_EXPORT FileNotFound 
      : public GeneralException
    {
      public:
      FileNotFound(const char* file, int line, const String& filename);

      ~FileNotFound()
        throw();
      String getFilename() const;

      protected:
      std::string filename_;
    };

    class BALL_EXPORT IllegalPosition 
      : public GeneralException
    {
      public:
      IllegalPosition(const char* file, int line, float x, float y, float z);
    };

    class BALL_EXPORT ParseError
      : public GeneralException
    {
      public:
      ParseError(const char* file, int line, const String& expression,
          const String& message);
    };

    class BALL_EXPORT Precondition
      : public GeneralException
    {
      public:
      Precondition(const char* file, int line, const char* condition);
    };

    class BALL_EXPORT Postcondition
      : public GeneralException
    {
      public:
      Postcondition(const char* file, int line, const char* condition);
    };

    class BALL_EXPORT InvalidOption: public Exception::GeneralException
    {
      public:

        InvalidOption(const char* file, int line, String option);
    };
    
    class BALL_EXPORT TooManyErrors
      : public Exception::GeneralException
    {
      public:
      TooManyErrors(const char* file, int line);
    };
     
    class BALL_EXPORT TooManyBonds
      : public Exception::GeneralException
    {
      public:
      TooManyBonds(const char* file, int line, const String& error);
    };
    
    class BALL_EXPORT CUDAError 
      : public Exception::GeneralException
    {
      public:
      CUDAError(const char* file, int line, const String& error);                 
    };

    class BALL_EXPORT NoBufferAvailable 
      : public Exception::GeneralException
    {
    public:
      NoBufferAvailable(const char* file, int line, const String& reason);
    };

    class BALL_EXPORT FormatUnsupported
      : public Exception::GeneralException
    {
    public:
      FormatUnsupported(const char* file, int line);
    };

    class BALL_EXPORT NotInitialized : public Exception::GeneralException
    {
      public:
        NotInitialized(const char* file, int line, const String& reason);
    };

    class BALL_EXPORT GlobalExceptionHandler
    {
      public:

      GlobalExceptionHandler();
      
        
      static void setName(const String& name);
        
      static void setMessage(const String& message);

      static void setLine(int line);

      static void setFile(const String& file);

      static void set
        (const String& file, int line, 
         const String& name, const String& message);
      
      protected:

      static void terminate();

      static void newHandler() throw(Exception::OutOfMemory);

      static std::string file_;
      static int         line_;
      static std::string name_;
      static std::string message_;
    };

    BALL_EXPORT extern GlobalExceptionHandler globalHandler;

  }
    BALL_EXPORT
    std::ostream& operator << (std::ostream& os, const Exception::GeneralException& e);
  
} // namespace BALL

#ifdef BALL_COMPILER_MSVC
  #pragma warning(pop)
#endif

#endif // BALL_COMMON_EXCEPTION_H