MultiOngoingCommandDispatcher.hpp

#pragma once
#include <score/command/Dispatchers/ICommandDispatcher.hpp>
#include <score/command/Dispatchers/SendStrategy.hpp>
#include <score/selection/SelectionStack.hpp>
 
// Creates commands on a list and keep updating the latest command
// up to the next new command.
namespace RollbackStrategy
{
struct Simple
{
  static void
  rollback(const score::DocumentContext& ctx, const std::vector<score::Command*>& cmds)
  {
    if(cmds.empty())
      return;
 
    for(int i = cmds.size() - 1; i >= 0; --i)
    {
      cmds[i]->undo(ctx);
    }
  }
};
}
 
class MultiOngoingCommandDispatcher final : public ICommandDispatcher
{
public:
  MultiOngoingCommandDispatcher(const score::CommandStackFacade& stack)
      : ICommandDispatcher{stack}
  {
  }
 
  ~MultiOngoingCommandDispatcher() { cleanup(); }
 
  void submit(score::Command* cmd)
  {
    stack().disableActions();
    {
      score::SelectionStack::Batch b{stack().selectionStack()};
      cmd->redo(stack().context());
    }
    m_cmds.push_back(cmd);
  }
 
  void submitQuiet(score::Command* cmd)
  {
    stack().disableActions();
    m_cmds.push_back(cmd);
  }
 
  template <typename TheCommand, typename... Args>
  void submit(Args&&... args)
  {
    score::SelectionStack::Batch b{stack().selectionStack()};
    if(m_cmds.empty())
    {
      stack().disableActions();
      auto cmd = new TheCommand(std::forward<Args>(args)...);
      cmd->redo(stack().context());
      m_cmds.push_back(cmd);
    }
    else
    {
      score::Command* last = m_cmds.back();
      if(last->key() == TheCommand::static_key())
      {
        auto cmd = safe_cast<TheCommand*>(last);
        if constexpr(requires { bool(cmd->compatible(std::forward<Args>(args)...)); })
        {
          if(cmd->compatible(std::forward<Args>(args)...))
          {
            cmd->update(std::forward<Args>(args)...);
            cmd->redo(stack().context());
          }
          else
          {
            auto cmd = new TheCommand(std::forward<Args>(args)...);
            cmd->redo(stack().context());
            m_cmds.push_back(cmd);
          }
        }
        else
        {
          cmd->update(std::forward<Args>(args)...);
          cmd->redo(stack().context());
        }
      }
      else
      {
        auto cmd = new TheCommand(std::forward<Args>(args)...);
        cmd->redo(stack().context());
        m_cmds.push_back(cmd);
      }
    }
  }
 
  // Give it something that behaves like AggregateCommand
  template <typename CommitCommand>
  void commit()
  {
    if(!m_cmds.empty())
    {
      auto theCmd = new CommitCommand;
      for(auto& cmd : m_cmds)
      {
        theCmd->addCommand(cmd);
      }
 
      SendStrategy::Quiet::send(stack(), theCmd);
      m_cmds.clear();
 
      stack().enableActions();
    }
  }
 
  template <typename RollbackStrategy = RollbackStrategy::Simple>
  void rollback()
  {
    {
      score::SelectionStack::Batch b{stack().selectionStack()};
      RollbackStrategy::rollback(stack().context(), m_cmds);
    }
 
    cleanup();
    m_cmds.clear();
 
    stack().enableActions();
  }
 
private:
  void cleanup()
  {
    std::for_each(m_cmds.rbegin(), m_cmds.rend(), [](auto cmd) { delete cmd; });
  }
 
  std::vector<score::Command*> m_cmds;
};