remoteControlInterface.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 1992-2010 VT MAK
** All rights reserved.
******************************************************************************/



#pragma once

#include "lgrRemoteControlInterface.h"

#include <lcRemoteLoggerConnection.h>

#include <vlutil/vlString.h>
#include <vlpi/entityIdentifier.h>
#include <vlutil/vlInetSocket.h>

#include <list>
#include <map>
#include <set>

class DtExerciseConn;
class DtInteraction;
class DtLgrControlPdu;
class DtEntityIdentifier;
class DtLgrAcknowledgePdu;
class DtLgrConnectPdu;
class DtLgrDisconnectPdu;
class DtLgrLgrHeartbeatPdu;
class DtLgrResponsePdu;
class DtLgrTotalStatePdu;
class DtInetSocket;

namespace MAKLogger
{
   class DtAbsoluteTime;
   class DtRelativeTime;
   class DtCommand;
   class DtRemoteControlDomainInterface;
   class DtRemoteControlSystemInterface;
   class DtRemoteControlPlaybackInterface;
   class DtRemoteControlRecordInterface;
   class DtRemoteControlEditorInterface;
   class DtRemoteControlSimulationInterface;
   class DtRemoteControlSharedInterface;

   typedef DtU32 DtSequenceNumber;
   typedef std::set<DtSequenceNumber> DtSequenceNumberSet;
   typedef std::set<DtEntityIdentifier> DtEntityIdSet;

   typedef void (*DtLgrConnectCb)( DtLgrConnectPdu* connect, void* usr );
   typedef void (*DtLgrDisconnectCb)( DtLgrDisconnectPdu* connect, void* usr );
   typedef void (*DtLgrLgrHeartbeatCb)( DtLgrLgrHeartbeatPdu* connect, void* usr );
   typedef void (*DtLgrAcknowledgeCb)( DtLgrAcknowledgePdu* connect, void* usr );
   typedef void (*DtLgrResponseCb)( DtLgrResponsePdu* connect, void* usr );
   typedef void (*DtLgrTotalStateCb)( DtLgrTotalStatePdu* connect, void* usr );
   typedef void (*DtLgrConnectionAddedCb)( const DtRemoteLoggerConnection& loggerConnection, void* usr );
   typedef void (*DtLgrConnectionRemovedCb)( const DtRemoteLoggerConnection& loggerConnection, void* usr );
   typedef void (*DtLgrConnectionTimedOutCb)( const DtRemoteLoggerConnection& loggerConnection, void* usr );

   typedef void (*DtLgrCommandAcceptedCb)( DtSequenceNumber sequenceNumber, void* usr );
   typedef void (*DtLgrCommandRejectedCb)(const DtEntityIdentifier& source,  DtSequenceNumber sequenceNumber, void* usr );
   typedef void (*DtLgrCommandTimedOutCb)( DtSequenceNumber sequenceNumber, void* usr );
   

   class DT_DLL_LGR_RCI DtRemoteControlInterface
   {
   public:
      DtRemoteControlInterface(int numberOfLoggersToManage=0);

      virtual ~DtRemoteControlInterface();

   private:
      DtRemoteControlInterface(const DtRemoteControlInterface&);
      DtRemoteControlInterface& operator=(const DtRemoteControlInterface&);

   public:

      virtual void setConnection(DtExerciseConn* exconn, const DtEntityIdentifier& entityId);

      virtual void setConnection(const DtEntityIdentifier& id, DtInetSocket* socket);

      virtual void clearConnection();

      virtual void disconnect(const DtEntityIdentifier& entityId);

      virtual void tick();

      virtual void setId( const DtEntityIdentifier& id );
      virtual const DtEntityIdentifier& id() const;

      virtual void setAcceptAnyId( bool acceptAny);
      virtual bool acceptAnyId() const;

      virtual DtTime connectionTimeout() const;
      virtual void setConnectionTimeout(DtTime val);

      virtual DtTime acknowledgeTimeout() const;
      virtual void setAcknowledgeTimeout(DtTime val);

      virtual void setNumberOfLoggers(int numberOfLoggersToManage);
      virtual int numberOfLoggers() const;

      virtual void setPassivelyAccepting(bool enablePassivelyAccept);
      virtual bool isPassivelyAccepting() const;

      virtual void getConnectionIds(DtEntityIdSet& connectedLoggers) const;

      virtual void getConnectionIds(DtEntityIdSet& connectedLoggers,
         const DtEntityIdentifier& idFilter) const;

      virtual int numberConnections() const;

      virtual DtRemoteLoggerConnection* getConnection(const DtEntityIdentifier& id);

      virtual DtTime lowestTime() const;

      virtual DtTime highestTime() const;


      virtual DtRemoteControlSystemInterface* systemInterface();
      virtual DtRemoteControlPlaybackInterface* playbackInterface();
      virtual DtRemoteControlRecordInterface* recordInterface();
      virtual DtRemoteControlEditorInterface* editorInterface();
      virtual DtRemoteControlSimulationInterface* simulationInterface();
      virtual DtRemoteControlSharedInterface* sharedInterface();

      virtual DtSequenceNumber sendCommandMessage(const DtCommand& command,
         const DtEntityIdentifier& target=theWildcardAddress);

      virtual DtSequenceNumber sendCommandMessage(const DtCommand& command,
         DtRemoteControlDomainInterface* domainInterface,
         const DtEntityIdentifier& target=theWildcardAddress);

      virtual DtSequenceNumber sendLoggerControlMessage(DtLgrControlPdu& lgrControl,
         const DtEntityIdentifier& target=theWildcardAddress);

      virtual DtSequenceNumber sendLoggerControlMessage(DtLgrControlPdu& lgrControl,
         DtRemoteControlDomainInterface* domainInterface,
         const DtEntityIdentifier& target=theWildcardAddress);


      virtual void addCallback( DtLgrConnectCb cb, void* user );
      virtual void removeCallback( DtLgrConnectCb );

      virtual void addCallback( DtLgrDisconnectCb cb, void* user );
      virtual void removeCallback( DtLgrDisconnectCb );

      virtual void addCallback( DtLgrLgrHeartbeatCb cb, void* user );
      virtual void removeCallback( DtLgrLgrHeartbeatCb );

      virtual void addCallback( DtLgrAcknowledgeCb cb, void* user );
      virtual void removeCallback( DtLgrAcknowledgeCb );

      virtual void addCallback( DtLgrResponseCb cb, void* user );
      virtual void removeCallback( DtLgrResponseCb );

      virtual void addCallback( DtLgrTotalStateCb cb, void* user );
      virtual void removeCallback( DtLgrTotalStateCb );

      virtual void addCallbackConnectionAdded( DtLgrConnectionAddedCb cb, void* user );
      virtual void removeCallbackConnectionAdded( DtLgrConnectionAddedCb );

      virtual void addCallbackConnectionRemoved( DtLgrConnectionRemovedCb cb, void* user );
      virtual void removeCallbackConnectionRemoved( DtLgrConnectionRemovedCb );

      virtual void addCallbackConnectionTimedOut( DtLgrConnectionTimedOutCb cb, void* user );
      virtual void removeCallbackConnectionTimedOut( DtLgrConnectionTimedOutCb );

      virtual void addCallbackCommandAccepted( DtLgrCommandAcceptedCb cb, void* user );
      virtual void removeCallbackCommandAccepted( DtLgrCommandAcceptedCb );

      virtual void addCallbackCommandRejected( DtLgrCommandRejectedCb cb, void* user );
      virtual void removeCallbackCommandRejected( DtLgrCommandRejectedCb );

      virtual void addCallbackCommandTimedOut( DtLgrCommandTimedOutCb cb, void* user );
      virtual void removeCallbackCommandTimedOut( DtLgrCommandTimedOutCb );


   public:

      static const DtEntityIdentifier& wildcardAddress();

      static const char* commandToString(int domain, int command);

     const DtRemoteLoggerMap& getMyRemoteLoggerMap() const;

   protected:

      virtual void lgrCtrlCallback( DtInteraction* );

      virtual void processControlPdus();

      virtual void processBackChannel();

      virtual void checkConnections();

      virtual bool isIdMatching(const DtEntityIdentifier& targetId, bool allowWildCard=true);

      virtual DtSequenceNumber nextSequenceNumber();


      virtual void processTotalState(DtLgrTotalStatePdu* totalStatePdu);
      virtual void processConnect(DtLgrConnectPdu* connectPdu);
      virtual void processDisconnect(DtLgrDisconnectPdu* disconnectPdu);
      virtual void processLgrHeartbeat(DtLgrLgrHeartbeatPdu* lgrHeartbeatPdu);
      virtual void processAcknowledge(DtLgrAcknowledgePdu* acknowledgePdu);
      virtual void processResponse(DtLgrResponsePdu* responsePdu);

      virtual void commandAccepted(DtSequenceNumber sequenceNumber);

      virtual void commandRejected(const DtEntityIdentifier& source, DtSequenceNumber sequenceNumber);

      virtual void commandTimedOut(DtSequenceNumber sequenceNumber);

      virtual void sendMessage(const DtLgrControlPdu& message);

   protected:

      static void lgrCtrlCb( DtInteraction*, void* );

   protected:

      typedef struct DtPendingAcknowledge
      {
         DtTime timeout;
         DtEntityIdSet pending;
      } DtPendingAcknowledge;

      typedef std::map<DtSequenceNumber, DtPendingAcknowledge> DtPendingAcknowledgeList;
      typedef std::map<DtSequenceNumber, DtTime> DtRejectCommandList;
      typedef std::map<DtSequenceNumber, DtRemoteControlDomainInterface*> DtAcknowledgeDomainMap;

      typedef std::list<DtLgrControlPdu*> DtPduList;

   protected:


      DtExerciseConn* myExerciseCon;
      DtInetSocket* myBackChannelConnection;
      DtInetBuffer myBackChannelBuffer;
      DtEntityIdentifier myId;
      DtSequenceNumber mySequenceNumber;
      DtPduList myPduList;
      DtRemoteLoggerMap myRemoteLoggers;
      DtEntityIdSet myRemoteLoggerIds;
      DtEntityIdSet myRejectedLoggerIds;
      bool myAcceptAnyId;
      DtTime myConnectionTimeout;
      DtTime myNextTimeoutCheck;
      DtPendingAcknowledgeList myPendingAcknowledgements;
      DtRejectCommandList myRejectedCommands;
      DtTime MyAcknowledgeTimeout;
      int myNumberOfLoggers;
      DtAcknowledgeDomainMap myAcknowledgeInterface;
      DtClock myClock;
      bool myPassivelyAccepting;

      std::map<DtLgrConnectCb, void*> myConnectCallbacks;
      std::map<DtLgrDisconnectCb, void*> myDisconnectCallbacks;
      std::map<DtLgrAcknowledgeCb, void*> myAcknowledgeCallbacks;
      std::map<DtLgrResponseCb, void*> myResponseCallbacks;
      std::map<DtLgrTotalStateCb, void*> myTotalStateCallbacks;
      std::map<DtLgrLgrHeartbeatCb, void*> myHeartbeatCallbacks;
      std::map<DtLgrConnectionAddedCb, void*> myConnectionAddedCallbacks;
      std::map<DtLgrConnectionRemovedCb, void*> myConnectionRemovedCallbacks;
      std::map<DtLgrConnectionTimedOutCb, void*> myConnectionTimedOutCallbacks;
      std::map<DtLgrCommandAcceptedCb, void*> myCommandAcceptedCallbacks;
      std::map<DtLgrCommandRejectedCb, void*> myCommandRejectedCallbacks;
      std::map<DtLgrCommandTimedOutCb, void*> myCommandTimedOutCallbacks;

      DtRemoteControlSystemInterface* mySystemInterface;
      DtRemoteControlPlaybackInterface* myPlaybackInterface;
      DtRemoteControlRecordInterface* myRecordInterface;
      DtRemoteControlEditorInterface* myEditorInterface;
      DtRemoteControlSimulationInterface* mySimulationInterface;
      DtRemoteControlSharedInterface* mySharedInterface;

   protected:
      static const DtU16 theAddressWildcard = ((1<<16)-1); // 65535 or 0xFFFF
      static const DtEntityIdentifier theWildcardAddress;

   };
}