CigiOutgoingMsg.h

Go to the documentation of this file.

#if !defined(_CIGI_OUTGOING_MESSAGE_INCLUDED_)
#define _CIGI_OUTGOING_MESSAGE_INCLUDED_

#include <string>
#include <list>

#include "CigiMessage.h"
#include "CigiBasePacket.h"
#include "CigiBaseEntityCtrl.h"
#include "CigiBaseIGCtrl.h"
#include "CigiBaseSOF.h"
#include "CigiMessageBuffer.h"
#include "CigiBaseVariableSizePckt.h"
#include "CigiDefaultPacket.h"

class CigiSession;

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

   friend class CigiSession;

public:
   //==> Management

   //=========================================================
   CigiOutgoingMsg();

   //=========================================================
   virtual ~CigiOutgoingMsg();





   //==> Buffer Packing Operators with References

   //=========================================================
   CigiOutgoingMsg & operator <<(CigiBaseIGCtrl &refPacket);

   //=========================================================
   inline CigiOutgoingMsg & pack(CigiBaseIGCtrl &refPacket)
   {
     return (*this) << refPacket;
   }

   //=========================================================
   CigiOutgoingMsg & operator <<(CigiBaseSOF &refPacket);

   //=========================================================
   CigiOutgoingMsg & pack(CigiBaseSOF &refPacket)
   {
     return (*this) << refPacket;
   }

   //=========================================================
   CigiOutgoingMsg & operator <<(CigiBaseEntityCtrl &refPacket);

   //=========================================================
   CigiOutgoingMsg & pack(CigiBaseEntityCtrl &refPacket)
   {
     return (*this) << refPacket;
   }

   //=========================================================
   CigiOutgoingMsg & operator <<(CigiBaseEnvCtrl &refPacket);

   //=========================================================
   CigiOutgoingMsg & pack(CigiBaseEnvCtrl &refPacket)
   {
     return (*this) << refPacket;
   }

   //=========================================================
   CigiOutgoingMsg & operator <<(CigiBaseVariableSizePckt &refPacket);

   //=========================================================
   CigiOutgoingMsg & pack(CigiBaseVariableSizePckt &refPacket)
   {
     return (*this) << refPacket;
   }

   //=========================================================
   CigiOutgoingMsg & operator <<(CigiBasePacket &refBasePacket);

   //=========================================================
   CigiOutgoingMsg & pack(CigiBasePacket &refBasePacket)
   {
     return (*this) << refBasePacket;
   }


   //==> Buffer Packing Operators with Pointers

   //=========================================================
   CigiOutgoingMsg & operator <<(CigiBaseIGCtrl *refPacket)
   {
      return(operator<<(*refPacket));
   }

   //=========================================================
   CigiOutgoingMsg & pack(CigiBaseIGCtrl *refPacket)
   {
     return this->pack(*refPacket);
   }

   //=========================================================
   CigiOutgoingMsg & operator <<(CigiBaseSOF *refPacket)
   {
      return(operator<<(*refPacket));
   }

   //=========================================================
   CigiOutgoingMsg & pack(CigiBaseSOF *refPacket)
   {
     return this->pack(*refPacket);
   }

   //=========================================================
   CigiOutgoingMsg & operator <<(CigiBaseEntityCtrl *refPacket)
   {
      return(operator<<(*refPacket));
   }

   //=========================================================
   CigiOutgoingMsg & pack(CigiBaseEntityCtrl *refPacket)
   {
     return this->pack(*refPacket);
   }

   //=========================================================
   CigiOutgoingMsg & operator <<(CigiBaseEnvCtrl *refPacket)
   {
      return(operator<<(*refPacket));
   }

   //=========================================================
   CigiOutgoingMsg & pack(CigiBaseEnvCtrl *refPacket)
   {
     return this->pack(*refPacket);
   }

   //=========================================================
   CigiOutgoingMsg & operator <<(CigiBaseVariableSizePckt *refPacket)
   {
      return(operator<<(*refPacket));
   }

   //=========================================================
   CigiOutgoingMsg & pack(CigiBaseVariableSizePckt *refPacket)
   {
     return this->pack(*refPacket);
   }

   //=========================================================
   CigiOutgoingMsg & operator <<(CigiBasePacket *refBasePacket)
   {
      return(operator<<(*refBasePacket));
   }

   //=========================================================
   CigiOutgoingMsg & pack(CigiBasePacket *refBasePacket)
   {
     return this->pack(*refBasePacket);
   }



   //==> Buffer Packing Managers

   //=========================================================
        int BeginMsg(void)
   {
      if(Buffers.empty())
         AdvanceBuffer();
      return(CIGI_SUCCESS);
   }

   //=========================================================
        int UpdateFrameCntr(void);

   //=========================================================
        int UpdateFrameCntr(Cigi_uint8 *OutgoingMsg, Cigi_uint8 *IncomingMsg = NULL);

   //=========================================================
        int UpdateIGCtrl(Cigi_uint8 *OutgoingMsg, Cigi_uint8 *IncomingMsg);

   //=========================================================
        int UpdateSOF(Cigi_uint8 *OutgoingMsg, Cigi_uint8 *IncomingMsg = NULL)
   {
      return(UpdateFrameCntr(OutgoingMsg,IncomingMsg));
   }

   //=========================================================
   int LockMsg(void);

   //=========================================================

        Cigi_uint8 * GetMsg(int &length);

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

   //=========================================================
   int GetMsgLength(void);

   //=========================================================
   std::string GetBufferString(void);

   //=========================================================
   int UnlockMsg(void);

   //=========================================================
        int PackageMsg(Cigi_uint8 **Msg, int &length);

   //=========================================================
        int GetCurrentlyPackagedMsg(Cigi_uint8 **Msg, int &length)
   {
      if(PackagedMsg != NULL)
      {
         *Msg = PackagedMsg->Buffer;
         length = PackagedMsg->BufferFillCnt;
         return(CIGI_SUCCESS);
      }
      else
      {
         *Msg = (Cigi_uint8 *)0;  // equivalent to NULL
         length = 0;
         return(CIGI_ERROR_UNEXPECTED_NULL);
      }
   }

   //=========================================================
   int FreeMsg(void);

   //+> Frame Count

   //=========================================================
   void SetFrameCnt(const Cigi_uint32 FrameCntIn) { FrameCnt = FrameCntIn; }

   //=========================================================
   Cigi_uint32 GetFrameCnt(void) const { return(FrameCnt); }

   //+> Synchronous Operation

   //=========================================================
   void SetSynchronous(const bool Sync) { };

   //=========================================================
   bool IsSynchronous(void) const;


   //+> Registering

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




protected:


   //=========================================================
        int Reset(void);

   //=========================================================
        int InitMsg(void)
   {
      AdvanceBuffer();
      return(CIGI_SUCCESS);
   }

   //=========================================================
        int SetOutgoingCigiVersion(CigiVersionID &Version,
                              bool bndchk=true);

   //=========================================================
        CigiVersionID GetOutgoingCigiVersion(void)
   {
      return(OutgoingVersion);
   }

   //=========================================================
   //    Cigi Version of an incoming message received.
        void SetMostMatureReceivedCigiVersion(CigiVersionID &Version);

   //=========================================================
   void SetLastRcvdFrame(Cigi_uint32 LastRcvdFrameIn)
   {
      LastRcvdFrame = LastRcvdFrameIn;
   }

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

   //=========================================================
   void ClearHandlerTable(void);

   //=========================================================
        void SetOutgoingHostV1Tbls(void);

   //=========================================================
        void SetOutgoingIGV1Tbls(void);

   //=========================================================
        void SetOutgoingHostV2Tbls(void);

   //=========================================================
        void SetOutgoingIGV2Tbls(void);

   //=========================================================
        void SetOutgoingHostV3Tbls(void);

   //=========================================================
        void SetOutgoingIGV3Tbls(void);

   //=========================================================
        void AdvanceBuffer(void);

   //=========================================================
   CigiOutgoingMsg &  PackObj(CigiBasePacket &DataPacket,
                              CigiBasePacket &PackingPacket,
                              void *Spec);

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

   //=========================================================
   CigiVersionID OutgoingVersion;

   //=========================================================
   bool CmdVersionChng;

   //=========================================================
   CigiVersionID CmdVersion;

   //=========================================================
   CigiVersionID MostMatureVersionReceived;

   //=========================================================
   CigiDefaultPacket DefaultPacket;

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

   //=========================================================
   bool VldSnd[256];

   //=========================================================
   Cigi_uint32 FrameCnt;

   //=========================================================
   Cigi_uint32 LastRcvdFrame;

   //=========================================================
   CigiBaseIGCtrl *pIGCtrlPck[6];

   //=========================================================
   CigiBaseSOF *pSOFPck[5];




};

#endif // !defined(_CIGI_OUTGOING_MESSAGE_INCLUDED_)

---