laserDesignatorStateComponent.h

Go to the documentation of this file.

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

#pragma once

#include "vrfStateData/stateComponent.h"
#include "vrfStateData/doubleBufferedDataStorage.h"
#include <legionStandardOM/sets/readDesignatorRepository.hpp>
#include <legionStandardOM/sets/writeDesignatorRepository.hpp>
#include <vrfutil/rwUUID.h>
#include <matrix/vlVector.h>

namespace makVrf
{
   struct DT_DLL_vrfStateData DtLaserDesignatorStateComponentData
   {
      DtLaserDesignatorStateComponentData()
      : myDesignatedObject(DtUUID::nullUUID())
      , myDesignatorId(DtUUID::nullUUID())
      {
      }

      DtLaserDesignatorStateComponentData(const DtLaserDesignatorStateComponentData& orig)
      : myDesignatedObject(orig.myDesignatedObject)
      , myDesignatorId(orig.myDesignatorId)
      , myGlobalId(orig.myGlobalId)
      {
      }

      DtLaserDesignatorStateComponentData& operator=(const DtLaserDesignatorStateComponentData& rhs)
      {
         myDesignatedObject = rhs.myDesignatedObject;
         myDesignatorId = rhs.myDesignatorId;
         myGlobalId = rhs.myGlobalId;

         return *this;
      }

      DEFINE_ACCESSOR_MUTATOR(DtUUID, designatedObject, DesignatedObject)
      DEFINE_ACCESSOR_MUTATOR(DtUUID, designatorId, DesignatorId)
      DEFINE_ACCESSOR_MUTATOR(DtString, globalId, GlobalId)

   protected:
      DtUUID myDesignatedObject;
      DtUUID myDesignatorId;
      DtString myGlobalId;
   };

   class DT_DLL_vrfStateData DtLaserDesignatorStateComponent : public DtFrameStateInterface
   {
   public:
      DEFINE_STATE_COMPONENT_TYPE(DtStateComponent::LaserDesignatorStateComponent)

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

      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(DtUUID, designatedObject, DesignatedObject)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(DtUUID, designatorId, DesignatorId)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(unsigned int, designatorCode, DesignatorCode)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(unsigned int, drAlgorithm, DrAlgorithm)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, designatorPower, DesignatorPower)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(double, designatorWavelength, DesignatorWavelength)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(DtVector, designatorSpotLocation, DesignatorSpotLocation)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(unsigned int, codeName, CodeName)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(DtVector, spotLinearAcceleration, SpotLinearAcceleration)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(DtString, globalId, GlobalId)
   };

   class DT_DLL_vrfStateData DtLaserDesignatorStateComponentNextFrame : public DtLaserDesignatorStateComponent
   {
   public:
      DtLaserDesignatorStateComponentNextFrame(DtStateData* storage);
      virtual ~DtLaserDesignatorStateComponentNextFrame();

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

      const DtUUID& designatedObject() const;
      void setDesignatedObject(const DtUUID&);

      const DtUUID& designatorId() const;
      void setDesignatorId(const DtUUID&);

      const unsigned int designatorCode() const;
      void setDesignatorCode(const unsigned int&);

      const unsigned int drAlgorithm() const;
      void setDrAlgorithm(const unsigned int&);

      const unsigned int codeName() const;
      void setCodeName(const unsigned int&);

      const DtVector spotLinearAcceleration() const;
      void setSpotLinearAcceleration(const DtVector&);

      const double designatorPower() const;
      void setDesignatorPower(const double&);

      const double designatorWavelength() const;
      void setDesignatorWavelength(const double&);

      const DtVector designatorSpotLocation() const;
      void setDesignatorSpotLocation(const DtVector&);

      const DtString& globalId() const;
      void setGlobalId(const DtString&);

      virtual void makeWritable();

      virtual void makeReadOnly();
      void cleanupWriteState();

   protected:
      DtLaserDesignatorStateComponentData myData;
      LOM::WriteDesignatorRepository myWriteDesignatorRepository;
      DtStateData* myStateData;
   };

   class DT_DLL_vrfStateData DtLaserDesignatorStateComponentCurrentFrame : public DtLaserDesignatorStateComponent
   {
   public:
      DtLaserDesignatorStateComponentCurrentFrame(DtStateData* storage);
      virtual ~DtLaserDesignatorStateComponentCurrentFrame();

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

      const DtUUID& designatedObject() const;
      const DtUUID& designatorId() const;
      const unsigned int designatorCode() const;
      const double designatorPower() const;
      const double designatorWavelength() const;
      const DtVector designatorSpotLocation() const;
      const unsigned int codeName() const;
      const DtVector spotLinearAcceleration() const;
      const unsigned int drAlgorithm() const;
      const DtString& globalId() const;

      bool readComponentValid() const;
      bool findReadComponent();

   protected:
      void handleDataUpdated();

      friend class DtLaserDesignatorStateComponentImplementation;
      void advanceFrame(const DtLaserDesignatorStateComponentData& data)
      {
         myData = data;
      }

   protected:
      DtLaserDesignatorStateComponentData myData;
      LOM::ReadDesignatorRepository myReadDesignatorRepository;
      int myCallbackHandle;
      DtStateData* myStateData;
   };

   class DT_DLL_vrfStateData DtLaserDesignatorStateComponentImplementation : public DtDoubleBufferedStateComponent<DtLaserDesignatorStateComponent>
   {
   public:
      DtLaserDesignatorStateComponentImplementation(DtStateData* sd);

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

      virtual bool forceAdvance() override;

      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<DtLaserDesignatorStateComponent>::aboutToBeDeleted();
         myCurrentFrameState.aboutToBeDeleted();
         myNextFrameState.aboutToBeDeleted();
      }

      virtual void firstFrameAdvance() override;
      virtual void removeAdditionalStateComponents() override;

   protected:
      DtLaserDesignatorStateComponentCurrentFrame myCurrentFrameState;
      DtLaserDesignatorStateComponentNextFrame myNextFrameState;
      bool myFoundComponent;
   };

   typedef DtStateComponentCreator<DtLaserDesignatorStateComponentImplementation> DtLaserDesignatorStateComponentCreator;
}