objectProximitySensorMonitor.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file objectProximitySensorMonitor.h
//! \ingroup vreVrfmodel
//! \brief Monitor for managing sensor contact information communication
//!
//! This file defines the DtObjectProximitySensorMonitor class which manages
//! the communication of sensor contact information between a proximity sensor
//! and visualization systems. It handles sensor data subscriptions and notifications
//! when detected objects change.
 
#pragma once
 
#include "vreVrfmodel/export.h"
#include <list>
 
class DtSimMessage;
class DtSensorContactInfoList;
 
namespace makVre
{
 
//! \brief Monitor for managing proximity sensor contact information
//!
//! DtObjectProximitySensorMonitor manages the communication of sensor contact
//! information between a proximity sensor and visualization systems. It handles
//! subscription requests from clients, maintains a list of current subscribers,
//! and sends sensor data messages when the detected object list changes.
//!
//! This class serves a similar purpose to DtObjectSensorMonitor in VR-Forces,
//! but is specifically designed for the DtObjectProximitySensor which does not
//! use a DtObjectSensorPSR.
class VREVRFMODEL_DLL DtObjectProximitySensorMonitor
{
private:
   //! \brief Default constructor (not implemented)
   //!
   //! Default constructor is private and not implemented to prevent
   //! creation of instances without proper initialization.
   DtObjectProximitySensorMonitor();
 
   //! \brief Copy constructor (not implemented)
   //!
   //! Copy constructor is private and not implemented to prevent
   //! copy construction.
   DtObjectProximitySensorMonitor(const DtObjectProximitySensorMonitor& orig);
 
   //! \brief Assignment operator (not implemented)
   //! \return Reference to this object
   //!
   //! Assignment operator is private and not implemented to prevent assignment.
   const DtObjectProximitySensorMonitor& operator=(const DtObjectProximitySensorMonitor& 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
   //!
   //! Creates a new sensor monitor that will handle communication between the
   //! specified sensor and visualization clients.
   DtObjectProximitySensorMonitor(DtLocalObject* hostObject, const DtSensorContactInfoList* contactInfoList,
      const DtString& sensorName, int sensorType);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the object proximity sensor monitor.
   virtual ~DtObjectProximitySensorMonitor();
 
   //! \brief Initializes the monitor
   //! \return True if initialization is successful, false otherwise
   //!
   //! Initializes the monitor by registering message callbacks to handle
   //! subscription requests from clients. Called after construction.
   virtual bool init();
 
   //! \brief Registers message callbacks for sensor data requests
   //!
   //! Registers callback functions to handle sensorDataRequest and
   //! sensorDataUnsubscribe messages from visualization clients.
   virtual void registerMessageCallbacks();
 
   //! \brief Static callback function for sensor data request messages
   //! \param msg The simulation message containing the request
   //! \param usrData User data pointer (contains the monitor instance)
   //!
   //! Static function registered as a callback to handle sensor data request
   //! messages. Forwards the request to the appropriate monitor instance.
   static void sensorDataRequestCallback(DtSimMessage* msg, void* usrData);
 
   //! \brief Processes a sensor data request message
   //! \param msg The simulation message containing the request
   //!
   //! Handles subscription or unsubscription requests for sensor data,
   //! updating the subscriber list and sending initial data when needed.
   virtual void processSensorDataRequest(DtSimMessage* msg);
 
   //! \brief Creates and sends a sensor data message to subscribers
   //!
   //! Constructs a DtSensorData message based on the current state of
   //! the sensor's contact list and sends it to all current subscribers.
   //! This provides visualization clients with up-to-date sensor contact information.
   virtual void createAndSendSensorDataMessage();
 
   //! \brief Notifies that the sensor's target list has changed
   //!
   //! Called by the object proximity sensor whenever the list of detected objects
   //! changes. This triggers sensor data messages to be sent out to all current
   //! subscribers, ensuring they have the latest detection information.
   virtual void notifyTargetsChanged();
 
protected:
   //! \brief Checks if an address is on the subscriber list
   //! \param id The client identifier to check
   //! \return True if the client is a current subscriber, false otherwise
   //!
   //! Determines if the specified client identifier is currently in the
   //! list of subscribers for this sensor's data.
   virtual bool onSubscriberList(const DtU64 id) const;
 
   //! \brief Adds a client to the subscriber list
   //! \param id The client identifier to add
   //!
   //! Adds the specified client identifier to the list of subscribers
   //! for this sensor's data.
   virtual void addToSubscriberList(const DtU64 id);
 
   //! \brief Removes a client from the subscriber list
   //! \param id The client identifier to remove
   //!
   //! Removes the specified client identifier from the list of subscribers
   //! for this sensor's data.
   virtual void removeFromSubscriberList(const DtU64 id);
 
   //! \brief Gets the number of current subscribers
   //! \return The number of clients currently subscribed to this sensor's data
   //!
   //! Returns the count of clients currently subscribed to receive
   //! sensor data updates.
   virtual int numberOfSubscribers();
 
protected:
   //! \brief Pointer to the local object that owns the sensor
   //!
   //! The entity object that owns the sensor this monitor is associated with.
   DtLocalObject* myHostObject;
 
   //! \brief Pointer to the sensor's contact information list
   //!
   //! Contains the current list of objects detected by the sensor.
   const DtSensorContactInfoList* mySensorContactInfoList;
 
   //! \brief Type identifier for the sensor
   //!
   //! Numeric identifier for the type of sensor being monitored.
   int mySensorType;
 
   //! \brief Name of the sensor
   //!
   //! String identifier for the sensor being monitored.
   DtString mySensorName;
 
   //! \brief Type definition for the subscriber list
   //!
   //! Defines the container type used to store the list of subscriber IDs.
   using DtSubscriberList = std::list<DtU64>;
 
   //! \brief List of current subscribers
   //!
   //! Contains the identifiers of all clients currently subscribed
   //! to receive sensor data updates.
   DtSubscriberList mySubscriberList;
};
 
} // namespace makVre