Action.cpp

#include "Action.hpp"
#include "Transition.hpp"

Action::Action(Action::Type type, std::function<void(Config & config, Action & action)> apply, std::function<void(Config & config, Action & action)> undo, std::function<bool(const Config & config, const Action & action)> appliable)
{
  this->type = type;
  this->apply = apply;
  this->undo = undo;
  this->appliable = appliable;
}

Action Action::addLinesIfNeeded(int nbLines)
{
  auto apply = [nbLines](Config & config, Action &)
  {
    while (!config.has(0, config.getWordIndex()+nbLines, 0))
      config.addLines(1);
  };

  auto undo = [](Config &, Action &)
  {
  };

  auto appliable = [](const Config &, const Action &)
  {
    return true;
  };

  return {Type::AddLines, apply, undo, appliable};
}

Action Action::moveWordIndex(int movement)
{
  auto apply = [movement](Config & config, Action &)
  {
    config.moveWordIndex(movement);
  };

  auto undo = [movement](Config & config, Action &)
  {
    config.moveWordIndex(-movement);
  };

  auto appliable = [movement](const Config & config, const Action &)
  {
    return config.canMoveWordIndex(movement);
  };

  return {Type::MoveWord, apply, undo, appliable};
}

Action Action::setMultiwordIds(int multiwordSize)
{
  auto apply = [multiwordSize](Config & config, Action & a)
  {
    addHypothesisRelative(Config::idColName, Config::Object::Buffer, 0, fmt::format("{}-{}", config.getCurrentWordId()+1, config.getCurrentWordId()+multiwordSize)).apply(config, a);
    for (int i = 0; i < multiwordSize; i++)
    {
      addHypothesisRelative(Config::idColName, Config::Object::Buffer, i+1, fmt::format("{}", config.getCurrentWordId()+1+i)).apply(config, a);
      addHypothesisRelative(Config::isMultiColName, Config::Object::Buffer, i+1, Config::EOSSymbol1).apply(config, a);
    }
  };

  auto undo = [multiwordSize](Config & config, Action &)
  {
    config.getLastNotEmpty(Config::idColName, config.getWordIndex()) = "";
    for (int i = 0; i < multiwordSize; i++)
      config.getLastNotEmpty(Config::idColName, config.getWordIndex()+1+i) = "";
  };

  auto appliable = [](const Config &, const Action &)
  {
    return true;
  };

  return {Type::Write, apply, undo, appliable};
}

Action Action::consumeCharacterIndex(const util::utf8string & consumed)
{
  auto apply = [consumed](Config & config, Action &)
  {
    config.moveCharacterIndex(consumed.size());
  };

  auto undo = [consumed](Config & config, Action &)
  {
    config.moveCharacterIndex(-consumed.size());
  };

  auto appliable = [consumed](const Config & config, const Action &)
  {
    if (!config.canMoveCharacterIndex(consumed.size()))
      return false;

    for (unsigned int i = 0; i < consumed.size(); i++)
    {
      if (!config.hasCharacter(config.getCharacterIndex()+i))
        return false;
      const util::utf8char & letter = config.getLetter(config.getCharacterIndex()+i);
      const util::utf8char & consumedLetter = consumed[i];
      if (util::lower(letter) != util::lower(consumedLetter))
        return false;
    }

    return true;
  };

  return {Type::MoveWord, apply, undo, appliable};
}

Action Action::moveCharacterIndex(int movement)
{
  auto apply = [movement](Config & config, Action &)
  {
    config.moveCharacterIndex(movement);
  };

  auto undo = [movement](Config & config, Action &)
  {
    config.moveCharacterIndex(-movement);
  };

  auto appliable = [movement](const Config & config, const Action &)
  {
    return config.canMoveCharacterIndex(movement);
  };

  return {Type::MoveChar, apply, undo, appliable};
}

Action Action::addHypothesis(const std::string & colName, std::size_t lineIndex, const std::string & hypothesis)
{
  auto apply = [colName, lineIndex, hypothesis](Config & config, Action &)
  {
    config.getFirstEmpty(colName, lineIndex) = hypothesis;
  };

  auto undo = [colName, lineIndex](Config & config, Action &)
  {
    config.getLastNotEmpty(colName, lineIndex) = "";
  };

  auto appliable = [](const Config &, const Action &)
  {
    return true;
  };

  return {Type::Write, apply, undo, appliable}; 
}

Action Action::addToHypothesis(const std::string & colName, std::size_t lineIndex, const std::string & addition)
{
  auto apply = [colName, lineIndex, addition](Config & config, Action &)
  {
    auto currentElems = util::split(std::string(config.getLastNotEmptyHypConst(colName, lineIndex)), '|');
    currentElems.emplace_back(addition);

    std::sort(currentElems.begin(), currentElems.end());

    config.getLastNotEmptyHyp(colName, lineIndex) = util::join("|", currentElems);
  };

  auto undo = [colName, lineIndex, addition](Config & config, Action &)
  {
    auto curElems = util::split(std::string(config.getLastNotEmptyHypConst(colName, lineIndex)), '|');
    std::vector<std::string> newElems;
    for (auto & elem : curElems)
      if (elem != addition)
        newElems.emplace_back(elem);

    config.getLastNotEmptyHyp(colName, lineIndex) = util::join("|", newElems);
  };

  auto appliable = [colName, lineIndex, addition](const Config & config, const Action &)
  {
    if (!config.has(colName, lineIndex, 0))
      return false;
    auto & current = config.getLastNotEmptyHypConst(colName, lineIndex);
    auto splited = util::split(std::string(current), '|');
    for (auto & part : splited)
      if (part == addition)
        return false;
    return true;
  };

  return {Type::Write, apply, undo, appliable}; 
}

Action Action::sumToHypothesis(const std::string & colName, std::size_t lineIndex, float addition, bool mean)
{
  auto apply = [colName, lineIndex, addition, mean](Config & config, Action &)
  {
    std::string totalStr = std::string(config.getLastNotEmptyHypConst(colName, lineIndex));

    if (totalStr.empty() || totalStr == "_")
      totalStr = fmt::format("{}={}|{}", std::string(config.getState()), 0.0, 0);

    auto byStates = util::split(totalStr, ',');
    int index = -1;