Use primitive bit field for TypeMatcher instead of elaborate data structure. (#207)

Inspired by pull request #223 (@dr0i).

Author: blackwinter

metafix/src/main/java/org/metafacture/metafix/Value.java

@@ -20,9 +20,9 @@
 import org.metafacture.commons.tries.WildcardTrie;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.ConcurrentModificationException;
-import java.util.EnumSet;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
@@ -305,9 +305,10 @@ enum Type {
 
     public static class TypeMatcher {
 
-        private final Set<Type> expected = EnumSet.noneOf(Type.class);
         private final Value value;
 
+        private byte expected; // NOTE: Covers at most 7 `Type`s.
+
         private TypeMatcher(final Value value) {
             this.value = value;
         }
@@ -325,20 +326,26 @@ public TypeMatcher ifString(final Consumer<String> consumer) {
         }
 
         public void orElse(final Consumer<Value> consumer) {
-            if (!expected.contains(value.type)) {
+            if (!expecting(value.type)) {
                 consumer.accept(value);
             }
         }
 
         public void orElseThrow() {
             orElse(v -> {
-                final String types = expected.stream().map(Type::name).collect(Collectors.joining(" or "));
+                final String types = Arrays.stream(Type.values()).filter(this::expecting)
+                    .map(Type::name).collect(Collectors.joining(" or "));
+
                 throw new IllegalStateException("Expected " + types + ", got " + value.type);
             });
         }
 
         private <T> TypeMatcher match(final Type type, final Consumer<T> consumer, final T rawValue) {
-            if (expected.add(type)) {
+            final byte newExpected = (byte) (expected | bit(type));
+
+            if (expected != newExpected) {
+                expected = newExpected;
+
                 if (value.isType(type)) {
                     consumer.accept(rawValue);
                 }
@@ -350,6 +357,14 @@ private <T> TypeMatcher match(final Type type, final Consumer<T> consumer, final
             }
         }
 
+        private boolean expecting(final Type type) {
+            return (expected & bit(type)) != 0;
+        }
+
+        private byte bit(final Type type) {
+            return (byte) (1 << type.ordinal());
+        }
+
     }
 
     private abstract static class AbstractValueType {