Integrate access information in RoadInformation.

src/main/org/insa/graph/RoadInformation.java

@@ -28,9 +28,36 @@ public class RoadInformation {
         COASTLINE
     }
 
+    /**
+     * Access mode.
+     */
+    public enum AccessMode {
+        FOOT, BICYCLE, SMALL_MOTORCYCLE, MOTORCYCLE, MOTORCAR, BUS
+    }
+
+    // Some masks...
+    @SuppressWarnings("unused")
+    private static final int MASK_UNKNOWN = 0x01;
+    private static final int MASK_PRIVATE = 0x02;
+    @SuppressWarnings("unused")
+    private static final int MASK_AGRICULTURAL = 0x04;
+    @SuppressWarnings("unused")
+    private static final int MASK_SERVICE = 0x08;
+    private static final int MASK_PUBLIC_TRANSPORT = 0x10;
+
+    private static final int MASK_FOOT = 0x01 << 8;
+    private static final int MASK_BICYCLE = 0x02 << 8;
+    private static final int MASK_MOTORCYCLE = 0x0C << 8;
+    private static final int MASK_SMALL_MOTORCYCLE = 0x08 << 8;
+    private static final int MASK_MOTORCAR = 0x10 << 8;
+    private static final int MASK_BUS = 0x20 << 8;
+
     // Type of the road (see above).
     private final RoadType type;
 
+    // Access information
+    private final int access;
+
     // One way road?
     private final boolean oneway;
 
@@ -40,13 +67,64 @@ public class RoadInformation {
     // Name of the road.
     private final String name;
 
-    public RoadInformation(RoadType roadType, boolean isOneWay, int maxSpeed, String name) {
+    public RoadInformation(RoadType roadType, int access, boolean isOneWay, int maxSpeed,
+            String name) {
         this.type = roadType;
+        this.access = access;
         this.oneway = isOneWay;
         this.maxSpeed = maxSpeed;
         this.name = name;
     }
 
+    // Access information
+
+    /**
+     * @return true if this is a private road.
+     */
+    public boolean isPrivate() {
+        return (this.access & MASK_PRIVATE) != 0;
+    }
+
+    /**
+     * @return true if this road is reserved for public transport.
+     */
+    public boolean isPublicTransport() {
+        return (this.access & MASK_PUBLIC_TRANSPORT) != 0;
+    }
+
+    /**
+     * @param mode
+     * 
+     * @return true if this road is allowed for the specified mode.
+     */
+    public boolean isAllowedFor(AccessMode mode) {
+        if ((this.access & MASK_UNKNOWN) != 0) {
+            return true;
+        }
+        int maskedAccess = 0;
+        switch (mode) {
+        case FOOT:
+            maskedAccess = access & MASK_FOOT;
+            break;
+        case BICYCLE:
+            maskedAccess = access & MASK_BICYCLE;
+            break;
+        case SMALL_MOTORCYCLE:
+            maskedAccess = access & MASK_SMALL_MOTORCYCLE;
+            break;
+        case MOTORCYCLE:
+            maskedAccess = access & MASK_MOTORCYCLE;
+            break;
+        case MOTORCAR:
+            maskedAccess = access & MASK_MOTORCAR;
+            break;
+        case BUS:
+            maskedAccess = access & MASK_BUS;
+            break;
+        }
+        return maskedAccess != 0;
+    }
+
     /**
      * @return Type of the road.
      */
@@ -77,7 +155,6 @@ public class RoadInformation {
 
     /*
      * (non-Javadoc)
-     * 
      * @see java.lang.Object#toString()
      */
     @Override
@@ -89,7 +166,8 @@ public class RoadInformation {
         if (getType() == RoadType.MOTORWAY) {
             typeAsString = "highway";
         }
-        return typeAsString + " : " + getName() + " " + (isOneWay() ? " (oneway) " : "") + maxSpeed + " km/h (max.)";
+        return typeAsString + " : " + getName() + " " + (isOneWay() ? " (oneway) " : "") + maxSpeed
+                + " km/h (max.)";
     }
 
 }

src/main/org/insa/graph/io/BinaryGraphReaderInsa2016.java

@@ -148,7 +148,8 @@ public class BinaryGraphReaderInsa2016 extends BinaryReader implements GraphRead
                     float dlon = (dis.readShort()) / 2.0e5f;
                     float dlat = (dis.readShort()) / 2.0e5f;
 
-                    points.add(new Point(lastPoint.getLongitude() + dlon, lastPoint.getLatitude() + dlat));
+                    points.add(new Point(lastPoint.getLongitude() + dlon,
+                            lastPoint.getLatitude() + dlat));
                 }
 
                 points.add(nodes.get(destNode).getPoint());
@@ -188,7 +189,8 @@ public class BinaryGraphReaderInsa2016 extends BinaryReader implements GraphRead
     private RoadInformation readRoadInformation() throws IOException {
         char type = (char) dis.readUnsignedByte();
         int x = dis.readUnsignedByte();
-        return new RoadInformation(toRoadType(type), (x & 0x80) > 0, (x & 0x7F) * 5, dis.readUTF());
+        return new RoadInformation(toRoadType(type), 0, (x & 0x80) > 0, (x & 0x7F) * 5,
+                dis.readUTF());
     }
 
 }

src/main/org/insa/graph/io/BinaryGraphReaderInsa2018.java

@@ -154,7 +154,8 @@ public class BinaryGraphReaderInsa2018 extends BinaryReader implements GraphRead
                     float dlon = (dis.readShort()) / 2.0e5f;
                     float dlat = (dis.readShort()) / 2.0e5f;
 
-                    points.add(new Point(lastPoint.getLongitude() + dlon, lastPoint.getLatitude() + dlat));
+                    points.add(new Point(lastPoint.getLongitude() + dlon,
+                            lastPoint.getLatitude() + dlat));
                 }
 
                 points.add(nodes.get(destNode).getPoint());
@@ -193,7 +194,12 @@ public class BinaryGraphReaderInsa2018 extends BinaryReader implements GraphRead
     private RoadInformation readRoadInformation() throws IOException {
         char type = (char) dis.readUnsignedByte();
         int x = dis.readUnsignedByte();
-        return new RoadInformation(toRoadType(type), (x & 0x80) > 0, (x & 0x7F) * 5, dis.readUTF());
+        int access = 0xFF00;
+        if (getCurrentVersion() >= 6) {
+            access = dis.readUnsignedShort();
+        }
+        return new RoadInformation(toRoadType(type), access, (x & 0x80) > 0, (x & 0x7F) * 5,
+                dis.readUTF());
     }
 
 }

src/main/org/insa/graph/io/BinaryReader.java

@@ -8,7 +8,8 @@ import java.util.List;
 public abstract class BinaryReader {
 
     // Map version and magic number targeted for this reader.
-    private int version;
+    private int minVersion;
+    private int curVersion;
     private int magicNumber;
 
     // InputStream
@@ -17,9 +18,9 @@ public abstract class BinaryReader {
     // List of observers
     protected List<GraphReaderObserver> observers = new ArrayList<>();
 
-    protected BinaryReader(int magicNumber, int version, DataInputStream dis) {
+    protected BinaryReader(int magicNumber, int minVersion, DataInputStream dis) {
         this.magicNumber = magicNumber;
-        this.version = version;
+        this.minVersion = minVersion;
         this.dis = dis;
     }
 
@@ -31,20 +32,31 @@ public abstract class BinaryReader {
     }
 
     /**
+     * Check if the given version is greater than the minimum version, and update
+     * the current version if it is.
+     * 
      * @param version
      * @throws BadVersionException
      */
-    public void checkVersionOrThrow(int version) throws BadVersionException {
+    protected void checkVersionOrThrow(int version) throws BadVersionException {
-        if (this.version != version) {
+        if (version < this.minVersion) {
-            throw new BadVersionException(version, this.version);
+            throw new BadVersionException(version, this.minVersion);
         }
+        this.curVersion = version;
+    }
+
+    /**
+     * @return the current version.
+     */
+    protected int getCurrentVersion() {
+        return this.curVersion;
     }
 
     /**
      * @param magicNumber
      * @throws BadMagicNumberException
      */
-    public void checkMagicNumberOrThrow(int magicNumber) throws BadMagicNumberException {
+    protected void checkMagicNumberOrThrow(int magicNumber) throws BadMagicNumberException {
         if (this.magicNumber != magicNumber) {
             throw new BadMagicNumberException(magicNumber, this.magicNumber);
         }
@@ -58,7 +70,7 @@ public abstract class BinaryReader {
      * 
      * @throws IOException
      */
-    public void checkByteOrThrow(int i) throws IOException {
+    protected void checkByteOrThrow(int i) throws IOException {
         if (dis.readUnsignedByte() != i) {
             throw new BadFormatException();
         }

src/test/org/insa/graph/PathTest.java

@@ -31,8 +31,8 @@ public class PathTest {
     public static void initAll() throws IOException {
 
         // 10 and 20 meters per seconds
-        RoadInformation speed10 = new RoadInformation(RoadType.ROAD, true, 36, ""),
+        RoadInformation speed10 = new RoadInformation(RoadType.ROAD, 0, true, 36, ""),
-                speed20 = new RoadInformation(RoadType.ROAD, true, 72, "");
+                speed20 = new RoadInformation(RoadType.ROAD, 0, true, 72, "");
 
         // Create nodes
         nodes = new Node[5];
@@ -58,7 +58,8 @@ public class PathTest {
         shortPath = new Path(graph, Arrays.asList(new Arc[]{ a2b, b2c, c2d_1 }));
         longPath = new Path(graph, Arrays.asList(new Arc[]{ a2b, b2c, c2d_1, d2e }));
         loopPath = new Path(graph, Arrays.asList(new Arc[]{ a2b, b2c, c2d_1, d2a }));
-        longLoopPath = new Path(graph, Arrays.asList(new Arc[] { a2b, b2c, c2d_1, d2a, a2c, c2d_3, d2a, a2b, b2c }));
+        longLoopPath = new Path(graph,
+                Arrays.asList(new Arc[]{ a2b, b2c, c2d_1, d2a, a2c, c2d_3, d2a, a2b, b2c }));
         invalidPath = new Path(graph, Arrays.asList(new Arc[]{ a2b, c2d_1, d2e }));
 
     }
@@ -124,7 +125,8 @@ public class PathTest {
         Arc[] expected;
 
         // Simple construction
-        path = Path.createFastestPathFromNodes(graph, Arrays.asList(new Node[] { nodes[0], nodes[1], nodes[2] }));
+        path = Path.createFastestPathFromNodes(graph,
+                Arrays.asList(new Node[]{ nodes[0], nodes[1], nodes[2] }));
         expected = new Arc[]{ a2b, b2c };
         assertEquals(expected.length, path.getArcs().size());
         for (int i = 0; i < expected.length; ++i) {
@@ -147,7 +149,8 @@ public class PathTest {
         Arc[] expected;
 
         // Simple construction
-        path = Path.createShortestPathFromNodes(graph, Arrays.asList(new Node[] { nodes[0], nodes[1], nodes[2] }));
+        path = Path.createShortestPathFromNodes(graph,
+                Arrays.asList(new Node[]{ nodes[0], nodes[1], nodes[2] }));
         expected = new Arc[]{ a2b, b2c };
         assertEquals(expected.length, path.getArcs().size());
         for (int i = 0; i < expected.length; ++i) {