[WIP] replace mbgl::variant with std::variant

expression-test/expression_test_parser.cpp

@@ -6,7 +6,6 @@
 
 #include <mbgl/util/io.hpp>
 #include <mbgl/util/logging.hpp>
-#include <mbgl/util/variant.hpp>
 #include <mbgl/style/conversion/function.hpp>
 #include <mbgl/style/rapidjson_conversion.hpp>
 #include <mbgl/style/expression/parsing_context.hpp>
@@ -19,6 +18,7 @@
 #include <args.hxx>
 
 #include <regex>
+#include <variant>
 
 using namespace mbgl;
 using namespace mbgl::style;
@@ -52,7 +52,7 @@ void writeJSON(rapidjson::PrettyWriter<rapidjson::StringBuffer>& writer, const V
 }
 
 using ErrorMessage = std::string;
-using JSONReply = variant<JSDocument, ErrorMessage>;
+using JSONReply = std::variant<JSDocument, ErrorMessage>;
 JSONReply readJson(const filesystem::path& jsonPath) {
     auto maybeJSON = util::readFile(jsonPath);
     if (!maybeJSON) {
@@ -384,11 +384,11 @@ Ignores parseExpressionIgnores() {
     Ignores ignores;
     const auto mainIgnoresPath = filesystem::path(TEST_RUNNER_ROOT_PATH).append("metrics/ignores/platform-all.json");
     auto maybeIgnores = readJson(mainIgnoresPath);
-    if (!maybeIgnores.is<JSDocument>()) { // NOLINT
+    if (!std::holds_alternative<JSDocument>(maybeIgnores)) { // NOLINT
         return {};
     }
 
-    for (const auto& property : maybeIgnores.get<JSDocument>().GetObject()) {
+    for (const auto& property : std::get<JSDocument>(maybeIgnores).GetObject()) {
         std::string id{toString(property.name)};
         // Keep only expression-test ignores
         if (id.rfind("expression-tests", 0) != 0) {
@@ -405,12 +405,12 @@ std::optional<TestData> parseTestData(const filesystem::path& path) {
     try {
         TestData data;
         auto maybeJson = readJson(path.string());
-        if (!maybeJson.is<JSDocument>()) { // NOLINT
+        if (!std::holds_alternative<JSDocument>(maybeJson)) { // NOLINT
             mbgl::Log::Error(mbgl::Event::General, "Cannot parse test '" + path.string() + "'.");
             return std::nullopt;
         }
 
-        data.document = std::move(maybeJson.get<JSDocument>());
+        data.document = std::move(std::get<JSDocument>(maybeJson));
 
         // Check that mandatory test data members are present.
         if (!data.document.HasMember("expression") || !data.document.HasMember("expected")) {

include/mbgl/style/sources/raster_dem_source.hpp

@@ -2,7 +2,8 @@
 
 #include <mbgl/style/sources/raster_source.hpp>
 #include <mbgl/util/tileset.hpp>
-#include <mbgl/util/variant.hpp>
+
+#include <variant>
 
 namespace mbgl {
 
@@ -12,7 +13,7 @@ namespace style {
 
 class RasterDEMSource : public RasterSource {
 public:
-    RasterDEMSource(std::string id, variant<std::string, Tileset> urlOrTileset, uint16_t tileSize);
+    RasterDEMSource(std::string id, std::variant<std::string, Tileset> urlOrTileset, uint16_t tileSize);
     bool supportsLayerType(const mbgl::style::LayerTypeInfo*) const override;
 };
 

include/mbgl/style/sources/raster_source.hpp

@@ -2,7 +2,8 @@
 
 #include <mbgl/style/source.hpp>
 #include <mbgl/util/tileset.hpp>
-#include <mbgl/util/variant.hpp>
+
+#include <variant>
 
 namespace mbgl {
 
@@ -13,12 +14,12 @@ namespace style {
 class RasterSource : public Source {
 public:
     RasterSource(std::string id,
-                 variant<std::string, Tileset> urlOrTileset,
+                 std::variant<std::string, Tileset> urlOrTileset,
                  uint16_t tileSize,
                  SourceType sourceType = SourceType::Raster);
     ~RasterSource() override;
 
-    const variant<std::string, Tileset>& getURLOrTileset() const;
+    const std::variant<std::string, Tileset>& getURLOrTileset() const;
     std::optional<std::string> getURL() const;
 
     uint16_t getTileSize() const;
@@ -36,7 +37,7 @@ class RasterSource : public Source {
     Mutable<Source::Impl> createMutable() const noexcept final;
 
 private:
-    const variant<std::string, Tileset> urlOrTileset;
+    const std::variant<std::string, Tileset> urlOrTileset;
     std::unique_ptr<AsyncRequest> req;
     mapbox::base::WeakPtrFactory<Source> weakFactory{this};
 };

include/mbgl/style/sources/vector_source.hpp

@@ -2,7 +2,8 @@
 
 #include <mbgl/style/source.hpp>
 #include <mbgl/util/tileset.hpp>
-#include <mbgl/util/variant.hpp>
+
+#include <variant>
 
 namespace mbgl {
 
@@ -13,12 +14,12 @@ namespace style {
 class VectorSource final : public Source {
 public:
     VectorSource(std::string id,
-                 variant<std::string, Tileset> urlOrTileset,
+                 std::variant<std::string, Tileset> urlOrTileset,
                  std::optional<float> maxZoom = std::nullopt,
                  std::optional<float> minZoom = std::nullopt);
     ~VectorSource() final;
 
-    const variant<std::string, Tileset>& getURLOrTileset() const;
+    const std::variant<std::string, Tileset>& getURLOrTileset() const;
     std::optional<std::string> getURL() const;
 
     class Impl;
@@ -34,7 +35,7 @@ class VectorSource final : public Source {
     Mutable<Source::Impl> createMutable() const noexcept final;
 
 private:
-    const variant<std::string, Tileset> urlOrTileset;
+    const std::variant<std::string, Tileset> urlOrTileset;
     std::unique_ptr<AsyncRequest> req;
     mapbox::base::WeakPtrFactory<Source> weakFactory{this};
     std::optional<float> maxZoom;

platform/android/MapboxGLAndroidSDK/src/cpp/style/sources/raster_dem_source.cpp

@@ -5,8 +5,6 @@
 #include "../conversion/url_or_tileset.hpp"
 #include "source.hpp"
 
-#include <mbgl/util/variant.hpp>
-
 #include <string>
 
 namespace mbgl {

platform/android/MapboxGLAndroidSDK/src/cpp/style/sources/raster_source.cpp

@@ -4,8 +4,6 @@
 #include "../value.hpp"
 #include "../conversion/url_or_tileset.hpp"
 
-#include <mbgl/util/variant.hpp>
-
 #include <string>
 
 namespace mbgl {

platform/android/MapboxGLAndroidSDK/src/cpp/style/sources/vector_source.cpp

@@ -12,8 +12,6 @@
 #include "../../geojson/feature.hpp"
 #include "../conversion/url_or_tileset.hpp"
 
-#include <mbgl/util/variant.hpp>
-
 #include <string>
 #include <vector>
 

platform/default/src/mbgl/storage/offline_download.cpp

@@ -150,14 +150,14 @@ OfflineRegionStatus OfflineDownload::getStatus() const {
     for (const auto& source : parser.sources) {
         SourceType type = source->getType();
 
-        auto handleTiledSource = [&](const variant<std::string, Tileset>& urlOrTileset, const uint16_t tileSize) {
-            if (urlOrTileset.is<Tileset>()) {
-                uint64_t tileSourceCount = tileCount(definition, type, tileSize, urlOrTileset.get<Tileset>().zoomRange);
+        auto handleTiledSource = [&](const std::variant<std::string, Tileset>& urlOrTileset, const uint16_t tileSize) {
+            if (std::holds_alternative<Tileset>(urlOrTileset)) {
+                uint64_t tileSourceCount = tileCount(definition, type, tileSize, std::get<Tileset>(urlOrTileset).zoomRange);
                 result->requiredTileCount += tileSourceCount;
                 result->requiredResourceCount += tileSourceCount;
             } else {
                 result->requiredResourceCount += 1;
-                const auto& url = urlOrTileset.get<std::string>();
+                const auto& url = std::get<std::string>(urlOrTileset);
                 std::optional<Response> sourceResponse = offlineDatabase.get(Resource::source(url));
                 if (sourceResponse) {
                     style::conversion::Error error;
@@ -252,11 +252,11 @@ void OfflineDownload::activateDownload() {
         for (const auto& source : parser.sources) {
             SourceType type = source->getType();
 
-            auto handleTiledSource = [&](const variant<std::string, Tileset>& urlOrTileset, const uint16_t tileSize) {
-                if (urlOrTileset.is<Tileset>()) {
-                    queueTiles(type, tileSize, urlOrTileset.get<Tileset>());
+            auto handleTiledSource = [&](const std::variant<std::string, Tileset>& urlOrTileset, const uint16_t tileSize) {
+                if (std::holds_alternative<Tileset>(urlOrTileset)) {
+                    queueTiles(type, tileSize, std::get<Tileset>(urlOrTileset));
                 } else {
-                    const auto& rawUrl = urlOrTileset.get<std::string>();
+                    const auto& rawUrl = std::get<std::string>(urlOrTileset);
                     const auto& url = util::mapbox::canonicalizeSourceURL(tileServerOptions, rawUrl);
 
                     status.requiredResourceCountIsPrecise = false;

platform/ios/platform/darwin/src/MLNRasterDEMSource.mm

@@ -7,7 +7,7 @@
 
 @implementation MLNRasterDEMSource
 
-- (std::unique_ptr<mbgl::style::RasterSource>)pendingSourceWithIdentifier:(NSString *)identifier urlOrTileset:(mbgl::variant<std::string, mbgl::Tileset>)urlOrTileset tileSize:(uint16_t)tileSize {
+- (std::unique_ptr<mbgl::style::RasterSource>)pendingSourceWithIdentifier:(NSString *)identifier urlOrTileset:(std::variant<std::string, mbgl::Tileset>)urlOrTileset tileSize:(uint16_t)tileSize {
     auto source = std::make_unique<mbgl::style::RasterDEMSource>(identifier.UTF8String,
                                                                  urlOrTileset,
                                                                  tileSize);

render-test/manifest_parser.cpp

@@ -59,10 +59,10 @@ std::vector<std::pair<std::string, std::string>> parseIgnores(const std::vector<
     std::vector<std::pair<std::string, std::string>> ignores;
     for (const auto& path : ignoresPaths) {
         auto maybeIgnores = readJson(path);
-        if (!maybeIgnores.is<mbgl::JSDocument>()) {
+        if (!std::holds_alternative<mbgl::JSDocument>(maybeIgnores)) {
             continue;
         }
-        for (const auto& property : maybeIgnores.get<mbgl::JSDocument>().GetObject()) {
+        for (const auto& property : std::get<mbgl::JSDocument>(maybeIgnores).GetObject()) {
             const std::string ignore = {property.name.GetString(), property.name.GetStringLength()};
             const std::string reason = {property.value.GetString(), property.value.GetStringLength()};
             ignores.emplace_back(std::make_pair(ignore, reason));
@@ -106,13 +106,13 @@ std::optional<Manifest> ManifestParser::parseManifest(const std::string& manifes
     manifest.manifestPath = manifestPath.substr(0, manifestPath.find(filePath.filename()));
 
     auto contents = readJson(filePath);
-    if (!contents.is<mbgl::JSDocument>()) {
+    if (!std::holds_alternative<mbgl::JSDocument>(contents)) {
         mbgl::Log::Error(mbgl::Event::General,
                          "Provided manifest file: " + std::string(filePath) + " is not a valid json");
         return std::nullopt;
     }
 
-    auto document = std::move(contents.get<mbgl::JSDocument>());
+    auto document = std::move(std::get<mbgl::JSDocument>(contents));
     if (document.HasMember("result_path")) {
         const auto& resultPathValue = document["result_path"];
         if (!resultPathValue.IsString()) {

render-test/parser.cpp

@@ -328,11 +328,11 @@ TestMetrics readExpectedMetrics(const mbgl::filesystem::path& path) {
     TestMetrics result;
 
     auto maybeJson = readJson(path.string());
-    if (!maybeJson.is<mbgl::JSDocument>()) { // NOLINT
+    if (!std::holds_alternative<mbgl::JSDocument>(maybeJson)) { // NOLINT
         return result;
     }
 
-    const auto& document = maybeJson.get<mbgl::JSDocument>();
+    const auto& document = std::get<mbgl::JSDocument>(maybeJson);
 
     if (document.HasMember("file-size")) {
         const mbgl::JSValue& fileSizeValue = document["file-size"];
@@ -452,12 +452,12 @@ TestMetadata parseTestMetadata(const TestPaths& paths) {
     metadata.paths = paths;
 
     auto maybeJson = readJson(paths.stylePath.string());
-    if (!maybeJson.is<mbgl::JSDocument>()) { // NOLINT
+    if (!std::holds_alternative<mbgl::JSDocument>(maybeJson)) { // NOLINT
         metadata.errorMessage = std::string("Unable to parse: ") + metadata.paths.stylePath.string();
         return metadata;
     }
 
-    metadata.document = std::move(maybeJson.get<mbgl::JSDocument>());
+    metadata.document = std::move(std::get<mbgl::JSDocument>(maybeJson));
     if (!metadata.document.HasMember("metadata")) {
         mbgl::Log::Warning(mbgl::Event::ParseStyle, "Style has no 'metadata': " + paths.stylePath.string());
         return metadata;

render-test/parser.hpp

@@ -3,16 +3,16 @@
 #include "metadata.hpp"
 
 #include <mbgl/util/rapidjson.hpp>
-#include <mbgl/util/variant.hpp>
 
 #include <string>
 #include <tuple>
 #include <vector>
+#include <variant>
 
 class Manifest;
 
 using ErrorMessage = std::string;
-using JSONReply = mbgl::variant<mbgl::JSDocument, ErrorMessage>;
+using JSONReply = std::variant<mbgl::JSDocument, ErrorMessage>;
 
 JSONReply readJson(const mbgl::filesystem::path&);
 std::string serializeJsonValue(const mbgl::JSValue&);

render-test/runner.cpp

@@ -173,8 +173,8 @@ void TestRunner::checkQueryTestResults(mbgl::PremultipliedImage&& actualImage,
 
     for (const auto& entry : expectedJsonPaths) {
         auto maybeExpectedJson = readJson(entry);
-        if (maybeExpectedJson.is<mbgl::JSDocument>()) {
-            auto& expected = maybeExpectedJson.get<mbgl::JSDocument>();
+        if (std::holds_alternative<mbgl::JSDocument>(maybeExpectedJson)) {
+            auto& expected = std::get<mbgl::JSDocument>(maybeExpectedJson);
 
             mbgl::JSDocument actual;
             actual.Parse<0>(metadata.actualJson);

src/mbgl/geometry/line_atlas.cpp

@@ -5,6 +5,7 @@
 #include <mbgl/math/minmax.hpp>
 #include <mbgl/util/hash.hpp>
 #include <mbgl/util/logging.hpp>
+#include <mbgl/util/overloaded.hpp>
 #include <mbgl/util/platform.hpp>
 
 namespace mbgl {
@@ -206,23 +207,23 @@ DashPatternTexture::DashPatternTexture(const std::vector<float>& from_,
 }
 
 void DashPatternTexture::upload(gfx::UploadPass& uploadPass) {
-    if (texture.is<AlphaImage>()) {
-        texture = uploadPass.createTexture(texture.get<AlphaImage>());
+    if (std::holds_alternative<AlphaImage>(texture)) {
+        texture = uploadPass.createTexture(std::get<AlphaImage>(texture));
     }
 }
 
 gfx::TextureBinding DashPatternTexture::textureBinding() const {
     // The texture needs to have been uploaded already.
-    assert(texture.is<gfx::Texture>());
-    return {texture.get<gfx::Texture>().getResource(),
+    assert(std::holds_alternative<gfx::Texture>(texture));
+    return {std::get<gfx::Texture>(texture).getResource(),
             gfx::TextureFilterType::Linear,
             gfx::TextureMipMapType::No,
             gfx::TextureWrapType::Repeat,
             gfx::TextureWrapType::Clamp};
 }
 
 Size DashPatternTexture::getSize() const {
-    return texture.match([](const auto& obj) { return obj.size; });
+    return std::visit([](const auto& obj) { return obj.size; }, texture);
 }
 
 LineAtlas::LineAtlas() = default;

src/mbgl/geometry/line_atlas.hpp

@@ -2,12 +2,12 @@
 
 #include <mbgl/gfx/texture.hpp>
 #include <mbgl/util/image.hpp>
-#include <mbgl/util/variant.hpp>
 
 #include <map>
 #include <memory>
-#include <vector>
 #include <optional>
+#include <variant>
+#include <vector>
 
 namespace mbgl {
 
@@ -54,7 +54,7 @@ class DashPatternTexture {
 
 private:
     LinePatternPos from, to;
-    variant<AlphaImage, gfx::Texture> texture;
+    std::variant<AlphaImage, gfx::Texture> texture;
 };
 
 class LineAtlas {

src/mbgl/gfx/color_mode.hpp

@@ -1,9 +1,10 @@
 #pragma once
 
 #include <mbgl/gfx/types.hpp>
-#include <mbgl/util/variant.hpp>
 #include <mbgl/util/color.hpp>
 
+#include <variant>
+
 namespace mbgl {
 namespace gfx {
 
@@ -33,7 +34,7 @@ class ColorMode {
     using Subtract = LinearBlend<ColorBlendEquationType::Subtract>;
     using ReverseSubtract = LinearBlend<ColorBlendEquationType::ReverseSubtract>;
 
-    using BlendFunction = variant<Replace, Add, Subtract, ReverseSubtract>;
+    using BlendFunction = std::variant< Replace, Add, Subtract, ReverseSubtract>;
 
     BlendFunction blendFunction;
     Color blendColor;