Changes to give the initial state correct handling during

sequence matching.

fixes #18
fixes #19

Author: UnquietCode

src/main/java/unquietcode/tools/esm/EnumStateMachine.java

@@ -24,7 +24,7 @@ this software and associated documentation files (the "Software"), to deal in
 package unquietcode.tools.esm;
 
 
-import java.util.*;
+import java.util.Arrays;
 
 /**
  * A state machine which runs on enums. Note that null is a valid state
@@ -82,7 +82,7 @@ public void setType(Class<T> clazz) {
 
 	@Override
 	protected EnumWrapper<T> wrap(T unwrapped) {
-		return new EnumWrapper<T>(unwrapped);
+		return new EnumWrapper<>(unwrapped);
 	}
 
 	@Override

src/main/java/unquietcode/tools/esm/GenericStateMachine.java

@@ -40,18 +40,18 @@ public class GenericStateMachine<T extends State> implements StateMachine<T> {
 
 	// states, and the routers that route them
 	private ExecutorService executor = _newExecutor();
-	private final Map<StateWrapper, StateContainer> states = new HashMap<StateWrapper, StateContainer>();
-	private final List<StateRouter<T>> routers = new ArrayList<StateRouter<T>>();
+	private final Map<StateWrapper, StateContainer> states = new HashMap<>();
+	private final List<StateRouter<T>> routers = new ArrayList<>();
 
 	// sequence matching
 	private int maxRecent = 0;
-	private final Queue<State> recentStates = new ArrayDeque<State>();
-	private final Set<PatternMatcher> matchers = new HashSet<PatternMatcher>();
+	private final Queue<StateContainer> recentStates = new ArrayDeque<>();
+	private final Set<PatternMatcher> matchers = new HashSet<>();
 
 	// global handlers
-	private final Set<StateHandler<T>> globalOnEntryHandlers = new HashSet<StateHandler<T>>();
-	private final Set<StateHandler<T>> globalOnExitHandlers = new HashSet<StateHandler<T>>();
-	private final Set<TransitionHandler<T>> globalOnTransitionHandlers = new HashSet<TransitionHandler<T>>();
+	private final Set<StateHandler<T>> globalOnEntryHandlers = new HashSet<>();
+	private final Set<StateHandler<T>> globalOnExitHandlers = new HashSet<>();
+	private final Set<TransitionHandler<T>> globalOnTransitionHandlers = new HashSet<>();
 
 	// backing data
 	private StateContainer initial;
@@ -78,6 +78,9 @@ public synchronized void reset() {
 		current = initial;
 		recentStates.clear();
 		executor = _newExecutor();
+
+		// add back the initial state for pattern matching
+		recentStates.add(initial);
 	}
 
 	@Override
@@ -146,15 +149,15 @@ private boolean _transition(final StateContainer nextState) {
 	@SuppressWarnings("unchecked")
 	private void doPatternMatching(StateContainer nextState) {
 		if (maxRecent != 0) {
-			recentStates.add(nextState.state);
+			recentStates.add(nextState);
 		}
 
 		if (recentStates.size() > maxRecent) {
 			recentStates.remove();
 		}
 
-		final List<State> recent
-			= Collections.unmodifiableList(new ArrayList<State>(recentStates));
+		final List<StateContainer> recent
+			= Collections.unmodifiableList(new ArrayList<>(recentStates));
 
 		for (PatternMatcher matcher : matchers) {
 			if (matcher.matches(recent.iterator(), recent.size())) {
@@ -641,13 +644,21 @@ private static class PatternMatcher {
 			this.handler = handler;
 		}
 
-		boolean matches(Iterator<State> it, int size) {
+		boolean matches(Iterator<StateContainer> it, int size) {
 			if (size < pattern.size()) {
 				return false;
 			}
 
 			for (State state : pattern) {
-				if (!state.equals(it.next())) {
+				State nextState = it.next().state;
+
+				if (state == null) {
+					if (nextState != null) {
+						return false;
+					}
+				} else if (nextState == null) {
+					return false;
+				} else if (!state.equals(nextState)) {
 					return false;
 				}
 			}

src/main/java/unquietcode/tools/esm/WrappedStateMachine.java

@@ -38,7 +38,7 @@ public WrappedStateMachine() {
 	}
 
 	public WrappedStateMachine(_Type initial) {
-		proxy = new GenericStateMachine<>(wrap(initial));
+		proxy = new GenericStateMachine<>(_wrap(initial));
 	}
 
 	@Override

src/test/java/unquietcode/tools/esm/EnumStateMachine_T.java

@@ -5,7 +5,6 @@
 
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Future;
-import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 
 /**

src/test/java/unquietcode/tools/esm/Sequence_T.java

@@ -38,6 +38,49 @@ public void testSequentialMatch() {
 		assertEquals(1, counter.get());
 	}
 
+	@Test
+	public void test_sequential_match_on_initial_state() {
+		EnumStateMachine<Color> sm = new EnumStateMachine<>(Color.Red);
+		sm.addTransition(Color.Red, Color.Green);
+		sm.addTransition(Color.Green, Color.Orange);
+		sm.addTransition(Color.Orange, Color.Red);
+
+		final List<Color> _pattern = Arrays.asList(Color.Red, Color.Green, Color.Orange);
+		final AtomicInteger counter = new AtomicInteger(0);
+
+		sm.onSequence(_pattern, pattern -> {
+			assertEquals(_pattern, pattern);
+			counter.incrementAndGet();
+		});
+
+		sm.transition(Color.Green);
+		sm.transition(Color.Orange);
+
+		assertEquals(1, counter.get());
+	}
+
+	@Test
+	public void test_sequential_match_with_null_initial_state() {
+		EnumStateMachine<Color> sm = new EnumStateMachine<>(null);
+		sm.addTransition(null, Color.Green);
+		sm.addTransition(Color.Green, Color.Orange);
+		sm.addTransition(Color.Orange, Color.Red);
+
+		final List<Color> _pattern = Arrays.asList(null, Color.Green, Color.Orange);
+		final AtomicInteger counter = new AtomicInteger(0);
+
+		sm.onSequence(_pattern, pattern -> {
+			assertEquals(_pattern, pattern);
+			counter.incrementAndGet();
+		});
+
+		sm.transition(Color.Green);
+		sm.transition(Color.Orange);
+
+		assertEquals(1, counter.get());
+	}
+
+
 	public enum Color implements State {
 		Red, Blue, Green, Orange
 	}