Changes pattern matching to iterate in reverse, which corrects

a problem where two sequences of different sizes will fail to
match from the beginning of the list.

fixes #17

Author: UnquietCode

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

@@ -24,7 +24,9 @@ this software and associated documentation files (the "Software"), to deal in
 package unquietcode.tools.esm;
 
 
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.List;
 
 /**
  * A state machine which runs on enums. Note that null is a valid state
@@ -58,8 +60,28 @@ public EnumStateMachine(T initial) {
 	 * @param includeSelf if true, will also create loops
 	 */
 	public void addAll(Class<T> clazz, boolean includeSelf) {
+		addAll(clazz, includeSelf, false);
+	}
+
+	/**
+	 * Add transitions between every enum in the class.
+	 * If includeSelf is set, then every enum state will
+	 * also have a transition added which returns to itself.
+	 *
+	 * @param clazz this enum class
+	 * @param includeSelf if true, will also create loops
+	 * @param includeNull if true, will also consider the null state
+	 */
+	public void addAll(Class<T> clazz, boolean includeSelf, boolean includeNull) {
 		setType(clazz);
-		addAllTransitions(Arrays.asList(clazz.getEnumConstants()), includeSelf);
+
+		List<T> allStates = new ArrayList<>(Arrays.asList(clazz.getEnumConstants()));
+
+		if (includeNull) {
+			allStates.add(null);
+		}
+
+		addAllTransitions(allStates, includeSelf);
 	}
 
 	/**

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

@@ -160,7 +160,7 @@ private void doPatternMatching(StateContainer nextState) {
 			= Collections.unmodifiableList(new ArrayList<>(recentStates));
 
 		for (PatternMatcher matcher : matchers) {
-			if (matcher.matches(recent.iterator(), recent.size())) {
+			if (matcher.matches(recent)) {
 				matcher.handler.onMatch(matcher.pattern);
 			}
 		}
@@ -644,21 +644,24 @@ private static class PatternMatcher {
 			this.handler = handler;
 		}
 
-		boolean matches(Iterator<StateContainer> it, int size) {
-			if (size < pattern.size()) {
-				return false;
-			}
+		boolean matches(List<StateContainer> states) {
+			for (int i = pattern.size() - 1; i >= 0; --i) {
+				int j = states.size() - (pattern.size() - i);
+
+				if (j < 0) {
+					return false;
+				}
 
-			for (State state : pattern) {
-				State nextState = it.next().state;
+				State matchState = pattern.get(i);
+				State recentState = states.get(j).state;
 
-				if (state == null) {
-					if (nextState != null) {
+				if (matchState == null) {
+					if (recentState != null) {
 						return false;
 					}
-				} else if (nextState == null) {
+				} else if (recentState == null) {
 					return false;
-				} else if (!state.equals(nextState)) {
+				} else if (!matchState.equals(recentState)) {
 					return false;
 				}
 			}

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

@@ -80,8 +80,39 @@ public void test_sequential_match_with_null_initial_state() {
 		assertEquals(1, counter.get());
 	}
 
+	@Test
+	public void test_sequential_match_with_differing_list_sizes() {
+		EnumStateMachine<ZState> esm = new EnumStateMachine<>();
+		esm.addAll(ZState.class, true, true);
+
+		List<ZState> threeStatePattern = Arrays.asList(ZState.One, ZState.Two, ZState.Three);
+		List<ZState> fourStatePattern = Arrays.asList(ZState.One, ZState.Two, ZState.Three, ZState.Four);
+
+		final AtomicInteger counter1 = new AtomicInteger(0);
+		final AtomicInteger counter2 = new AtomicInteger(0);
+
+		esm.onSequence(threeStatePattern, pattern -> counter1.incrementAndGet());
+		esm.onSequence(fourStatePattern, pattern -> counter2.incrementAndGet());
+
+		esm.transition(ZState.One);
+		esm.transition(ZState.Two);
+		assertEquals(0, counter1.get());
+		assertEquals(0, counter2.get());
+
+		esm.transition(ZState.Three);
+		assertEquals(1, counter1.get());
+		assertEquals(0, counter2.get());
+
+		esm.transition(ZState.Four);
+		assertEquals(1, counter1.get());
+		assertEquals(1, counter2.get());
+	}
 
 	public enum Color implements State {
 		Red, Blue, Green, Orange
 	}
+
+	public enum ZState implements State {
+		One, Two, Three, Four, Five
+	}
 }