Entity State Repository

The DtEntityStateRepWithTemperature is a new class that replaces the default VR-Link entity state repository in order to add storage for the new temperature attribute. In order to encode the temperature to an HLA attribute, new encoder, decoder, and checker functions are also required to be registered with VR-Link. Note that this example does not support publishing the new attribute to DIS. However this could be achieved using the VR-Link API to encode the temperature into a new attribute record in DIS 7. See the VR-Link API for more details. Additionally, VR-Forces state properties can also be used to easily add and publish new attributes for both HLA and DIS. Please see the addStateProperty example for more details.

---

State Repository Header file:

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

#pragma once

#if DtHLA

#include <vrfExtObjects/extEntityStateRepository.h>
#include <stdio.h>
#include <vrfExtObjects/extendedAttributesInitializer.h>
#include <vl/entityPublisher.h>
#include <vl/reflectedEntityList.h>

// Because this example adds a concept that did not already exist in VR-Link's
// DtEntityStateRepository class, we create this subclass of that adds the concept of temperature.

class DtEntityStateRepWithTemperature : public DtExtEntityStateRepository
{
public:
   DtEntityStateRepWithTemperature()
      : DtExtEntityStateRepository()
      , myTemperature(0.)
   {
   }

   DtEntityStateRepWithTemperature(const DtEntityStateRepWithTemperature& o)
      : DtExtEntityStateRepository(o)
      , myTemperature(o.myTemperature)
   {
   }

   // Set/Get the value of temperature
   virtual void setTemperature(double temp);
   virtual double temperature() const;

   // Virtual function override: print the state rep's data.
   virtual void printData() const;

public:

   // Create a DtEntityStateRepWithTemperature.  Caller is responsible for deletion.
   static DtExtEntityStateRepository* create();

   // Copy shallow (false) or deep (true).
   virtual DtStateRepository* clone(bool copy = false) const;

protected:

   float myTemperature;
};

// Inline functions

inline void DtEntityStateRepWithTemperature::setTemperature(double temp)
{
   myTemperature = temp;
}

inline double DtEntityStateRepWithTemperature::temperature() const
{
   return myTemperature;
}

inline void DtEntityStateRepWithTemperature::printData() const
{
   DtEntityStateRepository::printData();
   printf("Temperature: %lf\n", temperature());
}

inline DtExtEntityStateRepository* DtEntityStateRepWithTemperature::create()
{
   return new DtEntityStateRepWithTemperature();
}

inline DtStateRepository* DtEntityStateRepWithTemperature::clone(bool copy) const
{
   if (copy)
   {
      return new DtEntityStateRepWithTemperature(*this);
   }
   else
   {
      return new DtEntityStateRepWithTemperature();
   }
}

class DtEntityExtendedAttributesWithTemperatureInitializer : public DtEntityExtendedAttributesInitializer
{
public:

   DtEntityExtendedAttributesWithTemperatureInitializer()
      : DtEntityExtendedAttributesInitializer()
   {
      DtWarn << "Constructing" << std::endl;
   }

   virtual ~DtEntityExtendedAttributesWithTemperatureInitializer()
   {
      DtWarn << "Destructing" << std::endl;
   }

protected:

   void setPublisherStateRepCreator()
   {
      DtEntityPublisher::setStateRepCreator((DtEntityPublisher::DtStateRepCreator)
         DtEntityStateRepWithTemperature::create);
   }

   void setReflectedObjectStateRepCreator()
   {
      DtReflectedEntity::setStateRepCreator((DtReflectedEntity::DtStateRepCreator)
         DtEntityStateRepWithTemperature::create);
   }
};

#endif

---

Header file for encoder, decoder, and checker functions as well as FOM mapper configuration:

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

#pragma once

#if DtHLA

#include <vl/fomMapper.h>
#include "esrWithTemperature.h"

// This function registers new encoding, decoding, and checking functions with
// a FOM Mapper for the new attribute of the "BaseEntity" object class called
// "Temperature". 

void configFomMapper(DtFomMapper* mapper);

void unconfigFomMapper();

// The encoding, decoding and checking functions that configFomMapper registers:

//Encoding function to be used for the "Temperature" attribute.
void encodeTemperature(const DtEntityStateRepWithTemperature& stateRep,
   RTI::AttributeHandleValuePairSet* avList,
   RTI::AttributeHandle handle);

//Decoding function to be used for the "Temperature" attribute.
void decodeTemperature(DtEntityStateRepWithTemperature* stateRep,
   const RTI::AttributeHandleValuePairSet& avlist,
   int pairSetIndex);

//Checking function to be used for the "Temperature" attribute (checks whether
//update condition has been met).
bool needTemperature(
   const DtEntityStateRepWithTemperature& stateRep,
   const DtEntityStateRepWithTemperature& asSeenByRemote);

#endif

---

Implementation for encoder, decoder, and checker functions as well as FOM mapper configuration:

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

#if DtHLA

#include "configFomMapper.h"
#include <vl/stateEncoderFactory.h>
#include <vl/stateDecoderFactory.h>
#include <vrfExtObjects/vrfEntityPublisher.h>

void configFomMapper(DtFomMapper* mapper)
{
   DtVrfEntityPublisher::setInitializer(
      DtExtendedAttributesInitializerPtr(new DtEntityExtendedAttributesWithTemperatureInitializer));

   // Add your encoding function for the "Temperature" attribute to the prototype
   // encoders for BaseEntity and all of its subclasses.
   mapper->stateEncoderFactory()->addAttributeEncoder(
      "BaseEntity.PhysicalEntity", "Temperature",
      (DtHlaStateEncoder::DtAttributeEncoder) encodeTemperature, true);

   // Add your decoding function for the "Temperature" attribute to the prototype
   // decoders for BaseEntity and all of its subclasses.
   mapper->stateDecoderFactory()->addAttributeDecoder(
      "BaseEntity.PhysicalEntity", "Temperature",
      (DtHlaStateDecoder::DtAttributeDecoder) decodeTemperature, true);

   // Add your checking function for the "Temperature" attribute to the prototype
   // encoders for BaseEntity and all of its subclasses.
   mapper->stateEncoderFactory()->addAttributeChecker(
      "BaseEntity.PhysicalEntity", "Temperature",
      (DtHlaStateEncoder::DtAttributeChecker) needTemperature, true);
}

void unconfigFomMapper()
{
   DtVrfEntityPublisher::setInitializer(DtExtendedAttributesInitializerPtr());
}

// Define the new encoding, decoding and checking functions that we register
// with the FOM Mapper.  By using VR-Link's "Net" types in out functions, byte
// swapping occurs automatically when necessary.

// Encoding function to be used for the "Temperature" attribute.
void encodeTemperature(const DtEntityStateRepWithTemperature& stateRep,
   RTI::AttributeHandleValuePairSet* avList,
   RTI::AttributeHandle handle)
{
   // Get the value using stateRep's temperature(), and add it to the avList.
   double temperature = stateRep.temperature();
   DtNetFloat64 netVal(temperature);
   avList->add(handle, (char*)&netVal, sizeof(DtNetFloat64));
}

// Decoding function to be used for the "Temperature" attribute.
void decodeTemperature(DtEntityStateRepWithTemperature* stateRep,
   const RTI::AttributeHandleValuePairSet& avlist,
   int pairSetIndex)
{
   // Get the value from the avList, and pass it to stateRep's setTemperature().
   DtNetFloat64 netVal;
   RTI::ULong length = 0;
   avlist.getValue(pairSetIndex, (char*)&netVal, length);
   stateRep->setTemperature((double)netVal);
}

// Checking function to be used for the "Temperature" attribute (checks whether
// update condition has been met).
bool needTemperature(
   const DtEntityStateRepWithTemperature& stateRep,
   const DtEntityStateRepWithTemperature& asSeenByRemote)
{
   // Just compare the Temperatures in the two state repositories.
   return (bool)(stateRep.temperature() != asSeenByRemote.temperature());
}

#endif