Exception.h

#ifndef _RDA_EXCEPTION_H_
#define _RDA_EXCEPTION_H_
//
// 21 Mar 2001, N.Trofimov
// 10 Jul 2002 NNT
//    - added exception to stream
// 13 Jul 2006, W.Gajewski
//    - string management adjusted
// 14 Feb 2007 WPG
//    - rdaNoPermission added to support RBAC exceptions
// 17 Jun 2007 WPG
//    - rdaAccessDenied, rdaBadToken and rdaTokenExpired exceptions added to support RBAC-related exceptions
//
// TODO: doc for <<
//
#include <string>

class rdaData;

//
// Helper macro for the rdaInternalError constructor
//
#define __HERE__ __FILE__, __LINE__
// not very safe: maybe RDA_ERROR_HERE ?

class rdaInternalError
{
   
   char* message;
   char* file;
   int line;
   
   public:
  
      rdaInternalError(const char* f, int l, const char* msg = "");
      virtual ~rdaInternalError();

      rdaInternalError(const rdaInternalError& ex);
      rdaInternalError& operator=(const rdaInternalError& ex);

      const char* getMessage() const { return message; }
      const char* getFile() const { return file; }
      int getLine() const { return line; }   
};

class rdaException
{   
   protected:
   
      char* message;
   
   public:

      rdaException(const char* msg = "");
    
      rdaException(const rdaException& ex);

      rdaException& operator=(const rdaException& ex);

      virtual ~rdaException();

      virtual const char* getType() const
      {
         return "rdaException";
      }
   
      const char* getMessage() const
      {
         return message;
      }
};

class rdaBadParameter : public rdaException
{
   public:
   
      rdaBadParameter() {}
      rdaBadParameter(const char* msg) : rdaException(msg) {}

      virtual const char* getType() const
      {
         return "rdaBadParameter";
      }
};

class rdaTypeMismatch : public rdaException
{
   public:

      rdaTypeMismatch() {}
      rdaTypeMismatch(const char* msg) : rdaException(msg) { }

      virtual const char* getType() const
      {
         return "rdaTypeMismatch";
      }
};

class rdaTimeOut : public rdaException
{
   public:

      rdaTimeOut() {}
      rdaTimeOut(const char* msg) : rdaException(msg) { }

      virtual const char* getType() const
      {
         return "rdaTimeOut";
      }
};


class rdaNoConnection : public rdaException
{
   public:

      rdaNoConnection() {}
      rdaNoConnection(const char* msg) : rdaException(msg) { }

      virtual const char* getType() const
      {
         return "rdaNoConnection";
      }
};

class rdaNoPermission : public rdaException
{
public:
   rdaNoPermission(const char* msg) : rdaException(msg) { }

   virtual const char* getType() const
   {
      return "rdaNoPermission";
   }

};

class rdaInternalException : public rdaException
{
   public:

      rdaInternalException() {}
      rdaInternalException(const char* msg) : rdaException(msg) { }

      virtual const char* getType() const
      {
         return "rdaInternalException";
      }
};

class rdaAccessDenied : public rdaNoPermission
{
public:

   rdaAccessDenied( const char* msg ) : rdaNoPermission( msg ), type( 0 )
   {
   }

   rdaAccessDenied( long type_, const char* msg ) : rdaNoPermission( msg ), type( type_ )
   {
   }

   virtual const char* getType() const
   {
      return "rdaAccessDenied";
   }

   virtual long getErrorType() const
   {
      return type;
   }
private:
   long type;
};

class rdaBadToken : public rdaNoPermission
{
public:

   rdaBadToken( const char* msg ) : rdaNoPermission( msg ), type( 0 )
   {
   }

   rdaBadToken( long type_, const char* msg ) : rdaNoPermission( msg ), type( type_ )
   {
   }

   virtual const char* getType() const
   {
      return "rdaBadToken";
   }

   virtual long getErrorType() const
   {
      return type;
   }
private:
   long type;
};

class rdaTokenExpired : public rdaNoPermission
{
public:

   rdaTokenExpired( const char* msg ) : rdaNoPermission( msg ), type( 0 )
   {
   }

   rdaTokenExpired( long type_, const char* msg ) : rdaNoPermission( msg ), type( type_ )
   {
   }

   virtual const char* getType() const
   {
      return "rdaTokenExpired";
   }

   virtual long getErrorType() const
   {
      return type;
   }
private:
   long type;
};

class rdaIOError : public rdaException
{
   char* category;
   long errCode;
   rdaData* details;
   
   public:

      rdaIOError(const char* errorCategory, 
                 long errorCode, 
                 const char* errorMessage);

      rdaIOError(const char* errorCategory, 
                 long errorCode, 
                 const char* errorMessage, 
                 const rdaData& errorDetails);

      rdaIOError(const rdaIOError& ex);
      rdaIOError& operator=(const rdaIOError& ex);
      
      virtual ~rdaIOError();
  
      const char* getCategory() const
      {
         return category;
      }
      long getCode() const
      {
         return errCode;
      }      
      const rdaData* getDetails() const
      {
         return details;
      }       
      
      virtual const char* getType() const
      {
         return "rdaIOError";
      }
};

#ifndef RDA_HAS_NO_IOSTREAM
   #ifndef RDA_HAS_NO_STD_IOSTREAM
      #include <iostream>
      using std::ostream;
      using std::endl;
   #else
      #include <iostream.h>
   #endif

ostream& operator<<(ostream& os, const rdaException& ex);
ostream& operator<<(ostream& os, const rdaInternalError& ex);
#endif

#endif
 

---