#20 wildcard pattern matching, and new pattern builder

Author: UnquietCode

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

@@ -24,6 +24,8 @@ this software and associated documentation files (the "Software"), to deal in
 package unquietcode.tools.esm;
 
 import unquietcode.tools.esm.routing.StateRouter;
+import unquietcode.tools.esm.sequences.Pattern;
+import unquietcode.tools.esm.sequences.PatternBuilder;
 
 import java.util.*;
 import java.util.concurrent.*;
@@ -46,7 +48,7 @@ public class GenericStateMachine<T extends State> implements StateMachine<T> {
 	// sequence matching
 	private int maxRecent = 0;
 	private final Queue<StateContainer> recentStates = new ArrayDeque<>();
-	private final Set<PatternMatcher> matchers = new HashSet<>();
+	private final Set<PatternMatcher<T>> matchers = new HashSet<>();
 
 	// global handlers
 	private final Set<StateHandler<T>> globalOnEntryHandlers = new HashSet<>();
@@ -159,9 +161,11 @@ private void doPatternMatching(StateContainer nextState) {
 		final List<StateContainer> recent
 			= Collections.unmodifiableList(new ArrayList<>(recentStates));
 
-		for (PatternMatcher matcher : matchers) {
-			if (matcher.matches(recent)) {
-				matcher.handler.onMatch(matcher.pattern);
+		for (PatternMatcher<T> matcher : matchers) {
+			Optional<List<T>> matches = matcher.matches(recent);
+
+			if (matches.isPresent()) {
+				matcher.handler.onMatch(matches.get());
 			}
 		}
 	}
@@ -400,29 +404,35 @@ public T route(T current, T next) {
 	}
 
 	@Override
-	public synchronized HandlerRegistration onSequence(List<T> pattern, SequenceHandler<T> handler) {
-		List<State> _pattern = Collections.<State>unmodifiableList(pattern);
-		final PatternMatcher matcher = new PatternMatcher(_pattern, handler);
+	public HandlerRegistration onSequence(Pattern<T> pattern, SequenceHandler<T> handler) {
+		final PatternMatcher<T> matcher = new PatternMatcher<>(pattern, handler);
 		matchers.add(matcher);
-		maxRecent = Math.max(maxRecent, pattern.size());
 
-		return new HandlerRegistration() {
-			public void unregister() {
-				matchers.remove(matcher);
-			}
+		// recalculate the cache size on add
+		maxRecent = Math.max(maxRecent, pattern.length());
+
+		return () -> {
+			matchers.remove(matcher);
+
+			// recalculate the cache size on remove
+			Optional<Integer> max = matchers.stream()
+				.map(e -> e.pattern.length())
+				.max(Integer::compareTo);
+
+			maxRecent = max.orElse(0);
 		};
 	}
 
 	@Override
 	@SuppressWarnings("unchecked")
 	public synchronized boolean addTransition(T fromState, T toState) {
-		return addTransitions(null, true, fromState, Arrays.asList(toState));
+		return addTransitions(null, true, fromState, Collections.singletonList(toState));
 	}
 
 	@Override
 	@SuppressWarnings("unchecked")
 	public synchronized boolean addTransition(T fromState, T toState, TransitionHandler<T> callback) {
-		return addTransitions(callback, true, fromState, Arrays.asList(toState));
+		return addTransitions(callback, true, fromState, Collections.singletonList(toState));
 	}
 
 	@Override
@@ -516,14 +526,13 @@ public String toString() {
 		}
 
 		int i = 1;
-		Map<StateWrapper, StateContainer> sortedStates = new TreeMap<StateWrapper, StateContainer>(states);
+		Map<StateWrapper, StateContainer> sortedStates = new TreeMap<>(states);
 
 		for (Map.Entry<StateWrapper, StateContainer> entry : sortedStates.entrySet()) {
 			sb.append("\t").append(fullString(entry.getKey().state)).append(" : {");
 
 			int j = 1;
-			Map<StateContainer, Transition> sortedTransitions
-				= new TreeMap<StateContainer, Transition>(entry.getValue().transitions);
+			Map<StateContainer, Transition> sortedTransitions = new TreeMap<>(entry.getValue().transitions);
 
 			for (Transition t : sortedTransitions.values()) {
 				sb.append(fullString(t.next.state));
@@ -556,9 +565,9 @@ private StateContainer getState(T token) {
 
 	private static class StateContainer implements Comparable<StateContainer> {
 		final State state;
-		final Map<StateContainer, Transition> transitions = new HashMap<StateContainer, Transition>();
-		final Set<StateHandler> entryActions = new HashSet<StateHandler>();
-		final Set<StateHandler> exitActions = new HashSet<StateHandler>();
+		final Map<StateContainer, Transition> transitions = new HashMap<>();
+		final Set<StateHandler> entryActions = new HashSet<>();
+		final Set<StateHandler> exitActions = new HashSet<>();
 
 		StateContainer(State state) {
 			this.state = state;
@@ -617,7 +626,7 @@ public int hashCode() {
 
 	private static class Transition {
 		final StateContainer next;
-		final Set<TransitionHandler> callbacks = new HashSet<TransitionHandler>();
+		final Set<TransitionHandler> callbacks = new HashSet<>();
 
 		Transition(StateContainer next) {
 			this.next = next;
@@ -635,38 +644,48 @@ private static class Transition {
 //		}
 	}
 
-	private static class PatternMatcher {
-		private final List<State> pattern;
+	private static class PatternMatcher<T> {
+		private final Pattern<T> pattern;
 		private final SequenceHandler handler;
 
-		PatternMatcher(List<State> pattern, SequenceHandler handler) {
+		PatternMatcher(Pattern<T> pattern, SequenceHandler handler) {
 			this.pattern = pattern;
 			this.handler = handler;
 		}
 
-		boolean matches(List<StateContainer> states) {
-			for (int i = pattern.size() - 1; i >= 0; --i) {
-				int j = states.size() - (pattern.size() - i);
+		Optional<List<T>> matches(List<StateContainer> states) {
+			List<T> matches = new ArrayList<>();
+			List<Object> patternStates = this.pattern.pattern();
+
+			for (int i = patternStates.size() - 1; i >= 0; --i) {
+				int j = states.size() - (patternStates.size() - i);
 
 				if (j < 0) {
-					return false;
+					return Optional.empty();
 				}
 
-				State matchState = pattern.get(i);
+				Object matchState = patternStates.get(i);
 				State recentState = states.get(j).state;
 
-				if (matchState == null) {
+				if (PatternBuilder.isWildcard(matchState)) {
+					// nothing, do no state checking
+				} else if (matchState == null) {
 					if (recentState != null) {
-						return false;
+						return Optional.empty();
 					}
 				} else if (recentState == null) {
-					return false;
+					return Optional.empty();
 				} else if (!matchState.equals(recentState)) {
-					return false;
+					return Optional.empty();
 				}
+
+				@SuppressWarnings("unchecked")
+				T recentState_ = (T) recentState;
+				matches.add(recentState_);
 			}
 
-			return true;
+			Collections.reverse(matches);
+			return Optional.of(matches);
 		}
 	}
 

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

@@ -23,6 +23,9 @@ this software and associated documentation files (the "Software"), to deal in
 
 package unquietcode.tools.esm;
 
+import unquietcode.tools.esm.sequences.Pattern;
+import unquietcode.tools.esm.sequences.PatternBuilder;
+
 import java.util.List;
 
 /**
@@ -82,7 +85,12 @@ public interface ProgrammableStateMachine<T> {
 	 * @param handler to handle the match
 	 * @return registration to assist in removing the handler
 	 */
-	HandlerRegistration onSequence(List<T> pattern, SequenceHandler<T> handler);
+	default HandlerRegistration onSequence(List<T> pattern, SequenceHandler<T> handler) {
+		Pattern<T> pattern_ = PatternBuilder.createFrom(pattern);
+		return onSequence(pattern_, handler);
+	}
+
+	HandlerRegistration onSequence(Pattern<T> pattern, SequenceHandler<T> handler);
 
 	/*
 		Adds a transition from one state to another.

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

@@ -24,6 +24,8 @@ this software and associated documentation files (the "Software"), to deal in
 package unquietcode.tools.esm;
 
 import unquietcode.tools.esm.routing.StateRouter;
+import unquietcode.tools.esm.sequences.Pattern;
+import unquietcode.tools.esm.sequences.PatternBuilder;
 
 import java.util.*;
 import java.util.concurrent.Future;
@@ -167,8 +169,25 @@ public HandlerRegistration routeAfterExiting(_Type from, StateRouter<_Type> rout
 	}
 
 	@Override
-	public HandlerRegistration onSequence(List<_Type> pattern, SequenceHandler<_Type> handler) {
-		return proxy.onSequence(wrap(pattern), new SequenceWrapper(handler));
+	public HandlerRegistration onSequence(Pattern<_Type> pattern, SequenceHandler<_Type> handler) {
+		PatternBuilder<_Wrapper> patternBuilder = PatternBuilder.create();
+
+		for (Object type : pattern.pattern()) {
+
+			if (PatternBuilder.isWildcard(type)) {
+				patternBuilder.addWildcard();
+				continue;
+			}
+
+			@SuppressWarnings("unchecked")
+			_Type type_ = (_Type) type;
+
+			_Wrapper wrapped = _wrap(type_);
+			patternBuilder.add(wrapped);
+		}
+
+		Pattern<_Wrapper> pattern_ = patternBuilder.build();
+		return proxy.onSequence(pattern_, new SequenceWrapper(handler));
 	}
 
 	@Override

src/main/java/unquietcode/tools/esm/sequences/Pattern.java

@@ -0,0 +1,48 @@
+/*******************************************************************************
+ The MIT License (MIT)
+
+ Copyright (c) 2018 Benjamin Fagin
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy of
+ this software and associated documentation files (the "Software"), to deal in
+ the Software without restriction, including without limitation the rights to
+ use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ the Software, and to permit persons to whom the Software is furnished to do so,
+ subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ ******************************************************************************/
+
+package unquietcode.tools.esm.sequences;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * @author Ben Fagin
+ * @version 2018-07-18
+ */
+public class Pattern<T> {
+	private final List<T> pattern = new ArrayList<>();
+
+	/* package */ Pattern(List<T> pattern) {
+		this.pattern.addAll(pattern);
+	}
+
+	public List<Object> pattern() {
+		return Collections.unmodifiableList(pattern);
+	}
+
+	public int length() {
+		return pattern.size();
+	}
+}

src/main/java/unquietcode/tools/esm/sequences/PatternBuilder.java

@@ -0,0 +1,75 @@
+/*******************************************************************************
+ The MIT License (MIT)
+
+ Copyright (c) 2018 Benjamin Fagin
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy of
+ this software and associated documentation files (the "Software"), to deal in
+ the Software without restriction, including without limitation the rights to
+ use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ the Software, and to permit persons to whom the Software is furnished to do so,
+ subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ ******************************************************************************/
+
+package unquietcode.tools.esm.sequences;
+
+import unquietcode.tools.esm.State;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * @author Ben Fagin
+ * @version 2018-07-18
+ */
+public class PatternBuilder<T> {
+	private PatternBuilder() {}
+	private final List<Object> pattern = new ArrayList<>();
+
+
+	public static <T extends State> PatternBuilder<T> create() {
+		return new PatternBuilder<>();
+	}
+
+	public static <T> Pattern<T> createFrom(List<T> states) {
+		return new Pattern<>(states);
+	}
+
+	@SafeVarargs
+	public final PatternBuilder<T> add(T...states) {
+		pattern.addAll(Arrays.asList(states));
+		return this;
+	}
+
+	public Pattern<T> build() {
+		Pattern<Object> p1 = new Pattern<>(pattern);
+
+		@SuppressWarnings("unchecked")
+		Pattern<T> p2 = (Pattern<T>) p1;
+
+		return p2;
+	}
+
+	// wildcard matching state
+	private static final Object WILDCARD = new Object();
+
+	public static boolean isWildcard(Object element) {
+		return element == WILDCARD;
+	}
+
+	public PatternBuilder<T> addWildcard() {
+		pattern.add(WILDCARD);
+		return this;
+	}
+}