Internal Temperature State Component

The DtInternalTemperatureStateComponent is a new class that implements a state component for storing the internal temperature of an entity.

---

Header file:

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

#pragma once

#include <vrfStateData/stateComponent.h>
#include <vrfStateData/doubleBufferedDataStorage.h>
#include <matrix/vlVector.h>

namespace makVrf
{
   struct DtInternalTemperatureStateComponentData
   {
      DtInternalTemperatureStateComponentData()
         : myInternalCoreTemperature(37.0)
      {};

      DtInternalTemperatureStateComponentData(const DtInternalTemperatureStateComponentData& orig)
      {
         myInternalCoreTemperature = orig.myInternalCoreTemperature;
      }

      DtInternalTemperatureStateComponentData& operator=(const DtInternalTemperatureStateComponentData& orig)
      {
         myInternalCoreTemperature = orig.myInternalCoreTemperature;

         return *this;
      }

      DEFINE_ACCESSOR_MUTATOR(double, internalCoreTemperature, InternalCoreTemperature)

   protected:
      double myInternalCoreTemperature;
   };
   const unsigned int InternalTemperatureStateComponent = 65;

   class DtInternalTemperatureStateComponent : public DtFrameStateInterface
   {
   public:
      DEFINE_STATE_COMPONENT_TYPE(InternalTemperatureStateComponent)

         DtInternalTemperatureStateComponent(DtStateData* storage)
         : DtFrameStateInterface(storage)
      {
      }

      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(double, internalCoreTemperature, InternalCoreTemperature)
   };

   class DtInternalTemperatureStateComponentNextFrame : public DtInternalTemperatureStateComponent
   {
   public:
      DtInternalTemperatureStateComponentNextFrame(DtStateData*);

      const DtInternalTemperatureStateComponentData& frameState() const { return myData; };
      DtInternalTemperatureStateComponentData& frameState() { return myData; };

      const double& internalCoreTemperature() const;
      void setInternalCoreTemperature(const double&);

      virtual void makeWritable() {};

      virtual void makeReadOnly() {};

   protected:
      DtStateData* myStateData;
      DtInternalTemperatureStateComponentData myData;
   };

   class DtInternalTemperatureStateComponentCurrentFrame : public DtInternalTemperatureStateComponent
   {
   public:
      DtInternalTemperatureStateComponentCurrentFrame(DtStateData*);
      virtual ~DtInternalTemperatureStateComponentCurrentFrame();

      const DtInternalTemperatureStateComponentData& frameState() const { return myData; };

      const double& internalCoreTemperature() const;

   protected:
      void completeSetup();
      void updateVrfStateComponentParameters();

      void updateInternalTemperatureData();

      friend class DtInternalTemperatureStateComponentImplementation;
      void advanceFrame(const DtInternalTemperatureStateComponentData& data)
      {
         myData = data;
      }

   protected:
      boost::signals2::scoped_connection myVrfStateComponentChangedConnection;
      boost::signals2::scoped_connection myCompleteSetupConnection;
      DtStateData* myStateData;
      DtInternalTemperatureStateComponentData myData;
   };

   class DtInternalTemperatureStateComponentImplementation : public DtDoubleBufferedStateComponent<DtInternalTemperatureStateComponent>
   {
   public:
      DtInternalTemperatureStateComponentImplementation(DtStateData* sd);

      bool isDoubleBuffered() { return true; };
      const DtFrameStateInterface* currentFrameState() const { return &myCurrentFrameState; }
      virtual DtFrameStateInterface* nextFrameState() { return &myNextFrameState; };
      virtual const DtFrameStateInterface* nextFrameState() const { return &myNextFrameState; };

      void updateDataStorage()
      {
         if (myNextFrameState.isWritable())
         {
            myCurrentFrameState.advanceFrame(myNextFrameState.frameState());
         }

         myCurrentFrameState.emitComponentUpdated();
      }

      void updateStateData(DtStateData* sd)
      {
         myCurrentFrameState.updateStateData(sd);
         myNextFrameState.updateStateData(sd);
      }

      virtual void aboutToBeDeleted() override
      {
         DtDoubleBufferedStateComponent<DtInternalTemperatureStateComponent>::aboutToBeDeleted();
         myCurrentFrameState.aboutToBeDeleted();
         myNextFrameState.aboutToBeDeleted();
      }

   protected:
      DtInternalTemperatureStateComponentCurrentFrame myCurrentFrameState;
      DtInternalTemperatureStateComponentNextFrame myNextFrameState;
   };

   typedef DtStateComponentCreator<DtInternalTemperatureStateComponentImplementation> DtInternalTemperatureStateComponentCreator;
}

---

Implementation:

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

#include "internalTemperatureStateComponent.h"
#include <vrfStateData/stateComponentFactory.h>
#include <vrfStateData/statePropertiesStateComponent.h>
#include <vrfStateData/stateData.h>
#include <readerWriter/propertyUtils.h>

namespace makVrf
{
   REGISTER_STATE_COMPONENT(DtInternalTemperatureStateComponentCreator, DtInternalTemperatureStateComponent)

      
      DtInternalTemperatureStateComponentCurrentFrame::DtInternalTemperatureStateComponentCurrentFrame(DtStateData* sd)
      : DtInternalTemperatureStateComponent(sd)
      , myStateData(sd)
   {
      if (sd->advancedFrame())
      {
         completeSetup();
      }
      else
      {
         myCompleteSetupConnection = sd->signal_firstFrameAdvance.connect(boost::bind(&DtInternalTemperatureStateComponentCurrentFrame::completeSetup, this));
      }
   }

   DtInternalTemperatureStateComponentCurrentFrame::~DtInternalTemperatureStateComponentCurrentFrame()
   {
   }

   void DtInternalTemperatureStateComponentCurrentFrame::completeSetup()
   {
      myCompleteSetupConnection.disconnect();

      updateVrfStateComponentParameters();
   }

   void DtInternalTemperatureStateComponentCurrentFrame::updateVrfStateComponentParameters()
   {
      updateInternalTemperatureData();
   }

   void DtInternalTemperatureStateComponentCurrentFrame::updateInternalTemperatureData()
   {
      //We will be using state properties to publish out our temperature
      boost::optional<double> temp = findPropertyValue<double>(myStateData->currentFrameState()->getStateComponent<DtStatePropertiesStateComponent>()->stateProperties(), "internal-core-temperature");

      if (temp)
      {
         myData.setInternalCoreTemperature(*temp);
      }
   }

   const double& DtInternalTemperatureStateComponentCurrentFrame::internalCoreTemperature() const
   {
      return frameState().internalCoreTemperature();
   }

   DtInternalTemperatureStateComponentNextFrame::DtInternalTemperatureStateComponentNextFrame(DtStateData* sd)
      : DtInternalTemperatureStateComponent(sd)
      , myStateData(sd)
   {
   }

   const double& DtInternalTemperatureStateComponentNextFrame::internalCoreTemperature() const
   {
      return frameState().internalCoreTemperature();
   }

   void DtInternalTemperatureStateComponentNextFrame::setInternalCoreTemperature(const double& s)
   {
      if (s != internalCoreTemperature())
      {
         markModified();

         if (myStateData->nextFrameState()->hasStateComponent<DtStatePropertiesStateComponent>())
         {
            findAndSetPropertyValue<double>(myStateData->nextFrameState()->getStateComponent<DtStatePropertiesStateComponent>()->stateProperties(),"internal-core-temperature", s);
         }

         frameState().setInternalCoreTemperature(s);
      }
   }

   DtInternalTemperatureStateComponentImplementation::DtInternalTemperatureStateComponentImplementation(DtStateData* sd)
      : DtDoubleBufferedStateComponent(sd)
      , myCurrentFrameState(sd)
      , myNextFrameState(sd)
   {
   }
}