simObjectNetInterface.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2015 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/



#pragma once

#include "vrlinkNetworkInterface/vrlinkNetworkInterfaceDefines.h"
#include "vrlinkNetworkInterface/simObjectNetInterfaceFactory.h"
#include "vrlinkNetworkInterface/netInterfaceParallelLock.h"
#include "vrfutil/vrfCallbackQueue.h"
#include <tbb/spin_rw_mutex.h>
#include <tbb/spin_mutex.h>
#include <tbb/mutex.h>
#include <vl/publisherContainer.h>
#include <boost/signals2.hpp>

#include <vlpi/entityIdentifier.h>

#if DtHLA
#include <vl/rtiCompatibility.h>
#endif

class DtObjectPublisher;

class DtStateRepository;

namespace makVrf
{
   class DtNonVrfUUIDResolver;
   class DtVrlinkNetworkInterface;
   class DtSimObjectNetInterfaceFactory;

   class DT_DLL_vrlinkNetworkInterface DtSimObjectNetInterface
   {
   private:
      DtSimObjectNetInterface();

      DtSimObjectNetInterface(const DtSimObjectNetInterface & orig);

      const DtSimObjectNetInterface & operator=(const DtSimObjectNetInterface & 
         orig);

   public:

      class ParallelContainer : public DtVrfCallbackQueue::CallbackInterface
      {
      public:
         ParallelContainer(DtSimObjectNetInterface* sd)
            : CallbackInterface()
            , myNetInterface(sd)
         {
            myNetworkInterfaceDeletedConnection = myNetInterface->signal_networkInterfaceDeleted.connect(
               boost::bind(&ParallelContainer::networkInterfaceDeleted, this));
         }

         virtual ~ParallelContainer() override {
            myNetworkInterfaceDeletedConnection.disconnect();
         }

         virtual void run() override;
         virtual void networkInterfaceDeleted();

         DtSimObjectNetInterface* myNetInterface;
         tbb::spin_mutex myTickMutex;
         boost::signals2::connection myNetworkInterfaceDeletedConnection;
      };

      DtVrfCallbackQueue::CallbackInterface::Ptr parallelContainer()
      {
         if (!myParallelContainer)
         {
            myParallelContainer = DtVrfCallbackQueue::CallbackInterface::Ptr(new ParallelContainer(this));
         }

         return myParallelContainer;
      }

      DtSimObjectNetInterface(DtStateData * simObject, DtVrlinkNetworkInterface*, bool publishObject = true);

      virtual ~DtSimObjectNetInterface();

      virtual bool init(const DtEntityIdentifier& id = DtEntityIdentifier()) { return true; }

      virtual bool init(
#if DtHLA
      DtHlaObjectWithStateRep* obj,
      DtHlaObjectWithStateRep* extendedAttributes = nullptr
#else
      DtEntityStateRepository* obj
#endif
      ) { return true; }

      virtual void tick();

      virtual void onTick() = 0;

      virtual bool isUnit() const = 0;
      virtual bool isEntity() const = 0;
      virtual bool isEnvironmental() const = 0;

      virtual bool wantsToCreatePublisher() const = 0;

#if DtHLA_1516_EVOLVED
      virtual bool checkForNameReservation();
#endif

      virtual bool isLocal() const = 0;

      virtual DtString type() const = 0;
   
      virtual int maxNameLength() const;

      virtual void toBeRemoved();

      virtual bool publishObject() const
      {
         return false;
      }

   #if DtHLA
      virtual RTI::ObjectClassHandle objectClassHandle() const = 0;
   #endif

      static void setNonVrfObjectsUUIDScheme(const DtString&);
      static DtString nonVrfObjectsUUIDScheme();

      static void setNonVrfUUIDResolver(DtNonVrfUUIDResolver*);
      static DtNonVrfUUIDResolver* nonVrfUUIDResolver();

      static void addSimObjectNetInterfaceCreatorFcn(const DtString & type, 
         DtSimObjectNetIfaceCreatorFcn fcn);

      static void setFactory(DtSimObjectNetInterfaceFactory * factory);
      static DtSimObjectNetInterfaceFactory * factory();

      static DtSimObjectNetInterface * createNetInterface(
         const DtString & type, DtStateData* simObject, DtVrlinkNetworkInterface*, bool publishObject = true);

      static int maxNameLengthForInterfaceType(const DtString& interfaceTypeString);

      virtual void parallelTick();
      virtual void forceUpdate();

      boost::signals2::signal<void ()> signal_networkInterfaceDeleted;

#if DtDIS
      virtual void sendFinalPduOnDestruction(bool);
#endif

   protected:
      virtual void stateDataDestroyed();

      bool runFullyThreaded() const;

      const DtStateData* vrfObject() const
      {
         return mySimObject;
      }

      DtStateData* nextFrameVrfObject()
      {
         return mySimObject;
      }

      friend class DtVrlinkNetworkInterface;
      friend class DtPrintObjectStatusCommand;
      friend class DtPrintOrgViewCommand;

      virtual const DtStateRepository * networkState() const;

   public:
      static tbb::spin_rw_mutex thePublisherCreationMutex;
      static tbb::spin_rw_mutex thePublisherTickMutex;

      bool isValid() const { return (mySimObject != nullptr); };

      virtual std::vector<DtGlobalObjectDesignator> associatedGlobalObjectDesignators() const;

   protected:

      DtStateData* mySimObject;
      DtVrlinkNetworkInterface* myObjectManager;
      DtStateRepository * myNetworkState;

      static DtSimObjectNetInterfaceFactory* theFactory;
      static DtNonVrfUUIDResolver* theNonVrfUUIDResolver;

      bool myNeedsNetworkSetup;

      DtNetInterfaceParallelLock myLock;
      boost::signals2::connection mySimObjectRemovalConnection;
      tbb::mutex myDeleteGuardMutex;
      DtVrfCallbackQueue::CallbackInterface::Ptr myParallelContainer;
   };
}