endTransition() {
+ if (stateBuilder == null) {
+ throw new IllegalStateException("Use '.end()' instead");
+ }
+ end();
+ return stateBuilder;
+ }
+
}
diff --git a/src/main/java/me/bvn13/fsm/Fsm.java b/src/main/java/me/bvn13/fsm/Fsm.java
index f724986..5f694e3 100644
--- a/src/main/java/me/bvn13/fsm/Fsm.java
+++ b/src/main/java/me/bvn13/fsm/Fsm.java
@@ -52,6 +52,8 @@ import static java.lang.String.format;
* Simple way to use it - to construct an inherited class specified with the type of events to be processed
* during transitions.
*
+ * since 2.1.5
+ *
*
* {@code
* SimpleFsm simpleFsm = Fsm
@@ -76,6 +78,31 @@ import static java.lang.String.format;
* }
*
*
+ * or since 2.2.1
+ *
+ *
+ * {@code
+ * SimpleFsm simpleFsm = Fsm
+ * ., String>from(SimpleFsm::new)
+ * .withStates()
+ * .from("init")
+ * .withBeforeHandler(fsm -> initBefore.set(true))
+ * .withAfterHandler(fsm -> initAfter.set(true))
+ * .withProcessor((fsm, event) -> initProcess.set(true))
+ * .withTransition()
+ * .to("finish")
+ * .checking((fsm, event) -> true)
+ * .endTransition()
+ * .end()
+ * .finish("finish")
+ * .withBeforeHandler(fsm -> finishBefore.set(true))
+ * .withAfterHandler(fsm -> finishAfter.set(true))
+ * .withProcessor((fsm, event) -> finishProcess.set(true))
+ * .end()
+ * .create();
+ * }
+ *
+ *
*
* Otherwise you are able to use Old syntax:
*
diff --git a/src/main/java/me/bvn13/fsm/StateBuilder.java b/src/main/java/me/bvn13/fsm/StateBuilder.java
index 5af28a8..f6bb0e4 100644
--- a/src/main/java/me/bvn13/fsm/StateBuilder.java
+++ b/src/main/java/me/bvn13/fsm/StateBuilder.java
@@ -56,4 +56,8 @@ public class StateBuilder {
return this;
}
+ public ConditionBuilder withTransition() {
+ return new ConditionBuilder<>(fsmBuilder, this, name);
+ }
+
}
diff --git a/src/test/java/me/bvn13/fsm/tests/FsmTest.java b/src/test/java/me/bvn13/fsm/tests/FsmTest.java
index a02e733..fbee2b3 100644
--- a/src/test/java/me/bvn13/fsm/tests/FsmTest.java
+++ b/src/test/java/me/bvn13/fsm/tests/FsmTest.java
@@ -262,6 +262,78 @@ public class FsmTest {
}
+ @Test
+ public void newSyntaxOfTransitions() {
+
+ Counter initCounter = new Counter();
+ Counter firstIntermediateCounter = new Counter();
+ Counter secondIntermediateCounter = new Counter();
+ Counter finishCounter = new Counter();
+
+ // @formatter:off
+
+ SimpleFsm simpleFsm = Fsm
+ ., String>from(SimpleFsm::new)
+ .withStates()
+ .from("init")
+ .withBeforeHandler(fsm -> initCounter.before.incrementAndGet())
+ .withProcessor((fsm, event) -> initCounter.process.incrementAndGet())
+ .withAfterHandler(fsm -> initCounter.after.incrementAndGet())
+ .withTransition()
+ .to("intermediate-1")
+ .checking((fsm, event) -> true)
+ .endTransition()
+ .end()
+ .state("intermediate-1")
+ .withBeforeHandler(fsm -> firstIntermediateCounter.before.incrementAndGet())
+ .withProcessor((fsm, event) -> firstIntermediateCounter.process.incrementAndGet())
+ .withAfterHandler(fsm -> firstIntermediateCounter.after.incrementAndGet())
+ .withTransition()
+ .from("intermediate-1")
+ .to("intermediate-2")
+ .checking((fsm, event) -> true)
+ .endTransition()
+ .end()
+ .state("intermediate-2")
+ .withBeforeHandler(fsm -> secondIntermediateCounter.before.incrementAndGet())
+ .withProcessor((fsm, event) -> secondIntermediateCounter.process.incrementAndGet())
+ .withAfterHandler(fsm -> secondIntermediateCounter.after.incrementAndGet())
+ .end()
+ .finish("finish")
+ .withBeforeHandler(fsm -> finishCounter.before.incrementAndGet())
+ .withProcessor((fsm, event) -> finishCounter.process.incrementAndGet())
+ .withAfterHandler(fsm -> finishCounter.after.incrementAndGet())
+ .withTransition()
+ .from("intermediate-2")
+ .to("finish")
+ .checking((fsm, event) -> true)
+ .endTransition()
+ .end()
+ .create()
+ ;
+
+ // @formatter:on
+
+ simpleFsm.process("");
+ simpleFsm.process("");
+ simpleFsm.process("");
+
+ Assert.assertEquals("finish", simpleFsm.getCurrentState().getName());
+ Assert.assertEquals(1, initCounter.before.get());
+ Assert.assertEquals(1, initCounter.after.get());
+ Assert.assertEquals(1, initCounter.process.get());
+ Assert.assertEquals(1, firstIntermediateCounter.before.get());
+ Assert.assertEquals(1, firstIntermediateCounter.after.get());
+ Assert.assertEquals(1, firstIntermediateCounter.process.get());
+ Assert.assertEquals(1, secondIntermediateCounter.before.get());
+ Assert.assertEquals(1, secondIntermediateCounter.after.get());
+ Assert.assertEquals(1, secondIntermediateCounter.process.get());
+ Assert.assertEquals(1, finishCounter.before.get());
+ Assert.assertEquals(0, finishCounter.after.get());
+ Assert.assertEquals(0, finishCounter.process.get());
+
+ }
+
static class Counter {
final AtomicInteger before = new AtomicInteger(0);
final AtomicInteger after = new AtomicInteger(0);