exerciseConnDIS.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 1992-2025 MAK Technologies, Inc
** All rights reserved.
*********************************************************************/

#pragma once

#if DtDIS


#include <vlutil/vlMachineTypes.h>
#include "pduCallbackManager.h"
#include <vl/iffPduCallbackManager.h>
#include <vlpi/disEnums.h>
#include "packets/pduHeader.h"
#include "baseExerciseConn.h"
#include "stateMsgDIS.h"
#include "interactionDIS.h"
#include <matrix/vlMath.h>
#include <vlutil/vlHashlist.h>
#include "pduFactory.h"
#include <vlutil/vlTimeStampType.h>
#include "eventId.h"
#include <vlutil/vlVersion.h>

#include <vlutil/vlInetDevice.h>
#include <vlutil/vlInetEndpoint.h>
#include <vlutil/vlInetAddr.h>
#include <vlutil/vlInetSocket.h>

class DtPdu;
class DtDisObjectManager;
class DtExerciseConnInitializer;
class DtInetDevice;
class DtDisSocket;
class DtOwnershipHandler;
class DtPduDecoderFactory;
class DtPduEncoderFactory;
class DtStateRepositoryExtensionEncoderFactory;
class DtStateRepositoryExtensionDecoderFactory;

const DtExerciseId DtMaxExerciseId = 255;
const DtExerciseId DtAnyExercise   = 0;

typedef DtPdu* (*DtPduInterceptFcn)(DtPdu* pdu, int *retCode);

class DT_DLL_VL DtExerciseConn : public DtBaseExerciseConn
{
public:

   typedef int (*DtPredicate)(DtPdu *pdu, void *arg);

   enum {
      DtNET_READ_SUCCESS    =0, 
      DtNET_READ_NO_PACKETS      =1, 
      DtNET_READ_BAD_PACKET      =2, 
      DtNET_READ_SERVER_MSG      =3, 
      DtNET_READ_SIZE_MISMATCH   =4 
   };
   enum
   {
      DtPROCESS_PDU_SUCCESS      =0,
      DtPROCESS_PDU_WRONG_EXID   =5,
      DtPROCESS_PDU_NO_PDU       =6,
      DtNET_READ_FILTERED_PACKET =7
   };

   enum InitializationStatus {
      DtINIT_SUCCESS             =0, 
      DtCOULD_NOT_CREATE_SOCKET  =1  
   };

public:

   DtExerciseConn(const DtExerciseConnInitializer& initial, InitializationStatus* status = 0);

   DtExerciseConn(int port, int exercise_id, 
      int site_id, int application_num, 
      InitializationStatus* status = 0, bool use_async_io = false,
      bool useIpv6 = false, bool suppressSelfReflect = false);
   
   DtExerciseConn(int port, const DtInetAddr& destAddr, int exercise_id, 
      int site_id, int application_num, InitializationStatus* status = 0, 
      bool use_async_io = false, bool suppressSelfReflect = false);

   DtExerciseConn(DtInetSocket* skt, int exercise_id, 
      int site_id, int application_num, InitializationStatus* status = 0);

   virtual ~DtExerciseConn();

private:

   DtExerciseConn(const DtExerciseConn& orig);

   DtExerciseConn& operator=(const DtExerciseConn& orig);

public:


   virtual void addPduCallback( DtPduKind pduKind, DtPduCallbackFcn fcn, void *usr);

   virtual void removePduCallback( DtPduKind pduKind, DtPduCallbackFcn fcn, void *usr);

   virtual void addIffPduCallback(DtIffInteractionType type, DtPduCallbackFcn fcn, void* usr);

   virtual void removeIffPduCallback(DtIffInteractionType type, DtPduCallbackFcn fcn, void* usr);
   virtual int drainInput(DtTime timeout=-1, int nReadPerTimeCheck=100);

   virtual int readAndProcess(void);

   virtual int processPdu(DtPdu *pdu);

   virtual DtPdu *netRead(int *retCode = 0);

   virtual void addInterestInPduKind(DtPduKind kind);

   virtual void subtractInterestInPduKind(DtPduKind kind);

   virtual DtPduKind readUntil(DtPredicate predicate, void *arg, 
      DtTime timeout, DtTime sleepTime=0.1);

   virtual void addInterestInMcastAddr(const DtInetAddr& addr);

   virtual void subtractInterestInMcastAddr(const DtInetAddr& addr);

   virtual void send(const DtStateMsg &msg);

   virtual void send(const DtInteraction &msg);

   virtual void sendStamped(const DtStateMsg &msg);

   virtual void sendStamped(const DtInteraction &msg);

   virtual int send(
      const DtPdu &pdu, const DtInetAddr* addr = 0);

   virtual int sendStamped(
      const DtPdu &pdu, const DtInetAddr* addr = 0);

   virtual DtInetAddr* destinationAddr(const DtPdu &pdu);

   virtual bool addDestination(const DtInetAddr& destination, DtU16 port=0);

   virtual bool removeDestination(const DtInetAddr& destination, DtU16 port=0);

   virtual void setExerciseId(int exercise_id);

   virtual DtExerciseId exerciseId() const;

   virtual const DtEventID& nextEventId();

   virtual DtInetSocket* socket();


   virtual DtPduFactory *pduFactory();

   virtual DtPduEncoderFactory* pduEncoderFactory();

   virtual DtPduDecoderFactory* pduDecoderFactory();

   virtual void setPduFactory(DtPduFactory* fact);

   virtual DtStateRepositoryExtensionEncoderFactory* stateRepoExtensionEncoderFactory();

   virtual DtStateRepositoryExtensionDecoderFactory* stateRepoExtensionDecoderFactory();

   virtual void enableFiltering();

   virtual void disableFiltering();

   virtual void setTimeStampType(DtTimeStampType relOrAbs);

   virtual DtTimeStampType timeStampType() const;

   virtual void setTimeStampType(int relOrAbs);

   virtual DtDisObjectManager* disObjectManager();



   virtual void setDefaultOwnershipHandler(DtOwnershipHandler* ownershipHandler);
   virtual DtOwnershipHandler* defaultOwnershipHandler();

   void setRelativeTimeRatio(float ratio);
   float relativeTimeRatio();

   virtual void setAttributePduStrategy(DtAttributePduStrategy strat);
   virtual DtAttributePduStrategy attributePduStrategy() const;

   void setPduInterceptor(DtPduInterceptFcn interceptor);
   DtPduInterceptFcn pduInterceptor() const;

public:

   static DtString vrlinkVersion();

   static const int nSizeMismatchComplain;

protected:


   virtual DtTime currentTimeForStamping();

   void init0(int port, int exerId, int siteId, int applNum, 
      InitializationStatus* status, bool async_io, bool useIpv6, 
      bool suppressSelfReflect);
   
   void init0(DtInetSocket* s, int exerId, int siteId, int applNum, 
      InitializationStatus* status);

   virtual void setRemoteEndpoint( const DtInetAddr& addr, int port );

   void init(DtInetSocket* s, int deleteSkt, 
      int exerId, int siteId, int applNum, InitializationStatus* status);

   DtDisSocket* initializeSocket(const DtInetAddr& address, int port, 
      bool useAsyncIo, DtInetDevice* device, bool suppressSelfReflect);

protected:
   DtExerciseId myExerciseId; 
   int availEventNum;
   int deleteSocket;
   DtPduCallbackManager myPduCbMgr;
   DtIffPduCallbackManager myIffPduCbMgr;
   int pduInterest[DtMAX_PDU_KINDS + 1];
   void zeroPduInterestList();
   int nSizeMismatch;
   bool filtering;
   DtHashlist mcastAddrs;
   DtPduFactory* myPduFact;
   DtPduFactory* myDfltPduFact;
   DtPduEncoderFactory* myPduEncFact;
   DtPduDecoderFactory* myPduDecFact;
   DtStateRepositoryExtensionEncoderFactory* myStateRepoExtensionEncFac;
   DtStateRepositoryExtensionDecoderFactory* myStateRepoExtensionDecFac;
   DtEventID myCurrentEventId;
   DtTimeStampType myRelOrAbs;
   DtDisObjectManager* myDisObjectManager;
   DtOwnershipHandler* myOwnershipHandler;
   DtPduInterceptFcn myPduInterceptor;

   DtInetSocket*     mySocket;
   DtInetEndpoint    myRemoteEndpoint;
   DtInetBufferChain myBufferChain;
   DtInetBuffer      myBuffer;
   char*             myPacketBuffer;
   DtInetEndpoint    myEndpointReceivedFrom;

   // Correction coefficient for relative time correction
   float myRelativeTimeRatio; 

   // How we should send attribute PDUs
   DtAttributePduStrategy myAttributePduStrategy;
};


inline DtExerciseConn::DtExerciseConn(int po, int ex, int si, 
   int ap, InitializationStatus* status, bool use_async_io, bool useIpv6,
   bool suppressSelfReflect) 
   : mcastAddrs()
   , myRelOrAbs(DtTimeStampRelative)
   , myBufferChain()
   , myBuffer(DtDEFAULT_SOCK_BUFF_SIZE)
   , myPacketBuffer(0)
   , myEndpointReceivedFrom()
   , myOwnershipHandler(0)
   , myPduInterceptor(0)
   , myIffPduCbMgr(0)
   , myAttributePduStrategy(DtProtocolVersionToSend > 6 ? DtAttributePduStrategy_Couple : DtAttributePduStrategy_NoAttributePdu)
{ 
   init0(po, ex, si, ap,  status, use_async_io, useIpv6, suppressSelfReflect); 
}

inline DtExerciseConn::DtExerciseConn(
   DtInetSocket* so, int ex, int si, 
   int ap, InitializationStatus* status) 
   : mcastAddrs()
   , myRelOrAbs(DtTimeStampRelative)
   , myBufferChain()
   , myBuffer(DtDEFAULT_SOCK_BUFF_SIZE)
   , myPacketBuffer(0)
   , myEndpointReceivedFrom()
   , myOwnershipHandler(0)
   , myPduInterceptor(0)
   , myIffPduCbMgr(0)
   , myAttributePduStrategy(DtProtocolVersionToSend > 6 ? DtAttributePduStrategy_Couple : DtAttributePduStrategy_NoAttributePdu)
{
   init0(so, ex, si, ap,  status); 
}  

inline int DtExerciseConn::readAndProcess() 
{ 
   int result;
   DtPdu *pdu = netRead(&result);
   if (result == DtNET_READ_SUCCESS)      
   {
     result = processPdu(pdu);
   }
   if (pdu)
   {
      delete pdu;
   }
   return result;
}

inline DtExerciseId DtExerciseConn::exerciseId() const
{
   return myExerciseId; 
}

inline DtPduFactory *DtExerciseConn::pduFactory()
{
   return myPduFact;
}


inline DtPduEncoderFactory *DtExerciseConn::pduEncoderFactory()
{
   return myPduEncFact;
}


inline DtPduDecoderFactory *DtExerciseConn::pduDecoderFactory()
{
   return myPduDecFact;
}

inline DtStateRepositoryExtensionEncoderFactory* DtExerciseConn::stateRepoExtensionEncoderFactory()
{
   return myStateRepoExtensionEncFac;
}

inline DtStateRepositoryExtensionDecoderFactory* DtExerciseConn::stateRepoExtensionDecoderFactory()
{
   return myStateRepoExtensionDecFac;
}


inline DtInetSocket* DtExerciseConn::socket()
{
   return mySocket;
}

inline DtDisObjectManager* DtExerciseConn::disObjectManager()
{
   return myDisObjectManager;
}


#endif