Java循环算法

Question

鉴于此：

 public enum States implements StateEnum {
    SHOWING_WELCOME,
    WAITING_FOR_PIN,
    CHECKING_PIN,
    RETURNING_CARD,
    SHOWING_MAIN_MENU,
    SHOWING_PIN_INVALID,
    SHOWING_CARD_LOCKED,
    SHOWING_BALANCE,
    SHOWING_WITHDRAW_MENU,
    SHOWING_TAKE_CASH,
    TERMINATED
}

public enum Events implements EventEnum {
    cardPresent,
    cardExtracted,
    pinProvided,
    pinValid,
    pinInvalid,
    tryAgain,
    noMoreTries,
    cancel,
    confirm,
    menuShowBalance,
    menuWithdrawCash,
    menuExit,
    switchOff,
    cashExtracted
}

我想知道是否有一种方法可以创建一种算法来自动执行此操作：

from(SHOWING_WELCOME).transit(
    on(cardPresent).to(WAITING_FOR_PIN).transit(
        on(pinProvided).to(CHECKING_PIN).transit(
            on(pinValid).to(SHOWING_MAIN_MENU).transit(
                on(menuShowBalance).to(SHOWING_BALANCE).transit(
                    on(cancel).to(SHOWING_MAIN_MENU)
                ),
                on(menuWithdrawCash).to(SHOWING_WITHDRAW_MENU).transit(
                    on(cancel).to(SHOWING_MAIN_MENU),
                    on(confirm).to(SHOWING_TAKE_CASH).transit(
                        on(cashExtracted).to(SHOWING_MAIN_MENU)
                    )
                ),
                on(menuExit).to(RETURNING_CARD)
            ),
            on(pinInvalid).to(SHOWING_PIN_INVALID).transit(
                on(tryAgain).to(WAITING_FOR_PIN),
                on(noMoreTries).to(SHOWING_CARD_LOCKED).transit(
                    on(confirm).to(SHOWING_WELCOME)
                ),
                on(cancel).to(RETURNING_CARD)
            )
        ),
        on(cancel).to(RETURNING_CARD).transit(
            on(cardExtracted).to(SHOWING_WELCOME)
        )
    ),
    on(switchOff).finish(TERMINATED)
);

我正在考虑创建两个列表（事件和状态）以这种方式使用值：

on(Events.valueOf(EventsList.get(0))).to(States.valueOf(EventsList.get(0)).trans it(

...

但是，我不确定哪种是迭代模式。

非常感谢任何建议。

谢谢

////////////////////////更新/////////////// ////////////////

基于@Dukeling 建议的解决方案

  public  Map<States, List<Events>> transitMap;
   public Map<Events, States> toMap;

void transitCaller(States initialState, Events events)
  {
  transitCallerHelper(on(events).to(initialState),       
  transitMap.get(initialState));
  }

Transition  transitCallerHelper(Transition toResult, List<Events> events)
 {
   List<Transition> transitCalls = new ArrayList<Transition>();
   for (Events e: events)
    {
      States s = toMap.get(e);
      if (isFinishEvent(e)) // or isFinishState(s)
      transitCalls.add(on(e).finish(s));
   else
    {
      events = (s != null ? transitMap.get(s) : null);
      if (events == null)
         transitCalls.add(on(e).to(s));
     else
         transitCalls.add(transitCallerHelper(on(e).to(s), events));
    }
  }
 return toResult.transit(transitCalls.get(0));

}

Answer 1

我最初的想法是使用映射来定义您的 transit 和 to 映射：

Map<States, List<Events>> transitMap;
Map<Events, States> toMap;

您可以将这些映射存储在一个文本文件中，您可以从中构建上述映射。

从这里您可以创建一个调用您的方法的递归方法：
（因为from返回了不同的类型，所以有点乱）

void transitCaller(State initialState)
{
   from(initialState).transit(getTransitArgs(transitMap.get(ini‌​tialState)));
}

Transition transitCallerHelper(Transition toResult, List<Events> events)
{
   return toResult.transit(getTransitArgs(events));
}

Transition[] getTransitArgs(List<Events> events)
{
   List<Transition> transitArgs = new ArrayList<Transition>();
   for (Events e: events)
   {
      States s = toMap.get(e);
      if (isFinishEvent(e)) // or isFinishState(s)
         transitArgs.add(on(e).finish(s));
      else
      {
         List<Events> events = (s != null ? transitMap.get(s) : null);
         if (events == null)
            transitArgs.add(on(e).to(s));
         else
            transitArgs.add(transitCallerHelper(on(e).to(s), events));
      }
   }
   return transitArgs.toArray(new Transaction[0]);
}

（酌情添加错误检查）

---

旁注：您可能希望将 States 和 Events 设为单数而不是复数，因为枚举中的每个值仅分别定义一个状态和事件。