underwaterAcousticsStateComponent.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 <legionStandardOM/sets/readPropulsionNoiseRepository.hpp>
#include <legionStandardOM/sets/writePropulsionNoiseRepository.hpp>
#include <vrfutil/rwUUID.h>

#include <vlutil/vlString.h>
#include <matrix/vlVector.h>

namespace makVrf
{
   struct DT_DLL_vrfStateData DtUnderwaterAcousticsStateComponentData
   {
      struct UnderwaterAcousticShaftSpeed
      {
         UnderwaterAcousticShaftSpeed()
         : myCurrentShaftRPM(0.)
         , myOrderedShaftRPM(0.)
         , myShaftRPM_RateOfChange(0.)
         {
         }

         UnderwaterAcousticShaftSpeed(const UnderwaterAcousticShaftSpeed& orig)
         : myCurrentShaftRPM(orig.myCurrentShaftRPM)
         , myOrderedShaftRPM(orig.myOrderedShaftRPM)
         , myShaftRPM_RateOfChange(orig.myShaftRPM_RateOfChange)
         {
         }

         UnderwaterAcousticShaftSpeed& operator=(const UnderwaterAcousticShaftSpeed& rhs)
         {
            myCurrentShaftRPM = rhs.myCurrentShaftRPM;
            myOrderedShaftRPM = rhs.myOrderedShaftRPM;
            myShaftRPM_RateOfChange = rhs.myShaftRPM_RateOfChange;

            return *this;
         }

         bool operator==(const UnderwaterAcousticShaftSpeed& rhs) const
         {
            return ((myCurrentShaftRPM == rhs.myCurrentShaftRPM) &&
                    (myOrderedShaftRPM == rhs.myOrderedShaftRPM) &&
                    (myShaftRPM_RateOfChange == rhs.myShaftRPM_RateOfChange));
         }

         bool operator!=(const UnderwaterAcousticShaftSpeed& rhs) const
         {
            return !(*this == rhs);
         }

         DEFINE_ACCESSOR_MUTATOR(unsigned short, currentShaftRPM, CurrentShaftRPM)
         DEFINE_ACCESSOR_MUTATOR(unsigned short, orderedShaftRPM, OrderedShaftRPM)
         DEFINE_ACCESSOR_MUTATOR(unsigned short, shaftRPM_RateOfChange, ShaftRPM_RateOfChange)

      protected:
         unsigned short myCurrentShaftRPM;
         unsigned short myOrderedShaftRPM;
         unsigned short myShaftRPM_RateOfChange;
      };

      DtUnderwaterAcousticsStateComponentData()
      : myPublish(true)
      , myPassiveParameterIndex(1)
      {
      }

      DtUnderwaterAcousticsStateComponentData(const DtUnderwaterAcousticsStateComponentData& orig)
      : myPublish(orig.myPublish)
      , myShaftData(orig.myShaftData)
      , myPassiveParameterIndex(orig.myPassiveParameterIndex)
      {
      }

      DtUnderwaterAcousticsStateComponentData& operator=(const DtUnderwaterAcousticsStateComponentData& rhs)
      {
         myPublish = rhs.myPublish;
         myShaftData = rhs.myShaftData;
         myPassiveParameterIndex = rhs.myPassiveParameterIndex;

         return *this;
      }

      typedef std::vector<UnderwaterAcousticShaftSpeed> ShaftData;

      DEFINE_ACCESSOR_MUTATOR(bool, publish, Publish)
      DEFINE_ACCESSOR_MUTATOR(ShaftData, shaftData, ShaftData)
      DEFINE_ACCESSOR_MUTATOR(int, passiveParameterIndex, PassiveParameterIndex)
      ShaftData& shaftData() { return myShaftData; };

   protected:
      bool myPublish;
      ShaftData myShaftData{};
      int myPassiveParameterIndex;
   };

   class DT_DLL_vrfStateData DtUnderwaterAcousticsStateComponent : public DtFrameStateInterface
   {
   public:
      DEFINE_STATE_COMPONENT_TYPE(DtStateComponent::UnderwaterAcousticsStateComponent)

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

      UNDEFINED_RETURNVALUE_ACCESSOR(DtUUID, hostId)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(bool, publish, Publish)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(bool, hullMaskerOn, HullMaskerOn)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(int, passiveParameterIndex, PassiveParameterIndex)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(unsigned int, propulsionPlantConfiguration, PropulsionPlantConfiguration)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(DtUnderwaterAcousticsStateComponentData::ShaftData, shaftData, ShaftData)
   };

   class DT_DLL_vrfStateData DtUnderwaterAcousticsStateComponentNextFrame : public DtUnderwaterAcousticsStateComponent
   {
   public:
      DtUnderwaterAcousticsStateComponentNextFrame(DtStateData* storage);
      virtual ~DtUnderwaterAcousticsStateComponentNextFrame() override;

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

      virtual const DtUUID hostId() const override;

      virtual const bool& publish() const override;
      virtual void setPublish(const bool&) override;

      virtual const bool hullMaskerOn() const override;
      virtual void setHullMaskerOn(const bool&) override;

      virtual const int& passiveParameterIndex() const override;
      virtual void setPassiveParameterIndex(const int&) override;

      virtual const unsigned int propulsionPlantConfiguration() const override;
      virtual void setPropulsionPlantConfiguration(const unsigned int&) override;

      virtual const DtUnderwaterAcousticsStateComponentData::ShaftData& shaftData() const override;
      virtual void setShaftData(const DtUnderwaterAcousticsStateComponentData::ShaftData&) override;

      virtual void makeWritable() override;

      virtual void makeReadOnly() override;

   protected:
      DtUnderwaterAcousticsStateComponentData myData;
      LOM::WritePropulsionNoiseRepository myWritePropulsionNoiseRepository;
   };

   class DT_DLL_vrfStateData DtUnderwaterAcousticsStateComponentCurrentFrame : public DtUnderwaterAcousticsStateComponent
   {
   public:
      DtUnderwaterAcousticsStateComponentCurrentFrame(DtStateData* storage);
      virtual ~DtUnderwaterAcousticsStateComponentCurrentFrame() override;

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

      virtual const DtUUID hostId() const override;
      virtual const bool& publish() const override;
      virtual const bool hullMaskerOn() const override;
      virtual const DtUnderwaterAcousticsStateComponentData::ShaftData& shaftData() const override;
      virtual const int& passiveParameterIndex() const override;
      virtual const unsigned int propulsionPlantConfiguration() const override;
      bool readComponentValid() const;

      bool findReadComponent();

   protected:
      void handleDataUpdated();

      friend class DtUnderwaterAcousticsStateComponentImplementation;
      void advanceFrame(const DtUnderwaterAcousticsStateComponentData& data)
      {
         myData = data;
      }

   protected:
      DtUnderwaterAcousticsStateComponentData myData;
      LOM::ReadPropulsionNoiseRepository myReadPropulsionNoiseRepository;
      unsigned int myCallbackHandle;
   };

   class DT_DLL_vrfStateData DtUnderwaterAcousticsStateComponentImplementation : public DtDoubleBufferedStateComponent<DtUnderwaterAcousticsStateComponent>
   {
   public:
      DtUnderwaterAcousticsStateComponentImplementation(DtStateData* sd);

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

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

         myCurrentFrameState.emitComponentUpdated();
      }

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

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

      virtual bool forceAdvance() override;

      virtual void firstFrameAdvance() override;

   protected:
      DtUnderwaterAcousticsStateComponentCurrentFrame myCurrentFrameState;
      DtUnderwaterAcousticsStateComponentNextFrame myNextFrameState;
      bool myFoundComponent;
   };

   typedef DtStateComponentCreator<DtUnderwaterAcousticsStateComponentImplementation> DtUnderwaterAcousticsStateComponentCreator;
}