Clone the state map so that the StateMachineBuilder can be reused

alibaba · Feb 19, 2023 · 54fe065 · 54fe065
1 parent 5b50a54
commit 54fe065
Show file tree

Hide file tree

Showing 6 changed files with 104 additions and 9 deletions.
diff --git a/...s/cola-component-statemachine/src/main/java/com/alibaba/cola/statemachine/Transition.java b/...s/cola-component-statemachine/src/main/java/com/alibaba/cola/statemachine/Transition.java
@@ -28,6 +28,8 @@ public interface Transition<S, E, C>{
 
     void setEvent(E event);
 
+    TransitionType getType();
+
     void setType(TransitionType type);
     /**
      * Gets the target state of this transition.

diff --git a/...emachine/src/main/java/com/alibaba/cola/statemachine/builder/StateMachineBuilderImpl.java b/...emachine/src/main/java/com/alibaba/cola/statemachine/builder/StateMachineBuilderImpl.java
@@ -21,7 +21,6 @@ public class StateMachineBuilderImpl<S, E, C> implements StateMachineBuilder<S,
      * StateMap is the same with stateMachine, as the core of state machine is holding reference to states.
      */
     private final Map<S, State<S, E, C>> stateMap = new ConcurrentHashMap<>();
-    private final StateMachineImpl<S, E, C> stateMachine = new StateMachineImpl<>(stateMap);
     private FailCallback<S, E, C> failCallback = new NumbFailCallback<>();
 
     @Override
@@ -46,6 +45,7 @@ public void setFailCallback(FailCallback<S, E, C> callback) {
 
     @Override
     public StateMachine<S, E, C> build(String machineId) {
+        StateMachineImpl<S, E, C> stateMachine = new StateMachineImpl<>(stateMap);
         stateMachine.setMachineId(machineId);
         stateMachine.setReady(true);
         stateMachine.setFailCallback(failCallback);

diff --git a/...-component-statemachine/src/main/java/com/alibaba/cola/statemachine/impl/StateHelper.java b/...-component-statemachine/src/main/java/com/alibaba/cola/statemachine/impl/StateHelper.java
@@ -1,7 +1,9 @@
 package com.alibaba.cola.statemachine.impl;
 
 import com.alibaba.cola.statemachine.State;
+import com.alibaba.cola.statemachine.Transition;
 
+import java.util.HashMap;
 import java.util.Map;
 
 /**
@@ -11,12 +13,26 @@
  * @date 2020-02-08 4:23 PM
  */
 public class StateHelper {
-    public static <S, E, C> State<S, E, C> getState(Map<S, State<S, E, C>> stateMap, S stateId){
-        State<S, E, C> state = stateMap.get(stateId);
-        if (state == null) {
-            state = new StateImpl<>(stateId);
-            stateMap.put(stateId, state);
-        }
-        return state;
+
+    private StateHelper() {
+    }
+
+    public static <S, E, C> State<S, E, C> getState(Map<S, State<S, E, C>> stateMap, S stateId) {
+        return stateMap.computeIfAbsent(stateId, StateImpl::new);
+    }
+
+    static <S, E, C> Map<S, State<S, E, C>> cloneStateMap(Map<S, State<S, E, C>> stateMap) {
+        Map<S, State<S, E, C>> cloneStateMap = new HashMap<>();
+        stateMap.forEach((stateId, state) -> {
+            State<S, E, C> cloneState = getState(cloneStateMap, stateId);
+            state.getAllTransitions().forEach(transition -> {
+                State<S, E, C> target = transition.getTarget();
+                Transition<S, E, C> cloneTransition = cloneState.addTransition(transition.getEvent(),
+                    getState(cloneStateMap, target.getId()), transition.getType());
+                cloneTransition.setCondition(transition.getCondition());
+                cloneTransition.setAction(transition.getAction());
+            });
+        });
+        return cloneStateMap;
     }
 }
diff --git a/...onent-statemachine/src/main/java/com/alibaba/cola/statemachine/impl/StateMachineImpl.java b/...onent-statemachine/src/main/java/com/alibaba/cola/statemachine/impl/StateMachineImpl.java
@@ -30,7 +30,7 @@ public class StateMachineImpl<S, E, C> implements StateMachine<S, E, C> {
     private FailCallback<S, E, C> failCallback;
 
     public StateMachineImpl(Map<S, State<S, E, C>> stateMap) {
-        this.stateMap = stateMap;
+        this.stateMap = StateHelper.cloneStateMap(stateMap);
     }
 
     @Override

diff --git a/...mponent-statemachine/src/main/java/com/alibaba/cola/statemachine/impl/TransitionImpl.java b/...mponent-statemachine/src/main/java/com/alibaba/cola/statemachine/impl/TransitionImpl.java
@@ -47,6 +47,11 @@ public void setEvent(E event) {
         this.event = event;
     }
 
+    @Override
+    public TransitionType getType() {
+        return type;
+    }
+
     @Override
     public void setType(TransitionType type) {
         this.type = type;

diff --git a/...a-component-statemachine/src/test/java/com/alibaba/cola/test/StateMachineBuilderTest.java b/...a-component-statemachine/src/test/java/com/alibaba/cola/test/StateMachineBuilderTest.java
@@ -0,0 +1,72 @@
+package com.alibaba.cola.test;
+
+import com.alibaba.cola.statemachine.Action;
+import com.alibaba.cola.statemachine.StateMachine;
+import com.alibaba.cola.statemachine.builder.StateMachineBuilder;
+import com.alibaba.cola.statemachine.builder.StateMachineBuilderFactory;
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * StateMachineBuilderTest
+ *
+ * @author luozhenyu
+ * @date 2023-02-20 01:37 AM
+ */
+public class StateMachineBuilderTest {
+
+    enum States {
+        STATE1,
+        STATE2,
+        STATE3
+    }
+
+    enum Events {
+        EVENT1,
+        EVENT2
+    }
+
+    static class Context {
+    }
+
+    @Test
+    public void testReuseBuilder() {
+        StateMachineBuilder<States, Events, Context> builder = StateMachineBuilderFactory.create();
+        builder.externalTransition()
+            .from(States.STATE1)
+            .to(States.STATE2)
+            .on(Events.EVENT1)
+            .perform(doAction());
+        StateMachine<States, Events, Context> stateMachine1 = builder.build("TestReuseBuilder1");
+        {
+            States target = stateMachine1.fireEvent(States.STATE1, Events.EVENT1, new Context());
+            Assert.assertEquals(States.STATE2, target);
+            target = stateMachine1.fireEvent(States.STATE1, Events.EVENT2, new Context());
+            Assert.assertEquals(States.STATE1, target);
+        }
+
+        builder.externalTransition()
+            .from(States.STATE1)
+            .to(States.STATE3)
+            .on(Events.EVENT2)
+            .perform(doAction());
+        StateMachine<States, Events, Context> stateMachine2 = builder.build("TestReuseBuilder2");
+        {
+            States target = stateMachine1.fireEvent(States.STATE1, Events.EVENT1, new Context());
+            Assert.assertEquals(States.STATE2, target);
+            target = stateMachine1.fireEvent(States.STATE1, Events.EVENT2, new Context());
+            Assert.assertEquals(States.STATE1, target);
+
+            target = stateMachine2.fireEvent(States.STATE1, Events.EVENT1, new Context());
+            Assert.assertEquals(States.STATE2, target);
+            target = stateMachine2.fireEvent(States.STATE1, Events.EVENT2, new Context());
+            Assert.assertEquals(States.STATE3, target);
+        }
+    }
+
+    private Action<States, Events, Context> doAction() {
+        return (from, to, event, context) -> {
+            System.out.println("from:" + from + " to:" + to + " on:" + event);
+        };
+    }
+}