ifVrfObjectData.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/

#pragma once

#include <vrfExtProtocol/simInterfaceContent.h>
#include <vlutil/vlString.h>
#include <vrfExtProtocol/rangeItem.h>
#include <vrfExtProtocol/vrfExtendedRecordData.h>
#include <vlpi/disEnums.h>
#include <vl/globalObjectDesignator.h>

const unsigned char DtVrfObjectDataVersion = 13;

struct DtNetIfVrfObjectData_V1
{
   DtNetEntityIdentifier        myObjectIdentifier;// 48 bytes
   DtNetEntityType              myEntityType;      //  8 bytes
   DtNetU8                      mySuperType;       //  1 byte
   DtNetU8                      myLabelLength;     //  1 byte
   DtNetU8                      myEchelonIdLength; //  1 bytes
   DtNetBoolean                 myIsSubordinateOfForce;     //  1 byte
//   DtNetU32                     myPadding2;        //  4 bytes
};                           // Total:                64 bytes

struct DtNetIfVrfObjectData_V2
{
   DtNetEntityIdentifier        myObjectIdentifier;         // 48 bytes
   DtNetEntityType              myEntityType;               //  8 bytes
   DtNetU8                      mySuperType;                //  1 byte
   DtNetU8                      myLabelLength;              //  1 byte
   DtNetU8                      myEchelonIdLength;          //  1 bytes
   DtNetBoolean                 myIsSubordinateOfForce;     //  1 byte
   DtNetBoolean                 myIndependentlyTasked;      //  1 byte
   DtNetU32                     myPadding1;                 //  4 bytes
};                                     // Total:               64 bytes

struct DtNetIfVrfObjectData_V3
{
   DtNetEntityIdentifier        myObjectIdentifier;         //  6 bytes
   DtNetEntityType              myEntityType;               //  8 bytes
   DtNetU8                      mySuperType;                //  1 byte
   DtNetU8                      myLabelLength;              //  1 byte
   DtNetU8                      myEchelonIdLength;          //  1 bytes
   DtNetBoolean                 myIsSubordinateOfForce;     //  1 byte
   DtNetBoolean                 myIndependentlyTasked;      //  1 byte
   DtNetU8                      myVrfObjectDataVersion;     //  1 byte
   DtNetU8                      myOverlayParentLength;      //  1 byte
   DtNetBoolean                 myUnderFire;                //  1 bytes
};                                     // Total:               22 bytes

struct DtNetIfVrfObjectData
{
   DtNetEntityIdentifier        myObjectIdentifier;         //  6 bytes
   DtNetU16                     myUnused1;                  //  4 bytes
   DtNetU16                     myUnused2;                  //  4 bytes
   DtNetU8                      myUnused3;                  //  1 byte
   DtNetU8                      myLabelLength;              //  1 byte
   DtNetU8                      myEchelonIdLength;          //  1 bytes
   DtNetBoolean                 myIsSubordinateOfForce;     //  1 byte
   DtNetBoolean                 myIndependentlyTasked;      //  1 byte
   DtNetU8                      myVrfObjectDataVersion;     //  1 byte
   DtNetU8                      myOverlayParentLength;      //  1 byte
   DtNetBoolean                 myUnderFire;                //  1 byte
   DtNetBoolean                 myVrfSimulated;             //  1 byte
   DtNetU32                     myVrfSessionId;             //  4 bytes
   // Added version 4 of PDU
   DtNetU32                     myVrfMessageVersionSupported;      //  4 bytes
   DtNetBoolean                 myHasPlan;                  //  1 byte
   DtNetU8                      myRulesOfEngagementLength;  //  1 byte
   DtNetBoolean                 myIsCurrentlyTasked;        //  1 bytes
   DtNetBoolean                 myExecutingPlan;            //  1 byte
   DtNetU16                     myPadding1;                 //  2 bytes
   DtNetU8                      myPadding2;                 //  1 byte
   DtNetU8                      myPadding3;                 //  1 byte
   DtNetU8                      myPadding4;                 //  1 byte
};                                     // Total:               40 bytes

// Define the bits in the VRF Flags
typedef DtU32 DtVrfFlag;
#define DT_DEFINE_VRF_FLAG(flagName, shiftVal) \
   const unsigned flagName##BitShift = shiftVal; \
   const DtVrfFlag flagName = 0x01 << shiftVal;

DT_DEFINE_VRF_FLAG(DtVrfFlagVrfSimulated,         0)
DT_DEFINE_VRF_FLAG(DtVrfFlagIsSubordinateOfForce, 1)
DT_DEFINE_VRF_FLAG(DtVrfFlagIndependentlyTasked,  2)
DT_DEFINE_VRF_FLAG(DtVrfFlagUnderFire,            3)
DT_DEFINE_VRF_FLAG(DtVrfFlagHasPlan,              4)
DT_DEFINE_VRF_FLAG(DtVrfFlagExecutingPlan,        5)
DT_DEFINE_VRF_FLAG(DtVrfFlagIsCurrentlyTasked,    6)
DT_DEFINE_VRF_FLAG(DtVrfFlagIsClutterEntity,      7)


// class DtIfVrfObjectData:
//
// Instances of DtIfVrfObjectData are the message content for vrf
// object data messages.  The purpose of these messages is to convey
// essential information about a given vrf object that is beyond the 
// scope of DIS or the RPR FOM.  This message, in combination with the
// corresponding entity, aggregate, or environmental PDU/interaction, provides
// enough information for a remote VR-Forces process to update an existing
// vrf object.
// 
// Content-Type:  DtVrfObjectDataMessageType
// 
#include <vrfExtProtocol/vrfExtProtocolDefines.h>
class DT_DLL_vrfExtProtocol DtIfVrfObjectData : public DtSimInterfaceContent
{
public:

   // default constructor
   DtIfVrfObjectData();

   // destructor
   virtual ~DtIfVrfObjectData() override;

   // copy constructor
   DtIfVrfObjectData(const DtIfVrfObjectData& orig);

   // assignment operator
   DtIfVrfObjectData& operator=(const DtIfVrfObjectData& orig);

   // Returns a newly created instance of a DtIfVrfObjectData.
   virtual DtSimInterfaceContent *clone() const override;

   // Returns the string type of message, DtVrfObjectResponseMessageType
   // (defined in msgTypes.h).
   virtual int type() const override;

   // Set/get the object identifier (site:app:object id) of the vrf object.
   // Corresponds to entity identifier for individual entities, aggregate Id
   // for aggregates, and object identifier for environmental process objects.
   virtual void setObjectIdentifier(const DtEntityIdentifier & objectIdentifier);
   virtual const DtEntityIdentifier & objectIdentifier() const;

   // Set/get the session id.  This is the id that is used to say whether or not
   // front ends that are running in a particular session can control these objects
   virtual void setVrfSessionId(int s);
   virtual int vrfSessionId() const;

   // Set/get the message version id.  This is the message version of the VRF simulator
   // that created this object
   virtual void setVrfMessageVersionSupported(int s);
   virtual int vrfMessageVersionSupported() const;

   // Set/get the object label of the vrf object.
   virtual void setObjectLabel(const DtString & objectLabel);
   virtual const DtString & objectLabel() const;

   virtual void setEchelonIdString(const DtString& echelonId);
   virtual const DtString& echelonIdString() const;

   virtual void setIsSubordinateOfForce(bool yesNo);
   virtual bool isSubordinateOfForce() const;

   virtual void setIndependentlyTasked(bool yesNo);
   virtual bool independentlyTasked() const;

   virtual void setOverlayParent(const DtString& parent);
   virtual const DtString& overlayParent() const;

   // Does the entity think its currently under-fire.  Default is false.
   // @{
   virtual void setUnderFire(bool yesNo);
   virtual bool underFire() const;
   // @}

   // Does the entity have a plan
   // @{
   virtual void setHasPlan(bool yesNo);
   virtual bool hasPlan() const;
   // @}

   // Indicates whether the entity is executing its plan or not.
   virtual void setExecutingPlan(bool yesNo);
   virtual bool executingPlan() const;

   // Is the entity currently tasked
   // @{
   virtual void setIsCurrentlyTasked(bool yesNo);
   virtual bool isCurrentlyTasked() const;
   // @}

   // Is this a clutter entity
   // @{
   virtual void setIsClutterEntity(bool yesNo);
   virtual bool isClutterEntity() const;
   // @}

   // The extended data.  Used for entities only.  Aggregates and environmental
   // have their extended data
   // @{
   virtual void setExtendedData(const std::map<DtString, DtString>&);
   virtual void setExtendedData(const DtString& key, const DtString& value);
   virtual const std::map<DtString, DtString>& extendedData() const;
   virtual DtString extendedData(const DtString& key) const;

   // Entities rules of engagement
   // @{
   virtual void setRulesOfEngagement(const DtString&);
   virtual const DtString& rulesOfEngagement() const;
   // @}

   // Set when this entity is simulated by a VR-Force back-end.  Default is false.
   // Only the VR-Forces back-end engine should set this value.  Do not set this
   // value to true unless you are planning on handling messages sent by the front-end
   // that are supported by the VR-Forces back-end in some manner
   // @{
   virtual void setVrfSimulated(bool yesNo);
   virtual bool vrfSimulated() const;
   // @}

   //{@
   virtual void addRangeItem(const DtRangeItem&);
   virtual void removeRangeItem(int index);
   virtual void setRangeItems(const DtRangeItems&);
   const DtRangeItems& rangeItems() const;

   virtual void setBoundingVolume(const DtVector32&);
   virtual const DtVector32& boundingVolume() const;

   virtual void setBoundingVolumeOffset(const DtVector32&);
   virtual const DtVector32& boundingVolumeOffset() const;

   virtual char vrfObjectDataVersion() const;

   virtual int netRepSize() const override;
   virtual bool setFromNet(const char *contentBuffer,
                           unsigned contentSize) override;
   virtual bool setToNet() override;

   virtual void printDataToString(DtString &str) override;

   static DtSimInterfaceContent* creator();

   bool operator!=(const DtIfVrfObjectData&) const;
   bool operator==(const DtIfVrfObjectData&) const;

   // If myDirty flag is true, calls setToNet() before returning buffer.  Called
   // from equality operator
   virtual char* fillInNetRep();

protected:
   virtual bool parseV1Buffer(const char* contentBuffer, 
      unsigned contentSize);
   virtual bool parseV2Buffer(const char* contentBuffer, 
      unsigned contentSize);
   virtual bool parseV3Buffer(const char* contentBuffer, 
      unsigned contentSize);

protected:

   DtEntityIdentifier         myObjectIdentifier;
   DtString                   myObjectLabel;
   DtString                   myEchelonIdString;
   DtString                   myOverlayParent;
   int                        myVrfSessionId;
   int                        myVrfMessageVersionSupported;
   bool                       myIsSubordinateOfForce;
   bool                       myIndependentlyTasked;
   char                       myVrfObjectDataVersion;
   bool                       myUnderFire;
   bool                       myVrfSimulated;
   bool                       myHasPlan;
   bool                       myExecutingPlan;
   bool                       myIsCurrentlyTasked;
   bool                       myIsClutterEntity;
   DtString                   myRulesOfEngagement;

   // Used for filledInNetRep() method.  If myDirty is true, will call
   // setToNet()
   bool                       myDirty;

   DtRangeItems_V1            myRangeItems_V1;
   DtRangeItems               myRangeItems;

   DtVector32                 myBoundingVolume;
   DtVector32                 myBoundingVolumeOffset;

   mutable DtVrfExtendedRecordData myExtendedData;
};