radioReceiverStateComponent.h

Go to the documentation of this file.

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

#pragma once

#include "vrfStateData/vrfStateDataDefines.h"
#include "vrfStateData/doubleBufferedDataStorage.h"
#include "vrfStateData/stateComponent.h"
#include "vrfutil/rwUUID.h"
#include <legionStandardOM/sets/readRadioReceiverRepository.hpp>
#include <legionStandardOM/sets/writeRadioReceiverRepository.hpp>

namespace makVrf
{
   struct DT_DLL_vrfStateData DtRadioReceiverStateComponentData
   {
      DtRadioReceiverStateComponentData()
      : myHostId(DtUUID::nullUUID())
      , myTransmitterId(DtUUID::nullUUID())
      , myReceiverState(0)
      , myReceivedPower(0)
      , myRadioId(0)
      {
      }

      DtRadioReceiverStateComponentData(const DtRadioReceiverStateComponentData& orig)
      : myHostId(orig.myHostId)
      , myTransmitterId(orig.myTransmitterId)
      , myReceiverState(orig.myReceiverState)
      , myReceivedPower(orig.myReceivedPower)
      , myRadioId(orig.myRadioId)
      {
      }

      DtRadioReceiverStateComponentData& operator=(const DtRadioReceiverStateComponentData& orig)
      {
         myHostId = orig.myHostId;
         myTransmitterId = orig.myTransmitterId;
         myReceivedPower = orig.myReceivedPower;
         myReceiverState = orig.myReceiverState;
         myRadioId = orig.myRadioId;

         return *this;
      }

      DEFINE_ACCESSOR_MUTATOR(DtUUID, hostId, HostId)
      DEFINE_ACCESSOR_MUTATOR(DtUUID, transmitterId, TransmitterId)
      DEFINE_ACCESSOR_MUTATOR(unsigned int, receiverState, ReceiverState)
      DEFINE_ACCESSOR_MUTATOR(UInt64, radioId, RadioId)
      DEFINE_ACCESSOR_MUTATOR(float, receivedPower, ReceivedPower)

   protected:
      DtUUID myHostId;
      DtUUID myTransmitterId;
      unsigned int myReceiverState;
      float myReceivedPower;
      UInt64 myRadioId;
   };

   class DT_DLL_vrfStateData DtRadioReceiverStateComponent : public DtFrameStateInterface
   {
   public:
      DEFINE_STATE_COMPONENT_TYPE(DtStateComponent::RadioReceiverStateComponent)

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

      UNDEFINED_RETURNVALUE_ACCESSOR(DtUUID, hostId)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(DtUUID, transmitterId, TransmitterId)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(unsigned int, receiverState, ReceiverState)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(UInt64, radioId, RadioId)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(float, receivedPower, ReceivedPower)
   };

   class DT_DLL_vrfStateData DtRadioReceiverStateComponentNextFrame : public DtRadioReceiverStateComponent
   {
   public:
      DtRadioReceiverStateComponentNextFrame(DtStateData* storage);
      virtual ~DtRadioReceiverStateComponentNextFrame();

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

      const DtUUID hostId() const;

      const DtUUID& transmitterId() const;
      void setTransmitterId(const DtUUID&);

      const unsigned int receiverState() const;
      void setReceiverState(const unsigned int&);

      const UInt64 radioId() const;
      void setRadioId(const UInt64&);

      const float receivedPower() const;
      void setReceivedPower(const float&);

      virtual void makeWritable();

      virtual void makeReadOnly();

      Legion::WriteStateInstance writeStateInstance() override;
      virtual void updateStateData(DtStateData*) override;

      void cleanupWriteState();
      void setPublishingOnLegionNetwork(bool b);

   protected:
      DtRadioReceiverStateComponentData myData;
      LOM::WriteRadioReceiverRepository myWriteRadioReceiverRepository;
      DtStateData* myStateData;
      bool myPublishingOnLegionNetwork;
   };

   class DT_DLL_vrfStateData DtRadioReceiverStateComponentCurrentFrame : public DtRadioReceiverStateComponent
   {
   public:
      DtRadioReceiverStateComponentCurrentFrame(DtStateData* storage);
      virtual ~DtRadioReceiverStateComponentCurrentFrame();

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

      const DtUUID hostId() const;
      const DtUUID& transmitterId() const;
      const unsigned int receiverState() const;
      const UInt64 radioId() const;
      const float receivedPower() const;

      bool readComponentValid() const;
      bool findReadComponent();

      virtual void updateStateData(DtStateData*) override;

   protected:
      friend class DtRadioReceiverStateComponentImplementation;
      void advanceFrame(const DtRadioReceiverStateComponentData& data)
      {
         myData = data;
      }
      virtual void handleDataUpdated();

   protected:
      DtRadioReceiverStateComponentData myData;
      LOM::ReadRadioReceiverRepository myReadRadioReceiverRepository;
      int myCallbackHandle;
      DtStateData* myStateData;
   };

   class DT_DLL_vrfStateData DtRadioReceiverStateComponentImplementation : public DtDoubleBufferedStateComponent<DtRadioReceiverStateComponent>
   {
   public:
      DtRadioReceiverStateComponentImplementation(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();
      }

      virtual bool forceAdvance();

      virtual void firstFrameAdvance() override;

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

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

      virtual void completeSetup() override;
      virtual void removeAdditionalStateComponents() override;
      virtual void setPublishingOnLegionNetwork(bool b) override;

   protected:
      DtRadioReceiverStateComponentCurrentFrame myCurrentFrameState;
      DtRadioReceiverStateComponentNextFrame myNextFrameState;
      bool myFoundComponent;
   };

   typedef DtStateComponentCreator<DtRadioReceiverStateComponentImplementation> DtRadioReceiverStateComponentCreator;
}