radarStateMonitor.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file radarStateMonitor.h
//! \ingroup vreVrfmodel
//! \brief Monitor for managing radar state information communication
//!
//! This file defines the DtRadarStateMonitor class which manages
//! the communication of radar state information between a radar system
//! and visualization systems. It handles subscription requests and notifications
//! when radar state changes.
 
#pragma once
 
#include "vreVrfmodel/export.h"
 
class DtSimMessage;
class DtRwRadarStateInfo;
 
namespace makVre
{
 
//! \brief Monitor for managing radar state information communication
//!
//! DtRadarStateMonitor manages the communication of radar state information
//! between a radar system and visualization systems. It handles subscription
//! requests from clients, maintains a list of current subscribers, and sends
//! radar state messages when the radar state changes.
class VREVRFMODEL_DLL DtRadarStateMonitor
{
private:
   //! \brief Default constructor (not implemented)
   //!
   //! Default constructor is private and not implemented to prevent
   //! creation of instances without proper initialization.
   DtRadarStateMonitor();
 
   //! \brief Copy constructor (not implemented)
   //!
   //! Copy constructor is private and not implemented to prevent
   //! copy construction.
   DtRadarStateMonitor(const DtRadarStateMonitor& orig);
 
   //! \brief Assignment operator (not implemented)
   //! \return Reference to this object
   //!
   //! Assignment operator is private and not implemented to prevent assignment.
   const DtRadarStateMonitor& operator=(const DtRadarStateMonitor& orig);
 
public:
   //! \brief Constructor
   //! \param hostObject The local object that owns the radar this monitor is for
   //! \param contactInfoList Pointer to the radar state information maintained by the radar
   //!
   //! Creates a new radar state monitor that will handle communication between the
   //! specified radar system and visualization clients.
   DtRadarStateMonitor(DtLocalObject* hostObject, const DtRwRadarStateInfo* contactInfoList);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the radar state monitor.
   virtual ~DtRadarStateMonitor();
 
   //! \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 Sets the radar name
   //! \param val The name to set for the radar
   //!
   //! Sets the name identifier for the radar being monitored.
   virtual void setRadarName(const DtString& val);
 
   //! \brief Gets the radar name
   //! \return The name of the radar being monitored
   //!
   //! Retrieves the name identifier for the radar being monitored.
   virtual DtString radarName() const;
 
   //! \brief Registers message callbacks for radar state requests
   //!
   //! Registers callback functions to handle radarStateRequest and
   //! radarStateUnsubscribe messages from visualization clients.
   virtual void registerMessageCallbacks();
 
   //! \brief Static callback function for radar state 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 radar state request
   //! messages. Forwards the request to the appropriate monitor instance.
   static void radarStateRequestCallback(DtSimMessage* msg, void* usrData);
 
   //! \brief Processes a radar state request message
   //! \param msg The simulation message containing the request
   //!
   //! Handles subscription requests for radar state data,
   //! adding the client to the subscriber list and sending initial data.
   virtual void processRadarStateRequest(DtSimMessage* msg);
 
   //! \brief Static callback function for radar state unsubscribe messages
   //! \param msg The simulation message containing the unsubscribe request
   //! \param usrData User data pointer (contains the monitor instance)
   //!
   //! Static function registered as a callback to handle radar state unsubscribe
   //! messages. Forwards the request to the appropriate monitor instance.
   static void radarStateUnsubscribeCallback(DtSimMessage* msg, void* usrData);
 
   //! \brief Processes a radar state unsubscribe message
   //! \param msg The simulation message containing the unsubscribe request
   //!
   //! Handles unsubscription requests for radar state data,
   //! removing the client from the subscriber list.
   virtual void processRadarStateUnsubscribe(DtSimMessage* msg);
 
   //! \brief Creates and sends a radar state message to subscribers
   //!
   //! Constructs a DtRadarState message based on the current state of
   //! the radar system and sends it to all current subscribers.
   //! This provides visualization clients with up-to-date radar state information.
   virtual void createAndSendRadarStateMessage();
 
   //! \brief Notifies that the radar state has changed
   //!
   //! Called by the radar system whenever its state changes. This triggers
   //! radar state messages to be sent out to all current subscribers,
   //! ensuring they have the latest state information.
   virtual void notifyRadarStateChanged();
 
protected:
   //! \brief Adds a client to the subscriber list
   //! \param add The simulation address of the client to add
   //!
   //! Adds the specified client address to the list of subscribers
   //! for this radar's state data. Maintains a counter for each address
   //! to support multiple subscriptions from the same client.
   virtual void addToSubscriberList(const DtSimulationAddress& add);
 
   //! \brief Removes a client from the subscriber list
   //! \param add The simulation address of the client to remove
   //!
   //! Removes one subscription entry for the specified client address
   //! from the list of subscribers. Only completely removes the client
   //! when all subscription instances are removed.
   virtual void removeFromSubscriberList(const DtSimulationAddress& add);
 
   //! \brief Gets the number of current subscribers
   //! \return The number of clients currently subscribed to this radar's state data
   //!
   //! Returns the count of unique clients currently subscribed to receive
   //! radar state updates.
   virtual int numberOfSubscribers();
 
protected:
   //! \brief Pointer to the local object that owns the radar
   //!
   //! The entity object that owns the radar this monitor is associated with.
   DtLocalObject* myHostObject;
 
   //! \brief Name of the radar
   //!
   //! String identifier for the radar being monitored.
   DtString myRadarName;
 
   //! \brief Pointer to the radar state information
   //!
   //! Contains the current state information for the radar system.
   const DtRwRadarStateInfo* myRadarStateInfo;
 
   //! \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 state updates, with a count of subscriptions for each.
   DtSubscriberListCounter mySubscriberList;
};
 
} // namespace makVre