Ticket #17177: 17177.6.patch

new file resources/images/dialogs/add_mvt.svg

@@ +1 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+        xmlns:dc="http://purl.org/dc/elements/1.1/"
+        xmlns:cc="http://creativecommons.org/ns#"
+        xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+        xmlns="http://www.w3.org/2000/svg"
+        xmlns:xlink="http://www.w3.org/1999/xlink"
+        xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+        xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+        width="24"
+        height="24"
+        viewBox="0 0 24 24"
+        id="svg2"
+        version="1.1"
+        inkscape:version="1.0.1 (c497b03c, 2020-09-10)"
+        sodipodi:docname="add_mvt.svg">
+  <defs
+     id="defs4">
+    <linearGradient
+       gradientTransform="translate(4)"
+       gradientUnits="userSpaceOnUse"
+       y2="1049.3622"
+       x2="12"
+       y1="1041.3622"
+       x1="4"
+       id="linearGradient868"
+       xlink:href="#linearGradient866"
+       inkscape:collect="always" />
+    <linearGradient
+       id="linearGradient866"
+       inkscape:collect="always">
+      <stop
+         id="stop862"
+         offset="0"
+         style="stop-color:#dfdfdf;stop-opacity:1" />
+      <stop
+         id="stop864"
+         offset="1"
+         style="stop-color:#949593;stop-opacity:1" />
+    </linearGradient>
+  </defs>
+  <sodipodi:namedview
+     id="base"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageopacity="0"
+     inkscape:pageshadow="2"
+     inkscape:zoom="45.254834"
+     inkscape:cx="11.376506"
+     inkscape:cy="17.057298"
+     inkscape:document-units="px"
+     inkscape:current-layer="layer1"
+     showgrid="true"
+     units="px"
+     inkscape:window-width="1920"
+     inkscape:window-height="955"
+     inkscape:window-x="0"
+     inkscape:window-y="23"
+     inkscape:window-maximized="1"
+     viewbox-height="16"
+     inkscape:document-rotation="0">
+    <inkscape:grid
+       type="xygrid"
+       id="grid4136"
+       originx="0"
+       originy="0"
+       spacingx="1"
+       spacingy="1" />
+  </sodipodi:namedview>
+  <metadata
+     id="metadata7">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+        <dc:title></dc:title>
+        <cc:license
+           rdf:resource="http://creativecommons.org/publicdomain/zero/1.0/" />
+      </cc:Work>
+      <cc:License
+         rdf:about="http://creativecommons.org/publicdomain/zero/1.0/">
+        <cc:permits
+           rdf:resource="http://creativecommons.org/ns#Reproduction" />
+        <cc:permits
+           rdf:resource="http://creativecommons.org/ns#Distribution" />
+        <cc:permits
+           rdf:resource="http://creativecommons.org/ns#DerivativeWorks" />
+      </cc:License>
+    </rdf:RDF>
+  </metadata>
+  <g
+     inkscape:label="Layer 1"
+     inkscape:groupmode="layer"
+     id="layer1"
+     transform="translate(0,-1037.3622)">
+    <rect
+       ry="0.48361239"
+       y="1043.8622"
+       x="5.5"
+       height="3"
+       width="13"
+       id="rect833"
+       style="opacity:1;fill:#c1c2c0;fill-opacity:1;fill-rule:nonzero;stroke:#555753;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0.839909;stroke-opacity:1;paint-order:normal" />
+    <rect
+       transform="rotate(-90)"
+       ry="0.48361239"
+       y="10.5"
+       x="-1051.8622"
+       height="3"
+       width="13"
+       id="rect833-5"
+       style="opacity:1;fill:#c1c2c0;fill-opacity:1;fill-rule:nonzero;stroke:#555753;stroke-width:1;stroke-linecap:round;stroke-linejoin:round;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0.839909;stroke-opacity:1;paint-order:normal" />
+    <path
+       inkscape:connector-curvature="0"
+       id="path852"
+       d="M 6.0000001,1044.3622 H 11 v -5 h 2 v 5 h 5 v 2 h -5 v 5 h -2 v -5 H 6.0000001 Z"
+       style="fill:url(#linearGradient868);fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" />
+    <path
+       style="fill:none;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:round;stroke-opacity:1"
+       d="m 4.5,1060.3625 v -7.5948 l 2,4.3971 2,-4.3971 v 7.5948"
+       id="path894"
+       sodipodi:nodetypes="ccccc" />
+    <path
+       style="fill:none;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       d="m 17.5,1060.3622 v -8"
+       id="path896" />
+    <path
+       style="fill:none;stroke:#000000;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:round;stroke-opacity:1"
+       d="m 15,1052.8622 h 5"
+       id="path898" />
+    <text
+       xml:space="preserve"
+       style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.3042px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Bold';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;fill:#000000;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.894202;stroke-miterlimit:4;stroke-dasharray:none"
+       x="10.59868"
+       y="898.41876"
+       id="text854"
+       transform="scale(0.84728029,1.180247)"><tspan
+         sodipodi:role="line"
+         id="tspan852"
+         x="10.59868"
+         y="898.41876"
+         style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:9.3042px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Bold';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;fill-rule:nonzero;stroke-width:0.894202;stroke-miterlimit:4;stroke-dasharray:none">V</tspan></text>
+  </g>
+</svg>

src/org/openstreetmap/josm/data/cache/JCSCachedTileLoaderJob.java

@@ -1 +1 @@
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.data.cache;
 
+import java.io.File;
+import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.net.HttpURLConnection;
@@ -17 +19 @@
 import java.util.concurrent.TimeUnit;
 import java.util.regex.Matcher;
 
-import org.apache.commons.jcs3.access.behavior.ICacheAccess;
-import org.apache.commons.jcs3.engine.behavior.ICacheElement;
 import org.openstreetmap.josm.data.cache.ICachedLoaderListener.LoadResult;
 import org.openstreetmap.josm.data.imagery.TileJobOptions;
 import org.openstreetmap.josm.data.preferences.IntegerProperty;
@@ -27 +27 @@
 import org.openstreetmap.josm.tools.Logging;
 import org.openstreetmap.josm.tools.Utils;
 
+import org.apache.commons.compress.utils.IOUtils;
+import org.apache.commons.jcs3.access.behavior.ICacheAccess;
+import org.apache.commons.jcs3.engine.behavior.ICacheElement;
+
 /**
  * Generic loader for HTTP based tiles. Uses custom attribute, to check, if entry has expired
  * according to HTTP headers sent with tile. If so, it tries to verify using Etags
@@ -294 +298 @@
         if (attributes == null) {
             attributes = new CacheEntryAttributes();
         }
+        final URL url = this.getUrlNoException();
+        if (url == null) {
+            return false;
+        }
+
+        if (url.getProtocol().contains("http")) {
+            return loadObjectHttp();
+        }
+        if (url.getProtocol().contains("file")) {
+            return loadObjectFile(url);
+        }
+
+        return false;
+    }
+
+    private boolean loadObjectFile(URL url) {
+        String fileName = url.toExternalForm();
+        File file = new File(fileName.substring("file:/".length() - 1));
+        if (!file.exists()) {
+            file = new File(fileName.substring("file://".length() - 1));
+        }
+        try (FileInputStream fileInputStream = new FileInputStream(file)) {
+            cacheData = createCacheEntry(IOUtils.toByteArray(fileInputStream));
+            cache.put(getCacheKey(), cacheData, attributes);
+            return true;
+        } catch (IOException e) {
+            Logging.error(e);
+            attributes.setError(e);
+            attributes.setException(e);
+        }
+        return false;
+    }
+
+    /**
+     * @return true if object was successfully downloaded via http, false, if there was a loading failure
+     */
+    private boolean loadObjectHttp() {
         try {
             // if we have object in cache, and host doesn't support If-Modified-Since nor If-None-Match
             // then just use HEAD request and check returned values
@@ -553 +594 @@
         try {
             return getUrl();
         } catch (IOException e) {
+            Logging.trace(e);
             return null;
         }
     }

src/org/openstreetmap/josm/data/imagery/ImageryInfo.java

@@ -61 +61 @@
         /** A WMS endpoint entry only stores the WMS server info, without layer, which are chosen later by the user. **/
         WMS_ENDPOINT("wms_endpoint"),
         /** WMTS stores GetCapabilities URL. Does not store any information about the layer **/
-        WMTS("wmts");
+        WMTS("wmts"),
+        /** MapBox Vector Tiles entry*/
+        MVT("mvt");
 
         private final String typeString;
 
@@ -654 +656 @@
         defaultMaxZoom = 0;
         defaultMinZoom = 0;
         for (ImageryType type : ImageryType.values()) {
-            Matcher m = Pattern.compile(type.getTypeString()+"(?:\\[(?:(\\d+)[,-])?(\\d+)\\])?:(.*)").matcher(url);
+            Matcher m = Pattern.compile(type.getTypeString()+"(?:\\[(?:(\\d+)[,-])?(\\d+)])?:(.*)").matcher(url);
             if (m.matches()) {
                 this.url = m.group(3);
                 this.sourceType = type;
@@ -669 +671 @@
         }
 
         if (serverProjections.isEmpty()) {
-            Matcher m = Pattern.compile(".*\\{PROJ\\(([^)}]+)\\)\\}.*").matcher(url.toUpperCase(Locale.ENGLISH));
+            Matcher m = Pattern.compile(".*\\{PROJ\\(([^)}]+)\\)}.*").matcher(url.toUpperCase(Locale.ENGLISH));
             if (m.matches()) {
                 setServerProjections(Arrays.asList(m.group(1).split(",", -1)));
             }

src/org/openstreetmap/josm/data/imagery/TMSCachedTileLoaderJob.java

@@ -10 +10 @@
 import java.nio.charset.StandardCharsets;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Optional;
@@ -21 +22 @@
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
-import org.apache.commons.jcs3.access.behavior.ICacheAccess;
 import org.openstreetmap.gui.jmapviewer.Tile;
 import org.openstreetmap.gui.jmapviewer.interfaces.TileJob;
 import org.openstreetmap.gui.jmapviewer.interfaces.TileLoaderListener;
@@ -32 +32 @@
 import org.openstreetmap.josm.data.cache.CacheEntryAttributes;
 import org.openstreetmap.josm.data.cache.ICachedLoaderListener;
 import org.openstreetmap.josm.data.cache.JCSCachedTileLoaderJob;
+import org.openstreetmap.josm.data.imagery.vectortile.VectorTile;
+import org.openstreetmap.josm.data.imagery.vectortile.mapbox.MVTFile;
 import org.openstreetmap.josm.data.preferences.LongProperty;
 import org.openstreetmap.josm.tools.HttpClient;
 import org.openstreetmap.josm.tools.Logging;
 import org.openstreetmap.josm.tools.Utils;
 
+import org.apache.commons.jcs3.access.behavior.ICacheAccess;
+
 /**
  * Class bridging TMS requests to JCS cache requests
  *
@@ -147 +151 @@
     private boolean isNotImage(Map<String, List<String>> headers, int statusCode) {
         if (statusCode == 200 && headers.containsKey("Content-Type") && !headers.get("Content-Type").isEmpty()) {
             String contentType = headers.get("Content-Type").stream().findAny().get();
-            if (contentType != null && !contentType.startsWith("image")) {
+            if (contentType != null && !contentType.startsWith("image") && !MVTFile.MIMETYPE.contains(contentType.toLowerCase(Locale.ROOT))) {
                 Logging.warn("Image not returned for tile: " + url + " content type was: " + contentType);
                 // not an image - do not store response in cache, so next time it will be queried again from the server
                 return true;
@@ -321 +325 @@
             if (content.length > 0) {
                 try (ByteArrayInputStream in = new ByteArrayInputStream(content)) {
                     tile.loadImage(in);
-                    if (tile.getImage() == null) {
+                    if ((!(tile instanceof VectorTile) && tile.getImage() == null)
+                        || ((tile instanceof VectorTile) && !tile.isLoaded())) {
                         String s = new String(content, StandardCharsets.UTF_8);
                         Matcher m = SERVICE_EXCEPTION_PATTERN.matcher(s);
                         if (m.matches()) {

new file src/org/openstreetmap/josm/data/imagery/vectortile/mapbox/Command.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.imagery.vectortile.mapbox;
+
+/**
+ * Command integers for Mapbox Vector Tiles
+ * @author Taylor Smock
+ * @since xxx
+ */
+public enum Command {
+    /**
+     * For {@link GeometryTypes#POINT}, each {@link #MoveTo} is a new point.
+     * For {@link GeometryTypes#LINESTRING} and {@link GeometryTypes#POLYGON}, each {@link #MoveTo} is a new geometry of the same type.
+     */
+    MoveTo((byte) 1, (byte) 2),
+    /**
+     * While not explicitly prohibited for {@link GeometryTypes#POINT}, it should be ignored.
+     * For {@link GeometryTypes#LINESTRING} and {@link GeometryTypes#POLYGON}, each {@link #LineTo} extends that geometry.
+     */
+    LineTo((byte) 2, (byte) 2),
+    /**
+     * This is only explicitly valid for {@link GeometryTypes#POLYGON}. It closes the {@link GeometryTypes#POLYGON}.
+     */
+    ClosePath((byte) 7, (byte) 0);
+
+    private final byte id;
+    private final byte parameters;
+
+    Command(byte id, byte parameters) {
+        this.id = id;
+        this.parameters = parameters;
+    }
+
+    /**
+     * Get the command id
+     * @return The id
+     */
+    public byte getId() {
+        return this.id;
+    }
+
+    /**
+     * Get the number of parameters
+     * @return The number of parameters
+     */
+    public byte getParameterNumber() {
+        return this.parameters;
+    }
+}

new file src/org/openstreetmap/josm/data/imagery/vectortile/mapbox/CommandInteger.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.imagery.vectortile.mapbox;
+
+import java.util.stream.Stream;
+
+/**
+ * An indicator for a command to be executed
+ * @author Taylor Smock
+ * @since xxx
+ */
+public class CommandInteger {
+    private final Command type;
+    private final short[] parameters;
+    private int added;
+
+    /**
+     * Create a new command
+     * @param command the command (treated as an unsigned int)
+     */
+    public CommandInteger(final int command) {
+        // Technically, the int is unsigned, but it is easier to work with the long
+        final long unsigned = Integer.toUnsignedLong(command);
+        this.type = Stream.of(Command.values()).filter(e -> e.getId() == (unsigned & 0x7)).findAny()
+                .orElseThrow(InvalidMapboxVectorTileException::new);
+        // This is safe, since we are shifting right 3 when we converted an int to a long (for unsigned).
+        // So we <i>cannot</i> lose anything.
+        final int operationsInt = (int) (unsigned >> 3);
+        this.parameters = new short[operationsInt * this.type.getParameterNumber()];
+    }
+
+    /**
+     * Add a parameter
+     * @param parameterInteger The parameter to add (converted to {@link short}).
+     */
+    public void addParameter(Number parameterInteger) {
+        this.parameters[added++] = parameterInteger.shortValue();
+    }
+
+    /**
+     * Get the operations for the command
+     * @return The operations
+     */
+    public short[] getOperations() {
+        return this.parameters;
+    }
+
+    /**
+     * Get the command type
+     * @return the command type
+     */
+    public Command getType() {
+        return this.type;
+    }
+
+    /**
+     * Get the expected parameter length
+     * @return The expected parameter size
+     */
+    public boolean hasAllExpectedParameters() {
+            return this.added >= this.parameters.length;
+    }
+}

new file src/org/openstreetmap/josm/data/imagery/vectortile/mapbox/Feature.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.imagery.vectortile.mapbox;
+
+import java.io.IOException;
+import java.text.NumberFormat;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.openstreetmap.josm.data.osm.TagMap;
+import org.openstreetmap.josm.data.protobuf.ProtoBufPacked;
+import org.openstreetmap.josm.data.protobuf.ProtoBufParser;
+import org.openstreetmap.josm.data.protobuf.ProtoBufRecord;
+import org.openstreetmap.josm.tools.Utils;
+
+/**
+ * A Feature for a {@link Layer}
+ *
+ * @author Taylor Smock
+ * @since xxx
+ */
+public class Feature {
+    private static final byte ID_FIELD = 1;
+    private static final byte TAG_FIELD = 2;
+    private static final byte GEOMETRY_TYPE_FIELD = 3;
+    private static final byte GEOMETRY_FIELD = 4;
+    /**
+     * The geometry of the feature. Required.
+     */
+    private final List<CommandInteger> geometry = new ArrayList<>();
+
+    /**
+     * The geometry type of the feature. Required.
+     */
+    private final GeometryTypes geometryType;
+    /**
+     * The id of the feature. Optional.
+     */
+    // Technically, uint64
+    private final long id;
+    /**
+     * The tags of the feature. Optional.
+     */
+    private TagMap tags;
+
+    /**
+     * Create a new Feature
+     *
+     * @param layer  The layer the feature is part of (required for tags)
+     * @param record The record to create the feature from
+     * @throws IOException - if an IO error occurs
+     */
+    public Feature(Layer layer, ProtoBufRecord record) throws IOException {
+        long tId = 0;
+        GeometryTypes geometryTypeTemp = GeometryTypes.UNKNOWN;
+        String key = null;
+        try (ProtoBufParser parser = new ProtoBufParser(record.getBytes())) {
+            while (parser.hasNext()) {
+                try (ProtoBufRecord next = new ProtoBufRecord(parser)) {
+                    if (next.getField() == TAG_FIELD) {
+                        if (tags == null) {
+                            tags = new TagMap();
+                        }
+                        // This is packed in v1 and v2
+                        ProtoBufPacked packed = new ProtoBufPacked(next.getBytes());
+                        for (Number number : packed.getArray()) {
+                            key = parseTagValue(key, layer, number);
+                        }
+                    } else if (next.getField() == GEOMETRY_FIELD) {
+                        // This is packed in v1 and v2
+                        ProtoBufPacked packed = new ProtoBufPacked(next.getBytes());
+                        CommandInteger currentCommand = null;
+                        for (Number number : packed.getArray()) {
+                            if (currentCommand != null && currentCommand.hasAllExpectedParameters()) {
+                                currentCommand = null;
+                            }
+                            if (currentCommand == null) {
+                                currentCommand = new CommandInteger(number.intValue());
+                                this.geometry.add(currentCommand);
+                            } else {
+                                currentCommand.addParameter(ParameterInteger.decode(number.intValue()));
+                            }
+                        }
+                        // TODO fallback to non-packed
+                    } else if (next.getField() == GEOMETRY_TYPE_FIELD) {
+                        geometryTypeTemp = GeometryTypes.values()[next.asUnsignedVarInt().intValue()];
+                    } else if (next.getField() == ID_FIELD) {
+                        tId = next.asUnsignedVarInt().longValue();
+                    }
+                }
+            }
+        }
+        this.id = tId;
+        this.geometryType = geometryTypeTemp;
+        record.close();
+    }
+
+    /**
+     * Parse a tag value
+     *
+     * @param key    The current key (or {@code null}, if {@code null}, the returned value will be the new key)
+     * @param layer  The layer with key/value information
+     * @param number The number to get the value from
+     * @return The new key (if {@code null}, then a value was parsed and added to tags)
+     */
+    private String parseTagValue(String key, Layer layer, Number number) {
+        if (key == null) {
+            key = layer.getKey(number.intValue());
+        } else {
+            Object value = layer.getValue(number.intValue());
+            if (value instanceof Double || value instanceof Float) {
+                // reset grouping if the instance is a singleton
+                final NumberFormat numberFormat = NumberFormat.getNumberInstance();
+                final boolean grouping = numberFormat.isGroupingUsed();
+                try {
+                    numberFormat.setGroupingUsed(false);
+                    this.tags.put(key, numberFormat.format(value));
+                } finally {
+                    numberFormat.setGroupingUsed(grouping);
+                }
+            } else {
+                this.tags.put(key, Utils.intern(value.toString()));
+            }
+            key = null;
+        }
+        return key;
+    }
+
+    /**
+     * Get the geometry instructions
+     *
+     * @return The geometry
+     */
+    public List<CommandInteger> getGeometry() {
+        return this.geometry;
+    }
+
+    /**
+     * Get the geometry type
+     *
+     * @return The {@link GeometryTypes}
+     */
+    public GeometryTypes getGeometryType() {
+        return this.geometryType;
+    }
+
+    /**
+     * Get the id of the object
+     *
+     * @return The unique id in the layer, or 0.
+     */
+    public long getId() {
+        return this.id;
+    }
+
+    /**
+     * Get the tags
+     *
+     * @return A tag map
+     */
+    public TagMap getTags() {
+        return this.tags;
+    }
+}

new file src/org/openstreetmap/josm/data/imagery/vectortile/mapbox/Geometry.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.imagery.vectortile.mapbox;
+
+import static org.openstreetmap.josm.tools.I18n.tr;
+
+import java.awt.Shape;
+import java.awt.geom.Area;
+import java.awt.geom.Ellipse2D;
+import java.awt.geom.Path2D;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+
+/**
+ * A class to generate geometry for a vector tile
+ * @author Taylor Smock
+ * @since xxx
+ */
+public class Geometry {
+    private static final byte CIRCLE_SIZE = 0;
+    final Collection<Shape> shapes = new HashSet<>();
+    private final Feature feature;
+
+    /**
+     * Create a {@link Geometry} for a {@link Feature}
+     * @param feature the {@link Feature} for the geometry
+     */
+    public Geometry(final Feature feature) {
+        this.feature = feature;
+        final GeometryTypes geometryType = this.feature.getGeometryType();
+        final List<CommandInteger> commands = this.feature.getGeometry();
+        final byte circleSize = CIRCLE_SIZE;
+        if (geometryType == GeometryTypes.POINT) {
+            for (CommandInteger command : commands) {
+                final short[] operations = command.getOperations();
+                // Each MoveTo command is a new point
+                if (command.getType() == Command.MoveTo && operations.length % 2 == 0) {
+                    for (int i = 0; i < operations.length / 2; i++) {
+                        // move left/up by 1/2 circleSize, so that the circle is centered
+                        shapes.add(new Ellipse2D.Float(operations[2 * i] - circleSize / 2f,
+                                operations[2 * i + 1] - circleSize / 2f, circleSize, circleSize));
+                    }
+                } else {
+                    throw new IllegalArgumentException(tr("{0} with {1} arguments is not understood", geometryType, operations.length));
+                }
+            }
+        } else if (geometryType == GeometryTypes.LINESTRING || geometryType == GeometryTypes.POLYGON) {
+            Path2D.Float line = null;
+            Area area = null;
+            // MVT uses delta encoding. Each feature starts at (0, 0).
+            double x = 0;
+            double y = 0;
+            // Area is used to determine the inner/outer of a polygon
+            double areaAreaSq = 0;
+            for (CommandInteger command : commands) {
+                final short[] operations = command.getOperations();
+                // Technically, there is no reason why there can be multiple MoveTo operations in one command, but that is undefined behavior
+                if (command.getType() == Command.MoveTo && operations.length == 2) {
+                    areaAreaSq = 0;
+                    x += operations[0];
+                    y += operations[1];
+                    line = new Path2D.Float();
+                    line.moveTo(x, y);
+                    shapes.add(line);
+                } else if (command.getType() == Command.LineTo && operations.length % 2 == 0 && line != null) {
+                    for (int i = 0; i < operations.length / 2; i++) {
+                        final double lx = x;
+                        final double ly = y;
+                        x += operations[2 * i];
+                        y += operations[2 * i + 1];
+                        areaAreaSq += lx * y - x * ly;
+                        line.lineTo(x, y);
+                    }
+                // ClosePath should only be used with Polygon geometry
+                } else if (geometryType == GeometryTypes.POLYGON && command.getType() == Command.ClosePath && line != null) {
+                    // ClosePath specifically does not change the cursor position
+                    line.closePath();
+                    line.setWindingRule(Path2D.WIND_NON_ZERO);
+                    shapes.remove(line);
+                    if (area == null) {
+                        area = new Area(line);
+                        shapes.add(area);
+                    } else {
+                        Area nArea = new Area(line);
+                        // SonarLint thinks that this is never > 0. It can be.
+                        if (areaAreaSq > 0) {
+                            area.add(nArea);
+                        } else {
+                            area.exclusiveOr(nArea);
+                        }
+                    }
+                } else {
+                    throw new IllegalArgumentException(tr("{0} with {1} arguments is not understood", geometryType, operations.length));
+                }
+            }
+        }
+    }
+
+    /**
+     * Get the feature for this geometry
+     * @return The feature
+     */
+    public Feature getFeature() {
+        return this.feature;
+    }
+
+    /**
+     * Get the shapes to draw this geometry with
+     * @return A collection of shapes
+     */
+    public Collection<Shape> getShapes() {
+        return Collections.unmodifiableCollection(this.shapes);
+    }
+}

new file src/org/openstreetmap/josm/data/imagery/vectortile/mapbox/GeometryTypes.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.imagery.vectortile.mapbox;
+
+/**
+ * Geometry types used by Mapbox Vector Tiles
+ * @author Taylor Smock
+ * @since xxx
+ */
+public enum GeometryTypes {
+    /** May be ignored */
+    UNKNOWN((byte) 0),
+    /** May be a point or a multipoint geometry. Uses <i>only</i> {@link Command#MoveTo}. Multiple {@link Command#MoveTo}
+     * indicates that it is a multi-point object. */
+    POINT((byte) 1),
+    /** May be a line or a multiline geometry. Each line {@link Command#MoveTo} and one or more {@link Command#LineTo}. */
+    LINESTRING((byte) 2),
+    /** May be a polygon or a multipolygon. Each ring uses a {@link Command#MoveTo}, one or more {@link Command#LineTo},
+     * and one {@link Command#ClosePath} command. See {@link Ring}s. */
+    POLYGON((byte) 3);
+
+    private final byte id;
+    GeometryTypes(byte id) {
+        this.id = id;
+    }
+
+    /**
+     * Get the id for the geometry type
+     * @return The id
+     */
+    public byte getId() {
+        return this.id;
+    }
+
+    /**
+     * Rings used by {@link GeometryTypes#POLYGON}
+     * @author Taylor Smock
+     */
+    public enum Ring {
+        /** A ring that goes in the clockwise direction */
+        ExteriorRing,
+        /** A ring that goes in the anti-clockwise direction */
+        InteriorRing
+    }
+}

new file src/org/openstreetmap/josm/data/imagery/vectortile/mapbox/InvalidMapboxVectorTileException.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.imagery.vectortile.mapbox;
+
+/**
+ * Thrown when a mapbox vector tile does not match specifications.
+ *
+ * @author Taylor Smock
+ * @since xxx
+ */
+public class InvalidMapboxVectorTileException extends RuntimeException {
+    /**
+     * Create a default {@link InvalidMapboxVectorTileException}.
+     */
+    public InvalidMapboxVectorTileException() {
+        super();
+    }
+
+    /**
+     * Create a new {@link InvalidMapboxVectorTile} exception with a message
+     * @param message The message
+     */
+    public InvalidMapboxVectorTileException(final String message) {
+        super(message);
+    }
+}

new file src/org/openstreetmap/josm/data/imagery/vectortile/mapbox/Layer.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.imagery.vectortile.mapbox;
+import static org.openstreetmap.josm.tools.I18n.tr;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+import org.openstreetmap.josm.data.protobuf.ProtoBufParser;
+import org.openstreetmap.josm.data.protobuf.ProtoBufRecord;
+import org.openstreetmap.josm.tools.Logging;
+
+/**
+ * A Mapbox Vector Tile Layer
+ * @author Taylor Smock
+ * @since xxx
+ */
+public class Layer {
+    private static final class ValueFields<T> {
+        static final ValueFields<String> STRING = new ValueFields<>(1, ProtoBufRecord::asString);
+        static final ValueFields<Float> FLOAT = new ValueFields<>(2, ProtoBufRecord::asFloat);
+        static final ValueFields<Double> DOUBLE = new ValueFields<>(3, ProtoBufRecord::asDouble);
+        static final ValueFields<Number> INT64 = new ValueFields<>(4, ProtoBufRecord::asUnsignedVarInt);
+        // This may have issues if there are actual uint_values (i.e., more than {@link Long#MAX_VALUE})
+        static final ValueFields<Number> UINT64 = new ValueFields<>(5, ProtoBufRecord::asUnsignedVarInt);
+        static final ValueFields<Number> SINT64 = new ValueFields<>(6, ProtoBufRecord::asSignedVarInt);
+        static final ValueFields<Boolean> BOOL = new ValueFields<>(7, r -> r.asUnsignedVarInt().longValue() != 0);
+
+        /**
+         * A collection of methods to map a record to a type
+         */
+        public static final Collection<ValueFields<?>> MAPPERS =
+          Collections.unmodifiableList(Arrays.asList(STRING, FLOAT, DOUBLE, INT64, UINT64, SINT64, BOOL));
+
+        private final byte field;
+        private final Function<ProtoBufRecord, T> conversion;
+        private ValueFields(int field, Function<ProtoBufRecord, T> conversion) {
+            this.field = (byte) field;
+            this.conversion = conversion;
+        }
+
+        /**
+         * Get the field identifier for the value
+         * @return The identifier
+         */
+        public byte getField() {
+            return this.field;
+        }
+
+        /**
+         * Convert a protobuf record to a value
+         * @param protobufRecord The record to convert
+         * @return the converted value
+         */
+        public T convertValue(ProtoBufRecord protobufRecord) {
+            return this.conversion.apply(protobufRecord);
+        }
+    }
+
+    /** The field value for a layer (in {@link ProtoBufRecord#getField}) */
+    public static final byte LAYER_FIELD = 3;
+    private static final byte VERSION_FIELD = 15;
+    private static final byte NAME_FIELD = 1;
+    private static final byte FEATURE_FIELD = 2;
+    private static final byte KEY_FIELD = 3;
+    private static final byte VALUE_FIELD = 4;
+    private static final byte EXTENT_FIELD = 5;
+    /** The default extent for a vector tile */
+    static final int DEFAULT_EXTENT = 4096;
+    private static final byte DEFAULT_VERSION = 1;
+    /** This is <i>technically</i> an integer, but there are currently only two major versions (1, 2). Required. */
+    private final byte version;
+    /** A unique name for the layer. This <i>must</i> be unique on a per-tile basis. Required. */
+    private final String name;
+
+    /** The extent of the tile, typically 4096. Required. */
+    private final int extent;
+
+    /** A list of unique keys. Order is important. Optional. */
+    private final List<String> keyList = new ArrayList<>();
+    /** A list of unique values. Order is important. Optional. */
+    private final List<Object> valueList = new ArrayList<>();
+    /** The actual features of this layer in this tile */
+    private final List<Feature> featureCollection;
+    /** The shapes to use to draw this layer */
+    private final List<Geometry> geometryCollection;
+
+    /**
+     * Create a layer from a collection of records
+     * @param records The records to convert to a layer
+     * @throws IOException - if an IO error occurs
+     */
+    public Layer(Collection<ProtoBufRecord> records) throws IOException {
+        // Do the unique required fields first
+        Map<Integer, List<ProtoBufRecord>> sorted = records.stream().collect(Collectors.groupingBy(ProtoBufRecord::getField));
+        this.version = sorted.get((int) VERSION_FIELD).parallelStream().map(ProtoBufRecord::asUnsignedVarInt).map(Number::byteValue)
+                .findFirst().orElse(DEFAULT_VERSION);
+        // Per spec, we cannot continue past this until we have checked the version number
+        if (this.version != 1 && this.version != 2) {
+            throw new IllegalArgumentException(tr("We do not understand version {0} of the vector tile specification", this.version));
+        }
+        this.name = sorted.getOrDefault((int) NAME_FIELD, Collections.emptyList()).parallelStream().map(ProtoBufRecord::asString).findFirst()
+                .orElseThrow(() -> new IllegalArgumentException(tr("Vector tile layers must have a layer name")));
+        this.extent = sorted.getOrDefault((int) EXTENT_FIELD, Collections.emptyList()).parallelStream().map(ProtoBufRecord::asSignedVarInt)
+                .map(Number::intValue).findAny().orElse(DEFAULT_EXTENT);
+
+        sorted.getOrDefault((int) KEY_FIELD, Collections.emptyList()).parallelStream().map(ProtoBufRecord::asString)
+                .forEachOrdered(this.keyList::add);
+        sorted.getOrDefault((int) VALUE_FIELD, Collections.emptyList()).parallelStream().map(ProtoBufRecord::getBytes)
+                .map(ProtoBufParser::new).map(parser1 -> {
+                    try {
+                        return new ProtoBufRecord(parser1);
+                    } catch (IOException e) {
+                        Logging.error(e);
+                        return null;
+                    }
+                })
+                .filter(Objects::nonNull)
+                .map(value -> ValueFields.MAPPERS.parallelStream()
+                        .filter(v -> v.getField() == value.getField())
+                        .map(v -> v.convertValue(value)).findFirst()
+                        .orElseThrow(() -> new IllegalArgumentException(tr("Unknown field in vector tile layer value ({0})", value.getField()))))
+                .forEachOrdered(this.valueList::add);
+        Collection<IOException> exceptions = new HashSet<>(0);
+        this.featureCollection = sorted.getOrDefault((int) FEATURE_FIELD, Collections.emptyList()).parallelStream().map(feature -> {
+            try {
+                return new Feature(this, feature);
+            } catch (IOException e) {
+                exceptions.add(e);
+            }
+            return null;
+        }).collect(Collectors.toList());
+        this.geometryCollection = this.featureCollection.stream().map(Geometry::new).collect(Collectors.toList());
+        if (!exceptions.isEmpty()) {
+            throw exceptions.iterator().next();
+        }
+        // Cleanup bytes (for memory)
+        for (ProtoBufRecord record : records) {
+            record.close();
+        }
+    }
+
+    /**
+     * Get all the records from a array of bytes
+     * @param bytes The byte information
+     * @return All the protobuf records
+     * @throws IOException If there was an error reading the bytes (unlikely)
+     */
+    private static Collection<ProtoBufRecord> getAllRecords(byte[] bytes) throws IOException {
+        try (ProtoBufParser parser = new ProtoBufParser(bytes)) {
+            return parser.allRecords();
+        }
+    }
+
+    /**
+     * Create a new layer
+     * @param bytes The bytes that the layer comes from
+     * @throws IOException - if an IO error occurs
+     */
+    public Layer(byte[] bytes) throws IOException {
+        this(getAllRecords(bytes));
+    }
+
+    /**
+     * Get the extent of the tile
+     * @return The layer extent
+     */
+    public int getExtent() {
+        return this.extent;
+    }
+
+    /**
+     * Get the feature on this layer
+     * @return the features
+     */
+    public Collection<Feature> getFeatures() {
+        return Collections.unmodifiableCollection(this.featureCollection);
+    }
+
+    /**
+     * Get the geometry for this layer
+     * @return The geometry
+     */
+    public Collection<Geometry> getGeometry() {
+        return Collections.unmodifiableCollection(this.geometryCollection);
+    }
+
+    /**
+     * Get a specified key
+     * @param index The index in the key list
+     * @return The actual key
+     */
+    public String getKey(int index) {
+        return this.keyList.get(index);
+    }
+
+    /**
+     * Get the name of the layer
+     * @return The layer name
+     */
+    public String getName() {
+        return this.name;
+    }
+
+    /**
+     * Get a specified value
+     * @param index The index in the value list
+     * @return The actual value. This can be a {@link String}, {@link Boolean}, {@link Integer}, or {@link Float} value.
+     */
+    public Object getValue(int index) {
+        return this.valueList.get(index);
+    }
+
+    /**
+     * Get the MapBox Vector Tile version specification for this layer
+     * @return The version of the MapBox Vector Tile specification
+     */
+    public byte getVersion() {
+        return this.version;
+    }
+}

new file src/org/openstreetmap/josm/data/imagery/vectortile/mapbox/MapBoxVectorCachedTileLoader.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.imagery.vectortile.mapbox;
+
+import java.util.concurrent.ThreadPoolExecutor;
+
+import org.openstreetmap.gui.jmapviewer.Tile;
+import org.openstreetmap.gui.jmapviewer.interfaces.CachedTileLoader;
+import org.openstreetmap.gui.jmapviewer.interfaces.TileJob;
+import org.openstreetmap.gui.jmapviewer.interfaces.TileLoader;
+import org.openstreetmap.gui.jmapviewer.interfaces.TileLoaderListener;
+import org.openstreetmap.gui.jmapviewer.interfaces.TileSource;
+import org.openstreetmap.josm.data.cache.BufferedImageCacheEntry;
+import org.openstreetmap.josm.data.cache.JCSCachedTileLoaderJob;
+import org.openstreetmap.josm.data.imagery.TMSCachedTileLoader;
+import org.openstreetmap.josm.data.imagery.TileJobOptions;
+import org.openstreetmap.josm.data.preferences.IntegerProperty;
+import org.openstreetmap.josm.tools.CheckParameterUtil;
+
+import org.apache.commons.jcs3.access.behavior.ICacheAccess;
+
+/**
+ * A TileLoader class for MVT tiles
+ * @author Taylor Smock
+ * @since xxx
+ */
+public class MapBoxVectorCachedTileLoader implements TileLoader, CachedTileLoader {
+    protected final ICacheAccess<String, BufferedImageCacheEntry> cache;
+    protected final TileLoaderListener listener;
+    protected final TileJobOptions options;
+    private static final IntegerProperty THREAD_LIMIT =
+            new IntegerProperty("imagery.vector.mvtloader.maxjobs", TMSCachedTileLoader.THREAD_LIMIT.getDefaultValue());
+    private static final ThreadPoolExecutor DEFAULT_DOWNLOAD_JOB_DISPATCHER =
+            TMSCachedTileLoader.getNewThreadPoolExecutor("MVT-downloader-%d", THREAD_LIMIT.get());
+
+    /**
+     * Constructor
+     * @param listener          called when tile loading has finished
+     * @param cache             of the cache
+     * @param options           tile job options
+     */
+    public MapBoxVectorCachedTileLoader(TileLoaderListener listener, ICacheAccess<String, BufferedImageCacheEntry> cache,
+           TileJobOptions options) {
+        CheckParameterUtil.ensureParameterNotNull(cache, "cache");
+        this.cache = cache;
+        this.options = options;
+        this.listener = listener;
+    }
+
+    @Override
+    public void clearCache(TileSource source) {
+        this.cache.remove(source.getName() + ':');
+    }
+
+    @Override
+    public TileJob createTileLoaderJob(Tile tile) {
+        return new MapBoxVectorCachedTileLoaderJob(
+                listener,
+                tile,
+                cache,
+                options,
+                getDownloadExecutor());
+    }
+
+    @Override
+    public void cancelOutstandingTasks() {
+        final ThreadPoolExecutor executor = getDownloadExecutor();
+        executor.getQueue().stream().filter(executor::remove).filter(MapBoxVectorCachedTileLoaderJob.class::isInstance)
+                .map(MapBoxVectorCachedTileLoaderJob.class::cast).forEach(JCSCachedTileLoaderJob::handleJobCancellation);
+    }
+
+    @Override
+    public boolean hasOutstandingTasks() {
+        return getDownloadExecutor().getTaskCount() > getDownloadExecutor().getCompletedTaskCount();
+    }
+
+    private static ThreadPoolExecutor getDownloadExecutor() {
+        return DEFAULT_DOWNLOAD_JOB_DISPATCHER;
+    }
+}

new file src/org/openstreetmap/josm/data/imagery/vectortile/mapbox/MapBoxVectorCachedTileLoaderJob.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.imagery.vectortile.mapbox;
+
+import java.util.concurrent.ThreadPoolExecutor;
+
+import org.openstreetmap.gui.jmapviewer.Tile;
+import org.openstreetmap.gui.jmapviewer.interfaces.TileLoaderListener;
+import org.openstreetmap.josm.data.cache.BufferedImageCacheEntry;
+import org.openstreetmap.josm.data.imagery.TMSCachedTileLoaderJob;
+import org.openstreetmap.josm.data.imagery.TileJobOptions;
+
+import org.apache.commons.jcs3.access.behavior.ICacheAccess;
+
+/**
+ * Bridge to JCS cache for MVT tiles
+ * @author Taylor Smock
+ * @since xxx
+ */
+public class MapBoxVectorCachedTileLoaderJob extends TMSCachedTileLoaderJob {
+
+    public MapBoxVectorCachedTileLoaderJob(TileLoaderListener listener, Tile tile,
+            ICacheAccess<String, BufferedImageCacheEntry> cache, TileJobOptions options,
+            ThreadPoolExecutor downloadExecutor) {
+        super(listener, tile, cache, options, downloadExecutor);
+    }
+}

new file src/org/openstreetmap/josm/data/imagery/vectortile/mapbox/MapboxVectorTileSource.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.imagery.vectortile.mapbox;
+import static org.openstreetmap.josm.tools.I18n.tr;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Collection;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+import javax.json.Json;
+import javax.json.JsonException;
+import javax.json.JsonReader;
+
+import org.openstreetmap.josm.data.imagery.ImageryInfo;
+import org.openstreetmap.josm.data.imagery.JosmTemplatedTMSTileSource;
+import org.openstreetmap.josm.data.imagery.vectortile.mapbox.style.MapBoxVectorStyle;
+import org.openstreetmap.josm.data.imagery.vectortile.mapbox.style.Source;
+import org.openstreetmap.josm.gui.ExtendedDialog;
+import org.openstreetmap.josm.gui.MainApplication;
+import org.openstreetmap.josm.gui.util.GuiHelper;
+import org.openstreetmap.josm.gui.widgets.JosmComboBox;
+import org.openstreetmap.josm.io.CachedFile;
+import org.openstreetmap.josm.tools.Logging;
+
+/**
+ * Tile Source handling for Mapbox Vector Tile sources
+ * @author Taylor Smock
+ * @since xxx
+ */
+public class MapboxVectorTileSource extends JosmTemplatedTMSTileSource {
+    private final MapBoxVectorStyle styleSource;
+
+    public MapboxVectorTileSource(ImageryInfo info) {
+        super(info);
+        MapBoxVectorStyle mapBoxVectorStyle = null;
+        try (CachedFile style = new CachedFile(info.getUrl());
+          InputStream inputStream = style.getInputStream();
+          JsonReader reader = Json.createReader(inputStream)) {
+            reader.readObject();
+            // OK, we have a stylesheet
+            mapBoxVectorStyle = MapBoxVectorStyle.getMapBoxVectorStyle(info.getUrl());
+        } catch (IOException | JsonException e) {
+            Logging.trace(e);
+        }
+        this.styleSource = mapBoxVectorStyle;
+        if (this.styleSource != null) {
+            final Source source;
+            List<Source> sources = this.styleSource.getSources().keySet().stream().filter(Objects::nonNull)
+              .collect(Collectors.toList());
+            if (sources.size() == 1) {
+                source = sources.get(0);
+
+            } else if (!sources.isEmpty()) {
+                // Ask user what source they want.
+                source = GuiHelper.runInEDTAndWaitAndReturn(() -> {
+                    SelectLayerDialog dialog = new SelectLayerDialog(sources);
+                    dialog.showDialog();
+                    return dialog.getSource();
+                });
+            } else {
+                // Umm. What happened?
+                throw new InvalidMapboxVectorTileException(tr("Cannot understand style source: {0}", info.getUrl()));
+            }
+            this.name = name + ": " + source.getName();
+            // There can technically be multiple URL's for this field; unfortunately, JOSM can only handle one right now.
+            this.baseUrl = source.getUrls().get(0);
+            this.minZoom = source.getMinZoom();
+            this.maxZoom = source.getMaxZoom();
+            if (source.getAttributionText() != null) {
+                this.setAttributionText(source.getAttributionText());
+            }
+        }
+    }
+
+    private static class SelectLayerDialog extends ExtendedDialog {
+        private final JosmComboBox<Source> comboBox;
+
+        /**
+         * Create a dialog to show the possible sources
+         * @param sources The sources to show
+         */
+        SelectLayerDialog(Collection<Source> sources) {
+            super(MainApplication.getMainFrame(), tr("Select Vector Tile Layers"), tr("Add layers"));
+            this.comboBox = new JosmComboBox<>(sources.toArray(new Source[0]));
+            this.comboBox.setSelectedIndex(0);
+            setContent(comboBox);
+        }
+
+        /**
+         * Get the selected source
+         * @return The selected source
+         */
+        public Source getSource() {
+            Source selected = (Source) this.comboBox.getSelectedItem();
+            return selected != null ? selected : this.comboBox.getItemAt(0);
+        }
+    }
+
+    /**
+     * Get the style source for this Vector Tile source
+     * @return The source to use for styling
+     */
+    public MapBoxVectorStyle getStyleSource() {
+        return this.styleSource;
+    }
+}

new file src/org/openstreetmap/josm/data/imagery/vectortile/mapbox/MVTFile.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.imagery.vectortile.mapbox;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Items that MAY be used to figure out if a file or server response MAY BE a Mapbox Vector Tile
+ * @author Taylor Smock
+ * @since xxx
+ */
+public final class MVTFile {
+    /**
+     * Extensions for Mapbox Vector Tiles.
+     * This is a SHOULD, <i>not</i> a MUST.
+     */
+    public static final List<String> EXTENSION = Collections.unmodifiableList(Arrays.asList("mvt"));
+
+    /**
+     * mimetypes for Mapbox Vector Tiles
+     * This is a SHOULD, <i>not</i> a MUST.
+     */
+    public static final List<String> MIMETYPE = Collections.unmodifiableList(Arrays.asList("application/vnd.mapbox-vector-tile"));
+
+    /**
+     * The default projection. This is Web Mercator, per specification.
+     */
+    public static final String DEFAULT_PROJECTION = "EPSG:3857";
+
+    private MVTFile() {
+        // Hide the constructor
+    }
+}

new file src/org/openstreetmap/josm/data/imagery/vectortile/mapbox/MVTTile.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.imagery.vectortile.mapbox;
+
+import java.awt.Graphics;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+import org.openstreetmap.gui.jmapviewer.Tile;
+import org.openstreetmap.gui.jmapviewer.interfaces.TileSource;
+import org.openstreetmap.josm.data.imagery.vectortile.VectorTile;
+import org.openstreetmap.josm.data.protobuf.ProtoBufParser;
+import org.openstreetmap.josm.data.protobuf.ProtoBufRecord;
+import org.openstreetmap.josm.tools.ListenerList;
+import org.openstreetmap.josm.tools.Logging;
+
+/**
+ * A class for MapBox Vector Tiles
+ *
+ * @author Taylor Smock
+ * @since xxx
+ */
+public class MVTTile extends Tile implements VectorTile {
+    private final ListenerList<TileListener> listenerList = ListenerList.create();
+    private Collection<Layer> layers;
+    private int extent = Layer.DEFAULT_EXTENT;
+
+    /**
+     * Create a new Tile
+     * @param source The source of the tile
+     * @param xtile The x coordinate for the tile
+     * @param ytile The y coordinate for the tile
+     * @param zoom The zoom for the tile
+     */
+    public MVTTile(TileSource source, int xtile, int ytile, int zoom) {
+        super(source, xtile, ytile, zoom);
+    }
+
+    @Override
+    public void paint(final Graphics g, final int x, final int y) {
+        this.paint(g, x, y, 256, 256);
+    }
+
+    @Override
+    public void loadImage(final InputStream inputStream) throws IOException {
+        if (this.image == null || this.image == Tile.LOADING_IMAGE || this.image == Tile.ERROR_IMAGE) {
+            this.initLoading();
+            ProtoBufParser parser = new ProtoBufParser(inputStream);
+            Collection<ProtoBufRecord> protoBufRecords = parser.allRecords();
+            this.layers = new HashSet<>();
+            this.layers = protoBufRecords.stream().map(record -> {
+                Layer mvtLayer = null;
+                if (record.getField() == Layer.LAYER_FIELD) {
+                    try (ProtoBufParser tParser = new ProtoBufParser(record.getBytes())) {
+                        mvtLayer = new Layer(tParser.allRecords());
+                    } catch (IOException e) {
+                        Logging.error(e);
+                    } finally {
+                        // Cleanup bytes
+                        record.close();
+                    }
+                }
+                return mvtLayer;
+            }).collect(Collectors.toCollection(HashSet::new));
+            this.extent = layers.stream().map(Layer::getExtent).max(Integer::compare).orElse(Layer.DEFAULT_EXTENT);
+            // TODO figure out a better way to free memory
+            this.finishLoading();
+            this.listenerList.fireEvent(event -> event.finishedLoading(this));
+        }
+    }
+
+    @Override
+    public Collection<Layer> getLayers() {
+        return this.layers;
+    }
+
+    @Override
+    public int getExtent() {
+        return this.extent;
+    }
+
+    /**
+     * Add a tile loader finisher listener
+     *
+     * @param listener The listener to add
+     */
+    public void addTileLoaderFinisher(TileListener listener) {
+        // Add as weak listeners since we don't want to keep unnecessary references.
+        this.listenerList.addWeakListener(listener);
+    }
+
+    /**
+     * A class that can be notified that a tile has finished loading
+     *
+     * @author Taylor Smock
+     */
+    public interface TileListener {
+        /**
+         * Called when the MVTTile is finished loading
+         *
+         * @param tile The tile that finished loading
+         */
+        void finishedLoading(MVTTile tile);
+    }
+
+    /**
+     * A class used to set the layers that an MVTTile will show.
+     *
+     * @author Taylor Smock
+     */
+    public interface LayerShower {
+        /**
+         * Get a list of layers to show
+         *
+         * @return A list of layer names
+         */
+        List<String> layersToShow();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (!super.equals(obj) || obj.getClass().isAssignableFrom(this.getClass())) {
+            return false;
+        }
+        MVTTile other = (MVTTile) obj;
+        return extent == other.extent
+          && Objects.deepEquals(layers.toArray(), other.layers.toArray());
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(super.hashCode(), extent, layers);
+    }
+}

new file src/org/openstreetmap/josm/data/imagery/vectortile/mapbox/ParameterInteger.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.imagery.vectortile.mapbox;
+
+/**
+ * The parameters that follow the {@link CommandInteger}.
+ * @author Taylor Smock
+ * @since xxx
+ */
+public final class ParameterInteger {
+    private ParameterInteger() {
+        // Hide constructor
+    }
+
+    /**
+     * Get the value for this ParameterInteger
+     * @param value The zig-zag and delta encoded value to decode
+     * @return The decoded integer value
+     */
+    public static int decode(int value) {
+        return ((value >> 1) ^ -(value & 1));
+    }
+}

new file src/org/openstreetmap/josm/data/imagery/vectortile/mapbox/style/Expression.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.imagery.vectortile.mapbox.style;
+
+import java.util.Arrays;
+import java.util.stream.Collectors;
+
+import javax.json.JsonArray;
+import javax.json.JsonObject;
+import javax.json.JsonString;
+import javax.json.JsonValue;
+
+/**
+ * A MapBox vector style expression
+ * @author Taylor Smock
+ * @see <a href="https://docs.mapbox.com/mapbox-gl-js/style-spec/expressions/">https://docs.mapbox.com/mapbox-gl-js/style-spec/expressions/</a>
+ * @since xxx
+ */
+public class Expression {
+    /** An empty expression to use */
+    public static final Expression EMPTY_EXPRESSION = new Expression(JsonValue.NULL);
+    private static final String EMPTY_STRING = "";
+
+    private final String expression;
+
+    /**
+     * Create a new filter expression. <i>Please note that this currently only supports basic comparators!</i>
+     * @param value The value to parse
+     */
+    public Expression(JsonValue value) {
+        if (value.getValueType() == JsonValue.ValueType.ARRAY) {
+            final JsonArray array = value.asJsonArray();
+            if (array.get(0).getValueType() == JsonValue.ValueType.STRING) {
+                if ("==".equals(array.getString(0))) {
+                    // The mapcss equivalent of == is = (for the most part)
+                    this.expression = convertToString(array.get(1)) + "=" + convertToString(array.get(2));
+                } else if (Arrays.asList("<=", ">=", ">", "<", "!=").contains(array.getString(0))) {
+                    this.expression = convertToString(array.get(1)) + array.getString(0) + convertToString(array.get(2));
+                } else {
+                    this.expression = EMPTY_STRING;
+                }
+            } else {
+                this.expression = EMPTY_STRING;
+            }
+        } else {
+            this.expression = EMPTY_STRING;
+        }
+    }
+
+    /**
+     * Convert a value to a string
+     * @param value The value to convert
+     * @return A string
+     */
+    private static String convertToString(JsonValue value) {
+        switch (value.getValueType()) {
+        case STRING:
+            return ((JsonString) value).getString();
+        case FALSE:
+            return Boolean.FALSE.toString();
+        case TRUE:
+            return Boolean.TRUE.toString();
+        case NUMBER:
+            return value.toString();
+        case ARRAY:
+            return '['
+              + ((JsonArray) value).stream().map(Expression::convertToString).collect(Collectors.joining(","))
+              + ']';
+        case OBJECT:
+            return '{'
+              + ((JsonObject) value).entrySet().stream()
+              .map(entry -> entry.getKey() + ":" + convertToString(entry.getValue())).collect(
+                Collectors.joining(","))
+              + '}';
+        case NULL:
+        default:
+            return EMPTY_STRING;
+        }
+    }
+
+    @Override
+    public String toString() {
+        return !EMPTY_STRING.equals(this.expression) ? '[' + this.expression + ']' : EMPTY_STRING;
+    }
+}

new file src/org/openstreetmap/josm/data/imagery/vectortile/mapbox/style/Layers.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.imagery.vectortile.mapbox.style;
+
+import java.awt.Font;
+import java.awt.GraphicsEnvironment;
+import java.text.MessageFormat;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Locale;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import javax.json.JsonArray;
+import javax.json.JsonNumber;
+import javax.json.JsonObject;
+import javax.json.JsonString;
+import javax.json.JsonValue;
+
+/**
+ * MapBox style layers
+ * @author Taylor Smock
+ * @see <a href="https://docs.mapbox.com/mapbox-gl-js/style-spec/layers/">https://docs.mapbox.com/mapbox-gl-js/style-spec/layers/</a>
+ * @since xxx
+ */
+public class Layers {
+    /**
+     * The layer type. This affects the rendering.
+     * @author Taylor Smock
+     * @since xxx
+     */
+    enum Type {
+        /** Filled polygon with an (optional) border */
+        FILL,
+        /** A line */
+        LINE,
+        /** A symbol */
+        SYMBOL,
+        /** A circle */
+        CIRCLE,
+        /** A heatmap */
+        HEATMAP,
+        /** A 3D polygon extrusion */
+        FILL_EXTRUSION,
+        /** Raster */
+        RASTER,
+        /** Hillshade data */
+        HILLSHADE,
+        /** A background color or pattern */
+        BACKGROUND,
+        /** The fallback layer */
+        SKY
+    }
+
+    private static final String EMPTY_STRING = "";
+    private static final char SEMI_COLON = ';';
+    private static final Pattern CURLY_BRACES = Pattern.compile("(\\{(.*?)})");
+
+    /** A required unique layer name */
+    private final String id;
+    /** The required type */
+    private final Type type;
+    /** An optional expression */
+    private final Expression filter;
+    /** The max zoom for the layer */
+    private final int maxZoom;
+    /** The min zoom for the layer */
+    private final int minZoom;
+
+    /** Default paint properties for this layer */
+    private final String paint;
+
+    /** A source description to be used with this layer. Required for everything <i>but</i> {@link Type#BACKGROUND} */
+    private final String source;
+    /** Layer to use from the vector tile source. Only allowed with {@link SourceType#VECTOR}. */
+    private final String sourceLayer;
+
+    /**
+     * Create a layer object
+     * @param commonStyleInformation The MapBoxVectorStyle with common information
+     * @param layerInfo The info to use to create the layer
+     */
+    public Layers(final JsonObject layerInfo) {
+        this.id = layerInfo.getString("id");
+        this.type = Type.valueOf(layerInfo.getString("type").replace("-", "_").toUpperCase(Locale.ROOT));
+        if (layerInfo.containsKey("filter")) {
+            this.filter = new Expression(layerInfo.get("filter"));
+        } else {
+            this.filter = Expression.EMPTY_EXPRESSION;
+        }
+        this.maxZoom = layerInfo.getInt("maxzoom", Integer.MAX_VALUE);
+        this.minZoom = layerInfo.getInt("minzoom", Integer.MIN_VALUE);
+        // There is a metadata field (I don't *think* I need it?)
+        // source is only optional with {@link Type#BACKGROUND}.
+        if (this.type == Type.BACKGROUND) {
+            this.source = layerInfo.getString("source", null);
+        } else {
+            this.source = layerInfo.getString("source");
+        }
+        if (layerInfo.containsKey("paint") && layerInfo.get("paint").getValueType() == JsonValue.ValueType.OBJECT) {
+            final JsonObject paintObject = layerInfo.getJsonObject("paint");
+            final JsonObject layoutObject = layerInfo.getJsonObject("layout");
+            // Don't throw exceptions here, since we may just point at the styling
+            switch (type) {
+            case FILL:
+                // area
+                this.paint = parsePaintFill(paintObject);
+                break;
+            case LINE:
+                // way
+                this.paint = parsePaintLine(paintObject);
+                break;
+            case CIRCLE:
+                // point
+                this.paint = parsePaintCircle(paintObject);
+                break;
+            case SYMBOL:
+                // point
+                this.paint = parsePaintSymbol(layoutObject, paintObject);
+                break;
+            case BACKGROUND:
+                // canvas only
+                this.paint = parsePaintBackground(paintObject);
+                break;
+            default:
+                this.paint = EMPTY_STRING;
+            }
+        } else {
+            this.paint = null;
+        }
+        this.sourceLayer = layerInfo.getString("source-layer", null);
+    }
+
+    private static String parsePaintLine(final JsonObject paintObject) {
+        if (!checkVisibility(paintObject)) {
+            return "";
+        }
+        final StringBuilder sb = new StringBuilder();
+        // line-blur, default 0 (px)
+        // line-color, default #000000, disabled by line-pattern
+        final String color = paintObject.getString("line-color", "#000000");
+        if (color != null) {
+            sb.append("color:").append(color).append(SEMI_COLON);
+        }
+        // line-opacity, default 1 (0-1)
+        final JsonNumber opacity = paintObject.getJsonNumber("line-opacity");
+        if (opacity != null) {
+            sb.append("opacity:").append(opacity.numberValue().doubleValue()).append(SEMI_COLON);
+        }
+        // line-cap, default butt (butt|round|square)
+        final String cap = paintObject.getString("line-cap", "butt");
+        sb.append("linecap:");
+        switch (cap) {
+        case "round":
+        case "square":
+            sb.append(cap);
+            break;
+        case "butt":
+        default:
+            sb.append("none");
+        }
+
+        sb.append(SEMI_COLON);
+        // line-dasharray, array of number >= 0, units in line widths, disabled by line-pattern
+        if (paintObject.containsKey("line-dasharray")) {
+            final JsonArray dashArray = paintObject.getJsonArray("line-dasharray");
+            sb.append("dashes:");
+            sb.append(dashArray.stream().filter(JsonNumber.class::isInstance).map(JsonNumber.class::cast)
+              .map(JsonNumber::toString).collect(Collectors.joining(",")));
+            sb.append(SEMI_COLON);
+        }
+        // line-gap-width
+        // line-gradient
+        // line-join
+        // line-miter-limit
+        // line-offset
+        // line-pattern TODO this first, since it disables stuff
+        // line-round-limit
+        // line-sort-key
+        // line-translate
+        // line-translate-anchor
+        // line-width
+        final JsonNumber width = paintObject.getJsonNumber("line-width");
+        sb.append("width:").append(width == null ? 1 : width.toString()).append(SEMI_COLON);
+        return sb.toString();
+    }
+
+    private static String parsePaintCircle(final JsonObject paintObject) {
+        if (!checkVisibility(paintObject)) {
+            return EMPTY_STRING;
+        }
+        final StringBuilder sb = new StringBuilder("symbol-shape:circle;");
+        // circle-blur
+        // circle-color
+        sb.append("symbol-fill-color:").append(paintObject.getString("circle-color", "#000000")).append(SEMI_COLON);
+        // circle-opacity
+        final JsonNumber fillOpacity = paintObject.getJsonNumber("circle-opacity");
+        sb.append("symbol-fill-opacity:").append(fillOpacity != null ? fillOpacity.numberValue().toString() : "1").append(SEMI_COLON);
+        // circle-pitch-alignment // not 3D
+        // circle-pitch-scale // not 3D
+        // circle-radius
+        final JsonNumber radius = paintObject.getJsonNumber("circle-radius");
+        sb.append("symbol-size:").append(radius != null ? (2 * radius.numberValue().doubleValue()) : "10").append(SEMI_COLON);
+        // circle-sort-key
+        // circle-stroke-color
+        sb.append("symbol-stroke-color:").append(paintObject.getString("circle-stroke-color", "#000000")).append(SEMI_COLON);
+        // circle-stroke-opacity
+        final JsonNumber strokeOpacity = paintObject.getJsonNumber("circle-stroke-opacity");
+        sb.append("symbol-stroke-opacity:").append(strokeOpacity != null ? strokeOpacity.numberValue().toString() : "1").append(SEMI_COLON);
+        // circle-stroke-width
+        final JsonNumber strokeWidth = paintObject.getJsonNumber("circle-stroke-width");
+        sb.append("symbol-stroke-width:").append(strokeWidth != null ? strokeWidth.numberValue().toString() : "0").append(SEMI_COLON);
+        // circle-translate
+        // circle-translate-anchor
+        return sb.toString();
+    }
+
+    private static String parsePaintSymbol(
+      final JsonObject layoutObject,
+      final JsonObject paintObject) {
+        if (!checkVisibility(paintObject)) {
+            return EMPTY_STRING;
+        }
+        final StringBuilder sb = new StringBuilder();
+        // icon-allow-overlap
+        // icon-anchor
+        // icon-color
+        // icon-halo-blur
+        // icon-halo-color
+        // icon-halo-width
+        // icon-ignore-placement
+        // icon-image
+        boolean iconImage = false;
+        if (layoutObject.containsKey("icon-image")) {
+            sb.append("icon-image:concat(");
+            Matcher matcher = CURLY_BRACES.matcher(layoutObject.getString("icon-image"));
+            StringBuffer stringBuffer = new StringBuffer();
+            int previousMatch;
+            if (matcher.lookingAt()) {
+                matcher.appendReplacement(stringBuffer, "tag(\"$2\"), \"");
+                previousMatch = matcher.end();
+            } else {
+                previousMatch = 0;
+                stringBuffer.append('"');
+            }
+            while (matcher.find()) {
+                if (matcher.start() == previousMatch) {
+                    matcher.appendReplacement(stringBuffer, ",tag(\"$2\")");
+                } else {
+                    matcher.appendReplacement(stringBuffer, "\", tag(\"$2\"), \"");
+                }
+                previousMatch = matcher.end();
+            }
+            if (matcher.hitEnd()) {
+                stringBuffer.delete(stringBuffer.length() - ", \"".length(), stringBuffer.length());
+            } else {
+                stringBuffer.append('"');
+            }
+            matcher.appendTail(stringBuffer);
+
+            sb.append(stringBuffer).append(')').append(SEMI_COLON);
+            iconImage = true;
+        }
+        // icon-keep-upright
+        // icon-offset
+        if (iconImage && layoutObject.containsKey("icon-offset")) {
+            // default [0, 0], right,down == positive, left,up == negative
+            final List<JsonNumber> offset = layoutObject.getJsonArray("icon-offset").getValuesAs(JsonNumber.class);
+            // Assume that the offset must be size 2. Probably not necessary, but docs aren't necessary clear.
+            if (offset.size() == 2) {
+                sb.append("icon-offset-x:").append(offset.get(0).doubleValue()).append(SEMI_COLON)
+                  .append("icon-offset-y:").append(offset.get(1).doubleValue()).append(SEMI_COLON);
+            }
+        }
+        // icon-opacity
+        if (iconImage && paintObject.containsKey("icon-opacity")) {
+            final double opacity = layoutObject.getJsonNumber("icon-opacity").doubleValue();
+            sb.append("icon-opacity:").append(opacity).append(SEMI_COLON);
+        }
+        // icon-optional
+        // icon-padding
+        // icon-pitch-alignment
+        // icon-rotate
+        if (iconImage && layoutObject.containsKey("icon-rotate")) {
+            final double rotation = layoutObject.getJsonNumber("icon-rotate").doubleValue();
+            sb.append("icon-rotation:").append(rotation).append(SEMI_COLON);
+        }
+        // icon-rotation-alignment
+        // icon-size
+        // icon-text-fit
+        // icon-text-fit-padding
+        // icon-translate
+        // icon-translate-anchor
+        // symbol-avoid-edges
+        // symbol-placement
+        // symbol-sort-key
+        // symbol-spacing
+        // symbol-z-order
+        // text-allow-overlap
+        // text-anchor
+        // text-color
+        if (paintObject.containsKey("text-color")) {
+            sb.append("text-color:").append(paintObject.getString("text-color")).append(SEMI_COLON);
+        }
+        // text-field
+        if (paintObject.containsKey("text-field")) {
+            sb.append("text:")
+              .append(paintObject.getString("text-field").replace("}", EMPTY_STRING).replace("{", EMPTY_STRING))
+              .append(SEMI_COLON);
+        }
+        // text-font
+        if (paintObject.containsKey("text-font")) {
+            List<String> fonts = paintObject.getJsonArray("text-font").stream().filter(JsonString.class::isInstance)
+              .map(JsonString.class::cast).map(JsonString::getString).collect(Collectors.toList());
+            Font[] systemFonts = GraphicsEnvironment.getLocalGraphicsEnvironment().getAllFonts();
+            for (String fontString : fonts) {
+                Collection<Font> fontMatches = Stream.of(systemFonts)
+                  .filter(font -> Arrays.asList(font.getName(), font.getFontName(), font.getFamily(), font.getPSName()).contains(fontString))
+                  .collect(Collectors.toList());
+                if (!fontMatches.isEmpty()) {
+                    final Font setFont = fontMatches.stream().filter(font -> font.getName().equals(fontString)).findAny()
+                      .orElseGet(() -> fontMatches.stream().filter(font -> font.getFontName().equals(fontString)).findAny()
+                        .orElseGet(() -> fontMatches.stream().filter(font -> font.getPSName().equals(fontString)).findAny()
+                        .orElseGet(() -> fontMatches.stream().filter(font -> font.getFamily().equals(fontString)).findAny().orElse(null))));
+                    if (setFont != null) {
+                        sb.append("font-family:\"").append(setFont.getFamily()).append("\"").append(SEMI_COLON);
+                        sb.append("font-weight:").append(setFont.isBold() ? "bold" : "normal").append(SEMI_COLON);
+                        sb.append("font-style:").append(setFont.isItalic() ? "italic" : "normal").append(SEMI_COLON);
+                        break;
+                    }
+                }
+            }
+        }
+        // text-halo-blur
+        // text-halo-color
+        if (paintObject.containsKey("text-halo-color")) {
+            sb.append("text-halo-color:").append(paintObject.getString("text-halo-color")).append(SEMI_COLON);
+        }
+        // text-halo-width
+        if (paintObject.containsKey("text-halo-width")) {
+            sb.append("text-halo-radius:").append(paintObject.getString("text-halo-width")).append(SEMI_COLON);
+        }
+        // text-ignore-placement
+        // text-justify
+        // text-keep-upright
+        // text-letter-spacing
+        // text-line-height
+        // text-max-angle
+        // text-max-width
+        // text-offset
+        // text-opacity
+        if (paintObject.containsKey("text-opacity")) {
+            sb.append("text-opacity:").append(paintObject.getJsonNumber("text-opacity").doubleValue()).append(SEMI_COLON);
+        }
+        // text-optional
+        // text-padding
+        // text-pitch-alignment
+        // text-radial-offset
+        // text-rotate
+        // text-rotation-alignment
+        // text-size
+        final JsonNumber textSize = paintObject.getJsonNumber("text-size");
+        sb.append("font-size:").append(textSize != null ? textSize.numberValue().toString() : "16").append(SEMI_COLON);
+        // text-transform
+        // text-translate
+        // text-translate-anchor
+        // text-variable-anchor
+        // text-writing-mode
+        return sb.toString();
+    }
+
+    private static String parsePaintBackground(final JsonObject paintObject) {
+        if (!checkVisibility(paintObject)) {
+            return EMPTY_STRING;
+        }
+        final StringBuilder sb = new StringBuilder(20);
+        // background-color
+        final String bgColor = paintObject.getString("background-color", null);
+        if (bgColor != null) {
+            sb.append("fill-color:").append(bgColor).append(SEMI_COLON);
+        }
+        // background-opacity
+        // background-pattern
+        return sb.toString();
+    }
+
+    private static String parsePaintFill(final JsonObject paintObject) {
+        if (!checkVisibility(paintObject)) {
+            return EMPTY_STRING;
+        }
+        StringBuilder sb = new StringBuilder();
+        // fill-antialias
+        // fill-color
+        sb.append("fill-color:").append(paintObject.getString("fill-color", "#000000")).append(SEMI_COLON);
+        // fill-opacity
+        final JsonNumber opacity = paintObject.getJsonNumber("fill-opacity");
+        sb.append("fill-opacity:").append(opacity != null ? opacity.numberValue().toString() : "1").append(SEMI_COLON);
+        // fill-outline-color
+        sb.append("color:").append(paintObject.getString("fill-outline-color",
+          paintObject.getString("fill-color", "#000000"))).append(SEMI_COLON);
+        // fill-pattern
+        // fill-sort-key
+        // fill-translate
+        // fill-translate-anchor
+        return sb.toString();
+    }
+
+    /**
+     * Check if the layer is displayed
+     * @param paintObject The paint to check
+     * @return {@code true} if the layer should be visible
+     */
+    private static boolean checkVisibility(final JsonObject paintObject) {
+        return "visible".equals(paintObject.getString("visibility", "visible"));
+    }
+
+    @Override
+    public String toString() {
+        final String zoomSelector;
+        if (this.minZoom == this.maxZoom) {
+            zoomSelector = "|z" + this.minZoom;
+        } else if (this.minZoom > Integer.MIN_VALUE && this.maxZoom == Integer.MAX_VALUE) {
+            zoomSelector = "|z" + this.minZoom + "-";
+        } else if (this.minZoom == Integer.MIN_VALUE && this.maxZoom < Integer.MAX_VALUE) {
+            zoomSelector = "|z-" + this.maxZoom;
+        } else if (this.minZoom > Integer.MIN_VALUE) {
+            zoomSelector = MessageFormat.format("|z{0}-{1}", this.minZoom, this.maxZoom);
+        } else {
+            zoomSelector = EMPTY_STRING;
+        }
+        final String commonData = zoomSelector + this.filter.toString() + "::" + this.id + "{" + this.paint + "}";
+        if (this.type == Type.BACKGROUND) {
+            // AFAIK, paint has no zoom levels, and doesn't accept a layer
+            return "canvas{" + this.paint + "}";
+        } else if (this.type == Type.CIRCLE || this.type == Type.SYMBOL) {
+            return "node" + commonData;
+        } else if (this.type == Type.FILL) {
+            return "area" + commonData;
+        } else if (this.type == Type.LINE) {
+            return "way" + commonData;
+        }
+        return super.toString();
+    }
+
+    /**
+     * Get the source that this applies to
+     * @return The source name
+     */
+    public String getSource() {
+        return this.source;
+    }
+
+    /**
+     * Get the layer that this applies to
+     * @return The layer name
+     */
+    public String getSourceLayer() {
+        return this.sourceLayer;
+    }
+}

new file src/org/openstreetmap/josm/data/imagery/vectortile/mapbox/style/MapBoxVectorStyle.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.imagery.vectortile.mapbox.style;
+
+import static org.openstreetmap.josm.tools.I18n.tr;
+
+import java.awt.image.BufferedImage;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Collectors;
+
+import javax.imageio.ImageIO;
+import javax.json.Json;
+import javax.json.JsonArray;
+import javax.json.JsonObject;
+import javax.json.JsonReader;
+import javax.json.JsonStructure;
+import javax.json.JsonValue;
+
+import org.openstreetmap.josm.data.preferences.JosmBaseDirectories;
+import org.openstreetmap.josm.gui.MainApplication;
+import org.openstreetmap.josm.gui.mappaint.ElemStyles;
+import org.openstreetmap.josm.gui.mappaint.mapcss.MapCSSStyleSource;
+import org.openstreetmap.josm.io.CachedFile;
+import org.openstreetmap.josm.tools.Logging;
+
+/**
+ * Create a mapping for a Mapbox Vector Style
+ *
+ * @author Taylor Smock
+ * @see <a href="https://docs.mapbox.com/mapbox-gl-js/style-spec/">https://docs.mapbox.com/mapbox-gl-js/style-spec/</a>
+ * @since xxx
+ */
+public class MapBoxVectorStyle {
+
+    private static final ConcurrentHashMap<String, MapBoxVectorStyle> STYLE_MAPPING = new ConcurrentHashMap<>();
+
+    /**
+     * Get a MapBoxVector style for a URL
+     * @param url The url to get
+     * @return The MapBox Vector Style. May be {@code null} if there was an error.
+     */
+    public static MapBoxVectorStyle getMapBoxVectorStyle(String url) {
+        return STYLE_MAPPING.computeIfAbsent(url, key -> {
+            try (CachedFile style = new CachedFile(url);
+                    BufferedReader reader = style.getContentReader();
+                    JsonReader jsonReader = Json.createReader(reader)) {
+                JsonStructure structure = jsonReader.read();
+                return new MapBoxVectorStyle(structure.asJsonObject());
+            } catch (IOException e) {
+                Logging.error(e);
+            }
+            // Documentation indicates that this will <i>not</i> be entered into the map, which means that this will be
+            // retried if something goes wrong.
+            return null;
+        });
+    }
+
+    /** The version for the style specification */
+    private final int version;
+    /** The optional name for the vector style */
+    private final String name;
+    /** The optional URL for sprites. This mush be absolute (so it must contain the scheme, authority, and path). */
+    private final String spriteUrl;
+    /** The optional URL for glyphs. This may have replaceable values in it. */
+    private final String glyphUrl;
+    /** The required collection of sources with a list of layers that are applicable for that source*/
+    private final Map<Source, ElemStyles> sources;
+
+    /**
+     * Create a new MapBoxVector style. You should prefer {@link #getMapBoxVectorStyle(String)}
+     * for deduplication purposes.
+     *
+     * @param jsonObject The object to create the style from
+     * @see #getMapBoxVectorStyle(String)
+     */
+    public MapBoxVectorStyle(JsonObject jsonObject) {
+        // There should be a version specifier. We currently only support version 8.
+        // This can throw an NPE when there is no version number.
+        this.version = jsonObject.getInt("version");
+        if (this.version == 8) {
+            this.name = jsonObject.getString("name", null);
+            this.spriteUrl = jsonObject.getString("sprite", null);
+            this.glyphUrl = jsonObject.getString("glyphs", null);
+            final List<Source> sources;
+            if (jsonObject.containsKey("sources") && jsonObject.get("sources").getValueType() == JsonValue.ValueType.OBJECT) {
+                final JsonObject sourceObj = jsonObject.getJsonObject("sources");
+                sources = sourceObj.entrySet().stream().filter(entry -> entry.getValue().getValueType() == JsonValue.ValueType.OBJECT)
+                  .map(entry -> new Source(entry.getKey(), entry.getValue().asJsonObject())).collect(Collectors.toList());
+            } else {
+                sources = Collections.emptyList();
+            }
+            final List<Layers> layers;
+            if (jsonObject.containsKey("layers") && jsonObject.get("layers").getValueType() == JsonValue.ValueType.ARRAY) {
+                JsonArray lArray = jsonObject.getJsonArray("layers");
+                layers = lArray.stream().filter(JsonObject.class::isInstance).map(JsonObject.class::cast).map(Layers::new)
+                  .collect(Collectors.toList());
+            } else {
+                layers = Collections.emptyList();
+            }
+            final Map<Optional<Source>, List<Layers>> sourceLayer = layers.stream().collect(
+              Collectors.groupingBy(layer -> sources.stream().filter(source -> source.getName().equals(layer.getSource()))
+                .findFirst()));
+            // Abuse HashMap null (null == default)
+            this.sources = new HashMap<>();
+            for (Map.Entry<Optional<Source>, List<Layers>> entry : sourceLayer.entrySet()) {
+                final Source source = entry.getKey().orElse(null);
+                final String data = entry.getValue().stream().map(Layers::toString).collect(Collectors.joining());
+                final String metaData = "meta{title:" + (source == null ? "Generated Style" :
+                  source.getName()) + ";version:\"autogenerated\";description:\"auto generated style\";}";
+
+                // This is the default canvas
+                final String canvas = "canvas{default-points:false;default-lines:false;}";
+                final MapCSSStyleSource style = new MapCSSStyleSource(metaData + canvas + data);
+                // Save to directory
+                MainApplication.worker.execute(() -> this.save((source == null ? data.hashCode() : source.getName()) + ".mapcss", style));
+                this.sources.put(source, new ElemStyles(Collections.singleton(style)));
+            }
+            if (this.spriteUrl != null && !this.spriteUrl.trim().isEmpty()) {
+                MainApplication.worker.execute(this::fetchSprites);
+            }
+        } else {
+            throw new IllegalArgumentException(tr("Vector Tile Style Version not understood: version {0} (json: {1})",
+              this.version, jsonObject));
+        }
+    }
+
+    /**
+     * Fetch sprites. Please note that this is (literally) only png. Unfortunately.
+     * @see <a href="https://docs.mapbox.com/mapbox-gl-js/style-spec/sprite/">https://docs.mapbox.com/mapbox-gl-js/style-spec/sprite/</a>
+     */
+    private void fetchSprites() {
+        // HiDPI images first -- if this succeeds, don't bother with the lower resolution (JOSM has no method to switch)
+        try (CachedFile spriteJson = new CachedFile(this.spriteUrl + "@2x.json");
+          CachedFile spritePng = new CachedFile(this.spriteUrl + "@2x.png")) {
+            if (parseSprites(spriteJson, spritePng)) {
+                return;
+            }
+        }
+        try (CachedFile spriteJson = new CachedFile(this.spriteUrl + ".json");
+        CachedFile spritePng = new CachedFile(this.spriteUrl + ".png")) {
+            parseSprites(spriteJson, spritePng);
+        }
+    }
+
+    private boolean parseSprites(CachedFile spriteJson, CachedFile spritePng) {
+        /* JSON looks like this:
+         * { "image-name": {"width": width, "height": height, "x": x, "y": y, "pixelRatio": 1 }}
+         * width/height are the dimensions of the image
+         * x -- distance right from top left
+         * y -- distance down from top left
+         * pixelRatio -- this <i>appears</i> to be from the "@2x" (default 1)
+         * content -- [left, top corner, right, bottom corner]
+         * stretchX -- [[from, to], [from, to], ...]
+         * stretchY -- [[from, to], [from, to], ...]
+         */
+        final JsonObject spriteObject;
+        final BufferedImage spritePngImage;
+        try (BufferedReader spriteJsonBufferedReader = spriteJson.getContentReader();
+          JsonReader spriteJsonReader = Json.createReader(spriteJsonBufferedReader);
+          InputStream spritePngBufferedReader = spritePng.getInputStream()
+        ) {
+            spriteObject = spriteJsonReader.read().asJsonObject();
+            spritePngImage = ImageIO.read(spritePngBufferedReader);
+        } catch (IOException e) {
+            Logging.error(e);
+            return false;
+        }
+        for (Map.Entry<String, JsonValue> entry : spriteObject.entrySet()) {
+            final JsonObject info = entry.getValue().asJsonObject();
+            int width = info.getInt("width");
+            int height = info.getInt("height");
+            int x = info.getInt("x");
+            int y = info.getInt("y");
+            save(entry.getKey() + ".png", spritePngImage.getSubimage(x, y, width, height));
+        }
+        return true;
+    }
+
+    private void save(String name, Object object) {
+        final File cache = JosmBaseDirectories.getInstance().getCacheDirectory(true);
+        final File location = new File(cache.getPath(), this.name != null ? this.name : Integer.toString(this.hashCode()));
+        if (!location.exists()) {
+            location.mkdir();
+        } else if (location.exists() && !location.isDirectory()) {
+            // Don't try to save if the file exists and is not a directory
+            return;
+        }
+        final File toSave = new File(location, name);
+        try (FileOutputStream fileOutputStream = new FileOutputStream(toSave)) {
+            if (object instanceof String) {
+                fileOutputStream.write(((String) object).getBytes(StandardCharsets.UTF_8));
+            } else if (object instanceof MapCSSStyleSource) {
+                MapCSSStyleSource source = (MapCSSStyleSource) object;
+                try (InputStream inputStream = source.getSourceInputStream()) {
+                    int byteVal = inputStream.read();
+                    do {
+                        fileOutputStream.write(byteVal);
+                        byteVal = inputStream.read();
+                    } while (byteVal > -1);
+                    source.url = "file:/" + toSave.getAbsolutePath().replace('\\', '/');
+                    if (source.isLoaded()) {
+                        source.loadStyleSource();
+                    }
+                }
+            } else if (object instanceof BufferedImage) {
+                ImageIO.write((BufferedImage) object, "png", toSave);
+            }
+        } catch (IOException e) {
+            Logging.info(e);
+        }
+    }
+
+    /**
+     * Get the generated layer->style mapping
+     * @return The mapping (use to enable/disable a paint style)
+     */
+    public Map<Source, ElemStyles> getSources() {
+        return this.sources;
+    }
+
+    /**
+     * Get the sprite url for the style
+     * @return The base sprite url
+     */
+    public String getSpriteUrl() {
+        return this.spriteUrl;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(this.name, this.version, this.glyphUrl, this.spriteUrl);
+    }
+}

new file src/org/openstreetmap/josm/data/imagery/vectortile/mapbox/style/Scheme.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.imagery.vectortile.mapbox.style;
+
+/**
+ * The scheme used for tiles
+ */
+public enum Scheme {
+    /** Standard slippy map scheme */
+    XYZ,
+    /** OSGeo specification scheme */
+    TMS
+}

new file src/org/openstreetmap/josm/data/imagery/vectortile/mapbox/style/Source.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.imagery.vectortile.mapbox.style;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+import java.util.stream.Collectors;
+
+import javax.json.JsonArray;
+import javax.json.JsonObject;
+import javax.json.JsonString;
+import javax.json.JsonValue;
+
+import org.openstreetmap.josm.data.Bounds;
+
+/**
+ * A source from a MapBox Vector Style
+ *
+ * @author Taylor Smock
+ * @see <a href="https://docs.mapbox.com/mapbox-gl-js/style-spec/sources/">https://docs.mapbox.com/mapbox-gl-js/style-spec/sources/</a>
+ * @since xxx
+ */
+public class Source {
+    /**
+     * WMS servers should contain a "{bbox-epsg-3857}" parameter for the bbox
+     */
+    private static final String WMS_BBOX = "bbox-epsg-3857";
+
+    /* Common items */
+    /**
+     * The name of the source
+     */
+    private final String name;
+    /**
+     * The type of the source
+     */
+    private final SourceType sourceType;
+
+    /* Common tiled data */
+    /**
+     * The minimum zoom supported
+     */
+    private final int minZoom;
+    /**
+     * The maximum zoom supported
+     */
+    private final int maxZoom;
+    /**
+     * The tile urls. These usually have replaceable fields.
+     */
+    private final List<String> tileUrls;
+
+    /* Vector and raster data */
+    /**
+     * The attribution to display for the user
+     */
+    private final String attribution;
+    /**
+     * The bounds of the data. We should not request data outside of the bounds
+     */
+    private final Bounds bounds;
+    /**
+     * The property to use as a feature id. Can be parameterized
+     */
+    private final String promoteId;
+    /**
+     * The tile scheme
+     */
+    private final Scheme scheme;
+    /**
+     * {@code true} if the tiles should not be cached
+     */
+    private final boolean volatileCache;
+
+    /* Raster data */
+    /**
+     * The tile size
+     */
+    private final int tileSize;
+
+    /**
+     * Create a new Source object
+     *
+     * @param name The name of the source object
+     * @param data The data to set the source information with
+     */
+    public Source(final String name, final JsonObject data) {
+        this.name = name;
+        // "type" is required
+        final String type = data.getString("type");
+        this.sourceType = SourceType.valueOf(type.replace("-", "_").toUpperCase(Locale.ROOT));
+        // This can also contain SourceType.RASTER_DEM (only needs encoding)
+        if (SourceType.VECTOR == this.sourceType || SourceType.RASTER == this.sourceType) {
+            if (data.containsKey("url")) {
+                // TODO implement https://github.com/mapbox/tilejson-spec
+                throw new UnsupportedOperationException();
+            } else {
+                this.minZoom = data.getInt("minzoom", 0);
+                this.maxZoom = data.getInt("maxzoom", 22);
+                this.attribution = data.getString("attribution", null);
+                if (data.containsKey("bounds") && data.get("bounds").getValueType() == JsonValue.ValueType.ARRAY) {
+                    final JsonArray bJsonArray = data.getJsonArray("bounds");
+                    final double[] bArray = new double[4];
+                    for (int i = 0; i < 4; i++) {
+                        bArray[i] = bJsonArray.getJsonNumber(i).doubleValue();
+                    }
+                    // The order in the response is
+                    // [south-west longitude, south-west latitude, north-east longitude, north-east latitude]
+                    this.bounds = new Bounds(bArray[1], bArray[0], bArray[3], bArray[2]);
+                } else {
+                    this.bounds = new Bounds(-85.051129, -180, 85.051129, 180);
+                }
+                this.promoteId = data.getString("promoteId", null);
+                this.scheme = Scheme.valueOf(data.getString("scheme", "xyz").toUpperCase(Locale.ROOT));
+                if (data.containsKey("tiles") && data.get("tiles").getValueType() == JsonValue.ValueType.ARRAY) {
+                    this.tileUrls = data.getJsonArray("tiles").stream().filter(JsonString.class::isInstance)
+                      .map(JsonString.class::cast).map(JsonString::getString)
+                      // Replace bbox-epsg-3857 with bbox (already encased with {})
+                      .map(url -> url.replace(WMS_BBOX, "bbox")).collect(Collectors.toList());
+                } else {
+                    this.tileUrls = Collections.emptyList();
+                }
+                this.volatileCache = data.getBoolean("volatile", false);
+                this.tileSize = data.getInt("tileSize", 512);
+            }
+        } else {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    /**
+     * Get the source name
+     * @return the name
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * Get the URLs that can be used to get vector data
+     *
+     * @return The urls
+     */
+    public List<String> getUrls() {
+        return Collections.unmodifiableList(this.tileUrls);
+    }
+
+    /**
+     * Get the minimum zoom
+     *
+     * @return The min zoom (default {@code 0})
+     */
+    public int getMinZoom() {
+        return this.minZoom;
+    }
+
+    /**
+     * Get the max zoom
+     *
+     * @return The max zoom (default {@code 22})
+     */
+    public int getMaxZoom() {
+        return this.maxZoom;
+    }
+
+    /**
+     * Get the attribution for this source
+     *
+     * @return The attribution text. May be {@code null}.
+     */
+    public String getAttributionText() {
+        return this.attribution;
+    }
+
+    @Override
+    public String toString() {
+        Collection<String> parts = new ArrayList<>(1 + this.getUrls().size());
+        parts.add(this.getName());
+        parts.addAll(this.getUrls());
+        return String.join(" ", parts);
+    }
+}

new file src/org/openstreetmap/josm/data/imagery/vectortile/mapbox/style/SourceType.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.imagery.vectortile.mapbox.style;
+
+/**
+ * The "source type" for the data (MapBox Vector Style specification)
+ *
+ * @author Taylor Smock
+ * @since xxx
+ */
+public enum SourceType {
+    VECTOR,
+    RASTER,
+    RASTER_DEM,
+    GEOJSON,
+    IMAGE,
+    VIDEO
+}

new file src/org/openstreetmap/josm/data/imagery/vectortile/VectorTile.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.imagery.vectortile;
+
+import java.util.Collection;
+
+import org.openstreetmap.josm.data.imagery.vectortile.mapbox.Layer;
+
+/**
+ * An interface that is used to draw vector tiles, instead of using images
+ * @author Taylor Smock
+ * @since xxx
+ */
+public interface VectorTile {
+    /**
+     * Get the layers for this vector tile
+     * @return A collection of layers
+     */
+    Collection<Layer> getLayers();
+
+    /**
+     * Get the extent of the tile (in pixels)
+     * @return The tile extent (pixels)
+     */
+    int getExtent();
+}

src/org/openstreetmap/josm/data/osm/visitor/paint/StyledMapRenderer.java

@@ -1637 +1637 @@
         RenderBenchmarkCollector benchmark = benchmarkFactory.get();
         BBox bbox = bounds.toBBox();
         getSettings(renderVirtualNodes);
-
         try {
             if (data.getReadLock().tryLock(1, TimeUnit.SECONDS)) {
                 try {

src/org/openstreetmap/josm/data/osm/IPrimitive.java

@@ -369 +369 @@
         return getName();
     }
 
+    /**
+     * Get an object to synchronize the style cache on. This <i>should</i> be a field that does not change during paint.
+     * By default, it returns the current object, but should be overriden to avoid some performance issues.
+     * @return A non-{@code null} object to synchronize on when painting
+     */
+    default Object getStyleCacheSyncObject() {
+        return this;
+    }
+
     /**
      * Replies the display name of a primitive formatted by <code>formatter</code>
      * @param formatter formatter to use

src/org/openstreetmap/josm/data/osm/IRelationMember.java

@@ -66 +66 @@
      * @since 13766 (IRelationMember)
      */
     P getMember();
+
+    /**
+     * Returns the relation member as a way.
+     * @return Member as a way
+     * @since xxx
+     */
+    default IWay<?> getWay() {
+        return (IWay<?>) getMember();
+    }
 }

new file src/org/openstreetmap/josm/data/osm/IWaySegment.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.osm;
+
+import java.awt.geom.Line2D;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.util.Arrays;
+import java.util.Objects;
+
+import org.openstreetmap.josm.tools.Logging;
+
+/**
+ * A segment consisting of 2 consecutive nodes out of a way.
+ * @author Taylor Smock
+ * @param <N> The node type
+ * @param <W> The way type
+ * @since xxx
+ */
+public class IWaySegment<N extends INode, W extends IWay<N>> implements Comparable<IWaySegment<N, W>> {
+
+    /**
+     * The way.
+     */
+    public final W way;
+
+    /**
+     * The index of one of the 2 nodes in the way.  The other node has the
+     * index <code>lowerIndex + 1</code>.
+     */
+    public final int lowerIndex;
+
+    /**
+     * Constructs a new {@code IWaySegment}.
+     * @param w The way
+     * @param i The node lower index
+     * @throws IllegalArgumentException in case of invalid index
+     */
+    public IWaySegment(W w, int i) {
+        way = w;
+        lowerIndex = i;
+        if (i < 0 || i >= w.getNodesCount() - 1) {
+            throw new IllegalArgumentException(toString());
+        }
+    }
+
+    /**
+     * Returns the first node of the way segment.
+     * @return the first node
+     */
+    public N getFirstNode() {
+        return way.getNode(lowerIndex);
+    }
+
+    /**
+     * Returns the second (last) node of the way segment.
+     * @return the second node
+     */
+    public N getSecondNode() {
+        return way.getNode(lowerIndex + 1);
+    }
+
+    /**
+     * Determines and returns the way segment for the given way and node pair.
+     * @param way way
+     * @param first first node
+     * @param second second node
+     * @return way segment
+     * @throws IllegalArgumentException if the node pair is not part of way
+     */
+    public static <N extends INode, W extends IWay<N>> IWaySegment<N, W> forNodePair(W way, N first, N second) {
+        int endIndex = way.getNodesCount() - 1;
+        while (endIndex > 0) {
+            final int indexOfFirst = way.getNodes().subList(0, endIndex).lastIndexOf(first);
+            if (second.equals(way.getNode(indexOfFirst + 1))) {
+                return new IWaySegment<>(way, indexOfFirst);
+            }
+            endIndex--;
+        }
+        throw new IllegalArgumentException("Node pair is not part of way!");
+    }
+
+    /**
+     * Returns this way segment as complete way.
+     * @return the way segment as {@code Way}
+     * @throws IllegalAccessException See {@link Constructor#newInstance}
+     * @throws IllegalArgumentException See {@link Constructor#newInstance}
+     * @throws InstantiationException See {@link Constructor#newInstance}
+     * @throws InvocationTargetException See {@link Constructor#newInstance}
+     * @throws NoSuchMethodException See {@link Class#getConstructor}
+     */
+    public W toWay()
+      throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
+        // If the number of nodes is 2, then don't bother creating a new way
+        if (this.way.getNodes().size() == 2) {
+            return this.way;
+        }
+        // Since the way determines the generic class, this.way.getClass() is always Class<W>, assuming
+        // that way remains the defining element for the type, and remains final.
+        @SuppressWarnings("unchecked")
+        Class<W> clazz = (Class<W>) this.way.getClass();
+        Constructor<W> constructor;
+        W w;
+        try {
+            // Check for clone constructor
+            constructor = clazz.getConstructor(clazz);
+            w = constructor.newInstance(this.way);
+        } catch (NoSuchMethodException e) {
+            Logging.trace(e);
+            constructor = clazz.getConstructor();
+            w = constructor.newInstance();
+        }
+
+        w.setNodes(Arrays.asList(getFirstNode(), getSecondNode()));
+        return w;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        IWaySegment<?, ?> that = (IWaySegment<?, ?>) o;
+        return lowerIndex == that.lowerIndex &&
+          Objects.equals(way, that.way);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(way, lowerIndex);
+    }
+
+    @Override
+    public int compareTo(IWaySegment o) {
+        final W thisWay;
+        final IWay<?> otherWay;
+        try {
+            thisWay = toWay();
+            otherWay = o == null ? null : o.toWay();
+        } catch (ReflectiveOperationException e) {
+            Logging.error(e);
+            return -1;
+        }
+        return o == null ? -1 : (equals(o) ? 0 : thisWay.compareTo(otherWay));
+    }
+
+    /**
+     * Checks whether this segment crosses other segment
+     *
+     * @param s2 The other segment
+     * @return true if both segments crosses
+     */
+    public boolean intersects(IWaySegment<?, ?> s2) {
+        if (getFirstNode().equals(s2.getFirstNode()) || getSecondNode().equals(s2.getSecondNode()) ||
+          getFirstNode().equals(s2.getSecondNode()) || getSecondNode().equals(s2.getFirstNode()))
+            return false;
+
+        return Line2D.linesIntersect(
+          getFirstNode().getEastNorth().east(), getFirstNode().getEastNorth().north(),
+          getSecondNode().getEastNorth().east(), getSecondNode().getEastNorth().north(),
+          s2.getFirstNode().getEastNorth().east(), s2.getFirstNode().getEastNorth().north(),
+          s2.getSecondNode().getEastNorth().east(), s2.getSecondNode().getEastNorth().north());
+    }
+
+    /**
+     * Checks whether this segment and another way segment share the same points
+     * @param s2 The other segment
+     * @return true if other way segment is the same or reverse
+     */
+    public boolean isSimilar(IWaySegment<?, ?> s2) {
+        return (getFirstNode().equals(s2.getFirstNode()) && getSecondNode().equals(s2.getSecondNode()))
+          || (getFirstNode().equals(s2.getSecondNode()) && getSecondNode().equals(s2.getFirstNode()));
+    }
+
+    @Override
+    public String toString() {
+        return "IWaySegment [way=" + way.getUniqueId() + ", lowerIndex=" + lowerIndex + ']';
+    }
+}

src/org/openstreetmap/josm/data/osm/RelationMember.java

@@ -57 +57 @@
      * @return Member as way
      * @since 1937
      */
+    @Override
     public Way getWay() {
         return (Way) member;
     }

src/org/openstreetmap/josm/data/osm/WaySegment.java

@@ -1 +1 @@
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.data.osm;
 
-import java.awt.geom.Line2D;
-import java.util.Objects;
-
 /**
  * A segment consisting of 2 consecutive nodes out of a way.
  */
-public final class WaySegment implements Comparable<WaySegment> {
-
-    /**
-     * The way.
-     */
-    public final Way way;
-
-    /**
-     * The index of one of the 2 nodes in the way.  The other node has the
-     * index <code>lowerIndex + 1</code>.
-     */
-    public final int lowerIndex;
+public final class WaySegment extends IWaySegment<Node, Way> {
 
     /**
-     * Constructs a new {@code WaySegment}.
-     * @param w The way
-     * @param i The node lower index
+     * Constructs a new {@code IWaySegment}.
+     *
+     * @param way The way
+     * @param i   The node lower index
      * @throws IllegalArgumentException in case of invalid index
      */
-    public WaySegment(Way w, int i) {
-        way = w;
-        lowerIndex = i;
-        if (i < 0 || i >= w.getNodesCount() - 1) {
-            throw new IllegalArgumentException(toString());
-        }
-    }
-
-    /**
-     * Returns the first node of the way segment.
-     * @return the first node
-     */
-    public Node getFirstNode() {
-        return way.getNode(lowerIndex);
+    public WaySegment(Way way, int i) {
+        super(way, i);
     }
 
     /**
-     * Returns the second (last) node of the way segment.
-     * @return the second node
-     */
-    public Node getSecondNode() {
-        return way.getNode(lowerIndex + 1);
-    }
-
-    /**
-     * Determines and returns the way segment for the given way and node pair.
+     * Determines and returns the way segment for the given way and node pair. You should prefer
+     * {@link IWaySegment#forNodePair(IWay, INode, INode)} whenever possible.
+     *
      * @param way way
      * @param first first node
      * @param second second node
@@ -74 +43 @@
      * Returns this way segment as complete way.
      * @return the way segment as {@code Way}
      */
+    @Override
     public Way toWay() {
         Way w = new Way();
         w.addNode(getFirstNode());
@@ -81 +51 @@
         return w;
     }
 
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
-        WaySegment that = (WaySegment) o;
-        return lowerIndex == that.lowerIndex &&
-                Objects.equals(way, that.way);
-    }
-
-    @Override
-    public int hashCode() {
-        return Objects.hash(way, lowerIndex);
-    }
-
-    @Override
-    public int compareTo(WaySegment o) {
-        return o == null ? -1 : (equals(o) ? 0 : toWay().compareTo(o.toWay()));
-    }
-
-    /**
-     * Checks whether this segment crosses other segment
-     *
-     * @param s2 The other segment
-     * @return true if both segments crosses
-     */
-    public boolean intersects(WaySegment s2) {
-        if (getFirstNode().equals(s2.getFirstNode()) || getSecondNode().equals(s2.getSecondNode()) ||
-                getFirstNode().equals(s2.getSecondNode()) || getSecondNode().equals(s2.getFirstNode()))
-            return false;
-
-        return Line2D.linesIntersect(
-                getFirstNode().getEastNorth().east(), getFirstNode().getEastNorth().north(),
-                getSecondNode().getEastNorth().east(), getSecondNode().getEastNorth().north(),
-                s2.getFirstNode().getEastNorth().east(), s2.getFirstNode().getEastNorth().north(),
-                s2.getSecondNode().getEastNorth().east(), s2.getSecondNode().getEastNorth().north());
-    }
-
-    /**
-     * Checks whether this segment and another way segment share the same points
-     * @param s2 The other segment
-     * @return true if other way segment is the same or reverse
-     */
-    public boolean isSimilar(WaySegment s2) {
-        return (getFirstNode().equals(s2.getFirstNode()) && getSecondNode().equals(s2.getSecondNode()))
-            || (getFirstNode().equals(s2.getSecondNode()) && getSecondNode().equals(s2.getFirstNode()));
-    }
-
     @Override
     public String toString() {
         return "WaySegment [way=" + way.getUniqueId() + ", lowerIndex=" + lowerIndex + ']';

new file src/org/openstreetmap/josm/data/protobuf/ProtoBufPacked.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.protobuf;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Parse packed values (only numerical values)
+ *
+ * @author Taylor Smock
+ * @since xxx
+ */
+public class ProtoBufPacked {
+    private final byte[] bytes;
+    private final Number[] numbers;
+    private int location;
+
+    /**
+     * Create a new ProtoBufPacked object
+     *
+     * @param bytes The packed bytes
+     */
+    public ProtoBufPacked(byte[] bytes) {
+        this.location = 0;
+        this.bytes = bytes;
+        List<Number> numbersT = new ArrayList<>();
+        while (this.location < bytes.length) {
+            numbersT.add(ProtoBufParser.convertByteArray(this.nextVarInt(), ProtoBufParser.VAR_INT_BYTE_SIZE));
+        }
+
+        this.numbers = new Number[numbersT.size()];
+        for (int i = 0; i < numbersT.size(); i++) {
+            this.numbers[i] = numbersT.get(i);
+        }
+    }
+
+    /**
+     * The number of expected values
+     *
+     * @return The expected values
+     */
+    public int size() {
+        return this.numbers.length;
+    }
+
+    /**
+     * Get the parsed number array
+     *
+     * @return The number array
+     */
+    public Number[] getArray() {
+        return this.numbers;
+    }
+
+    private byte[] nextVarInt() {
+        List<Byte> byteList = new ArrayList<>();
+        while ((this.bytes[this.location] & ProtoBufParser.MOST_SIGNIFICANT_BYTE)
+          == ProtoBufParser.MOST_SIGNIFICANT_BYTE) {
+            // Get rid of the leading bit (shift left 1, then shift right 1 unsigned)
+            byteList.add((byte) (this.bytes[this.location++] ^ ProtoBufParser.MOST_SIGNIFICANT_BYTE));
+        }
+        // The last byte doesn't drop the most significant bit
+        byteList.add(this.bytes[this.location++]);
+        byte[] byteArray = new byte[byteList.size()];
+        for (int i = 0; i < byteList.size(); i++) {
+            byteArray[i] = byteList.get(i);
+        }
+
+        return byteArray;
+    }
+}

new file src/org/openstreetmap/josm/data/protobuf/ProtoBufParser.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.protobuf;
+
+import java.io.BufferedInputStream;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import org.openstreetmap.josm.tools.Logging;
+
+/**
+ * A basic Protobuf parser
+ *
+ * @author Taylor Smock
+ * @since xxx
+ */
+public class ProtoBufParser implements AutoCloseable {
+    /**
+     * The default byte size (see {@link #VAR_INT_BYTE_SIZE} for var ints)
+     */
+    public static final byte BYTE_SIZE = 8;
+    /**
+     * The byte size for var ints (since the first byte is just an indicator for if the var int is done)
+     */
+    public static final byte VAR_INT_BYTE_SIZE = BYTE_SIZE - 1;
+    /**
+     * Used to get the most significant byte
+     */
+    static final byte MOST_SIGNIFICANT_BYTE = (byte) (1 << 7);
+    // TODO switch to a better parser
+    private final InputStream inputStream;
+
+    /**
+     * Create a new parser
+     *
+     * @param bytes The bytes to parse
+     */
+    public ProtoBufParser(byte[] bytes) {
+        this(new ByteArrayInputStream(bytes));
+    }
+
+    /**
+     * Create a new parser
+     *
+     * @param inputStream The InputStream (will be fully read at this time)
+     */
+    public ProtoBufParser(InputStream inputStream) {
+        if (inputStream.markSupported()) {
+            this.inputStream = inputStream;
+        } else {
+            this.inputStream = new BufferedInputStream(inputStream);
+        }
+    }
+
+    /**
+     * Convert a byte array to a number (little endian)
+     *
+     * @param bytes    The bytes to convert
+     * @param byteSize The size of the byte. For var ints, this is 7, for other ints, this is 8.
+     * @return An appropriate {@link Number} class.
+     */
+    public static Number convertByteArray(byte[] bytes, byte byteSize) {
+        long number = 0;
+        for (int i = 0; i < bytes.length; i++) {
+            // Need to convert to uint64 in order to avoid bit operation from filling in 1's and overflow issues
+            number += Byte.toUnsignedLong(bytes[i]) << (byteSize * i);
+        }
+        return convertLong(number);
+    }
+
+    /**
+     * Convert a long to an appropriate {@link Number} class
+     *
+     * @param number The long to convert
+     * @return A {@link Number}
+     */
+    public static Number convertLong(long number) {
+        // TODO deal with booleans
+        if (number <= Byte.MAX_VALUE && number >= Byte.MIN_VALUE) {
+            return (byte) number;
+        } else if (number <= Short.MAX_VALUE && number >= Short.MIN_VALUE) {
+            return (short) number;
+        } else if (number <= Integer.MAX_VALUE && number >= Integer.MIN_VALUE) {
+            return (int) number;
+        }
+        return number;
+    }
+
+    /**
+     * Decode a zig-zag encoded value
+     *
+     * @param signed The value to decode
+     * @return The decoded value
+     */
+    public static Number decodeZigZag(Number signed) {
+        final long value = signed.longValue();
+        return convertLong((value >> 1) ^ -(value & 1));
+    }
+
+    /**
+     * Encode a number to a zig-zag encode value
+     *
+     * @param signed The number to encode
+     * @return The encoded value
+     */
+    public static Number encodeZigZag(Number signed) {
+        final long value = signed.longValue();
+        final int shift = (value > Integer.MAX_VALUE ? Long.BYTES : Integer.BYTES) * 8 - 1;
+        return convertLong((value << 1) ^ (value >>> shift));
+    }
+
+    @Override
+    public void close() {
+        try {
+            this.inputStream.close();
+        } catch (IOException e) {
+            Logging.error(e);
+        }
+    }
+
+    /**
+     * Get the "next" WireType
+     *
+     * @return {@link WireType} expected
+     * @throws IOException - if an IO error occurs
+     */
+    public WireType next() throws IOException {
+        this.inputStream.mark(16);
+        try {
+            return WireType.values()[this.inputStream.read() << 3];
+        } finally {
+            this.inputStream.reset();
+        }
+    }
+
+    /**
+     * Get the next byte
+     *
+     * @return The next byte
+     * @throws IOException - if an IO error occurs
+     */
+    public int nextByte() throws IOException {
+        return this.inputStream.read();
+    }
+
+    /**
+     * Check if there is more data to read
+     *
+     * @return {@code true} if there is more data to read
+     * @throws IOException - if an IO error occurs
+     */
+    public boolean hasNext() throws IOException {
+        return this.inputStream.available() > 0;
+    }
+
+    /**
+     * Get the next var int ({@code WireType#VARINT})
+     *
+     * @return The next var int ({@code int32}, {@code int64}, {@code uint32}, {@code uint64}, {@code bool}, {@code enum})
+     * @throws IOException - if an IO error occurs
+     */
+    public byte[] nextVarInt() throws IOException {
+        List<Byte> byteList = new ArrayList<>();
+        int currentByte = this.nextByte();
+        while ((byte) (currentByte & MOST_SIGNIFICANT_BYTE) == MOST_SIGNIFICANT_BYTE) {
+            // Get rid of the leading bit (shift left 1, then shift right 1 unsigned)
+            byteList.add((byte) (currentByte ^ MOST_SIGNIFICANT_BYTE));
+            currentByte = this.nextByte();
+        }
+        // The last byte doesn't drop the most significant bit
+        byteList.add((byte) currentByte);
+        byte[] byteArray = new byte[byteList.size()];
+        for (int i = 0; i < byteList.size(); i++) {
+            byteArray[i] = byteList.get(i);
+        }
+
+        return byteArray;
+    }
+
+    /**
+     * Get the next 32 bits ({@link WireType#THIRTY_TWO_BIT})
+     *
+     * @return a byte array of the next 32 bits (4 bytes)
+     * @throws IOException - if an IO error occurs
+     */
+    public byte[] nextFixed32() throws IOException {
+        // 4 bytes == 32 bits
+        return readNextBytes(4);
+    }
+
+    /**
+     * Get the next 64 bits ({@link WireType#SIXTY_FOUR_BIT})
+     *
+     * @return a byte array of the next 64 bits (8 bytes)
+     * @throws IOException - if an IO error occurs
+     */
+    public byte[] nextFixed64() throws IOException {
+        // 8 bytes == 64 bits
+        return readNextBytes(8);
+    }
+
+    /**
+     * Read an arbitrary number of bytes
+     *
+     * @param size The number of bytes to read
+     * @return a byte array of the specified size, filled with bytes read (unsigned)
+     * @throws IOException - if an IO error occurs
+     */
+    private byte[] readNextBytes(int size) throws IOException {
+        byte[] bytesRead = new byte[size];
+        for (int i = 0; i < bytesRead.length; i++) {
+            bytesRead[i] = (byte) this.nextByte();
+        }
+        return bytesRead;
+    }
+
+    /**
+     * Get the next delimited message ({@link WireType#LENGTH_DELIMITED})
+     *
+     * @return The next length delimited message
+     * @throws IOException - if an IO error occurs
+     */
+    public byte[] nextLengthDelimited() throws IOException {
+        int length = convertByteArray(this.nextVarInt(), VAR_INT_BYTE_SIZE).intValue();
+        return readNextBytes(length);
+    }
+
+    /**
+     * Read all records
+     *
+     * @return A collection of all records
+     * @throws IOException - if an IO error occurs
+     */
+    public Collection<ProtoBufRecord> allRecords() throws IOException {
+        Collection<ProtoBufRecord> records = new ArrayList<>();
+        while (this.hasNext()) {
+            records.add(new ProtoBufRecord(this));
+        }
+        return records;
+    }
+}

new file src/org/openstreetmap/josm/data/protobuf/ProtoBufRecord.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.protobuf;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.stream.Stream;
+
+import org.openstreetmap.josm.tools.Utils;
+
+/**
+ * A protobuf record, storing the {@link WireType}, the parsed field number, and the bytes for it.
+ *
+ * @author Taylor Smock
+ * @since xxx
+ */
+public class ProtoBufRecord implements AutoCloseable {
+    private static final byte[] EMPTY_BYTES = {};
+    private final WireType type;
+    private final int field;
+    private byte[] bytes;
+
+    /**
+     * Create a new Protobuf record
+     *
+     * @param parser The parser to use to create the record
+     * @throws IOException - if an IO error occurs
+     */
+    public ProtoBufRecord(ProtoBufParser parser) throws IOException {
+        Number number = ProtoBufParser.convertByteArray(parser.nextVarInt(), ProtoBufParser.VAR_INT_BYTE_SIZE);
+        // I don't foresee having field numbers > {@code Integer#MAX_VALUE >> 3}
+        this.field = (int) number.longValue() >> 3;
+        // 7 is 111 (so last three bits)
+        byte wireType = (byte) (number.longValue() & 7);
+        this.type = Stream.of(WireType.values()).filter(wType -> wType.getTypeRepresentation() == wireType).findFirst()
+          .orElse(WireType.UNKNOWN);
+
+        if (this.type == WireType.VARINT) {
+            this.bytes = parser.nextVarInt();
+        } else if (this.type == WireType.SIXTY_FOUR_BIT) {
+            this.bytes = parser.nextFixed64();
+        } else if (this.type == WireType.THIRTY_TWO_BIT) {
+            this.bytes = parser.nextFixed32();
+        } else if (this.type == WireType.LENGTH_DELIMITED) {
+            this.bytes = parser.nextLengthDelimited();
+        } else {
+            this.bytes = EMPTY_BYTES;
+        }
+    }
+
+    /**
+     * Get the field value
+     *
+     * @return The field value
+     */
+    public int getField() {
+        return this.field;
+    }
+
+    /**
+     * Get the WireType of the data
+     *
+     * @return The {@link WireType} of the data
+     */
+    public WireType getType() {
+        return this.type;
+    }
+
+    /**
+     * Get the raw bytes for this record
+     *
+     * @return The bytes
+     */
+    public byte[] getBytes() {
+        return this.bytes;
+    }
+
+    /**
+     * Get the var int ({@code WireType#VARINT})
+     *
+     * @return The var int ({@code int32}, {@code int64}, {@code uint32}, {@code uint64}, {@code bool}, {@code enum})
+     */
+    public Number asUnsignedVarInt() {
+        return ProtoBufParser.convertByteArray(this.bytes, ProtoBufParser.VAR_INT_BYTE_SIZE);
+    }
+
+    /**
+     * Get the signed var int ({@code WireType#VARINT}).
+     * These are specially encoded so that they take up less space.
+     *
+     * @return The signed var int ({@code sint32} or {@code sint64})
+     */
+    public Number asSignedVarInt() {
+        final Number signed = this.asUnsignedVarInt();
+        return ProtoBufParser.decodeZigZag(signed);
+    }
+
+    /**
+     * Get as a double ({@link WireType#SIXTY_FOUR_BIT})
+     *
+     * @return the double
+     */
+    public double asDouble() {
+        long doubleNumber = ProtoBufParser.convertByteArray(asFixed64(), ProtoBufParser.BYTE_SIZE).longValue();
+        return Double.longBitsToDouble(doubleNumber);
+    }
+
+    /**
+     * Get as a float ({@link WireType#THIRTY_TWO_BIT})
+     *
+     * @return the float
+     */
+    public float asFloat() {
+        int floatNumber = ProtoBufParser.convertByteArray(asFixed32(), ProtoBufParser.BYTE_SIZE).intValue();
+        return Float.intBitsToFloat(floatNumber);
+    }
+
+    /**
+     * Get as a string ({@link WireType#LENGTH_DELIMITED})
+     *
+     * @return The string (encoded as {@link StandardCharsets#UTF_8})
+     */
+    public String asString() {
+        return Utils.intern(new String(this.bytes, StandardCharsets.UTF_8));
+    }
+
+    /**
+     * Get as 32 bits ({@link WireType#THIRTY_TWO_BIT})
+     *
+     * @return a byte array of the 32 bits (4 bytes)
+     */
+    public byte[] asFixed32() {
+        // TODO verify, or just assume?
+        // 4 bytes == 32 bits
+        return this.bytes;
+    }
+
+    /**
+     * Get as 64 bits ({@link WireType#SIXTY_FOUR_BIT})
+     *
+     * @return a byte array of the 64 bits (8 bytes)
+     */
+    public byte[] asFixed64() {
+        // TODO verify, or just assume?
+        // 8 bytes == 64 bits
+        return this.bytes;
+    }
+
+    @Override
+    public void close() {
+        this.bytes = null;
+    }
+}

new file src/org/openstreetmap/josm/data/protobuf/WireType.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.protobuf;
+
+/**
+ * The WireTypes
+ *
+ * @author Taylor Smock
+ * @since xxx
+ */
+public enum WireType {
+    /**
+     * int32, int64, uint32, uint64, sing32, sint64, bool, enum
+     */
+    VARINT(0),
+    /**
+     * fixed64, sfixed64, double
+     */
+    SIXTY_FOUR_BIT(1),
+    /**
+     * string, bytes, embedded messages, packed repeated fields
+     */
+    LENGTH_DELIMITED(2),
+    /**
+     * start groups
+     *
+     * @deprecated Unknown reason. Deprecated since at least 2012.
+     */
+    @Deprecated
+    START_GROUP(3),
+    /**
+     * end groups
+     *
+     * @deprecated Unknown reason. Deprecated since at least 2012.
+     */
+    @Deprecated
+    END_GROUP(4),
+    /**
+     * fixed32, sfixed32, float
+     */
+    THIRTY_TWO_BIT(5),
+
+    /**
+     * For unknown WireTypes
+     */
+    UNKNOWN(Byte.MAX_VALUE);
+
+    private final byte type;
+
+    WireType(int value) {
+        this.type = (byte) value;
+    }
+
+    /**
+     * Get the type representation (byte form)
+     *
+     * @return The wire type byte representation
+     */
+    public byte getTypeRepresentation() {
+        return this.type;
+    }
+}

new file src/org/openstreetmap/josm/data/vector/DataLayer.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.vector;
+
+/**
+ * An interface for objects that are part of a data layer
+ * @param <T> The type used to identify a layer, typically a string
+ */
+public interface DataLayer<T> {
+    /**
+     * Get the layer
+     * @return The layer
+     */
+    T getLayer();
+
+    /**
+     * Set the layer
+     * @param layer The layer to set
+     * @return {@code true} if the layer was set -- some objects may never change layers.
+     */
+    default boolean setLayer(T layer) {
+        return layer != null && layer.equals(getLayer());
+    }
+}

new file src/org/openstreetmap/josm/data/vector/VectorDataSet.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.vector;
+
+import java.awt.geom.Area;
+import java.awt.geom.Ellipse2D;
+import java.awt.geom.Path2D;
+import java.awt.geom.PathIterator;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.openstreetmap.gui.jmapviewer.Coordinate;
+import org.openstreetmap.gui.jmapviewer.Tile;
+import org.openstreetmap.gui.jmapviewer.interfaces.ICoordinate;
+import org.openstreetmap.josm.data.DataSource;
+import org.openstreetmap.josm.data.imagery.vectortile.VectorTile;
+import org.openstreetmap.josm.data.imagery.vectortile.mapbox.Feature;
+import org.openstreetmap.josm.data.imagery.vectortile.mapbox.Layer;
+import org.openstreetmap.josm.data.osm.BBox;
+import org.openstreetmap.josm.data.osm.DataSelectionListener;
+import org.openstreetmap.josm.data.osm.DownloadPolicy;
+import org.openstreetmap.josm.data.osm.HighlightUpdateListener;
+import org.openstreetmap.josm.data.osm.INode;
+import org.openstreetmap.josm.data.osm.IPrimitive;
+import org.openstreetmap.josm.data.osm.IRelation;
+import org.openstreetmap.josm.data.osm.IWay;
+import org.openstreetmap.josm.data.osm.OsmData;
+import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
+import org.openstreetmap.josm.data.osm.PrimitiveId;
+import org.openstreetmap.josm.data.osm.QuadBucketPrimitiveStore;
+import org.openstreetmap.josm.data.osm.SimplePrimitiveId;
+import org.openstreetmap.josm.data.osm.Storage;
+import org.openstreetmap.josm.data.osm.UniqueIdGenerator;
+import org.openstreetmap.josm.data.osm.UploadPolicy;
+import org.openstreetmap.josm.data.osm.WaySegment;
+import org.openstreetmap.josm.gui.dialogs.relation.sort.RelationSorter;
+import org.openstreetmap.josm.gui.mappaint.ElemStyles;
+import org.openstreetmap.josm.tools.Geometry;
+import org.openstreetmap.josm.tools.ListenerList;
+import org.openstreetmap.josm.tools.Logging;
+import org.openstreetmap.josm.tools.SubclassFilteredCollection;
+
+/**
+ * A data class for Vector Data
+ *
+ * @author Taylor Smock
+ * @since xxx
+ */
+public class VectorDataSet implements OsmData<VectorPrimitive, VectorNode, VectorWay, VectorRelation> {
+    // Note: In Java 8, computeIfAbsent is blocking for both pre-existing and new values. In Java 9, it is only blocking
+    // for new values (perf increase). See JDK-8161372 for more info.
+    private final Map<Integer, VectorDataStore> dataStoreMap = new ConcurrentHashMap<>();
+    private final Collection<PrimitiveId> selected = new HashSet<>();
+    // Both of these listener lists are useless, since they expect OsmPrimitives at this time
+    private final ListenerList<HighlightUpdateListener> highlightUpdateListenerListenerList = ListenerList.create();
+    private final ListenerList<DataSelectionListener> dataSelectionListenerListenerList = ListenerList.create();
+    private boolean lock = true;
+    private final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
+    private String name;
+    private short mappaintCacheIdx = 1;
+
+    /**
+     * The distance to consider nodes duplicates -- mostly a memory saving measure.
+     * 0.000_000_1 ~1.2 cm (+- 5.57 mm)
+     * Descriptions from <a href="https://xkcd.com/2170/">https://xkcd.com/2170/</a>
+     * Notes on <a href="https://wiki.openstreetmap.org/wiki/Node">https://wiki.openstreetmap.org/wiki/Node</a> indicate
+     * that IEEE 32-bit floats should not be used at high longitude (0.000_01 precision)
+     */
+    protected static final float DUPE_NODE_DISTANCE = 0.000_000_1f;
+
+    /**
+     * The current zoom we are getting/adding to
+     */
+    private int zoom;
+    /**
+     * Default to normal download policy
+     */
+    private DownloadPolicy downloadPolicy = DownloadPolicy.NORMAL;
+    /**
+     * Default to a blocked upload policy
+     */
+    private UploadPolicy uploadPolicy = UploadPolicy.BLOCKED;
+    /**
+     * The paint style for this layer
+     */
+    private ElemStyles styles;
+
+    @Override public Collection<DataSource> getDataSources() {
+        final int currentZoom = this.zoom;
+        final VectorDataStore dataStore = this.dataStoreMap.computeIfAbsent(currentZoom, VectorDataStore::new);
+        return dataStore.getDataSources();
+    }
+
+    /**
+     * Add a data source
+     *
+     * @param currentZoom the zoom
+     * @param dataSource  The datasource to add at the zoom level
+     */
+    public void addDataSource(int currentZoom, DataSource dataSource) {
+        final VectorDataStore dataStore = this.dataStoreMap.computeIfAbsent(currentZoom, VectorDataStore::new);
+        dataStore.addDataSource(dataSource);
+    }
+
+    @Override public void lock() {
+        this.lock = true;
+    }
+
+    @Override public void unlock() {
+        this.lock = false;
+    }
+
+    @Override public boolean isLocked() {
+        return this.lock;
+    }
+
+    @Override public String getVersion() {
+        return "8"; // TODO
+    }
+
+    @Override public String getName() {
+        return this.name;
+    }
+
+    @Override public void setName(String name) {
+        this.name = name;
+    }
+
+    @Override public void addPrimitive(VectorPrimitive primitive) {
+        primitive.setDataSet(this);
+        final int currentZoom = this.zoom;
+        this.tryWrite(() -> {
+            final VectorDataStore dataStore = this.dataStoreMap.computeIfAbsent(currentZoom, VectorDataStore::new);
+            dataStore.addPrimitive(primitive);
+        });
+    }
+
+    /**
+     * Remove a primitive from this dataset
+     *
+     * @param primitive The primitive to remove
+     */
+    protected void removePrimitive(VectorPrimitive primitive) {
+        if (primitive.getDataSet() == this) {
+            final int currentZoom = this.zoom;
+            primitive.setDataSet(null);
+            this.tryWrite(() -> {
+                final VectorDataStore dataStore = this.dataStoreMap.computeIfAbsent(currentZoom, VectorDataStore::new);
+                dataStore.removePrimitive(primitive);
+            });
+        }
+    }
+
+    @Override public void clear() {
+        this.tryWrite(this.dataStoreMap::clear);
+    }
+
+    @Override public List<VectorNode> searchNodes(BBox bbox) {
+        return this.tryRead(() -> {
+            final int currentZoom = this.zoom;
+            final VectorDataStore dataStore = this.dataStoreMap.computeIfAbsent(currentZoom, VectorDataStore::new);
+            return dataStore.getStore().searchNodes(bbox);
+        }).orElseGet(Collections::emptyList);
+    }
+
+    @Override public boolean containsNode(VectorNode vectorNode) {
+        return this.tryRead(() -> {
+            final int currentZoom = this.zoom;
+            final VectorDataStore dataStore = this.dataStoreMap.computeIfAbsent(currentZoom, VectorDataStore::new);
+            return dataStore.getStore().containsNode(vectorNode);
+        }).orElse(false);
+    }
+
+    @Override public List<VectorWay> searchWays(BBox bbox) {
+        return this.tryRead(() -> {
+            final int currentZoom = this.zoom;
+            final VectorDataStore dataStore = this.dataStoreMap.computeIfAbsent(currentZoom, VectorDataStore::new);
+            return dataStore.getStore().searchWays(bbox);
+        }).orElseGet(Collections::emptyList);
+    }
+
+    @Override public boolean containsWay(VectorWay vectorWay) {
+        return this.tryRead(() -> {
+            final int currentZoom = this.zoom;
+            final VectorDataStore dataStore = this.dataStoreMap.computeIfAbsent(currentZoom, VectorDataStore::new);
+            return dataStore.getStore().containsWay(vectorWay);
+        }).orElse(false);
+    }
+
+    @Override public List<VectorRelation> searchRelations(BBox bbox) {
+        return this.tryRead(() -> {
+            final int currentZoom = this.zoom;
+            final VectorDataStore dataStore = this.dataStoreMap.computeIfAbsent(currentZoom, VectorDataStore::new);
+            return dataStore.getStore().searchRelations(bbox);
+        }).orElseGet(Collections::emptyList);
+    }
+
+    @Override public boolean containsRelation(VectorRelation vectorRelation) {
+        return this.tryRead(() -> {
+            final int currentZoom = this.zoom;
+            final VectorDataStore dataStore = this.dataStoreMap.computeIfAbsent(currentZoom, VectorDataStore::new);
+            return dataStore.getStore().containsRelation(vectorRelation);
+        }).orElse(false);
+    }
+
+    @Override public VectorPrimitive getPrimitiveById(PrimitiveId primitiveId) {
+        return this.tryRead(() -> {
+            final int currentZoom = this.zoom;
+            final VectorDataStore dataStore = this.dataStoreMap.computeIfAbsent(currentZoom, VectorDataStore::new);
+            return dataStore.getPrimitivesMap().get(primitiveId);
+        }).orElse(null);
+    }
+
+    @Override public <T extends VectorPrimitive> Collection<T> getPrimitives(
+      Predicate<? super VectorPrimitive> predicate) {
+        // index should be negative, as the datastore doesn't have that zoom level
+        // Prefer the higher zoom level
+        Optional<Collection<T>> optional = this.tryRead(() -> {
+            int currentZoom = this.zoom;
+            if (!this.dataStoreMap.containsKey(currentZoom)) {
+                // index should be negative, as the datastore doesn't have that zoom level
+                final int[] keys = this.dataStoreMap.keySet().stream().mapToInt(Integer::intValue).sorted().toArray();
+                final int index = 1 - Arrays.binarySearch(keys, currentZoom);
+                // Prefer the higher zoom level
+                if (index < keys.length - 2) {
+                    currentZoom = keys[index + 1];
+                } else if (index > 0 && keys.length > index - 1) {
+                    currentZoom = keys[index - 1];
+                }
+            }
+            final VectorDataStore dataStore = this.dataStoreMap.computeIfAbsent(currentZoom, VectorDataStore::new);
+            return new SubclassFilteredCollection<>(dataStore.getAllPrimitives(), predicate);
+        });
+        return optional.orElseGet(Collections::emptyList);
+    }
+
+    @Override public Collection<VectorNode> getNodes() {
+        return this.getPrimitives(VectorNode.class::isInstance);
+    }
+
+    @Override public Collection<VectorWay> getWays() {
+        return this.getPrimitives(VectorWay.class::isInstance);
+    }
+
+    @Override public Collection<VectorRelation> getRelations() {
+        return this.getPrimitives(VectorRelation.class::isInstance);
+    }
+
+    @Override public DownloadPolicy getDownloadPolicy() {
+        return this.downloadPolicy;
+    }
+
+    @Override public void setDownloadPolicy(DownloadPolicy downloadPolicy) {
+        this.downloadPolicy = downloadPolicy;
+    }
+
+    @Override public UploadPolicy getUploadPolicy() {
+        return this.uploadPolicy;
+    }
+
+    @Override public void setUploadPolicy(UploadPolicy uploadPolicy) {
+        this.uploadPolicy = uploadPolicy;
+    }
+
+    @Override public Lock getReadLock() {
+        return this.readWriteLock.readLock();
+    }
+
+    @Override public Collection<WaySegment> getHighlightedVirtualNodes() {
+        // TODO?
+        return Collections.emptyList();
+    }
+
+    @Override public void setHighlightedVirtualNodes(Collection<WaySegment> waySegments) {
+        // TODO?
+    }
+
+    @Override public Collection<WaySegment> getHighlightedWaySegments() {
+        // TODO?
+        return Collections.emptyList();
+    }
+
+    @Override public void setHighlightedWaySegments(Collection<WaySegment> waySegments) {
+        // TODO?
+    }
+
+    @Override public void addHighlightUpdateListener(HighlightUpdateListener listener) {
+        this.highlightUpdateListenerListenerList.addListener(listener);
+    }
+
+    @Override public void removeHighlightUpdateListener(HighlightUpdateListener listener) {
+        this.highlightUpdateListenerListenerList.removeListener(listener);
+    }
+
+    @Override public Collection<VectorPrimitive> getAllSelected() {
+        final int currentZoom = this.zoom;
+        final VectorDataStore dataStore = this.dataStoreMap.computeIfAbsent(currentZoom, VectorDataStore::new);
+        return dataStore.getAllPrimitives().stream()
+          .filter(primitive -> this.selected.contains(primitive.getPrimitiveId())).collect(
+            Collectors.toList());
+    }
+
+    @Override public boolean selectionEmpty() {
+        return this.selected.isEmpty();
+    }
+
+    @Override public boolean isSelected(VectorPrimitive osm) {
+        return this.selected.contains(osm.getPrimitiveId());
+    }
+
+    @Override public void toggleSelected(Collection<? extends PrimitiveId> osm) {
+        this.toggleSelectedImpl(osm.stream());
+    }
+
+    @Override public void toggleSelected(PrimitiveId... osm) {
+        this.toggleSelectedImpl(Stream.of(osm));
+    }
+
+    private void toggleSelectedImpl(Stream<? extends PrimitiveId> osm) {
+        osm.forEach(primitiveId -> {
+            if (this.selected.contains(primitiveId)) {
+                this.selected.remove(primitiveId);
+            } else {
+                this.selected.add(primitiveId);
+            }
+        });
+    }
+
+    @Override public void setSelected(Collection<? extends PrimitiveId> selection) {
+        this.setSelectedImpl(selection.stream());
+    }
+
+    @Override public void setSelected(PrimitiveId... osm) {
+        this.setSelectedImpl(Stream.of(osm));
+    }
+
+    private void setSelectedImpl(Stream<? extends PrimitiveId> osm) {
+        this.selected.clear();
+        osm.forEach(this.selected::add);
+    }
+
+    @Override public void addSelected(Collection<? extends PrimitiveId> selection) {
+        this.addSelectedImpl(selection.stream());
+    }
+
+    @Override public void addSelected(PrimitiveId... osm) {
+        this.addSelectedImpl(Stream.of(osm));
+    }
+
+    private void addSelectedImpl(Stream<? extends PrimitiveId> osm) {
+        osm.forEach(this.selected::add);
+    }
+
+    @Override public void clearSelection(PrimitiveId... osm) {
+        this.clearSelectionImpl(Stream.of(osm));
+    }
+
+    @Override public void clearSelection(Collection<? extends PrimitiveId> list) {
+        this.clearSelectionImpl(list.stream());
+    }
+
+    @Override public void clearSelection() {
+        this.clearSelectionImpl(new ArrayList<>(this.selected).stream());
+    }
+
+    private void clearSelectionImpl(Stream<? extends PrimitiveId> osm) {
+        osm.forEach(this.selected::remove);
+    }
+
+    @Override public void addSelectionListener(DataSelectionListener listener) {
+        this.dataSelectionListenerListenerList.addListener(listener);
+    }
+
+    @Override public void removeSelectionListener(DataSelectionListener listener) {
+        this.dataSelectionListenerListenerList.removeListener(listener);
+    }
+
+    public short getMappaintCacheIndex() {
+        return this.mappaintCacheIdx;
+    }
+
+    @Override public void clearMappaintCache() {
+        this.mappaintCacheIdx++;
+    }
+
+    public void setZoom(int zoom) {
+        if (zoom == this.zoom) {
+            return; // Do nothing -- zoom isn't actually changing
+        }
+        this.tryWrite(() -> {
+            this.zoom = zoom;
+            this.clearMappaintCache();
+            final int[] nearestZoom = new int[] {-1, -1, -1};
+            nearestZoom[0] = zoom;
+            // Create a new list to avoid concurrent modification issues
+            final int[] keys = new ArrayList<>(this.dataStoreMap.keySet()).stream().filter(Objects::nonNull)
+              .mapToInt(Integer::intValue).sorted().toArray();
+            final int index;
+            if (this.dataStoreMap.containsKey(zoom)) {
+                index = Arrays.binarySearch(keys, zoom);
+            } else {
+                // (-(insertion point) - 1) = return -> insertion point = -(return + 1)
+                index = -(Arrays.binarySearch(keys, zoom) + 1);
+            }
+            if (index > 0) {
+                nearestZoom[1] = keys[index - 1];
+            }
+            if (index < keys.length - 2) {
+                nearestZoom[2] = keys[index + 1];
+            }
+            // Clear zoom levels not immediately above/below the current zoom level (attempt to save some memory)
+            //IntStream.of(keys).filter(key -> IntStream.of(nearestZoom).noneMatch(zoomKey -> zoomKey == key)).forEach(this.dataStoreMap::remove);
+        });
+    }
+
+    public int getZoom() {
+        return this.zoom;
+    }
+
+    /**
+     * Add tile data to this dataset
+     * @param tile The tile to add
+     * @param <T> The tile type
+     */
+    public <T extends Tile & VectorTile> void addTileData(T tile) {
+        this.tryWrite(() -> {
+            final VectorDataStore dataStore = this.dataStoreMap.computeIfAbsent(tile.getZoom(), VectorDataStore::new);
+            dataStore.addTile(tile);
+        });
+    }
+
+    /**
+     * Try to read something (here to avoid boilerplate)
+     *
+     * @param supplier The reading function
+     * @param <T>      The return type
+     * @return The optional return
+     */
+    private <T> Optional<T> tryRead(Supplier<T> supplier) {
+        try {
+            this.readWriteLock.readLock().lockInterruptibly();
+            return Optional.ofNullable(supplier.get());
+        } catch (InterruptedException e) {
+            Logging.error(e);
+            Thread.currentThread().interrupt();
+        } finally {
+            this.readWriteLock.readLock().unlock();
+        }
+        return Optional.empty();
+    }
+
+    /**
+     * Try to write something (here to avoid boilerplate)
+     *
+     * @param runnable The writing function
+     */
+    private void tryWrite(Runnable runnable) {
+        try {
+            this.readWriteLock.writeLock().lockInterruptibly();
+            runnable.run();
+        } catch (InterruptedException e) {
+            Logging.error(e);
+            Thread.currentThread().interrupt();
+        } finally {
+            if (this.readWriteLock.isWriteLockedByCurrentThread()) {
+                this.readWriteLock.writeLock().unlock();
+            }
+        }
+    }
+
+    /**
+     * Get the styles for this layer
+     *
+     * @return The styles
+     */
+    public ElemStyles getStyles() {
+        return this.styles;
+    }
+
+    /**
+     * Set the styles for this layer
+     * @param styles The styles to set for this layer
+     */
+    public void setStyles(Collection<ElemStyles> styles) {
+        if (styles.size() == 1) {
+            this.styles = styles.iterator().next();
+        } else if (!styles.isEmpty()) {
+            this.styles = new ElemStyles(styles.stream().flatMap(style -> style.getStyleSources().stream()).collect(Collectors.toList()));
+        } else {
+            this.styles = null;
+        }
+    }
+
+    /**
+     * This literally only exists to make {@link QuadBucketPrimitiveStore#removePrimitive} public
+     *
+     * @param <N> The node type
+     * @param <W> The way type
+     * @param <R> The relation type
+     */
+    private static class LocalQuadBucketPrimitiveStore<N extends INode, W extends IWay<N>, R extends IRelation<?>>
+      extends QuadBucketPrimitiveStore<N, W, R> {
+        // Allow us to remove primitives
+        @Override
+        public void removePrimitive(IPrimitive primitive) {
+            if ((primitive instanceof IRelation && this.containsRelation((R) primitive))
+                || (primitive instanceof IWay && this.containsWay((W) primitive))
+                || (primitive instanceof INode && this.containsNode((N) primitive))) {
+                super.removePrimitive(primitive);
+            }
+        }
+    }
+
+    private static class DataStore<O extends IPrimitive, N extends INode, W extends IWay<N>, R extends IRelation<?>> {
+        protected final int zoom;
+        protected final LocalQuadBucketPrimitiveStore<N, W, R> store = new LocalQuadBucketPrimitiveStore<>();
+        protected final Storage<O> allPrimitives = new Storage<>(new Storage.PrimitiveIdHash(), true);
+        protected final Set<Tile> addedTiles = new HashSet<>();
+        protected final Map<PrimitiveId, O> primitivesMap = allPrimitives
+          .foreignKey(new Storage.PrimitiveIdHash());
+        protected final Collection<DataSource> dataSources = new LinkedList<>();
+
+        DataStore(int zoom) {
+            this.zoom = zoom;
+        }
+
+        public int getZoom() {
+            return this.zoom;
+        }
+
+        public QuadBucketPrimitiveStore<N, W, R> getStore() {
+            return this.store;
+        }
+
+        public Storage<O> getAllPrimitives() {
+            return this.allPrimitives;
+        }
+
+        public Map<PrimitiveId, O> getPrimitivesMap() {
+            return this.primitivesMap;
+        }
+
+        public Collection<DataSource> getDataSources() {
+            return Collections.unmodifiableCollection(dataSources);
+        }
+
+        /**
+         * Add a datasource to this data set
+         * @param dataSource The data soure to add
+         */
+        public void addDataSource(DataSource dataSource) {
+            this.dataSources.add(dataSource);
+        }
+
+        /**
+         * Add a primitive to this dataset
+         * @param primitive The primitive to remove
+         */
+        protected void removePrimitive(O primitive) {
+            this.store.removePrimitive(primitive);
+            this.allPrimitives.remove(primitive);
+            this.primitivesMap.remove(primitive.getPrimitiveId());
+        }
+
+        /**
+         * Add a primitive to this dataset
+         * @param primitive The primitive to add
+         */
+        protected void addPrimitive(O primitive) {
+            this.store.addPrimitive(primitive);
+            this.allPrimitives.add(primitive);
+            this.primitivesMap.put(primitive.getPrimitiveId(), primitive);
+        }
+    }
+
+    private class VectorDataStore extends DataStore<VectorPrimitive, VectorNode, VectorWay, VectorRelation> {
+        private static final String JOSM_MERGE_TYPE_KEY = "josm_merge_type";
+
+        VectorDataStore(int zoom) {
+            super(zoom);
+        }
+
+        @Override
+        protected void addPrimitive(VectorPrimitive primitive) {
+            primitive.setDataSet(VectorDataSet.this);
+            // The field is uint64, so we can use negative numbers to indicate that it is a "generated" object (e.g., nodes for ways)
+            if (primitive.getUniqueId() == 0) {
+                final UniqueIdGenerator generator = primitive.getIdGenerator();
+                long id;
+                do {
+                    id = generator.generateUniqueId();
+                } while (this.primitivesMap.containsKey(new SimplePrimitiveId(id, primitive.getType())));
+                primitive.setId(primitive.getIdGenerator().generateUniqueId());
+            }
+            if (primitive instanceof VectorRelation && !primitive.isMultipolygon()) {
+                primitive = mergeWays((VectorRelation) primitive);
+            }
+            final VectorPrimitive alreadyAdded = this.primitivesMap.get(primitive.getPrimitiveId());
+            final VectorRelation mergedRelation = (VectorRelation) this.primitivesMap
+              .get(new SimplePrimitiveId(primitive.getPrimitiveId().getUniqueId(),
+                OsmPrimitiveType.RELATION));
+            if (alreadyAdded == null || alreadyAdded.equals(primitive)) {
+                super.addPrimitive(primitive);
+            } else if (mergedRelation != null && mergedRelation.get(JOSM_MERGE_TYPE_KEY) != null) {
+                mergedRelation.addRelationMember(new VectorRelationMember("", primitive));
+                super.addPrimitive(primitive);
+                // Check that all primitives can be merged
+                if (mergedRelation.getMemberPrimitivesList().stream().allMatch(IWay.class::isInstance)) {
+                    // This pretty much does the "right" thing
+                    this.mergeWays(mergedRelation);
+                } else if (!(primitive instanceof IWay)) {
+                    // Can't merge, ever (one of the childs is a node/relation)
+                    mergedRelation.remove(JOSM_MERGE_TYPE_KEY);
+                }
+            } else if (mergedRelation != null && primitive instanceof IRelation) {
+                // Just add to the relation
+                ((VectorRelation) primitive).getMembers().forEach(mergedRelation::addRelationMember);
+            } else if (alreadyAdded instanceof VectorWay && primitive instanceof VectorWay) {
+                final VectorRelation temporaryRelation =
+                  mergedRelation == null ? new VectorRelation(primitive.getLayer()) : mergedRelation;
+                if (mergedRelation == null) {
+                    temporaryRelation.put(JOSM_MERGE_TYPE_KEY, "merge");
+                    temporaryRelation.addRelationMember(new VectorRelationMember("", alreadyAdded));
+                }
+                temporaryRelation.addRelationMember(new VectorRelationMember("", primitive));
+                temporaryRelation.setDataSet(VectorDataSet.this);
+                super.addPrimitive(primitive);
+                super.addPrimitive(temporaryRelation);
+            }
+        }
+
+        private VectorPrimitive mergeWays(VectorRelation relation) {
+            List<VectorRelationMember> members = RelationSorter.sortMembersByConnectivity(relation.getMembers());
+            Collection<VectorWay> relationWayList = relation.getMemberPrimitivesList().stream()
+              .filter(VectorWay.class::isInstance)
+              .map(VectorWay.class::cast).collect(Collectors.toCollection(ArrayList::new));
+            // Only support way-only relations
+            if (relationWayList.size() != relation.getMemberPrimitivesList().size()) {
+                return relation;
+            }
+            List<VectorWay> wayList = new ArrayList<>(relation.getMembersCount());
+            // Assume that the order may not be correct, worst case O(n), best case O(n/2)
+            // Assume that the ways were drawn in order
+            final int maxIteration = relationWayList.size();
+            int iteration = 0;
+            while (iteration < maxIteration && wayList.size() < relationWayList.size()) {
+                for (VectorWay way : relationWayList) {
+                    if (wayList.isEmpty()) {
+                        wayList.add(way);
+                        continue;
+                    }
+                    // Check first/last ways
+                    if (canMergeWays(wayList.get(0), way, false)) {
+                        wayList.add(0, way);
+                    } else if (canMergeWays(wayList.get(wayList.size() - 1), way, false)) {
+                        wayList.add(way);
+                    }
+                }
+                iteration++;
+                relationWayList.removeIf(wayList::contains);
+            }
+            if (!relationWayList.isEmpty()) {
+                return relation;
+            }
+            // Merge ways
+            List<VectorNode> nodes = new ArrayList<>();
+            for (VectorWay way : wayList) {
+                for (VectorNode node : way.getNodes()) {
+                    if (nodes.isEmpty() || !Objects.equals(nodes.get(nodes.size() - 1), node)) {
+                        nodes.add(node);
+                    }
+                }
+            }
+            VectorWay way = wayList.get(0);
+            way.setNodes(nodes);
+            wayList.remove(way);
+            wayList.forEach(this::removePrimitive);
+            this.removePrimitive(relation);
+            return way;
+        }
+
+        private <N extends INode, W extends IWay<N>> boolean canMergeWays(W old, W toAdd, boolean allowReverse) {
+            final List<N> nodes = new ArrayList<>(old.getNodes());
+            boolean added = true;
+            if (allowReverse && old.firstNode().equals(toAdd.firstNode())) {
+                // old <-|-> new becomes old ->|-> new
+                Collections.reverse(nodes);
+                nodes.addAll(toAdd.getNodes());
+            } else if (old.firstNode().equals(toAdd.lastNode())) {
+                // old <-|<- new, so we prepend the new nodes in order
+                nodes.addAll(0, toAdd.getNodes());
+            } else if (old.lastNode().equals(toAdd.firstNode())) {
+                // old ->|-> new, we just add it
+                nodes.addAll(toAdd.getNodes());
+            } else if (allowReverse && old.lastNode().equals(toAdd.lastNode())) {
+                // old ->|<- new, we need to reverse new
+                final List<N> toAddNodes = new ArrayList<>(toAdd.getNodes());
+                Collections.reverse(toAddNodes);
+                nodes.addAll(toAddNodes);
+            } else {
+                added = false;
+            }
+            if (added) {
+                // This is (technically) always correct
+                old.setNodes(nodes);
+            }
+            return added;
+        }
+
+        private synchronized <T extends Tile & VectorTile> VectorNode pointToNode(T tile, Layer layer,
+          Collection<VectorPrimitive> featureObjects, int x, int y) {
+            final ICoordinate upperLeft = tile.getTileSource().tileXYToLatLon(tile);
+            final int layerExtent = layer.getExtent() * 2;
+            final ICoordinate lowerRight = tile.getTileSource()
+              .tileXYToLatLon(tile.getXtile() + 1, tile.getYtile() + 1, tile.getZoom());
+            final ICoordinate coords = new Coordinate(
+              upperLeft.getLat() - (upperLeft.getLat() - lowerRight.getLat()) * y / layerExtent,
+              upperLeft.getLon() + (lowerRight.getLon() - upperLeft.getLon()) * x / layerExtent);
+            final Collection<VectorNode> nodes = this.store
+              .searchNodes(new BBox(coords.getLon(), coords.getLat(), DUPE_NODE_DISTANCE));
+            final VectorNode node;
+            if (!nodes.isEmpty()) {
+                final VectorNode first = nodes.iterator().next();
+                if (first.isDisabled() || !first.isVisible()) {
+                    // Only replace nodes that are not visible
+                    node = new VectorNode(layer.getName());
+                    node.setCoor(node.getCoor());
+                    first.getReferrers(true).forEach(primitive -> {
+                        if (primitive instanceof VectorWay) {
+                            List<VectorNode> nodeList = new ArrayList<>(((VectorWay) primitive).getNodes());
+                            nodeList.replaceAll(vnode -> vnode.equals(first) ? node : vnode);
+                            ((VectorWay) primitive).setNodes(nodeList);
+                        } else if (primitive instanceof VectorRelation) {
+                            List<VectorRelationMember> members = new ArrayList<>(((VectorRelation) primitive).getMembers());
+                            members.replaceAll(member ->
+                              member.getMember().equals(first) ? new VectorRelationMember(member.getRole(), node): member);
+                            ((VectorRelation) primitive).setMembers(members);
+                        }
+                    });
+                    this.removePrimitive(first);
+                } else {
+                    node = first;
+                }
+            } else {
+                node = new VectorNode(layer.getName());
+            }
+            node.setCoor(coords);
+            featureObjects.add(node);
+            return node;
+        }
+
+        private <T extends Tile & VectorTile> List<VectorWay> pathToWay(T tile, Layer layer,
+          Collection<VectorPrimitive> featureObjects, Path2D shape) {
+            final PathIterator pathIterator = shape.getPathIterator(null);
+            final List<VectorWay> ways = pathIteratorToObjects(tile, layer, featureObjects, pathIterator).stream()
+              .filter(VectorWay.class::isInstance).map(VectorWay.class::cast).collect(
+                Collectors.toList());
+            // These nodes technically do not exist, so we shouldn't show them
+            ways.stream().flatMap(way -> way.getNodes().stream())
+              .filter(prim -> !prim.isTagged() && prim.getReferrers(true).size() == 1 && prim.getId() <= 0)
+              .forEach(prim -> {
+                  prim.setDisabled(true);
+                  prim.setVisible(false);
+              });
+            return ways;
+        }
+
+        private <T extends Tile & VectorTile> List<VectorPrimitive> pathIteratorToObjects(T tile, Layer layer,
+          Collection<VectorPrimitive> featureObjects, PathIterator pathIterator) {
+            final List<VectorNode> nodes = new ArrayList<>();
+            final double[] coords = new double[6];
+            final List<VectorPrimitive> ways = new ArrayList<>();
+            do {
+                final int type = pathIterator.currentSegment(coords);
+                pathIterator.next();
+                if ((PathIterator.SEG_MOVETO == type || PathIterator.SEG_CLOSE == type) && !nodes.isEmpty()) {
+                    if (PathIterator.SEG_CLOSE == type) {
+                        nodes.add(nodes.get(0));
+                    }
+                    // New line
+                    if (!nodes.isEmpty()) {
+                        final VectorWay way = new VectorWay(layer.getName());
+                        way.setNodes(nodes);
+                        featureObjects.add(way);
+                        ways.add(way);
+                    }
+                    nodes.clear();
+                }
+                if (PathIterator.SEG_MOVETO == type || PathIterator.SEG_LINETO == type) {
+                    final VectorNode node = pointToNode(tile, layer, featureObjects, (int) coords[0], (int) coords[1]);
+                    nodes.add(node);
+                } else if (PathIterator.SEG_CLOSE != type) {
+                    // Vector Tiles only have MoveTo, LineTo, and ClosePath. Anything else is not supported at this time.
+                    throw new UnsupportedOperationException();
+                }
+            } while (!pathIterator.isDone());
+            if (!nodes.isEmpty()) {
+                final VectorWay way = new VectorWay(layer.getName());
+                way.setNodes(nodes);
+                featureObjects.add(way);
+                ways.add(way);
+            }
+            return ways;
+        }
+
+        private <T extends Tile & VectorTile> VectorRelation areaToRelation(T tile, Layer layer,
+          Collection<VectorPrimitive> featureObjects, Area area) {
+            final PathIterator pathIterator = area.getPathIterator(null);
+            final List<VectorPrimitive> members = pathIteratorToObjects(tile, layer, featureObjects, pathIterator);
+            VectorRelation vectorRelation = new VectorRelation(layer.getName());
+            for (VectorPrimitive member : members) {
+                final String role;
+                if (member instanceof VectorWay && ((VectorWay) member).isClosed()) {
+                    role = Geometry.isClockwise(((VectorWay) member).getNodes()) ? "outer" : "inner";
+                } else {
+                    role = "";
+                }
+                vectorRelation.addRelationMember(new VectorRelationMember(role, member));
+            }
+            return vectorRelation;
+        }
+
+        /**
+         * Add a tile to this data store
+         * @param tile The tile to add
+         * @param <T> The tile type
+         */
+        public synchronized <T extends Tile & VectorTile> void addTile(T tile) {
+            Optional<Tile> previous = this.addedTiles.stream()
+              .filter(t -> t.getTileXY().equals(tile.getTileXY()) && t.getZoom() == tile.getZoom()).findAny();
+            // Check if we have already added the tile (just to save processing time)
+            if (!previous.isPresent() || (!previous.get().isLoaded() && !previous.get().isLoading())) {
+                previous.ifPresent(this.addedTiles::remove);
+                this.addedTiles.add(tile);
+                for (Layer layer : tile.getLayers()) {
+                    layer.getGeometry().forEach(geometry -> {
+                        List<VectorPrimitive> featureObjects = new ArrayList<>();
+                        List<VectorPrimitive> primaryFeatureObjects = new ArrayList<>();
+                        geometry.getShapes().forEach(shape -> {
+                            final VectorPrimitive primitive;
+                            if (shape instanceof Ellipse2D) {
+                                primitive = pointToNode(tile, layer, featureObjects,
+                                  (int) ((Ellipse2D) shape).getCenterX(), (int) ((Ellipse2D) shape).getCenterY());
+                            } else if (shape instanceof Path2D) {
+                                primitive = pathToWay(tile, layer, featureObjects, (Path2D) shape).stream().findFirst()
+                                  .orElse(null);
+                            } else if (shape instanceof Area) {
+                                primitive = areaToRelation(tile, layer, featureObjects, (Area) shape);
+                                primitive.put("type", "multipolygon");
+                            } else {
+                                // We shouldn't hit this, but just in case
+                                throw new UnsupportedOperationException();
+                            }
+                            primaryFeatureObjects.add(primitive);
+                        });
+                        final VectorPrimitive primitive;
+                        if (primaryFeatureObjects.size() == 1) {
+                            primitive = primaryFeatureObjects.get(0);
+                            if (primitive instanceof IRelation && !primitive.isMultipolygon()) {
+                                primitive.put(JOSM_MERGE_TYPE_KEY, "merge");
+                            }
+                        } else if (!primaryFeatureObjects.isEmpty()) {
+                            VectorRelation relation = new VectorRelation(layer.getName());
+                            primaryFeatureObjects.stream().map(prim -> new VectorRelationMember("", prim))
+                              .forEach(relation::addRelationMember);
+                            primitive = relation;
+                        } else {
+                            return;
+                        }
+                        Feature feature = geometry.getFeature();
+                        primitive.setId(feature.getId());
+                        feature.getTags().forEach(primitive::put);
+                        featureObjects.forEach(this::addPrimitive);
+                        primaryFeatureObjects.forEach(this::addPrimitive);
+                        this.addPrimitive(primitive);
+                    });
+                }
+            }
+        }
+    }
+}

new file src/org/openstreetmap/josm/data/vector/VectorNode.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.vector;
+
+import java.util.List;
+
+import org.openstreetmap.gui.jmapviewer.interfaces.ICoordinate;
+import org.openstreetmap.josm.data.coor.EastNorth;
+import org.openstreetmap.josm.data.coor.LatLon;
+import org.openstreetmap.josm.data.osm.BBox;
+import org.openstreetmap.josm.data.osm.INode;
+import org.openstreetmap.josm.data.osm.IPrimitive;
+import org.openstreetmap.josm.data.osm.IWay;
+import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
+import org.openstreetmap.josm.data.osm.UniqueIdGenerator;
+import org.openstreetmap.josm.data.osm.visitor.PrimitiveVisitor;
+import org.openstreetmap.josm.data.projection.ProjectionRegistry;
+
+/**
+ * The "Node" type of a vector layer
+ *
+ * @since xxx
+ */
+public class VectorNode extends VectorPrimitive implements INode {
+    private static final UniqueIdGenerator ID_GENERATOR = new UniqueIdGenerator();
+    private double lon = Double.NaN;
+    private double lat = Double.NaN;
+
+    /**
+     * Create a new vector node
+     * @param layer The layer for the vector node
+     */
+    public VectorNode(String layer) {
+        super(layer);
+    }
+
+    @Override public double lon() {
+        return this.lon;
+    }
+
+    @Override public double lat() {
+        return this.lat;
+    }
+
+    @Override public UniqueIdGenerator getIdGenerator() {
+        return ID_GENERATOR;
+    }
+
+    @Override public LatLon getCoor() {
+        return new LatLon(this.lat, this.lon);
+    }
+
+    @Override public void setCoor(LatLon coordinates) {
+        this.lat = coordinates.lat();
+        this.lon = coordinates.lon();
+    }
+
+    /**
+     * Set the coordinates of this node
+     *
+     * @param coordinates The coordinates to set
+     * @see #setCoor(LatLon)
+     */
+    public void setCoor(ICoordinate coordinates) {
+        this.lat = coordinates.getLat();
+        this.lon = coordinates.getLon();
+    }
+
+    @Override public void setEastNorth(EastNorth eastNorth) {
+        final LatLon ll = ProjectionRegistry.getProjection().eastNorth2latlon(eastNorth);
+        this.lat = ll.lat();
+        this.lon = ll.lon();
+    }
+
+    @Override public boolean isReferredByWays(int n) {
+        // Count only referrers that are members of the same dataset (primitive can have some fake references, for example
+        // when way is cloned
+        List<? extends IPrimitive> referrers = super.getReferrers();
+        if (referrers == null || referrers.isEmpty())
+            return false;
+        if (referrers instanceof IPrimitive)
+            return n <= 1 && referrers instanceof IWay && ((IPrimitive) referrers).getDataSet() == getDataSet();
+        else {
+            int counter = 0;
+            for (IPrimitive o : referrers) {
+                if (getDataSet() == o.getDataSet() && o instanceof IWay && ++counter >= n)
+                    return true;
+            }
+            return false;
+        }
+    }
+
+    @Override public void accept(PrimitiveVisitor visitor) {
+        visitor.visit(this);
+    }
+
+    @Override public BBox getBBox() {
+        return new BBox(this.lon, this.lat);
+    }
+
+    @Override public OsmPrimitiveType getType() {
+        return OsmPrimitiveType.NODE;
+    }
+}

new file src/org/openstreetmap/josm/data/vector/VectorPrimitive.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.vector;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
+import org.openstreetmap.josm.data.osm.AbstractPrimitive;
+import org.openstreetmap.josm.data.osm.IPrimitive;
+import org.openstreetmap.josm.data.osm.visitor.PrimitiveVisitor;
+import org.openstreetmap.josm.gui.mappaint.StyleCache;
+import org.openstreetmap.josm.tools.Utils;
+
+/**
+ * The base class for Vector primitives
+ * @author Taylor Smock
+ * @since xxx
+ */
+public abstract class VectorPrimitive extends AbstractPrimitive implements DataLayer<String> {
+    private VectorDataSet dataSet;
+    private boolean highlighted;
+    private StyleCache mappaintStyle;
+    private final String layer;
+
+    /**
+     * Create a primitive for a specific vector layer
+     * @param layer The layer for the primitive
+     */
+    public VectorPrimitive(String layer) {
+        this.layer = layer;
+    }
+
+    @Override protected void keysChangedImpl(Map<String, String> originalKeys) {
+        clearCachedStyle();
+        if (dataSet != null) {
+            for (IPrimitive ref : getReferrers()) {
+                ref.clearCachedStyle();
+            }
+        }
+    }
+
+    @Override public boolean isHighlighted() {
+        return this.highlighted;
+    }
+
+    @Override public void setHighlighted(boolean highlighted) {
+        this.highlighted = highlighted;
+    }
+
+    @Override public boolean isTagged() {
+        return !this.getInterestingTags().isEmpty();
+    }
+
+    @Override public boolean isAnnotated() {
+        return this.getInterestingTags().size() - this.getKeys().size() > 0;
+    }
+
+    @Override
+    public VectorDataSet getDataSet() {
+        return this.dataSet;
+    }
+
+    protected void setDataSet(VectorDataSet dataSet) {
+        this.dataSet = dataSet;
+    }
+
+    /*----------
+     * MAPPAINT
+     *--------*/
+    private short mappaintCacheIdx;
+
+    @Override
+    public final StyleCache getCachedStyle() {
+        return mappaintStyle;
+    }
+
+    @Override
+    public final void setCachedStyle(StyleCache mappaintStyle) {
+        this.mappaintStyle = mappaintStyle;
+    }
+
+    @Override
+    public final boolean isCachedStyleUpToDate() {
+        return mappaintStyle != null && mappaintCacheIdx == dataSet.getMappaintCacheIndex();
+    }
+
+    @Override
+    public final void declareCachedStyleUpToDate() {
+        this.mappaintCacheIdx = dataSet.getMappaintCacheIndex();
+    }
+
+    @Override public boolean hasDirectionKeys() {
+        return false;
+    }
+
+    @Override public boolean reversedDirection() {
+        return false;
+    }
+
+    /*------------
+     * Referrers
+     ------------*/
+    // Largely the same as OsmPrimitive, OsmPrimitive not modified at this time to avoid breaking binary compatibility
+
+    private Object referrers;
+
+    @Override
+    public final List<VectorPrimitive> getReferrers(boolean allowWithoutDataset) {
+        return referrers(allowWithoutDataset, VectorPrimitive.class)
+          .collect(Collectors.toList());
+    }
+
+    /**
+     * Add new referrer. If referrer is already included then no action is taken
+     * @param referrer The referrer to add
+     */
+    protected void addReferrer(IPrimitive referrer) {
+        if (referrers == null) {
+            referrers = referrer;
+        } else if (referrers instanceof IPrimitive) {
+            if (referrers != referrer) {
+                referrers = new IPrimitive[] {(IPrimitive) referrers, referrer};
+            }
+        } else {
+            for (IPrimitive primitive:(IPrimitive[]) referrers) {
+                if (primitive == referrer)
+                    return;
+            }
+            referrers = Utils.addInArrayCopy((IPrimitive[]) referrers, referrer);
+        }
+    }
+
+    /**
+     * Remove referrer. No action is taken if referrer is not registered
+     * @param referrer The referrer to remove
+     */
+    protected void removeReferrer(IPrimitive referrer) {
+        if (referrers instanceof IPrimitive) {
+            if (referrers == referrer) {
+                referrers = null;
+            }
+        } else if (referrers instanceof IPrimitive[]) {
+            IPrimitive[] orig = (IPrimitive[]) referrers;
+            int idx = IntStream.range(0, orig.length)
+              .filter(i -> orig[i] == referrer)
+              .findFirst().orElse(-1);
+            if (idx == -1)
+                return;
+
+            if (orig.length == 2) {
+                referrers = orig[1-idx]; // idx is either 0 or 1, take the other
+            } else { // downsize the array
+                IPrimitive[] smaller = new IPrimitive[orig.length-1];
+                System.arraycopy(orig, 0, smaller, 0, idx);
+                System.arraycopy(orig, idx+1, smaller, idx, smaller.length-idx);
+                referrers = smaller;
+            }
+        }
+    }
+
+    private <T extends IPrimitive> Stream<T> referrers(boolean allowWithoutDataset, Class<T> filter) {
+        // Returns only referrers that are members of the same dataset (primitive can have some fake references, for example
+        // when way is cloned
+
+        if (dataSet == null && allowWithoutDataset) {
+            return Stream.empty();
+        }
+        if (referrers == null) {
+            return Stream.empty();
+        }
+        final Stream<IPrimitive> stream = referrers instanceof IPrimitive // NOPMD
+          ? Stream.of((IPrimitive) referrers)
+          : Arrays.stream((IPrimitive[]) referrers);
+        return stream
+          .filter(p -> p.getDataSet() == dataSet)
+          .filter(filter::isInstance)
+          .map(filter::cast);
+    }
+
+    /**
+     * Gets all primitives in the current dataset that reference this primitive.
+     * @param filter restrict primitives to subclasses
+     * @param <T> type of primitives
+     * @return the referrers as Stream
+     */
+    public final <T extends IPrimitive> Stream<T> referrers(Class<T> filter) {
+        return referrers(false, filter);
+    }
+
+    @Override
+    public void visitReferrers(PrimitiveVisitor visitor) {
+        if (visitor != null)
+            doVisitReferrers(o -> o.accept(visitor));
+    }
+
+    private void doVisitReferrers(Consumer<IPrimitive> visitor) {
+        if (this.referrers instanceof IPrimitive) {
+            IPrimitive ref = (IPrimitive) this.referrers;
+            if (ref.getDataSet() == dataSet) {
+                visitor.accept(ref);
+            }
+        } else if (this.referrers instanceof IPrimitive[]) {
+            IPrimitive[] refs = (IPrimitive[]) this.referrers;
+            for (IPrimitive ref: refs) {
+                if (ref.getDataSet() == dataSet) {
+                    visitor.accept(ref);
+                }
+            }
+        }
+    }
+
+    /**
+     * Set the id of the object
+     * @param id The id
+     */
+    protected void setId(long id) {
+        this.id = id;
+    }
+
+    /**
+     * Make this object disabled
+     * @param disabled {@code true} to disable the object
+     */
+    public void setDisabled(boolean disabled) {
+        this.updateFlags(FLAG_DISABLED, disabled);
+    }
+
+    /**
+     * Make this object visible
+     * @param visible {@code true} to make this object visible (default)
+     */
+    @Override
+    public void setVisible(boolean visible) {
+        this.updateFlags(FLAG_VISIBLE, visible);
+    }
+
+    /**************************
+     * Data layer information *
+     **************************/
+    @Override
+    public String getLayer() {
+        return this.layer;
+    }
+}

new file src/org/openstreetmap/josm/data/vector/VectorRelation.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.vector;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import org.openstreetmap.josm.data.osm.BBox;
+import org.openstreetmap.josm.data.osm.IPrimitive;
+import org.openstreetmap.josm.data.osm.IRelation;
+import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
+import org.openstreetmap.josm.data.osm.UniqueIdGenerator;
+import org.openstreetmap.josm.data.osm.visitor.PrimitiveVisitor;
+
+/**
+ * The "Relation" type for vectors
+ *
+ * @author Taylor Smock
+ * @since xxx
+ */
+public class VectorRelation extends VectorPrimitive implements IRelation<VectorRelationMember> {
+    private static final UniqueIdGenerator RELATION_ID_GENERATOR = new UniqueIdGenerator();
+    private final List<VectorRelationMember> members = new ArrayList<>();
+    private BBox cachedBBox;
+
+    /**
+     * Create a new relation for a layer
+     * @param layer The layer the relation will belong to
+     */
+    public VectorRelation(String layer) {
+        super(layer);
+    }
+
+    @Override public UniqueIdGenerator getIdGenerator() {
+        return RELATION_ID_GENERATOR;
+    }
+
+    @Override public void accept(PrimitiveVisitor visitor) {
+        visitor.visit(this);
+    }
+
+    @Override public BBox getBBox() {
+        if (cachedBBox == null) {
+            cachedBBox = new BBox();
+            for (IPrimitive member : this.getMemberPrimitivesList()) {
+                cachedBBox.add(member.getBBox());
+            }
+        }
+        return cachedBBox;
+    }
+
+    protected void addRelationMember(VectorRelationMember member) {
+        this.members.add(member);
+        member.getMember().addReferrer(this);
+        cachedBBox = null;
+    }
+
+    /**
+     * Remove the first instance of a member from the relation
+     *
+     * @param member The member to remove
+     */
+    protected void removeRelationMember(VectorRelationMember member) {
+        this.members.remove(member);
+        if (!this.members.contains(member)) {
+            member.getMember().removeReferrer(this);
+        }
+    }
+
+    @Override public int getMembersCount() {
+        return this.members.size();
+    }
+
+    @Override public VectorRelationMember getMember(int index) {
+        return this.members.get(index);
+    }
+
+    @Override public List<VectorRelationMember> getMembers() {
+        return Collections.unmodifiableList(this.members);
+    }
+
+    @Override public void setMembers(List<VectorRelationMember> members) {
+        this.members.clear();
+        this.members.addAll(members);
+    }
+
+    @Override public long getMemberId(int idx) {
+        return this.getMember(idx).getMember().getId();
+    }
+
+    @Override public String getRole(int idx) {
+        return this.getMember(idx).getRole();
+    }
+
+    @Override public OsmPrimitiveType getMemberType(int idx) {
+        return this.getMember(idx).getType();
+    }
+
+    @Override public OsmPrimitiveType getType() {
+        return this.getMembers().stream().map(VectorRelationMember::getType)
+          .allMatch(OsmPrimitiveType.CLOSEDWAY::equals) ? OsmPrimitiveType.MULTIPOLYGON : OsmPrimitiveType.RELATION;
+    }
+}

new file src/org/openstreetmap/josm/data/vector/VectorRelationMember.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.vector;
+
+import java.util.Optional;
+
+import org.openstreetmap.josm.data.osm.INode;
+import org.openstreetmap.josm.data.osm.IRelation;
+import org.openstreetmap.josm.data.osm.IRelationMember;
+import org.openstreetmap.josm.data.osm.IWay;
+import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
+import org.openstreetmap.josm.tools.CheckParameterUtil;
+
+/**
+ * Relation members for a Vector Relation
+ */
+public class VectorRelationMember implements IRelationMember<VectorPrimitive> {
+    private final String role;
+    private final VectorPrimitive member;
+
+    /**
+     * Create a new relation member
+     * @param role The role of the member
+     * @param member The member primitive
+     */
+    public VectorRelationMember(String role, VectorPrimitive member) {
+        CheckParameterUtil.ensureParameterNotNull(member, "member");
+        this.role = Optional.ofNullable(role).orElse("").intern();
+        this.member = member;
+    }
+
+    @Override public String getRole() {
+        return this.role;
+    }
+
+    @Override public boolean isNode() {
+        return this.member instanceof INode;
+    }
+
+    @Override public boolean isWay() {
+        return this.member instanceof IWay;
+    }
+
+    @Override public boolean isRelation() {
+        return this.member instanceof IRelation;
+    }
+
+    @Override public VectorPrimitive getMember() {
+        return this.member;
+    }
+
+    @Override public long getUniqueId() {
+        return this.member.getId();
+    }
+
+    @Override public OsmPrimitiveType getType() {
+        return this.member.getType();
+    }
+
+    @Override public boolean isNew() {
+        return this.member.isNew();
+    }
+}

new file src/org/openstreetmap/josm/data/vector/VectorWay.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.vector;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.openstreetmap.josm.data.osm.BBox;
+import org.openstreetmap.josm.data.osm.INode;
+import org.openstreetmap.josm.data.osm.IWay;
+import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
+import org.openstreetmap.josm.data.osm.UniqueIdGenerator;
+import org.openstreetmap.josm.data.osm.visitor.PrimitiveVisitor;
+
+/**
+ * The "Way" type for a Vector layer
+ *
+ * @author Taylor Smock
+ * @since xxx
+ */
+public class VectorWay extends VectorPrimitive implements IWay<VectorNode> {
+    private static final UniqueIdGenerator WAY_GENERATOR = new UniqueIdGenerator();
+    private final List<VectorNode> nodes = new ArrayList<>();
+    private BBox cachedBBox;
+
+    /**
+     * Create a new way for a layer
+     * @param layer The layer for the way
+     */
+    public VectorWay(String layer) {
+        super(layer);
+    }
+
+    @Override public UniqueIdGenerator getIdGenerator() {
+        return WAY_GENERATOR;
+    }
+
+    @Override public void accept(PrimitiveVisitor visitor) {
+        visitor.visit(this);
+    }
+
+    @Override public BBox getBBox() {
+        if (cachedBBox == null) {
+            cachedBBox = new BBox();
+            for (INode node : this.getNodes()) {
+                cachedBBox.add(node.getBBox());
+            }
+        }
+        return cachedBBox;
+    }
+
+    @Override public int getNodesCount() {
+        return this.getNodes().size();
+    }
+
+    @Override public VectorNode getNode(int index) {
+        return this.getNodes().get(index);
+    }
+
+    @Override public List<VectorNode> getNodes() {
+        return Collections.unmodifiableList(this.nodes);
+    }
+
+    @Override public void setNodes(List<VectorNode> nodes) {
+        this.nodes.forEach(node -> node.removeReferrer(this));
+        this.nodes.clear();
+        nodes.forEach(node -> node.addReferrer(this));
+        this.nodes.addAll(nodes);
+        this.cachedBBox = null;
+    }
+
+    @Override public List<Long> getNodeIds() {
+        return this.getNodes().stream().map(VectorNode::getId).collect(Collectors.toList());
+    }
+
+    @Override public long getNodeId(int idx) {
+        return this.getNodes().get(idx).getId();
+    }
+
+    @Override public boolean isClosed() {
+        return this.firstNode() != null && this.firstNode().equals(this.lastNode());
+    }
+
+    @Override public VectorNode firstNode() {
+        if (this.nodes.isEmpty()) {
+            return null;
+        }
+        return this.getNode(0);
+    }
+
+    @Override public VectorNode lastNode() {
+        if (this.nodes.isEmpty()) {
+            return null;
+        }
+        return this.getNode(this.getNodesCount() - 1);
+    }
+
+    @Override public boolean isFirstLastNode(INode n) {
+        if (this.nodes.isEmpty()) {
+            return false;
+        }
+        return this.firstNode().equals(n) || this.lastNode().equals(n);
+    }
+
+    @Override public boolean isInnerNode(INode n) {
+        if (this.nodes.isEmpty()) {
+            return false;
+        }
+        return !this.firstNode().equals(n) && !this.lastNode().equals(n) && this.nodes.stream()
+          .anyMatch(vectorNode -> vectorNode.equals(n));
+    }
+
+    @Override public OsmPrimitiveType getType() {
+        return this.isClosed() ? OsmPrimitiveType.CLOSEDWAY : OsmPrimitiveType.WAY;
+    }
+}

src/org/openstreetmap/josm/gui/dialogs/relation/sort/RelationNodeMap.java

@@ -10 +10 @@
 import java.util.TreeMap;
 import java.util.TreeSet;
 
-import org.openstreetmap.josm.data.osm.Node;
-import org.openstreetmap.josm.data.osm.RelationMember;
-import org.openstreetmap.josm.data.osm.Way;
+import org.openstreetmap.josm.data.osm.INode;
+import org.openstreetmap.josm.data.osm.IPrimitive;
+import org.openstreetmap.josm.data.osm.IRelationMember;
+import org.openstreetmap.josm.data.osm.IWay;
 
 /**
  * Auxiliary class for relation sorting.
@@ -26 +27 @@
  * (that are shared by other members).
  *
  * @author Christiaan Welvaart <cjw@time4t.net>
- * @since 1785
+ * @param <T> The type of {@link IRelationMember}
+ * @since 1785, xxx (generics)
  */
-public class RelationNodeMap {
+public class RelationNodeMap<T extends IRelationMember<? extends IPrimitive>> {
 
     private static final String ROLE_BACKWARD = "backward";
 
     private static class NodesWays {
-        public final Map<Node, Set<Integer>> nodes = new TreeMap<>();
-        public final Map<Integer, Set<Node>> ways = new TreeMap<>();
+        public final Map<INode, Set<Integer>> nodes = new TreeMap<>();
+        public final Map<Integer, Set<INode>> ways = new TreeMap<>();
         public final boolean oneWay;
 
         NodesWays(boolean oneWay) {
@@ -56 +58 @@
      * Used to keep track of what members are done.
      */
     private final Set<Integer> remaining = new TreeSet<>();
-    private final Map<Integer, Set<Node>> remainingOneway = new TreeMap<>();
+    private final Map<Integer, Set<INode>> remainingOneway = new TreeMap<>();
 
     /**
      * All members that are incomplete or not a way
@@ -67 +69 @@
      * Gets the start node of the member, respecting the direction role.
      * @param m The relation member.
      * @return <code>null</code> if the member is no way, the node otherwise.
+     * @since xxx (generics)
      */
-    public static Node firstOnewayNode(RelationMember m) {
+    public static INode firstOnewayNode(IRelationMember<?> m) {
         if (!m.isWay()) return null;
         if (ROLE_BACKWARD.equals(m.getRole())) {
             return m.getWay().lastNode();
@@ -81 +84 @@
      * @param m The relation member.
      * @return <code>null</code> if the member is no way, the node otherwise.
      */
-    public static Node lastOnewayNode(RelationMember m) {
+    public static INode lastOnewayNode(IRelationMember<?> m) {
         if (!m.isWay()) return null;
         if (ROLE_BACKWARD.equals(m.getRole())) {
             return m.getWay().firstNode();
@@ -89 +92 @@
         return m.getWay().lastNode();
     }
 
-    RelationNodeMap(List<RelationMember> members) {
+    RelationNodeMap(List<T> members) {
         for (int i = 0; i < members.size(); ++i) {
-            RelationMember m = members.get(i);
+            T m = members.get(i);
             if (m.getMember().isIncomplete() || !m.isWay() || m.getWay().getNodesCount() < 2) {
                 notSortable.add(i);
                 continue;
             }
 
-            Way w = m.getWay();
+            IWay<?> w = m.getWay();
             if (RelationSortUtils.roundaboutType(w) != NONE) {
-                for (Node nd : w.getNodes()) {
+                for (INode nd : w.getNodes()) {
                     addPair(nd, i);
                 }
             } else if (RelationSortUtils.isOneway(m)) {
@@ -118 +121 @@
         remaining.addAll(map.ways.keySet());
     }
 
-    private void addPair(Node n, int i) {
+    private void addPair(INode n, int i) {
         map.nodes.computeIfAbsent(n, k -> new TreeSet<>()).add(i);
         map.ways.computeIfAbsent(i, k -> new TreeSet<>()).add(n);
     }
 
-    private void addNodeWayMap(Node n, int i) {
+    private void addNodeWayMap(INode n, int i) {
         onewayMap.nodes.computeIfAbsent(n, k -> new TreeSet<>()).add(i);
     }
 
-    private void addWayNodeMap(Node n, int i) {
+    private void addWayNodeMap(INode n, int i) {
         onewayMap.ways.computeIfAbsent(i, k -> new TreeSet<>()).add(n);
     }
 
-    private void addNodeWayMapReverse(Node n, int i) {
+    private void addNodeWayMapReverse(INode n, int i) {
         onewayReverseMap.nodes.computeIfAbsent(n, k -> new TreeSet<>()).add(i);
     }
 
-    private void addWayNodeMapReverse(Node n, int i) {
+    private void addWayNodeMapReverse(INode n, int i) {
         onewayReverseMap.ways.computeIfAbsent(i, k -> new TreeSet<>()).add(n);
     }
 
-    private void addRemainingForward(Node n, int i) {
+    private void addRemainingForward(INode n, int i) {
         remainingOneway.computeIfAbsent(i, k -> new TreeSet<>()).add(n);
     }
 
     private Integer firstOneway;
-    private Node lastOnewayNode;
-    private Node firstCircular;
+    private INode lastOnewayNode;
+    private INode firstCircular;
 
     /**
      * Return a relation member that is linked to the member 'i', but has not been popped yet.
@@ -158 +161 @@
         if (firstOneway != null) return popForwardOnewayPart(way);
 
         if (map.ways.containsKey(way)) {
-            for (Node n : map.ways.get(way)) {
+            for (INode n : map.ways.get(way)) {
                 Integer i = deleteAndGetAdjacentNode(map, n);
                 if (i != null) return i;
 
@@ -176 +179 @@
 
     private Integer popForwardOnewayPart(Integer way) {
         if (onewayMap.ways.containsKey(way)) {
-            Node exitNode = onewayMap.ways.get(way).iterator().next();
+            INode exitNode = onewayMap.ways.get(way).iterator().next();
 
             if (checkIfEndOfLoopReached(exitNode)) {
                 lastOnewayNode = exitNode;
@@ -201 +204 @@
     // Check if the given node can be the end of the loop (i.e. it has
     // an outgoing bidirectional or multiple outgoing oneways, or we
     // looped back to our first circular node)
-    private boolean checkIfEndOfLoopReached(Node n) {
+    private boolean checkIfEndOfLoopReached(INode n) {
         return map.nodes.containsKey(n)
                 || (onewayMap.nodes.containsKey(n) && (onewayMap.nodes.get(n).size() > 1))
                 || ((firstCircular != null) && (firstCircular == n));
@@ -209 +212 @@
 
     private Integer popBackwardOnewayPart(int way) {
         if (lastOnewayNode != null) {
-            Set<Node> nodes = new TreeSet<>();
+            Set<INode> nodes = new TreeSet<>();
             if (onewayReverseMap.ways.containsKey(way)) {
                 nodes.addAll(onewayReverseMap.ways.get(way));
             }
             if (map.ways.containsKey(way)) {
                 nodes.addAll(map.ways.get(way));
             }
-            for (Node n : nodes) {
+            for (INode n : nodes) {
                 if (n == lastOnewayNode) { //if oneway part ends
                     firstOneway = null;
                     lastOnewayNode = null;
@@ -247 +250 @@
      * @param n node
      * @return node next to n
      */
-    private Integer deleteAndGetAdjacentNode(NodesWays nw, Node n) {
+    private Integer deleteAndGetAdjacentNode(NodesWays nw, INode n) {
         Integer j = findAdjacentWay(nw, n);
         if (j == null) return null;
         deleteWayNode(nw, j, n);
         return j;
     }
 
-    private static Integer findAdjacentWay(NodesWays nw, Node n) {
+    private static Integer findAdjacentWay(NodesWays nw, INode n) {
         Set<Integer> adj = nw.nodes.get(n);
         if (adj == null || adj.isEmpty()) return null;
         return adj.iterator().next();
     }
 
-    private void deleteWayNode(NodesWays nw, Integer way, Node n) {
+    private void deleteWayNode(NodesWays nw, Integer way, INode n) {
         if (nw.oneWay) {
             doneOneway(way);
         } else {
@@ -285 +288 @@
 
         if (remainingOneway.isEmpty()) return null;
         for (Integer i : remainingOneway.keySet()) { //find oneway, which is connected to more than one way (is between two oneway loops)
-            for (Node n : onewayReverseMap.ways.get(i)) {
+            for (INode n : onewayReverseMap.ways.get(i)) {
                 if (onewayReverseMap.nodes.containsKey(n) && onewayReverseMap.nodes.get(n).size() > 1) {
                     doneOneway(i);
                     firstCircular = n;
@@ -305 +308 @@
      * @param i member key
      */
     private void doneOneway(Integer i) {
-        Set<Node> nodesForward = remainingOneway.get(i);
-        for (Node n : nodesForward) {
+        Set<INode> nodesForward = remainingOneway.get(i);
+        for (INode n : nodesForward) {
             if (onewayMap.nodes.containsKey(n)) {
                 onewayMap.nodes.get(n).remove(i);
             }
@@ -319 +322 @@
 
     private void done(Integer i) {
         remaining.remove(i);
-        Set<Node> nodes = map.ways.get(i);
-        for (Node n : nodes) {
+        Set<INode> nodes = map.ways.get(i);
+        for (INode n : nodes) {
             boolean result = map.nodes.get(n).remove(i);
             if (!result) throw new AssertionError();
         }

src/org/openstreetmap/josm/gui/dialogs/relation/sort/RelationSorter.java

@@ -15 +15 @@
 import java.util.stream.Collectors;
 
 import org.openstreetmap.josm.data.osm.DefaultNameFormatter;
+import org.openstreetmap.josm.data.osm.IPrimitive;
+import org.openstreetmap.josm.data.osm.IRelationMember;
 import org.openstreetmap.josm.data.osm.OsmPrimitive;
 import org.openstreetmap.josm.data.osm.Relation;
 import org.openstreetmap.josm.data.osm.RelationMember;
@@ -194 +196 @@
      * Sorts a list of members by connectivity
      * @param defaultMembers The members to sort
      * @return A sorted list of the same members
+     * @since xxx (signature change, generics)
      */
-    public static List<RelationMember> sortMembersByConnectivity(List<RelationMember> defaultMembers) {
+    public static <T extends IRelationMember<? extends IPrimitive>> List<T> sortMembersByConnectivity(List<T> defaultMembers) {
+        List<T> newMembers;
 
-        List<RelationMember> newMembers;
-
-        RelationNodeMap map = new RelationNodeMap(defaultMembers);
+        RelationNodeMap<T> map = new RelationNodeMap<>(defaultMembers);
         // List of groups of linked members
         //
         List<LinkedList<Integer>> allGroups = new ArrayList<>();

src/org/openstreetmap/josm/gui/dialogs/relation/sort/RelationSortUtils.java

@@ -6 +6 @@
 import static org.openstreetmap.josm.gui.dialogs.relation.sort.WayConnectionType.Direction.ROUNDABOUT_RIGHT;
 
 import org.openstreetmap.josm.data.coor.EastNorth;
-import org.openstreetmap.josm.data.osm.Node;
-import org.openstreetmap.josm.data.osm.RelationMember;
-import org.openstreetmap.josm.data.osm.Way;
+import org.openstreetmap.josm.data.osm.INode;
+import org.openstreetmap.josm.data.osm.IRelationMember;
+import org.openstreetmap.josm.data.osm.IWay;
 import org.openstreetmap.josm.gui.dialogs.relation.sort.WayConnectionType.Direction;
 
 /**
@@ -24 +24 @@
      * determine, if the way i is a roundabout and if yes, what type of roundabout
      * @param member relation member
      * @return roundabout type
+     * @since xxx (generics)
      */
-    static Direction roundaboutType(RelationMember member) {
+    static Direction roundaboutType(IRelationMember<?> member) {
         if (member == null || !member.isWay()) return NONE;
-        return roundaboutType(member.getWay());
+        return roundaboutType((IWay<?>) member.getWay());
     }
 
-    static Direction roundaboutType(Way w) {
+    /**
+     * Check if a way is a roundabout type
+     * @param w The way to check
+     * @param <W> The way type
+     * @return The roundabout type
+     * @since xxx (generics)
+     */
+    static <W extends IWay<?>> Direction roundaboutType(W w) {
         if (w != null && w.hasTag("junction", "circular", "roundabout")) {
             int nodesCount = w.getNodesCount();
             if (nodesCount > 2 && nodesCount < 200) {
-                Node n1 = w.getNode(0);
-                Node n2 = w.getNode(1);
-                Node n3 = w.getNode(2);
+                INode n1 = w.getNode(0);
+                INode n2 = w.getNode(1);
+                INode n3 = w.getNode(2);
                 if (n1 != null && n2 != null && n3 != null && w.isClosed()) {
                     /** do some simple determinant / cross product test on the first 3 nodes
                         to see, if the roundabout goes clock wise or ccw */
@@ -54 +62 @@
         return NONE;
     }
 
-    static boolean isBackward(final RelationMember member) {
+    static boolean isBackward(final IRelationMember<?> member) {
         return "backward".equals(member.getRole());
     }
 
-    static boolean isForward(final RelationMember member) {
+    static boolean isForward(final IRelationMember<?> member) {
         return "forward".equals(member.getRole());
     }
 
-    static boolean isOneway(final RelationMember member) {
+    static boolean isOneway(final IRelationMember<?> member) {
         return isForward(member) || isBackward(member);
     }
 }

new file src/org/openstreetmap/josm/gui/layer/imagery/MVTLayer.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.gui.layer.imagery;
+
+import static org.openstreetmap.josm.tools.I18n.tr;
+
+import java.awt.Component;
+import java.awt.Graphics2D;
+import java.awt.event.ActionEvent;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.function.BooleanSupplier;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+
+import javax.swing.AbstractAction;
+import javax.swing.Action;
+import javax.swing.JCheckBoxMenuItem;
+import javax.swing.JMenuItem;
+
+import org.openstreetmap.gui.jmapviewer.Tile;
+import org.openstreetmap.gui.jmapviewer.interfaces.TileLoader;
+import org.openstreetmap.josm.data.Bounds;
+import org.openstreetmap.josm.data.imagery.ImageryInfo;
+import org.openstreetmap.josm.data.imagery.vectortile.mapbox.Layer;
+import org.openstreetmap.josm.data.imagery.vectortile.mapbox.MVTFile;
+import org.openstreetmap.josm.data.imagery.vectortile.mapbox.MVTTile;
+import org.openstreetmap.josm.data.imagery.vectortile.mapbox.MVTTile.TileListener;
+import org.openstreetmap.josm.data.imagery.vectortile.mapbox.MapBoxVectorCachedTileLoader;
+import org.openstreetmap.josm.data.imagery.vectortile.mapbox.MapboxVectorTileSource;
+import org.openstreetmap.josm.data.osm.DataSet;
+import org.openstreetmap.josm.data.osm.Node;
+import org.openstreetmap.josm.data.osm.OsmPrimitive;
+import org.openstreetmap.josm.data.osm.Relation;
+import org.openstreetmap.josm.data.osm.RelationMember;
+import org.openstreetmap.josm.data.osm.Way;
+import org.openstreetmap.josm.data.osm.visitor.paint.AbstractMapRenderer;
+import org.openstreetmap.josm.data.osm.visitor.paint.MapRendererFactory;
+import org.openstreetmap.josm.data.osm.visitor.paint.StyledMapRenderer;
+import org.openstreetmap.josm.data.vector.VectorDataSet;
+import org.openstreetmap.josm.data.vector.VectorNode;
+import org.openstreetmap.josm.data.vector.VectorRelation;
+import org.openstreetmap.josm.data.vector.VectorWay;
+import org.openstreetmap.josm.gui.MainApplication;
+import org.openstreetmap.josm.gui.MapView;
+import org.openstreetmap.josm.gui.layer.AbstractCachedTileSourceLayer;
+import org.openstreetmap.josm.gui.layer.LayerManager;
+import org.openstreetmap.josm.gui.layer.OsmDataLayer;
+import org.openstreetmap.josm.gui.mappaint.ElemStyles;
+import org.openstreetmap.josm.gui.mappaint.StyleSource;
+
+/**
+ * A layer for MapBox Vector Tiles
+ * @author Taylor Smock
+ * @since xxx
+ */
+public class MVTLayer extends AbstractCachedTileSourceLayer<MapboxVectorTileSource> implements TileListener {
+    private static final String CACHE_REGION_NAME = "MVT";
+    private final Map<String, Boolean> layerNames = new HashMap<>();
+    private final VectorDataSet dataSet = new VectorDataSet();
+
+    /**
+     * Creates an instance of an MVT layer
+     *
+     * @param info ImageryInfo describing the layer
+     */
+    public MVTLayer(ImageryInfo info) {
+        super(info);
+    }
+
+    @Override
+    protected Class<? extends TileLoader> getTileLoaderClass() {
+        return MapBoxVectorCachedTileLoader.class;
+    }
+
+    @Override
+    protected String getCacheName() {
+        return CACHE_REGION_NAME;
+    }
+
+    @Override
+    public Collection<String> getNativeProjections() {
+        // MapBox Vector Tiles <i>specifically</i> only support EPSG:3857
+        // ("it is exclusively geared towards square pixel tiles in {link to EPSG:3857}").
+        return Collections.singleton(MVTFile.DEFAULT_PROJECTION);
+    }
+
+    @Override public void paint(Graphics2D g, MapView mv, Bounds box) {
+        this.dataSet.setZoom(this.getZoomLevel());
+        AbstractMapRenderer painter = MapRendererFactory.getInstance().createActiveRenderer(g, mv, false);
+        painter.enableSlowOperations(mv.getMapMover() == null || !mv.getMapMover().movementInProgress()
+          || !OsmDataLayer.PROPERTY_HIDE_LABELS_WHILE_DRAGGING.get());
+        // Set the painter to use our custom style sheet
+        if (painter instanceof StyledMapRenderer && this.dataSet.getStyles() != null) {
+            ((StyledMapRenderer) painter).setStyles(this.dataSet.getStyles());
+        }
+        painter.render(this.dataSet, false, box);
+    }
+
+    @Override
+    protected MapboxVectorTileSource getTileSource() {
+        MapboxVectorTileSource source = new MapboxVectorTileSource(this.info);
+        this.info.setAttribution(source);
+        if (source.getStyleSource() != null) {
+            List<ElemStyles> styles = source.getStyleSource().getSources().entrySet().stream()
+              .filter(entry -> entry.getKey() == null || entry.getKey().getUrls().contains(source.getBaseUrl()))
+              .map(Map.Entry::getValue).collect(Collectors.toList());
+            // load the style sources
+            styles.stream().map(ElemStyles::getStyleSources).flatMap(Collection::stream).forEach(StyleSource::loadStyleSource);
+            this.dataSet.setStyles(styles);
+            this.setName(source.getName());
+        }
+        return source;
+    }
+
+    @Override
+    public Tile createTile(MapboxVectorTileSource source, int x, int y, int zoom) {
+        final MVTTile tile = new MVTTile(source, x, y, zoom);
+        tile.addTileLoaderFinisher(this);
+        return tile;
+    }
+
+    @Override
+    public Action[] getMenuEntries() {
+        ArrayList<Action> actions = new ArrayList<>(Arrays.asList(super.getMenuEntries()));
+        // Add separator between Info and the layers
+        actions.add(SeparatorLayerAction.INSTANCE);
+        for (Map.Entry<String, Boolean> layerConfig : layerNames.entrySet()) {
+            actions.add(new EnableLayerAction(layerConfig.getKey(), () -> layerNames.computeIfAbsent(layerConfig.getKey(), key -> true),
+                    layer -> {
+                layerNames.compute(layer, (key, value) -> Boolean.FALSE.equals(value));
+                this.invalidate();
+            }));
+        }
+        // Add separator between layers and convert action
+        actions.add(SeparatorLayerAction.INSTANCE);
+        actions.add(new ConvertLayerAction(this));
+        return actions.toArray(new Action[0]);
+    }
+
+    /**
+     * Get the data set for this layer
+     */
+    public VectorDataSet getData() {
+        return this.dataSet;
+    }
+    
+    private static class ConvertLayerAction extends AbstractAction implements LayerAction {
+        private final MVTLayer layer;
+
+        ConvertLayerAction(MVTLayer layer) {
+            this.layer = layer;
+        }
+
+        @Override public void actionPerformed(ActionEvent e) {
+            LayerManager manager = MainApplication.getLayerManager();
+            VectorDataSet dataSet = layer.getData();
+            DataSet osmData = new DataSet();
+            // Add nodes first, map is to ensure we can map new nodes to vector nodes
+            Map<VectorNode, Node> nodeMap = new HashMap<>(dataSet.getNodes().size());
+            for (VectorNode vectorNode : dataSet.getNodes()) {
+                Node newNode = new Node(vectorNode.getCoor());
+                if (vectorNode.isTagged()) {
+                    vectorNode.getInterestingTags().forEach(newNode::put);
+                }
+                nodeMap.put(vectorNode, newNode);
+            }
+            // Add ways next
+            Map<VectorWay, Way> wayMap = new HashMap<>(dataSet.getWays().size());
+            for (VectorWay vectorWay : dataSet.getWays()) {
+                Way newWay = new Way();
+                List<Node> nodes = vectorWay.getNodes().stream().map(nodeMap::get).filter(Objects::nonNull).collect(Collectors.toList());
+                newWay.setNodes(nodes);
+                if (vectorWay.isTagged()) {
+                    vectorWay.getInterestingTags().forEach(newWay::put);
+                }
+                wayMap.put(vectorWay, newWay);
+            }
+
+            // Finally, add Relations
+            Map<VectorRelation, Relation> relationMap = new HashMap<>(dataSet.getRelations().size());
+            for (VectorRelation vectorRelation : dataSet.getRelations()) {
+                Relation relation = new Relation();
+                if (vectorRelation.isTagged()) {
+                    vectorRelation.getInterestingTags().forEach(relation::put);
+                }
+                List<RelationMember> members = vectorRelation.getMembers().stream().map(member -> {
+                    final OsmPrimitive primitive;
+                    if (member.getMember() instanceof VectorNode) {
+                        primitive = nodeMap.get(member.getMember());
+                    } else if (member.getMember() instanceof VectorWay) {
+                        primitive = wayMap.get(member.getMember());
+                    } else if (member.getMember() instanceof VectorRelation) {
+                        // Hopefully, relations are encountered in order...
+                        primitive = relationMap.get(member.getMember());
+                    } else {
+                        primitive = null;
+                    }
+                    if (primitive == null) return null;
+                    return new RelationMember(member.getRole(), primitive);
+                }).filter(Objects::nonNull).collect(Collectors.toList());
+                relation.setMembers(members);
+                relationMap.put(vectorRelation, relation);
+            }
+            try {
+                osmData.beginUpdate();
+                nodeMap.values().forEach(osmData::addPrimitive);
+                wayMap.values().forEach(osmData::addPrimitive);
+                relationMap.values().forEach(osmData::addPrimitive);
+            } finally {
+                osmData.endUpdate();
+            }
+            manager.addLayer(new OsmDataLayer(osmData, this.layer.getName(), null));
+            manager.removeLayer(this.layer);
+        }
+
+        @Override public boolean supportLayers(List<org.openstreetmap.josm.gui.layer.Layer> layers) {
+            return layers.stream().allMatch(MVTLayer.class::isInstance);
+        }
+
+        @Override public Component createMenuComponent() {
+            JMenuItem menuItem = new JMenuItem(tr("Convert to OSM Data"));
+            menuItem.addActionListener(this);
+            return menuItem;
+        }
+    }
+
+    private static class EnableLayerAction extends AbstractAction implements LayerAction {
+        private final String layer;
+        private final Consumer<String> consumer;
+        private final BooleanSupplier state;
+
+        EnableLayerAction(String layer, BooleanSupplier state, Consumer<String> consumer) {
+            super(tr("Toggle layer {0}", layer));
+            this.layer = layer;
+            this.consumer = consumer;
+            this.state = state;
+        }
+
+        @Override
+        public void actionPerformed(ActionEvent e) {
+            consumer.accept(layer);
+        }
+
+        @Override
+        public boolean supportLayers(List<org.openstreetmap.josm.gui.layer.Layer> layers) {
+            return layers.stream().allMatch(MVTLayer.class::isInstance);
+        }
+
+        @Override
+        public Component createMenuComponent() {
+            JCheckBoxMenuItem item = new JCheckBoxMenuItem(this);
+            item.setSelected(this.state.getAsBoolean());
+            return item;
+        }
+    }
+
+    @Override
+    public void finishedLoading(MVTTile tile) {
+        for (Layer layer : tile.getLayers()) {
+            this.layerNames.putIfAbsent(layer.getName(), true);
+        }
+        this.dataSet.addTileData(tile);
+    }
+}

src/org/openstreetmap/josm/gui/layer/AbstractTileSourceLayer.java

@@ -87 +87 @@
 import org.openstreetmap.josm.data.imagery.OffsetBookmark;
 import org.openstreetmap.josm.data.imagery.TMSCachedTileLoader;
 import org.openstreetmap.josm.data.imagery.TileLoaderFactory;
+import org.openstreetmap.josm.data.imagery.vectortile.VectorTile;
 import org.openstreetmap.josm.data.osm.visitor.BoundingXYVisitor;
 import org.openstreetmap.josm.data.preferences.BooleanProperty;
 import org.openstreetmap.josm.data.preferences.IntegerProperty;
@@ -110 +111 @@
 import org.openstreetmap.josm.gui.layer.imagery.IncreaseZoomAction;
 import org.openstreetmap.josm.gui.layer.imagery.LoadAllTilesAction;
 import org.openstreetmap.josm.gui.layer.imagery.LoadErroneousTilesAction;
+import org.openstreetmap.josm.gui.layer.imagery.MVTLayer;
 import org.openstreetmap.josm.gui.layer.imagery.ReprojectionTile;
 import org.openstreetmap.josm.gui.layer.imagery.ShowErrorsAction;
 import org.openstreetmap.josm.gui.layer.imagery.TileAnchor;
@@ -890 +892 @@
             if (coordinateConverter.requiresReprojection()) {
                 tile = new ReprojectionTile(tileSource, x, y, zoom);
             } else {
-                tile = new Tile(tileSource, x, y, zoom);
+                tile = createTile(tileSource, x, y, zoom);
             }
             tileCache.addTile(tile);
         }
@@ -1043 +1045 @@
                     img = getLoadedTileImage(tile);
                     anchorImage = getAnchor(tile, img);
                 }
-                if (img == null || anchorImage == null) {
+                if (img == null || anchorImage == null || (tile instanceof VectorTile && !tile.isLoaded())) {
                     miss = true;
                 }
             }
@@ -1052 +1054 @@
                 return;
             }
 
-            img = applyImageProcessors(img);
+            if (img != null) {
+                img = applyImageProcessors(img);
+            }
 
             TileAnchor anchorScreen = coordinateConverter.getScreenAnchorForTile(tile);
             synchronized (paintMutex) {
@@ -1864 +1868 @@
 
                 for (int x = minX; x <= maxX; x++) {
                     for (int y = minY; y <= maxY; y++) {
-                        requestedTiles.add(new Tile(tileSource, x, y, currentZoomLevel));
+                        requestedTiles.add(createTile(tileSource, x, y, currentZoomLevel));
                     }
                 }
             }
@@ -1970 +1974 @@
         return SaveActionBase.createAndOpenSaveFileChooser(tr("Save WMS file"), WMSLayerImporter.FILE_FILTER);
     }
 
+    /**
+     * Create a new tile. Added to allow use of custom {@link Tile} objects.
+     *
+     * @param source Tile source
+     * @param x X coordinate
+     * @param y Y coordinate
+     * @param zoom Zoom level
+     * @return The new {@link Tile}
+     * @since xxx
+     */
+    public Tile createTile(T source, int x, int y, int zoom) {
+        return new Tile(source, x, y, zoom);
+    }
+
     @Override
     public synchronized void destroy() {
         super.destroy();
@@ -1990 +2008 @@
             allocateCacheMemory();
             if (memory != null) {
                 doPaint(graphics);
+                if (AbstractTileSourceLayer.this instanceof MVTLayer) {
+                    AbstractTileSourceLayer.this.paint(graphics.getDefaultGraphics(), graphics.getMapView(), graphics.getMapView()
+                      .getRealBounds());
+                }
             } else {
                 Graphics g = graphics.getDefaultGraphics();
                 Color oldColor = g.getColor();

src/org/openstreetmap/josm/gui/layer/ImageryLayer.java

@@ -37 +37 @@
 import org.openstreetmap.josm.gui.MapView;
 import org.openstreetmap.josm.gui.MenuScroller;
 import org.openstreetmap.josm.gui.layer.imagery.ImageryFilterSettings;
+import org.openstreetmap.josm.gui.layer.imagery.MVTLayer;
 import org.openstreetmap.josm.gui.widgets.UrlLabel;
 import org.openstreetmap.josm.tools.GBC;
 import org.openstreetmap.josm.tools.ImageProcessor;
@@ -168 +169 @@
         case BING:
         case SCANEX:
             return new TMSLayer(info);
+        case MVT:
+            return new MVTLayer(info);
         default:
             throw new AssertionError(tr("Unsupported imagery type: {0}", info.getImageryType()));
         }

src/org/openstreetmap/josm/gui/mappaint/ElemStyles.java

@@ -85 +85 @@
         Config.getPref().addPreferenceChangeListener(this);
     }
 
+    /**
+     * Constructs a new {@code ElemStyles} with specific style sources. This does not listen to preference changes,
+     * and therefore should only be used with layers that have specific drawing requirements.
+     *
+     * @param sources The style sources (these cannot be added to, or removed from)
+     * @since xxx
+     */
+    public ElemStyles(Collection<StyleSource> sources) {
+        this.styleSources.addAll(sources);
+    }
+
     /**
      * Clear the style cache for all primitives of all DataSets.
      */
@@ -151 +162 @@
      * @since 13810 (signature)
      */
     public Pair<StyleElementList, Range> getStyleCacheWithRange(IPrimitive osm, double scale, NavigatableComponent nc) {
-        if (!osm.isCachedStyleUpToDate() || scale <= 0) {
-            osm.setCachedStyle(StyleCache.EMPTY_STYLECACHE);
-        } else {
-            Pair<StyleElementList, Range> lst = osm.getCachedStyle().getWithRange(scale, osm.isSelected());
-            if (lst.a != null)
-                return lst;
-        }
-        Pair<StyleElementList, Range> p = getImpl(osm, scale, nc);
-        if (osm instanceof INode && isDefaultNodes()) {
-            if (p.a.isEmpty()) {
-                if (TextLabel.AUTO_LABEL_COMPOSITION_STRATEGY.compose(osm) != null) {
-                    p.a = DefaultStyles.DEFAULT_NODE_STYLELIST_TEXT;
-                } else {
-                    p.a = DefaultStyles.DEFAULT_NODE_STYLELIST;
-                }
-            } else {
-                boolean hasNonModifier = false;
-                boolean hasText = false;
-                for (StyleElement s : p.a) {
-                    if (s instanceof BoxTextElement) {
-                        hasText = true;
-                    } else {
-                        if (!s.isModifier) {
-                            hasNonModifier = true;
-                        }
-                    }
-                }
-                if (!hasNonModifier) {
-                    p.a = new StyleElementList(p.a, DefaultStyles.SIMPLE_NODE_ELEMSTYLE);
-                    if (!hasText && TextLabel.AUTO_LABEL_COMPOSITION_STRATEGY.compose(osm) != null) {
-                        p.a = new StyleElementList(p.a, DefaultStyles.SIMPLE_NODE_TEXT_ELEMSTYLE);
-                    }
-                }
-            }
-        } else if (osm instanceof IWay && isDefaultLines()) {
-            boolean hasProperLineStyle = false;
-            for (StyleElement s : p.a) {
-                if (s.isProperLineStyle()) {
-                    hasProperLineStyle = true;
-                    break;
-                }
-            }
-            if (!hasProperLineStyle) {
-                LineElement line = LineElement.UNTAGGED_WAY;
-                for (StyleElement element : p.a) {
-                    if (element instanceof AreaElement) {
-                        line = LineElement.createSimpleLineStyle(((AreaElement) element).color, true);
-                        break;
-                    }
-                }
-                p.a = new StyleElementList(p.a, line);
-            }
-        }
-        StyleCache style = osm.getCachedStyle() != null ? osm.getCachedStyle() : StyleCache.EMPTY_STYLECACHE;
-        try {
-            osm.setCachedStyle(style.put(p.a, p.b, osm.isSelected()));
-        } catch (RangeViolatedError e) {
-            throw new AssertionError("Range violated: " + e.getMessage()
-                    + " (object: " + osm.getPrimitiveId() + ", current style: "+osm.getCachedStyle()
-                    + ", scale: " + scale + ", new stylelist: " + p.a + ", new range: " + p.b + ')', e);
-        }
-        osm.declareCachedStyleUpToDate();
-        return p;
+        synchronized (osm.getStyleCacheSyncObject()) {
+            if (!osm.isCachedStyleUpToDate() || scale <= 0) {
+                osm.setCachedStyle(StyleCache.EMPTY_STYLECACHE);
+            } else {
+                Pair<StyleElementList, Range> lst = osm.getCachedStyle().getWithRange(scale, osm.isSelected());
+                if (lst.a != null)
+                    return lst;
+            }
+            Pair<StyleElementList, Range> p = getImpl(osm, scale, nc);
+            if (osm instanceof INode && isDefaultNodes()) {
+                if (p.a.isEmpty()) {
+                    if (TextLabel.AUTO_LABEL_COMPOSITION_STRATEGY.compose(osm) != null) {
+                        p.a = DefaultStyles.DEFAULT_NODE_STYLELIST_TEXT;
+                    } else {
+                        p.a = DefaultStyles.DEFAULT_NODE_STYLELIST;
+                    }
+                } else {
+                    boolean hasNonModifier = false;
+                    boolean hasText = false;
+                    for (StyleElement s : p.a) {
+                        if (s instanceof BoxTextElement) {
+                            hasText = true;
+                        } else {
+                            if (!s.isModifier) {
+                                hasNonModifier = true;
+                            }
+                        }
+                    }
+                    if (!hasNonModifier) {
+                        p.a = new StyleElementList(p.a, DefaultStyles.SIMPLE_NODE_ELEMSTYLE);
+                        if (!hasText && TextLabel.AUTO_LABEL_COMPOSITION_STRATEGY.compose(osm) != null) {
+                            p.a = new StyleElementList(p.a, DefaultStyles.SIMPLE_NODE_TEXT_ELEMSTYLE);
+                        }
+                    }
+                }
+            } else if (osm instanceof IWay && isDefaultLines()) {
+                boolean hasProperLineStyle = false;
+                for (StyleElement s : p.a) {
+                    if (s.isProperLineStyle()) {
+                        hasProperLineStyle = true;
+                        break;
+                    }
+                }
+                if (!hasProperLineStyle) {
+                    LineElement line = LineElement.UNTAGGED_WAY;
+                    for (StyleElement element : p.a) {
+                        if (element instanceof AreaElement) {
+                            line = LineElement.createSimpleLineStyle(((AreaElement) element).color, true);
+                            break;
+                        }
+                    }
+                    p.a = new StyleElementList(p.a, line);
+                }
+            }
+            StyleCache style = osm.getCachedStyle() != null ? osm.getCachedStyle() : StyleCache.EMPTY_STYLECACHE;
+            try {
+                osm.setCachedStyle(style.put(p.a, p.b, osm.isSelected()));
+            } catch (RangeViolatedError e) {
+                throw new AssertionError("Range violated: " + e.getMessage()
+                  + " (object: " + osm.getPrimitiveId() + ", current style: " + osm.getCachedStyle()
+                  + ", scale: " + scale + ", new stylelist: " + p.a + ", new range: " + p.b + ')', e);
+            }
+            osm.declareCachedStyleUpToDate();
+            return p;
+        }
     }
 
     /**
@@ -241 +254 @@
      * @param nc navigable component
      * @return pair containing style list and range
      */
-    private Pair<StyleElementList, Range> getImpl(IPrimitive osm, double scale, NavigatableComponent nc) {
+     Pair<StyleElementList, Range> getImpl(IPrimitive osm, double scale, NavigatableComponent nc) {
         if (osm instanceof INode)
             return generateStyles(osm, scale, false);
         else if (osm instanceof IWay) {
@@ -376 +389 @@
      * @since 13810 (signature)
      */
     public Pair<StyleElementList, Range> generateStyles(IPrimitive osm, double scale, boolean pretendWayIsClosed) {
-
         List<StyleElement> sl = new ArrayList<>();
         MultiCascade mc = new MultiCascade();
         Environment env = new Environment(osm, mc, null, null);

new file src/org/openstreetmap/josm/gui/preferences/imagery/AddMVTLayerPanel.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.gui.preferences.imagery;
+
+import static org.openstreetmap.josm.tools.I18n.tr;
+
+import java.awt.event.KeyAdapter;
+import java.awt.event.KeyEvent;
+import java.util.Arrays;
+
+import javax.swing.JLabel;
+
+import org.openstreetmap.josm.data.imagery.ImageryInfo;
+import org.openstreetmap.josm.data.imagery.ImageryInfo.ImageryType;
+import org.openstreetmap.josm.gui.widgets.JosmTextArea;
+import org.openstreetmap.josm.gui.widgets.JosmTextField;
+import org.openstreetmap.josm.tools.GBC;
+import org.openstreetmap.josm.tools.Utils;
+
+/**
+ * A panel for adding MapBox Vector Tile layers
+ * @author Taylor Smock
+ * @since xxx
+ */
+public class AddMVTLayerPanel extends AddImageryPanel {
+    private final JosmTextField mvtZoom = new JosmTextField();
+    private final JosmTextArea mvtUrl = new JosmTextArea(3, 40).transferFocusOnTab();
+
+    /**
+     * Constructs a new {@code AddMVTLayerPanel}.
+     */
+    public AddMVTLayerPanel() {
+
+        add(new JLabel(tr("{0} Make sure OSM has the permission to use this service", "1.")), GBC.eol());
+        add(new JLabel(tr("{0} Enter URL (may be a style sheet url)", "2.")), GBC.eol());
+        add(new JLabel("<html>" + Utils.joinAsHtmlUnorderedList(Arrays.asList(
+                tr("{0} is replaced by tile zoom level, also supported:<br>" +
+                        "offsets to the zoom level: {1} or {2}<br>" +
+                        "reversed zoom level: {3}", "{zoom}", "{zoom+1}", "{zoom-1}", "{19-zoom}"),
+                tr("{0} is replaced by X-coordinate of the tile", "{x}"),
+                tr("{0} is replaced by Y-coordinate of the tile", "{y}"),
+                tr("{0} is replaced by a random selection from the given comma separated list, e.g. {1}", "{switch:...}", "{switch:a,b,c}")
+        )) + "</html>"), GBC.eol().fill());
+
+        final KeyAdapter keyAdapter = new KeyAdapter() {
+            @Override
+            public void keyReleased(KeyEvent e) {
+                mvtUrl.setText(buildMvtUrl());
+            }
+        };
+
+        add(rawUrl, GBC.eop().fill());
+        rawUrl.setLineWrap(true);
+        rawUrl.addKeyListener(keyAdapter);
+
+        add(new JLabel(tr("{0} Enter maximum zoom (optional)", "3.")), GBC.eol());
+        mvtZoom.addKeyListener(keyAdapter);
+        add(mvtZoom, GBC.eop().fill());
+
+        add(new JLabel(tr("{0} Edit generated {1} URL (optional)", "4.", "MVT")), GBC.eol());
+        add(mvtUrl, GBC.eop().fill());
+        mvtUrl.setLineWrap(true);
+
+        add(new JLabel(tr("{0} Enter name for this layer", "5.")), GBC.eol());
+        add(name, GBC.eop().fill());
+
+        registerValidableComponent(mvtUrl);
+    }
+
+    private String buildMvtUrl() {
+        StringBuilder a = new StringBuilder("mvt");
+        String z = sanitize(mvtZoom.getText());
+        if (!z.isEmpty()) {
+            a.append('[').append(z).append(']');
+        }
+        a.append(':').append(sanitize(getImageryRawUrl(), ImageryType.MVT));
+        return a.toString();
+    }
+
+    @Override
+    public ImageryInfo getImageryInfo() {
+        final ImageryInfo generated = new ImageryInfo(getImageryName(), getMvtUrl());
+        generated.setImageryType(ImageryType.MVT);
+        return generated;
+    }
+
+    protected final String getMvtUrl() {
+        return sanitize(mvtUrl.getText());
+    }
+
+    @Override
+    protected boolean isImageryValid() {
+        return !getImageryName().isEmpty() && !getMvtUrl().isEmpty();
+    }
+}

src/org/openstreetmap/josm/gui/preferences/imagery/ImageryProvidersPanel.java

@@ -312 +312 @@
         activeToolbar.add(new NewEntryAction(ImageryInfo.ImageryType.WMS));
         activeToolbar.add(new NewEntryAction(ImageryInfo.ImageryType.TMS));
         activeToolbar.add(new NewEntryAction(ImageryInfo.ImageryType.WMTS));
+        activeToolbar.add(new NewEntryAction(ImageryInfo.ImageryType.MVT));
         activeToolbar.add(remove);
         activePanel.add(activeToolbar, BorderLayout.EAST);
         add(activePanel, GBC.eol().fill(GridBagConstraints.BOTH).weight(2.0, 0.4).insets(5, 0, 0, 5));
@@ -439 +440 @@
                 break;
             case WMTS:
                 icon = /* ICON(dialogs/) */ "add_wmts";
+                break;
+            case MVT:
+                icon = /* ICON(dialogs/) */ "add_mvt";
                 break;
             default:
                 break;
@@ -460 +464 @@
             case WMTS:
                 p = new AddWMTSLayerPanel();
                 break;
+            case MVT:
+                p = new AddMVTLayerPanel();
+                break;
             default:
                 throw new IllegalStateException("Type " + type + " not supported");
             }
@@ -741 +748 @@
     private static boolean confirmEulaAcceptance(PreferenceTabbedPane gui, String eulaUrl) {
         URL url;
         try {
-            url = new URL(eulaUrl.replaceAll("\\{lang\\}", LanguageInfo.getWikiLanguagePrefix()));
+            url = new URL(eulaUrl.replaceAll("\\{lang}", LanguageInfo.getWikiLanguagePrefix()));
             JosmEditorPane htmlPane;
             try {
                 htmlPane = new JosmEditorPane(url);
@@ -749 +756 @@
                 Logging.trace(e1);
                 // give a second chance with a default Locale 'en'
                 try {
-                    url = new URL(eulaUrl.replaceAll("\\{lang\\}", ""));
+                    url = new URL(eulaUrl.replaceAll("\\{lang}", ""));
                     htmlPane = new JosmEditorPane(url);
                 } catch (IOException e2) {
                     Logging.debug(e2);

new file test/unit/org/openstreetmap/josm/data/imagery/vectortile/mapbox/style/MapBoxVectorStyleTest.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.imagery.vectortile.mapbox.style;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+
+import java.nio.file.Paths;
+import java.text.MessageFormat;
+import java.util.Collection;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+import org.openstreetmap.josm.TestUtils;
+import org.openstreetmap.josm.gui.mappaint.ElemStyles;
+import org.openstreetmap.josm.gui.mappaint.Keyword;
+import org.openstreetmap.josm.gui.mappaint.StyleSource;
+import org.openstreetmap.josm.gui.mappaint.mapcss.Instruction;
+import org.openstreetmap.josm.gui.mappaint.mapcss.MapCSSRule;
+import org.openstreetmap.josm.gui.mappaint.mapcss.MapCSSStyleSource;
+import org.openstreetmap.josm.testutils.JOSMTestRules;
+import org.openstreetmap.josm.tools.ColorHelper;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+/**
+ * Test class for {@link MapBoxVectorStyle}
+ * @author Taylor Smock
+ */
+public class MapBoxVectorStyleTest {
+    // Needed for osm primitives (we really just need to initialize the config)
+    // OSM primitives are called when we load style sources
+    @RegisterExtension
+    JOSMTestRules rules = new JOSMTestRules();
+
+    @Test
+    void testMapillaryStyle() {
+        final String file = Paths.get("file:", TestUtils.getTestDataRoot(), "mapillary.json").toString();
+        final MapBoxVectorStyle style = MapBoxVectorStyle.getMapBoxVectorStyle(file);
+        assertNotNull(style);
+        // There are three "sources" in the mapillary.json file
+        assertEquals(3, style.getSources().size());
+        final ElemStyles mapillarySource = style.getSources().entrySet().stream()
+          .filter(source -> "mapillary-source".equals(source.getKey().getName())).map(
+            Map.Entry::getValue).findAny().orElse(null);
+        assertNotNull(mapillarySource);
+        mapillarySource.getStyleSources().forEach(StyleSource::loadStyleSource);
+        assertEquals(1, mapillarySource.getStyleSources().size());
+        final MapCSSStyleSource mapillaryCssSource = (MapCSSStyleSource) mapillarySource.getStyleSources().get(0);
+        assertTrue(mapillaryCssSource.getErrors().isEmpty());
+        final MapCSSRule mapillaryOverview = getRule(mapillaryCssSource, "node", "mapillary-overview");
+        assertNotNull(mapillaryOverview);
+        assertInInstructions(mapillaryOverview.declaration.instructions, "symbol-shape", new Keyword("circle"));
+        assertInInstructions(mapillaryOverview.declaration.instructions, "symbol-fill-color", ColorHelper.html2color("#05CB63"));
+        assertInInstructions(mapillaryOverview.declaration.instructions, "symbol-fill-opacity", 0.6f);
+        assertInInstructions(mapillaryOverview.declaration.instructions, "symbol-size", 4.0f);
+    }
+
+    /**
+     * Check that an instruction is in a collection of instructions, and return it
+     * @param instructions The instructions to search
+     * @param key The key to look for
+     * @param value The expected value for the key
+     */
+    private void assertInInstructions(Collection<Instruction> instructions, String key, Object value) {
+        // In JOSM, all Instruction objects are AssignmentInstruction objects
+        Collection<Instruction.AssignmentInstruction> instructionKeys = instructions.stream().filter(Instruction.AssignmentInstruction.class::isInstance).map(
+          Instruction.AssignmentInstruction.class::cast).filter(instruction -> Objects.equals(key, instruction.key)).collect(
+          Collectors.toList());
+        Optional<Instruction.AssignmentInstruction> instructionOptional = instructionKeys.stream().filter(instruction -> Objects.equals(value, instruction.val)).findAny();
+        assertTrue(instructionOptional.isPresent(), MessageFormat
+          .format("Expected {0}, but got {1}", value, instructionOptional.orElse(instructionKeys.stream().findAny().orElseThrow(() -> new AssertionError("No instruction with "+key+" found"))).val));
+    }
+
+    private static MapCSSRule getRule(MapCSSStyleSource source, String base, String subpart) {
+        return source.rules.stream().filter(rule -> rule.selectors.stream().filter(selector -> base.equals(selector.getBase()) && subpart.equals(selector.getSubpart().getId(null))).count() > 0).findAny().orElse(null);
+    }
+}

new file test/unit/org/openstreetmap/josm/data/protobuf/ProtoBufTest.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.protobuf;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.fail;
+
+
+import java.awt.Shape;
+import java.awt.geom.Ellipse2D;
+import java.awt.geom.PathIterator;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Paths;
+import java.text.MessageFormat;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.openstreetmap.josm.TestUtils;
+import org.openstreetmap.josm.data.coor.LatLon;
+import org.openstreetmap.josm.data.imagery.vectortile.mapbox.Feature;
+import org.openstreetmap.josm.data.imagery.vectortile.mapbox.Geometry;
+import org.openstreetmap.josm.data.imagery.vectortile.mapbox.Layer;
+import org.openstreetmap.josm.data.osm.BBox;
+import org.openstreetmap.josm.data.osm.DataSet;
+import org.openstreetmap.josm.data.osm.Node;
+import org.openstreetmap.josm.data.osm.OsmPrimitive;
+import org.openstreetmap.josm.data.osm.Relation;
+import org.openstreetmap.josm.data.osm.RelationMember;
+import org.openstreetmap.josm.data.osm.Way;
+import org.openstreetmap.josm.gui.layer.OsmDataLayer;
+import org.openstreetmap.josm.io.Compression;
+import org.openstreetmap.josm.testutils.JOSMTestRules;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+/**
+ * Test class for {@link ProtoBufParser} and {@link ProtoBufRecord}
+ * @author Taylor Smock
+ * @since xxx
+ */
+class ProtoBufTest {
+    @RegisterExtension
+    JOSMTestRules josmTestRules = new JOSMTestRules().preferences();
+
+    /**
+     * Test simple message.
+     * Check that a simple message is readable
+     * @throws IOException - if an IO error occurs
+     */
+    @Test
+    void testSimpleMessage() throws IOException {
+        ProtoBufParser parser = new ProtoBufParser(new byte[] {(byte) 0x08, (byte) 0x96, (byte) 0x01});
+        ProtoBufRecord record = new ProtoBufRecord(parser);
+        assertEquals(WireType.VARINT, record.getType());
+        assertEquals(150, record.asUnsignedVarInt().intValue());
+    }
+
+    /**
+     * Test reading tile from Mapillary ( 14/3251/6258 )
+     * @throws IOException if there is a problem reading the file
+     */
+    @Test
+    void testRead_14_3251_6258() throws IOException {
+        File vectorTile = Paths.get(TestUtils.getTestDataRoot(), "pbf", "6258.mvt").toFile();
+        InputStream inputStream = Compression.getUncompressedFileInputStream(vectorTile);
+        Collection<ProtoBufRecord> records = new ProtoBufParser(inputStream).allRecords();
+        assertEquals(2, records.size());
+        List<Layer> layers = new ArrayList<>();
+        for (ProtoBufRecord record : records) {
+            if (record.getField() == Layer.LAYER_FIELD) {
+                layers.add(new Layer(record.getBytes()));
+            } else {
+                fail(MessageFormat.format("Invalid field {0}", record.getField()));
+            }
+        }
+        Layer mapillarySequences = layers.get(0);
+        Layer mapillaryPictures = layers.get(1);
+        assertEquals("mapillary-sequences", mapillarySequences.getName());
+        assertEquals("mapillary-images", mapillaryPictures.getName());
+        assertEquals(2048, mapillarySequences.getExtent());
+        assertEquals(2048, mapillaryPictures.getExtent());
+
+        assertEquals(1, mapillarySequences.getFeatures().stream().filter(feature -> feature.getId() == 241083111).count());
+        Feature testSequence = mapillarySequences.getFeatures().stream().filter(feature -> feature.getId() == 241083111).findAny().orElse(null);
+        assertEquals("jgxkXqVFM4jepMG3vP5Q9A", testSequence.getTags().get("key"));
+        assertEquals("C15Ul6qVMfQFlzRcmQCLcA", testSequence.getTags().get("ikey"));
+        assertEquals("x0hTY8cakpy0m3ui1GaG1A", testSequence.getTags().get("userkey"));
+        assertEquals(Long.valueOf(1565196718638L), Long.valueOf(testSequence.getTags().get("captured_at")));
+        assertEquals(0, Integer.parseInt(testSequence.getTags().get("pano")));
+    }
+
+    /**
+     * Test reading tile from OpenInfraMap ( 16/13014/25030 )
+     * @throws IOException if there is a problem reading the file
+     */
+    @Test
+    void testRead_16_13014_25030() throws IOException {
+        // TODO finish
+        File vectorTile = Paths.get(TestUtils.getTestDataRoot(), "pbf", "16", "13014", "25030.pbf").toFile();
+        InputStream inputStream = Compression.getUncompressedFileInputStream(vectorTile);
+        Collection<ProtoBufRecord> records = new ProtoBufParser(inputStream).allRecords();
+        List<Layer> layers = new ArrayList<>();
+        for (ProtoBufRecord record : records) {
+            if (record.getField() == Layer.LAYER_FIELD) {
+                layers.add(new Layer(record.getBytes()));
+            } else {
+                fail(MessageFormat.format("Invalid field {0}", record.getField()));
+            }
+        }
+        assertEquals(19, layers.size());
+        List<Layer> dataLayers = layers.stream().filter(layer -> !layer.getFeatures().isEmpty()).collect(Collectors.toList());
+        // power_plant, power_plant_point, power_generator, power_heatmap_solar, and power_generator_area
+        assertEquals(5, dataLayers.size());
+    }
+
+    @Test
+    void testRead_17_26028_50060() throws IOException {
+        File vectorTile = Paths.get(TestUtils.getTestDataRoot(), "pbf", "17", "26028", "50060.pbf").toFile();
+        InputStream inputStream = Compression.getUncompressedFileInputStream(vectorTile);
+        Collection<ProtoBufRecord> records = new ProtoBufParser(inputStream).allRecords();
+        List<Layer> layers = new ArrayList<>();
+        for (ProtoBufRecord record : records) {
+            if (record.getField() == Layer.LAYER_FIELD) {
+                layers.add(new Layer(record.getBytes()));
+            } else {
+                fail(MessageFormat.format("Invalid field {0}", record.getField()));
+            }
+        }
+        assertEquals(19, layers.size());
+        List<Layer> dataLayers = layers.stream().filter(layer -> !layer.getFeatures().isEmpty()).collect(Collectors.toList());
+        // power_plant, power_plant_point, power_generator, power_heatmap_solar, and power_generator_area
+        assertEquals(5, dataLayers.size());
+
+        // power_generator_area was rendered incorrectly
+        final Layer powerGeneratorArea = dataLayers.stream().filter(layer -> "power_generator_area".equals(layer.getName())).findAny().orElse(null);
+        assertNotNull(powerGeneratorArea);
+        final int extent = powerGeneratorArea.getExtent();
+        // 17/26028/50060 bounds
+        final BBox tileExtent = new BBox(new LatLon(39.068246, -108.511959), new LatLon(39.070381, -108.509219));
+        final DataSet ds = new DataSet();
+        for (Geometry feature : powerGeneratorArea.getGeometry()) {
+            final Collection<OsmPrimitive> primitives = feature.getShapes().stream().flatMap(shape -> convertShape(tileExtent, extent, shape).stream()).collect(Collectors.toList());
+            primitives.forEach(ds::addPrimitive);
+            final OsmPrimitive toTag;
+            if (primitives.size() > 1) {
+                final Relation relation = new Relation();
+                primitives.forEach(prim -> relation.addMember(new RelationMember("", prim)));
+                ds.addPrimitive(relation);
+                toTag = relation;
+            } else {
+                toTag = primitives.iterator().next();
+            }
+            feature.getFeature().getTags().forEach((key, value) -> toTag.put(key, value));
+        }
+        final Way one = new Way();
+        one.addNode(new Node(new LatLon(39.0687509, -108.5100816)));
+        one.addNode(new Node(new LatLon(39.0687509, -108.5095751)));
+        one.addNode(new Node(new LatLon(39.0687169, -108.5095751)));
+        one.addNode(new Node(new LatLon(39.0687169, -108.5100816)));
+        one.addNode(one.getNode(0));
+        one.setOsmId(666293899, 2);
+        final BBox searchBBox = one.getBBox();
+        searchBBox.addPrimitive(one, 0.001);
+        final Collection<Node> searchedNodes = ds.searchNodes(searchBBox);
+        OsmDataLayer testLayer = new OsmDataLayer(ds, "", null);
+        testLayer.autosave(new File("/tmp/test.osm"));
+        assertEquals(4, searchedNodes.size());
+    }
+
+    /**
+     * Convert a latlon to a relative latlon for the bbox
+     * @param tileExtent The tile extent
+     * @param toConvert The shape
+     * @return An OSM primitive representing the shape
+     */
+    private static Collection<OsmPrimitive> convertShape(BBox tileExtent, int extent, Shape toConvert) {
+        final List<Node> nodes = new ArrayList<>();
+        final List<Way> ways = new ArrayList<>();
+        final List<Relation> relations = new ArrayList<>();
+        final PathIterator iterator = toConvert.getPathIterator(null);
+        final List<Node> wayNodes = new ArrayList<>();
+        while (!iterator.isDone()) {
+            final double[] coords = new double[6];
+            final int type = iterator.currentSegment(coords);
+            if (type == PathIterator.SEG_MOVETO || type == PathIterator.SEG_LINETO) {
+                final Node node = convertPointToNode(tileExtent, extent, coords[0], coords[1]);
+                nodes.add(node);
+                if (type == PathIterator.SEG_MOVETO && wayNodes.size() > 1) {
+                    final Way way = new Way();
+                    way.setNodes(wayNodes);
+                    ways.add(way);
+                    wayNodes.clear();
+                } else if (type == PathIterator.SEG_MOVETO) {
+                    wayNodes.clear();
+                }
+                wayNodes.add(node);
+            } else if (type == PathIterator.SEG_CLOSE) {
+                wayNodes.add(wayNodes.get(0));
+                final Way way = new Way();
+                way.setNodes(wayNodes);
+                ways.add(way);
+                wayNodes.clear();
+            }
+            iterator.next();
+        }
+
+        final Collection<OsmPrimitive> primitives = new ArrayList<>(nodes);
+        primitives.addAll(ways);
+        primitives.addAll(relations);
+        return primitives;
+    }
+
+    private static Node convertPointToNode(BBox tileExtent, int extent, double x, double y) {
+        final double latDiff = tileExtent.getTopLeftLat() - tileExtent.getBottomRightLat();
+        final double lonDiff = tileExtent.getBottomRightLon() - tileExtent.getTopLeftLon();
+        final double lat = tileExtent.getTopLeftLat() - y * latDiff / extent;
+        final double lon = tileExtent.getTopLeftLon() - x * lonDiff / extent;
+        return new Node(new LatLon(lat, lon));
+    }
+
+
+    // TODO remove temporary tests or indicate that they are from the vector-tile-js library (BSD-3)
+    @Test
+    void test_14_8801_5371() throws IOException {
+        File vectorTile = Paths.get(TestUtils.getTestDataRoot(), "pbf", "tmp", "14-8801-5371.vector.pbf").toFile();
+        InputStream inputStream = Compression.getUncompressedFileInputStream(vectorTile);
+        Collection<ProtoBufRecord> records = new ProtoBufParser(inputStream).allRecords();
+        List<Layer> layers = new ArrayList<>();
+        for (ProtoBufRecord record : records) {
+            if (record.getField() == Layer.LAYER_FIELD) {
+                layers.add(new Layer(record.getBytes()));
+            } else {
+                fail(MessageFormat.format("Invalid field {0}", record.getField()));
+            }
+        }
+        assertEquals(20, layers.size());
+        Geometry park = layers.stream().filter(layer -> "poi_label".equals(layer.getName())).flatMap(layer -> layer.getGeometry().stream()).filter(g -> g.getFeature().getId() == 3000003150561L).findAny().orElse(null);
+        assertEquals("Mauerpark", park.getFeature().getTags().get("name"));
+        assertEquals("Park", park.getFeature().getTags().get("type"));
+
+        Ellipse2D parkShape = (Ellipse2D) park.getShapes().iterator().next();
+        assertEquals(3898, parkShape.getCenterX());
+        assertEquals(1731, parkShape.getCenterY());
+
+        Geometry road = layers.stream().filter(layer -> "road".equals(layer.getName())).flatMap(layer -> layer.getGeometry().stream()).skip(656).findFirst().orElse(null);
+        PathIterator roadIterator = road.getShapes().iterator().next().getPathIterator(null);
+        double[] coords = new double[6];
+        assertEquals(PathIterator.SEG_MOVETO, roadIterator.currentSegment(coords));
+        assertEquals(1988, coords[0]);
+        assertEquals(306, coords[1]);
+        roadIterator.next();
+        assertEquals(PathIterator.SEG_LINETO, roadIterator.currentSegment(coords));
+        assertEquals(1808, coords[0]);
+        assertEquals(321, coords[1]);
+        roadIterator.next();
+        assertEquals(PathIterator.SEG_LINETO, roadIterator.currentSegment(coords));
+        assertEquals(1506, coords[0]);
+        assertEquals(347, coords[1]);
+    }
+
+    @Test
+    void testSingletonMultiPoint() throws IOException {
+        File vectorTile = Paths.get(TestUtils.getTestDataRoot(), "pbf", "tmp", "singleton-multi-point.pbf").toFile();
+        InputStream inputStream = Compression.getUncompressedFileInputStream(vectorTile);
+        Collection<ProtoBufRecord> records = new ProtoBufParser(inputStream).allRecords();
+        List<Layer> layers = new ArrayList<>();
+        for (ProtoBufRecord record : records) {
+            if (record.getField() == Layer.LAYER_FIELD) {
+                layers.add(new Layer(record.getBytes()));
+            } else {
+                fail(MessageFormat.format("Invalid field {0}", record.getField()));
+            }
+        }
+        assertEquals(1, layers.size());
+        assertEquals(1, layers.get(0).getGeometry().size());
+        Ellipse2D shape = (Ellipse2D) layers.get(0).getGeometry().iterator().next().getShapes().iterator().next();
+        assertEquals(2059, shape.getCenterX());
+        assertEquals(2071, shape.getCenterY());
+    }
+
+    @Test
+    void testReadVarInt() {
+        assertEquals(ProtoBufParser.convertLong(0), bytesToVarInt(0x0));
+        assertEquals(ProtoBufParser.convertLong(1), bytesToVarInt(0x1));
+        assertEquals(ProtoBufParser.convertLong(127), bytesToVarInt(0x7f));
+        // This should b 0xff 0xff 0xff 0xff 0x07, but we drop the leading bit when reading to a byte array
+        Number actual = bytesToVarInt(0x7f, 0x7f, 0x7f, 0x7f, 0x07);
+        assertEquals(ProtoBufParser.convertLong(Integer.MAX_VALUE), actual,
+          MessageFormat.format("Expected {0} but got {1}", Integer.toBinaryString(Integer.MAX_VALUE),
+            Long.toBinaryString(actual.longValue())));
+    }
+
+    @Test
+    void testZigZag() {
+        assertEquals(0, ProtoBufParser.decodeZigZag(0).intValue());
+        assertEquals(-1, ProtoBufParser.decodeZigZag(1).intValue());
+        assertEquals(1, ProtoBufParser.decodeZigZag(2).intValue());
+        assertEquals(-2, ProtoBufParser.decodeZigZag(3).intValue());
+    }
+
+    private Number bytesToVarInt(int... bytes) {
+        byte[] byteArray = new byte[bytes.length];
+        for (int i = 0; i < bytes.length; i++) {
+            byteArray[i] = (byte) bytes[i];
+        }
+        return ProtoBufParser.convertByteArray(byteArray, ProtoBufParser.VAR_INT_BYTE_SIZE);
+    }
+}

new file test/unit/org/openstreetmap/josm/data/vector/VectorDataSetTest.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.vector;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+
+import java.nio.file.Paths;
+import java.text.MessageFormat;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import org.openstreetmap.josm.TestUtils;
+import org.openstreetmap.josm.data.imagery.ImageryInfo;
+import org.openstreetmap.josm.data.imagery.vectortile.mapbox.MVTTile;
+import org.openstreetmap.josm.data.imagery.vectortile.mapbox.MapBoxVectorCachedTileLoader;
+import org.openstreetmap.josm.data.imagery.vectortile.mapbox.MapboxVectorTileSource;
+import org.openstreetmap.josm.gui.layer.imagery.MVTLayer;
+import org.openstreetmap.josm.testutils.JOSMTestRules;
+
+import org.awaitility.Awaitility;
+import org.awaitility.Durations;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+/**
+ * A test for {@link VectorDataSet}
+ */
+ class VectorDataSetTest {
+    /**
+     * Make some methods available for this test class
+     */
+    private static class MVTLayerMock extends MVTLayer {
+        private final Collection<MVTTile> finishedLoading = new HashSet<>();
+
+        MVTLayerMock(ImageryInfo info) {
+            super(info);
+        }
+
+        @Override
+        protected MapboxVectorTileSource getTileSource() {
+            return super.getTileSource();
+        }
+
+        protected MapBoxVectorCachedTileLoader getTileLoader() {
+            if (this.tileLoader == null) {
+                this.tileLoader = this.getTileLoaderFactory().makeTileLoader(this, Collections.emptyMap(), 7200);
+            }
+            if (this.tileLoader instanceof MapBoxVectorCachedTileLoader) {
+                return (MapBoxVectorCachedTileLoader) this.tileLoader;
+            }
+            return null;
+        }
+
+        @Override
+        public void finishedLoading(MVTTile tile) {
+            super.finishedLoading(tile);
+            this.finishedLoading.add(tile);
+        }
+
+        public Collection<MVTTile> finishedLoading() {
+            return this.finishedLoading;
+        }
+    }
+
+    @RegisterExtension JOSMTestRules rule = new JOSMTestRules().projection();
+
+    /**
+     * Load arbitrary tiles
+     * @param layer The layer to add the tiles to
+     * @param tiles The tiles to load ([z, x, y, z, x, y, ...]) -- must be divisible by three
+     */
+    private static void loadTile(MVTLayerMock layer, int... tiles) {
+        if (tiles.length % 3 != 0 || tiles.length == 0) {
+            throw new IllegalArgumentException("Tiles come with a {z}, {x}, and {y} component");
+        }
+        final MapboxVectorTileSource tileSource = layer.getTileSource();
+        MapBoxVectorCachedTileLoader tileLoader = layer.getTileLoader();
+        Collection<MVTTile> tilesCollection = new ArrayList<>();
+        for (int i = 0; i < tiles.length / 3; i++) {
+            final MVTTile tile = (MVTTile) layer.createTile(tileSource, tiles[3 * i + 1], tiles[3 * i + 2], tiles[3 * i]);
+            tileLoader.createTileLoaderJob(tile).submit();
+            tilesCollection.add(tile);
+        }
+        Awaitility.await().atMost(Durations.FIVE_SECONDS).until(() -> layer.finishedLoading().size() == tilesCollection
+          .size());
+    }
+
+    private MVTLayerMock layer;
+
+    @BeforeEach
+    void setup() {
+        // Create the preconditions for the test
+        final ImageryInfo info = new ImageryInfo();
+        info.setName("en", "Test info");
+        info.setUrl("file:/" + Paths.get(TestUtils.getTestDataRoot(), "pbf", "mapillary", "{z}", "{x}", "{y}.mvt"));
+        layer = new MVTLayerMock(info);
+    }
+
+    @Test
+    void testNodeDeduplication() {
+        final VectorDataSet dataSet = this.layer.getData();
+        assertTrue(dataSet.allPrimitives().isEmpty());
+
+        // Set the zoom to 14, as that is the tile we are checking
+        dataSet.setZoom(14);
+        loadTile(this.layer, 14, 3248, 6258);
+
+        // Actual test
+        // With Mapillary, only ends of ways should be untagged
+        // There are 55 actual "nodes" in the data with two nodes for the ends of the way.
+        assertEquals(57, dataSet.getNodes().size());
+        assertEquals(1, dataSet.getWays().size());
+        assertEquals(0, dataSet.getRelations().size());
+    }
+
+    @Test
+    void testWayDeduplicationSimple() {
+        final VectorDataSet dataSet = this.layer.getData();
+        assertTrue(dataSet.allPrimitives().isEmpty());
+
+        // Set the zoom to 14, as that is the tile we are checking
+        dataSet.setZoom(14);
+        // Load tiles that are next to each other
+        loadTile(this.layer, 14, 3248, 6258, 14, 3248, 6257);
+
+        Map<Long, List<VectorWay>> wayGroups = dataSet.getWays().stream()
+          .collect(Collectors.groupingBy(VectorWay::getId));
+        wayGroups.forEach((id, ways) -> assertEquals(1, ways.size(), MessageFormat.format("{0} was not deduplicated", id)));
+    }
+}