rwrMonitor.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file rwrMonitor.h
//! \ingroup vreVrfmodel
//! \brief Monitor for managing radar warning receiver (RWR) contact information
//!
//! This file defines the DtRwrMonitor class which manages the communication
//! of radar warning receiver contact information between an RWR system and
//! visualization systems. It handles subscription requests and notifications
//! when RWR contacts change.
 
#pragma once
 
#include "vreVrfmodel/export.h"
 
class DtSimMessage;
 
namespace makVre
{
class DtRwrContactInfoList;
 
//! \brief Monitor for managing radar warning receiver (RWR) contact information
//!
//! DtRwrMonitor manages the communication of radar warning receiver contact information
//! between an RWR system and visualization systems. It handles subscription
//! requests from clients, maintains a list of current subscribers, and sends
//! RWR data messages when the contact list changes.
class VREVRFMODEL_DLL DtRwrMonitor
{
private:
   //! \brief Default constructor (not implemented)
   //!
   //! Default constructor is private and not implemented to prevent
   //! creation of instances without proper initialization.
   DtRwrMonitor();
 
   //! \brief Copy constructor (not implemented)
   //!
   //! Copy constructor is private and not implemented to prevent
   //! copy construction.
   DtRwrMonitor(const DtRwrMonitor& orig);
 
   //! \brief Assignment operator (not implemented)
   //! \return Reference to this object
   //!
   //! Assignment operator is private and not implemented to prevent assignment.
   const DtRwrMonitor& operator=(const DtRwrMonitor& orig);
 
public:
   //! \brief Constructor
   //! \param hostObject The local object that owns the RWR this monitor is for
   //! \param contactInfoList Pointer to the RWR contact information list maintained by the RWR
   //!
   //! Creates a new RWR monitor that will handle communication between the
   //! specified RWR system and visualization clients.
   DtRwrMonitor(DtLocalObject* hostObject, const DtRwrContactInfoList* contactInfoList);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the RWR monitor.
   virtual ~DtRwrMonitor();
 
   //! \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 RWR data requests
   //!
   //! Registers callback functions to handle rwrDataRequest and
   //! rwrDataUnsubscribe messages from visualization clients.
   virtual void registerMessageCallbacks();
 
   //! \brief Static callback function for RWR 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 RWR data request
   //! messages. Forwards the request to the appropriate monitor instance.
   static void rwrDataRequestCallback(DtSimMessage* msg, void* usrData);
 
   //! \brief Processes an RWR data request message
   //! \param msg The simulation message containing the request
   //!
   //! Handles subscription requests for RWR data,
   //! adding the client to the subscriber list and sending initial data.
   virtual void processRwrDataRequest(DtSimMessage* msg);
 
   //! \brief Static callback function for RWR data 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 RWR data unsubscribe
   //! messages. Forwards the request to the appropriate monitor instance.
   static void rwrDataUnsubscribeCallback(DtSimMessage* msg, void* usrData);
 
   //! \brief Processes an RWR data unsubscribe message
   //! \param msg The simulation message containing the unsubscribe request
   //!
   //! Handles unsubscription requests for RWR data,
   //! removing the client from the subscriber list.
   virtual void processRwrDataUnsubscribe(DtSimMessage* msg);
 
   //! \brief Creates and sends an RWR data message to subscribers
   //!
   //! Constructs a DtRwrData message based on the current state of
   //! the RWR contact list and sends it to all current subscribers.
   //! This provides visualization clients with up-to-date RWR contact information.
   virtual void createAndSendRwrDataMessage();
 
   //! \brief Notifies that the RWR contact list has changed
   //!
   //! Called by the RWR system whenever its contact list changes. This triggers
   //! RWR data messages to be sent out to all current subscribers,
   //! ensuring they have the latest contact information.
   virtual void notifyTargetsChanged();
 
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 RWR's 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 RWR's data
   //!
   //! Returns the count of unique clients currently subscribed to receive
   //! RWR data updates.
   virtual int numberOfSubscribers();
 
protected:
   //! \brief Pointer to the local object that owns the RWR
   //!
   //! The entity object that owns the RWR this monitor is associated with.
   DtLocalObject* myHostObject;
 
   //! \brief Pointer to the RWR contact information list
   //!
   //! Contains the current list of radar contacts detected by the RWR system.
   const DtRwrContactInfoList* myRwrContactList;
 
   //! \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 RWR data updates, with a count of subscriptions for each.
   DtSubscriberListCounter mySubscriberListCounter;
};
 
} // namespace makVre