vreRadarObjectSensorMonitor.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file vreRadarObjectSensorMonitor.h
//! \ingroup vreVrfmodel
//! \brief Monitor for radar sensor contact information communication
//!
//! This file defines the DtVreRadarObjectSensorMonitor class which manages
//! the communication of radar sensor contact information between a radar system
//! and visualization systems. It handles subscription requests and notifications
//! when radar contacts change.
 
#pragma once
 
#include "vreVrfmodel/export.h"
 
#include <vrfmodel/objectSensorMonitor.h>
 
class DtSimMessage;
class DtRadarContactInfoList;
class DtObjectSensorPSR;
 
namespace makVre
{
class DtVreRadarObjectSensor;
 
//! \brief Monitor for radar sensor contact information communication
//!
//! DtVreRadarObjectSensorMonitor manages the communication of radar sensor
//! contact information between a radar system and visualization clients. It extends
//! the base ObjectSensorMonitor with VR-Engage specific functionality for handling
//! multiple subscriptions from the same client address and providing enhanced
//! radar contact information.
//!
//! This class manages the sending of radar sensor contact information to the
//! GUI from one particular sensor on an entity, handling subscription requests
//! and maintaining a list of current subscribers.
class VREVRFMODEL_DLL DtVreRadarObjectSensorMonitor : public DtObjectSensorMonitor
{
private:
   //! \brief Default constructor (not implemented)
   //!
   //! Default constructor is private and not implemented to prevent
   //! creation of instances without proper initialization.
   DtVreRadarObjectSensorMonitor();
 
   //! \brief Copy constructor (not implemented)
   //!
   //! Copy constructor is private and not implemented to prevent
   //! copy construction.
   DtVreRadarObjectSensorMonitor(const DtVreRadarObjectSensorMonitor& orig);
 
   //! \brief Assignment operator (not implemented)
   //! \return Reference to this object
   //!
   //! Assignment operator is private and not implemented to prevent assignment.
   const DtVreRadarObjectSensorMonitor& operator=(const DtVreRadarObjectSensorMonitor& orig);
 
public:
   //! \brief Constructor
   //! \param hostObject The local object that owns the sensor this monitor is for
   //! \param contactInfoList Pointer to the list of sensor contacts maintained by the sensor
   //! \param sensorName The name of the sensor being monitored
   //! \param sensorType The type identifier for the sensor being monitored
   //! \param psr Pointer to the process state repository for the sensor
   //!
   //! Creates a new radar sensor monitor that will handle communication between the
   //! specified radar system and visualization clients.
   DtVreRadarObjectSensorMonitor(DtLocalObject* hostObject, const DtSensorContactInfoList* contactInfoList,
      const DtString& sensorName, int sensorType, DtObjectSensorPSR* psr);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the radar object sensor monitor.
   virtual ~DtVreRadarObjectSensorMonitor() override;
 
   //! \brief Creates and sends a sensor data message to subscribers
   //!
   //! Constructs a DtSensorData message based on the current state of
   //! the sensor's process state repository (PSR), and sends it to all
   //! current subscribers. This provides visualization clients with up-to-date
   //! radar contact information.
   virtual void createAndSendSensorDataMessage() override;
 
   //! \brief Processes a sensor data request message
   //! \param msg The simulation message containing the request
   //!
   //! Handles subscription requests for radar sensor data,
   //! adding the client to the subscriber list and sending initial data.
   //! Overrides the base class implementation to use the counter-based
   //! subscriber list for better handling of multiple subscriptions.
   virtual void processSensorDataRequest(DtSimMessage* msg) override;
 
   //! \brief Processes a sensor data unsubscribe message
   //! \param msg The simulation message containing the unsubscribe request
   //!
   //! Handles unsubscription requests for radar sensor data,
   //! removing the client from the subscriber list. Overrides the base class
   //! implementation to use the counter-based subscriber list.
   virtual void processSensorDataUnsubscribe(DtSimMessage* msg) override;
 
protected:
   //! \brief Adds a client to the subscriber list
   //! \param add The simulation address of the client to add
   //!
   //! Overridden to use mySubscriberListCounter instead of the base member mySubscriberList
   //! to properly handle cases where more than one application uses the same SimulationAddress.
   //! Maintains a counter for each address to track multiple subscriptions from the same client.
   virtual void addToSubscriberList(const DtSimulationAddress& add) override;
 
   //! \brief Removes a client from the subscriber list
   //! \param add The simulation address of the client to remove
   //!
   //! Overridden to use mySubscriberListCounter instead of the base member mySubscriberList
   //! to properly handle cases where more than one application uses the same SimulationAddress.
   //! Decrements the counter for the address and only completely removes the client
   //! when the counter reaches zero.
   virtual void removeFromSubscriberList(const DtSimulationAddress& add) override;
 
   //! \brief Gets the number of current subscribers
   //! \return The number of clients currently subscribed to this radar sensor's data
   //!
   //! Returns the count of unique clients currently subscribed to receive
   //! radar sensor data updates. Overridden to use the counter-based subscriber list.
   virtual int numberOfSubscribers() override;
 
protected:
   //! \brief Pointer to the radar contact information list
   //!
   //! Contains the current list of radar contacts detected by the radar system.
   //! Cast from the base contact info list to the radar-specific type.
   const DtRadarContactInfoList* myRadarContactInfoList;
 
   //! \brief Type definition for the subscriber list with counter
   //!
   //! Defines the container type used to store simulation addresses of subscribers
   //! with a counter for each to track multiple subscriptions from the same client.
   using DtSubscriberListCounter = std::map<DtSimulationAddress, int>;
 
   //! \brief List of current subscribers with subscription counts
   //!
   //! Contains the simulation addresses of all clients currently subscribed
   //! to receive radar sensor data updates, with a count of subscriptions for each.
   DtSubscriberListCounter mySubscriberListCounter;
};
 
} // namespace makVre