cigiSession.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2024 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
#pragma once
 
//! @file cigiSession.h
//!
//! @brief DtCigiSession instances manage a connection to a single CIGI IG, and
//! all associated Publishers.
 
#include "vreCigiHost/export.h"
#include "vreCigiHost/cigiHost.h"
#include "vreCigiHost/cigiIgControlPublisher.h"
#include "vreCigiHost/cigiStartOfFrameListener.h"
 
#include "vreUtil/initializer.h"
#include "vreUtil/baseClass.h"
 
#include <vlutil/vlInetSocket.h>
#include <vlutil/vlInetEndpoint.h>
 
#include <CigiTypes.h>
 
#include <memory>
#include <map>
 
class CigiHostSession;
class CigiOutgoingMsg;
 
namespace makVre
{
class DtCigiHost;
class DtCigiSimEntityPublisher;
 
 
class CIGIHOST_DLL DtCigiSession : public DtSpSubClass<DtCigiSession>
{
public:
   using ConfigPtr = std::shared_ptr<DtInitializer>;
 
   DtCigiSession();
   virtual ~DtCigiSession() override;
 
   //! @brief CIGI Major Version for this Session
   //! @return int representing CIGI Major Version
   virtual unsigned int version() const;
 
   virtual Sptr setHost(DtCigiHost& host);
   virtual DtCigiHost& host();
 
   virtual Sptr setConfig(ConfigPtr config);
   virtual ConfigPtr config();
 
   virtual Sptr setIgAddress(std::string address);
   virtual std::string igAddress();
 
   virtual void init();
 
   //! @brief Called once per Sim tick. Processes all incoming CIGI packets and may send outgoing CIGI packets.
   //!
   //!    DtCigiSession::tick is called from DtCigiHost::tick which is connected to
   //!    DtSimObjectManager::signal_advanceFrame.
   //!
   //!    DtCigiSession::ticks process all CIGI packets received from the IG and dispatches them to
   //!    the correct Listeners.
   //!
   //!    If a Start Of Frame is received from the IG indicating that the IG has advanced a frame, then
   //!    advanceFrame() will be called and the Publishers will be ticked and called upon to update and write
   //!    CIGI packet data. If no Start Of Frame has been received for the configured updTimeout time, the IG
   //!    will be marked as offline.
   //!
   //!    If the IG is offline, Publishers will not be ticked, nor called to update and write CIGI data; except
   //!    for the root DtCigiIgControlPublisher publisher, which will continue to heartbeat IGCtrl CIGI packets
   //!    once per second.
   //!
   //! @param dt Elapsed time in seconds since the last tick.
   virtual void tick(double dt);
 
   //! @brief Returns the Session frame number.
   //!
   //!   The Session frame number is published by DtCigiIgControlPublisher. The Session frame number does not
   //!   correspond to the IG frame number, but the Session frame number does advances when the IG frame
   //!   number advances.
   virtual unsigned int frame() const;
 
   //! @brief Advances the Session frame number, updates Publishers and sends CIGI data.
   //!
   //!   advanceFrame ticks the root Publisher (which in turn ticks all child Publishers), then calls
   //!   packAndSendFrame(), which will call upon Publishers to update and write CIGI data.
   virtual void advanceFrame();
 
   //! @brief Returns online status of IG.
   //!
   //!   The IG is considered online if a Start Of Frame packet has been received within the configured
   //!   udpTimeout window, and the Start Of Frame packet does not indicate that the IG is in Offline
   //!   Maintenance mode.
   virtual bool igOnline();
 
   //! @brief Returns true if the IG is online and has indicated that it is in Operate mode.
   virtual bool igRunning();
 
   //! @brief Begins the process of shutting down the Session.
   //!
   //!   IG Control Mode is set to Standby and all published CIGI entity states are set to Remove/Destroyed.
   //!   The Session will continue to tick until receipt of entity removal is confirmed or the IG times out,
   //!   at which point the IP socket is closed and sessionEnded() will return true.
   virtual void endSession();
 
   //! @brief Returns true if endSession() has been called.
   virtual bool endingSession();
 
   //! @brief Returns true if the process started by endSession() is complete.
   virtual bool sessionEnded();
 
   //! @brief Returns a smart pointer to the root Publisher, a DtCigiIgControlPublisher class.
   virtual DtCigiIgControlPublisher::Sptr rootPublisher();
 
   //! @brief Marks all publishers as dirty and clears list of publishers waiting for receipt confirmation.
   virtual void resetPublishers();
 
   virtual void addListener(DtCigiListenerBase::Sptr listener);
 
   virtual void requestFrameReceipt(DtCigiPublisherBase::Wptr publisher);
   virtual void frameConfirmedReceived(unsigned int receivedFrame);
 
   virtual Cigi_int8 terrainDatabaseId();
 
   //! @brief Gets the next available CIGI EntityID.
   //! @param forWho Publisher this ID will be assigned to. ID is freed when Publisher is deleted.
   //! @return A CIGI EntityID
   virtual Cigi_uint16 claimNextEntitytId(DtCigiPublisherBase::Sptr forWho);
 
   virtual bool useExtendedEntityType();
   virtual bool findShortEntityType(const DtEntityType& entityType, Cigi_uint16& found_id);
   virtual bool findCigiPartId(const DtEntityType& entityType, unsigned int partType, Cigi_uint8& found_id);
   virtual bool findMuzzleFlashType(const DtEntityType& munitionType, Cigi_uint16& found_id);
   virtual bool findDetonationType(const DtEntityType& munitionType, Cigi_uint16& found_id);
 
   //! @brief In Publish Ownship Only mode, only the entity(s) with a ViewControl attached are published.
   //! @return Bool indicating whether Publish Ownship Only mode is enabled.
   virtual bool publishOwnshipOnly();
 
   virtual bool findCigiViewType(const std::string& sensor, Cigi_uint8& found_type);
   virtual int firstViewId();
 
   using EntityPubPtr = std::shared_ptr<DtCigiSimEntityPublisher>;
 
   //! @brief Find the SimEntityPublisher associted with the given DtEntityIdentifier.
   //! @param entityId DtEntityIdentifier of the Sim Entity to find.
   //! @return Shared Pointer to SimEntityPublisher associated with entityId, if there is one.
   EntityPubPtr findEntity(const DtEntityIdentifier& entityId);
 
   //! @brief Find the SimEntityPublisher associated with the given entityId, or create one if not found.
   //! @param entityId DtEntityIdenifier of the Sim Entity to find, or to create a Publisher for.
   //! @return Shared Pointer to the SimEntityPublisher associated with the given entityId.
   EntityPubPtr findOrCreateEntity(const DtEntityIdentifier& entityId);
 
   virtual DtInitTable findConfigTableByType(const std::string& mapName, const DtEntityType& entityType);
 
   template <typename FIND_T, typename RETURN_T = FIND_T>
   bool findConfigParam(DtInitTable table, const std::string paramName, RETURN_T& ret)
   {
      if (table.isValid())
      {
         if (table.hasField(paramName))
         {
            ret = table.findData<FIND_T>(paramName);
            return true;
         }
      }
      return false;
   }
 
   //! @brief Creates a new Publisher of the type registered for the given CREATE_T and Session version.
   //! @tparam CREATE_T Type of Publisher to create. This is usually an abstract base type, and the
   //! actual instance will be a derived concete "V#" class.
   //! @return Shared Pointer to the new Publisher.
   template <class CREATE_T>
   std::shared_ptr<CREATE_T> createVersioned()
   {
      return CREATE_T::createVersion(version());
   }
 
protected:
   virtual void openSocket();
   virtual void initRootPublisher();
   virtual void initListeners();
   virtual void startSession();
 
   virtual DtCigiStartOfFrameListener::Sptr igStatus();
 
   virtual void checkForIncomingPackets();
 
   virtual void packAndSendFrame();
 
   virtual void updateTerrainDatabaseId();
   virtual bool findCigiDatabaseId(const std::string& terrain, Cigi_int8& found_id);
 
protected:
   DtCigiHost* myHost;
 
   ConfigPtr myConfig;
   unsigned int myVersion;
 
   std::string myOverrideIgAddress;
 
   std::shared_ptr<DtInetSocket> mySocket;
   DtInetEndpoint myIgEndpoint;
 
   std::shared_ptr<CigiHostSession> mySession;
 
   DtCigiIgControlPublisher::Sptr myIgControl;
 
   unsigned int myFrame;
   double myLastFrameTime;
   double myShutdownStarted;
 
   Cigi_int8 myTerrainDatabaseId;
 
   using SortedTypeSet = std::set<DtEntityType>;
   using SortedTypeSetMap = std::map<std::string, SortedTypeSet>;
   SortedTypeSetMap mySortedTypeSetMap;
 
   using BestTypeMatchMap = std::map<DtEntityType, DtInitTable>;
   using BestTypeMatchMapMap = std::map<std::string, BestTypeMatchMap>;
   BestTypeMatchMapMap myBestTypeMatchMapMap;
 
   using CigiIdMap = std::map<Cigi_uint16, DtCigiPublisherBase::Wptr>;
   CigiIdMap myCigiIdMap;
   Cigi_uint16 myLastUsedId;
 
   using FrameReceiptRequest = std::pair<DtCigiPublisherBase::Wptr, unsigned int>;
   using FrameReceiptMap = std::map<void*, FrameReceiptRequest>;
   FrameReceiptMap myFrameReceiptMap;
 
   using ListenerMap = std::map<Cigi_uint16, DtCigiListenerBase::Sptr>;
   ListenerMap myListenerMap;
 
   bool myFakeIgHeartbeat;
 
   bool myShuttingDown;
};
 
} // namespace makVre