OngoingCommandDispatcher.hpp

#pragma once
#include <score/command/Dispatchers/ICommandDispatcher.hpp>
#include <score/command/Dispatchers/SendStrategy.hpp>
#include <score/plugins/StringFactoryKey.hpp>
#include <score/tools/Debug.hpp>
#include <score/tools/SafeCast.hpp>
 
#include <memory>
 
class SCORE_LIB_BASE_EXPORT OngoingCommandDispatcher final : public ICommandDispatcher
{
public:
  explicit OngoingCommandDispatcher(const score::CommandStackFacade& stack);
  ~OngoingCommandDispatcher();
 
  // In Document.cpp
  void watch(const QObject* obj);
  void unwatch(const QObject* obj);
 
  template <typename TheCommand, typename Watched, typename... Args>
  void submit(Watched&& watched, Args&&... args)
  {
    using decayed = std::remove_cvref_t<Watched>;
    if constexpr(std::is_pointer_v<decayed>)
    {
      static_assert(std::is_base_of_v<QObject, std::remove_cvref_t<decltype(*watched)>>);
      watch(watched);
    }
    else
    {
      static_assert(std::is_base_of_v<QObject, decayed>);
      watch(&watched);
    }
 
    if(!m_cmd)
    {
      stack().disableActions();
      m_cmd = std::make_unique<TheCommand>(watched, std::forward<Args>(args)...);
      m_cmd->redo(stack().context());
    }
    else
    {
      if(m_cmd->key() != TheCommand::static_key())
      {
        throw std::runtime_error(
            "Ongoing command mismatch: current command " + m_cmd->key().toString()
            + " does not match new command " + TheCommand{}.key().toString());
      }
 
      safe_cast<TheCommand*>(m_cmd.get())->update(watched, std::forward<Args>(args)...);
      m_cmd->redo(stack().context());
    }
  }
 
  void commit();
 
  void rollback();
  void rollback_without_undo();
 
private:
  std::unique_ptr<score::Command> m_cmd;
  const QObject* m_watched{};
};