radarWarningReceiverPSR.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file radarWarningReceiverPSR.h
//! \ingroup vreVrfobjcore
//! \brief Radar warning receiver process state repository for VREngage
//!
//! This file defines the DtRadarWarningReceiverPSR class, which provides a process state repository
//! for radar warning receiver (RWR) components in VREngage. It tracks radar emissions detected
//! by the entity and stores information about emitter contacts and detection parameters.
 
#pragma once
 
#include "vreVrfobjcore/export.h"
#include <vrfobjcore/vrfProcessStateRepository.h>
#include <readerWriter/rwReal.h>
#include <readerWriter/rwBoolean.h>
#include <vlutil/vlTime.h>
#include <vrfutil/rwEntityTypeList.h>
 
//! Forward declarations for classes used in this file
 
class DtRwRwrContactInfo;
class DtEntityIdentifier;
class DtUUID;
 
namespace makVre
{
//! \brief Contact information list for the radar warning receiver
class DtRwrContactInfoList;
 
//! \brief Type identifier string for the VREngage radar warning receiver PSR
const char DtVreRadarWarningReceiverPSRType[] = "vre-radar-warning-receiver-psr";
 
//! \brief Process state repository for radar warning receiver components
//!
//! This class provides storage and management for radar warning receiver (RWR) state data.
//! An RWR is a passive sensor that detects radar emissions and provides information about
//! potential threats to the entity. This PSR tracks detected radar contacts, their
//! properties, and the operational parameters of the RWR system.
class VREVRFOBJCORE_DLL DtRadarWarningReceiverPSR : public DtVrfProcessStateRepository
{
public:
   //! \brief Constructor with VRF object and optional name
   //! \param vrfObject Pointer to the local object this PSR is associated with
   //! \param rwName Optional reader/writer name
   //! \param parentRegistry Optional parent registry for reader/writer functionality
   //!
   //! Creates a new radar warning receiver PSR for the specified VRF object.
   DtRadarWarningReceiverPSR(DtLocalObject* vrfObject, const DtString& rwName = DtString::nullString(),
      DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Copy constructor
   //! \param orig The source PSR to copy from
   //! \param rwName Optional reader/writer name
   //! \param parentRegistry Optional parent registry for reader/writer functionality
   //!
   //! Creates a new radar warning receiver PSR as a copy of the provided original.
   DtRadarWarningReceiverPSR(const DtRadarWarningReceiverPSR& orig, const DtString& rwName = DtString::nullString(),
      DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the PSR.
   virtual ~DtRadarWarningReceiverPSR() override;
 
   //! \brief Assignment operator (not implemented)
   //! \param orig The source PSR to copy from
   //! \return Reference to this PSR after assignment
   //!
   //! Assignment operator is declared but not implemented to prevent assignment.
   DtRadarWarningReceiverPSR& operator=(const DtRadarWarningReceiverPSR& orig);
 
   //! \brief Creates a clone of this PSR
   //! \param rwName Optional reader/writer name for the clone
   //! \param parentRegistry Optional parent registry for reader/writer functionality
   //! \return Pointer to a new PSR that is a clone of this one
   //!
   //! Creates a new radar warning receiver PSR as a deep copy of this one.
   virtual DtVrfProcessStateRepository* clone(const DtString& rwName = DtString::nullString(),
      DtReaderWriterRegistry* parentRegistry = 0) const override;
 
   //! \brief Gets the type identifier for this PSR
   //! \return String identifying this PSR type
   //!
   //! Returns a unique type identifier string for this PSR type.
   //! Will return DtVreRadarWarningReceiverPSRType.
   virtual DtString type() const override;
 
   //! \brief Initializes the PSR after creation
   //! \return True if initialization was successful, false otherwise
   //!
   //! Called after creation to initialize the PSR. This method sets up
   //! myContactInfoList using createRwrContactInfoList().
   virtual bool init() override;
 
   //! \brief Gets the list of radar contact information objects (non-const version)
   //! \return Pointer to the contact information list
   //!
   //! Returns the list of DtRwRwrContactInfo (or derivative) objects representing
   //! detected radar emitters. Will call mapContactNamesToIds() if the flag is set.
   //! For this reason, avoid holding a pointer to this list outside of this class.
   virtual DtRwrContactInfoList* contactInfoList();
 
   //! \brief Gets the list of radar contact information objects (const version)
   //! \return Const pointer to the contact information list
   //!
   //! Returns the const list of DtRwRwrContactInfo (or derivative) objects representing
   //! detected radar emitters. Will call mapContactNamesToIds() if the flag is set
   //! (casting away constness to do so). For this reason, avoid holding a pointer
   //! to this list outside of this class.
   virtual const DtRwrContactInfoList* contactInfoList() const;
 
   //! \brief Looks up contact information by entity ID
   //! \param id The UUID of the entity to find contact information for
   //! \return Pointer to the contact information, or nullptr if not found
   //!
   //! Returns the contact information for the radar contact with the
   //! specified entity ID, or nullptr if not found in the contact list.
   virtual DtRwRwrContactInfo* lookupContactById(const DtUUID& id) const;
 
   //! \brief Clears all radar contacts
   //!
   //! Empties the contact information list, removing all currently tracked radar contacts.
   virtual void clearContactInfoList();
 
   //! \brief Creates a new radar contact information object
   //! \return Pointer to the newly created contact information object, or nullptr if creation failed
   //!
   //! Returns a new DtRwRwrContactInfo (or derivative) object by calling
   //! myContactInfoList->createRwrContactInfo(). This returns the type being used in
   //! the contactInfoList. All items added to the contactInfoList should be created
   //! by calling this method. Returns nullptr if myContactInfoList is not set.
   virtual DtRwRwrContactInfo* createRwrContactInfo() const;
 
   //! \brief Gets the task-specific entity types to detect
   //! \return Const reference to the list of entity types
   //!
   //! Returns the list of entity types to detect that were set specifically for a task.
   //! This type list is used along with the list in the descriptor and the list on the
   //! types-to-detect input port to make a combined list for processing detections.
   //! This task list is expected to be changed dynamically during a scenario by tasks.
   virtual const DtRwEntityTypeList& typesToDetectForTask() const;
 
   //! \brief Sets the task-specific entity types to detect
   //! \param objectTypes The list of entity types to detect
   //!
   //! Sets the task-specific list of entity types that the RWR should detect.
   //! This allows tasks to dynamically change detection parameters during a scenario.
   virtual void setTypesToDetectForTask(const DtRwEntityTypeList& objectTypes);
 
   //! \brief Clears the task-specific entity types to detect
   //!
   //! Clears the task-specific list of entity types that the RWR should detect,
   //! returning to using only the default types from the descriptor.
   virtual void clearTypesToDetectForTask();
 
   //! \brief Sets the simulation time for the next detection attempt
   //! \param time The simulation time (in seconds) for the next detection
   //!
   //! Sets the simulation time at which the RWR should make its next detection attempt.
   //! This is used to control the detection update rate of the RWR.
   virtual void setNextDetectAttempt(DtTime time);
 
   //! \brief Gets the simulation time for the next detection attempt
   //! \return The simulation time (in seconds) for the next detection
   //!
   //! Returns the simulation time at which the RWR will make its next detection attempt.
   virtual DtTime nextDetectAttempt() const;
 
   //! \brief Sets whether the RWR is enabled
   //! \param enabled True to enable the RWR, false to disable it
   //!
   //! Enables or disables the radar warning receiver. When disabled, the RWR
   //! will not detect any new radar emissions.
   virtual void setRwrEnabled(bool enabled);
 
   //! \brief Checks if the RWR is enabled
   //! \return True if the RWR is enabled, false otherwise
   //!
   //! Returns whether the radar warning receiver is currently enabled.
   virtual bool rwrEnabled() const;
 
   //! \brief Writes this PSR to a file
   //! \param fp The file path string to write to
   //! \param indentLevel The indentation level to use
   //! \param writeUnspecified Whether to write unspecified values
   //! \param path The base path for resolving relative paths
   //!
   //! Overrides the base class method to perform additional processing before writing
   //! the PSR to a file. Maps target IDs to target names before calling the base class
   //! version to ensure that previously detected targets are preserved in checkpoint saves.
   virtual void putSelf(std::string& fp,
      int indentLevel = 0,
      bool writeUnspecified = false,
      const DtFilename& path = DtReaderWriter::appPath()) override;
 
   //! \brief Reads this PSR from a stream
   //! \param args The input stream to read from
   //! \param searchPaths Search paths for resolving references
   //! \param variableBindings Variable bindings for resolving references
   //!
   //! Overrides the base class method to perform additional processing after reading
   //! the PSR from a stream. Sets a flag indicating that target names should be mapped
   //! to target identifiers the next time lookupPreviousTarget() is called.
   virtual void getSelf(DtlObjPtr args,
      const DtReaderWriter::SearchPaths& searchPaths,
      const DtVariableBindingsList& variableBindings) override;
 
protected:
   //! \brief Creates a new contact information list
   //! \param name The name to assign to the new list
   //! \return Pointer to the newly created contact information list
   //!
   //! Factory method that returns a new DtRwrContactInfoList. If you are adding custom
   //! data to the RWR contact info, create a new derivative of DtRwrContactInfoList
   //! and override this method to create your new subclass here.
   virtual DtRwrContactInfoList* createRwrContactInfoList(const DtString& name);
 
public:
   //! \brief Factory function to create a new instance of this PSR
   //! \param rwName The reader/writer name for the new instance
   //! \param vrfObject Pointer to the local object this PSR will be associated with
   //! \param parentRegistry Parent registry for reader/writer functionality
   //! \return Pointer to a newly created PSR instance
   //!
   //! Static factory function used by the PSR creation system to instantiate
   //! new instances of this PSR type.
   static DtVrfProcessStateRepository* creator(
      const DtString& rwName, DtLocalObject* vrfObject, DtReaderWriterRegistry* parentRegistry);
 
protected:
   //! \brief Maps contact IDs to contact names
   //!
   //! Looks up each object in myContactInfoList by the entity ID
   //! in the contact information and sets the name of the contact
   //! in the contact info to the name of the object found.
   //! Objects that are not found are left as they were.
   // virtual void mapContactIdsToContactNames();
 
   //! \brief Maps contact names to contact IDs
   //!
   //! Looks up each object in myContactInfoList by name,
   //! and sets the entity ID in the contact information
   //! to the one found in the vrf object.
   // virtual void mapContactNamesToContactIds();
 
protected:
   //! \brief List of radar contact information
   //!
   //! The list of radar contacts detected by the RWR. This is created by the init() method
   //! using the createRwrContactInfoList() factory method.
   DtRwrContactInfoList* myContactInfoList;
 
   //! \brief Flag for contact name to ID mapping
   //!
   //! Flag used to indicate that we should initialize contact names to entity identifiers.
   //! This is used during deserialization to ensure contact information is properly restored.
   mutable bool myMutableMapContactNamesToContactIds;
 
   //! \brief Task-specific entity types to detect
   //!
   //! Types of objects to detect for a particular task. This can be set with a function call
   //! or an setAttribute call in Lua. Default value is empty.
   DtRwEntityTypeList myTaskDetectionTypes;
 
   //! \brief Next detection time
   //!
   //! Simulation time of the next detection attempt (in seconds).
   DtRwReal myNextDetectAttempt;
 
   //! \brief RWR enabled state
   //!
   //! Whether the radar warning receiver is enabled or disabled.
   DtRwBoolean myRwrEnabled;
};
} // namespace makVre