CigiExceptions.h

Go to the documentation of this file.

#if ! defined( _CIGI_EXCEPTIONS_INCLUDED_)
#define _CIGI_EXCEPTIONS_INCLUDED_
    
    
#include "CigiException.h"
#include <string.h>
#include <stdio.h>


//=========================================================
class CIGI_SPEC CigiAllocFailedException : public CigiException
{

public:

   //=========================================================
   CigiAllocFailedException(void)
   {
      memcpy(ErrMsg,"Allocation Failure\n",21);
      Msg = ErrMsg;
      ErrorCode = CIGI_ERROR_ALLOC_FAILED;
   }

   //=========================================================
   virtual ~CigiAllocFailedException(void) throw() { };

protected:

   char ErrMsg[25];

};

//=========================================================
class CIGI_SPEC CigiBufferOverrunException : public CigiException
{

public:

   //=========================================================
   CigiBufferOverrunException(void)
   {
      memcpy(ErrMsg,"Buffer Overrun Error\n",22);
      Msg = ErrMsg;
      ErrorCode = CIGI_ERROR_BUFFER_OVERRUN;
   }

   //=========================================================
   virtual ~CigiBufferOverrunException(void) throw() { };

protected:

   char ErrMsg[25];

};

//=========================================================
class CIGI_SPEC CigiBufferTooSmallException : public CigiException
{

public:

   //=========================================================
   CigiBufferTooSmallException(void)
   {
      memcpy(ErrMsg,"Buffer Too Small Error\n",26);
      Msg = ErrMsg;
      ErrorCode = CIGI_ERROR_BUFFER_TOO_SMALL;
   }


   //=========================================================
   virtual ~CigiBufferTooSmallException(void) throw() { };

protected:

   char ErrMsg[30];

};

//=========================================================
class CIGI_SPEC CigiCalledOutOfSequenceException : public CigiException
{

public:

   //=========================================================
   CigiCalledOutOfSequenceException(void)
   {
      memcpy(ErrMsg,"Routine Call Out Of Sequence Error\n",38);
      Msg = ErrMsg;
      ErrorCode = CIGI_ERROR_CALLED_OUT_OF_SEQUENCE;
   }

   //=========================================================
   virtual ~CigiCalledOutOfSequenceException(void) throw() { };

protected:

   char ErrMsg[40];

};

//=========================================================
class CIGI_SPEC CigiInvalidOpcodeException : public CigiException
{

public:

   //=========================================================
   CigiInvalidOpcodeException(void)
   {
      memcpy(ErrMsg,"Invalid Packet ID\n",21);
      Msg = ErrMsg;
      ErrorCode = CIGI_ERROR_INVALID_OPCODE;
   }

   //=========================================================
   virtual ~CigiInvalidOpcodeException(void) throw() { };

protected:

   char ErrMsg[25];

};

//=========================================================
class CIGI_SPEC CigiInvalidPacketException : public CigiException
{

public:

   //=========================================================
   CigiInvalidPacketException(void)
   {
      memcpy(ErrMsg,"Invalid Packet\n",18);
      Msg = ErrMsg;
      ErrorCode = CIGI_ERROR_INVALID_PACKET;
   }

   //=========================================================
   virtual ~CigiInvalidPacketException(void) throw() { };

protected:

   char ErrMsg[25];

};

//=========================================================
class CIGI_SPEC CigiInvalidPacketSizeException : public CigiException
{

public:

   //=========================================================
   CigiInvalidPacketSizeException(void)
   {
      memcpy(ErrMsg,"Invalid Packet Size\n",23);
      Msg = ErrMsg;
      ErrorCode = CIGI_ERROR_INVALID_PACKET_SIZE;
   }

   //=========================================================
   virtual ~CigiInvalidPacketSizeException(void) throw() { };

protected:

   char ErrMsg[25];

};

//=========================================================
class CIGI_SPEC CigiInvalidSessionException : public CigiException
{

public:

   //=========================================================
   CigiInvalidSessionException(void) 
   {
      memcpy(ErrMsg,"Invalid Session\n",19);
      Msg = ErrMsg;
      ErrorCode = CIGI_ERROR_INVALID_SESSION;
   }

   //=========================================================
   virtual ~CigiInvalidSessionException(void) throw() { };

protected:

   char ErrMsg[25];

};

//=========================================================
class CIGI_SPEC CigiInvalidSessionTypeException : public CigiException
{

public:

   //=========================================================
   CigiInvalidSessionTypeException(void) 
   {
      memcpy(ErrMsg,"Invalid Session Type\n",24);
      Msg = ErrMsg;
      ErrorCode = CIGI_ERROR_INVALID_SESSION_TYPE;
   }

   //=========================================================
   virtual ~CigiInvalidSessionTypeException(void) throw() { };

protected:

   char ErrMsg[25];

};

//=========================================================
class CIGI_SPEC CigiMaxSessionsException : public CigiException
{

public:

   //=========================================================
   CigiMaxSessionsException(void) 
   {
      memcpy(ErrMsg,"Requested Number Of Sessions Exceeds Maximum\n",48);
      Msg = ErrMsg;
      ErrorCode = CIGI_ERROR_MAX_SESSIONS;
   }

   //=========================================================
   virtual ~CigiMaxSessionsException(void) throw() { };

protected:

   char ErrMsg[50];

};

//=========================================================
class CIGI_SPEC CigiMissingIgControlException : public CigiException
{

public:

   //=========================================================
   CigiMissingIgControlException(void) 
   {
      memcpy(ErrMsg,"The Message Is Missing The IG Control Packet\n",48);
      Msg = ErrMsg;
      ErrorCode = CIGI_ERROR_MISSING_IG_CONTROL_PACKET;
   }

   //=========================================================
   virtual ~CigiMissingIgControlException(void) throw() { };

protected:

   char ErrMsg[50];

};

//=========================================================
class CIGI_SPEC CigiMissingStartOfFrameException : public CigiException
{

public:

   //=========================================================
   CigiMissingStartOfFrameException(void) 
   {
      memcpy(ErrMsg,"The Message Is Missing The Start Of Frame Packet\n",52);
      Msg = ErrMsg;
      ErrorCode = CIGI_ERROR_MISSING_SOF_PACKET;
   }

   //=========================================================
   virtual ~CigiMissingStartOfFrameException(void) throw() { };

protected:

   char ErrMsg[55];

};

//=========================================================
class CIGI_SPEC CigiNotImplementedException : public CigiException
{

public:

   //=========================================================
   CigiNotImplementedException(void) 
   {
      memcpy(ErrMsg,"Not Implemented Error\n",25);
      Msg = ErrMsg;
      ErrorCode = CIGI_ERROR_NOT_IMPLEMENTED;
   }

   //=========================================================
   virtual ~CigiNotImplementedException(void) throw() { };

protected:

   char ErrMsg[30];

};

//=========================================================
class CIGI_SPEC CigiNullPointerException : public CigiException
{

public:

   //=========================================================
   CigiNullPointerException(void) 
   {
      memcpy(ErrMsg,"Null Pointer Error\n",21);
      Msg = ErrMsg;
      ErrorCode = CIGI_ERROR_UNEXPECTED_NULL;
   }

   //=========================================================
   virtual ~CigiNullPointerException(void) throw() { };

protected:

   char ErrMsg[25];

};

//=========================================================
class CIGI_SPEC CigiPacketTooLargeException : public CigiException
{

public:

   //=========================================================
   CigiPacketTooLargeException(void) 
   {
      memcpy(ErrMsg,"Packet Is Too Large\n",23);
      Msg = ErrMsg;
      ErrorCode = CIGI_ERROR_PACKET_TOO_LARGE;
   }

   //=========================================================
   virtual ~CigiPacketTooLargeException(void) throw() { };

protected:

   char ErrMsg[25];

};

//=========================================================
class CIGI_SPEC CigiValueOutOfRangeException : public CigiException
{

public:

   //=========================================================
   CigiValueOutOfRangeException(void) 
   {
      memcpy(ErrMsg,"Value Out Of Range\n",23);
      Msg = ErrMsg;
      ErrorCode = CIGI_ERROR_VALUE_OUT_OF_RANGE;
   }

   //=========================================================
   CigiValueOutOfRangeException(char *ParameterName, int Value, int Low, int High) 
   {

      if(strlen(ParameterName) < 75)
         PrtPname = ParameterName;
      else
      {
         memcpy(SubPname,ParameterName,74);
         SubPname[74] = 0;
         PrtPname = SubPname;
      }

      sprintf(ErrMsg,"Parameter Out of Range: Parameter %s is %d. The valid range is from %d to %d.\n",
              PrtPname, Value, Low, High);

      Msg = ErrMsg;
      ErrorCode = CIGI_ERROR_VALUE_OUT_OF_RANGE;
   }

   //=========================================================
   CigiValueOutOfRangeException(char *ParameterName, double Value, double Low, double High) 
   {
      if(strlen(ParameterName) < 75)
         PrtPname = ParameterName;
      else
      {
         memcpy(SubPname,ParameterName,74);
         SubPname[74] = 0;
         PrtPname = SubPname;
      }

      sprintf(ErrMsg,"Parameter Out of Range: Parameter %s is %g. The valid range is from %g to %g.\n",
              PrtPname, Value, Low, High);

      Msg = ErrMsg;
      ErrorCode = CIGI_ERROR_VALUE_OUT_OF_RANGE;
   }

   //=========================================================
   CigiValueOutOfRangeException(char *ParameterName, double Value, char *Mod, double Limit) 
   {
      if(strlen(ParameterName) < 75)
         PrtPname = ParameterName;
      else
      {
         memcpy(SubPname,ParameterName,74);
         SubPname[74] = 0;
         PrtPname = SubPname;
      }

      sprintf(ErrMsg,"Parameter Out of Range: Parameter %s is %g. The valid range is %s %g.\n",
              PrtPname, Value, Mod, Limit);

      Msg = ErrMsg;
      ErrorCode = CIGI_ERROR_VALUE_OUT_OF_RANGE;
   }

   //=========================================================
   virtual ~CigiValueOutOfRangeException(void) throw() { };

protected:

   char ErrMsg[255];
   char SubPname[75];
   char *PrtPname;

};

//=========================================================
class CIGI_SPEC CigiWrongVersionException : public CigiException
{

public:

   //=========================================================
   CigiWrongVersionException(void) 
   {
      memcpy(ErrMsg,"Wrong Cigi Version Used\n",28);
      Msg = ErrMsg;
      ErrorCode = CIGI_ERROR_WRONG_VERSION;
   }

   //=========================================================
   virtual ~CigiWrongVersionException(void) throw() { };

protected:

   char ErrMsg[30];

};


//=========================================================
class CIGI_SPEC CigiInvalidUserPacketException : public CigiException
{

public:

   //=========================================================
   CigiInvalidUserPacketException(void) 
   {
      memcpy(ErrMsg,"Cigi User Defined Packets Must Have an ID above 199\n",56);
      Msg = ErrMsg;
      ErrorCode = CIGI_ERROR_INVALID_USER_PACKET;
   }


   //=========================================================
   CigiInvalidUserPacketException(Cigi_uint8 PacketID)
   {
      int IPacketID = (int)PacketID;
      sprintf(ErrMsg,"Cigi User Defined Packets Must Have an ID above 199\nUsed ID was %d\n",IPacketID);
      Msg = ErrMsg;
      ErrorCode = CIGI_ERROR_INVALID_USER_PACKET;
   }


   //=========================================================
   virtual ~CigiInvalidUserPacketException(void) throw() { };

protected:

   char ErrMsg[90];

};



//=========================================================
class CIGI_SPEC CigiImproperPacketException : public CigiException
{

public:

   //=========================================================
   CigiImproperPacketException(void) 
   {
      memcpy(ErrMsg,"Improper packet for Session Type\n",37);
      Msg = ErrMsg;
      ErrorCode = CIGI_ERROR_IMPROPER_PACKET;
   }


   //=========================================================
   virtual ~CigiImproperPacketException(void) throw() { };

protected:

   char ErrMsg[40];

};

#endif // #if ! defined(_CIGI_EXCEPTIONS_INCLUDED_)

---