Ticket #17177: 17177.9.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.FileNotFoundException;
 import java.io.IOException;
+import java.io.InputStream;
 import java.net.HttpURLConnection;
 import java.net.URL;
+import java.nio.file.Files;
 import java.security.SecureRandom;
 import java.util.Collections;
 import java.util.List;
@@ -17 +20 @@
 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 +28 @@
 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 +299 @@
         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 (InputStream fileInputStream = Files.newInputStream(file.toPath())) {
+            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 +595 @@
         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;
@@ -318 +322 @@
     private boolean tryLoadTileImage(CacheEntry object) throws IOException {
         if (object != null) {
             byte[] content = object.getContent();
-            if (content.length > 0) {
+            if (content.length > 0 || tile instanceof VectorTile) {
                 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/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();
+}

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;
+    private Geometry geometryObject;
+
+    /**
+     * 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(ProtoBufParser.decodeZigZag(number));
+                            }
+                        }
+                        // 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;
+    }
+
+    /**
+     * Get the an object with shapes for the geometry
+     * @return An object with usable geometry information
+     */
+    public Geometry getGeometryObject() {
+        if (this.geometryObject == null) {
+            this.geometryObject = new Geometry(this.getGeometryType(), this.getGeometry());
+        }
+        return this.geometryObject;
+    }
+}

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.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * A class to generate geometry for a vector tile
+ * @author Taylor Smock
+ * @since xxx
+ */
+public class Geometry {
+    final Collection<Shape> shapes = new ArrayList<>();
+
+    /**
+     * Create a {@link Geometry} for a {@link Feature}
+     * @param geometryType The type of geometry
+     * @param commands The commands used to create the geometry
+     */
+    public Geometry(GeometryTypes geometryType, List<CommandInteger> commands) {
+        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 && operations.length > 0) {
+                    for (int i = 0; i < operations.length / 2; i++) {
+                        // Just using Ellipse2D since it extends Shape
+                        shapes.add(new Ellipse2D.Float(operations[2 * i],
+                                operations[2 * i + 1], 0, 0));
+                    }
+                } 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) {
+                    shapes.remove(line);
+                    // new Area() closes the line if it isn't already closed
+                    if (area == null) {
+                        area = new Area();
+                        shapes.add(area);
+                    }
+
+                    Area nArea = new Area(line);
+                    // SonarLint thinks that this is never > 0. It can be.
+                    if (areaAreaSq > 0) {
+                        area.add(nArea);
+                    } else if (areaAreaSq < 0) {
+                        area.exclusiveOr(nArea);
+                    } else {
+                        throw new IllegalArgumentException(tr("{0} cannot have zero area", geometryType));
+                    }
+                } else {
+                    throw new IllegalArgumentException(tr("{0} with {1} arguments is not understood", geometryType, operations.length));
+                }
+            }
+        }
+    }
+
+    /**
+     * 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,
+    /** 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,
+    /** May be a line or a multiline geometry. Each line {@link Command#MoveTo} and one or more {@link Command#LineTo}. */
+    LINESTRING,
+    /** 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;
+
+    /**
+     * 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 final 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;
+
+    /**
+     * 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.getOrDefault((int) VERSION_FIELD, Collections.emptyList()).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());
+        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 getFeatures().stream().map(Feature::getGeometryObject).collect(Collectors.toList());
+    }
+
+    /**
+     * 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;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (other instanceof Layer) {
+            Layer o = (Layer) other;
+            return this.extent == o.extent
+              && this.version == o.version
+              && Objects.equals(this.name, o.name)
+              && Objects.equals(this.featureCollection, o.featureCollection)
+              && Objects.equals(this.keyList, o.keyList)
+              && Objects.equals(this.valueList, o.valueList);
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(this.name, this.version, this.extent, this.featureCollection, this.keyList, this.valueList);
+    }
+}

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.image.BufferedImage;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+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;
+    static final BufferedImage CLEAR_LOADED = new BufferedImage(1, 1, BufferedImage.TYPE_4BYTE_ABGR);
+
+    /**
+     * 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 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);
+            this.finishLoading();
+            this.listenerList.fireEvent(event -> event.finishedLoading(this));
+            // Ensure that we don't keep the loading image around
+            this.image = CLEAR_LOADED;
+        }
+    }
+
+    @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();
+    }
+}

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.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;
+
+    /**
+     * Create a new {@link MapboxVectorTileSource} from an {@link ImageryInfo}
+     * @param info The info to create the source from
+     */
+    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(() -> {
+                    ExtendedDialog dialog = new ExtendedDialog(MainApplication.getMainFrame(),
+                      tr("Select Vector Tile Layers"), tr("Add layers"));
+                    JosmComboBox<Source> comboBox = new JosmComboBox<>(sources.toArray(new Source[0]));
+                    comboBox.setSelectedIndex(0);
+                    dialog.setContent(comboBox);
+                    dialog.showDialog();
+                    return (Source) comboBox.getSelectedItem();
+                });
+            } else {
+                // Umm. What happened? We probably have an invalid style source.
+                throw new InvalidMapboxVectorTileException(tr("Cannot understand style source: {0}", info.getUrl()));
+            }
+            if (source != null) {
+                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());
+                }
+            }
+        }
+    }
+
+    /**
+     * 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/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.Objects;
+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 (immutable)
+ * @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 final 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 mapcssFilterExpression;
+
+    /**
+     * 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.isEmpty() && array.get(0).getValueType() == JsonValue.ValueType.STRING) {
+                if ("==".equals(array.getString(0))) {
+                    // The mapcss equivalent of == is = (for the most part)
+                    this.mapcssFilterExpression = convertToString(array.get(1)) + "=" + convertToString(array.get(2));
+                } else if (Arrays.asList("<=", ">=", ">", "<", "!=").contains(array.getString(0))) {
+                    this.mapcssFilterExpression = convertToString(array.get(1)) + array.getString(0) + convertToString(array.get(2));
+                } else {
+                    this.mapcssFilterExpression = EMPTY_STRING;
+                }
+            } else {
+                this.mapcssFilterExpression = EMPTY_STRING;
+            }
+        } else {
+            this.mapcssFilterExpression = 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.mapcssFilterExpression) ? '[' + this.mapcssFilterExpression + ']' : EMPTY_STRING;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (other instanceof Expression) {
+            Expression o = (Expression) other;
+            return Objects.equals(this.mapcssFilterExpression, o.mapcssFilterExpression);
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(this.mapcssFilterExpression);
+    }
+}

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.Objects;
+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;
+    /** The id for the style -- used for image paths */
+    private final String styleId;
+    /**
+     * Create a layer object
+     * @param layerInfo The info to use to create the layer
+     */
+    public Layers(final JsonObject layerInfo) {
+        this (null, layerInfo);
+    }
+
+    /**
+     * Create a layer object
+     * @param styleId The id for the style (image paths require this)
+     * @param layerInfo The info to use to create the layer
+     */
+    public Layers(final String styleId, final JsonObject layerInfo) {
+        this.id = layerInfo.getString("id");
+        this.styleId = styleId;
+        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.getOrDefault("layout", JsonValue.EMPTY_JSON_OBJECT).asJsonObject();
+            // Don't throw exceptions here, since we may just point at the styling
+            if ("visible".equalsIgnoreCase(layoutObject.getString("visibility", "visible"))) {
+                switch (type) {
+                case FILL:
+                    // area
+                    this.paint = parsePaintFill(paintObject);
+                    break;
+                case LINE:
+                    // way
+                    this.paint = parsePaintLine(layoutObject, 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 = EMPTY_STRING;
+            }
+        } else {
+            this.paint = EMPTY_STRING;
+        }
+        this.sourceLayer = layerInfo.getString("source-layer", null);
+    }
+
+    /**
+     * Get the filter for this layer
+     * @return The filter
+     */
+    public Expression getFilter() {
+        return this.filter;
+    }
+
+    /**
+     * Get the unique id for this layer
+     * @return The unique id
+     */
+    public String getId() {
+        return this.id;
+    }
+
+    /**
+     * Get the type of this layer
+     * @return The layer type
+     */
+    public Type getType() {
+        return this.type;
+    }
+
+    private static String parsePaintLine(final JsonObject layoutObject, final JsonObject paintObject) {
+        final StringBuilder sb = new StringBuilder(36);
+        // line-blur, default 0 (px)
+        // line-color, default #000000, disabled by line-pattern
+        final String color = paintObject.getString("line-color", "#000000");
+        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 = layoutObject.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) {
+        final StringBuilder sb = new StringBuilder(150).append("symbol-shape:circle;")
+          // circle-blur
+          // circle-color
+          .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
+          .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 String parsePaintSymbol(
+      final JsonObject layoutObject,
+      final JsonObject paintObject) {
+        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(");
+            if (this.styleId != null && !this.styleId.trim().isEmpty()) {
+                sb.append('"').append(this.styleId).append('/').append("\",");
+            }
+            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.toString().endsWith(",\"")) {
+                stringBuffer.delete(stringBuffer.length() - ",\"".length(), stringBuffer.length());
+            } else if (!matcher.hitEnd()) {
+                stringBuffer.append('"');
+            }
+            StringBuffer tail = new StringBuffer();
+            matcher.appendTail(tail);
+            if (tail.length() > 0) {
+                String current = stringBuffer.toString();
+                if (!"\"".equals(current) && !current.endsWith(",\"")) {
+                    stringBuffer.append(",\"");
+                }
+                stringBuffer.append(tail);
+                stringBuffer.append('"');
+            }
+
+            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 = paintObject.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 (layoutObject.containsKey("text-field")) {
+            sb.append("text:")
+              .append(layoutObject.getString("text-field").replace("}", EMPTY_STRING).replace("{", EMPTY_STRING))
+              .append(SEMI_COLON);
+        }
+        // text-font
+        if (layoutObject.containsKey("text-font")) {
+            List<String> fonts = layoutObject.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.getJsonNumber("text-halo-width").intValue()).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 = layoutObject.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) {
+        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) {
+        StringBuilder sb = new StringBuilder(50)
+          // fill-antialias
+          // fill-color
+          .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
+          .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();
+    }
+
+    /**
+     * Converts this layer object to a mapcss entry string (to be parsed later)
+     * @return The mapcss entry (string form)
+     */
+    @Override
+    public String toString() {
+        if (this.filter.toString().isEmpty() && this.paint.isEmpty()) {
+            return EMPTY_STRING;
+        } else if (this.type == Type.BACKGROUND) {
+            // AFAIK, paint has no zoom levels, and doesn't accept a layer
+            return "canvas{" + this.paint + "}";
+        }
+
+        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.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;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (other != null && this.getClass() == other.getClass()) {
+            Layers o = (Layers) other;
+            return this.type == o.type
+              && this.minZoom == o.minZoom
+              && this.maxZoom == o.maxZoom
+              && Objects.equals(this.id, o.id)
+              && Objects.equals(this.styleId, o.styleId)
+              && Objects.equals(this.sourceLayer, o.sourceLayer)
+              && Objects.equals(this.source, o.source)
+              && Objects.equals(this.filter, o.filter)
+              && Objects.equals(this.paint, o.paint);
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(this.type, this.minZoom, this.maxZoom, this.id, this.styleId, this.sourceLayer, this.source,
+          this.filter, this.paint);
+    }
+}

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;
+import java.awt.image.BufferedImage;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+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.spi.preferences.Config;
+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);
+            String id = jsonObject.getString("id", this.name);
+            this.spriteUrl = jsonObject.getString("sprite", null);
+            this.glyphUrl = jsonObject.getString("glyphs", null);
+            final List<Source> sourceList;
+            if (jsonObject.containsKey("sources") && jsonObject.get("sources").getValueType() == JsonValue.ValueType.OBJECT) {
+                final JsonObject sourceObj = jsonObject.getJsonObject("sources");
+                sourceList = sourceObj.entrySet().stream().filter(entry -> entry.getValue().getValueType() == JsonValue.ValueType.OBJECT)
+                  .map(entry -> new Source(entry.getKey(), entry.getValue().asJsonObject())).collect(Collectors.toList());
+            } else {
+                sourceList = 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(obj -> new Layers(id, obj))
+                  .collect(Collectors.toList());
+            } else {
+                layers = Collections.emptyList();
+            }
+            final Map<Optional<Source>, List<Layers>> sourceLayer = layers.stream().collect(
+              Collectors.groupingBy(layer -> sourceList.stream().filter(source -> source.getName().equals(layer.getSource()))
+                .findFirst(), LinkedHashMap::new, Collectors.toList()));
+            // Abuse HashMap null (null == default)
+            this.sources = new LinkedHashMap<>();
+            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;
+        if (object instanceof Image) {
+            // Images have a specific location where they are looked for
+            cache = new File(Config.getDirs().getUserDataDirectory(true), "images");
+        } else {
+            cache = JosmBaseDirectories.getInstance().getCacheDirectory(true);
+        }
+        final File location = new File(cache, this.name != null ? this.name : Integer.toString(this.hashCode()));
+        if ((!location.exists() && !location.mkdirs()) || (location.exists() && !location.isDirectory())) {
+            // Don't try to save if the file exists and is not a directory or we couldn't create it
+            return;
+        }
+        final File toSave = new File(location, name);
+        try (OutputStream fileOutputStream = Files.newOutputStream(toSave.toPath())) {
+            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) {
+                // This directory is checked first when getting images
+                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 boolean equals(Object other) {
+        if (other != null && other.getClass() == this.getClass()) {
+            MapBoxVectorStyle o = (MapBoxVectorStyle) other;
+            return this.version == o.version
+              && Objects.equals(this.name, o.name)
+              && Objects.equals(this.glyphUrl, o.glyphUrl)
+              && Objects.equals(this.spriteUrl, o.spriteUrl)
+              && Objects.equals(this.sources, o.sources);
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(this.name, this.version, this.glyphUrl, this.spriteUrl, this.sources);
+    }
+}

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.text.MessageFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+import java.util.Objects;
+import java.util.function.IntFunction;
+
+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 {
+    /**
+     * A common function for zoom constraints
+     */
+    private static class ZoomBoundFunction implements IntFunction<Integer> {
+        private final int min;
+        private final int max;
+        /**
+         * Create a new bound for zooms
+         * @param min The min zoom
+         * @param max The max zoom
+         */
+        ZoomBoundFunction(int min, int max) {
+            this.min = min;
+            this.max = max;
+        }
+
+        @Override public Integer apply(int value) {
+            return Math.max(min, Math.min(value, max));
+        }
+    }
+
+    /**
+     * WMS servers should contain a "{bbox-epsg-3857}" parameter for the bbox
+     */
+    private static final String WMS_BBOX = "bbox-epsg-3857";
+
+    private static final String[] NO_URLS = new String[0];
+
+    /**
+     * Constrain the min/max zooms to be between 0 and 30, as per tilejson spec
+     */
+    private static final IntFunction<Integer> ZOOM_BOUND_FUNCTION = new ZoomBoundFunction(0, 30);
+
+    /* 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 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) {
+        Objects.requireNonNull(name, "Name cannot be null");
+        Objects.requireNonNull(data, "Data cannot be null");
+        this.name = name;
+        // "type" is required (so throw an NPE if it doesn't exist)
+        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 = ZOOM_BOUND_FUNCTION.apply(data.getInt("minzoom", 0));
+                this.maxZoom = ZOOM_BOUND_FUNCTION.apply(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");
+                    if (bJsonArray.size() != 4) {
+                        throw new IllegalArgumentException(MessageFormat.format("bounds must have four values, but has {0}", bJsonArray.size()));
+                    }
+                    final double[] bArray = new double[bJsonArray.size()];
+                    for (int i = 0; i < bJsonArray.size(); 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 {
+                    // Don't use a static instance for bounds, as it is not a immutable class
+                    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")).toArray(String[]::new);
+                } else {
+                    this.tileUrls = NO_URLS;
+                }
+                this.volatileCache = data.getBoolean("volatile", false);
+                this.tileSize = data.getInt("tileSize", 512);
+            }
+        } else {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    /**
+     * Get the bounds for this source
+     * @return The bounds where this source can be used
+     */
+    public Bounds getBounds() {
+        return this.bounds;
+    }
+
+    /**
+     * 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(Arrays.asList(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);
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (other != null && this.getClass() == other.getClass()) {
+            Source o = (Source) other;
+            return Objects.equals(this.name, o.name)
+              && this.sourceType == o.sourceType
+              && this.minZoom == o.minZoom
+              && this.maxZoom == o.maxZoom
+              && Objects.equals(this.attribution, o.attribution)
+              && Objects.equals(this.promoteId, o.promoteId)
+              && this.scheme == o.scheme
+              && this.volatileCache == o.volatileCache
+              && this.tileSize == o.tileSize
+              && Objects.equals(this.bounds, o.bounds)
+              && Objects.deepEquals(this.tileUrls, o.tileUrls);
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(this.name, this.sourceType, this.minZoom, this.maxZoom, this.attribution, this.promoteId,
+          this.scheme, this.volatileCache, this.tileSize, this.bounds, Arrays.hashCode(this.tileUrls));
+    }
+}

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
+}

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

@@ -391 +391 @@
         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());
-        }
+    public WaySegment(Way way, int i) {
+        super(way, i);
     }
 
     /**
-     * Returns the first node of the way segment.
-     * @return the first node
-     */
-    public Node getFirstNode() {
-        return way.getNode(lowerIndex);
-    }
-
-    /**
-     * 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 + ']';

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

@@ -36 +36 @@
 import java.util.Optional;
 import java.util.concurrent.ForkJoinPool;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.Lock;
 import java.util.function.BiConsumer;
 import java.util.function.Consumer;
 import java.util.function.Supplier;
@@ -1637 +1638 @@
         RenderBenchmarkCollector benchmark = benchmarkFactory.get();
         BBox bbox = bounds.toBBox();
         getSettings(renderVirtualNodes);
-
         try {
-            if (data.getReadLock().tryLock(1, TimeUnit.SECONDS)) {
+            Lock readLock = data.getReadLock();
+            if (readLock.tryLock(1, TimeUnit.SECONDS)) {
                 try {
                     paintWithLock(data, renderVirtualNodes, benchmark, bbox);
                 } finally {
-                    data.getReadLock().unlock();
+                    readLock.unlock();
                 }
             } else {
                 Logging.warn("Cannot paint layer {0}: It is locked.");

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);
+        }
+    }
+
+    /**
+     * 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);
+    /**
+     * 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();
+        // This boundary condition could be >= or <= or both. Tests indicate that it doesn't actually matter.
+        // The only difference would be the number type returned, except it is always converted to the most basic type.
+        final int shift = (value > Integer.MAX_VALUE || value < Integer.MIN_VALUE ? Long.BYTES : Integer.BYTES) * 8 - 1;
+        return convertLong((value << 1) ^ (value >> shift));
+    }
+
+    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);
+        }
+    }
+
+    /**
+     * 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;
+    }
+
+    @Override
+    public void close() {
+        try {
+            this.inputStream.close();
+        } catch (IOException e) {
+            Logging.error(e);
+        }
+    }
+
+    /**
+     * 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" 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();
+    }
+
+    /**
+     * 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);
+    }
+
+    /**
+     * 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);
+    }
+
+    /**
+     * 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 && currentByte > 0) {
+            // 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;
+    }
+
+    /**
+     * 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;
+    }
+}

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 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 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;
+    }
+
+    /**
+     * 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 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 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 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);
+    }
+
+    @Override
+    public void close() {
+        this.bytes = null;
+    }
+
+    /**
+     * Get the raw bytes for this record
+     *
+     * @return The bytes
+     */
+    public byte[] getBytes() {
+        return this.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;
+    }
+}

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/DataStore.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.vector;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
+import org.openstreetmap.gui.jmapviewer.Tile;
+import org.openstreetmap.josm.data.DataSource;
+import org.openstreetmap.josm.data.osm.DataSet;
+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.PrimitiveId;
+import org.openstreetmap.josm.data.osm.QuadBucketPrimitiveStore;
+import org.openstreetmap.josm.data.osm.Storage;
+
+/**
+ * A class that stores data (essentially a simple {@link DataSet})
+ * @author Taylor Smock
+ * @since xxx
+ */
+class DataStore<O extends IPrimitive, N extends INode, W extends IWay<N>, R extends IRelation<?>> {
+    /**
+     * 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
+     */
+    static class LocalQuadBucketPrimitiveStore<N extends INode, W extends IWay<N>, R extends IRelation<?>>
+      extends QuadBucketPrimitiveStore<N, W, R> {
+        // Allow us to remove primitives (protected in {@link QuadBucketPrimitiveStore})
+        @Override
+        public void removePrimitive(IPrimitive primitive) {
+            super.removePrimitive(primitive);
+        }
+    }
+
+    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<>();
+    private final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
+
+    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() {
+        if (this.readWriteLock.isWriteLocked()) {
+            return new HashMap<>(this.primitivesMap);
+        }
+        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
+     */
+    @SuppressWarnings("squid:S2445")
+    protected void removePrimitive(O primitive) {
+        if (primitive == null) {
+            return;
+        }
+        // This is deliberate -- attempting to remove the primitive twice causes issues
+        synchronized (primitive) {
+            if (this.allPrimitives.contains(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);
+    }
+
+    /**
+     * Get the read/write lock for this dataset
+     * @return The read/write lock
+     */
+    protected ReentrantReadWriteLock getReadWriteLock() {
+        return this.readWriteLock;
+    }
+}

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.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.Optional;
+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.IntStream;
+import java.util.stream.Stream;
+
+import org.openstreetmap.gui.jmapviewer.Tile;
+import org.openstreetmap.josm.data.DataSource;
+import org.openstreetmap.josm.data.imagery.vectortile.VectorTile;
+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.OsmData;
+import org.openstreetmap.josm.data.osm.PrimitiveId;
+import org.openstreetmap.josm.data.osm.UploadPolicy;
+import org.openstreetmap.josm.data.osm.WaySegment;
+import org.openstreetmap.josm.gui.mappaint.ElemStyles;
+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 String name;
+    private short mappaintCacheIdx = 1;
+
+    private final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
+
+    /**
+     * 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, tZoom -> new VectorDataStore(this, tZoom));
+        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, tZoom -> new VectorDataStore(this, tZoom));
+        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 get this dynamically. Not critical, as this is currently the _only_ version.
+    }
+
+    @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;
+        final VectorDataStore dataStore = this.dataStoreMap.computeIfAbsent(currentZoom, tZoom -> new VectorDataStore(this, tZoom));
+        tryWrite(dataStore, () -> dataStore.addPrimitive(primitive));
+    }
+
+    /**
+     * Remove a primitive from this dataset
+     *
+     * @param primitive The primitive to remove
+     */
+    protected void removePrimitive(VectorPrimitive primitive) {
+        if (primitive.getDataSet() == this) {
+            primitive.setDataSet(null);
+            this.dataStoreMap.values()
+              .forEach(vectorDataStore -> tryWrite(vectorDataStore, () -> vectorDataStore.removePrimitive(primitive)));
+        }
+    }
+
+    @Override
+    public void clear() {
+        synchronized (this.dataStoreMap) {
+            this.dataStoreMap.clear();
+        }
+    }
+
+    @Override
+    public List<VectorNode> searchNodes(BBox bbox) {
+        return this.getBestZoomDataStore().map(VectorDataStore::getStore).map(store -> store.searchNodes(bbox))
+          .orElseGet(Collections::emptyList);
+    }
+
+    @Override
+    public boolean containsNode(VectorNode vectorNode) {
+        return this.getBestZoomDataStore().map(VectorDataStore::getStore).map(store -> store.containsNode(vectorNode)).orElse(false);
+    }
+
+    @Override
+    public List<VectorWay> searchWays(BBox bbox) {
+        return this.getBestZoomDataStore().map(VectorDataStore::getStore).map(store -> store.searchWays(bbox))
+          .orElseGet(Collections::emptyList);
+    }
+
+    @Override
+    public boolean containsWay(VectorWay vectorWay) {
+        return this.getBestZoomDataStore().map(VectorDataStore::getStore).map(store -> store.containsWay(vectorWay)).orElse(false);
+    }
+
+    @Override
+    public List<VectorRelation> searchRelations(BBox bbox) {
+        return this.getBestZoomDataStore().map(VectorDataStore::getStore).map(store -> store.searchRelations(bbox))
+          .orElseGet(Collections::emptyList);
+    }
+
+    @Override
+    public boolean containsRelation(VectorRelation vectorRelation) {
+        return this.getBestZoomDataStore().map(VectorDataStore::getStore).map(store -> store.containsRelation(vectorRelation)).orElse(false);
+    }
+
+    @Override
+    public VectorPrimitive getPrimitiveById(PrimitiveId primitiveId) {
+        return this.getBestZoomDataStore().map(VectorDataStore::getPrimitivesMap).map(m -> m .get(primitiveId)).orElse(null);
+    }
+
+    // The last return statement is "unchecked", even though it is literally the same as the previous return, except
+    // as an optional.
+    @SuppressWarnings("unchecked")
+    @Override
+    public <T extends VectorPrimitive> Collection<T> getPrimitives(
+      Predicate<? super VectorPrimitive> predicate) {
+        final VectorDataStore dataStore = this.getBestZoomDataStore().orElse(null);
+        if (dataStore == null) {
+            return Collections.emptyList();
+        }
+
+        if (dataStore.getReadWriteLock().isWriteLocked()) {
+            return new SubclassFilteredCollection<>(new HashSet<>(dataStore.getAllPrimitives()), predicate);
+        }
+        return (Collection<T>) tryRead(dataStore, () -> new SubclassFilteredCollection<>(dataStore.getAllPrimitives(), predicate))
+          // Throw an NPE if we don't have a collection (this should never happen, so if it does, _something_ is wrong)
+          .orElseThrow(NullPointerException::new);
+    }
+
+    @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;
+    }
+
+    /**
+     * Get the current Read/Write lock
+     * @implNote This changes based off of zoom level. Please do not use this in a finally block
+     * @return The current read/write lock
+     */
+    @Override
+    public Lock getReadLock() {
+        return getBestZoomDataStore().map(VectorDataStore::getReadWriteLock).map(ReentrantReadWriteLock::readLock)
+          .orElse(this.readWriteLock.readLock());
+    }
+
+    @Override
+    public Collection<WaySegment> getHighlightedVirtualNodes() {
+        // TODO? This requires a change to WaySegment so that it isn't Way/Node specific
+        return Collections.emptyList();
+    }
+
+    @Override
+    public void setHighlightedVirtualNodes(Collection<WaySegment> waySegments) {
+        // TODO? This requires a change to WaySegment so that it isn't Way/Node specific
+    }
+
+    @Override
+    public Collection<WaySegment> getHighlightedWaySegments() {
+        // TODO? This requires a change to WaySegment so that it isn't Way/Node specific
+        return Collections.emptyList();
+    }
+
+    @Override
+    public void setHighlightedWaySegments(Collection<WaySegment> waySegments) {
+        // TODO? This requires a change to WaySegment so that it isn't Way/Node specific
+    }
+
+    @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 Optional<VectorDataStore> dataStore = this.getBestZoomDataStore();
+        return dataStore.map(vectorDataStore -> vectorDataStore.getAllPrimitives().stream()
+          .filter(primitive -> this.selected.contains(primitive.getPrimitiveId()))
+          .collect(Collectors.toList())).orElse(Collections.emptyList());
+    }
+
+    /**
+     * Get the best zoom datastore
+     * @return A datastore with data, or {@code null} if no good datastore exists.
+     */
+    private Optional<VectorDataStore> getBestZoomDataStore() {
+        final int currentZoom = this.zoom;
+        if (this.dataStoreMap.containsKey(currentZoom)) {
+            return Optional.of(this.dataStoreMap.get(currentZoom));
+        }
+        // Check up to two zooms higher (may cause perf hit)
+        for (int tZoom = currentZoom + 1; tZoom < currentZoom + 3; tZoom++) {
+            if (this.dataStoreMap.containsKey(tZoom)) {
+                return Optional.of(this.dataStoreMap.get(tZoom));
+            }
+        }
+        // Return *any* lower zoom data (shouldn't cause a perf hit...)
+        for (int tZoom = currentZoom - 1; tZoom >= 0; tZoom--) {
+            if (this.dataStoreMap.containsKey(tZoom)) {
+                return Optional.of(this.dataStoreMap.get(tZoom));
+            }
+        }
+        // Check higher level zooms. May cause perf issues if selected datastore has a lot of data.
+        for (int tZoom = currentZoom + 3; tZoom < 34; tZoom++) {
+            if (this.dataStoreMap.containsKey(tZoom)) {
+                return Optional.of(this.dataStoreMap.get(tZoom));
+            }
+        }
+        return Optional.empty();
+    }
+
+    @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.zoom = zoom;
+        this.clearMappaintCache();
+        final int[] nearestZoom = {-1, -1, -1, -1};
+        nearestZoom[0] = zoom;
+        // Create a new list to avoid concurrent modification issues
+        synchronized (this.dataStoreMap) {
+            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];
+            }
+
+            nearestZoom[3] = this.getBestZoomDataStore().map(VectorDataStore::getZoom).orElse(-1);
+            IntStream.of(keys).filter(key -> IntStream.of(nearestZoom).noneMatch(zoomKey -> zoomKey == key))
+              .mapToObj(this.dataStoreMap::get).forEach(VectorDataStore::destroy);
+            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) {
+        final int currentZoom = tile.getZoom();
+        // computeIfAbsent should be thread safe (ConcurrentHashMap indicates it is, anyway)
+        final VectorDataStore dataStore = this.dataStoreMap.computeIfAbsent(currentZoom, tZoom -> new VectorDataStore(this, tZoom));
+        tryWrite(dataStore, () -> 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 static <T> Optional<T> tryRead(VectorDataStore dataStore, Supplier<T> supplier) {
+        try {
+            dataStore.getReadWriteLock().readLock().lockInterruptibly();
+            return Optional.ofNullable(supplier.get());
+        } catch (InterruptedException e) {
+            Logging.error(e);
+            Thread.currentThread().interrupt();
+        } finally {
+            dataStore.getReadWriteLock().readLock().unlock();
+        }
+        return Optional.empty();
+    }
+
+    /**
+     * Try to write something (here to avoid boilerplate)
+     *
+     * @param runnable The writing function
+     */
+    private static void tryWrite(VectorDataStore dataStore, Runnable runnable) {
+        try {
+            dataStore.getReadWriteLock().writeLock().lockInterruptibly();
+            runnable.run();
+        } catch (InterruptedException e) {
+            Logging.error(e);
+            Thread.currentThread().interrupt();
+        } finally {
+            if (dataStore.getReadWriteLock().isWriteLockedByCurrentThread()) {
+                dataStore.getReadWriteLock().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;
+        }
+    }
+}

new file src/org/openstreetmap/josm/data/vector/VectorDataStore.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.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+import org.openstreetmap.gui.jmapviewer.Coordinate;
+import org.openstreetmap.gui.jmapviewer.Tile;
+import org.openstreetmap.gui.jmapviewer.interfaces.ICoordinate;
+import org.openstreetmap.josm.data.imagery.vectortile.VectorTile;
+import org.openstreetmap.josm.data.imagery.vectortile.mapbox.Layer;
+import org.openstreetmap.josm.data.osm.BBox;
+import org.openstreetmap.josm.data.osm.INode;
+import org.openstreetmap.josm.data.osm.IRelation;
+import org.openstreetmap.josm.data.osm.IWay;
+import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
+import org.openstreetmap.josm.data.osm.SimplePrimitiveId;
+import org.openstreetmap.josm.data.osm.UniqueIdGenerator;
+import org.openstreetmap.josm.gui.dialogs.relation.sort.RelationSorter;
+import org.openstreetmap.josm.tools.Destroyable;
+import org.openstreetmap.josm.tools.Geometry;
+
+/**
+ * A data store for Vector Data sets
+ * @author Taylor Smock
+ * @since xxx
+ */
+class VectorDataStore extends DataStore<VectorPrimitive, VectorNode, VectorWay, VectorRelation> implements Destroyable {
+    private static final String JOSM_MERGE_TYPE_KEY = "josm_merge_type";
+    private final VectorDataSet dataSet;
+
+    VectorDataStore(VectorDataSet dataSet, int zoom) {
+        super(zoom);
+        this.dataSet = dataSet;
+    }
+
+    @Override
+    protected void addPrimitive(VectorPrimitive primitive) {
+        primitive.setDataSet(this.dataSet);
+        // 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(this.dataSet);
+            super.addPrimitive(primitive);
+            super.addPrimitive(temporaryRelation);
+        }
+    }
+
+    private VectorPrimitive mergeWays(VectorRelation relation) {
+        List<VectorRelationMember> members = RelationSorter.sortMembersByConnectivity(relation.getMembers());
+        Collection<VectorWay> relationWayList = members.stream().map(VectorRelationMember::getMember)
+          .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 (last first, since the list *should* be sorted)
+                if (canMergeWays(wayList.get(wayList.size() - 1), way, false)) {
+                    wayList.add(way);
+                } else if (canMergeWays(wayList.get(0), way, false)) {
+                    wayList.add(0, 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 static <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(), VectorDataSet.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.getFeatures().forEach(feature -> {
+                    org.openstreetmap.josm.data.imagery.vectortile.mapbox.Geometry geometry = feature
+                      .getGeometryObject();
+                    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;
+                    }
+                    primitive.setId(feature.getId());
+                    feature.getTags().forEach(primitive::put);
+                    featureObjects.forEach(this::addPrimitive);
+                    primaryFeatureObjects.forEach(this::addPrimitive);
+                    this.addPrimitive(primitive);
+                });
+            }
+        }
+    }
+
+    @Override
+    public void destroy() {
+        this.addedTiles.forEach(tile -> tile.setLoaded(false));
+        this.addedTiles.forEach(tile -> tile.setImage(null));
+        this.addedTiles.clear();
+        this.store.clear();
+        this.allPrimitives.clear();
+        this.primitivesMap.clear();
+    }
+}

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
+     */
+    protected VectorPrimitive(String layer) {
+        this.layer = layer;
+        this.id = getIdGenerator().generateUniqueId();
+    }
+
+    @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/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);
     }
 }

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/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;
@@ -889 +891 @@
             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);
         }
@@ -1042 +1044 @@
                     img = getLoadedTileImage(tile);
                     anchorImage = getAnchor(tile, img);
                 }
-                if (img == null || anchorImage == null) {
+                if (img == null || anchorImage == null || (tile instanceof VectorTile && !tile.isLoaded())) {
                     miss = true;
                 }
             }
@@ -1051 +1053 @@
                 return;
             }
 
-            img = applyImageProcessors(img);
+            if (img != null) {
+                img = applyImageProcessors(img);
+            }
 
             TileAnchor anchorScreen = coordinateConverter.getScreenAnchorForTile(tile);
             synchronized (paintMutex) {
@@ -1863 +1867 @@
 
                 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));
                     }
                 }
             }
@@ -1969 +1973 @@
         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();
@@ -1989 +2007 @@
             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()));
         }

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.VectorPrimitive;
+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";
+    // Just to avoid allocating a bunch of 0 length action arrays
+    private static final Action[] EMPTY_ACTIONS = new Action[0];
+    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(EMPTY_ACTIONS);
+    }
+
+    /**
+     * 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;
+                    final VectorPrimitive vectorPrimitive = member.getMember();
+                    if (vectorPrimitive instanceof VectorNode) {
+                        primitive = nodeMap.get(vectorPrimitive);
+                    } else if (vectorPrimitive instanceof VectorWay) {
+                        primitive = wayMap.get(vectorPrimitive);
+                    } else if (vectorPrimitive instanceof VectorRelation) {
+                        // Hopefully, relations are encountered in order...
+                        primitive = relationMap.get(vectorPrimitive);
+                    } 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/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;
-                }
+        synchronized (osm.getStyleCacheSyncObject()) {
+            if (!osm.isCachedStyleUpToDate() || scale <= 0) {
+                osm.setCachedStyle(StyleCache.EMPTY_STYLECACHE);
             } else {
-                boolean hasNonModifier = false;
-                boolean hasText = false;
-                for (StyleElement s : p.a) {
-                    if (s instanceof BoxTextElement) {
-                        hasText = true;
+                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 {
-                        if (!s.isModifier) {
-                            hasNonModifier = true;
+                        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);
+                    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);
+            } else if (osm instanceof IWay && isDefaultLines()) {
+                boolean hasProperLineStyle = false;
+                for (StyleElement s : p.a) {
+                    if (s.isProperLineStyle()) {
+                        hasProperLineStyle = true;
                         break;
                     }
                 }
-                p.a = new StyleElementList(p.a, line);
+                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;
         }
-        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;
     }
 
     /**
@@ -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);

src/org/openstreetmap/josm/gui/mappaint/mapcss/ConditionFactory.java

@@ -875 +875 @@
             }
             return e.osm.isSelected();
         }
+
+        /**
+         * Check if the object is highlighted (i.e., is hovered over)
+         * @param e The MapCSS environment
+         * @return {@code true} if the object is highlighted
+         * @see IPrimitive#isHighlighted
+         * @since xxx
+         */
+        static boolean highlighted(Environment e) { // NO_UCD (unused code)
+            return e.osm.isHighlighted();
+        }
     }
 
     /**

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));
@@ -440 +441 @@
             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/data/mapillary.json

@@ +1 @@
+{
+  "version":8,
+  "name":"Mapillary",
+  "owner":"Mapillary",
+  "id":"mapillary",
+  "sources":{
+      "mapillary-source":{
+        "type":"vector",
+        "tiles":[
+            "https://tiles3.mapillary.com/v0.1/{z}/{x}/{y}.mvt"
+        ],
+        "maxzoom":14
+      },
+      "mapillary-features-source": {
+        "maxzoom": 20,
+        "minzoom": 14,
+        "tiles": [ "https://a.mapillary.com/v3/map_features?tile={z}/{x}/{y}&client_id=_apiKey_&layers=points&per_page=1000" ],
+        "type": "vector"
+      },
+      "mapillary-traffic-signs-source": {
+        "maxzoom": 20,
+        "minzoom": 14,
+        "tiles": [ "https://a.mapillary.com/v3/map_features?tile={z}/{x}/{y}&client_id=_apiKey_&layers=trafficsigns&per_page=1000" ],
+        "type": "vector"
+      }
+  },
+  "layers":[
+    {
+      "filter": [ "==", "pano", 1 ],
+      "id": "mapillary-panos",
+      "type": "circle",
+      "source": "mapillary-source",
+      "source-layer": "mapillary-images",
+      "minzoom": 17,
+      "paint": {
+        "circle-color": "#05CB63",
+        "circle-opacity": 0.5,
+        "circle-radius": 18
+      }
+    },
+    {
+      "id": "mapillary-dots",
+      "type": "circle",
+      "source": "mapillary-source",
+      "source-layer": "mapillary-images",
+      "interactive": true,
+      "minzoom": 14,
+      "paint": {
+        "circle-color": "#05CB63",
+        "circle-radius": 6
+      }
+    },
+    {
+      "id": "mapillary-lines",
+      "type": "line",
+      "source": "mapillary-source",
+      "source-layer": "mapillary-sequences",
+      "minzoom": 6,
+      "paint": {
+        "line-color": "#05CB63",
+        "line-width": 2
+      }
+    },
+    {
+      "id": "mapillary-overview",
+      "type": "circle",
+      "source": "mapillary-source",
+      "source-layer": "mapillary-sequence-overview",
+      "maxzoom": 6,
+      "paint": {
+        "circle-radius": 4,
+        "circle-opacity": 0.6,
+        "circle-color": "#05CB63"
+      }
+    },
+    {
+      "id": "mapillary-features",
+      "type": "symbol",
+      "source": "mapillary-features-source",
+      "source-layer": "mapillary-map-features",
+      "interactive": true,
+      "minzoom": 14,
+      "layout": {
+        "icon-image": "{value}",
+        "icon-allow-overlap": true,
+        "symbol-avoid-edges": true
+      },
+      "paint": {
+        "text-color": "#fff",
+        "text-halo-color": "#000"
+      }
+    },
+    {
+      "id": "mapillary-traffic-signs",
+      "type": "symbol",
+      "source": "mapillary-traffic-signs-source",
+      "source-layer": "mapillary-map-features",
+      "interactive": true,
+      "minzoom": 14,
+      "layout": {
+        "icon-image": "{value}",
+        "icon-allow-overlap": true,
+        "symbol-avoid-edges": true
+      },
+      "paint": {
+        "text-color": "#fff",
+        "text-halo-color": "#000"
+      }
+    }
+  ]
+}

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

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.imagery.vectortile.mapbox;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+
+import static org.openstreetmap.josm.data.imagery.vectortile.mapbox.LayerTest.getSimpleFeatureLayerBytes;
+import static org.openstreetmap.josm.data.imagery.vectortile.mapbox.LayerTest.getLayer;
+
+import java.text.NumberFormat;
+import java.util.Arrays;
+
+import org.junit.jupiter.api.Test;
+
+/**
+ * Test class for {@link Feature}
+ */
+class FeatureTest {
+    /**
+     * This can be used to replace bytes 11-14 (inclusive) in {@link LayerTest#simpleFeatureLayerBytes}.
+     */
+    private final byte[] nonPackedTags = new byte[] {0x10, 0x00, 0x10, 0x00};
+
+    @Test
+    void testCreation() {
+        testCreation(getSimpleFeatureLayerBytes());
+    }
+
+    @Test
+    void testCreationUnpacked() {
+        byte[] copyBytes = getSimpleFeatureLayerBytes();
+        System.arraycopy(nonPackedTags, 0, copyBytes, 13, nonPackedTags.length);
+        testCreation(copyBytes);
+    }
+
+    @Test
+    void testCreationTrueToFalse() {
+        byte[] copyBytes = getSimpleFeatureLayerBytes();
+        copyBytes[copyBytes.length - 1] = 0x00; // set value=false
+        Layer layer = assertDoesNotThrow(() -> getLayer(copyBytes));
+        assertSame(Boolean.FALSE, layer.getValue(0));
+    }
+
+    @Test
+    void testNumberGrouping() {
+        // This is the float we are adding
+        // 49 74 24 00 == 1_000_000f
+        // 3f 80 00 00 == 1f
+        byte[] newBytes = new byte[] {0x22, 0x09, 0x15, 0x00, 0x24, 0x74, 0x49};
+        byte[] copyBytes = Arrays.copyOf(getSimpleFeatureLayerBytes(), getSimpleFeatureLayerBytes().length + newBytes.length - 4);
+        // Change last few bytes
+        System.arraycopy(newBytes, 0, copyBytes, 25, newBytes.length);
+        // Update the length of the record
+        copyBytes[1] = (byte) (copyBytes[1] + newBytes.length - 4);
+        final NumberFormat numberFormat = NumberFormat.getNumberInstance();
+        final boolean numberFormatGroupingUsed = numberFormat.isGroupingUsed();
+        // Sanity check
+        Layer layer;
+        try {
+            numberFormat.setGroupingUsed(true);
+            layer = assertDoesNotThrow(() -> getLayer(copyBytes));
+            assertTrue(numberFormat.isGroupingUsed());
+        } finally {
+            numberFormat.setGroupingUsed(numberFormatGroupingUsed);
+        }
+        assertEquals(1, layer.getFeatures().size());
+        assertEquals("t", layer.getName());
+        assertEquals(2, layer.getVersion());
+        assertEquals("a", layer.getKey(0));
+        assertEquals(1_000_000f, ((Number) layer.getValue(0)).floatValue(), 0.00001);
+        
+        // Feature check
+        Feature feature = layer.getFeatures().iterator().next();
+        checkDefaultGeometry(feature);
+        assertEquals("1000000", feature.getTags().get("a"));
+    }
+
+    private void testCreation(byte[] bytes) {
+        Layer layer = assertDoesNotThrow(() -> getLayer(bytes));
+        // Sanity check the layer
+        assertEquals(1, layer.getFeatures().size());
+        assertEquals("t", layer.getName());
+        assertEquals(2, layer.getVersion());
+        assertEquals("a", layer.getKey(0));
+        assertSame(Boolean.TRUE, layer.getValue(0));
+
+        // OK. Get the feature.
+        Feature feature = layer.getFeatures().iterator().next();
+
+        checkDefaultTags(feature);
+
+        // Check id (should be the default of 0)
+        assertEquals(1, feature.getId());
+
+        checkDefaultGeometry(feature);
+    }
+
+    private void checkDefaultTags(Feature feature) {
+        // Check tags
+        assertEquals(1, feature.getTags().size());
+        assertTrue(feature.getTags().containsKey("a"));
+        // We are converting to a tag map (Map<String, String>), so "true"
+        assertEquals("true", feature.getTags().get("a"));
+    }
+
+    private void checkDefaultGeometry(Feature feature) {
+        // Check the geometry
+        assertEquals(GeometryTypes.POINT, feature.getGeometryType());
+        assertEquals(1, feature.getGeometry().size());
+        CommandInteger geometry = feature.getGeometry().get(0);
+        assertEquals(Command.MoveTo, geometry.getType());
+        assertEquals(2, geometry.getOperations().length);
+        assertEquals(25, geometry.getOperations()[0]);
+        assertEquals(17, geometry.getOperations()[1]);
+        assertNotNull(feature.getGeometryObject());
+        assertEquals(feature.getGeometryObject(), feature.getGeometryObject());
+    }
+}

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

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.imagery.vectortile.mapbox;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+
+import java.awt.geom.Area;
+import java.awt.geom.Ellipse2D;
+import java.awt.geom.Path2D;
+import java.awt.geom.PathIterator;
+import java.awt.geom.Point2D;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import org.junit.jupiter.api.Test;
+
+/**
+ * Test class for {@link Geometry}
+ * @author Taylor Smock
+ * @since xxx
+ */
+class GeometryTest {
+    /**
+     * Create a command integer fairly easily
+     * @param command The command type (see {@link Command})
+     * @param parameters The parameters for the command
+     * @return A command integer
+     */
+    private static CommandInteger createCommandInteger(int command, int... parameters) {
+        CommandInteger commandInteger = new CommandInteger(command);
+        if (parameters != null) {
+            for (int parameter : parameters) {
+                commandInteger.addParameter(parameter);
+            }
+        }
+        return commandInteger;
+    }
+
+    /**
+     * Check the current
+     * @param pathIterator The path to check
+     * @param expected The expected coords
+     */
+    private static void checkCurrentSegmentAndIncrement(PathIterator pathIterator, float... expected) {
+        float[] coords = new float[6];
+        int type = pathIterator.currentSegment(coords);
+        pathIterator.next();
+        for (int i = 0; i < expected.length; i++) {
+            assertEquals(expected[i], coords[i]);
+        }
+        if (Arrays.asList(PathIterator.SEG_MOVETO, PathIterator.SEG_LINETO).contains(type)) {
+            assertEquals(2, expected.length, "You should check both x and y coordinates");
+        } else if (PathIterator.SEG_QUADTO == type) {
+            assertEquals(4, expected.length, "You should check all x and y coordinates");
+        } else if (PathIterator.SEG_CUBICTO == type) {
+            assertEquals(6, expected.length, "You should check all x and y coordinates");
+        } else if (PathIterator.SEG_CLOSE == type) {
+            assertEquals(0, expected.length, "CloseTo has no expected coordinates to check");
+        }
+    }
+
+    @Test
+    void testBadGeometry() {
+        IllegalArgumentException badPointException = assertThrows(IllegalArgumentException.class,
+          () -> new Geometry(GeometryTypes.POINT, Collections.singletonList(createCommandInteger(1))));
+        assertEquals("POINT with 0 arguments is not understood", badPointException.getMessage());
+        IllegalArgumentException badLineException = assertThrows(IllegalArgumentException.class,
+          () -> new Geometry(GeometryTypes.LINESTRING, Collections.singletonList(createCommandInteger(15))));
+        assertEquals("LINESTRING with 0 arguments is not understood", badLineException.getMessage());
+    }
+
+    @Test
+    void testPoint() {
+        CommandInteger moveTo = createCommandInteger(9, 17, 34);
+        Geometry geometry = new Geometry(GeometryTypes.POINT, Collections.singletonList(moveTo));
+        assertEquals(1, geometry.getShapes().size());
+        Ellipse2D shape = (Ellipse2D) geometry.getShapes().iterator().next();
+        assertEquals(17, shape.getCenterX());
+        assertEquals(34, shape.getCenterY());
+    }
+
+    @Test
+    void testLine() {
+        CommandInteger moveTo = createCommandInteger(9, 2, 2);
+        CommandInteger lineTo = createCommandInteger(18, 0, 8, 8, 0);
+        Geometry geometry = new Geometry(GeometryTypes.LINESTRING, Arrays.asList(moveTo, lineTo));
+        assertEquals(1, geometry.getShapes().size());
+        Path2D path = (Path2D) geometry.getShapes().iterator().next();
+        PathIterator pathIterator = path.getPathIterator(null);
+        checkCurrentSegmentAndIncrement(pathIterator, 2, 2);
+        checkCurrentSegmentAndIncrement(pathIterator, 2, 10);
+        checkCurrentSegmentAndIncrement(pathIterator, 10, 10);
+        assertTrue(pathIterator.isDone());
+    }
+
+    @Test
+    void testPolygon() {
+        List<CommandInteger> commands = new ArrayList<>(3);
+        commands.add(createCommandInteger(9, 3, 6));
+        commands.add(createCommandInteger(18, 5, 6, 12, 22));
+        commands.add(createCommandInteger(15));
+
+        Geometry geometry = new Geometry(GeometryTypes.POLYGON, commands);
+        assertEquals(1, geometry.getShapes().size());
+
+        Area area = (Area) geometry.getShapes().iterator().next();
+        PathIterator pathIterator = area.getPathIterator(null);
+        checkCurrentSegmentAndIncrement(pathIterator, 3, 6);
+        // This is somewhat unexpected, and may change based off of JVM implementations
+        // But for whatever reason, Java flips the inner coordinates in this case.
+        checkCurrentSegmentAndIncrement(pathIterator, 20, 34);
+        checkCurrentSegmentAndIncrement(pathIterator, 8, 12);
+        checkCurrentSegmentAndIncrement(pathIterator, 3, 6);
+        checkCurrentSegmentAndIncrement(pathIterator);
+        assertTrue(pathIterator.isDone());
+    }
+
+    @Test
+    void testBadPolygon() {
+        /*
+         * "Linear rings MUST be geometric objects that have no anomalous geometric points,
+         * such as self-intersection or self-tangency. The position of the cursor before
+         * calling the ClosePath command of a linear ring SHALL NOT repeat the same position
+         * as the first point in the linear ring as this would create a zero-length line
+         * segment. A linear ring SHOULD NOT have an area calculated by the surveyor's
+         * formula equal to zero, as this would signify a ring with anomalous geometric points."
+         */
+        List<CommandInteger> commands = new ArrayList<>(3);
+        commands.add(createCommandInteger(9, 0, 0));
+        commands.add(createCommandInteger(18, 0, 0));
+        commands.add(createCommandInteger(15));
+        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> new Geometry(GeometryTypes.POLYGON, commands));
+        assertEquals("POLYGON cannot have zero area", exception.getMessage());
+    }
+
+    @Test
+    void testMultiPolygon() {
+        List<CommandInteger> commands = new ArrayList<>(10);
+        // Polygon 1
+        commands.add(createCommandInteger(9, 0, 0));
+        commands.add(createCommandInteger(26, 10, 0, 0, 10, -10, 0));
+        commands.add(createCommandInteger(15));
+        // Polygon 2 outer
+        commands.add(createCommandInteger(9, 11, 1));
+        commands.add(createCommandInteger(26, 9, 0, 0, 9, -9, 0));
+        commands.add(createCommandInteger(15));
+        // Polygon 2 inner
+        commands.add(createCommandInteger(9, 2, -7));
+        commands.add(createCommandInteger(26, 0, 4, 4, 0, 0, -4));
+        commands.add(createCommandInteger(15));
+
+        Geometry geometry = new Geometry(GeometryTypes.POLYGON, commands);
+        assertEquals(1, geometry.getShapes().size());
+        Area area = (Area) geometry.getShapes().iterator().next();
+        assertFalse(area.isSingular());
+        PathIterator pathIterator = area.getPathIterator(null);
+        assertEquals(PathIterator.WIND_NON_ZERO, pathIterator.getWindingRule());
+        assertTrue(area.contains(new Point2D.Float(5, 5)));
+        assertTrue(area.contains(new Point2D.Float(12, 12)));
+        assertFalse(area.contains(new Point2D.Float(15, 15)));
+        assertFalse(area.contains(new Point2D.Float(10, 11)));
+        assertFalse(area.contains(new Point2D.Float(-1, -1)));
+    }
+}

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

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.imagery.vectortile.mapbox;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.fail;
+
+
+import org.openstreetmap.josm.TestUtils;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.EnumSource;
+
+/**
+ * Test class for {@link GeometryTypes}
+ * @author Taylor Smock
+ * @since xxx
+ */
+class GeometryTypesTest {
+    @Test
+    void testNaiveEnumTest() {
+        TestUtils.superficialEnumCodeCoverage(GeometryTypes.class);
+        TestUtils.superficialEnumCodeCoverage(GeometryTypes.Ring.class);
+    }
+
+    @ParameterizedTest
+    @EnumSource(GeometryTypes.class)
+    void testExpectedIds(GeometryTypes type) {
+        // Ensure that users can get the type from the ordinal
+        // See https://github.com/mapbox/vector-tile-spec/blob/master/2.1/vector_tile.proto#L8
+        // for the expected values
+        final int expectedId;
+        if (type == GeometryTypes.UNKNOWN) {
+            expectedId = 0;
+        } else if (type == GeometryTypes.POINT) {
+            expectedId = 1;
+        } else if (type == GeometryTypes.LINESTRING) {
+            expectedId = 2;
+        } else if (type == GeometryTypes.POLYGON) {
+            expectedId = 3;
+        } else {
+            fail("Unknown geometry type, see vector tile spec");
+            expectedId = Integer.MIN_VALUE;
+        }
+        assertEquals(expectedId, type.ordinal());
+    }
+}

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

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.imagery.vectortile.mapbox;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.List;
+
+import org.openstreetmap.josm.TestUtils;
+import org.openstreetmap.josm.data.protobuf.ProtoBufParser;
+import org.openstreetmap.josm.data.protobuf.ProtoBufRecord;
+
+import nl.jqno.equalsverifier.EqualsVerifier;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Test class for {@link Layer}
+ */
+public class LayerTest {
+    /**
+     * This looks something like this (if it were json). Note that some keys could be repeated,
+     * and so could be better represented as an array. Specifically, "features", "key", and "value".
+     * "layer": {
+     *     "name": "t",
+     *     "version": 2,
+     *     "features": {
+     *         "type": "POINT",
+     *         "tags": [0, 0],
+     *         "geometry": [9, 50, 34]
+     *     },
+     *     "key": "a",
+     *     "value": true
+     * }
+     *
+     * WARNING: DO NOT MODIFY THIS ARRAY DIRECTLY -- it could contaminate other tests
+     */
+    private static final byte[] simpleFeatureLayerBytes = new byte[] {
+      0x1a, 0x1b, // layer, 27 bytes for the rest
+      0x0a, 0x01, 0x74, // name=t
+      0x78, 0x02, // version=2
+      0x12, 0x0d, // features, 11 bytes
+      0x08, 0x01, // id=1
+      0x18, 0x01, // type=POINT
+      0x12, 0x02, 0x00, 0x00, // tags=[0, 0] (packed). Non-packed would be [0x10, 0x00, 0x10, 0x00]
+      0x22, 0x03, 0x09, 0x32, 0x22, // geometry=[9, 50, 34]
+      0x1a, 0x01, 0x61, // key=a
+      0x22, 0x02, 0x38, 0x01, // value=true (boolean)
+    };
+
+    /**
+     * Gets a copy of {@link #simpleFeatureLayerBytes} so that a test doesn't accidentally change the bytes
+     * @return An array that can be modified.
+     */
+    static byte[] getSimpleFeatureLayerBytes() {
+        return Arrays.copyOf(simpleFeatureLayerBytes, simpleFeatureLayerBytes.length);
+    }
+
+    /**
+     * Create a layer from bytes
+     * @param bytes The bytes that make up the layer
+     * @return The generated layer
+     * @throws IOException If something happened (should never trigger)
+     */
+    static Layer getLayer(byte[] bytes) throws IOException {
+        List<ProtoBufRecord> records = (List<ProtoBufRecord>) new ProtoBufParser(bytes).allRecords();
+        assertEquals(1, records.size());
+        return new Layer(new ProtoBufParser(records.get(0).getBytes()).allRecords());
+    }
+
+    @Test
+    void testLayerCreation() throws IOException {
+        List<ProtoBufRecord> layers = (List<ProtoBufRecord>) new ProtoBufParser(new FileInputStream(TestUtils.getTestDataRoot()
+          + "pbf/mapillary/14/3249/6258.mvt")).allRecords();
+        Layer sequenceLayer = new Layer(layers.get(0).getBytes());
+        assertEquals("mapillary-sequences", sequenceLayer.getName());
+        assertEquals(1, sequenceLayer.getFeatures().size());
+        assertEquals(1, sequenceLayer.getGeometry().size());
+        assertEquals(2048, sequenceLayer.getExtent());
+        assertEquals(1, sequenceLayer.getVersion());
+
+        Layer imageLayer = new Layer(layers.get(1).getBytes());
+        assertEquals("mapillary-images", imageLayer.getName());
+        assertEquals(116, imageLayer.getFeatures().size());
+        assertEquals(116, imageLayer.getGeometry().size());
+        assertEquals(2048, imageLayer.getExtent());
+        assertEquals(1, imageLayer.getVersion());
+    }
+
+    @Test
+    void testLayerEqualsHashCode() throws IOException {
+        List<ProtoBufRecord> layers = (List<ProtoBufRecord>) new ProtoBufParser(new FileInputStream(TestUtils.getTestDataRoot()
+          + "pbf/mapillary/14/3249/6258.mvt")).allRecords();
+        EqualsVerifier.forClass(Layer.class).withPrefabValues(byte[].class, layers.get(0).getBytes(), layers.get(1).getBytes())
+          .verify();
+    }
+
+    @Test
+    void testVersionsNumbers() {
+        byte[] copyByte = getSimpleFeatureLayerBytes();
+        assertEquals(2, assertDoesNotThrow(() -> getLayer(copyByte)).getVersion());
+        copyByte[6] = 1;
+        assertEquals(1, assertDoesNotThrow(() -> getLayer(copyByte)).getVersion());
+        copyByte[6] = 0;
+        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> getLayer(copyByte));
+        assertEquals("We do not understand version 0 of the vector tile specification", exception.getMessage());
+        copyByte[6] = 3;
+        exception = assertThrows(IllegalArgumentException.class, () -> getLayer(copyByte));
+        assertEquals("We do not understand version 3 of the vector tile specification", exception.getMessage());
+        // Remove version number (AKA change it to some unknown field). Default is version=1.
+        copyByte[5] = 0x18;
+        assertEquals(1, assertDoesNotThrow(() -> getLayer(copyByte)).getVersion());
+    }
+
+    @Test
+    void testLayerName() throws IOException {
+        byte[] copyByte = getSimpleFeatureLayerBytes();
+        Layer layer = getLayer(copyByte);
+        assertEquals("t", layer.getName());
+        copyByte[2] = 0x1a; // name=t -> ?
+        Exception noNameException = assertThrows(IllegalArgumentException.class, () -> getLayer(copyByte));
+        assertEquals("Vector tile layers must have a layer name", noNameException.getMessage());
+    }
+
+    @Test
+    void testUnknownField() {
+        byte[] copyByte = getSimpleFeatureLayerBytes();
+        copyByte[27] = 0x78;
+        Exception unknownField = assertThrows(IllegalArgumentException.class, () -> getLayer(copyByte));
+        assertEquals("Unknown field in vector tile layer value (15)", unknownField.getMessage());
+    }
+}

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

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.imagery.vectortile.mapbox;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+import java.awt.image.BufferedImage;
+import java.util.Collections;
+import java.util.stream.Stream;
+
+import org.openstreetmap.gui.jmapviewer.Tile;
+import org.openstreetmap.gui.jmapviewer.interfaces.TileJob;
+import org.openstreetmap.josm.TestUtils;
+import org.openstreetmap.josm.data.cache.JCSCacheManager;
+import org.openstreetmap.josm.data.imagery.ImageryInfo;
+import org.openstreetmap.josm.data.imagery.TileJobOptions;
+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.extension.RegisterExtension;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+/**
+ * Test class for {@link MVTTile}
+ */
+public class MVTTileTest {
+    private MapboxVectorTileSource tileSource;
+    private MapBoxVectorCachedTileLoader loader;
+    @RegisterExtension
+    JOSMTestRules rule = new JOSMTestRules();
+    @BeforeEach
+    void setup() {
+        tileSource = new MapboxVectorTileSource(new ImageryInfo("Test Mapillary", "file:/" + TestUtils.getTestDataRoot()
+          + "pbf/mapillary/{z}/{x}/{y}.mvt"));
+        loader = new MapBoxVectorCachedTileLoader(null,
+          JCSCacheManager.getCache("testMapillaryCache"), new TileJobOptions(1, 1, Collections
+          .emptyMap(), 3600));
+    }
+
+    /**
+     * Provide arguments for {@link #testMVTTile(BufferedImage, Boolean)}
+     * @return The arguments to use
+     */
+    private static Stream<Arguments> testMVTTile() {
+        return Stream.of(
+          Arguments.of(null, Boolean.TRUE),
+          Arguments.of(Tile.LOADING_IMAGE, Boolean.TRUE),
+          Arguments.of(Tile.ERROR_IMAGE, Boolean.TRUE),
+          Arguments.of(new BufferedImage(1, 1, BufferedImage.TYPE_BYTE_GRAY), Boolean.FALSE)
+        );
+    }
+
+    @ParameterizedTest
+    @MethodSource("testMVTTile")
+    void testMVTTile(BufferedImage image, Boolean isLoaded) {
+        MVTTile tile = new MVTTile(tileSource, 3249, 6258, 14);
+        tile.setImage(image);
+        assertEquals(image, tile.getImage());
+
+        TileJob job = loader.createTileLoaderJob(tile);
+        job.submit();
+        Awaitility.await().atMost(Durations.ONE_SECOND).until(tile::isLoaded);
+        if (isLoaded) {
+            Awaitility.await().atMost(Durations.ONE_SECOND).until(() -> tile.getLayers() != null && tile.getLayers().size() > 1);
+            assertEquals(2, tile.getLayers().size());
+            // The test Mapillary tiles have 2048 instead of 4096 for their extent. This *may* change
+            // in future Mapillary tiles, so if the test PBF files are updated, beware.
+            assertEquals(2048, tile.getExtent());
+            // Ensure that we have the clear image set, such that the tile doesn't add to the dataset again
+            // and we don't have a loading image
+            assertEquals(MVTTile.CLEAR_LOADED, tile.getImage());
+        } else {
+            assertNull(tile.getLayers());
+            assertEquals(image, tile.getImage());
+        }
+    }
+
+}

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

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.imagery.vectortile.mapbox;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+
+import java.util.stream.Stream;
+
+import org.junit.jupiter.api.extension.RegisterExtension;
+import org.openstreetmap.josm.TestUtils;
+import org.openstreetmap.josm.data.imagery.ImageryInfo;
+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.widgets.JosmComboBox;
+import org.openstreetmap.josm.testutils.JOSMTestRules;
+import org.openstreetmap.josm.testutils.mockers.ExtendedDialogMocker;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+/**
+ * Test class for {@link MapboxVectorTileSource}
+ * @author Taylor Smock
+ * @since xxx
+ */
+class MapboxVectorTileSourceTest {
+    @RegisterExtension
+    JOSMTestRules rule = new JOSMTestRules();
+    private static class SelectLayerDialogMocker extends ExtendedDialogMocker {
+        int index;
+        @Override
+        protected void act(final ExtendedDialog instance) {
+            ((JosmComboBox<?>) this.getContent(instance)).setSelectedIndex(index);
+        }
+
+        @Override
+        protected String getString(final ExtendedDialog instance) {
+            return String.join(";", ((Source) ((JosmComboBox<?>) this.getContent(instance)).getSelectedItem()).getUrls());
+        }
+    }
+
+    @Test
+    void testNoStyle() {
+        MapboxVectorTileSource tileSource = new MapboxVectorTileSource(
+          new ImageryInfo("Test Mapillary", "file:/" + TestUtils.getTestDataRoot() + "pbf/mapillary/{z}/{x}/{y}.mvt"));
+        assertNull(tileSource.getStyleSource());
+    }
+
+    private static Stream<Arguments> testMapillaryStyle() {
+        return Stream.of(Arguments.of(0, "Test Mapillary: mapillary-source", "https://tiles3.mapillary.com/v0.1/{z}/{x}/{y}.mvt"),
+          Arguments.of(1, "Test Mapillary: mapillary-features-source",
+            "https://a.mapillary.com/v3/map_features?tile={z}/{x}/{y}&client_id=_apiKey_"
+              + "&layers=points&per_page=1000"),
+          Arguments.of(2, "Test Mapillary: mapillary-traffic-signs-source",
+            "https://a.mapillary.com/v3/map_features?tile={z}/{x}/{y}&client_id=_apiKey_"
+              + "&layers=trafficsigns&per_page=1000"));
+    }
+
+    @ParameterizedTest
+    @MethodSource("testMapillaryStyle")
+    void testMapillaryStyle(Integer index, String expected, String dialogMockerText) {
+        TestUtils.assumeWorkingJMockit();
+        SelectLayerDialogMocker extendedDialogMocker = new SelectLayerDialogMocker();
+        extendedDialogMocker.index = index;
+        extendedDialogMocker.getMockResultMap().put(dialogMockerText, "Add layers");
+        MapboxVectorTileSource tileSource = new MapboxVectorTileSource(
+          new ImageryInfo("Test Mapillary", "file:/" + TestUtils.getTestDataRoot() + "mapillary.json"));
+        MapBoxVectorStyle styleSource = tileSource.getStyleSource();
+        assertNotNull(styleSource);
+        assertEquals(expected, tileSource.toString());
+    }
+}

new file test/unit/org/openstreetmap/josm/data/imagery/vectortile/mapbox/style/ExpressionTest.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 javax.json.Json;
+import javax.json.JsonValue;
+
+import nl.jqno.equalsverifier.EqualsVerifier;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Test class for {@link Expression}
+ * @author Taylor Smock
+ * @since xxx
+ */
+class ExpressionTest {
+    @Test
+    void testInvalidJson() {
+        assertEquals(Expression.EMPTY_EXPRESSION, new Expression(JsonValue.NULL));
+        assertEquals(Expression.EMPTY_EXPRESSION, new Expression(JsonValue.FALSE));
+        assertEquals(Expression.EMPTY_EXPRESSION, new Expression(JsonValue.TRUE));
+        assertEquals(Expression.EMPTY_EXPRESSION, new Expression(JsonValue.EMPTY_JSON_OBJECT));
+        assertEquals(Expression.EMPTY_EXPRESSION, new Expression(JsonValue.EMPTY_JSON_ARRAY));
+        assertEquals(Expression.EMPTY_EXPRESSION, new Expression(Json.createObjectBuilder().add("bad", "value").build()));
+        assertEquals(Expression.EMPTY_EXPRESSION, new Expression(Json.createValue(1)));
+        assertEquals(Expression.EMPTY_EXPRESSION, new Expression(Json.createValue(1.0)));
+        assertEquals(Expression.EMPTY_EXPRESSION, new Expression(Json.createValue("bad string")));
+    }
+
+    @Test
+    void testBasicExpressions() {
+        // "filter": [ "==|>=|<=|<|>", "key", "value" ]
+        assertEquals("[key=value]", new Expression(Json.createArrayBuilder().add("==").add("key").add("value").build()).toString());
+        assertEquals("[key>=true]", new Expression(Json.createArrayBuilder().add(">=").add("key").add(true).build()).toString());
+        assertEquals("[key<=false]", new Expression(Json.createArrayBuilder().add("<=").add("key").add(false).build()).toString());
+        assertEquals("[key<1]", new Expression(Json.createArrayBuilder().add("<").add("key").add(1).build()).toString());
+        assertEquals("[key>2.5]", new Expression(Json.createArrayBuilder().add(">").add("key").add(2.5).build()).toString());
+        // Test bad expression
+        assertEquals(Expression.EMPTY_EXPRESSION, new Expression(Json.createArrayBuilder().add(">>").add("key").add("value").build()));
+
+        // Test expressions with a subarray and object. This is expected to fail when properly supported, so it should be fixed.
+        assertEquals("[key=[{bad:value}]]", new Expression(Json.createArrayBuilder().add("==").add("key").add(
+          Json.createArrayBuilder().add(Json.createObjectBuilder().add("bad", "value"))).build()).toString());
+        assertEquals("[key=]", new Expression(Json.createArrayBuilder().add("==").add("key").add(JsonValue.NULL).build()).toString());
+    }
+
+    @Test
+    void testEquals() {
+        EqualsVerifier.forClass(Expression.class).verify();
+    }
+}

new file test/unit/org/openstreetmap/josm/data/imagery/vectortile/mapbox/style/LayersTest.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.assertNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.text.MessageFormat;
+import java.util.Locale;
+
+import javax.json.Json;
+import javax.json.JsonObject;
+import javax.json.JsonValue;
+
+import nl.jqno.equalsverifier.EqualsVerifier;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Test class for {@link Layers}.
+ * @implNote Tests will fail when support is added for new styling information.
+ * All current (2021-03-31) properties are checked for in some form or another.
+ * @author Taylor Smock
+ * @since xxx
+ */
+class LayersTest {
+    @Test
+    void testBackground() {
+        // Test an empty background layer
+        Layers emptyBackgroundLayer = new Layers(Json.createObjectBuilder()
+          .add("type", Layers.Type.BACKGROUND.name())
+          .add("id", "Empty Background").build());
+        assertEquals("Empty Background", emptyBackgroundLayer.getId());
+        assertEquals(Layers.Type.BACKGROUND, emptyBackgroundLayer.getType());
+        assertNull(emptyBackgroundLayer.getSource());
+        assertSame(Expression.EMPTY_EXPRESSION, emptyBackgroundLayer.getFilter());
+        assertEquals("", emptyBackgroundLayer.toString());
+
+        // Test a background layer with some styling information
+        JsonObject allProperties = Json.createObjectBuilder()
+          .add("background-color", "#fff000") // fill-color:#fff000;
+          .add("background-opacity", 0.5) // No good mapping for JOSM yet
+          .add("background-pattern", "null") // This should be an image, not implemented
+          .build();
+        Layers backgroundLayer = new Layers(Json.createObjectBuilder()
+          .add("id", "Background layer")
+          .add("type", Layers.Type.BACKGROUND.name().toLowerCase(Locale.ROOT))
+          .add("paint", allProperties)
+        .build());
+        assertEquals("canvas{fill-color:#fff000;}", backgroundLayer.toString());
+
+        // Test a background layer with some styling information, but invisible
+        Layers invisibleBackgroundLayer = new Layers(Json.createObjectBuilder()
+          .add("id", "Background layer")
+          .add("type", Layers.Type.BACKGROUND.name().toLowerCase(Locale.ROOT))
+          .add("layout", Json.createObjectBuilder().add("visibility", "none").build())
+          .add("paint", allProperties).build());
+        assertEquals("", invisibleBackgroundLayer.toString());
+    }
+
+    @Test
+    void testFill() {
+        // Test a layer without a source (should fail)
+        assertThrows(NullPointerException.class, () -> new Layers(Json.createObjectBuilder()
+          .add("type", Layers.Type.FILL.name())
+          .add("id", "Empty Fill").build()));
+
+        // Test an empty fill layer
+        Layers emptyFillLayer = new Layers(Json.createObjectBuilder()
+          .add("type", Layers.Type.FILL.name())
+          .add("id", "Empty Fill")
+          .add("source", "Random source").build());
+        assertEquals("Empty Fill", emptyFillLayer.getId());
+        assertEquals("Random source", emptyFillLayer.getSource());
+        assertEquals("", emptyFillLayer.toString());
+
+        // Test a fully implemented fill layer
+        JsonObject allLayoutProperties = Json.createObjectBuilder()
+          .add("fill-sort-key", 5)
+          .add("visibility", "visible")
+          .build();
+        JsonObject allPaintProperties = Json.createObjectBuilder()
+          .add("fill-antialias", false)
+          .add("fill-color", "#fff000") // fill-color:#fff000
+          .add("fill-opacity", 0.5) // fill-opacity:0.5
+          .add("fill-outline-color", "#ffff00") // fill-color:#ffff00 (defaults to fill-color)
+          .add("fill-pattern", JsonValue.NULL) // disables fill-outline-color and fill-color
+          .add("fill-translate", Json.createArrayBuilder().add(5).add(5))
+          .add("fill-translate-anchor", "viewport") // requires fill-translate
+          .build();
+
+        Layers fullFillLayer = new Layers(Json.createObjectBuilder()
+          .add("type", Layers.Type.FILL.toString())
+          .add("id", "random-layer-id")
+          .add("source", "Random source")
+          .add("layout", allLayoutProperties)
+          .add("paint", allPaintProperties)
+          .build());
+        assertEquals("random-layer-id", fullFillLayer.getId());
+        assertEquals(Layers.Type.FILL, fullFillLayer.getType());
+        assertEquals("area::random-layer-id{fill-color:#fff000;fill-opacity:0.5;color:#ffff00;}", fullFillLayer.toString());
+
+        // Test a fully implemented fill layer (invisible)
+        Layers fullFillInvisibleLayer = new Layers(Json.createObjectBuilder()
+          .add("type", Layers.Type.FILL.toString())
+          .add("id", "random-layer-id")
+          .add("source", "Random source")
+          .add("layout", Json.createObjectBuilder(allLayoutProperties)
+            .add("visibility", "none"))
+          .add("paint", allPaintProperties)
+          .build());
+        assertEquals("random-layer-id", fullFillInvisibleLayer.getId());
+        assertEquals(Layers.Type.FILL, fullFillInvisibleLayer.getType());
+        assertEquals("", fullFillInvisibleLayer.toString());
+    }
+
+    @Test
+    void testLine() {
+        // Test a layer without a source (should fail)
+        assertThrows(NullPointerException.class, () -> new Layers(Json.createObjectBuilder()
+          .add("type", Layers.Type.LINE.name())
+          .add("id", "Empty Line").build()));
+
+        JsonObject allLayoutProperties = Json.createObjectBuilder()
+          .add("line-cap", "round") // linecap:round;
+          .add("line-join", "bevel")
+          .add("line-miter-limit", 65)
+          .add("line-round-limit", 1.5)
+          .add("line-sort-key", 3)
+          .add("visibility", "visible")
+          .build();
+        JsonObject allPaintProperties = Json.createObjectBuilder()
+          .add("line-blur", 5)
+          .add("line-color", "#fff000") // color:#fff000;
+          .add("line-dasharray", Json.createArrayBuilder().add(1).add(5).add(1)) // dashes:1,5,1;
+          .add("line-gap-width", 6)
+          .add("line-gradient", "#ffff00") // disabled by line-dasharray/line-pattern, source must be "geojson"
+          .add("line-offset", 12)
+          .add("line-opacity", 0.5) // opacity:0.5;
+          .add("line-pattern", JsonValue.NULL)
+          .add("line-translate", Json.createArrayBuilder().add(-1).add(-2))
+          .add("line-translate-anchor", "viewport")
+          .add("line-width", 22) // width:22;
+          .build();
+
+        // Test fully defined line
+        Layers fullLineLayer = new Layers(Json.createObjectBuilder()
+          .add("type", Layers.Type.LINE.name().toLowerCase(Locale.ROOT))
+          .add("id", "random-layer-id")
+          .add("source", "Random source")
+          .add("layout", allLayoutProperties)
+          .add("paint", allPaintProperties)
+          .build());
+        assertEquals("random-layer-id", fullLineLayer.getId());
+        assertEquals(Layers.Type.LINE, fullLineLayer.getType());
+        assertEquals("way::random-layer-id{color:#fff000;opacity:0.5;linecap:round;dashes:1,5,1;width:22;}", fullLineLayer.toString());
+
+        // Test invisible line
+        Layers fullLineInvisibleLayer = new Layers(Json.createObjectBuilder()
+          .add("type", Layers.Type.LINE.name().toLowerCase(Locale.ROOT))
+          .add("id", "random-layer-id")
+          .add("source", "Random source")
+          .add("layout", Json.createObjectBuilder(allLayoutProperties)
+            .add("visibility", "none"))
+          .add("paint", allPaintProperties)
+          .build());
+        assertEquals("random-layer-id", fullLineInvisibleLayer.getId());
+        assertEquals(Layers.Type.LINE, fullLineInvisibleLayer.getType());
+        assertEquals("", fullLineInvisibleLayer.toString());
+    }
+
+    @Test
+    void testSymbol() {
+        // Test a layer without a source (should fail)
+        assertThrows(NullPointerException.class, () -> new Layers(Json.createObjectBuilder()
+          .add("type", Layers.Type.SYMBOL.name())
+          .add("id", "Empty Symbol").build()));
+
+        JsonObject allPaintProperties = Json.createObjectBuilder()
+          .add("icon-color", "#fff000") // also requires sdf icons
+          .add("icon-halo-blur", 5)
+          .add("icon-halo-color", "#ffff00")
+          .add("icon-halo-width", 6)
+          .add("icon-opacity", 0.5) // icon-opacity:0.5;
+          .add("icon-translate", Json.createArrayBuilder().add(11).add(12))
+          .add("icon-translate-anchor", "viewport") // also requires icon-translate
+          .add("text-color", "#fffff0") // text-color:#fffff0;
+          .add("text-halo-blur", 15)
+          .add("text-halo-color", "#ffffff") // text-halo-color:#ffffff;
+          .add("text-halo-width", 16) // text-halo-radius:16;
+          .add("text-opacity", 0.6) // text-opacity:0.6;
+          .add("text-translate", Json.createArrayBuilder().add(26).add(27))
+          .add("text-translate-anchor", "viewport")
+          .build();
+        JsonObject allLayoutProperties = Json.createObjectBuilder()
+          .add("icon-allow-overlap", true)
+          .add("icon-anchor", "left")
+          .add("icon-ignore-placement", true)
+          .add("icon-image", "random-image") // icon-image:concat(\"random-image\");
+          .add("icon-keep-upright", true) // also requires icon-rotation-alignment=map and symbol-placement=line|line-center
+          .add("icon-offset", Json.createArrayBuilder().add(2).add(3)) // icon-offset-x:2.0;icon-offset-y:3.0;
+          .add("icon-optional", true) // also requires text-field
+          .add("icon-padding", 4)
+          .add("icon-pitch-alignment", "viewport")
+          .add("icon-rotate", 30) // icon-rotation:30.0;
+          .add("icon-rotation-alignment", "map")
+          .add("icon-size", 2)
+          .add("icon-text-fit", "width") // also requires text-field
+          .add("icon-text-fit-padding", Json.createArrayBuilder().add(7).add(8).add(9).add(10))
+          .add("symbol-avoid-edges", true)
+          .add("symbol-placement", "line")
+          .add("symbol-sort-key", 13)
+          .add("symbol-spacing", 14) // requires symbol-placement=line
+          .add("symbol-z-order", "source")
+          .add("text-allow-overlap", true) // requires text-field
+          .add("text-anchor", "left") // requires text-field, disabled by text-variable-anchor
+          .add("text-field", "something") // text:something;
+          .add("text-font", Json.createArrayBuilder().add("SansSerif")) // DroidSans isn't always available in an IDE
+          .add("text-ignore-placement", true)
+          .add("text-justify", "left")
+          .add("text-keep-upright", false)
+          .add("text-letter-spacing", 17)
+          .add("text-line-height", 1.3)
+          .add("text-max-angle", 18)
+          .add("text-max-width", 19)
+          .add("text-offset", Json.createArrayBuilder().add(20).add(21))
+          .add("text-optional", true)
+          .add("text-padding", 22)
+          .add("text-pitch-alignment", "viewport")
+          .add("text-radial-offset", 23)
+          .add("text-rotate", 24)
+          .add("text-rotation-alignment", "viewport")
+          .add("text-size", 25) // font-size:25;
+          .add("text-transform", "uppercase")
+          .add("text-variable-anchor", "left")
+          .add("text-writing-mode", "vertical")
+          .add("visibility", "visible").build();
+
+        // Test fully defined symbol
+        Layers fullLineLayer = new Layers(Json.createObjectBuilder()
+          .add("type", Layers.Type.SYMBOL.name().toLowerCase(Locale.ROOT))
+          .add("id", "random-layer-id")
+          .add("source", "Random source")
+          .add("layout", allLayoutProperties)
+          .add("paint", allPaintProperties)
+          .build());
+        assertEquals("random-layer-id", fullLineLayer.getId());
+        assertEquals(Layers.Type.SYMBOL, fullLineLayer.getType());
+        assertEquals("node::random-layer-id{icon-image:concat(\"random-image\");icon-offset-x:2.0;icon-offset-y:3.0;"
+          + "icon-opacity:0.5;icon-rotation:30.0;text-color:#fffff0;text:something;font-family:\"SansSerif\";font-weight:normal;"
+          + "font-style:normal;text-halo-color:#ffffff;text-halo-radius:16;text-opacity:0.6;font-size:25;}", fullLineLayer.toString());
+
+        // Test an invisible symbol
+        Layers fullLineInvisibleLayer = new Layers(Json.createObjectBuilder()
+          .add("type", Layers.Type.SYMBOL.name().toLowerCase(Locale.ROOT))
+          .add("id", "random-layer-id")
+          .add("source", "Random source")
+          .add("layout", Json.createObjectBuilder(allLayoutProperties).add("visibility", "none"))
+          .add("paint", allPaintProperties)
+          .build());
+        assertEquals("random-layer-id", fullLineInvisibleLayer.getId());
+        assertEquals(Layers.Type.SYMBOL, fullLineInvisibleLayer.getType());
+        assertEquals("", fullLineInvisibleLayer.toString());
+
+        // Test with placeholders in icon-image
+        Layers fullOneIconImagePlaceholderLineLayer = new Layers(Json.createObjectBuilder()
+          .add("type", Layers.Type.SYMBOL.name().toLowerCase(Locale.ROOT))
+          .add("id", "random-layer-id")
+          .add("source", "Random source")
+          .add("layout", Json.createObjectBuilder(allLayoutProperties).add("icon-image", "{value}"))
+          .add("paint", allPaintProperties)
+          .build());
+        assertEquals("node::random-layer-id{icon-image:concat(tag(\"value\"));icon-offset-x:2.0;icon-offset-y:3.0;"
+          + "icon-opacity:0.5;icon-rotation:30.0;text-color:#fffff0;text:something;font-family:\"SansSerif\";font-weight:normal;"
+          + "font-style:normal;text-halo-color:#ffffff;text-halo-radius:16;text-opacity:0.6;font-size:25;}",
+          fullOneIconImagePlaceholderLineLayer.toString());
+
+        // Test with placeholders in icon-image
+        Layers fullOneIconImagePlaceholderExtraLineLayer = new Layers(Json.createObjectBuilder()
+          .add("type", Layers.Type.SYMBOL.name().toLowerCase(Locale.ROOT))
+          .add("id", "random-layer-id")
+          .add("source", "Random source")
+          .add("layout", Json.createObjectBuilder(allLayoutProperties).add("icon-image", "something/{value}/random"))
+          .add("paint", allPaintProperties)
+          .build());
+        assertEquals("node::random-layer-id{icon-image:concat(\"something/\",tag(\"value\"),\"/random\");icon-offset-x:2.0;"
+          + "icon-offset-y:3.0;icon-opacity:0.5;icon-rotation:30.0;text-color:#fffff0;text:something;font-family:\"SansSerif\";"
+          + "font-weight:normal;font-style:normal;text-halo-color:#ffffff;text-halo-radius:16;text-opacity:0.6;font-size:25;}",
+          fullOneIconImagePlaceholderExtraLineLayer.toString());
+
+        // Test with placeholders in icon-image
+        Layers fullTwoIconImagePlaceholderExtraLineLayer = new Layers(Json.createObjectBuilder()
+          .add("type", Layers.Type.SYMBOL.name().toLowerCase(Locale.ROOT))
+          .add("id", "random-layer-id")
+          .add("source", "Random source")
+          .add("layout", Json.createObjectBuilder(allLayoutProperties).add("icon-image", "something/{value}/random/{value2}"))
+          .add("paint", allPaintProperties)
+          .build());
+        assertEquals("node::random-layer-id{icon-image:concat(\"something/\",tag(\"value\"),\"/random/\",tag(\"value2\"));"
+          + "icon-offset-x:2.0;icon-offset-y:3.0;icon-opacity:0.5;icon-rotation:30.0;text-color:#fffff0;text:something;"
+          + "font-family:\"SansSerif\";font-weight:normal;font-style:normal;text-halo-color:#ffffff;text-halo-radius:16;"
+          + "text-opacity:0.6;font-size:25;}", fullTwoIconImagePlaceholderExtraLineLayer.toString());
+    }
+
+    @Test
+    void testRaster() {
+        // Test a layer without a source (should fail)
+        assertThrows(NullPointerException.class, () -> new Layers(Json.createObjectBuilder()
+          .add("type", Layers.Type.RASTER.name())
+          .add("id", "Empty Raster").build()));
+
+        JsonObject allPaintProperties = Json.createObjectBuilder()
+          .add("raster-brightness-max", 0.5)
+          .add("raster-brightness-min", 0.6)
+          .add("raster-contrast", 0.7)
+          .add("raster-fade-duration", 1)
+          .add("raster-hue-rotate", 2)
+          .add("raster-opacity", 0.7)
+          .add("raster-resampling", "nearest")
+          .add("raster-saturation", 0.8)
+          .build();
+        JsonObject allLayoutProperties = Json.createObjectBuilder().add("visibility", "visible").build();
+
+        // Test fully defined raster
+        Layers fullRaster = new Layers(Json.createObjectBuilder()
+          .add("id", "test-raster")
+          .add("type", Layers.Type.RASTER.name().toLowerCase(Locale.ROOT))
+          .add("source", "Random source")
+          .add("layout", allLayoutProperties)
+          .add("paint", allPaintProperties)
+          .build());
+        assertEquals(Layers.Type.RASTER, fullRaster.getType());
+        assertEquals("test-raster", fullRaster.getId());
+        assertEquals("Random source", fullRaster.getSource());
+        assertEquals("", fullRaster.toString());
+
+        // Test fully defined invisible raster
+        Layers fullInvisibleRaster = new Layers(Json.createObjectBuilder()
+          .add("id", "test-raster")
+          .add("type", Layers.Type.RASTER.name().toLowerCase(Locale.ROOT))
+          .add("source", "Random source")
+          .add("layout", Json.createObjectBuilder(allLayoutProperties).add("visibility", "none"))
+          .add("paint", allPaintProperties)
+          .build());
+        assertEquals("", fullInvisibleRaster.toString());
+    }
+
+    @Test
+    void testCircle() {
+        // Test a layer without a source (should fail)
+        assertThrows(NullPointerException.class, () -> new Layers(Json.createObjectBuilder()
+          .add("type", Layers.Type.CIRCLE.name())
+          .add("id", "Empty Circle").build()));
+
+        JsonObject allPaintProperties = Json.createObjectBuilder()
+          .add("circle-blur", 1)
+          .add("circle-color", "#fff000") // symbol-fill-color:#fff000;
+          .add("circle-opacity", 0.5) // symbol-fill-opacity:0.5;
+          .add("circle-pitch-alignment", "map")
+          .add("circle-pitch-scale", "viewport")
+          .add("circle-radius", 2) // symbol-size:4.0; (we use width)
+          .add("circle-stroke-color", "#ffff00") // symbol-stroke-color:#ffff00;
+          .add("circle-stroke-opacity", 0.6) // symbol-stroke-opacity:0.6;
+          .add("circle-stroke-width", 5) // symbol-stroke-width:5.0;
+          .add("circle-translate", Json.createArrayBuilder().add(3).add(4))
+          .add("circle-translate-anchor", "viewport")
+          .build();
+        JsonObject allLayoutProperties = Json.createObjectBuilder()
+          .add("circle-sort-key", 3)
+          .add("visibility", "visible")
+          .build();
+
+        Layers fullCircleLayer = new Layers(Json.createObjectBuilder()
+          .add("id", "Full circle layer")
+          .add("type", Layers.Type.CIRCLE.name().toLowerCase(Locale.ROOT))
+          .add("source", "Random source")
+          .add("layout", allLayoutProperties)
+          .add("paint", allPaintProperties)
+          .build());
+        assertEquals(Layers.Type.CIRCLE, fullCircleLayer.getType());
+        assertEquals("Full circle layer", fullCircleLayer.getId());
+        assertEquals("Random source", fullCircleLayer.getSource());
+        assertEquals("node::Full circle layer{symbol-shape:circle;symbol-fill-color:#fff000;symbol-fill-opacity:0.5;"
+          + "symbol-size:4.0;symbol-stroke-color:#ffff00;symbol-stroke-opacity:0.6;symbol-stroke-width:5;}", fullCircleLayer.toString());
+
+        Layers fullCircleInvisibleLayer = new Layers(Json.createObjectBuilder()
+          .add("id", "Full circle layer")
+          .add("type", Layers.Type.CIRCLE.name().toLowerCase(Locale.ROOT))
+          .add("source", "Random source")
+          .add("layout", Json.createObjectBuilder(allLayoutProperties).add("visibility", "none"))
+          .add("paint", allPaintProperties)
+          .build());
+        assertEquals(Layers.Type.CIRCLE, fullCircleInvisibleLayer.getType());
+        assertEquals("Full circle layer", fullCircleInvisibleLayer.getId());
+        assertEquals("Random source", fullCircleInvisibleLayer.getSource());
+        assertEquals("", fullCircleInvisibleLayer.toString());
+    }
+
+    @Test
+    void testFillExtrusion() {
+        // Test a layer without a source (should fail)
+        assertThrows(NullPointerException.class, () -> new Layers(Json.createObjectBuilder()
+          .add("type", Layers.Type.FILL_EXTRUSION.name())
+          .add("id", "Empty Fill Extrusion").build()));
+
+        JsonObject allPaintProperties = Json.createObjectBuilder()
+          .add("fill-extrusion-base", 1)
+          .add("fill-extrusion-color", "#fff000")
+          .add("fill-extrusion-height", 2)
+          .add("fill-extrusion-opacity", 0.5)
+          .add("fill-extrusion-pattern", "something-random")
+          .add("fill-extrusion-translate", Json.createArrayBuilder().add(3).add(4))
+          .add("fill-extrusion-translate-anchor", "viewport")
+          .add("fill-extrusion-vertical-gradient", false)
+          .build();
+        JsonObject allLayoutProperties = Json.createObjectBuilder().add("visibility", "visible").build();
+
+        Layers fullFillLayer = new Layers(Json.createObjectBuilder()
+          .add("id", "Fill Extrusion")
+          .add("type", Layers.Type.FILL_EXTRUSION.name().toLowerCase(Locale.ROOT))
+          .add("source", "Random source")
+          .add("layout", allLayoutProperties)
+          .add("paint", allPaintProperties)
+          .build());
+        assertEquals("", fullFillLayer.toString());
+        assertEquals(Layers.Type.FILL_EXTRUSION, fullFillLayer.getType());
+        Layers fullFillInvisibleLayer = new Layers(Json.createObjectBuilder()
+          .add("id", "Fill Extrusion")
+          .add("type", Layers.Type.FILL_EXTRUSION.name().toLowerCase(Locale.ROOT))
+          .add("source", "Random source")
+          .add("layout", Json.createObjectBuilder(allLayoutProperties).add("visibility", "none"))
+          .add("paint", allPaintProperties)
+          .build());
+        assertEquals("", fullFillInvisibleLayer.toString());
+        assertEquals(Layers.Type.FILL_EXTRUSION, fullFillInvisibleLayer.getType());
+    }
+
+    @Test
+    void testHeatmap() {
+        // Test a layer without a source (should fail)
+        assertThrows(NullPointerException.class, () -> new Layers(Json.createObjectBuilder()
+          .add("type", Layers.Type.HEATMAP.name())
+          .add("id", "Empty Heatmap").build()));
+
+        JsonObject allPaintProperties = Json.createObjectBuilder()
+          .add("heatmap-color", "#fff000") // This will probably be a gradient of some type
+          .add("heatmap-intensity", 0.5)
+          .add("heatmap-opacity", 0.6)
+          .add("heatmap-radius", 1) // This is in pixels
+          .add("heatmap-weight", 0.7)
+          .build();
+        JsonObject allLayoutProperties = Json.createObjectBuilder().add("visibility", "visible").build();
+
+        Layers fullHeatmapLayer = new Layers(Json.createObjectBuilder()
+          .add("id", "Full heatmap")
+          .add("type", Layers.Type.HEATMAP.name().toLowerCase(Locale.ROOT))
+          .add("source", "Random source")
+          .add("paint", allPaintProperties)
+          .add("layout", allLayoutProperties)
+          .build());
+        assertEquals(Layers.Type.HEATMAP, fullHeatmapLayer.getType());
+        assertEquals("", fullHeatmapLayer.toString());
+
+        Layers fullHeatmapInvisibleLayer = new Layers(Json.createObjectBuilder()
+          .add("id", "Full heatmap")
+          .add("type", Layers.Type.HEATMAP.name().toLowerCase(Locale.ROOT))
+          .add("source", "Random source")
+          .add("paint", allPaintProperties)
+          .add("layout", Json.createObjectBuilder(allLayoutProperties).add("visibility", "none"))
+          .build());
+        assertEquals(Layers.Type.HEATMAP, fullHeatmapInvisibleLayer.getType());
+        assertEquals("", fullHeatmapInvisibleLayer.toString());
+    }
+
+    @Test
+    void testHillshade() {
+        // Test a layer without a source (should fail)
+        assertThrows(NullPointerException.class, () -> new Layers(Json.createObjectBuilder()
+          .add("type", Layers.Type.HILLSHADE.name())
+          .add("id", "Empty Hillshade").build()));
+
+        JsonObject allPaintProperties = Json.createObjectBuilder()
+          .add("hillshade-accent-color", "#fff000")
+          .add("hillshade-exaggeration", 0.6)
+          .add("hillshade-highlight-color", "#ffff00")
+          .add("hillshade-illumination-anchor", "map")
+          .add("hillshade-illumination-direction", 90)
+          .add("hillshade-shadow-color", "#fffff0")
+          .build();
+        JsonObject allLayoutProperties = Json.createObjectBuilder()
+          .add("visibility", "visible")
+          .build();
+
+        Layers fullHillshadeLayer = new Layers(Json.createObjectBuilder()
+          .add("id", "Hillshade")
+          .add("type", Layers.Type.HILLSHADE.toString().toLowerCase(Locale.ROOT))
+          .add("source", "Random source")
+          .add("paint", allPaintProperties)
+          .add("layout", allLayoutProperties)
+          .build());
+        assertEquals(Layers.Type.HILLSHADE, fullHillshadeLayer.getType());
+        assertEquals("", fullHillshadeLayer.toString());
+
+        Layers fullHillshadeInvisibleLayer = new Layers(Json.createObjectBuilder()
+          .add("id", "Hillshade")
+          .add("type", Layers.Type.HILLSHADE.toString().toLowerCase(Locale.ROOT))
+          .add("source", "Random source")
+          .add("paint", allPaintProperties)
+          .add("layout", Json.createObjectBuilder(allLayoutProperties).add("visibility", "none"))
+          .build());
+        assertEquals(Layers.Type.HILLSHADE, fullHillshadeInvisibleLayer.getType());
+        assertEquals("", fullHillshadeInvisibleLayer.toString());
+    }
+
+    @Test
+    void testSky() {
+        // Test a layer without a source (should fail)
+        assertThrows(NullPointerException.class, () -> new Layers(Json.createObjectBuilder()
+          .add("type", Layers.Type.SKY.name())
+          .add("id", "Empty Sky").build()));
+
+        JsonObject allPaintProperties = Json.createObjectBuilder()
+          .add("sky-atmosphere-color", "red")
+          .add("sky-atmosphere-halo-color", "yellow")
+          // 360180 is apparently included in this? Or it might be a formatting issue in the docs.
+          .add("sky-atmosphere-sun", Json.createArrayBuilder().add(0, 360180))
+          .add("sky-atmosphere-sun-intensity", 99)
+          .add("sky-gradient", "#fff000")
+          .add("sky-gradient-center", Json.createArrayBuilder().add(0).add(360180)) // see note on 360180 above
+          .add("sky-gradient-radius", 1)
+          .add("sky-opacity", 0.5)
+          .add("sky-type", "gradient")
+          .build();
+        JsonObject allLayoutProperties = Json.createObjectBuilder().add("visibility", "visible").build();
+
+        Layers fullSkyLayer = new Layers(Json.createObjectBuilder()
+          .add("id", "Sky")
+          .add("type", Layers.Type.SKY.name().toLowerCase(Locale.ROOT))
+          .add("source", "Random source")
+          .add("paint", allPaintProperties)
+          .add("layout", allLayoutProperties)
+          .build());
+        assertEquals(Layers.Type.SKY, fullSkyLayer.getType());
+        assertEquals("", fullSkyLayer.toString());
+
+        Layers fullSkyInvisibleLayer = new Layers(Json.createObjectBuilder()
+          .add("id", "Sky")
+          .add("type", Layers.Type.SKY.name().toLowerCase(Locale.ROOT))
+          .add("source", "Random source")
+          .add("paint", allPaintProperties)
+          .add("layout", Json.createObjectBuilder(allLayoutProperties).add("visibility", "none"))
+          .build());
+        assertEquals(Layers.Type.SKY, fullSkyInvisibleLayer.getType());
+        assertEquals("", fullSkyInvisibleLayer.toString());
+    }
+
+    @Test
+    void testZoomLevels() {
+        JsonObject baseInformation = Json.createObjectBuilder()
+          .add("id", "dots")
+          .add("type", "CiRcLe")
+          .add("source", "osm-source")
+          .add("source-layer", "osm-images")
+          .add("paint", Json.createObjectBuilder()
+            .add("circle-color", "#fff000")
+            .add("circle-radius", 6)
+          ).build();
+        Layers noZoomLayer = new Layers(baseInformation);
+        String baseString = "node{0}::dots'{symbol-shape:circle;symbol-fill-color:#fff000;symbol-fill-opacity:1;"
+          + "symbol-size:12.0;symbol-stroke-color:#000000;symbol-stroke-opacity:1;symbol-stroke-width:0;}'";
+        assertEquals("osm-images", noZoomLayer.getSourceLayer());
+        assertEquals(MessageFormat.format(baseString, ""), noZoomLayer.toString());
+
+        Layers minZoomLayer = new Layers(Json.createObjectBuilder(baseInformation)
+          .add("minzoom", 0)
+          .build());
+        assertEquals(MessageFormat.format(baseString, "|z0-"), minZoomLayer.toString());
+
+        Layers maxZoomLayer = new Layers(Json.createObjectBuilder(baseInformation)
+          .add("maxzoom", 24)
+          .build());
+        assertEquals(MessageFormat.format(baseString, "|z-24"), maxZoomLayer.toString());
+
+        Layers minMaxZoomLayer = new Layers(Json.createObjectBuilder(baseInformation)
+          .add("minzoom", 1)
+          .add("maxzoom", 2)
+          .build());
+        assertEquals(MessageFormat.format(baseString, "|z1-2"), minMaxZoomLayer.toString());
+
+        Layers sameMinMaxZoomLayer = new Layers(Json.createObjectBuilder(baseInformation)
+          .add("minzoom", 2)
+          .add("maxzoom", 2)
+          .build());
+        assertEquals(MessageFormat.format(baseString, "|z2"), sameMinMaxZoomLayer.toString());
+    }
+
+    @Test
+    void testEquals() {
+        EqualsVerifier.forClass(Layers.class).usingGetClass().verify();
+    }
+}

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.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.image.BufferedImage;
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Paths;
+import java.text.MessageFormat;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.stream.Collectors;
+
+import javax.imageio.ImageIO;
+import javax.json.Json;
+import javax.json.JsonObject;
+import javax.json.JsonObjectBuilder;
+import javax.json.JsonReader;
+import javax.json.JsonStructure;
+import javax.json.JsonValue;
+
+import org.openstreetmap.josm.TestUtils;
+import org.openstreetmap.josm.gui.MainApplication;
+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.openstreetmap.josm.tools.ImageProvider;
+
+import nl.jqno.equalsverifier.EqualsVerifier;
+import org.awaitility.Awaitility;
+import org.awaitility.Durations;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+import org.junit.jupiter.api.io.TempDir;
+
+/**
+ * Test class for {@link MapBoxVectorStyle}
+ * @author Taylor Smock
+ */
+public class MapBoxVectorStyleTest {
+    /** Used to store sprite files (specifically, sprite{,@2x}.{png,json}) */
+    @TempDir
+    File spritesDirectory;
+
+    // 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();
+
+    /** The base information */
+    private static final String BASE_STYLE = "'{'\"version\":8,\"name\":\"test style\",\"owner\":\"josm test\",\"id\":\"{0}\",{1}'}'";
+    /** Source 1 */
+    private static final String SOURCE1 = "\"source1\":{\"type\":\"vector\",\"tiles\":[\"https://example.org/{z}/{x}/{y}.mvt\"]}";
+    /** Layer 1 */
+    private static final String LAYER1 = "{\"id\":\"layer1\",\"type\":\"circle\",\"source\":\"source1\",\"source-layer\":\"nodes\"}";
+    /** Source 2 */
+    private static final String SOURCE2 = "\"source2\":{\"type\":\"vector\",\"tiles\":[\"https://example.org/{z}2/{x}/{y}.mvt\"]}";
+    /** Layer 2 */
+    private static final String LAYER2 = "{\"id\":\"layer2\",\"type\":\"circle\",\"source\":\"source2\",\"source-layer\":\"nodes\"}";
+
+    /**
+     * Check that the version matches the supported style version(s). Currently, only version 8 exists and is (partially)
+     * supported.
+     */
+    @Test
+    void testVersionChecks() {
+        assertThrows(NullPointerException.class, () -> new MapBoxVectorStyle(JsonValue.EMPTY_JSON_OBJECT));
+        IllegalArgumentException badVersion = assertThrows(IllegalArgumentException.class,
+          () -> new MapBoxVectorStyle(Json.createObjectBuilder().add("version", 7).build()));
+        assertEquals("Vector Tile Style Version not understood: version 7 (json: {\"version\":7})", badVersion.getMessage());
+        badVersion = assertThrows(IllegalArgumentException.class,
+          () -> new MapBoxVectorStyle(Json.createObjectBuilder().add("version", 9).build()));
+        assertEquals("Vector Tile Style Version not understood: version 9 (json: {\"version\":9})", badVersion.getMessage());
+        assertDoesNotThrow(() -> new MapBoxVectorStyle(Json.createObjectBuilder().add("version", 8).build()));
+    }
+
+    @Test
+    void testSources() {
+        // Check with an invalid sources list
+        assertTrue(new MapBoxVectorStyle(getJson(JsonObject.class, "{\"version\":8,\"sources\":[\"s1\",\"s2\"]}")).getSources().isEmpty());
+        Map<Source, ElemStyles> sources = new MapBoxVectorStyle(getJson(JsonObject.class, MessageFormat.format(BASE_STYLE, "test",
+          MessageFormat.format("\"sources\":'{'{0},{1},\"source3\":[\"bad source\"]'}',\"layers\":[{2},{3},{4}]",
+            SOURCE1, SOURCE2, LAYER1, LAYER2, LAYER2.replace('2', '3'))))).getSources();
+        assertEquals(3, sources.size());
+        assertTrue(sources.containsKey(null)); // This is due to there being no source3 layer
+        sources.remove(null); // Avoid null checks later
+        assertTrue(sources.keySet().stream().map(Source::getName).anyMatch("source1"::equals));
+        assertTrue(sources.keySet().stream().map(Source::getName).anyMatch("source2"::equals));
+        assertTrue(sources.keySet().stream().map(Source::getName).noneMatch("source3"::equals));
+    }
+
+    @Test
+    void testSavedFiles() {
+        assertTrue(new MapBoxVectorStyle(getJson(JsonObject.class, "{\"version\":8,\"sources\":[\"s1\",\"s2\"]}")).getSources().isEmpty());
+        Map<Source, ElemStyles> sources = new MapBoxVectorStyle(getJson(JsonObject.class, MessageFormat.format(BASE_STYLE, "test",
+          MessageFormat.format("\"sources\":'{'{0},{1}'}',\"layers\":[{2},{3}]", SOURCE1, SOURCE2, LAYER1, LAYER2)))).getSources();
+        assertEquals(2, sources.size());
+        // For various reasons, the map _must_ be reliably ordered in the order of encounter
+        Source source1 = sources.keySet().iterator().next();
+        Source source2 = sources.keySet().stream().skip(1).findFirst().orElseGet(() -> fail("No second source"));
+        assertEquals("source1", source1.getName());
+        assertEquals("source2", source2.getName());
+
+        // Check that the files have been saved. Ideally, we would check that they haven't been
+        // saved earlier, since this is in a different thread. Unfortunately, that is a _race condition_.
+        MapCSSStyleSource styleSource1 = (MapCSSStyleSource) sources.get(source1).getStyleSources().get(0);
+        MapCSSStyleSource styleSource2 = (MapCSSStyleSource) sources.get(source2).getStyleSources().get(0);
+
+        AtomicBoolean saveFinished = new AtomicBoolean();
+        MainApplication.worker.execute(() -> saveFinished.set(true));
+        Awaitility.await().atMost(Durations.ONE_SECOND).until(saveFinished::get);
+
+        assertTrue(styleSource1.url.endsWith("source1.mapcss"));
+        assertTrue(styleSource2.url.endsWith("source2.mapcss"));
+
+        MapCSSStyleSource mapCSSStyleSource1 = new MapCSSStyleSource(styleSource1.url, styleSource1.name, styleSource1.title);
+        MapCSSStyleSource mapCSSStyleSource2 = new MapCSSStyleSource(styleSource2.url, styleSource2.name, styleSource2.title);
+
+        assertEquals(styleSource1, mapCSSStyleSource1);
+        assertEquals(styleSource2, mapCSSStyleSource2);
+    }
+
+    @Test
+    void testSprites() throws IOException {
+        generateSprites(false);
+        // Ensure that we fall back to 1x sprites
+        assertTrue(new File(this.spritesDirectory, "sprite.png").exists());
+        assertFalse(new File(this.spritesDirectory, "sprite@2x.png").exists());
+        assertTrue(new File(this.spritesDirectory, "sprite.json").exists());
+        assertFalse(new File(this.spritesDirectory, "sprite@2x.json").exists());
+
+        checkImages(false);
+
+        generateSprites(true);
+        checkImages(true);
+    }
+
+    private void checkImages(boolean hiDpi) {
+        // Ensure that we don't have images saved in the ImageProvider cache
+        ImageProvider.clearCache();
+        int hiDpiScalar = hiDpi ? 2 : 1;
+        String spritePath = new File(this.spritesDirectory, "sprite").getPath();
+        MapBoxVectorStyle style = new MapBoxVectorStyle(getJson(JsonObject.class,
+          MessageFormat.format(BASE_STYLE, "sprite_test", "\"sprite\":\"file:/" + spritePath + "\"")));
+        assertEquals("file:/" + spritePath, style.getSpriteUrl());
+
+        AtomicBoolean saveFinished = new AtomicBoolean();
+        MainApplication.worker.execute(() -> saveFinished.set(true));
+        Awaitility.await().atMost(Durations.ONE_SECOND).until(saveFinished::get);
+
+        int scalar = 28; // 255 / 9 (could be 4, but this was a nicer number)
+        for (int x = 0; x < 3; x++) {
+            for (int y = 0; y < 3; y++) {
+                // Expected color
+                Color color = new Color(scalar * x, scalar * y, scalar * x * y);
+                int finalX = x;
+                int finalY = y;
+                BufferedImage image = (BufferedImage) assertDoesNotThrow(
+                  () -> ImageProvider.get(new File("test style", MessageFormat.format("({0},{1})", finalX, finalY)).getPath()))
+                  .getImage();
+                assertEquals(3 * hiDpiScalar, image.getWidth(null));
+                assertEquals(3 * hiDpiScalar, image.getHeight(null));
+                for (int x2 = 0; x2 < image.getWidth(null); x2++) {
+                    for (int y2 = 0; y2 < image.getHeight(null); y2++) {
+                        assertEquals(color.getRGB(), image.getRGB(x2, y2));
+                    }
+                }
+            }
+        }
+    }
+
+    private void generateSprites(boolean hiDpi) throws IOException {
+        // Create a 3x3 grid of 3x3 or 6x6 pixel squares (depends upon the dpi setting)
+        int hiDpiScale = hiDpi ? 2 : 1;
+        BufferedImage nineByNine = new BufferedImage(hiDpiScale * 9, hiDpiScale * 9, BufferedImage.TYPE_4BYTE_ABGR);
+        int scalar = 28; // 255 / 9 (could be 4, but this was a nicer number)
+        Graphics2D g = nineByNine.createGraphics();
+        JsonObjectBuilder json = Json.createObjectBuilder();
+        for (int x = 0; x < 3; x++) {
+            for (int y = 0; y < 3; y++) {
+                Color color = new Color(scalar * x, scalar * y, scalar * x * y);
+                g.setColor(color);
+                g.drawRect(3 * hiDpiScale * x, 3 * hiDpiScale * y, 3 * hiDpiScale, 3 * hiDpiScale);
+                g.fillRect(3 * hiDpiScale * x, 3 * hiDpiScale * y, 3 * hiDpiScale, 3 * hiDpiScale);
+
+                JsonObjectBuilder sprite = Json.createObjectBuilder();
+                sprite.add("height", hiDpiScale * 3);
+                sprite.add("pixelRatio", hiDpiScale);
+                sprite.add("width", hiDpiScale * 3);
+                sprite.add("x", 3 * hiDpiScale * x);
+                sprite.add("y", 3 * hiDpiScale * y);
+
+                json.add(MessageFormat.format("({0},{1})", x, y), sprite);
+            }
+        }
+        String imageName = hiDpi ? "sprite@2x.png" : "sprite.png";
+        ImageIO.write(nineByNine, "png", new File(this.spritesDirectory, imageName));
+        String jsonName = hiDpi ? "sprite@2x.json" : "sprite.json";
+        File jsonFile = new File(this.spritesDirectory, jsonName);
+        try (FileOutputStream fileOutputStream = new FileOutputStream(jsonFile)) {
+            fileOutputStream.write(json.build().toString().getBytes(StandardCharsets.UTF_8));
+        }
+    }
+
+    private static <T extends JsonStructure> T getJson(Class<T> clazz, String json) {
+        try (JsonReader reader = Json.createReader(new ByteArrayInputStream(json.getBytes(StandardCharsets.UTF_8)))) {
+            JsonStructure structure = reader.read();
+            if (clazz.isAssignableFrom(structure.getClass())) {
+                return clazz.cast(structure);
+            }
+        }
+        fail("Could not cast to expected class");
+        throw new IllegalArgumentException();
+    }
+
+    @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);
+        // Docs indicate that symbol-size is total width, while we are translating from a radius. So 2 * 4 = 8.
+        assertInInstructions(mapillaryOverview.declaration.instructions, "symbol-size", 8.0f);
+    }
+
+    @Test
+    void testEqualsContract() {
+        // We need to "load" the style sources to avoid the verifier from thinking they are equal
+        StyleSource canvas = new MapCSSStyleSource("meta{title:\"canvas\";}canvas{default-points:false;}");
+        StyleSource node = new MapCSSStyleSource("meta{title:\"node\";}node{text:ref;}");
+        node.loadStyleSource();
+        canvas.loadStyleSource();
+        EqualsVerifier.forClass(MapBoxVectorStyle.class)
+          .withPrefabValues(ImageProvider.class, new ImageProvider("cancel"), new ImageProvider("ok"))
+          .withPrefabValues(StyleSource.class, canvas, node)
+          .usingGetClass().verify();
+    }
+
+    /**
+     * 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) {
+        // We need to do a new arraylist just to avoid the occasional ConcurrentModificationException
+        return new ArrayList<>(source.rules).stream().filter(rule -> rule.selectors.stream()
+          .anyMatch(selector -> base.equals(selector.getBase()) && subpart.equals(selector.getSubpart().getId(null))))
+          .findAny().orElse(null);
+    }
+}

new file test/unit/org/openstreetmap/josm/data/imagery/vectortile/mapbox/style/SourceTest.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.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+
+import java.util.Locale;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import javax.json.Json;
+import javax.json.JsonObject;
+import javax.json.JsonValue;
+
+import org.openstreetmap.josm.data.Bounds;
+
+import nl.jqno.equalsverifier.EqualsVerifier;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Test class for {@link Source}
+ * @author Taylor Smock
+ * @since xxx
+ */
+public class SourceTest {
+    @Test
+    void testEquals() {
+        EqualsVerifier.forClass(Source.class).usingGetClass().verify();
+    }
+
+    @Test
+    void testSimpleSources() {
+        final JsonObject emptyObject = Json.createObjectBuilder().build();
+        assertThrows(NullPointerException.class, () -> new Source("Test source", emptyObject));
+
+        final JsonObject badTypeValue = Json.createObjectBuilder().add("type", "bad type value").build();
+        assertThrows(IllegalArgumentException.class, () -> new Source("Test source", badTypeValue));
+
+        // Only SourceType.{VECTOR,RASTER} are supported
+        final SourceType[] supported = new SourceType[] {SourceType.VECTOR, SourceType.RASTER};
+        for (SourceType type : supported) {
+            final JsonObject goodSourceType = Json.createObjectBuilder().add("type", type.toString().toLowerCase(Locale.ROOT)).build();
+            Source source = assertDoesNotThrow(() -> new Source(type.name(), goodSourceType));
+            // Check defaults
+            assertEquals(0, source.getMinZoom());
+            assertEquals(22, source.getMaxZoom());
+            assertEquals(type.name(), source.getName());
+            assertNull(source.getAttributionText());
+            assertTrue(source.getUrls().isEmpty());
+            assertEquals(new Bounds(-85.051129, -180, 85.051129, 180), source.getBounds());
+        }
+
+        // Check that unsupported types throw
+        for (SourceType type : Stream.of(SourceType.values()).filter(t -> Stream.of(supported).noneMatch(t::equals)).collect(
+          Collectors.toList())) {
+            final JsonObject goodSourceType = Json.createObjectBuilder().add("type", type.toString().toLowerCase(Locale.ROOT)).build();
+            assertThrows(UnsupportedOperationException.class, () -> new Source(type.name(), goodSourceType));
+        }
+    }
+
+    @Test
+    void testTileJsonSpec() {
+        // This isn't currently implemented, so it should throw. Mostly here to remind implementor to add tests...
+        final JsonObject tileJsonSpec = Json.createObjectBuilder()
+          .add("type", SourceType.VECTOR.name()).add("url", "some-random-url.com")
+          .build();
+        assertThrows(UnsupportedOperationException.class, () -> new Source("Test TileJson", tileJsonSpec));
+    }
+
+    @Test
+    void testBounds() {
+        // Check a "good" bounds
+        final JsonObject tileJsonSpec = Json.createObjectBuilder().add("type", SourceType.VECTOR.name()).add("bounds",
+          Json.createArrayBuilder().add(-1).add(-2).add(3).add(4)).build();
+        Source source = new Source("Test Bounds[-1, -2, 3, 4]", tileJsonSpec);
+        assertEquals(new Bounds(-2, -1, 4, 3), source.getBounds());
+
+        // Check "bad" bounds
+        final JsonObject tileJsonSpecShort = Json.createObjectBuilder().add("type", SourceType.VECTOR.name()).add("bounds",
+          Json.createArrayBuilder().add(-1).add(-2).add(3)).build();
+        IllegalArgumentException badLengthException = assertThrows(IllegalArgumentException.class,
+          () -> new Source("Test Bounds[-1, -2, 3]", tileJsonSpecShort));
+        assertEquals("bounds must have four values, but has 3", badLengthException.getMessage());
+
+        final JsonObject tileJsonSpecLong = Json.createObjectBuilder().add("type", SourceType.VECTOR.name()).add("bounds",
+          Json.createArrayBuilder().add(-1).add(-2).add(3).add(4).add(5)).build();
+        badLengthException = assertThrows(IllegalArgumentException.class, () -> new Source("Test Bounds[-1, -2, 3, 4, 5]", tileJsonSpecLong));
+        assertEquals("bounds must have four values, but has 5", badLengthException.getMessage());
+    }
+
+    @Test
+    void testTiles() {
+        // No url
+        final JsonObject tileJsonSpecEmpty = Json.createObjectBuilder().add("type", SourceType.VECTOR.name()).add("tiles",
+          JsonValue.NULL).build();
+        Source source = new Source("Test Tile[]", tileJsonSpecEmpty);
+        assertTrue(source.getUrls().isEmpty());
+
+        // Create a tile URL
+        final JsonObject tileJsonSpec = Json.createObjectBuilder().add("type", SourceType.VECTOR.name()).add("tiles",
+          Json.createArrayBuilder().add("https://example.org/{bbox-epsg-3857}")).build();
+        source = new Source("Test Tile[https://example.org/{bbox-epsg-3857}]", tileJsonSpec);
+        assertEquals(1, source.getUrls().size());
+        // Make certain that {bbox-epsg-3857} is replaced with the JOSM equivalent
+        assertEquals("https://example.org/{bbox}", source.getUrls().get(0));
+
+        // Check with invalid data
+        final JsonObject tileJsonSpecBad = Json.createObjectBuilder().add("type", SourceType.VECTOR.name()).add("tiles",
+          Json.createArrayBuilder().add(1).add("https://example.org/{bbox-epsg-3857}").add(false).add(Json.createArrayBuilder().add("hello"))
+            .add(Json.createObjectBuilder().add("bad", "array"))).build();
+        source = new Source("Test Tile[1, https://example.org/{bbox-epsg-3857}, false, [\"hello\"], {\"bad\": \"array\"}]", tileJsonSpecBad);
+        assertEquals(1, source.getUrls().size());
+        // Make certain that {bbox-epsg-3857} is replaced with the JOSM equivalent
+        assertEquals("https://example.org/{bbox}", source.getUrls().get(0));
+    }
+
+    @Test
+    void testZoom() {
+        // Min zoom
+        final JsonObject minZoom5 = Json.createObjectBuilder().add("type", SourceType.VECTOR.name()).add("minzoom",
+          5).build();
+        Source source = new Source("Test Zoom[minzoom=5]", minZoom5);
+        assertEquals(5, source.getMinZoom());
+        assertEquals(22, source.getMaxZoom());
+
+        // Negative min zoom
+        final JsonObject minZoomNeg1 = Json.createObjectBuilder().add("type", SourceType.VECTOR.name()).add("minzoom",
+          -1).build();
+        source = new Source("Test Zoom[minzoom=-1]", minZoomNeg1);
+        assertEquals(0, source.getMinZoom());
+        assertEquals(22, source.getMaxZoom());
+
+        // Max zoom
+        final JsonObject maxZoom5 = Json.createObjectBuilder().add("type", SourceType.VECTOR.name()).add("maxzoom",
+          5).build();
+        source = new Source("Test Zoom[maxzoom=5]", maxZoom5);
+        assertEquals(0, source.getMinZoom());
+        assertEquals(5, source.getMaxZoom());
+
+        // Big Max zoom
+        final JsonObject maxZoom31 = Json.createObjectBuilder().add("type", SourceType.VECTOR.name()).add("maxzoom",
+          31).build();
+        source = new Source("Test Zoom[maxzoom=31]", maxZoom31);
+        assertEquals(0, source.getMinZoom());
+        assertEquals(30, source.getMaxZoom());
+
+        // Negative max zoom
+        final JsonObject maxZoomNeg5 = Json.createObjectBuilder().add("type", SourceType.VECTOR.name()).add("maxzoom",
+          -5).build();
+        source = new Source("Test Zoom[maxzoom=-5]", maxZoomNeg5);
+        assertEquals(0, source.getMinZoom());
+        assertEquals(0, source.getMaxZoom());
+
+        // Min max zoom
+        final JsonObject minZoom1MaxZoom5 = Json.createObjectBuilder().add("type", SourceType.VECTOR.name()).add("maxzoom",
+          5).add("minzoom", 1).build();
+        source = new Source("Test Zoom[minzoom=1,maxzoom=5]", minZoom1MaxZoom5);
+        assertEquals(1, source.getMinZoom());
+        assertEquals(5, source.getMaxZoom());
+    }
+
+    @Test
+    void testToString() {
+        // Simple (no urls)
+        final JsonObject noTileJsonSpec = Json.createObjectBuilder().add("type", SourceType.VECTOR.name()).build();
+        Source source = new Source("Test String[]", noTileJsonSpec);
+        assertEquals("Test String[]", source.toString());
+
+        // With one url
+        final JsonObject tileJsonSpec = Json.createObjectBuilder().add("type", SourceType.VECTOR.name()).add("tiles",
+          Json.createArrayBuilder().add("https://example.org/{bbox-epsg-3857}")).build();
+        source = new Source("Test String[https://example.org/{bbox-epsg-3857}]", tileJsonSpec);
+        assertEquals("Test String[https://example.org/{bbox-epsg-3857}] https://example.org/{bbox}", source.toString());
+
+        // With two URLs
+        final JsonObject tileJsonSpecMultiple = Json.createObjectBuilder().add("type", SourceType.VECTOR.name())
+          .add("tiles", Json.createArrayBuilder()
+            .add("https://example.org/{bbox-epsg-3857}")
+            .add("https://example.com/{bbox-epsg-3857}")).build();
+        source = new Source("Test String[https://example.org/{bbox-epsg-3857},https://example.com/{bbox-epsg-3857}]", tileJsonSpecMultiple);
+        assertEquals("Test String[https://example.org/{bbox-epsg-3857},https://example.com/{bbox-epsg-3857}] https://example.org/{bbox} "
+          + "https://example.com/{bbox}", source.toString());
+    }
+}

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

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.protobuf;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+
+/**
+ * Test class for {@link ProtoBufParser}
+ * @author Taylor Smock
+ * @since xxx
+ */
+class ProtoBufParserTest {
+    /**
+     * Check that we are appropriately converting values to the "smallest" type
+     */
+    @Test
+    void testConvertLong() {
+        // No casting due to auto conversions
+        assertEquals(Byte.MAX_VALUE, ProtoBufParser.convertLong(Byte.MAX_VALUE));
+        assertEquals(Byte.MIN_VALUE, ProtoBufParser.convertLong(Byte.MIN_VALUE));
+        assertEquals(Short.MIN_VALUE, ProtoBufParser.convertLong(Short.MIN_VALUE));
+        assertEquals(Short.MAX_VALUE, ProtoBufParser.convertLong(Short.MAX_VALUE));
+        assertEquals(Integer.MAX_VALUE, ProtoBufParser.convertLong(Integer.MAX_VALUE));
+        assertEquals(Integer.MIN_VALUE, ProtoBufParser.convertLong(Integer.MIN_VALUE));
+        assertEquals(Long.MIN_VALUE, ProtoBufParser.convertLong(Long.MIN_VALUE));
+        assertEquals(Long.MAX_VALUE, ProtoBufParser.convertLong(Long.MAX_VALUE));
+    }
+
+    /**
+     * Check that zig zags are appropriately encoded.
+     */
+    @Test
+    void testEncodeZigZag() {
+        assertEquals(0, ProtoBufParser.encodeZigZag(0).byteValue());
+        assertEquals(1, ProtoBufParser.encodeZigZag(-1).byteValue());
+        assertEquals(2, ProtoBufParser.encodeZigZag(1).byteValue());
+        assertEquals(3, ProtoBufParser.encodeZigZag(-2).byteValue());
+        assertEquals(254, ProtoBufParser.encodeZigZag(Byte.MAX_VALUE).shortValue());
+        assertEquals(255, ProtoBufParser.encodeZigZag(Byte.MIN_VALUE).shortValue());
+        assertEquals(65_534, ProtoBufParser.encodeZigZag(Short.MAX_VALUE).intValue());
+        assertEquals(65_535, ProtoBufParser.encodeZigZag(Short.MIN_VALUE).intValue());
+        // These integers check a possible boundary condition (the boundary between using the 32/64 bit encoding methods)
+        assertEquals(4_294_967_292L, ProtoBufParser.encodeZigZag(Integer.MAX_VALUE - 1).longValue());
+        assertEquals(4_294_967_293L, ProtoBufParser.encodeZigZag(Integer.MIN_VALUE + 1).longValue());
+        assertEquals(4_294_967_294L, ProtoBufParser.encodeZigZag(Integer.MAX_VALUE).longValue());
+        assertEquals(4_294_967_295L, ProtoBufParser.encodeZigZag(Integer.MIN_VALUE).longValue());
+        assertEquals(4_294_967_296L, ProtoBufParser.encodeZigZag(Integer.MAX_VALUE + 1L).longValue());
+        assertEquals(4_294_967_297L, ProtoBufParser.encodeZigZag(Integer.MIN_VALUE - 1L).longValue());
+    }
+}

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

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.protobuf;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+
+import java.io.IOException;
+
+import org.junit.jupiter.api.Test;
+
+/**
+ * Test class for specific {@link ProtoBufRecord} functionality
+ */
+class ProtoBufRecordTest {
+    @Test
+    void testFixed32() throws IOException {
+        ProtoBufParser parser = new ProtoBufParser(ProtoBufTest.toByteArray(new int[] {0x0d, 0x00, 0x00, 0x80, 0x3f}));
+        ProtoBufRecord thirtyTwoBit = new ProtoBufRecord(parser);
+        assertEquals(WireType.THIRTY_TWO_BIT, thirtyTwoBit.getType());
+        assertEquals(1f, thirtyTwoBit.asFloat());
+    }
+
+    @Test
+    void testUnknown() throws IOException {
+        ProtoBufParser parser = new ProtoBufParser(ProtoBufTest.toByteArray(new int[] {0x0f, 0x00, 0x00, 0x80, 0x3f}));
+        ProtoBufRecord unknown = new ProtoBufRecord(parser);
+        assertEquals(WireType.UNKNOWN, unknown.getType());
+        assertEquals(0, unknown.getBytes().length);
+    }
+}

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.geom.Ellipse2D;
+import java.io.ByteArrayInputStream;
+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.ImageryInfo;
+import org.openstreetmap.josm.data.imagery.vectortile.mapbox.Feature;
+import org.openstreetmap.josm.data.imagery.vectortile.mapbox.Layer;
+import org.openstreetmap.josm.data.imagery.vectortile.mapbox.MVTTile;
+import org.openstreetmap.josm.data.imagery.vectortile.mapbox.MapboxVectorTileSource;
+import org.openstreetmap.josm.data.osm.BBox;
+import org.openstreetmap.josm.data.osm.Node;
+import org.openstreetmap.josm.data.osm.Way;
+import org.openstreetmap.josm.data.vector.VectorDataSet;
+import org.openstreetmap.josm.data.vector.VectorNode;
+import org.openstreetmap.josm.data.vector.VectorWay;
+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 {
+    /**
+     * Convert an int array into a byte array
+     * @param intArray The int array to convert (NOTE: numbers must be below 255)
+     * @return A byte array that can be used
+     */
+    static byte[] toByteArray(int[] intArray) {
+        byte[] byteArray = new byte[intArray.length];
+        for (int i = 0; i < intArray.length; i++) {
+            if (intArray[i] > Byte.MAX_VALUE - Byte.MIN_VALUE) {
+                throw new IllegalArgumentException();
+            }
+            byteArray[i] = Integer.valueOf(intArray[i]).byteValue();
+        }
+        return byteArray;
+    }
+
+    @RegisterExtension
+    JOSMTestRules josmTestRules = new JOSMTestRules().preferences();
+
+    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);
+    }
+
+    /**
+     * Test reading tile from Mapillary ( 14/3248/6258 )
+     *
+     * @throws IOException if there is a problem reading the file
+     */
+    @Test
+    void testRead_14_3248_6258() throws IOException {
+        File vectorTile = Paths.get(TestUtils.getTestDataRoot(), "pbf", "mapillary", "14", "3248", "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() == 233760500).count());
+        Feature testSequence = mapillarySequences.getFeatures().stream().filter(feature -> feature.getId() == 233760500)
+                .findAny().orElse(null);
+        assertEquals("dpudn262yz6aitu33zh7bl", testSequence.getTags().get("key"));
+        assertEquals("clnaw3kpokIAe_CsN5Qmiw", testSequence.getTags().get("ikey"));
+        assertEquals("B1iNjH4Ohn25cRAGPhetfw", testSequence.getTags().get("userkey"));
+        assertEquals(Long.valueOf(1557535457401L), Long.valueOf(testSequence.getTags().get("captured_at")));
+        assertEquals(0, Integer.parseInt(testSequence.getTags().get("pano")));
+    }
+
+    @Test
+    void testRead_17_26028_50060() throws IOException {
+        File vectorTile = Paths.get(TestUtils.getTestDataRoot(), "pbf", "openinframap", "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
+        VectorDataSet vectorDataSet = new VectorDataSet();
+        MVTTile vectorTile1 = new MVTTile(new MapboxVectorTileSource(new ImageryInfo("Test info", "example.org")),
+                26028, 50060, 17);
+        vectorTile1.loadImage(Compression.getUncompressedFileInputStream(vectorTile));
+        vectorDataSet.addTileData(vectorTile1);
+        vectorDataSet.setZoom(17);
+        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.00001);
+        final Collection<VectorNode> searchedNodes = vectorDataSet.searchNodes(searchBBox);
+        final Collection<VectorWay> searchedWays = vectorDataSet.searchWays(searchBBox);
+        assertEquals(4, searchedNodes.size());
+    }
+
+    @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 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
+    void testSingletonMultiPoint() throws IOException {
+        Collection<ProtoBufRecord> records = new ProtoBufParser(new ByteArrayInputStream(toByteArray(
+                new int[] {0x1a, 0x2c, 0x78, 0x02, 0x0a, 0x03, 0x74, 0x6d, 0x70, 0x28, 0x80, 0x20, 0x1a, 0x04, 0x6e,
+                        0x61, 0x6d, 0x65, 0x22, 0x0b, 0x0a, 0x09, 0x54, 0x65, 0x73, 0x74, 0x20, 0x6e, 0x61, 0x6d, 0x65,
+                        0x12, 0x0d, 0x18, 0x01, 0x12, 0x02, 0x00, 0x00, 0x22, 0x05, 0x09, 0xe0, 0x3e, 0x84, 0x27})))
+                                .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(4016, shape.getCenterX());
+        assertEquals(2498, shape.getCenterY());
+    }
+
+    @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());
+    }
+}

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);
+
+        // There _does_ appear to be some kind of race condition though
+        Awaitility.await().atMost(Durations.FIVE_SECONDS).until(() -> dataSet.getNodes().size() > 50);
+        // 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.
+        // One of the end nodes is a duplicate of an actual node.
+        assertEquals(56, 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, 3249, 6258);
+
+        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)));
+    }
+}

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

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.vector;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+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.IRelation;
+import org.openstreetmap.josm.data.osm.IWay;
+import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
+import org.openstreetmap.josm.data.osm.visitor.PrimitiveVisitor;
+import org.openstreetmap.josm.data.projection.ProjectionRegistry;
+import org.openstreetmap.josm.testutils.JOSMTestRules;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+/**
+ * Test class for {@link VectorNode}
+ * @author Taylor Smock
+ * @since xxx
+ */
+class VectorNodeTest {
+    @RegisterExtension
+    JOSMTestRules rule = new JOSMTestRules().projection();
+
+    @Test
+    void testLatLon() {
+        VectorNode node = new VectorNode("test");
+        assertTrue(Double.isNaN(node.lat()));
+        assertTrue(Double.isNaN(node.lon()));
+        LatLon testLatLon = new LatLon(50, -40);
+        node.setCoor(testLatLon);
+        assertEquals(50, node.lat());
+        assertEquals(-40, node.lon());
+        assertEquals(testLatLon, node.getCoor());
+    }
+
+    @Test
+    void testSetEastNorth() {
+        VectorNode node = new VectorNode("test");
+        LatLon latLon = new LatLon(-1, 5);
+        EastNorth eastNorth = ProjectionRegistry.getProjection().latlon2eastNorth(latLon);
+        node.setEastNorth(eastNorth);
+        assertEquals(-1, node.lat(), 0.0000000001);
+        assertEquals(5, node.lon(), 0.0000000001);
+    }
+
+    @Test
+    void testICoordinate() {
+        VectorNode node = new VectorNode("test");
+        assertTrue(Double.isNaN(node.lat()));
+        assertTrue(Double.isNaN(node.lon()));
+        ICoordinate coord = new ICoordinate() {
+            @Override
+            public double getLat() {
+                return 5;
+            }
+
+            @Override
+            public void setLat(double lat) {
+                // No op
+            }
+
+            @Override
+            public double getLon() {
+                return -1;
+            }
+
+            @Override
+            public void setLon(double lon) {
+                // no op
+            }
+        };
+        node.setCoor(coord);
+        assertEquals(5, node.lat());
+        assertEquals(-1, node.lon());
+    }
+
+    @Test
+    void testUniqueIdGenerator() {
+        VectorNode node1 = new VectorNode("test");
+        VectorNode node2 = new VectorNode("test2");
+        assertSame(node1.getIdGenerator(), node2.getIdGenerator());
+        assertNotNull(node1.getIdGenerator());
+    }
+
+    @Test
+    void testNode() {
+        assertEquals(OsmPrimitiveType.NODE, new VectorNode("test").getType());
+    }
+
+    @Test
+    void testBBox() {
+        VectorNode node = new VectorNode("test");
+        node.setCoor(new LatLon(5, -1));
+        assertTrue(node.getBBox().bboxIsFunctionallyEqual(new BBox(-1, 5), 0d));
+    }
+
+    @Test
+    void testVisitor() {
+        List<VectorNode> visited = new ArrayList<>();
+        VectorNode node = new VectorNode("test");
+        node.accept(new PrimitiveVisitor() {
+            @Override
+            public void visit(INode n) {
+                visited.add((VectorNode) n);
+            }
+
+            @Override
+            public void visit(IWay<?> w) {
+                fail("Way should not have been visited");
+            }
+
+            @Override
+            public void visit(IRelation<?> r) {
+                fail("Relation should not have been visited");
+            }
+        });
+
+        assertEquals(1, visited.size());
+        assertSame(node, visited.get(0));
+    }
+
+    @Test
+    void testIsReferredToByWays() {
+        VectorWay way = new VectorWay("test");
+        VectorNode node = new VectorNode("test");
+        assertFalse(node.isReferredByWays(1));
+        assertTrue(node.getReferrers(true).isEmpty());
+        way.setNodes(Collections.singletonList(node));
+        assertEquals(1, node.getReferrers(true).size());
+        assertSame(way, node.getReferrers(true).get(0));
+        // No dataset yet
+        assertFalse(node.isReferredByWays(1));
+        VectorDataSet dataSet = new VectorDataSet();
+        dataSet.addPrimitive(way);
+        dataSet.addPrimitive(node);
+        assertTrue(node.isReferredByWays(1));
+        assertFalse(node.isReferredByWays(2));
+    }
+}

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

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.vector;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+import org.openstreetmap.josm.testutils.JOSMTestRules;
+
+import java.util.Arrays;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Test class for {@link VectorRelation}
+ * @author Taylor Smock
+ * @since xxx
+ */
+class VectorRelationTest {
+    @RegisterExtension
+    JOSMTestRules rule = new JOSMTestRules();
+
+    @Test
+    void testMembers() {
+        VectorNode node1 = new VectorNode("test");
+        VectorNode node2 = new VectorNode("test");
+        VectorWay way1 = new VectorWay("test");
+        way1.setNodes(Arrays.asList(node1, node2));
+        VectorRelationMember member1 = new VectorRelationMember("randomRole", node1);
+        VectorRelationMember member2 = new VectorRelationMember("role2", way1);
+        assertSame(node1, member1.getMember());
+        assertSame(node1.getType(), member1.getType());
+        assertEquals("randomRole", member1.getRole());
+        assertSame(node1.getId(), member1.getUniqueId());
+        // Not a way.
+        assertThrows(ClassCastException.class, member1::getWay);
+
+        assertTrue(member1.isNode());
+        assertFalse(member1.isWay());
+        assertFalse(member2.isNode());
+        assertTrue(member2.isWay());
+    }
+}

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

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.vector;
+
+import org.junit.jupiter.api.Test;
+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.IRelation;
+import org.openstreetmap.josm.data.osm.IWay;
+import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
+import org.openstreetmap.josm.data.osm.visitor.PrimitiveVisitor;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
+
+/**
+ * Test class for {@link VectorWay}
+ * @author Taylor Smock
+ * @since xxx
+ */
+class VectorWayTest {
+    @Test
+    void testBBox() {
+        VectorNode node1 = new VectorNode("test");
+        VectorWay way = new VectorWay("test");
+        way.setNodes(Collections.singletonList(node1));
+        node1.setCoor(new LatLon(-5, 1));
+        assertTrue(node1.getBBox().bboxIsFunctionallyEqual(way.getBBox(), 0.0));
+
+        VectorNode node2 = new VectorNode("test");
+        node2.setCoor(new LatLon(-10, 2));
+
+        way.setNodes(Arrays.asList(node1, node2));
+        assertTrue(way.getBBox().bboxIsFunctionallyEqual(new BBox(2, -10, 1, -5), 0.0));
+    }
+
+    @Test
+    void testIdGenerator() {
+        assertSame(new VectorWay("test").getIdGenerator(), new VectorWay("test").getIdGenerator());
+    }
+
+    @Test
+    void testNodes() {
+        VectorNode node1 = new VectorNode("test");
+        VectorNode node2 = new VectorNode("test");
+        VectorNode node3 = new VectorNode("test");
+        node1.setId(1);
+        node2.setId(2);
+        node3.setId(3);
+        VectorWay way = new VectorWay("test");
+        assertNull(way.firstNode());
+        assertNull(way.lastNode());
+        assertFalse(way.isClosed());
+        assertFalse(way.isFirstLastNode(node1));
+        assertFalse(way.isInnerNode(node2));
+        way.setNodes(Arrays.asList(node1, node2, node3));
+        assertEquals(3, way.getNodesCount());
+        assertEquals(node1, way.getNode(0));
+        assertEquals(node2, way.getNode(1));
+        assertEquals(node3, way.getNode(2));
+        assertTrue(way.isFirstLastNode(node1));
+        assertTrue(way.isFirstLastNode(node3));
+        assertFalse(way.isFirstLastNode(node2));
+        assertTrue(way.isInnerNode(node2));
+        assertFalse(way.isInnerNode(node1));
+        assertFalse(way.isInnerNode(node3));
+
+        assertEquals(1, way.getNodeIds().get(0));
+        assertEquals(2, way.getNodeIds().get(1));
+        assertEquals(3, way.getNodeIds().get(2));
+        assertEquals(1, way.getNodeId(0));
+        assertEquals(2, way.getNodeId(1));
+        assertEquals(3, way.getNodeId(2));
+
+        assertFalse(way.isClosed());
+        assertEquals(OsmPrimitiveType.WAY, way.getType());
+        List<VectorNode> nodes = new ArrayList<>(way.getNodes());
+        nodes.add(nodes.get(0));
+        way.setNodes(nodes);
+        assertTrue(way.isClosed());
+        assertEquals(OsmPrimitiveType.CLOSEDWAY, way.getType());
+    }
+
+    @Test
+    void testAccept() {
+        VectorWay way = new VectorWay("test");
+        List<VectorWay> visited = new ArrayList<>(1);
+        way.accept(new PrimitiveVisitor() {
+            @Override
+            public void visit(INode n) {
+                fail("No nodes should be visited");
+            }
+
+            @Override
+            public void visit(IWay<?> w) {
+                visited.add((VectorWay) w);
+            }
+
+            @Override
+            public void visit(IRelation<?> r) {
+                fail("No relations should be visited");
+            }
+        });
+
+        assertEquals(1, visited.size());
+        assertSame(way, visited.get(0));
+    }
+}