exerciseConnHLA.h

Go to the documentation of this file.

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

#ifndef exerciseConnHLA_H_
#define exerciseConnHLA_H_

#if DtHLA 

#include "baseExerciseConn.h"
#include "callbacks.h"
#include "rprFomMapper.h"
#include "netnFomMapper.h"
#include "rtiCompatibility.h"
#include "eventId.h"
#include "vrlFederateAmbassador.h"
#include "vrlRtiAmbassador.h"
#include "exerciseConnInitializerHLA.h"
#include "vrlinkStateStateRepository.h"

#include <matrix/geodeticCoord.h>
#include <vlutil/vlVersion.h>
#include "userTagModifiers.h"


class DtInteraction;
class DtInteractionFactory;
class DtHlaObjectFactory;
class DtInteractionManager;
class DtHlaObjectManager;
class DtStateMsg;
class DtVrlFederateAmbassador;
class DtFom;
class DtFilename;
class DtDynamicLibrary;
class DtFomMapper;
class DtVRLinkStateManager;



class DT_DLL_VL DtExerciseConn : public DtBaseExerciseConn
{

public: 

   typedef DtVrlFederateAmbassador* (*DtFedAmbCreator)();
   typedef DtFomMapper* (*DtFomMapperCreator)(void* usr);
   typedef void (*DtFomMapperDeletor)(DtFomMapper*);

   typedef void (*DtRtiErrorCb)(const char* label, void* usr);

   typedef DtVrlRtiAmbassador* (*DtRtiAmbCreator)(const std::vector<std::wstring>&);

#if DtHLA_1516
   typedef DtTime (*DtLogicalTimeToVrlTimeConverter) (const RTI::LogicalTime &theLogicalTime);
   typedef std::auto_ptr<RTI::LogicalTime>(*DtVrlTimeToLogicalTimeConverter) (const DtTime &time);
#else
   typedef DtTime (*DtFedTimeToVrlTimeConverter) (const RTI::FedTime &theFedTIme);
   typedef RTI::FedTime* (*DtVrlTimeToFedTimeConverter) (const DtTime &time);
#endif

   enum InitializationStatus {
      DtINIT_SUCCESS                = 0,
      DtCOULD_NOT_CREATE_RTIAMB     = 1,
      DtCOULD_NOT_CREATE_FEDEX      = 2,
      DtCOULD_NOT_JOIN_FEDEX        = 3,
      DtCOULD_NOT_OPEN_FED          = 4,
      DtCOULD_NOT_PARSE_FED         = 5,
      DtCOULD_NOT_FIND_FOMMAPPER    = 6,
      DtERROR_OPENING_FOMMAPPER_LIB = 7,
      DtCOULD_NOT_CONNECT_RTIAMB    = 8

   };

public: 

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

   DtExerciseConn(const char* execName, 
                  const char* federateType,
                  DtFomMapper* mapper = defaultFomMapper(),
                  const char* fedFileName = 0, 
                  InitializationStatus* status = 0
                  );

   DtExerciseConn(const char* execName, 
                  const char* federateType,
                  const char* dsoName, 
                  const char* fedFileName = 0,
                  void* fomMapInitData = 0, 
                  InitializationStatus* status = 0
                  );

#if DtHLA_1516_EVOLVED


   
   DtExerciseConn(const char* execName,
      const char* federateName,
      const char* federateType,
      const DtString& fedFile,
      DtFomMapper* mapper = defaultFomMapper(),
      const DtString mimModule = "",
      const std::vector<DtString>& fomModules = std::vector<DtString>(),
      InitializationStatus* status = 0 );



   DtExerciseConn(const char* execName,
                  const char* federateName,
                  const char* federateType,
                  const DtString& fedFile,
                  const char* dsoName,
                  void* fomMapInitData = 0, 
                  const DtString mimModule = "",
                  const std::vector<DtString>& fomModules = std::vector<DtString>(),
                  InitializationStatus* status = 0 );
#endif

   virtual ~DtExerciseConn();

private:

   DtExerciseConn(const DtExerciseConn& orig);

   DtExerciseConn& operator=(const DtExerciseConn& orig);

public:

   virtual void setReflecting();
   
   virtual bool reflecting() const;

   virtual void setPassiveMode();

   virtual bool passiveMode() const;


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

   virtual void setReflectRemoteUpdatesIntoPubFlag(bool onff);

   virtual bool reflectRemoteUpdatesIntoPubFlag() const;

   virtual void setReflectingThroughRti();

   virtual bool reflectingThroughRti() const;

   virtual void ignoreAdvisories();

   virtual bool usingAdvisories() const; 

   virtual void setRemoveObjectOnAttOutOfScope(bool remove);

   virtual bool enabledGenericAttributes() const;

#if DtHLA_1516_EVOLVED
   void listFederationExecutions();
#endif

   virtual void send(const DtStateMsg& msg);

   virtual void send(const DtInteraction& msg);

#if DtHLA_1516
   virtual void send(const DtInteraction& msg,
                     const RTI::RegionHandleSet* region);
#else
   virtual void send(const DtInteraction& msg,
                     const RTI::Region* region);
#endif

   virtual void sendStamped(const DtStateMsg& msg);

   virtual void sendStamped(const DtInteraction& msg);

   virtual void sendStampedWithRegion(const DtInteraction& msg,
      DtDDMRegionSP region);

#if DtHLA_1516
   virtual void sendStamped(const DtInteraction& msg,
                            const RTI::RegionHandleSet* region);
#else
   virtual void sendStamped(const DtInteraction& msg,
                            const RTI::Region* region);
#endif

   virtual DtTime currentTimeForStamping();

   virtual int drainInput(DtTime maxTime = -1, DtTime minTime = 0.0);

   virtual void setObjectIdForEventId(const DtGlobalObjectDesignator& id);

   virtual const DtEventID& nextEventId();

   virtual DtVrlRtiAmbassador* rtiAmb();

   virtual DtVrlFederateAmbassador* fedAmb();

   virtual RTI::FederateHandle fedHandle() const;

   virtual const DtString& fedType() const;

#if DtHLA_1516_EVOLVED
   virtual const DtString& fedName() const;
#endif

   virtual const DtString& execName() const;
   
   virtual bool isUsingMakRti() const;

   virtual DtString rtiName() const;

   virtual DtString rtiVersion() const;

   virtual DtString rtiError() const;

   virtual DtFom* fom();

   virtual DtInteractionFactory* interactionFactory();

   virtual DtHlaObjectFactory* objectFactory();

   virtual DtFomMapper* fomMapper() const;

   virtual DtHlaObjectManager* hlaObjectManager();

   virtual void setTimeStampType(DtTimeStampType relOrAbs);
   
   virtual DtTimeStampType timeStampType() const;

   virtual void addInteractionCallback(RTI::InteractionClassHandle h,
                                       DtReceiveInteractionCb cb,
                                       void* usr,
                                       DtDDMRegionSP region = DtDDMRegionSP());
   
   virtual void addInteractionCallbackByName(const char* className,
                                             DtReceiveInteractionCb cb,
                                             void* usr,
                                             DtDDMRegionSP region = DtDDMRegionSP());

   virtual void removeInteractionCallback(RTI::InteractionClassHandle h,
                                          DtReceiveInteractionCb cb,
                                          void* usr,
                                          DtDDMRegionSP region = DtDDMRegionSP());

   virtual void removeInteractionCallbackByName(const char* className,
      DtReceiveInteractionCb cb,
      void* usr, DtDDMRegionSP region = DtDDMRegionSP());

   virtual void addDiscoverObjectCallback(RTI::ObjectClassHandle h,
                                          DtDiscoverObjectCb cb,
                                          void* usr);

   virtual void removeDiscoverObjectCallback(RTI::ObjectClassHandle h,
                                             DtDiscoverObjectCb cb,
                                             void* usr);

   virtual void addRemoveObjectCallback(
#if DtHLA_1516
                                        RTI::ObjectInstanceHandle id,
#else
                                        RTI::ObjectHandle id,
#endif
                                        DtRemoveObjectCb cb,
                                        void* usr);

   virtual void removeRemoveObjectCallback(
#if DtHLA_1516
                                           RTI::ObjectInstanceHandle id,
#else
                                           RTI::ObjectHandle id,
#endif
                                           DtRemoveObjectCb cb,
                                           void* usr);

   virtual void setDestroyFedExecFlag(bool flag);
   
   virtual bool destroyFedExecFlag();

   virtual void setReplyingToSynchronizationPoints(bool yesNo);
   
   virtual bool replyingToSynchronizationPoints();

   virtual void replyToSynchronizationPoint(const char* label);

   virtual void setAutoSubscribeFlag(bool flag);
   
   virtual bool autoSubscribeFlag() const;

   virtual void setSendFedTime(bool flag);
   
   virtual bool sendFedTime() const;

   virtual void setUseGeographicDdm(bool flag);

   virtual bool useGeographicDdm() const;

   virtual void setDeleteOnOutOfScope(bool yesNo);

   virtual bool deleteOnOutOfScope() const;

#if DtHLA_1516
   virtual RTI::LogicalTimeFactory *logicalTimeFactory() const;

#endif

   virtual void registerSynchronizationPoint(const DtString& label);
   
   virtual void registerSynchronizationPoint(
      const DtString& label,    
#if DtHLA_1516
      const RTI::VariableLengthData& tag);
#else
      const DtString& tag);
#endif

   virtual void addFederateSaveCb(const DtString& label,
      DtFederateSaveCb func, void* usr);
   virtual void addFederateSaveCb(DtFederateSaveCb func, void* usr);

   virtual void addFederateRestoreCb(const DtString& label,
      DtFederateSaveCb func, void* usr);
   virtual void addFederateRestoreCb(DtFederateSaveCb func, void* usr);

   virtual void removeFederateSaveCb(const DtString& label,
      DtFederateSaveCb func, void* usr);
   virtual void removeFederateSaveCb(DtFederateSaveCb func, void* usr);

   virtual void removeFederateRestoreCb(const DtString& label,
      DtFederateSaveCb func, void* usr);
   virtual void removeFederateRestoreCb(DtFederateSaveCb func, void* usr);

   virtual void addSynchPointRegistrationSucceededCb(const DtString& label,
      DtSynchPointCb func, void* usr);
   
   virtual void addSynchPointRegistrationSucceededCb(DtSynchPointCb func,
      void* usr);

   virtual void removeSynchPointRegistrationSucceededCb(const DtString& label,
      DtSynchPointCb func, void* usr);

   virtual void removeSynchPointRegistrationSucceededCb(DtSynchPointCb func,
      void* usr);

   virtual void addSynchPointRegistrationFailedCb(const DtString& label,
      DtSynchPointCb func, void* usr);

   virtual void addSynchPointRegistrationFailedCb(DtSynchPointCb func, 
      void* usr);

   virtual void removeSynchPointRegistrationFailedCb(const DtString& label,
      DtSynchPointCb func, void* usr);

   virtual void removeSynchPointRegistrationFailedCb(DtSynchPointCb func, 
      void* usr);

   virtual void addFederationSynchedCb(const DtString& label, 
      DtSynchPointCb func, void* usr);

   virtual void addFederationSynchedCb(DtSynchPointCb func, 
      void* usr);

   virtual void removeFederationSynchedCb(const DtString& label, 
      DtSynchPointCb func, void* usr);

   virtual void removeFederationSynchedCb(DtSynchPointCb func, 
      void* usr);


   virtual void addRtiErrorCb(const DtString& label, DtRtiErrorCb func, 
      void* usr);
   virtual void removeRtiErrorCb(const DtString& label, DtRtiErrorCb func, 
      void* usr);
   virtual void addRtiErrorCb(DtRtiErrorCb func, void* usr);
   virtual void removeRtiErrorCb(DtRtiErrorCb func, void* usr);

#if DtHLA_1516_EVOLVED
   virtual void addConnectionLostCb(DtConnectionLostCb func,
      void* usr);
   virtual void removeConnectionLostCb(DtConnectionLostCb func, void *usr);
#endif

   virtual void addAnnounceSynchPointCb(const DtString& label, 
      DtAnnounceSynchPointCb func, void* usr);
   
   virtual void addAnnounceSynchPointCb(DtAnnounceSynchPointCb func, 
      void* usr);

   virtual void removeAnnounceSynchPointCb(const DtString& label,
      DtAnnounceSynchPointCb func, void* usr);

   virtual void removeAnnounceSynchPointCb(DtAnnounceSynchPointCb func, 
      void* usr);

   virtual void setDdmPlayBoxLowerBound(const DtGeodeticCoord& bound);

   virtual void setDdmPlayBoxUpperBound(const DtGeodeticCoord& bound);

   virtual const DtGeodeticCoord& ddmPlayBoxLowerBound() const;

   virtual const DtGeodeticCoord& ddmPlayBoxUpperBound() const;

   virtual void setObjectTagModifier(const DtString& className,
      DtObjectTagModifierSP modifier, bool applyToSubClasses = true);

   virtual void setInteractionTagModifier(const DtString& className,
      DtInteractionTagModifierSP modifier, bool applyToSubClasses = true);


   virtual void setGetValueMethod( DtExerciseConnInitializer::DtGetValueMethod getValueMethodChoice );
   virtual DtExerciseConnInitializer::DtGetValueMethod getValueMethod( ) const;

   virtual void setExecutionStatus(DtVRLExecutionStatus status);

   virtual bool isInitialized() const;

public:

#if DtHLA_1516
   static void setLogicalTimeFactoryFactoryParameter(std::wstring);
   
   static std::wstring logicalTimeFactoryFactoryParameter();
#endif
   static void setFedAmbCreator(DtFedAmbCreator creator);
   
   static DtFedAmbCreator fedAmbCreator();

   static void setRtiAmbCreator(DtRtiAmbCreator creator);
   
   static DtRtiAmbCreator rtiAmbCreator();

   static void overrideRidParameters(const std::map<DtString, DtString>& ridParams);

   static void setFomMapperCreator(DtFomMapperCreator creator,
                                   void* usr = 0);
   
   static DtFomMapperCreator fomMapperCreator();

   static DtFomMapper* defaultFomMapper();

#if DtHLA_1516
   static void setLogicalTimeToVrlTimeConverter(DtLogicalTimeToVrlTimeConverter func);
   static DtLogicalTimeToVrlTimeConverter logicalTimeToVrlTimeConverter();
#else
   static void setFedTimeToVrlTimeConverter(DtFedTimeToVrlTimeConverter func);
   static DtFedTimeToVrlTimeConverter fedTimeToVrlTimeConverter();
#endif

#if DtHLA_1516
   static void setVrlTimeToLogicalTimeConverter(DtVrlTimeToLogicalTimeConverter func);
   static DtVrlTimeToLogicalTimeConverter vrlTimeToLogicalTimeConverter();
#else
   static void setVrlTimeToFedTimeConverter(DtVrlTimeToFedTimeConverter func);
   static DtVrlTimeToFedTimeConverter vrlTimeToFedTimeConverter();
#endif

#if DtHLA_1516
   static DtTime defaultDtLogicalTimeToVrlTimeConverter( const RTI::LogicalTime &time);
#else
   static DtTime defaultDtFedTimeToVrlTimeConverter( const RTI::FedTime &time);
#endif

#if DtHLA_1516
   static std::auto_ptr<RTI::LogicalTime> defaultVrlTimeToLogicalTimeConverter( 
      const DtTime &time);
#else
   static RTI::FedTime* defaultVrlTimeToFedTimeConverter(const DtTime &time);
#endif
   
   static DtString vrlinkVersion();

   virtual bool callRtiErrorCallback(DtString &label);

protected:

   // Check if the RTI version supports 64-bit alignment for getValuePointer.
   bool checkRtiVersionForPointerAlignment();

   void initializeConnection(InitializationStatus* result);

   void initializeFomMapper(const char* dsoName, void* fomMapInitData, 
             InitializationStatus* result);

   void getFuncsFromSharedLib(DtDynamicLibrary& dso,
                              DtFomMapperCreator* creator, 
                              DtFomMapperDeletor* deletor);


   void handleFedFile(const DtString& fedFileName);

   int initFom(InitializationStatus* result);

   int createRtiAmb(InitializationStatus* result);

   int connectRtiAmb(InitializationStatus* result);

   int createFedEx(InitializationStatus* result);

   int createFedAmb(InitializationStatus* result);

   int joinFedEx(InitializationStatus* result);

   bool fedFileExists(const DtFilename &name) const;
   
#if DtHLA_1516_EVOLVED
   void setFomModules(const std::vector<DtString>& modules);

   void resignAndDisconnect();
#endif

#if DtHLA_1516
   virtual void rtiSend(DtInteraction& msg, RTI::InteractionClassHandle handle,
      const RTI::RegionHandleSet* region);
#else
   virtual void rtiSend(DtInteraction& msg, RTI::InteractionClassHandle handle,
      const RTI::Region* region);
#endif

#if DtHLA_1516
   virtual void selfReflectInteraction(DtInteraction& msg, RTI::InteractionClassHandle handle,
      const RTI::RegionHandleSet* region);
#else
   virtual void selfReflectInteraction(DtInteraction& msg, RTI::InteractionClassHandle handle,
      const RTI::Region* region);
#endif

protected:

   static void replyToSyncPointCallback(void* usr);

protected:

   struct DtGeneralRtiErrorCbInfo
   {
      DtRtiErrorCb cbFunction;
      void* userData;
   };

   struct DtLabelledRtiErrorCbInfo
   {
      DtString label;
      DtRtiErrorCb cbFunction;
      void* userData;
   };

   DtString myExecName;
   
   DtString myFedType;
#if DtHLA_1516_EVOLVED
   DtString myFedName;
#endif
#if DtHLA_1516
   std::auto_ptr<RTI::LogicalTimeFactory> myLogicalTimeFactory;
#endif
   DtVrlRtiAmbassador* myRtiAmb;
   RTI::FederateHandle myFedHandle;
   DtVrlFederateAmbassador* myFedAmb;

   DtFom* myFom;

   DtHlaObjectManager* myHlaObjectManager; 
   DtInteractionManager* myInteractionManager;  
   DtOwnershipHandler* myOwnershipHandler;

   DtFomMapper* myFomMapper;
   DtDynamicLibrary *myFomMapperDso;
   DtFomMapperCreator myDsoCreator;
   DtFomMapperDeletor myDsoDeletor;

   DtEventID myCurrentEventId;
   DtTimeStampType myRelOrAbs;

   bool myDestroyFedExFlag;
   bool myUseFomMapperDeletor;

   bool myGenericAttributes;
   bool myPassiveMode;
   bool myReflecting;
   bool myReflectRemoteUpdatesIntoPubFlag;
   bool myReflectingThroughRti;
   bool myReplyingToSynchronizationPoints;
   bool myUsingAdvisories;
   bool myAutoSubscribeFlag;
   bool mySendFedTimeFlag;
   DtExerciseConnInitializer::DtGetValueMethod myGetValueMethod;
   bool myPauseOnSaveRestore;

   bool myUseGeographicDdm;
   bool myDeleteOnOutOfScope;
#if DtHLA_1516_EVOLVED
   bool myIsConnected;
#endif

   DtString myRtiError;

   DtString myFedFile;

#if DtHLA_1516_EVOLVED
   std::vector<std::wstring> myFomModules;
   std::wstring myMimFomModule;

   std::wstring myLocalSettingsDesignator;
#elif DtHLA_1516
   std::vector<std::wstring> myRtiArguments;
#endif

#if DtHLA_1516
   RTI::VariableLengthData myTag;
#else
   DtString myTag;
#endif

   DtGeodeticCoord myDdmPlayBoxLowerBound;

   DtGeodeticCoord myDdmPlayBoxUpperBound;

   std::list<DtGeneralRtiErrorCbInfo> myRtiErrorCbList;
   std::list<DtLabelledRtiErrorCbInfo> myLabRtiErrorCbList;

   DtVRLinkStateManager* myVrlStateManager;

protected:

   static std::wstring myLogicalTimeFactFactParam;
   static DtFedAmbCreator theFedAmbCreator;
   static DtRtiAmbCreator theRtiAmbCreator;
   static DtFomMapperCreator theFomMapperCreator;
   static DtFomMapper* theDefaultFomMapper;
   static void* theFomMapInitData;
#if DtHLA_1516
   static DtVrlTimeToLogicalTimeConverter theVrlTimeToLogicalTimeConverter;
   static DtLogicalTimeToVrlTimeConverter theLogicalTimeToVrlTimeConverter;
#else
   static DtVrlTimeToFedTimeConverter theVrlTimeToFedTimeConverter;
   static DtFedTimeToVrlTimeConverter theFedTimeToVrlTimeConverter;
#endif

};

inline DtVrlRtiAmbassador* DtExerciseConn::rtiAmb()
{
   return myRtiAmb;
}

inline DtVrlFederateAmbassador* DtExerciseConn::fedAmb()
{
   return myFedAmb;
}

inline DtHlaObjectManager* DtExerciseConn::hlaObjectManager()
{
   return myHlaObjectManager;
}

inline DtFom* DtExerciseConn::fom()
{
   return myFom;
}

inline RTI::FederateHandle DtExerciseConn::fedHandle() const
{
   return myFedHandle;
}

#if DtHLA_1516_EVOLVED
inline const DtString& DtExerciseConn::fedName() const
{
   return myFedName;
}
#endif

inline const DtString& DtExerciseConn::fedType() const
{
   return myFedType;
}

inline const DtString& DtExerciseConn::execName() const
{
   return myExecName;
}


inline void DtExerciseConn::setSendFedTime(bool flag)
{
   mySendFedTimeFlag = flag;
}

inline bool DtExerciseConn::sendFedTime() const
{
   return mySendFedTimeFlag;
}

inline void DtExerciseConn::setUseGeographicDdm(bool flag)
{
   myUseGeographicDdm = flag;
}

inline bool DtExerciseConn::useGeographicDdm() const
{
   return myUseGeographicDdm;
}

inline void DtExerciseConn::setDeleteOnOutOfScope(bool yesNo)
{
   myDeleteOnOutOfScope = yesNo;
}

inline bool DtExerciseConn::deleteOnOutOfScope() const
{
   return myDeleteOnOutOfScope;
}

#endif
#endif