exception.h

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
// $Id: exception.h,v 1.51 2005/12/23 17:01:39 amoll Exp $
//
   
#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

#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 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

#endif // BALL_COMMON_EXCEPTION_H

---