CigiIncomingMsg.h

Go to the documentation of this file.

#if !defined(_CIGI_INCOMING_MESSAGE_INCLUDED_)
#define _CIGI_INCOMING_MESSAGE_INCLUDED_

#include <stdlib.h>
#include "CigiMessage.h"
#include "CigiMessageBuffer.h"
#include "CigiBaseEventProcessor.h"
#include "CigiBaseSignalProcessing.h"
#include "CigiSignalType.h"


//=========================================================
typedef void (* CigiCBProcessor)(CigiBasePacket *Packet);


class CigiDefaultPacket;

class CigiSession;


//=========================================================
class CIGI_SPEC CigiIncomingMsg : public CigiMessage  
{

   friend class CigiSession;

public:


   //==> Management

   //=========================================================
   CigiIncomingMsg();

   //=========================================================
        virtual ~CigiIncomingMsg();



   //==> Processing Member functions


   //+> Processing Incoming Messages

   //=========================================================
        int ProcessIncomingMsg(Cigi_uint8 *Buff, int Size);

   //=========================================================
        int ProcessIncomingMsg(void)
   {
      int Rslt = CIGI_ERROR_UNEXPECTED_NULL;
      if(CrntMsgBuf != NULL)
         Rslt = ProcessIncomingMsg(CrntMsgBuf->Buffer,
                                   CrntMsgBuf->BufferFillCnt);

      return(Rslt);
   }

   //=========================================================
        void ProcessPacket(int PcktId, CigiBasePacket *Pckt);


   //+> Iterative packet processing method calls

   //=========================================================
        CigiBasePacket * GetFirstPacket(void);

   //=========================================================
        CigiBasePacket * GetNextPacket(void);


   //+> Packet Processor Management

   //=========================================================
        int RegisterEventProcessor(int PacketID,
                              CigiBaseEventProcessor *EventMgr);

   //=========================================================
        int UnregisterEventProcessor(int PacketID,
                              CigiBaseEventProcessor *EventMgr);


   //=========================================================
   int RegisterCallBack(int PacketID, CigiCBProcessor CallBack);

   //=========================================================
   int UnregisterCallBack(int PacketID, CigiCBProcessor CallBack);


   //=========================================================
   int RegisterSignalProcessor(CigiBaseSignalProcessing *SignalMgr);

   //=========================================================
   int UnregisterSignalProcessor(CigiBaseSignalProcessing *SignalMgr);


   //=========================================================
   int RegisterUnrecognizedPacketEvent(CigiBaseEventProcessor *EventMgr)
   {
        return(RegisterEventProcessor(0,EventMgr));
   }

   //=========================================================
   int UnregisterUnrecognizedPacketEvent(CigiBaseEventProcessor *EventMgr)
   {
      return(UnregisterEventProcessor(0,EventMgr));
   }


   //=========================================================
   int RegisterUnrecognizedPacketCallBack(CigiCBProcessor CallBack)
   {
      return(RegisterCallBack(0,CallBack));
   }

   //=========================================================
   int UnregisterUnrecognizedPacketCallBack(CigiCBProcessor CallBack)
   {
      return(UnregisterCallBack(0,CallBack));
   }

   //=========================================================
   int RegisterUnhandledPacketEvent(CigiBaseEventProcessor *EventMgr)
   {
        return(RegisterEventProcessor(256,EventMgr));
   }

   //=========================================================
   int UnregisterUnhandledPacketEvent(CigiBaseEventProcessor *EventMgr)
   {
      return(UnregisterEventProcessor(256,EventMgr));
   }


   //=========================================================
   int RegisterUnhandledPacketCallBack(CigiCBProcessor CallBack)
   {
      return(RegisterCallBack(256,CallBack));
   }

   //=========================================================
   int UnregisterUnhandledPacketCallBack(CigiCBProcessor CallBack)
   {
      return(UnregisterCallBack(256,CallBack));
   }


   //==> Buffer Packing Managers


   //=========================================================
   Cigi_uint8 *GetNextBuffToLoad(void);

   //=========================================================
   void AdvanceCrntBuffer(void);

   //=========================================================
   void SetCrntMsgSize(int MsgSize)
   {
      if(CrntMsgBuf != NULL)
         CrntMsgBuf->BufferFillCnt = MsgSize;
   }



   //==> Accessing Member Variable Values functions

   //=========================================================
   Cigi_uint8 * GetMsgBuffer()
   {
      if(CrntMsgBuf == NULL)
         AdvanceCrntBuffer();

      return(CrntMsgBuf->Buffer);
   }

   //=========================================================
   int GetMsgBufSize(void) { return(CrntMsgBuf->BufferSize); }


   //+> Iteration Method Flag

   //=========================================================
   void UsingIteration(bool IterationIn=true) { Iteration = IterationIn; }

   //=========================================================
   bool CheckIteration(void) { return(Iteration); }


   //+> Reader's CIGI Version

   //=========================================================
        void SetReaderVersion(CigiVersionID &Version);

   //=========================================================
   int SetReaderCigiVersion(const int CigiVersionIn, bool bndchk=true)
   {
      CigiVersionID tVer(CigiVersionIn,0);
      SetReaderVersion(tVer);
      return(CIGI_SUCCESS);
   }

   //=========================================================
   int SetReaderCigiVersion(const int CigiVersionIn, const int CigiMinorVersionIn, bool bndchk=true)
   {
      CigiVersionID tVer(CigiVersionIn,CigiMinorVersionIn);
      SetReaderVersion(tVer);
      return(CIGI_SUCCESS);
   }

   //=========================================================
   int GetReaderCigiVersion(void) const
   {
      return(ReaderVersion.CigiMajorVersion);
   }

   //=========================================================
   int GetReaderCigiMinorVersion(void) const { return(ReaderVersion.CigiMinorVersion); }


   //+> Registering

   //=========================================================
        int RegisterUserPacket(CigiBasePacket *Packet,
                          Cigi_uint8 PacketID,
                          bool HostSend,
                          bool IGSend);



protected:

   //==> Member variables

   //=========================================================
   bool Iteration;

   //=========================================================
   Cigi_uint8 *CrntPacket;

   //=========================================================
   int ReadBufferPos;

   //=========================================================
   list<CigiBaseEventProcessor *>EventList[257];

   //=========================================================
   list<CigiCBProcessor>CallBackList[257];

   //=========================================================
   list<CigiBaseSignalProcessing *>SignalList;

   //=========================================================
   bool Swap;

   //=========================================================
   CigiVersionID MostMatureCigiVersionReceived;

   //=========================================================
   CigiVersionID ProcessingVersion;

   //=========================================================
   CigiVersionID ReaderVersion;

   //=========================================================
   CigiBasePacket *IncomingHandlerTbl[256];

   //=========================================================
   CigiSignalType::Type SignalTbl[256];

   //=========================================================
   CigiDefaultPacket *DefaultPckt;


   //==> Member protected functions

   //=========================================================
   bool SignalJump(const Cigi_uint8 PacketID, CigiBasePacket *Packet);

   //=========================================================
        void ClearTbls(bool Complete);

   //=========================================================
        void SetIncomingHostV1Tbls(void);

   //=========================================================
        void SetIncomingIGV1Tbls(void);

   //=========================================================
        void SetIncomingHostV2Tbls(void);

   //=========================================================
        void SetIncomingIGV2Tbls(void);

   //=========================================================
        void SetIncomingHostV3Tbls(void);

   //=========================================================
        void SetIncomingIGV3Tbls(void);

   //=========================================================
        int CheckFirstPacket(Cigi_uint8 *Buff);


};

#endif // !defined(_CIGI_INCOMING_MESSAGE_INCLUDED_)

---