org.squirrelframework.foundation.fsm.impl.DeferBoundActionBuilderImpl Maven / Gradle / Ivy

Go to download
package org.squirrelframework.foundation.fsm.impl;

import com.google.common.base.Function;
import com.google.common.collect.Lists;
import org.squirrelframework.foundation.component.SquirrelComponent;
import org.squirrelframework.foundation.fsm.*;
import org.squirrelframework.foundation.fsm.builder.*;

import java.util.Collections;
import java.util.List;

public class DeferBoundActionBuilderImpl, S, E, C>
        implements DeferBoundActionBuilder,
        DeferBoundActionFrom, DeferBoundActionTo,
        On, SquirrelComponent {

    private final List> deferBoundActionInfoList;

    private final ExecutionContext executionContext;

    private S from;

    private S to;

    private DeferBoundActionInfo deferBoundActionInfo;

    private Condition condition;

    DeferBoundActionBuilderImpl(
            List> deferBoundActionInfoList,
            ExecutionContext executionContext) {
        this.deferBoundActionInfoList = deferBoundActionInfoList;
        this.executionContext = executionContext;
    }

    @Override
    public void perform(Action action) {
        if (condition == null) {
            deferBoundActionInfo.setActions(Collections.singletonList(action));
        } else {
            deferBoundActionInfo.setActions(Collections
                    .singletonList(warpConditionalAction(action)));
        }
    }

    @Override
    public void perform(List> actions) {
        if (condition == null) {
            deferBoundActionInfo.setActions(actions);
        } else {
            List> wrapActions = Lists.transform(actions,
                    new Function, Action>() {
                        @Override
                        public Action apply(Action action) {
                            return warpConditionalAction(action);
                        }
                    });
            deferBoundActionInfo.setActions(wrapActions);
        }
    }

    @Override
    public void evalMvel(String expression) {
        Action action = FSM.newMvelAction(expression,
                executionContext);
        perform(action);
    }

    @Override
    public void callMethod(String methodName) {
        Action action = FSM.newMethodCallActionProxy(methodName,
                executionContext);
        perform(action);
    }

    @Override
    public On on(E event) {
        deferBoundActionInfo = new DeferBoundActionInfo(from, to,
                event);
        deferBoundActionInfoList.add(deferBoundActionInfo);
        return this;
    }

    @Override
    public On onAny() {
        deferBoundActionInfo = new DeferBoundActionInfo(from, to,
                null);
        deferBoundActionInfoList.add(deferBoundActionInfo);
        return this;
    }

    @Override
    public DeferBoundActionTo to(S to) {
        this.to = to;
        return this;
    }

    @Override
    public DeferBoundActionTo toAny() {
        return this;
    }

    @Override
    public DeferBoundActionFrom fromAny() {
        return this;
    }

    @Override
    public DeferBoundActionFrom from(S from) {
        this.from = from;
        return this;
    }

    @Override
    public When when(Condition condition) {
        this.condition = condition;
        return this;
    }

    @Override
    public When whenMvel(String expression) {
        condition = FSM.newMvelCondition(expression,
                executionContext.getScriptManager());
        return this;
    }

    private Action warpConditionalAction(Action action) {
        return new ActionWrapper(action) {
            @Override
            public void execute(S from, S to, E event, C context, T stateMachine) {
                if (Conditions.isSatified(condition, context)) {
                    super.execute(from, to, event, context, stateMachine);
                }
            }
        };
    }
}