EncodingManager refactoring (graphhopper#1546)

* EncodingManager refactoring

* avoid name clash with new TagParser

Author: karussell

core/files/changelog.txt

@@ -1,4 +1,6 @@
 0.12
+    refactoring of EncodingManager to use builder pattern. Migration should be simple. Replace new EncodingManager with EncodingManager.create
+    EncodingManager.supports renames to hasEncoder
     big refactoring #1447: to increase 64bit limit of flags, make reverse direction handling easier, to allow shared EncodedValues,
         remove reverseFlags method, much simpler property access, simplify FlagEncoder (maybe even deprecate this interface at a later stage)
     moved shp-reader into separate repository: https://github.com/graphhopper/graphhopper-reader-shp    

core/src/main/java/com/graphhopper/GraphHopper.java

@@ -548,7 +548,7 @@ public GraphHopper init(CmdArgs args) {
         int bytesForFlags = args.getInt("graph.bytes_for_flags", 4);
         String flagEncodersStr = args.get("graph.flag_encoders", "");
         if (!flagEncodersStr.isEmpty())
-            setEncodingManager(new EncodingManager(flagEncoderFactory, flagEncodersStr, bytesForFlags));
+            setEncodingManager(EncodingManager.create(flagEncoderFactory, flagEncodersStr, bytesForFlags));
 
         if (args.get("graph.locktype", "native").equals("simple"))
             lockFactory = new SimpleFSLockFactory();
@@ -881,7 +881,7 @@ public void postProcessing() {
     }
 
     private void interpolateBridgesAndOrTunnels() {
-        if (ghStorage.getEncodingManager().supports("generic")) {
+        if (ghStorage.getEncodingManager().hasEncoder("generic")) {
             final FlagEncoder genericFlagEncoder = ghStorage.getEncodingManager()
                     .getEncoder("generic");
             if (!(genericFlagEncoder instanceof DataFlagEncoder)) {
@@ -983,7 +983,7 @@ public List<Path> calcPaths(GHRequest request, GHResponse ghRsp) {
         Lock readLock = readWriteLock.readLock();
         readLock.lock();
         try {
-            if (!encodingManager.supports(vehicle))
+            if (!encodingManager.hasEncoder(vehicle))
                 throw new IllegalArgumentException("Vehicle not supported: " + vehicle + ". Supported are: " + encodingManager.toString());
 
             HintsMap hints = request.getHints();

core/src/main/java/com/graphhopper/routing/profiles/EncodedValueLookup.java

@@ -29,5 +29,5 @@ public interface EncodedValueLookup {
 
     ObjectEncodedValue getObjectEncodedValue(String key);
 
-    boolean supports(String key);
+    boolean hasEncoder(String key);
 }

core/src/main/java/com/graphhopper/routing/util/AbstractFlagEncoder.java

@@ -310,7 +310,7 @@ public boolean equals(Object obj) {
     /**
      * @return the speed in km/h
      */
-    protected double parseSpeed(String str) {
+    public static double parseSpeed(String str) {
         if (Helper.isEmpty(str))
             return -1;
 
@@ -537,13 +537,13 @@ protected boolean isAccept(long internalFlags) {
 
     public final DecimalEncodedValue getAverageSpeedEnc() {
         if (speedEncoder == null)
-            throw new NullPointerException("FlagEncoder not yet initialized");
+            throw new NullPointerException("FlagEncoder " + toString() + " not yet initialized");
         return speedEncoder;
     }
 
     public final BooleanEncodedValue getAccessEnc() {
         if (accessEnc == null)
-            throw new NullPointerException("FlagEncoder not yet initialized");
+            throw new NullPointerException("FlagEncoder " + toString() + " not yet initialized");
         return accessEnc;
     }
 
@@ -638,7 +638,7 @@ public boolean supports(Class<?> feature) {
     }
 
     @Override
-    public boolean supports(String key) {
-        return encodedValueLookup.supports(key);
+    public boolean hasEncoder(String key) {
+        return encodedValueLookup.hasEncoder(key);
     }
 }

core/src/main/java/com/graphhopper/routing/util/EncodingManager.java

@@ -35,8 +35,9 @@
 
 /**
  * Manager class to register encoder, assign their flag values and check objects with all encoders
- * during parsing.
+ * during parsing. Create one via:
  * <p>
+ * EncodingManager.start(4).add(new CarFlagEncoder()).build();
  *
  * @author Peter Karich
  * @author Nop
@@ -46,7 +47,7 @@ public class EncodingManager implements EncodedValueLookup {
     private static final String WAY_ERR = "Decrease the number of vehicles or increase the flags to take long via graph.bytes_for_flags: 8";
     private final List<AbstractFlagEncoder> edgeEncoders = new ArrayList<>();
     private final Map<String, EncodedValue> encodedValueMap = new LinkedHashMap<>();
-    private final Map<EncodedValue, OSMTagParser> sharedEncodedValueMap = new LinkedHashMap<>();
+    private final Map<EncodedValue, TagParser> sharedEncodedValueMap = new LinkedHashMap<>();
     private final int bitsForEdgeFlags;
     private final int bitsForTurnFlags = 8 * 4;
     private int nextNodeBit = 0;
@@ -63,61 +64,139 @@ public class EncodingManager implements EncodedValueLookup {
      *
      * @param flagEncodersStr comma delimited list of encoders. The order does not matter.
      */
-    public EncodingManager(String flagEncodersStr) {
-        this(flagEncodersStr, 4);
+    public static EncodingManager create(String flagEncodersStr) {
+        return create(flagEncodersStr, 4);
     }
 
-    public EncodingManager(String flagEncodersStr, int bytesForEdgeFlags) {
-        this(FlagEncoderFactory.DEFAULT, flagEncodersStr, bytesForEdgeFlags);
+    public static EncodingManager create(String flagEncodersStr, int bytesForEdgeFlags) {
+        return create(FlagEncoderFactory.DEFAULT, flagEncodersStr, bytesForEdgeFlags);
     }
 
-    public EncodingManager(FlagEncoderFactory factory, String flagEncodersStr, int bytesForEdgeFlags) {
-        this(parseEncoderString(factory, flagEncodersStr), bytesForEdgeFlags);
+    public static EncodingManager create(FlagEncoderFactory factory, String flagEncodersStr, int bytesForEdgeFlags) {
+        return create(parseEncoderString(factory, flagEncodersStr), bytesForEdgeFlags);
     }
 
     /**
      * Instantiate manager with the given list of encoders.
      *
      * @param flagEncoders comma delimited list of encoders. The order does not matter.
      */
-    public EncodingManager(FlagEncoder... flagEncoders) {
-        this(Arrays.asList(flagEncoders));
+    public static EncodingManager create(FlagEncoder... flagEncoders) {
+        return create(Arrays.asList(flagEncoders));
     }
 
     /**
      * Instantiate manager with the given list of encoders.
      *
      * @param flagEncoders comma delimited list of encoders. The order does not matter.
      */
-    public EncodingManager(List<? extends FlagEncoder> flagEncoders) {
-        this(flagEncoders, 4);
+    public static EncodingManager create(List<? extends FlagEncoder> flagEncoders) {
+        return create(flagEncoders, 4);
     }
 
-    public EncodingManager(List<? extends FlagEncoder> flagEncoders, int bytesForEdgeFlags) {
-        if (bytesForEdgeFlags <= 0 || (bytesForEdgeFlags / 4) * 4 != bytesForEdgeFlags)
-            throw new IllegalStateException("For 'edge flags' only a multiple of 4 is supported");
+    public static EncodingManager create(List<? extends FlagEncoder> flagEncoders, int bytesForEdgeFlags) {
+        Builder builder = new Builder(bytesForEdgeFlags);
+        for (FlagEncoder flagEncoder : flagEncoders) {
+            builder.add(flagEncoder);
+        }
+        return builder.build();
+    }
 
-        this.bitsForEdgeFlags = bytesForEdgeFlags * 8;
+    /**
+     * Create the EncodingManager from the provided GraphHopper location. Throws an
+     * IllegalStateException if it fails. Used if no EncodingManager specified on load.
+     */
+    public static EncodingManager create(FlagEncoderFactory factory, String ghLoc) {
+        Directory dir = new RAMDirectory(ghLoc, true);
+        StorableProperties properties = new StorableProperties(dir);
+        if (!properties.loadExisting())
+            throw new IllegalStateException("Cannot load properties to fetch EncodingManager configuration at: "
+                    + dir.getLocation());
+
+        // check encoding for compatibility
+        properties.checkVersions(false);
+        String acceptStr = properties.get("graph.flag_encoders");
+
+        if (acceptStr.isEmpty())
+            throw new IllegalStateException("EncodingManager was not configured. And no one was found in the graph: "
+                    + dir.getLocation());
+
+        int bytesForFlags = 4;
+        try {
+            bytesForFlags = Integer.parseInt(properties.get("graph.bytes_for_flags"));
+        } catch (NumberFormatException ex) {
+        }
+        return create(factory, acceptStr, bytesForFlags);
+    }
+
+    /**
+     * Starts the build process of an EncodingManager
+     */
+    public static Builder start() {
+        return new Builder(4);
+    }
+
+    private EncodingManager(int bytes) {
+        if (bytes <= 0 || (bytes / 4) * 4 != bytes)
+            throw new IllegalStateException("bytesForEdgeFlags can be only a multiple of 4");
+
+        this.bitsForEdgeFlags = bytes * 8;
         this.config = new EncodedValue.InitializerConfig();
-        final BooleanEncodedValue roundaboutEnc = new SimpleBooleanEncodedValue("roundabout", false);
-        sharedEncodedValueMap.put(roundaboutEnc, new OSMTagParser() {
-            @Override
-            public IntsRef handleWayTags(IntsRef edgeFlags, ReaderWay way, long allowed, long relationFlags) {
-                boolean isRoundabout = way.hasTag("junction", "roundabout") || way.hasTag("junction", "circular");
-                if (isRoundabout)
-                    roundaboutEnc.setBool(false, edgeFlags, true);
-                return edgeFlags;
+    }
+
+    public static class Builder {
+        private final EncodingManager em;
+        private boolean buildCalled = false;
+
+        public Builder(int bytes) {
+            em = new EncodingManager(bytes);
+            final BooleanEncodedValue roundaboutEnc = new SimpleBooleanEncodedValue("roundabout", false);
+            put(roundaboutEnc, new TagParser() {
+                @Override
+                public IntsRef handleWayTags(IntsRef edgeFlags, ReaderWay way, long allowed, long relationFlags) {
+                    boolean isRoundabout = way.hasTag("junction", "roundabout") || way.hasTag("junction", "circular");
+                    if (isRoundabout)
+                        roundaboutEnc.setBool(false, edgeFlags, true);
+                    return edgeFlags;
+                }
+            });
+        }
+
+        /**
+         * For backward compatibility provide a way to add multiple FlagEncoders
+         */
+        public Builder addAll(FlagEncoderFactory factory, String flagEncodersStr) {
+            for (FlagEncoder fe : parseEncoderString(factory, flagEncodersStr)) {
+                add(fe);
             }
-        });
-        for (EncodedValue ev : sharedEncodedValueMap.keySet()) {
-            addEncodedValue(ev);
+            return this;
         }
-        for (FlagEncoder flagEncoder : flagEncoders) {
-            registerEncoder((AbstractFlagEncoder) flagEncoder);
+
+        public Builder add(FlagEncoder encoder) {
+            em.addEncoder((AbstractFlagEncoder) encoder);
+            return this;
         }
 
-        if (edgeEncoders.isEmpty())
-            throw new IllegalStateException("No vehicles found");
+        public Builder add(EncodedValue encodedValue) {
+            em.addEncodedValue(encodedValue);
+            return this;
+        }
+
+        public Builder put(EncodedValue encodedValue, TagParser tagParser) {
+            add(encodedValue);
+            em.sharedEncodedValueMap.put(encodedValue, tagParser);
+            return this;
+        }
+
+        public EncodingManager build() {
+            if (buildCalled)
+                throw new IllegalStateException("Cannot call Builder.build() twice");
+            if (em.encodedValueMap.isEmpty())
+                throw new IllegalStateException("No EncodedValues found");
+
+            buildCalled = true;
+            return em;
+        }
     }
 
     static List<FlagEncoder> parseEncoderString(FlagEncoderFactory factory, String encoderList) {
@@ -159,38 +238,11 @@ static String fixWayName(String str) {
         return str.replaceAll(";[ ]*", ", ");
     }
 
-    /**
-     * Create the EncodingManager from the provided GraphHopper location. Throws an
-     * IllegalStateException if it fails. Used if no EncodingManager specified on load.
-     */
-    public static EncodingManager create(FlagEncoderFactory factory, String ghLoc) {
-        Directory dir = new RAMDirectory(ghLoc, true);
-        StorableProperties properties = new StorableProperties(dir);
-        if (!properties.loadExisting())
-            throw new IllegalStateException("Cannot load properties to fetch EncodingManager configuration at: "
-                    + dir.getLocation());
-
-        // check encoding for compatibility
-        properties.checkVersions(false);
-        String acceptStr = properties.get("graph.flag_encoders");
-
-        if (acceptStr.isEmpty())
-            throw new IllegalStateException("EncodingManager was not configured. And no one was found in the graph: "
-                    + dir.getLocation());
-
-        int bytesForFlags = 4;
-        try {
-            bytesForFlags = Integer.parseInt(properties.get("graph.bytes_for_flags"));
-        } catch (NumberFormatException ex) {
-        }
-        return new EncodingManager(factory, acceptStr, bytesForFlags);
-    }
-
     public int getBytesForFlags() {
         return bitsForEdgeFlags / 8;
     }
 
-    private void registerEncoder(AbstractFlagEncoder encoder) {
+    private void addEncoder(AbstractFlagEncoder encoder) {
         if (encoder.isRegistered())
             throw new IllegalStateException("You must not register a FlagEncoder (" + encoder.toString() + ") twice!");
 
@@ -243,7 +295,7 @@ private void addEncodedValue(EncodedValue ev) {
     /**
      * @return true if the specified encoder is found
      */
-    public boolean supports(String encoder) {
+    public boolean hasEncoder(String encoder) {
         return getEncoder(encoder, false) != null;
     }
 
@@ -290,7 +342,7 @@ public long handleRelationTags(long oldRelationFlags, ReaderRelation relation) {
      */
     public IntsRef handleWayTags(ReaderWay way, long includeWay, long relationFlags) {
         IntsRef edgeFlags = createEdgeFlags();
-        for (OSMTagParser parser : sharedEncodedValueMap.values()) {
+        for (TagParser parser : sharedEncodedValueMap.values()) {
             parser.handleWayTags(edgeFlags, way, includeWay, relationFlags);
         }
         for (AbstractFlagEncoder encoder : edgeEncoders) {
@@ -466,7 +518,7 @@ public ObjectEncodedValue getObjectEncodedValue(String key) {
     public <T extends EncodedValue> T getEncodedValue(String key, Class<T> encodedValueType) {
         EncodedValue ev = encodedValueMap.get(key);
         if (ev == null)
-            throw new IllegalArgumentException("Cannot find encoded value " + key + " in collection: " + ev);
+            throw new IllegalArgumentException("Cannot find EncodedValue " + key + " in collection: " + ev);
         return (T) ev;
     }
 
@@ -479,8 +531,7 @@ public static final String getKey(FlagEncoder encoder, String str) {
         return encoder.toString() + "." + str;
     }
 
-    // for now keep private as public IntsRef is too ugly and relationFlags is unclear
-    interface OSMTagParser {
+    public interface TagParser {
         IntsRef handleWayTags(IntsRef edgeFlags, ReaderWay way, long allowed, long relationFlags);
     }
 }

core/src/main/java/com/graphhopper/storage/CHGraph.java

@@ -29,7 +29,6 @@
  * Extended graph interface which supports Contraction Hierarchies. Ie. storing and retrieving the
  * levels for a node and creating shortcuts, which are additional 'artificial' edges to speedup
  * traversal in certain cases.
- * <p>
  *
  * @author Peter Karich
  */

core/src/main/java/com/graphhopper/storage/GraphHopperStorage.java

@@ -65,7 +65,7 @@ public GraphHopperStorage(List<? extends Weighting> nodeBasedCHWeightings, List<
             throw new IllegalArgumentException("GraphExtension cannot be null, use NoOpExtension");
 
         if (encodingManager == null)
-            throw new IllegalArgumentException("EncodingManager needs to be non-null since 0.7. Create one using new EncodingManager or EncodingManager.create(flagEncoderFactory, ghLocation)");
+            throw new IllegalArgumentException("EncodingManager needs to be non-null since 0.7. Create one using EncodingManager.create or EncodingManager.create(flagEncoderFactory, ghLocation)");
 
         this.encodingManager = encodingManager;
         this.dir = dir;

core/src/test/java/com/graphhopper/GraphHopperAPITest.java

@@ -42,7 +42,7 @@
  * @author Peter Karich
  */
 public class GraphHopperAPITest {
-    final EncodingManager encodingManager = new EncodingManager("car");
+    final EncodingManager encodingManager = EncodingManager.create("car");
 
     void initGraph(GraphHopperStorage graph) {
         NodeAccess na = graph.getNodeAccess();

core/src/test/java/com/graphhopper/reader/PrincetonReaderTest.java

@@ -37,7 +37,7 @@
  * @author Peter Karich
  */
 public class PrincetonReaderTest {
-    private EncodingManager encodingManager = new EncodingManager("car");
+    private EncodingManager encodingManager = EncodingManager.create("car");
     private EdgeFilter carOutEdges = DefaultEdgeFilter.outEdges(encodingManager.getEncoder("car"));
 
     @Test

core/src/test/java/com/graphhopper/reader/dem/AbstractEdgeElevationInterpolatorTest.java

@@ -52,7 +52,7 @@ public abstract class AbstractEdgeElevationInterpolatorTest {
     public void setUp() {
         dataFlagEncoder = new DataFlagEncoder();
         graph = new GraphHopperStorage(new RAMDirectory(),
-                new EncodingManager(Arrays.asList(dataFlagEncoder, new FootFlagEncoder()),
+                EncodingManager.create(Arrays.asList(dataFlagEncoder, new FootFlagEncoder()),
                         8),
                 true, new GraphExtension.NoOpExtension()).create(100);