vreSimpleRadarObjectSensorPSR.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file vreSimpleRadarObjectSensorPSR.h
//! \ingroup vreVrfobjcore
//! \brief Simple radar object sensor process state repository for VREngage
//!
//! This file defines the DtVreSimpleRadarObjectSensorPSR class, which provides a simplified
//! version of the radar object sensor PSR for VREngage. It adds support for track IDs and
//! designated targets, used to implement simple radar displays and interfaces.
 
#pragma once
 
#include "vreVrfobjcore/export.h"
#include "vreVrfobjcore/vreRadarObjectSensorPSR.h"
 
#include <vrfutil/rwTemplatedList.h>
#include <vrfutil/rwTemplatedMap.h>
 
namespace makVre
{
//! \brief Type identifier string for the VREngage simple radar object sensor PSR
const char DtVreSimpleRadarObjectSensorPSRType[] = "vre-simple-radar-object-sensor-psr";
 
//! \brief Map of track IDs to entity UUIDs
//!
//! Maps radar track IDs (integers) to the UUIDs of the tracked entities.
//! This allows rapid lookup of entity information by track ID.
using DtTrackIdObjectRefMap = DtRwTemplatedMapPtr<DtRwInt, DtRwUUID>;
 
//! \brief List of designated target track IDs
//!
//! Contains a list of track IDs that have been designated as special targets
//! by the radar operator. Designated targets often receive special treatment
//! in the radar display and targeting systems.
using DtDesignatedTargetList = DtRwTemplatedListPtr<DtRwInt, true>;
 
//! \brief Simplified radar object sensor process state repository for VREngage
//!
//! This class extends the VREngage radar object sensor PSR to provide a simplified
//! version for basic radar functionality. It adds support for track IDs and designated
//! targets, which are used to implement simpler radar displays and interfaces.
//! This PSR is typically used for simplified radar systems that don't require
//! the full complexity of the regular radar object sensor.
class VREVRFOBJCORE_DLL DtVreSimpleRadarObjectSensorPSR : public DtVreRadarObjectSensorPSR
{
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 simple radar object sensor PSR for the specified VRF object.
   DtVreSimpleRadarObjectSensorPSR(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 simple radar object sensor PSR as a copy of the provided original.
   DtVreSimpleRadarObjectSensorPSR(const DtVreSimpleRadarObjectSensorPSR& orig,
      const DtString& rwName = DtString::nullString(), DtReaderWriterRegistry* parentRegistry = 0);
 
   //! \brief Virtual destructor
   //!
   //! Cleans up resources used by the PSR.
   virtual ~DtVreSimpleRadarObjectSensorPSR() 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.
   DtVreSimpleRadarObjectSensorPSR& operator=(const DtVreSimpleRadarObjectSensorPSR& 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 simple radar object sensor 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 DtVreSimpleRadarObjectSensorPSRType.
   virtual DtString type() const override;
 
   //! \brief Gets the track ID to entity UUID map (const version)
   //! \return Const reference to the track ID map
   //!
   //! Returns a constant reference to the map of track IDs to entity UUIDs.
   virtual const DtTrackIdObjectRefMap& trackIds() const;
 
   //! \brief Gets the track ID to entity UUID map (non-const version)
   //! \return Reference to the track ID map
   //!
   //! Returns a reference to the map of track IDs to entity UUIDs,
   //! allowing modification of the track ID assignments.
   virtual DtTrackIdObjectRefMap& trackIds();
 
   //! \brief Gets the designated targets list (const version)
   //! \return Const reference to the designated targets list
   //!
   //! Returns a constant reference to the list of designated target track IDs.
   virtual const DtDesignatedTargetList& designatedTargets() const;
 
   //! \brief Gets the designated targets list (non-const version)
   //! \return Reference to the designated targets list
   //!
   //! Returns a reference to the list of designated target track IDs,
   //! allowing modification of the designated targets.
   virtual DtDesignatedTargetList& designatedTargets();
 
   //! \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 Map of track IDs to entity UUIDs
   //!
   //! Stores the mapping between radar track IDs (integers) and the UUIDs of
   //! the tracked entities. This allows rapid lookup of entity information by track ID.
   DtTrackIdObjectRefMap myTrackIdMap;
 
   //! \brief List of designated target track IDs
   //!
   //! Stores the list of track IDs that have been designated as special targets
   //! by the radar operator. Designated targets often receive special treatment
   //! in the radar display and targeting systems.
   DtDesignatedTargetList myDesignatedTargets;
};
 
} // namespace makVre