serverExerciseConnection.h

Go to the documentation of this file.

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


#pragma once

#include "clientServerExConnDllDefines.h"

#include <vl/exerciseConnHLA.h>

#include <map>
#include <vector>

class DtMutex;

namespace MAKTrafficClientServerExConn
{
   class DtClientExerciseConnection;
   class DtServerFederateAmbassador;
   class DtServerRtiAmbassador;

   typedef std::map<unsigned int, DtClientExerciseConnection*> DtClientConnectionMap;

   typedef void (*DtAddConnectionCb)(DtClientExerciseConnection* conn, void* usr);
   typedef DtAddConnectionCb DtRemoveConnectionCb;
   typedef std::map<void*, DtAddConnectionCb> DtAddConnectionCbMap;
   typedef std::map<void*, DtRemoveConnectionCb> DtRemoveConnectionCbMap;

   class DT_DLL_CSEC DtServerExerciseConnection : public DtExerciseConn
   {

   public:

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

      DtServerExerciseConnection(const char* execName, 
         const char* federateType,
         DtFomMapper* mapper = DtRprFomMapper::create(0),
         const char* fedFileName = 0, 
         InitializationStatus* status = 0);

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

#if DtHLA_1516_EVOLVED


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



      DtServerExerciseConnection(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 ~DtServerExerciseConnection();

   private:

      DtServerExerciseConnection(const DtServerExerciseConnection& orig);

      DtServerExerciseConnection& operator=(const DtServerExerciseConnection& orig);

   public:

      virtual const DtString& clientExecName() const;

      virtual DtServerRtiAmbassador* serverRtiAmb();

      virtual const DtString& fedFileName() const;

      virtual const std::wstring& mimModule() const;

      virtual const DtString& mimModuleAscii() const;

      virtual const std::vector<std::wstring>& fomModules() const;

      virtual const std::vector<DtString>& fomModulesAscii() const;

      virtual void getFomModules(std::vector<std::wstring>& allFomModules) const;

      virtual void getFomModules(std::vector<DtString>& allFomModules) const;

      virtual DtServerFederateAmbassador* serverFederateAmbassador();

      virtual void setReceiveSelfReflect(unsigned long clientID, bool enableReceiveSelfReflect);

      virtual bool receiveSelfReflectEnabled(unsigned long clientID);

      virtual void prepareToResign();

      virtual void readyToResign(DtClientExerciseConnection* client);

      virtual void rejoined(DtClientExerciseConnection* client);

      virtual void forceResign();

      virtual bool doResign() const;

      virtual bool resignReady() const;

      virtual bool resignComplete() const;

      virtual bool resignOK() const;

      virtual bool isJoined() const;

      virtual bool resign();

      virtual bool rejoin(DtString const& execName);

      virtual bool clientsRejoined() const;

      virtual void connect(DtClientExerciseConnection* client);

      virtual void disconnect(DtClientExerciseConnection* client);

      virtual DtClientConnectionMap& clientConnections();

      virtual unsigned int nextConnectionID();

      virtual void addConnectionAddedCallback(DtAddConnectionCb cbFunction, void* usr);

      virtual void removeConnectionAddedCallback(DtAddConnectionCb cbFunction, void* usr);

      virtual void addConnectionRemovedCallback(DtRemoveConnectionCb cbFunction, void* usr);

      virtual void removeConnectionRemovedCallback(DtRemoveConnectionCb cbFunction, void* usr);

      virtual int invokeCallbacks(DtClientExerciseConnection* client,
         double maximum=-1, double minimum=0);

      virtual void getLateJoinDiscoveries(DtClientExerciseConnection* lateJoiner);



      virtual bool lockServiceCall();

      virtual void unlockServiceCall();

      virtual bool serviceCallLocked();

      virtual bool enterServiceCall();

      virtual void exitServiceCall();

      virtual bool inServiceCall();

   public:



      static DtServerExerciseConnection* create(const DtExerciseConnInitializer& init, InitializationStatus* status = 0);
      static DtServerExerciseConnection* create(const char* execName, 
         const char* federateType,
         DtFomMapper* mapper = DtRprFomMapper::create(0),
         const char* fedFileName = 0, 
         InitializationStatus* status = 0);
      static DtServerExerciseConnection* create(const char* execName, 
         const char* federateType,
         const char* dsoName, 
         const char* fedFileName = 0,
         void* fomMapInitData = 0, 
         InitializationStatus* status = 0);
#if DtHLA_1516_EVOLVED
      static DtServerExerciseConnection* create(const char* execName,
         const char* federateName,
         const char* federateType,
         const DtString& fedFile,
         DtFomMapper* mapper = DtRprFomMapper::create(0),
         const DtString& mimModule = "",
         const std::vector<DtString>& fomModules = std::vector<DtString>(),
         InitializationStatus* status = 0 );
      static DtServerExerciseConnection* create(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



      static DtServerExerciseConnection* setInstance(DtServerExerciseConnection* serverExConn,
         bool replace=false);

      static DtServerExerciseConnection* getInstance(bool blocking=true);

      static bool theCreateServerConnectionFailed;

   protected:

      void init(InitializationStatus* status = 0);

      // that was previously subscribed and published
      virtual bool reSubscribeAndPublish();

      virtual void removeAllObjects();

   protected:

      DtClientConnectionMap myClientConnections;

      unsigned int myNextConnectionID;

      DtAddConnectionCbMap myAddConnCb;

      DtRemoveConnectionCbMap myRemoveConnCb;

      std::set<unsigned int> myPendingReadyToResign;

      std::set<unsigned int> myPendingRejoined;

      bool myDoResign;

      DtMutex* myCallbackMutex;

      unsigned int myLockService;

      unsigned int myInService;

      DtServerFederateAmbassador* myServerFederateAmbassador;

      DtServerRtiAmbassador* myServerRtiAmbassador;

      bool myResignOK;

      bool myIsJoined;

      std::vector<DtString> myFomModulesAscii;

      DtString myMimFomModuleAscii;

#ifndef DtHLA_1516_EVOLVED
      // Dummy place holders to return by reference
      std::vector<std::wstring> myFomModules;
      std::wstring myMimFomModule;
#endif


   protected:

      static DtServerExerciseConnection* theServerConnection;
   };
}