iffStateComponent.h

Go to the documentation of this file.

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

#pragma once

#include "vrfStateData/vrfStateDataDefines.h"
#include <vrfutil/iffModeSettings.h>
#include "vrfStateData/doubleBufferedDataStorage.h"
#include "vrfStateData/stateComponent.h"
#include <vrfutil/rwUUID.h>

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

namespace makVrf
{
   struct DT_DLL_vrfStateData DtIffStateComponentData
   {
      DtIffStateComponentData()
      : myModeSettingsList("mode-settings")
      , myHostId(DtUUID::nullUUID())
      {
      }

      DtIffStateComponentData(const DtIffStateComponentData& orig)
      : myModeSettingsList(orig.myModeSettingsList)
      , myHostId(orig.myHostId)
      {
      }

      DtIffStateComponentData& operator=(const DtIffStateComponentData& rhs)
      {
         myModeSettingsList = rhs.myModeSettingsList;
         myHostId = rhs.myHostId;

         return *this;
      }

      bool hasModeSetting(int i) const
      {
         return myModeSettingsList.hasModeSetting(i);
      }

      const DtIffModeSetting* modeSetting(int i) const
      {
         return myModeSettingsList.modeSetting(i);
      }

      DtIffModeSetting* modeSetting(int i)
      {
         return myModeSettingsList.modeSetting(i);
      }

      std::vector<DtModeType> enabledModes() const
      {
         return myModeSettingsList.enabledModes();
      }

      DtIffModeSettingsList& modeSettings()
      {
         return myModeSettingsList;
      }

      const DtIffModeSettingsList& modeSettings() const
      {
         return myModeSettingsList;
      }

      DEFINE_ACCESSOR_MUTATOR(DtUUID, hostId, HostId)

   protected:
      DtIffModeSettingsList myModeSettingsList;
      DtUUID myHostId;
   };

   class DT_DLL_vrfStateData DtIffStateComponent : public DtFrameStateInterface
   {
   public:
      DEFINE_STATE_COMPONENT_TYPE(DtStateComponent::IffStateComponent)

      DtIffStateComponent(DtStateData* sd)
      : DtFrameStateInterface(sd)
      {
      }

      virtual const DtIffModeSetting* modeSetting(int) const { throw DtUnimplementedMethod("The const DtIffModeSetting* modeSetting(int) const method is unimplemented"); };
      virtual DtIffModeSetting* modeSetting(int) { throw DtUnimplementedMethod("The DtIffModeSetting* modeSetting(int) method is unimplemented"); };
      virtual void setEnabledModes(const std::vector<DtModeType>&) { throw DtUnimplementedMethod("The void setEnabledModes(const std::vector<DtModeType>&) method is unimplemented"); };
      virtual std::vector<DtModeType> enabledModes() const { throw DtUnimplementedMethod("The std::vector<DtModeType> enabledModes() const) method is unimplemented"); };
      virtual bool anyModeIsOn() const { throw DtUnimplementedMethod("The bool anyModeIsOn() const method is unimplemented"); };
      virtual bool modeIsOn(DtModeType) const { throw DtUnimplementedMethod("The bool modeIsOn(DtModeType) const method is unimplemented"); };
      virtual bool hasModeSetting(DtModeType) const { throw DtUnimplementedMethod("The bool hasModeSetting(DtModeType) const method is unimplemented"); };
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(DtUUID, hostId, HostId)
      UNDEFINED_RETURNREF_ACCESSOR(DtIffModeSettingsList, modeSettings)

      virtual bool canHaveModeCodeSet(DtModeType modeType) const
      {
         return CAN_HAVE_CODES_SET(modeType);
      }
   };

   class DT_DLL_vrfStateData DtIffStateComponentNextFrame : public DtIffStateComponent
   {
   public:
      DtIffStateComponentNextFrame(DtStateData* storage);

      virtual const DtIffModeSetting* modeSetting(int) const override;
      virtual DtIffModeSetting* modeSetting(int) override;

      virtual void setEnabledModes(const std::vector<DtModeType>&) override;
      virtual std::vector<DtModeType> enabledModes() const override;
      virtual bool anyModeIsOn() const override;
      virtual bool modeIsOn(DtModeType) const override;
      virtual bool hasModeSetting(DtModeType) const override;

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

      virtual const DtUUID& hostId() const override;
      virtual void setHostId(const DtUUID&) override;
      virtual const DtIffModeSettingsList& modeSettings() const override;

      virtual void makeWritable() override {};

      virtual void makeReadOnly() override {};

   protected:
      DtIffStateComponentData myData;
   };

   class DT_DLL_vrfStateData DtIffStateComponentCurrentFrame : public DtIffStateComponent
   {
   public:
      DtIffStateComponentCurrentFrame(DtStateData* storage);

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

      virtual bool anyModeIsOn() const override;
      virtual const DtIffModeSetting* modeSetting(int) const override;
      virtual std::vector<DtModeType> enabledModes() const override;
      virtual const DtUUID& hostId() const override;
      virtual const DtIffModeSettingsList& modeSettings() const override;
      virtual bool modeIsOn(DtModeType) const override;
      virtual bool hasModeSetting(DtModeType) const override;

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

   protected:
      DtIffStateComponentData myData;
   };

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

   protected:
      DtIffStateComponentCurrentFrame myCurrentFrameState;
      DtIffStateComponentNextFrame myNextFrameState;
   };

   typedef DtStateComponentCreator<DtIffStateComponentImplementation> DtIffStateComponentCreator;
}