icVreTdlTrack.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file icVreTdlTrack.h
//! \ingroup vreVrfMessages
//! \brief Interface classes for Tactical Data Link (TDL) track information
//!
//! This file defines the classes for representing tactical data link track information
//! within the VREngage simulation. It includes IcVreTdlTrackContents structure for
//! storing track data and IcVreTdlTrack class for message-based communication.
 
#pragma once
 
// VR-Forces includes
#include <vrfExtProtocol/simInterfaceContent.h>
#include <vrfutil/rwUUID.h>
 
// VR-Link includes
#include <vlutil/vlString.h>
 
// #include "TDLMessageTypes.h"
 
namespace ctiTdl
{
 
//! \brief Structure containing TDL track information
//!
//! This structure contains all the data fields for a Tactical Data Link (TDL) track,
//! including common parameters, PPLI-specific parameters, and surveillance parameters.
struct IcVreTdlTrackContents
{
   // common parameters
   DtString tn;               // track number (STN for PPLI, TN for Surveillance tracks)
   int type;                  // see ctiTdl::TrackType in VreTdlTrackTypes.h
   int domain;                // see ctiTdl::TrackDomain in VreTdlTrackTypes.h
 
   double latitude;           // deg
   double longitude;          // deg
   float altitudeElevDepth;   // ft
   float course;              // deg
   float speed;               // mph
 
   int strength;
   DtString specPlatformType; // specific platform type when available (J13.2), otherwise platform
   bool ageingOut;            // true when track is ageing out - symbol should flash when true
 
   bool deleteRequest;        // true when track should be deleted (sent once following deletion)
 
   // common PPLI parameters
   bool c2Indicator; // true when a PPLI and a C2 platform
   DtString vcs;     // voice callsign
 
   // air PPLI parameters
   bool flightLeader;     // true when an Air PPLI and a Flight Leader
   bool missionCommander; // true when an Air PPLI and a Mission Commander
   bool bailout;          // true when an Air PPLI and the bailout indicator is set
   bool isTanker;         // indicates if this is a tanker and thus offload fuel should be presented (J13.2)
   int numFox1;           // only used if isTanker = false (J13.2)
   int numFox2;           // only used if isTanker = false (J13.2)
   int numFox3;           // only used if isTanker = false (J13.2)
   int numOther;          // only used if isTanker = false (J13.2)
   float offloadFuel;     // only used if isTanker = true, thousands of lbs (J13.2)
   float burnableFuel;    // thousands of lbs (J13.2)
 
   // air PPLI / target report parameters
   DtString wingmanId; // alpha-numeric [0 - 9] or [A - Z] or space ' '
 
   // surveillance / target report parameters
   int identity; // see ctiTdl::TrackIdentity in VreTdlTrackTypes.h
 
   // surveillance parameters
   int survTrackSubType; // see ctiTdl::SurvTrackSubType in VreTdlTrackTypes.h
   bool threatWarningActive;
 
   IcVreTdlTrackContents()
      : tn("")
      , type(0)
      , domain(0)
      , latitude(0)
      , longitude(0)
      , altitudeElevDepth(0)
      , course(0)
      , speed(0)
      , strength(0)
      , specPlatformType("")
      , ageingOut(0)
      , deleteRequest(0)
      , c2Indicator(0)
      , vcs("")
      , flightLeader(0)
      , missionCommander(0)
      , bailout(0)
      , isTanker(0)
      , numFox1(0)
      , numFox2(0)
      , numFox3(0)
      , numOther(0)
      , offloadFuel(0)
      , burnableFuel(0)
      , wingmanId("")
      , identity(0)
      , survTrackSubType(0)
      , threatWarningActive(0)
   {
   }
 
   IcVreTdlTrackContents(const IcVreTdlTrackContents& orig)
      : tn(orig.tn)
      , type(orig.type)
      , domain(orig.domain)
      , latitude(orig.latitude)
      , longitude(orig.longitude)
      , altitudeElevDepth(orig.altitudeElevDepth)
      , course(orig.course)
      , speed(orig.speed)
      , strength(orig.strength)
      , specPlatformType(orig.specPlatformType)
      , ageingOut(orig.ageingOut)
      , deleteRequest(orig.deleteRequest)
      , c2Indicator(orig.c2Indicator)
      , vcs(orig.vcs)
      , flightLeader(orig.flightLeader)
      , missionCommander(orig.missionCommander)
      , bailout(orig.bailout)
      , isTanker(orig.isTanker)
      , numFox1(orig.numFox1)
      , numFox2(orig.numFox2)
      , numFox3(orig.numFox3)
      , numOther(orig.numOther)
      , offloadFuel(orig.offloadFuel)
      , burnableFuel(orig.burnableFuel)
      , wingmanId(orig.wingmanId)
      , identity(orig.identity)
      , survTrackSubType(orig.survTrackSubType)
      , threatWarningActive(orig.threatWarningActive)
   {
   }
 
   IcVreTdlTrackContents& operator=(const IcVreTdlTrackContents& orig)
   {
      // Guard against assignment to yourself.
      if (this == &orig)
      {
         return *this;
      }
 
      tn = orig.tn;
      type = orig.type;
      domain = orig.domain;
      latitude = orig.latitude;
      longitude = orig.longitude;
      altitudeElevDepth = orig.altitudeElevDepth;
      course = orig.course;
      speed = orig.speed;
      strength = orig.strength;
      specPlatformType = orig.specPlatformType;
      ageingOut = orig.ageingOut;
      deleteRequest = orig.deleteRequest;
      c2Indicator = orig.c2Indicator;
      vcs = orig.vcs;
      flightLeader = orig.flightLeader;
      missionCommander = orig.missionCommander;
      bailout = orig.bailout;
      isTanker = orig.isTanker;
      numFox1 = orig.numFox1;
      numFox2 = orig.numFox2;
      numFox3 = orig.numFox3;
      numOther = orig.numOther;
      offloadFuel = orig.offloadFuel;
      burnableFuel = orig.burnableFuel;
      wingmanId = orig.wingmanId;
      identity = orig.identity;
      survTrackSubType = orig.survTrackSubType;
      threatWarningActive = orig.threatWarningActive;
 
      return *this;
   }
};
 
//! \brief Interface message class for TDL track information
//!
//! This class provides a mechanism for transmitting Tactical Data Link track
//! information between simulation components. It encapsulates track contents
//! and provides methods for network serialization and deserialization.
class IcVreTdlTrack : public DtSimInterfaceContent
{
public:
   //! \brief Default constructor
   //!
   //! Initializes an empty TDL track message.
   IcVreTdlTrack();
 
   //! \brief Virtual destructor
   virtual ~IcVreTdlTrack() override;
 
   //! \brief Copy constructor
   //! \param orig The TDL track to copy from
   //!
   //! Creates a new TDL track by copying an existing one.
   IcVreTdlTrack(const IcVreTdlTrack& orig);
 
   //! \brief Assignment operator
   //! \param orig The TDL track to copy from
   //! \return Reference to this object after assignment
   //!
   //! Copies the contents of another TDL track into this one.
   IcVreTdlTrack& operator=(const IcVreTdlTrack& orig);
 
   //! \brief Gets the interface message type
   //! \return The message type identifier
   virtual int type() const override;
 
   //! \brief Creates a copy of this message
   //! \return Pointer to the new copy
   //!
   //! Calls the copy constructor to create a dynamically allocated clone.
   virtual DtSimInterfaceContent* clone() const override;
 
   //! \brief Static creator function for factory registration
   //! \return Pointer to a new instance of IcVreTdlTrack
   //!
   //! This static function is used for registration with DtInterfaceContentFactory.
   static DtSimInterfaceContent* creator();
 
   //! \brief Gets the network representation size
   //! \return Size in bytes of the network representation
   //!
   //! Returns the size of the full network representation padded to an 8-byte boundary.
   virtual int netRepSize() const override;
 
   //! \brief Deserializes the message from a network buffer
   //! \param contentBuffer Pointer to the network buffer
   //! \param contentSize Size of the buffer in bytes
   //! \return True if deserialization was successful
   //!
   //! Fills the message from the provided network buffer.
   virtual bool setFromNet(const char* contentBuffer, unsigned contentSize) override;
 
   //! \brief Serializes the message for network transmission
   //! \return True if serialization was successful
   //!
   //! Fills in the network buffer with the message contents.
   virtual bool setToNet() override;
 
   //! \brief Formats the message data as a string
   //! \param str String to store the formatted message data
   //!
   //! Appends a human-readable representation of the message to the provided string.
   virtual void printDataToString(DtString& str) override;
 
   //! \brief Sets the UUID for this track
   //! \param uuid The UUID to set
   virtual void setUUID(DtUUID uuid);
 
   //! \brief Gets the UUID of this track
   //! \return The track's UUID
   virtual DtUUID getUUID();
 
   //! \brief Sets the source track number
   //! \param stn The source track number to set
   virtual void setSourceTrackNumber(const DtString& stn);
 
   //! \brief Gets the source track number
   //! \return The source track number
   virtual DtString getSourceTrackNumber();
 
   //! \brief Sets the track contents
   //! \param track The track contents to set
   virtual void setTrack(const IcVreTdlTrackContents& track);
 
   //! \brief Gets the track contents
   //! \return The track contents
   virtual IcVreTdlTrackContents getTrack();
 
protected:
   //! \brief UUID of this track for unique identification
   DtUUID myUUID;
 
   //! \brief Source track number (used for correlation)
   DtString sourceTrackNumber;
 
   //! \brief Detailed track contents/parameters
   IcVreTdlTrackContents trackContents;
};
 
} // namespace ctiTdl