RealtimeEffectState::Access Struct Reference

Main thread's interface to inter-thread communication of changes of settings. More...

Inheritance diagram for RealtimeEffectState::Access:

Collaboration diagram for RealtimeEffectState::Access:

Public Member Functions
	Access ()=default
	Access (RealtimeEffectState &state)
	~Access () override=default
const EffectSettings &	Get () override
void	Set (EffectSettings &&settings, std::unique_ptr< Message > pMessage) override
void	Set (std::unique_ptr< Message > pMessage) override
	Message-only overload of Set(). In future, this should be the only one. More...
void	Flush () override
	Make the last Set changes "persistent" in underlying storage. More...
bool	IsSameAs (const EffectSettingsAccess &other) const override
Public Member Functions inherited from EffectSettingsAccess
virtual	~EffectSettingsAccess ()
virtual const EffectSettings &	Get ()=0
virtual void	Set (EffectSettings &&settings, std::unique_ptr< Message > pMessage=nullptr)=0
virtual void	Set (std::unique_ptr< Message > pMessage=nullptr)=0
	Message-only overload of Set(). In future, this should be the only one. More...
virtual void	Flush ()=0
	Make the last Set changes "persistent" in underlying storage. More...
virtual bool	IsSameAs (const EffectSettingsAccess &other) const =0
template<typename Function >
void	ModifySettings (Function &&function)
	Do a correct read-modify-write of settings. More...

Public Attributes
std::weak_ptr< RealtimeEffectState >	mwState
	Store no state here but this weak pointer, so IsSameAs isn't lying. More...

Detailed Description

Main thread's interface to inter-thread communication of changes of settings.

Definition at line 191 of file RealtimeEffectState.cpp.

Constructor & Destructor Documentation

Access() [1/2]

RealtimeEffectState::Access::Access ( )

default

Access() [2/2]

RealtimeEffectState::Access::Access ( RealtimeEffectState &  state )

inlineexplicit

Definition at line 193 of file RealtimeEffectState.cpp.

      : mwState{ state.weak_from_this() }
   {
   }

~Access()

RealtimeEffectState::Access::~Access ( )

overridedefault

Member Function Documentation

Flush()

void RealtimeEffectState::Access::Flush ( )

inlineoverridevirtual

Make the last Set changes "persistent" in underlying storage.

Precondition

called on the main thread only

Implements EffectSettingsAccess.

Definition at line 277 of file RealtimeEffectState.cpp.

                         {
      if (auto pState = mwState.lock()) {
         if (auto pAccessState = pState->GetAccessState()) {
            assert(pAccessState->mMainThreadId == std::this_thread::get_id());
            
            if (pAccessState->mState.mInitialized)
            {
               std::unique_lock lk(pAccessState->mLockForCV);
               pAccessState->mCV.wait(lk,
                  [&] {
                        auto& lastSettings = pAccessState->mLastSettings;
                        pAccessState->MainRead();
                        return pAccessState->mCounter == lastSettings.counter;
                      }
               );
            }
 
            // Update what GetSettings() will return, during play and before
            // Finalize(), but after it is confirmed that any worker thread has
            // seen the values given to the last Set().  These values will also
            // be returned by Get().
            pState->mMainSettings.Set(pAccessState->mLastSettings);
         }
      }
   }

References mwState.

Get()

const EffectSettings & RealtimeEffectState::Access::Get ( )

inlineoverridevirtual

Implements EffectSettingsAccess.

Definition at line 200 of file RealtimeEffectState.cpp.

                                        {
      if (auto pState = mwState.lock()) {
         if (auto pAccessState = pState->GetAccessState()) {
            if (pAccessState->mState.mInitialized)
            {
               // try once
               assert(pAccessState->mState.mInitialized);
               auto& lastSettings = pAccessState->mLastSettings;
               // Assigns to mCounter
               pAccessState->MainRead();
            }
            else {
               // Not yet waiting on the other thread's progress
               // Not necessarily values yet in the state's Settings objects
            }
            return pAccessState->mLastSettings.settings;
         }
      }
      // Non-modal dialog may have outlived the RealtimeEffectState
      static EffectSettings empty;
      return empty;
   }

References mwState.

IsSameAs()

bool RealtimeEffectState::Access::IsSameAs ( const EffectSettingsAccess &  other ) const

inlineoverridevirtual

Returns

whether this and the other give access to the same settings

Implements EffectSettingsAccess.

Definition at line 302 of file RealtimeEffectState.cpp.

                                                                   {
      if (auto pOther = dynamic_cast<const Access*>(&other)) {
         auto &mine = mwState;
         auto &theirs = pOther->mwState;
         auto less = std::owner_less{};
         return !(less(mine, theirs) || less(theirs, mine));
      }
      return false;
   }

References mwState.

Set() [1/2]

void RealtimeEffectState::Access::Set ( EffectSettings &&  settings, std::unique_ptr< Message >  pMessage  )

inlineoverridevirtual

Implements EffectSettingsAccess.

Definition at line 222 of file RealtimeEffectState.cpp.

            {
      if (auto pState = mwState.lock()) {
         if (auto pAccessState = pState->GetAccessState()) {
            if (pMessage && !pAccessState->mState.mInitialized) {
               // Other thread isn't processing.
               // Let the instance consume the message directly.
               if (auto pInstance = pState->mwInstance.lock()) {
                  auto &stateSettings = pState->mMainSettings.settings;
                  stateSettings = std::move(settings);
                  EffectInstance::MessagePackage package{
                     stateSettings, pMessage.get()
                  };
                  pInstance->RealtimeProcessStart(package);
                  pInstance->RealtimeProcessEnd(stateSettings);
                  pAccessState->mLastSettings.settings = stateSettings;
                  return;
               }
            }
            auto &lastSettings = pAccessState->mLastSettings;
            // move to remember values here
            lastSettings.settings = std::move(settings);
            ++lastSettings.counter;
            // move a copy to there
            pAccessState->MainWrite(
               SettingsAndCounter{ lastSettings }, std::move(pMessage));
         }
      }
   }

References mwState, EffectInstance::MessagePackage::settings, and settings().

Here is the call graph for this function:

Set() [2/2]

void RealtimeEffectState::Access::Set ( std::unique_ptr< Message >  pMessage )

inlineoverridevirtual

Message-only overload of Set(). In future, this should be the only one.

Implements EffectSettingsAccess.

Definition at line 251 of file RealtimeEffectState.cpp.

            {
      if (auto pState = mwState.lock()) {
         if (auto pAccessState = pState->GetAccessState()) {
            if (pMessage && !pAccessState->mState.mInitialized) {
               // Other thread isn't processing.
               // Let the instance consume the message directly.
               if (auto pInstance = pState->mwInstance.lock()) {
                  auto &stateSettings = pState->mMainSettings.settings;
                  EffectInstance::MessagePackage package{
                     stateSettings, pMessage.get()
                  };
                  pInstance->RealtimeProcessStart(package);
                  pInstance->RealtimeProcessEnd(stateSettings);
                  // Don't need to update pAccessState->mLastSettings
                  return;
               }
            }
            auto &lastSettings = pAccessState->mLastSettings;
            // Don't update settings, but do count
            ++lastSettings.counter;
            pAccessState->MainWrite(
               lastSettings.counter, std::move(pMessage));
         }
      }
   }

References mwState.

Member Data Documentation

mwState

std::weak_ptr<RealtimeEffectState> RealtimeEffectState::Access::mwState

Store no state here but this weak pointer, so IsSameAs isn't lying.

Definition at line 312 of file RealtimeEffectState.cpp.

Referenced by Flush(), Get(), IsSameAs(), and Set().

---

The documentation for this struct was generated from the following file:

• RealtimeEffectState.cpp