rwRwrContactInfo.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file rwRwrContactInfo.h
//! \ingroup vreVrfMessages
//! \brief Defines RWR (Radar Warning Receiver) contact information structure
//!
//! This file contains the DtRwRwrContactInfo class which represents detailed
//! information about radar warning receiver contacts detected by aircraft
//! electronic warfare systems. It includes positional data, signal characteristics,
//! and emitter identification information.
 
#pragma once
 
#include "export.h"
 
#include <readerWriter/readerWriter.h>
#include <readerWriter/rwReal.h>
#include <readerWriter/rwInt.h>
#include <vrfutil/rwTemplatedList.h>
 
// class DtReaderWriterRegistry;
//! \brief Radar Warning Receiver (RWR) contact information class
//!
//! This class represents the data gathered by an RWR about a particular
//! emitter (radar) detected in the environment. It provides information about
//! the contact's position, signal characteristics, and emitter identification.
//! This is a readable/writable class that can store and read itself from a file.
//! Note that entity IDs are not persisted, as they change between scenario runs.
 
class VRFMESSAGES_DLL DtRwRwrContactInfo : public DtReaderWriter
{
public:
   //! \brief Default constructor
   //!
   //! Initializes an RWR contact info object with default values.
   DtRwRwrContactInfo();
 
   //! \brief Constructor with name
   //! \param name The name of the RWR contact
   //! \param parentRegistry Optional reader-writer registry for serialization
   DtRwRwrContactInfo(const DtString& name, DtReaderWriterRegistry* const parentRegistry = NULL);
 
   //! \brief Constructor with symbol name
   //! \param name The symbol name of the RWR contact
   //! \param parentRegistry Optional reader-writer registry for serialization
   DtRwRwrContactInfo(const DtSymbolString& name, DtReaderWriterRegistry* const parentRegistry = NULL);
 
   //! \brief Copy constructor
   //! \param orig The RWR contact info to copy from
   //! \param parentRegistry Optional reader-writer registry for serialization
   DtRwRwrContactInfo(const DtRwRwrContactInfo& orig, DtReaderWriterRegistry* const parentRegistry = NULL);
 
   //! \brief Virtual destructor
   virtual ~DtRwRwrContactInfo() override;
 
   //! \brief Assignment operator
   //! \param orig The RWR contact info to copy from
   //! \return Reference to this object after assignment
   DtRwRwrContactInfo& operator=(const DtRwRwrContactInfo& orig);
 
   //! \brief Sets the contact's azimuth relative to the platform's heading
   //! \param azimuth The azimuth angle in degrees
   //!
   //! Sets the azimuth angle (in degrees) of the contact relative to the platform's heading.
   //! Negative azimuth values indicate the contact is towards the left.
   virtual void setContactAzimuth(double azimuth);
 
   //! \brief Gets the contact's azimuth
   //! \return The azimuth angle in degrees relative to the platform's heading
   virtual double contactAzimuth() const;
 
   //! \brief Sets the contact's elevation angle
   //! \param elevation The elevation angle in degrees
   //!
   //! Sets the elevation angle (in degrees) of the contact relative to the platform.
   virtual void setContactElevation(double elevation);
 
   //! \brief Gets the contact's elevation angle
   //! \return The elevation angle in degrees
   virtual double contactElevation() const;
 
   //! \brief Sets the range to the contact
   //! \param range The range in meters
   //!
   //! Sets the straight-line distance to the contact in meters.
   virtual void setContactRange(double range);
 
   //! \brief Gets the range to the contact
   //! \return The range in meters
   virtual double contactRange() const;
 
   //! \brief Sets the radar mode of the contact
   //! \param mode The radar mode identifier
   //!
   //! Sets the operational mode of the radar emitter that this contact represents.
   virtual void setContactRadarMode(int mode);
 
   //! \brief Gets the radar mode of the contact
   //! \return The radar mode identifier
   virtual int contactRadarMode() const;
 
   //! \brief Sets the received signal power
   //! \param power The signal power in Watts
   //!
   //! Sets the power of the signal received from this contact, measured in Watts.
   virtual void setContactPower(double power);
 
   //! \brief Gets the received signal power
   //! \return The signal power in Watts
   virtual double contactPower() const;
 
   //! \brief Sets the emitter system identifier
   //! \param id The emitter system identifier string
   //!
   //! Sets the identifier for the emitter system type of this contact.
   virtual void setEmitterSystemId(const DtString& id);
 
   //! \brief Gets the emitter system identifier
   //! \return The emitter system identifier string
   virtual DtString emitterSystemId() const;
 
   //! \brief Gets the list of target UUIDs associated with this contact
   //! \return Reference to the list of target UUIDs
   //!
   //! Returns a reference to the list of entity UUIDs targeted by this emitter.
   DtRwTemplatedUUIDList& targets();
 
   //! \brief Creates a deep copy of this object
   //! \return Pointer to a newly created clone of this object
   //!
   //! Returns a dynamically allocated copy of this RWR contact info.
   virtual DtRwRwrContactInfo* clone() const;
 
   //! \brief Equality comparison operator
   //! \param other The RWR contact info to compare with
   //! \return True if the objects are equal, false otherwise
   bool operator==(const DtRwRwrContactInfo& other) const;
 
   //! \brief Inequality comparison operator
   //! \param rhs The RWR contact info to compare with
   //! \return True if the objects are not equal, false otherwise
   bool operator!=(const DtRwRwrContactInfo& rhs) { return !(*this == rhs); };
 
   //! \brief Encodes this object to a buffer
   //! \param buffer The buffer to encode into
   //! \return Pointer to the buffer after the encoded data
   virtual char* encode(char* buffer) const;
 
   //! \brief Decodes this object from a buffer
   //! \param buffer The buffer to decode from
   //! \return Pointer to the buffer after the decoded data
   virtual const char* decode(const char* buffer);
 
   //! \brief Gets the size of the encoded data in bytes
   //! \return The size in bytes
   virtual int getSize() const;
 
protected:
   //! \brief Azimuth angle to the contact relative to platform heading (degrees)
   DtRwReal myContactAzimuth;
 
   //! \brief Elevation angle to the contact relative to platform (degrees)
   DtRwReal myContactElevation;
 
   //! \brief Range to the contact (meters)
   DtRwReal myContactRange;
 
   //! \brief Operational mode of the radar emitter
   DtRwInt myRadarMode;
 
   //! \brief Received signal power (Watts)
   DtRwReal mySignalPower;
 
   //! \brief Identifier for the emitter system type
   DtRwString myEmitterSystemId;
 
   //! \brief List of entity UUIDs targeted by this emitter
   DtRwTemplatedUUIDList myTargets;
};
 
//! \brief List type for storing multiple RWR contact information entries
using DtRwRwrContactInfoList = DtRwTemplatedListPtr<DtRwRwrContactInfo, true>;
 
//! \brief Gets the number of bytes required to encode the RWR contact info
//! \param info The RWR contact info to calculate size for
//! \return The number of bytes required for encoding
//!
//! Calculates the number of bytes required to encode the specified RWR contact info.
//! Note that passing in a null pointer is valid and will return a size of zero.
VRFMESSAGES_DLL int getSize(const DtRwRwrContactInfo& info);
 
//! \brief Serializes the RWR contact info into a buffer
//! \param info The RWR contact info to encode
//! \param buffer The buffer to serialize into
//! \return Pointer to the buffer after the serialization
//!
//! Serializes the provided RWR contact info into the buffer.
//! The buffer must have at least the number of bytes returned by getSize().
VRFMESSAGES_DLL char* encode(const DtRwRwrContactInfo& info, char* buffer);
 
//! \brief Deserializes the buffer into RWR contact info
//! \param info The RWR contact info to populate
//! \param buffer The buffer to deserialize from
//! \return Pointer to the buffer after the deserialization
//!
//! Decodes data from the buffer into the provided RWR contact info object.
VRFMESSAGES_DLL const char* decode(DtRwRwrContactInfo& info, const char* buffer);