Merge branch 'master' into sf-ranges

include/engine/api/flatbuffers/fbresult.fbs

@@ -0,0 +1,20 @@
+include "route.fbs";
+include "table.fbs";
+
+namespace osrm.engine.api.fbresult;
+
+table Error {
+    code: string;
+    message: string;
+}
+
+table FBResult {
+    error: bool = false;
+    code: Error;
+    data_version: string;
+    waypoints: [Waypoint]; //Used as 'sources' waypoints for a 'Table' service
+    routes: [RouteObject];
+    table: TableResult;
+}
+
+root_type FBResult;

include/engine/api/flatbuffers/position.fbs

@@ -0,0 +1,6 @@
+namespace osrm.engine.api.fbresult;
+
+struct Position {
+    longitude: float;
+    latitude:  float;
+}

include/engine/api/flatbuffers/route.fbs

@@ -0,0 +1,110 @@
+include "waypoint.fbs";
+namespace osrm.engine.api.fbresult;
+
+table Metadata {
+    datasource_names: [string];
+}
+
+table Annotation {
+    distance: [uint];
+    duration: [uint];
+    datasources: [uint];
+    nodes: [uint];
+    weight: [uint];
+    speed: [float];
+    metadata: Metadata;
+}
+
+enum ManeuverType: byte {
+    Turn,
+    NewName,
+    Depart,
+    Arrive,
+    Merge,
+    OnRamp,
+    OffRamp,
+    Fork,
+    EndOfRoad,
+    Continue,
+    Roundabout,
+    Rotary,
+    RoundaboutTurn,
+    Notification,
+    ExitRoundabout,
+    ExitRotary
+}
+
+enum Turn: byte {
+    None,
+    UTurn,
+    SharpRight,
+    Right,
+    SlightRight,
+    Straight,
+    SlightLeft,
+    Left,
+    SharpLeft
+}
+
+table StepManeuver {
+    location: Position;
+    bearing_before: ushort;
+    bearing_after: ushort;
+    type: ManeuverType;
+    modifier: Turn;
+    exit: ubyte;
+}
+
+table Lane {
+    indications: [Turn];
+    valid: bool;
+}
+
+table Intersection {
+    location: Position;
+    bearings: [short];
+    classes: [string];
+    entry: [bool];
+    in_bearing: uint;
+    out_bearing: uint;
+    lanes: [Lane];
+}
+
+table Step {
+    distance: float;
+    duration: float;
+    polyline: string;
+    coordinates: [Position];
+    weight: float;
+    name: string;
+    ref: string;
+    pronunciation: string;
+    destinations: string;
+    exits: string;
+    mode: string;
+    maneuver: StepManeuver;
+    intersections: [Intersection];
+    rotary_name: string;
+    rotary_pronunciation: string;
+    driving_side: bool; //Where true stands for the left side.
+}
+
+table Leg {
+    distance: double;
+    duration: double;
+    weight: double;
+    summary: string;
+    annotations: Annotation;
+    steps: [Step];
+}
+
+table RouteObject {
+    distance: float;
+    duration: float;
+    weight: float;
+    weight_name: string;
+    confidence: float; //Used only by 'Match' service
+    polyline: string;
+    coordinates: [Position];
+    legs: [Leg];
+}

include/engine/api/flatbuffers/table.fbs

@@ -0,0 +1,11 @@
+include "waypoint.fbs";
+namespace osrm.engine.api.fbresult;
+
+table TableResult {
+    durations: [float];
+    rows: ushort;
+    cols: ushort;
+    distances: [float];
+    destinations: [Waypoint];
+    fallback_speed_cells: [uint];
+}

include/engine/api/flatbuffers/waypoint.fbs

@@ -0,0 +1,19 @@
+include "position.fbs";
+namespace osrm.engine.api.fbresult;
+
+struct Uint64Pair {
+    first: uint64;
+    second: uint64;
+}
+
+table Waypoint {
+    hint: string;
+    distance: float;
+    name: string;
+    location: Position;
+    nodes: Uint64Pair; //Used only by 'Nearest' service
+    matchings_index: uint; //Used only by 'Match' service
+    waypoint_index: uint; //Used by 'Match' and 'Trip' services
+    alternatives_count: uint; //Used only by 'Match' service
+    trips_index: uint; //Used only by 'Trip' service
+}

include/engine/datafacade/contiguous_internalmem_datafacade.hpp

@@ -603,6 +603,8 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
         auto found_range = std::equal_range(
             m_maneuver_overrides.begin(), m_maneuver_overrides.end(), edge_based_node_id, Comp{});
 
+        results.reserve(std::distance(found_range.first, found_range.second));
+
         std::for_each(found_range.first,
                       found_range.second,
                       [&](const auto &override)

include/nodejs/json_v8_renderer.hpp

@@ -30,7 +30,7 @@ struct V8Renderer
         {
             Napi::Value child;
             std::visit(V8Renderer(env, child), keyValue.second);
-            obj.Set(keyValue.first, child);
+            obj.Set(keyValue.first.data(), child);
         }
         out = obj;
     }

include/util/bearing.hpp

@@ -11,46 +11,6 @@ namespace osrm::util
 namespace bearing
 {
 
-inline std::string get(const double heading)
-{
-    BOOST_ASSERT(heading >= 0);
-    BOOST_ASSERT(heading <= 360);
-
-    if (heading <= 22.5)
-    {
-        return "N";
-    }
-    if (heading <= 67.5)
-    {
-        return "NE";
-    }
-    if (heading <= 112.5)
-    {
-        return "E";
-    }
-    if (heading <= 157.5)
-    {
-        return "SE";
-    }
-    if (heading <= 202.5)
-    {
-        return "S";
-    }
-    if (heading <= 247.5)
-    {
-        return "SW";
-    }
-    if (heading <= 292.5)
-    {
-        return "W";
-    }
-    if (heading <= 337.5)
-    {
-        return "NW";
-    }
-    return "N";
-}
-
 // Checks whether A is between B-range and B+range, all modulo 360
 // e.g. A = 5, B = 5, range = 10 == true
 //      A = -6, B = 5, range = 10 == false

include/util/bit_range.hpp

@@ -2,43 +2,13 @@
 #define OSRM_UTIL_BIT_RANGE_HPP
 
 #include "util/msb.hpp"
-
+#include <bit>
 #include <boost/iterator/iterator_facade.hpp>
 #include <ranges>
 
 namespace osrm::util
 {
 
-namespace detail
-{
-template <typename T> std::size_t countOnes(T value)
-{
-    static_assert(std::is_unsigned<T>::value, "Only unsigned types allowed");
-    std::size_t number_of_ones = 0;
-    while (value > 0)
-    {
-        auto index = msb(value);
-        value = value & ~(T{1} << index);
-        number_of_ones++;
-    }
-    return number_of_ones;
-}
-
-#if (defined(__clang__) || defined(__GNUC__) || defined(__GNUG__))
-inline std::size_t countOnes(std::uint8_t value)
-{
-    return __builtin_popcount(std::uint32_t{value});
-}
-inline std::size_t countOnes(std::uint16_t value)
-{
-    return __builtin_popcount(std::uint32_t{value});
-}
-inline std::size_t countOnes(unsigned int value) { return __builtin_popcount(value); }
-inline std::size_t countOnes(unsigned long value) { return __builtin_popcountl(value); }
-inline std::size_t countOnes(unsigned long long value) { return __builtin_popcountll(value); }
-#endif
-} // namespace detail
-
 // Investigate if we can replace this with
 // http://www.boost.org/doc/libs/1_64_0/libs/dynamic_bitset/dynamic_bitset.html
 template <typename DataT>
@@ -70,7 +40,7 @@ class BitIterator : public boost::iterator_facade<BitIterator<DataT>,
 
     difference_type distance_to(const BitIterator &other) const
     {
-        return detail::countOnes(m_value) - detail::countOnes(other.m_value);
+        return std::popcount(m_value) - std::popcount(other.m_value);
     }
 
     bool equal(const BitIterator &other) const { return m_value == other.m_value; }

include/util/json_container.hpp

@@ -104,7 +104,7 @@ using Value = std::variant<String, Number, Object, Array, True, False, Null>;
  */
 struct Object
 {
-    std::unordered_map<std::string, Value> values;
+    std::unordered_map<std::string_view, Value> values;
 };
 
 /**

include/util/json_deep_compare.hpp

@@ -44,13 +44,13 @@ struct Comparator
 
     bool operator()(const Object &lhs, const Object &rhs) const
     {
-        std::set<std::string> lhs_keys;
+        std::set<std::string_view> lhs_keys;
         for (const auto &key_value : lhs.values)
         {
             lhs_keys.insert(key_value.first);
         }
 
-        std::set<std::string> rhs_keys;
+        std::set<std::string_view> rhs_keys;
         for (const auto &key_value : rhs.values)
         {
             rhs_keys.insert(key_value.first);
@@ -60,7 +60,7 @@ struct Comparator
         {
             if (rhs_keys.find(key) == rhs_keys.end())
             {
-                reason = rhs_path + " doesn't have key \"" + key + "\"";
+                reason = rhs_path + " doesn't have key \"" + std::string(key) + "\"";
                 return false;
             }
         }
@@ -69,7 +69,7 @@ struct Comparator
         {
             if (lhs_keys.find(key) == lhs_keys.end())
             {
-                reason = lhs_path + " doesn't have key \"" + key + "\"";
+                reason = lhs_path + " doesn't have key \"" + std::string(key) + "\"";
                 return false;
             }
         }
@@ -81,10 +81,11 @@ 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 + "." + std::string(key),
+                                                 rhs_path + "." + std::string(key)),
+                                      lhs_child,
+                                      rhs_child);
             if (!is_same)
             {
                 return false;

include/util/json_renderer.hpp

@@ -97,7 +97,7 @@ template <typename Out> struct Renderer
     void operator()(const Null &) { write<>("null"); }
 
   private:
-    void write(const std::string &str);
+    void write(std::string_view str);
     void write(const char *str, size_t size);
     void write(char ch);
 
@@ -110,7 +110,7 @@ template <typename Out> struct Renderer
     Out &out;
 };
 
-template <> void Renderer<std::vector<char>>::write(const std::string &str)
+template <> void Renderer<std::vector<char>>::write(std::string_view str)
 {
     out.insert(out.end(), str.begin(), str.end());
 }
@@ -122,7 +122,7 @@ template <> void Renderer<std::vector<char>>::write(const char *str, size_t size
 
 template <> void Renderer<std::vector<char>>::write(char ch) { out.push_back(ch); }
 
-template <> void Renderer<std::ostream>::write(const std::string &str) { out << str; }
+template <> void Renderer<std::ostream>::write(std::string_view str) { out << str; }
 
 template <> void Renderer<std::ostream>::write(const char *str, size_t size)
 {
@@ -131,7 +131,7 @@ template <> void Renderer<std::ostream>::write(const char *str, size_t size)
 
 template <> void Renderer<std::ostream>::write(char ch) { out << ch; }
 
-template <> void Renderer<std::string>::write(const std::string &str) { out += str; }
+template <> void Renderer<std::string>::write(std::string_view str) { out += str; }
 
 template <> void Renderer<std::string>::write(const char *str, size_t size)
 {

include/util/meminfo.hpp

@@ -2,6 +2,7 @@
 #define MEMINFO_HPP
 
 #include "util/log.hpp"
+#include <cstddef>
 
 #ifndef _WIN32
 #include <sys/resource.h>
@@ -10,22 +11,31 @@
 namespace osrm::util
 {
 
-inline void DumpMemoryStats()
+inline size_t PeakRAMUsedInBytes()
 {
 #ifndef _WIN32
     rusage usage;
     getrusage(RUSAGE_SELF, &usage);
 #ifdef __linux__
     // Under linux, ru.maxrss is in kb
-    util::Log() << "RAM: peak bytes used: " << usage.ru_maxrss * 1024;
+    return usage.ru_maxrss * 1024;
 #else  // __linux__
     // Under BSD systems (OSX), it's in bytes
-    util::Log() << "RAM: peak bytes used: " << usage.ru_maxrss;
+    return usage.ru_maxrss;
 #endif // __linux__
+#else  // _WIN32
+    return 0;
+#endif // _WIN32
+}
+
+inline void DumpMemoryStats()
+{
+#ifndef _WIN32
+    util::Log() << "RAM: peak bytes used: " << PeakRAMUsedInBytes();
 #else  // _WIN32
     util::Log() << "RAM: peak bytes used: <not implemented on Windows>";
 #endif // _WIN32
 }
 } // namespace osrm::util
 
-#endif
+#endif

include/util/msb.hpp

@@ -1,50 +1,24 @@
 #ifndef OSRM_UTIL_MSB_HPP
 #define OSRM_UTIL_MSB_HPP
 
+#include <bit>
 #include <boost/assert.hpp>
-
-#include <climits>
 #include <cstdint>
-#include <utility>
+#include <limits>
 
 namespace osrm::util
 {
 
-// get the msb of an integer
-// return 0 for integers without msb
 template <typename T> std::size_t msb(T value)
 {
+    BOOST_ASSERT(value > 0);
+
     static_assert(std::is_integral<T>::value && !std::is_signed<T>::value, "Integer required.");
-    std::size_t msb = 0;
-    while (value > 0)
-    {
-        value >>= 1u;
-        msb++;
-    }
-    BOOST_ASSERT(msb > 0);
-    return msb - 1;
+    constexpr auto MSB_INDEX = std::numeric_limits<unsigned char>::digits * sizeof(T) - 1;
+
+    return MSB_INDEX - std::countl_zero(value);
 }
 
-#if (defined(__clang__) || defined(__GNUC__) || defined(__GNUG__))
-inline std::size_t msb(unsigned long long v)
-{
-    BOOST_ASSERT(v > 0);
-    constexpr auto MSB_INDEX = CHAR_BIT * sizeof(unsigned long long) - 1;
-    return MSB_INDEX - __builtin_clzll(v);
-}
-inline std::size_t msb(unsigned long v)
-{
-    BOOST_ASSERT(v > 0);
-    constexpr auto MSB_INDEX = CHAR_BIT * sizeof(unsigned long) - 1;
-    return MSB_INDEX - __builtin_clzl(v);
-}
-inline std::size_t msb(unsigned int v)
-{
-    BOOST_ASSERT(v > 0);
-    constexpr auto MSB_INDEX = CHAR_BIT * sizeof(unsigned int) - 1;
-    return MSB_INDEX - __builtin_clz(v);
-}
-#endif
 } // namespace osrm::util
 
 #endif