state-recorder.hpp

Go to the documentation of this file.

/*
  STATE-RECORDER.hpp  -  map based recording of presentation state

   Copyright (C)
     2016,            Hermann Vosseler <Ichthyostega@web.de>

  **Lumiera** is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License as published by the
  Free Software Foundation; either version 2 of the License, or (at your
  option) any later version. See the file COPYING for further details.

*/


#ifndef STAGE_CTRL_STATE_RECORDER_H
#define STAGE_CTRL_STATE_RECORDER_H


#include "lib/error.hpp"
#include "lib/idi/entry-id.hpp"
#include "lib/diff/gen-node.hpp"
#include "stage/ctrl/bus-term.hpp"
#include "stage/ctrl/state-manager.hpp"
#include "stage/ctrl/state-map-grouping-storage.hpp"
#include "include/ui-protocol.hpp"

#include <string>


namespace stage {
namespace ctrl {
  
  using stage::ctrl::BusTerm;
  using lib::diff::GenNode;
  using lib::diff::Ref;
  using std::string;
  
  
  
  
  class StateRecorder
    : public StateManager
    {
      using Storage = StateMapGroupingStorage;
      using Record  = Storage::Record const&;
      
      BusTerm& uiBus_;
      Storage  storage_;
      
      
      
      /* === PresentationStateManager interface === */
      
      virtual StateMark
      currentState (ID uiElm, string propertyKey)  const override
        {
          return storage_.retrieve (uiElm, propertyKey);
        }
      
      
      virtual void
      replayState (ID uiElm, string propertyKey)  override
        {
          StateMark state = storage_.retrieve (uiElm, propertyKey);
          if (state != Ref::NO)
            uiBus_.mark (uiElm, state);
        }
      
      
      virtual void
      replayAllState()  override
        {
          for (Record entry : storage_)
            replayPropertiesOf (entry);
        }
      
      
      virtual void
      replayAllState (string propertyKey)  override
        {
          for (Record entry : storage_)
            {
              StateMark state = Storage::getState (entry, propertyKey);
              if (state != Ref::NO)
                uiBus_.mark (Storage::getID (entry), state);
            }
        }
      
      
      virtual void
      replayAllProperties (ID uiElm)  override
        {
          auto entry = storage_.find (uiElm);
          if (entry != storage_.end())
            replayPropertiesOf (*entry);
        }
      
      
      virtual void
      clearState()  override
        {
          storage_.clear();
        }
      
      
    public:
      StateRecorder (BusTerm& busConnection)
        : uiBus_(busConnection)
        , storage_()
        { }
      
      void
      recordState (ID uiElm, StateMark stateMark)
        {
          if (MARK_reset == stateMark.idi.getSym())
            storage_.clearState (uiElm);
          else
          if (MARK_clearErr == stateMark.idi.getSym())
            storage_.clearProperty (uiElm, string{MARK_Error});
          else
          if (MARK_clearMsg == stateMark.idi.getSym())
            storage_.clearProperty (uiElm, string{MARK_Message});
          else
            storage_.record (uiElm, stateMark);
        }
      
    private:
      void
      replayPropertiesOf (Record entry)
        {
          ID uiElm = Storage::getID (entry);
          for (auto& stateMark : Storage::getState (entry))
            uiBus_.mark (uiElm, stateMark);
        }
    };
  
  
  
}} // namespace stage::ctrl
#endif /*STAGE_CTRL_STATE_RECORDER_H*/