wip

include/engine/api/base_result.hpp

@@ -10,8 +10,7 @@
 
 namespace osrm::engine::api
 {
-using ResultT =
-    std::variant<util::json::Object, std::string, flatbuffers::FlatBufferBuilder>;
+using ResultT = std::variant<util::json::Object, std::string, flatbuffers::FlatBufferBuilder>;
 } // namespace osrm::engine::api
 
 #endif

include/engine/api/route_api.hpp

@@ -159,7 +159,7 @@ class RouteAPI : public BaseAPI
 
     template <typename ForwardIter>
     std::variant<flatbuffers::Offset<flatbuffers::String>,
-                          flatbuffers::Offset<flatbuffers::Vector<const fbresult::Position *>>>
+                 flatbuffers::Offset<flatbuffers::Vector<const fbresult::Position *>>>
     MakeGeometry(flatbuffers::FlatBufferBuilder &builder, ForwardIter begin, ForwardIter end) const
     {
         if (parameters.geometries == RouteParameters::GeometriesType::Polyline)
@@ -409,7 +409,7 @@ class RouteAPI : public BaseAPI
         // Fill geometry
         auto overview = MakeOverview(leg_geometries);
         std::variant<flatbuffers::Offset<flatbuffers::String>,
-                              flatbuffers::Offset<flatbuffers::Vector<const fbresult::Position *>>>
+                     flatbuffers::Offset<flatbuffers::Vector<const fbresult::Position *>>>
             geometry;
         if (overview)
         {
@@ -426,8 +426,7 @@ class RouteAPI : public BaseAPI
         routeObject.add_legs(legs_vector);
         if (overview)
         {
-            std::visit(GeometryVisitor<fbresult::RouteObjectBuilder>(routeObject),
-                                        geometry);
+            std::visit(GeometryVisitor<fbresult::RouteObjectBuilder>(routeObject), geometry);
         }
 
         return routeObject.Finish();

include/extractor/internal_extractor_edge.hpp

@@ -7,7 +7,7 @@
 #include "util/typedefs.hpp"
 
 #include <boost/assert.hpp>
-#include <mapbox/variant.hpp>
+#include <variant>
 #include <utility>
 
 namespace osrm::extractor

include/extractor/maneuver_override.hpp

@@ -11,7 +11,7 @@
 #include "util/std_hash.hpp"
 #include "util/vector_view.hpp"
 
-#include <mapbox/variant.hpp>
+#include <variant>
 
 #include <algorithm>
 

include/extractor/turn_path.hpp

@@ -4,7 +4,7 @@
 #include "util/typedefs.hpp"
 
 #include <algorithm>
-#include <mapbox/variant.hpp>
+#include <variant>
 #include <vector>
 
 namespace osrm::extractor
@@ -61,50 +61,50 @@ struct InputViaWayPath
 
 struct InputTurnPath
 {
-    mapbox::util::variant<InputViaNodePath, InputViaWayPath> node_or_way;
+    std::variant<InputViaNodePath, InputViaWayPath> node_or_way;
 
     TurnPathType Type() const
     {
-        BOOST_ASSERT(node_or_way.which() < TurnPathType::NUM_TURN_PATH_TYPES);
-        return static_cast<TurnPathType>(node_or_way.which());
+        BOOST_ASSERT(node_or_way.index() < TurnPathType::NUM_TURN_PATH_TYPES);
+        return static_cast<TurnPathType>(node_or_way.index());
     }
 
     OSMWayID From() const
     {
-        return node_or_way.which() == TurnPathType::VIA_NODE_TURN_PATH
-                   ? mapbox::util::get<InputViaNodePath>(node_or_way).from
-                   : mapbox::util::get<InputViaWayPath>(node_or_way).from;
+        return node_or_way.index() == TurnPathType::VIA_NODE_TURN_PATH
+                   ? std::get<InputViaNodePath>(node_or_way).from
+                   : std::get<InputViaWayPath>(node_or_way).from;
     }
 
     OSMWayID To() const
     {
-        return node_or_way.which() == TurnPathType::VIA_NODE_TURN_PATH
-                   ? mapbox::util::get<InputViaNodePath>(node_or_way).to
-                   : mapbox::util::get<InputViaWayPath>(node_or_way).to;
+        return node_or_way.index() == TurnPathType::VIA_NODE_TURN_PATH
+                   ? std::get<InputViaNodePath>(node_or_way).to
+                   : std::get<InputViaWayPath>(node_or_way).to;
     }
 
     InputViaWayPath &AsViaWayPath()
     {
-        BOOST_ASSERT(node_or_way.which() == TurnPathType::VIA_WAY_TURN_PATH);
-        return mapbox::util::get<InputViaWayPath>(node_or_way);
+        BOOST_ASSERT(node_or_way.index() == TurnPathType::VIA_WAY_TURN_PATH);
+        return std::get<InputViaWayPath>(node_or_way);
     }
 
     const InputViaWayPath &AsViaWayPath() const
     {
-        BOOST_ASSERT(node_or_way.which() == TurnPathType::VIA_WAY_TURN_PATH);
-        return mapbox::util::get<InputViaWayPath>(node_or_way);
+        BOOST_ASSERT(node_or_way.index() == TurnPathType::VIA_WAY_TURN_PATH);
+        return std::get<InputViaWayPath>(node_or_way);
     }
 
     InputViaNodePath &AsViaNodePath()
     {
-        BOOST_ASSERT(node_or_way.which() == TurnPathType::VIA_NODE_TURN_PATH);
-        return mapbox::util::get<InputViaNodePath>(node_or_way);
+        BOOST_ASSERT(node_or_way.index() == TurnPathType::VIA_NODE_TURN_PATH);
+        return std::get<InputViaNodePath>(node_or_way);
     }
 
     const InputViaNodePath &AsViaNodePath() const
     {
-        BOOST_ASSERT(node_or_way.which() == TurnPathType::VIA_NODE_TURN_PATH);
-        return mapbox::util::get<InputViaNodePath>(node_or_way);
+        BOOST_ASSERT(node_or_way.index() == TurnPathType::VIA_NODE_TURN_PATH);
+        return std::get<InputViaNodePath>(node_or_way);
     }
 };
 
@@ -175,63 +175,63 @@ struct ViaWayPath
 // between node/way paths
 struct TurnPath
 {
-    mapbox::util::variant<ViaNodePath, ViaWayPath> node_or_way;
+    std::variant<ViaNodePath, ViaWayPath> node_or_way;
 
     NodeID To() const
     {
-        return node_or_way.which() == TurnPathType::VIA_NODE_TURN_PATH
-                   ? mapbox::util::get<ViaNodePath>(node_or_way).to
-                   : mapbox::util::get<ViaWayPath>(node_or_way).to;
+        return node_or_way.index() == TurnPathType::VIA_NODE_TURN_PATH
+                   ? std::get<ViaNodePath>(node_or_way).to
+                   : std::get<ViaWayPath>(node_or_way).to;
     }
 
     NodeID From() const
     {
-        return node_or_way.which() == TurnPathType::VIA_NODE_TURN_PATH
-                   ? mapbox::util::get<ViaNodePath>(node_or_way).from
-                   : mapbox::util::get<ViaWayPath>(node_or_way).from;
+        return node_or_way.index() == TurnPathType::VIA_NODE_TURN_PATH
+                   ? std::get<ViaNodePath>(node_or_way).from
+                   : std::get<ViaWayPath>(node_or_way).from;
     }
 
     NodeID FirstVia() const
     {
-        if (node_or_way.which() == TurnPathType::VIA_NODE_TURN_PATH)
+        if (node_or_way.index() == TurnPathType::VIA_NODE_TURN_PATH)
         {
-            return mapbox::util::get<ViaNodePath>(node_or_way).via;
+            return std::get<ViaNodePath>(node_or_way).via;
         }
         else
         {
-            BOOST_ASSERT(!mapbox::util::get<ViaWayPath>(node_or_way).via.empty());
-            return mapbox::util::get<ViaWayPath>(node_or_way).via[0];
+            BOOST_ASSERT(!std::get<ViaWayPath>(node_or_way).via.empty());
+            return std::get<ViaWayPath>(node_or_way).via[0];
         }
     }
 
     ViaWayPath &AsViaWayPath()
     {
-        BOOST_ASSERT(node_or_way.which() == TurnPathType::VIA_WAY_TURN_PATH);
-        return mapbox::util::get<ViaWayPath>(node_or_way);
+        BOOST_ASSERT(node_or_way.index() == TurnPathType::VIA_WAY_TURN_PATH);
+        return std::get<ViaWayPath>(node_or_way);
     }
 
     const ViaWayPath &AsViaWayPath() const
     {
-        BOOST_ASSERT(node_or_way.which() == TurnPathType::VIA_WAY_TURN_PATH);
-        return mapbox::util::get<ViaWayPath>(node_or_way);
+        BOOST_ASSERT(node_or_way.index() == TurnPathType::VIA_WAY_TURN_PATH);
+        return std::get<ViaWayPath>(node_or_way);
     }
 
     ViaNodePath &AsViaNodePath()
     {
-        BOOST_ASSERT(node_or_way.which() == TurnPathType::VIA_NODE_TURN_PATH);
-        return mapbox::util::get<ViaNodePath>(node_or_way);
+        BOOST_ASSERT(node_or_way.index() == TurnPathType::VIA_NODE_TURN_PATH);
+        return std::get<ViaNodePath>(node_or_way);
     }
 
     const ViaNodePath &AsViaNodePath() const
     {
-        BOOST_ASSERT(node_or_way.which() == TurnPathType::VIA_NODE_TURN_PATH);
-        return mapbox::util::get<ViaNodePath>(node_or_way);
+        BOOST_ASSERT(node_or_way.index() == TurnPathType::VIA_NODE_TURN_PATH);
+        return std::get<ViaNodePath>(node_or_way);
     }
 
     TurnPathType Type() const
     {
-        BOOST_ASSERT(node_or_way.which() < TurnPathType::NUM_TURN_PATH_TYPES);
-        return static_cast<TurnPathType>(node_or_way.which());
+        BOOST_ASSERT(node_or_way.index() < TurnPathType::NUM_TURN_PATH_TYPES);
+        return static_cast<TurnPathType>(node_or_way.index());
     }
 
     bool operator==(const TurnPath &other) const

include/nodejs/node_osrm_support.hpp

@@ -29,6 +29,7 @@
 #include <sstream>
 #include <stdexcept>
 #include <string>
+#include <variant>
 #include <vector>
 
 #include <exception>
@@ -51,7 +52,7 @@ struct PluginParameters
     bool renderToBuffer = false;
 };
 
-using ObjectOrString = typename mapbox::util::variant<osrm::json::Object, std::string>;
+using ObjectOrString = typename std::variant<osrm::json::Object, std::string>;
 
 template <typename ResultT> inline Napi::Value render(const Napi::Env &env, const ResultT &result);
 
@@ -62,7 +63,7 @@ template <> Napi::Value inline render(const Napi::Env &env, const std::string &r
 
 template <> Napi::Value inline render(const Napi::Env &env, const ObjectOrString &result)
 {
-    if (result.is<osrm::json::Object>())
+    if (std::holds_alternative<osrm::json::Object>(result))
     {
         // Convert osrm::json object tree into matching v8 object tree
         Napi::Value value;
@@ -96,7 +97,7 @@ inline void ParseResult(const osrm::Status &result_status, osrm::json::Object &r
 
     if (result_status == osrm::Status::Error)
     {
-        throw std::logic_error(code_iter->second.get<osrm::json::String>().value.c_str());
+        throw std::logic_error(std::get<osrm::json::String>(code_iter->second).value.c_str());
     }
 
     result.values.erase(code_iter);

include/server/service/base_service.hpp

@@ -5,7 +5,7 @@
 #include "osrm/osrm.hpp"
 #include "util/coordinate.hpp"
 
-#include <mapbox/variant.hpp>
+#include <variant>
 
 #include <string>
 #include <vector>

include/util/json_container.hpp

@@ -31,11 +31,11 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef JSON_CONTAINER_HPP
 #define JSON_CONTAINER_HPP
 
-#include <variant>
 #include <boost/variant/recursive_wrapper.hpp>
 #include <string>
 #include <unordered_map>
 #include <utility>
+#include <variant>
 #include <vector>
 
 namespace osrm::util::json
@@ -96,13 +96,7 @@ struct Null
  *
  * Dispatch on its type by either by using apply_visitor or its get function.
  */
-using Value = std::variant<String,
-                           Number,
-                                    Object,
-                                    Array,
-                                    True,
-                                    False,
-                                    Null>;
+using Value = std::variant<String, Number, Object, Array, True, False, Null>;
 
 /**
  * Typed Object.

include/util/json_deep_compare.hpp

@@ -81,10 +81,10 @@ struct Comparator
 
             const auto &rhs_child = rhs.values.find(key)->second;
             const auto &lhs_child = lhs.values.find(key)->second;
-            auto is_same = std::visit(
-                Comparator(reason, lhs_path + "." + key, rhs_path + "." + key),
-                lhs_child,
-                rhs_child);
+            auto is_same =
+                std::visit(Comparator(reason, lhs_path + "." + key, rhs_path + "." + key),
+                           lhs_child,
+                           rhs_child);
             if (!is_same)
             {
                 return false;
@@ -104,12 +104,11 @@ struct Comparator
 
         for (auto i = 0UL; i < lhs.values.size(); ++i)
         {
-            auto is_same =
-                std::visit(Comparator(reason,
-                                                       lhs_path + "[" + std::to_string(i) + "]",
-                                                       rhs_path + "[" + std::to_string(i) + "]"),
-                                            lhs.values[i],
-                                            rhs.values[i]);
+            auto is_same = std::visit(Comparator(reason,
+                                                 lhs_path + "[" + std::to_string(i) + "]",
+                                                 rhs_path + "[" + std::to_string(i) + "]"),
+                                      lhs.values[i],
+                                      rhs.values[i]);
             if (!is_same)
             {
                 return false;
@@ -151,8 +150,7 @@ struct Comparator
 
 inline bool compare(const Value &reference, const Value &result, std::string &reason)
 {
-    return std::visit(
-        Comparator(reason, "reference", "result"), reference, result);
+    return std::visit(Comparator(reason, "reference", "result"), reference, result);
 }
 } // namespace osrm::util::json
 

src/benchmarks/match.cpp

@@ -234,7 +234,7 @@ try
             const auto rc = osrm.Match(params, result);
             auto &json_result = std::get<json::Object>(result);
             if (rc != Status::Ok ||
-                json_result.values.at("matchings").get<json::Array>().values.size() != 1)
+                std::get<json::Array>(json_result.values.at("matchings")).values.size() != 1)
             {
                 throw std::runtime_error{"Couldn't match"};
             }

src/nodejs/node_osrm.cpp

@@ -147,7 +147,7 @@ inline void async(const Napi::CallbackInfo &info,
                 osrm::engine::api::ResultT r;
                 r = osrm::util::json::Object();
                 const auto status = ((*osrm).*(service))(*params, r);
-                auto &json_result = r.get<osrm::json::Object>();
+                auto &json_result = std::get<osrm::json::Object>(r);
                 ParseResult(status, json_result);
                 if (pluginParams.renderToBuffer)
                 {

unit_tests/library/match.cpp

@@ -64,11 +64,10 @@ void test_match(bool use_json_only_api)
                 std::get<json::Number>(waypoint_object.values.at("matchings_index")).value;
             const auto waypoint_index =
                 std::get<json::Number>(waypoint_object.values.at("waypoint_index")).value;
-            const auto &route_legs = std::get<json::Array>(std::get<json::Object>(matchings[matchings_index]
-                                         )
-                                         .values.at("legs")
-                                         )
-                                         .values;
+            const auto &route_legs =
+                std::get<json::Array>(
+                    std::get<json::Object>(matchings[matchings_index]).values.at("legs"))
+                    .values;
             BOOST_CHECK_LT(waypoint_index, route_legs.size() + 1);
             BOOST_CHECK_LT(matchings_index, number_of_matchings);
         }
@@ -122,7 +121,7 @@ void test_match_split(bool use_json_only_api)
     const auto code = std::get<json::String>(json_result.values.at("code")).value;
     BOOST_CHECK_EQUAL(code, "Ok");
 
-    const auto &tracepoints =std::get<json::Array>(json_result.values.at("tracepoints")).values;
+    const auto &tracepoints = std::get<json::Array>(json_result.values.at("tracepoints")).values;
     BOOST_CHECK_EQUAL(tracepoints.size(), params.coordinates.size());
 
     const auto &matchings = std::get<json::Array>(json_result.values.at("matchings")).values;
@@ -136,7 +135,7 @@ void test_match_split(bool use_json_only_api)
             BOOST_CHECK(waypoint_check(waypoint));
             const auto &waypoint_object = std::get<json::Object>(waypoint);
             const auto matchings_index =
-               std::get<json::Number>(waypoint_object.values.at("matchings_index")).value;
+                std::get<json::Number>(waypoint_object.values.at("matchings_index")).value;
             const auto waypoint_index =
                 std::get<json::Number>(waypoint_object.values.at("waypoint_index")).value;