internalTemperatureStateComponent.h

Go to the documentation of this 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;
}