activeSonarStateComponent.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 <matrix/vlVector.h>

namespace makVrf
{
   struct DT_DLL_vrfStateData DtActiveSonarBeamStateData
   {
      DtActiveSonarBeamStateData()
      : mySystemId(0)
      , myBeamId(0)
      , myAzimuthCenter(0.)
      , myAzimuthBeamWidth(0.)
      , myElevationCenter(0.)
      , myElevationBeamWidth(0.)
      , myActiveEmissionParameterIndex(0)
      , myScanPattern(0)
      {
      }

      DtActiveSonarBeamStateData(const DtActiveSonarBeamStateData& orig)
      : mySystemId(orig.mySystemId)
      , myBeamId(orig.myBeamId)
      , myAzimuthCenter(orig.myAzimuthCenter)
      , myAzimuthBeamWidth(orig.myAzimuthBeamWidth)
      , myElevationCenter(orig.myElevationCenter)
      , myElevationBeamWidth(orig.myElevationBeamWidth)
      , myActiveEmissionParameterIndex(orig.myActiveEmissionParameterIndex)
      , myScanPattern(orig.myScanPattern)
      {
      }

      DtActiveSonarBeamStateData& operator=(const DtActiveSonarBeamStateData& rhs)
      {
         mySystemId = rhs.mySystemId;
         myBeamId = rhs.myBeamId;
         myAzimuthCenter = rhs.myAzimuthCenter;
         myAzimuthBeamWidth = rhs.myAzimuthBeamWidth;
         myElevationCenter = rhs.myElevationCenter;
         myElevationBeamWidth = rhs.myElevationBeamWidth;
         myActiveEmissionParameterIndex = rhs.myActiveEmissionParameterIndex;
         myScanPattern = rhs.myScanPattern;

         return *this;
      }

      DEFINE_ACCESSOR_MUTATOR(unsigned int, beamId, BeamId)
      DEFINE_ACCESSOR_MUTATOR(unsigned int, systemId, SystemId)
      DEFINE_ACCESSOR_MUTATOR(unsigned int, activeEmissionParameterIndex, ActiveEmissionParameterIndex)
      DEFINE_ACCESSOR_MUTATOR(unsigned int, scanPattern, ScanPattern)
      DEFINE_ACCESSOR_MUTATOR(double, azimuthCenter, AzimuthCenter)
      DEFINE_ACCESSOR_MUTATOR(double, azimuthBeamWidth, AzimuthBeamWidth)
      DEFINE_ACCESSOR_MUTATOR(double, elevationCenter, ElevationCenter)
      DEFINE_ACCESSOR_MUTATOR(double, elevationBeamWidth, ElevationBeamWidth)

   protected:
      unsigned int myBeamId;
      unsigned int mySystemId;
      double myAzimuthCenter;
      double myAzimuthBeamWidth;
      double myElevationCenter;
      double myElevationBeamWidth;
      unsigned int myActiveEmissionParameterIndex;
      unsigned int myScanPattern;
   };

   struct DT_DLL_vrfStateData DtActiveSonarStateComponentData
   {
      struct DtActiveSonarBeams
      {
      public:
         DtActiveSonarBeams()
         : nextId(0)
         {};

         DtActiveSonarBeams(const DtActiveSonarBeams& orig)
         : beams(orig.beams)
         {
         };

         DtActiveSonarBeams& operator=(const DtActiveSonarBeams& rhs)
         {
            beams = rhs.beams;

            return *this;
         }

         int size() const
         {
            return beams.size();
         }

         DtActiveSonarBeamStateData* operator[](unsigned short beamId)
         {
            std::vector<DtActiveSonarBeamStateData>::iterator iter = beams.begin();
            std::vector<DtActiveSonarBeamStateData>::iterator end = beams.end();
            while (iter != end)
            {
               if (iter->beamId() == beamId)
               {
                  return &(*iter);
               }

               ++iter;
            }

            return nullptr;
         }

         const DtActiveSonarBeamStateData* operator[](unsigned short beamId) const
         {
            std::vector<DtActiveSonarBeamStateData>::const_iterator iter = beams.begin();
            std::vector<DtActiveSonarBeamStateData>::const_iterator end = beams.end();
            while (iter != end)
            {
               if (iter->beamId() == beamId)
               {
                  return &(*iter);
               }

               ++iter;
            }

            return nullptr;
         }

         void removeBeam(unsigned short beamId)
         {
            std::vector<DtActiveSonarBeamStateData>::iterator iter = beams.begin();
            std::vector<DtActiveSonarBeamStateData>::iterator end = beams.end();
            while (iter != end)
            {
               if (iter->beamId() == beamId)
               {
                  beams.erase(iter);
                  break;
               }

               ++iter;
            }
         }

         DtActiveSonarBeamStateData* beamByBeamId(unsigned short beamId)
         {
            return (*this)[beamId];
         }

         const DtActiveSonarBeamStateData* beamByBeamId(unsigned short beamId) const
         {
            return (*this)[beamId];
         }

         DtActiveSonarBeamStateData* beamByBeamIndex(unsigned short index)
         {
            if (index < beams.size())
            {
               return &beams[index];
            }

            return nullptr;
         }

         const DtActiveSonarBeamStateData* beamByBeamIndex(unsigned short index) const
         {
            if (index < beams.size())
            {
               return &beams[index];
            }

            return nullptr;
         }

         DtActiveSonarBeamStateData* addBeam()
         {
            unsigned short id = nextBeamId();

            DtActiveSonarBeamStateData data;
            data.setBeamId(id);

            beams.push_back(data);

            return &beams[beams.size() - 1];
         }

         unsigned short nextBeamId()
         {
            return ++nextId;
         }

         void removeAllBeams()
         {
            nextId = 0;
            beams.clear();
         }

         std::vector<DtActiveSonarBeamStateData> beams{};
         unsigned short nextId{ 0 };
      };

      DtActiveSonarStateComponentData()
      : myPublish(true)
      , mySystemName(0)
      , mySystemFunction(0)
      , mySystemId(0)
      {
      }

      DtActiveSonarStateComponentData(const DtActiveSonarStateComponentData& orig)
      : myPublish(orig.myPublish)
      , mySystemName(orig.mySystemName)
      , mySystemFunction(orig.mySystemFunction)
      , myMountLocation(orig.myMountLocation)
      , myBeamsList(orig.myBeamsList)
      , mySystemId(orig.mySystemId)
      {
      }

      DtActiveSonarStateComponentData& operator=(const DtActiveSonarStateComponentData& rhs)
      {
         myPublish = rhs.myPublish;
         mySystemName = rhs.mySystemName;
         mySystemFunction = rhs.mySystemFunction;
         myMountLocation = rhs.myMountLocation;
         myBeamsList = rhs.myBeamsList;
         mySystemId = rhs.mySystemId;

         return *this;
      }

      DtActiveSonarBeamStateData* beamByBeamId(unsigned short beamId)
      {
         return myBeamsList.beamByBeamId(beamId);
      }

      const DtActiveSonarBeamStateData* beamByBeamId(unsigned short beamId) const
      {
         return myBeamsList.beamByBeamId(beamId);
      }

      DtActiveSonarBeamStateData* beamByBeamIndex(unsigned short beamId)
      {
         return myBeamsList.beamByBeamIndex(beamId);
      }

      const DtActiveSonarBeamStateData* beamByBeamIndex(unsigned short beamId) const
      {
         return myBeamsList.beamByBeamIndex(beamId);
      }

      unsigned int numBeams() const { return myBeamsList.size(); };
      DtActiveSonarBeamStateData* addBeam() { return myBeamsList.addBeam(); };
      DtActiveSonarBeams& beams() { return myBeamsList; };
      const DtActiveSonarBeams& beams() const { return myBeamsList; };
      const std::vector<DtActiveSonarBeamStateData>& rawBeams() const { return myBeamsList.beams; };
      std::vector<DtActiveSonarBeamStateData>& rawBeams() { return myBeamsList.beams; };
      void removeAllBeams() { myBeamsList.removeAllBeams(); };
      void removeBeam(unsigned short beamId) { myBeamsList.removeBeam(beamId); };

      DEFINE_ACCESSOR_MUTATOR(bool, publish, Publish)
      DEFINE_ACCESSOR_MUTATOR(unsigned int, systemId, SystemId)
      DEFINE_ACCESSOR_MUTATOR(unsigned int, systemName, SystemName)
      DEFINE_ACCESSOR_MUTATOR(unsigned int, systemFunction, SystemFunction)
      DEFINE_ACCESSOR_MUTATOR(DtVector, mountLocation, MountLocation)

   protected:
      bool myPublish;
      unsigned int mySystemId;
      unsigned int mySystemName;
      unsigned int mySystemFunction;
      DtVector myMountLocation;
      DtActiveSonarBeams myBeamsList;
   };

   class DT_DLL_vrfStateData DtActiveSonarStateComponent : public DtFrameStateInterface
   {
   public:
      DEFINE_STATE_COMPONENT_TYPE(DtStateComponent::ActiveSonarStateComponent)

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

      UNDEFINED_RETURNVALUE_ACCESSOR(DtUUID, hostId)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(unsigned int, systemName, SystemName)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(unsigned int, systemFunction, SystemFunction)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(bool, publish, Publish)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(DtVector, mountLocation, MountLocation)
      UNDEFINED_METHOD(void, removeAllBeams)
      UNDEFINED_METHOD(void, removeBeam, unsigned short beamId)
      UNDEFINED_RETURNVALUE_ACCESSOR(unsigned int, numBeams)
      UNDEFINED_METHOD(DtActiveSonarBeamStateData*, addBeam)
      virtual const DtActiveSonarBeamStateData* beamByBeamIndex(unsigned short beamIndex) const { throw DtUnimplementedMethod("The const beamByBeamIndex() const method is unimplemented"); };
      virtual const DtActiveSonarBeamStateData* beamByBeamId(unsigned short beamId) const { throw DtUnimplementedMethod("The const beamByBeamId() const method is unimplemented"); };
      virtual DtActiveSonarBeamStateData* beamByBeamIndex(unsigned short beamIndex) { throw DtUnimplementedMethod("The beamByBeamIndex() method is unimplemented"); };
      virtual DtActiveSonarBeamStateData* beamByBeamId(unsigned short beamId) { throw DtUnimplementedMethod("The beamByBeamId() method is unimplemented"); };
      virtual const DtActiveSonarStateComponentData& frameState() const { throw DtUnimplementedMethod("The const DtActiveSonarStateComponentData& const frameState() method is unimplemented"); };
      UNDEFINED_RETURNREF_ACCESSORS(std::vector<DtActiveSonarBeamStateData>, beams)
   };

   class DT_DLL_vrfStateData DtActiveSonarStateComponentNextFrame : public DtActiveSonarStateComponent
   {
   public:
      DtActiveSonarStateComponentNextFrame(DtStateData* storage);

      virtual const DtActiveSonarStateComponentData& frameState() const override { return myData; };
      DtActiveSonarStateComponentData& frameState() { return myData; };
      virtual const std::vector<DtActiveSonarBeamStateData>& beams() const override;
      virtual std::vector<DtActiveSonarBeamStateData>& beams() override;

      virtual const DtUUID hostId() const override;

      virtual const unsigned int& systemName() const override;
      virtual void setSystemName(const unsigned int&) override;

      virtual const unsigned int& systemFunction() const override;
      virtual void setSystemFunction(const unsigned int&) override;

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

      virtual const DtVector& mountLocation() const override;
      virtual void setMountLocation(const DtVector&) override;

      virtual const unsigned int numBeams() const override;

      virtual const DtActiveSonarBeamStateData* beamByBeamIndex(unsigned short beamIndex) const override;
      virtual DtActiveSonarBeamStateData* beamByBeamIndex(unsigned short beamIndex) override;

      virtual const DtActiveSonarBeamStateData* beamByBeamId(unsigned short beamId) const override;
      virtual DtActiveSonarBeamStateData* beamByBeamId(unsigned short beamId) override;

      virtual void removeAllBeams() override;
      virtual void removeBeam(unsigned short beamId) override;
      virtual DtActiveSonarBeamStateData* addBeam() override;

      virtual void makeWritable() override {};

      virtual void makeReadOnly() override {};

   protected:
      unsigned short myNextBeamId;
      DtActiveSonarStateComponentData myData;
   };

   class DT_DLL_vrfStateData DtActiveSonarStateComponentCurrentFrame : public DtActiveSonarStateComponent
   {
   public:
      DtActiveSonarStateComponentCurrentFrame(DtStateData* storage);

      virtual const DtActiveSonarStateComponentData& frameState() const override { return myData; };
      virtual const std::vector<DtActiveSonarBeamStateData>& beams() const override;
      virtual const DtUUID hostId() const override;
      virtual const unsigned int& systemName() const override;
      virtual const unsigned int& systemFunction() const override;
      virtual const bool& publish() const override;
      virtual const DtVector& mountLocation() const override;
      virtual const unsigned int numBeams() const override;
      virtual const DtActiveSonarBeamStateData* beamByBeamIndex(unsigned short beamIndex) const override;
      virtual const DtActiveSonarBeamStateData* beamByBeamId(unsigned short beamId) const override;

   protected:
      friend class DtActiveSonarStateComponentImplementation;
      void advanceFrame(const DtActiveSonarStateComponentData& data)
      {
         myData = data;
      }

   protected:
      DtActiveSonarStateComponentData myData;
   };

   class DT_DLL_vrfStateData DtActiveSonarStateComponentImplementation : public DtDoubleBufferedStateComponent<DtActiveSonarStateComponent>
   {
   public:
      DtActiveSonarStateComponentImplementation(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<DtActiveSonarStateComponent>::aboutToBeDeleted();
         myCurrentFrameState.aboutToBeDeleted();
         myNextFrameState.aboutToBeDeleted();
      }

   protected:
      DtActiveSonarStateComponentCurrentFrame myCurrentFrameState;
      DtActiveSonarStateComponentNextFrame myNextFrameState;
   };

   typedef DtStateComponentCreator<DtActiveSonarStateComponentImplementation> DtActiveSonarStateComponentCreator;
}