statePropertiesStateComponent.h

Go to the documentation of this file.

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

#pragma once

#include "vrfStateData/doubleBufferedDataStorage.h"
#include "vrfStateData/stateComponent.h"
#include "readerWriter/rwProperties.h"
#include "readerWriter/readerWriterRegistryData.h"
#include <vrfutil/extendedDataKeywords.h>
#include <vrfutil/rwUUID.h>
#include "vrfutil/echelonId.h"
#include <vlutil/vlTime.h>
#include "legionDataStore/writeStateInstance.h"
#include "legionDataStore/readStateInstance.h"
#include "legionDataStore/view.h"
#include "vrfOM/sets/readStatePropertiesRepository.hpp"
#include "vrfOM/sets/writeStatePropertiesRepository.hpp"

namespace makVrf
{
   class DtStatePropertiesStateComponentDataStore;

   struct DT_DLL_vrfStateData DtStatePropertiesStateComponentData
   {
      DtStatePropertiesStateComponentData()
      : myStateProperties("state-properties")
      , myStatePropertiesUpdated(false)
      , myParameterProperties(new DtRwProperties("parameter-properties"))
      {
      }

      DtStatePropertiesStateComponentData(const DtStatePropertiesStateComponentData& orig)
      : myStateProperties(orig.myStateProperties)
      , myStatePropertiesUpdated(orig.myStatePropertiesUpdated)
      , myParameterProperties(orig.myParameterProperties)
      {
      }

      DtStatePropertiesStateComponentData& operator=(const DtStatePropertiesStateComponentData& rhs)
      {
         myParameterProperties = rhs.myParameterProperties;
         myStateProperties = rhs.myStateProperties;
         myStatePropertiesUpdated = true;

         return *this;
      }

      void clearStatePropertiesUpdated()
      {
         myStatePropertiesUpdated = false;
      }

      void statePropertiesWereUpdated()
      {
         myStatePropertiesUpdated = true;
      }

      void copyOnlPublishedStateProperties(const DtRwProperties& other)
      {
         myStateProperties.clearVariables();
         std::vector<DtReaderWriterRegistryData*>::const_iterator itr = other.registry().registryData().begin();
         std::vector<DtReaderWriterRegistryData*>::const_iterator end = other.registry().registryData().end();
         for(; itr != end; ++itr)
         {
            const DtPropertyInterface* iface = dynamic_cast<const DtPropertyInterface*>((*itr)->readerWriter());

            if (!iface || iface->isPublished())
            {
               const DtReaderWriter* otherRw = (*itr)->readerWriter();
               DtReaderWriter::factory()->cloneReaderWriter(DtString(otherRw->name()),
                  otherRw, &myStateProperties.registry());
            }
         }
      }

      const DtRwProperties& parameterProperties() const { return *(myParameterProperties.get()); };
      DtRwProperties& parameterProperties() { return *(myParameterProperties.get()); };

      DEFINE_REF_ACCESSORS(DtRwProperties, stateProperties, StateProperties)
      DEFINE_ACCESSOR_MUTATOR(bool, statePropertiesUpdated, StatePropertiesUpdated)

   protected:
      DtRwProperties myStateProperties;
      bool myStatePropertiesUpdated;
      std::shared_ptr<DtRwProperties> myParameterProperties;
   };

   class DT_DLL_vrfStateData DtStatePropertiesStateComponent : public DtFrameStateInterface
   {
   public:
      typedef std::map<DtString, DtString> ExtendedData;
      DEFINE_STATE_COMPONENT_TYPE(DtStateComponent::StatePropertiesStateComponent)

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

      UNDEFINED_RETURNREF_ACCESSORS(DtRwProperties, stateProperties)
      UNDEFINED_RETURNREF_ACCESSOR(bool, statePropertiesUpdated)
      UNDEFINED_RETURNREF_ACCESSORS(DtRwProperties, parameterProperties)
      UNDEFINED_METHOD(void, setParameterProperties, const DtRwProperties&)

      virtual void setStateProperties(const DtRwProperties&) { throw DtUnimplementedMethod("setStateProperties(const DtRwProperties& key) is not implemented for this class"); };
   };

   class DT_DLL_vrfStateData DtStatePropertiesStateComponentNextFrame : public DtStatePropertiesStateComponent
   {
   public:
      DtStatePropertiesStateComponentNextFrame(DtStateData*);
      virtual ~DtStatePropertiesStateComponentNextFrame() override;

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

      virtual const DtRwProperties& stateProperties() const override;
      virtual DtRwProperties& stateProperties() override;
      virtual void setStateProperties(const DtRwProperties&) override;

      virtual const bool& statePropertiesUpdated() const override;

      virtual const DtRwProperties& parameterProperties() const override;
      virtual DtRwProperties& parameterProperties() override;
      virtual void setParameterProperties(const DtRwProperties&) override;
      virtual bool isModified() const override;

      virtual void makeWritable() override;

      virtual void makeReadOnly() override;

      bool statePropertiesModified() const
      {
         return myStatePropertiesModified;
      }

      void clearStatePropertiesModified()
      {
         myStatePropertiesModified = false;
      }

      void setPublishingOnLegionNetwork(bool);

      void updateLegionNetwork(double newTime);

      double lastTimeStatePropertiesUpdated() const
      {
         return myLastTimeStatePropertiesUpdated;
      }

      void markUpdated();

   protected:
      VRF::WriteStatePropertiesRepository myWriteStatePropertiesRepository;
      bool myStatePropertiesModified;
      bool myPublishOnLegionNetwork;
      std::map<std::string, Legion::InstanceHandle> myLegionStateProperties;
      DtStatePropertiesStateComponentData myData;
      double myLastTimeStatePropertiesUpdated = 0.;
   };

   class DT_DLL_vrfStateData DtStatePropertiesStateComponentCurrentFrame : public DtStatePropertiesStateComponent
   {
   public:
      DtStatePropertiesStateComponentCurrentFrame(DtStateData*);
      virtual ~DtStatePropertiesStateComponentCurrentFrame() override;

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

      virtual const DtRwProperties& stateProperties() const override;
      virtual const bool& statePropertiesUpdated() const override;
      virtual const DtRwProperties& parameterProperties() const override;

      virtual bool findReadComponent();
      virtual bool readComponentValid() const;

      void setPublishingOnLegionNetwork(bool);

      bool statePropertiesModifiedByLegion() const
      {
         return myStatePropertiesModifiedByLegion;
      }

      void clearStatePropertiesModifiedByLegion()
      {
         myStatePropertiesModifiedByLegion = false;
      }

   protected:
      friend class DtStatePropertiesStateComponentImplementation;
      void handleStatePropertiesUpdated();

   protected:
      friend class DtStatePropertiesStateComponentImplementation;
      bool updateOnlyModifiedStatePropertiesSince(const DtRwProperties& source, double since);
      void advanceFrame(const DtStatePropertiesStateComponentData& data)
      {
         myData.parameterProperties() = data.parameterProperties();
      }

   protected:
      VRF::ReadStatePropertiesRepository myReadStatePropertiesRepository;
      unsigned int myCallbackHandle;
      bool myPublishOnLegionNetwork;
      std::map<std::string, double> myLastTimeUpdated;
      bool myStatePropertiesModifiedByLegion;
      DtStatePropertiesStateComponentData myData;
   };

   class DT_DLL_vrfStateData DtStatePropertiesStateComponentImplementation : public DtDoubleBufferedStateComponent<DtStatePropertiesStateComponent>
   {
   public:
      DtStatePropertiesStateComponentImplementation(DtStateData* sd);
      virtual ~DtStatePropertiesStateComponentImplementation() override;

      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;

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

      virtual bool forceAdvance() override;

      virtual void initializeFromParameters(const DtVrfObjectParameters* params) override;

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

      virtual void setPublishingOnLegionNetwork(bool) override;

   protected:
      DtStatePropertiesStateComponentCurrentFrame myCurrentFrameState;
      DtStatePropertiesStateComponentNextFrame myNextFrameState;
      bool myFoundComponent;
   };

   typedef DtStateComponentCreator<DtStatePropertiesStateComponentImplementation> DtStatePropertiesStateComponentCreator;
}