Actually expose snapping in node bindings.

.travis.yml

@@ -13,6 +13,7 @@ notifications:
 branches:
   only:
     - master
+    - 5.21
     # enable building tags
     - /^v\d+\.\d+(\.\d+)?(-\S*)?$/
 
@@ -36,10 +37,6 @@ env:
    - ENABLE_NODE_BINDINGS=On
    - NODE="10"
 
-stages:
-  - core
-  - optional
-
 matrix:
   fast_finish: true
 
@@ -47,14 +44,12 @@ matrix:
   include:
 
     # Debug Builds
-    - stage: core
-      os: linux
+    - os: linux
       compiler: "format-taginfo-docs"
       env: NODE=10
       sudo: false
       before_install:
       install:
-        - curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.34.0/install.sh | bash
         - source $NVM_DIR/nvm.sh
         - nvm install $NODE
         - nvm use $NODE
@@ -281,135 +276,7 @@ matrix:
       after_success:
         - ./scripts/travis/publish.sh
 
-    - os: osx
-      stage: optional
-      osx_image: xcode9.2
-      compiler: "mason-osx-release-node-latest"
-      # we use the xcode provides clang and don't install our own
-      env: ENABLE_MASON=ON BUILD_TYPE='Release' CUCUMBER_TIMEOUT=60000 CCOMPILER='clang' CXXCOMPILER='clang++' ENABLE_ASSERTIONS=ON ENABLE_LTO=ON NODE="node"
-      after_success:
-        - ./scripts/travis/publish.sh
-
-    - os: linux
-      sudo: false
-      compiler: "node-latest-mason-linux-release"
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['libstdc++-4.9-dev']
-      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Release' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="node"
-      install:
-        - pushd ${OSRM_BUILD_DIR}
-        - |
-          cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
-              -DENABLE_MASON=${ENABLE_MASON:-OFF} \
-              -DENABLE_NODE_BINDINGS=${ENABLE_NODE_BINDINGS:-OFF} \
-              -DENABLE_CCACHE=ON \
-              -DCMAKE_INSTALL_PREFIX=${OSRM_INSTALL_DIR} \
-              -DENABLE_GLIBC_WORKAROUND=ON
-        - make --jobs=${JOBS}
-        - popd
-      script:
-        - npm run nodejs-tests
-      after_success:
-        - ./scripts/travis/publish.sh
-
-    - os: linux
-      sudo: false
-      compiler: "node-latest-mason-linux-debug"
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['libstdc++-4.9-dev']
-      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Debug' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="node"
-      install:
-        - pushd ${OSRM_BUILD_DIR}
-        - |
-          cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
-              -DENABLE_MASON=${ENABLE_MASON:-OFF} \
-              -DENABLE_NODE_BINDINGS=${ENABLE_NODE_BINDINGS:-OFF} \
-              -DENABLE_CCACHE=ON \
-              -DCMAKE_INSTALL_PREFIX=${OSRM_INSTALL_DIR} \
-              -DENABLE_GLIBC_WORKAROUND=ON
-        - make --jobs=${JOBS}
-        - popd
-      script:
-        - npm run nodejs-tests
-      after_success:
-        - ./scripts/travis/publish.sh
-
-    - os: osx
-      osx_image: xcode9.2
-      compiler: "mason-osx-release-node-lts"
-      # we use the xcode provides clang and don't install our own
-      env: ENABLE_MASON=ON BUILD_TYPE='Release' CUCUMBER_TIMEOUT=60000 CCOMPILER='clang' CXXCOMPILER='clang++' ENABLE_ASSERTIONS=ON ENABLE_LTO=ON NODE="--lts"
-      after_success:
-        - ./scripts/travis/publish.sh
-
-    - os: linux
-      sudo: false
-      compiler: "node-lts-mason-linux-release"
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['libstdc++-4.9-dev']
-      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Release' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="--lts"
-      install:
-        - pushd ${OSRM_BUILD_DIR}
-        - |
-          cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
-              -DENABLE_MASON=${ENABLE_MASON:-OFF} \
-              -DENABLE_NODE_BINDINGS=${ENABLE_NODE_BINDINGS:-OFF} \
-              -DENABLE_CCACHE=ON \
-              -DCMAKE_INSTALL_PREFIX=${OSRM_INSTALL_DIR} \
-              -DENABLE_GLIBC_WORKAROUND=ON
-        - make --jobs=${JOBS}
-        - popd
-      script:
-        - npm run nodejs-tests
-      after_success:
-        - ./scripts/travis/publish.sh
-
-    - os: linux
-      sudo: false
-      compiler: "node-lts-mason-linux-debug"
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['libstdc++-4.9-dev']
-      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Debug' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="--lts"
-      install:
-        - pushd ${OSRM_BUILD_DIR}
-        - |
-          cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
-              -DENABLE_MASON=${ENABLE_MASON:-OFF} \
-              -DENABLE_NODE_BINDINGS=${ENABLE_NODE_BINDINGS:-OFF} \
-              -DENABLE_CCACHE=ON \
-              -DCMAKE_INSTALL_PREFIX=${OSRM_INSTALL_DIR} \
-              -DENABLE_GLIBC_WORKAROUND=ON
-        - make --jobs=${JOBS}
-        - popd
-      script:
-        - npm run nodejs-tests
-      after_success:
-        - ./scripts/travis/publish.sh
-
-  allow_failures:
-    - compiler: "mason-osx-release-node-latest"
-      env: ENABLE_MASON=ON BUILD_TYPE='Release' CUCUMBER_TIMEOUT=60000 CCOMPILER='clang' CXXCOMPILER='clang++' ENABLE_ASSERTIONS=ON ENABLE_LTO=ON NODE="node"
-    - compiler: "node-latest-mason-linux-release"
-      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Release' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="node"
-    - compiler: "node-latest-mason-linux-debug"
-      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Debug' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="node"
-    - compiler: "mason-osx-release-node-lts"
-      env: ENABLE_MASON=ON BUILD_TYPE='Release' CUCUMBER_TIMEOUT=60000 CCOMPILER='clang' CXXCOMPILER='clang++' ENABLE_ASSERTIONS=ON ENABLE_LTO=ON NODE="--lts"
-    - compiler: "node-lts-mason-linux-release"
-      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Release' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="--lts"
-    - compiler: "node-lts-mason-linux-debug"
-      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Debug' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="--lts"
-
 before_install:
-  - curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.34.0/install.sh | bash
   - source $NVM_DIR/nvm.sh
   - nvm install $NODE
   - nvm use $NODE

CHANGELOG.md

@@ -1,11 +1,3 @@
-# Unreleased
-  - Changes from 5.21.0
-    - Build:
-      - ADDED: optionally build Node `lts` and `latest` bindings [#5347](https://github.com/Project-OSRM/osrm-backend/pull/5347)
-    - Features:
-      - ADDED: new waypoints parameter to the `route` plugin, enabling silent waypoints [#5345](https://github.com/Project-OSRM/osrm-backend/pull/5345)
-      - ADDED: data timestamp information in the response (saved in new file `.osrm.timestamp`). [#5115](https://github.com/Project-OSRM/osrm-backend/issues/5115)
-
 # 5.21.0
   - Changes from 5.20.0
     - Features:

cmake/CPackConfig.cmake

@@ -11,7 +11,7 @@ SET(CPACK_INCLUDE_TOPLEVEL_DIRECTORY "FALSE")
 SET(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_SOURCE_DIR}/README.md")
 SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Open Source Routing Machine (OSRM) is a high-performance routing engine. It combines sophisticated routing algorithms with the open and free data of the OpenStreetMap.")
 SET(CPACK_PACKAGE_CONTACT "Project OSRM <info@project-osrm.org>")
-SET(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_SOURCE_DIR}/LICENSE.TXT")
+SET(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_SOURCE_DIR}/LICENCE.TXT")
 
 SET(CPACK_STRIP_FILES "TRUE")
 file(GLOB_RECURSE ProfileGlob ${CMAKE_SOURCE_DIR}/profiles/*)

docker/Dockerfile

@@ -1,14 +1,14 @@
-FROM debian:stretch-slim as builder
+FROM debian:buster-slim as builder
 ARG DOCKER_TAG
-ARG BUILD_CONCURRENCY
 RUN mkdir -p /src  && mkdir -p /opt
 COPY . /src
 WORKDIR /src
 
-RUN NPROC=${BUILD_CONCURRENCY:-$(grep -c ^processor /proc/cpuinfo 2>/dev/null || 1)} && \
+RUN NPROC=$(grep -c ^processor /proc/cpuinfo 2>/dev/null || 1) && \
     apt-get update && \
-    apt-get -y --no-install-recommends install cmake make git gcc g++ libbz2-dev libxml2-dev \
-    libzip-dev libboost1.62-all-dev lua5.2 liblua5.2-dev libtbb-dev -o APT::Install-Suggests=0 -o APT::Install-Recommends=0 && \
+    apt-get -y --no-install-recommends install cmake make git gcc g++ libbz2-dev libstxxl-dev libstxxl1v5 libxml2-dev \
+    libzip-dev libboost1.67-all-dev lua5.2 liblua5.2-dev libtbb-dev -o APT::Install-Suggests=0 -o APT::Install-Recommends=0 && \
+    NPROC=$(grep -c ^processor /proc/cpuinfo 2>/dev/null || 1) && \
     echo "Building OSRM ${DOCKER_TAG}" && \
     git show --format="%H" | head -n1 > /opt/OSRM_GITSHA && \
     echo "Building OSRM gitsha $(cat /opt/OSRM_GITSHA)" && \
@@ -30,20 +30,15 @@ RUN NPROC=${BUILD_CONCURRENCY:-$(grep -c ^processor /proc/cpuinfo 2>/dev/null ||
 
 # Multistage build to reduce image size - https://docs.docker.com/engine/userguide/eng-image/multistage-build/#use-multi-stage-builds
 # Only the content below ends up in the image, this helps remove /src from the image (which is large)
-FROM debian:stretch-slim as runstage
+FROM debian:buster-slim as runstage
 RUN mkdir -p /src  && mkdir -p /opt
 RUN apt-get update && \
-    apt-get install -y --no-install-recommends libboost-program-options1.62.0 libboost-regex1.62.0 \
-        libboost-date-time1.62.0 libboost-chrono1.62.0 libboost-filesystem1.62.0 \
-        libboost-iostreams1.62.0 libboost-thread1.62.0 expat liblua5.2-0 libtbb2 &&\
-    rm -rf /var/lib/apt/lists/*
+apt-get install -y --no-install-recommends libboost-program-options1.67.0 libboost-regex1.67.0 \
+libboost-date-time1.67.0 libboost-chrono1.67.0 libboost-filesystem1.67.0 \
+libboost-iostreams1.67.0 libboost-thread1.67.0 expat liblua5.2-0 libtbb2 &&\
+rm -rf /var/lib/apt/lists/*
 COPY --from=builder /usr/local /usr/local
 COPY --from=builder /opt /opt
-RUN /usr/local/bin/osrm-extract --help && \
-    /usr/local/bin/osrm-routed --help && \
-    /usr/local/bin/osrm-contract --help && \
-    /usr/local/bin/osrm-partition --help && \
-    /usr/local/bin/osrm-customize --help
 WORKDIR /opt
 
 EXPOSE 5000

docker/hooks/build

@@ -6,4 +6,4 @@
 # ensure that "COPY . /src" is referring to the repo root, not the directory
 # that contains the Dockerfile.
 # This script gets executed with a pwd of wherever the Dockerfile is.
-docker build --build-arg BUILD_CONCURRENCY=${CONCURRENCY:-1} --build-arg DOCKER_TAG=${DOCKER_TAG} -t $IMAGE_NAME -f Dockerfile ..
+docker build --build-arg DOCKER_TAG=${DOCKER_TAG} -t $IMAGE_NAME -f Dockerfile ..

docs/http.md

@@ -70,8 +70,6 @@ curl 'http://router.project-osrm.org/route/v1/driving/polyline(ofp_Ik_vpAilAyu@t
 
 ### Responses
 
-#### Code
-
 Every response object has a `code` property containing one of the strings below or a service dependent code:
 
 | Type              | Description                                                                      |
@@ -89,17 +87,12 @@ Every response object has a `code` property containing one of the strings below
 - `message` is a **optional** human-readable error message. All other status types are service dependent.
 - In case of an error the HTTP status code will be `400`. Otherwise the HTTP status code will be `200` and `code` will be `Ok`.
 
-#### Data version
-
-Every response object has a `data_version` propetry containing timestamp from the original OpenStreetMap file. This field is optional. It can be ommited if data_version parametr was not set on osrm-extract stage or OSM file has not `osmosis_replication_timestamp` section.
-
 #### Example response
 
 ```json
 {
 "code": "Ok",
-"message": "Everything worked",
-"data_version": "2017-11-17T21:43:02Z"
+"message": "Everything worked"
 }
 ```
 
@@ -202,7 +195,6 @@ In addition to the [general options](#general-options) the following options are
 |geometries  |`polyline` (default), `polyline6`, `geojson` |Returned route geometry format (influences overview and per step)              |
 |overview    |`simplified` (default), `full`, `false`      |Add overview geometry either full, simplified according to highest zoom level it could be display on, or not at all.|
 |continue\_straight |`default` (default), `true`, `false` |Forces the route to keep going straight at waypoints constraining uturns there even if it would be faster. Default value depends on the profile. |
-|waypoints   | `{index};{index};{index}...`                   |Treats input coordinates indicated by given indices as waypoints in returned Match object. Default is to treat all input coordinates as waypoints.    |
 
 \* Please note that even if alternative routes are requested, a result cannot be guaranteed.
 

docs/nodejs/api.md

@@ -57,7 +57,6 @@ Returns the fastest route between two or more coordinates while visiting the way
     -   `options.overview` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** Add overview geometry either `full`, `simplified` according to highest zoom level it could be display on, or not at all (`false`). (optional, default `simplified`)
     -   `options.continue_straight` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Forces the route to keep going straight at waypoints and don't do a uturn even if it would be faster. Default value depends on the profile.
     -   `options.approaches` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Keep waypoints on curb side. Can be `null` (unrestricted, default) or `curb`.
-    -   `options.waypoints` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Indices to coordinates to treat as waypoints.  If not supplied, all coordinates are waypoints.  Must include first and last coordinate index.
                          `null`/`true`/`false`
 -   `callback` **[Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function)**
 
@@ -211,7 +210,6 @@ if they can not be matched successfully.
     -   `options.radiuses` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Standard deviation of GPS precision used for map matching. If applicable use GPS accuracy. Can be `null` for default value `5` meters or `double >= 0`.
     -   `options.gaps` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?** Allows the input track splitting based on huge timestamp gaps between points. Either `split` or `ignore` (optional, default `split`).
     -   `options.tidy` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Allows the input track modification to obtain better matching quality for noisy tracks (optional, default `false`).
-    -   `options.waypoints` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Indices to coordinates to treat as waypoints.  If not supplied, all coordinates are waypoints.  Must include first and last coordinate index.
 -   `callback` **[Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function)**
 
 **Examples**

features/support/shared_steps.js

@@ -75,10 +75,6 @@ module.exports = function () {
                             got.message = json.message || '';
                         }
 
-                        if (headers.has('data_version')) {
-                            got.data_version = json.data_version || '';
-                        }
-
                         if (headers.has('#')) {
                             // comment column
                             got['#'] = row['#'];

features/testbot/basic.feature

@@ -17,26 +17,9 @@ Feature: Basic Routing
             | ab    |
 
         When I route I should get
-            | from | to | route    | data_version |
-            | a    | b  | ab,ab    |              |
-            | b    | a  | ab,ab    |              |
-
-    Scenario: Data_version test
-        Given the node map
-            """
-            a b
-            """
-
-        And the extract extra arguments "--data_version cucumber_data_version"
-
-        And the ways
-            | nodes |
-            | ab    |
-
-        When I route I should get
-            | from | to | route    | data_version          |
-            | a    | b  | ab,ab    | cucumber_data_version |
-            | b    | a  | ab,ab    | cucumber_data_version |
+            | from | to | route    |
+            | a    | b  | ab,ab    |
+            | b    | a  | ab,ab    |
 
     Scenario: Routing in between two nodes of way
         Given the node map

features/testbot/via.feature

@@ -18,53 +18,6 @@ Feature: Via points
             | waypoints | route           |
             | a,b,c     | abc,abc,abc,abc |
 
-    Scenario: Simple via point with waypoints collapsing
-        Given the node map
-            """
-                 a
-
-            b   1c    d
-                 2
-
-                 e
-            """
-
-        And the ways
-            | nodes |
-            | ace   |
-            | bcd   |
-
-       Given the query options
-            | waypoints | 0;2   |
-
-        When I route I should get
-            | waypoints | route       | turns                    |
-            | b,1,e     | bcd,ace,ace | depart,turn right,arrive |
-            | b,2,e     | bcd,ace,ace | depart,turn right,arrive |
-
-    Scenario: Simple via point with waypoints collapsing
-        Given the node map
-            """
-            a  2  b
-
-            c     d
-             1   3
-            """
-
-        And the ways
-            | nodes |
-            | ab   |
-            | bd   |
-            | cd   |
-            | ac   |
-
-       Given the query options
-            | waypoints | 0;2   |
-
-        When I route I should get
-            | waypoints | route          | turns                                                      |
-            | 1,2,3     | cd,ac,ab,bd,cd | depart,new name right,new name right,new name right,arrive |
-
     Scenario: Simple via point with core factor
         Given the contract extra arguments "--core 0.8"
         Given the node map

include/engine/api/match_parameters.hpp

@@ -63,7 +63,7 @@ struct MatchParameters : public RouteParameters
                           RouteParameters::GeometriesType::Polyline,
                           RouteParameters::OverviewType::Simplified,
                           {}),
-          gaps(GapsType::Split), tidy(false)
+          gaps(GapsType::Split), tidy(false), waypoints()
     {
     }
 
@@ -79,19 +79,24 @@ struct MatchParameters : public RouteParameters
                     bool tidy_,
                     std::vector<std::size_t> waypoints_,
                     Args... args_)
-        : RouteParameters{std::forward<Args>(args_)..., waypoints_},
-          timestamps{std::move(timestamps_)}, gaps(gaps_), tidy(tidy_)
+        : RouteParameters{std::forward<Args>(args_)...}, timestamps{std::move(timestamps_)},
+          gaps(gaps_), tidy(tidy_), waypoints{std::move(waypoints_)}
     {
     }
 
     std::vector<unsigned> timestamps;
     GapsType gaps;
     bool tidy;
+    std::vector<std::size_t> waypoints;
 
     bool IsValid() const
     {
+        const auto valid_waypoints =
+            std::all_of(waypoints.begin(), waypoints.end(), [this](const auto &w) {
+                return w < coordinates.size();
+            });
         return RouteParameters::IsValid() &&
-               (timestamps.empty() || timestamps.size() == coordinates.size());
+               (timestamps.empty() || timestamps.size() == coordinates.size()) && valid_waypoints;
     }
 };
 }

include/engine/api/route_api.hpp

@@ -44,11 +44,8 @@ class RouteAPI : public BaseAPI
     {
     }
 
-    void
-    MakeResponse(const InternalManyRoutesResult &raw_routes,
-                 const std::vector<PhantomNodes>
-                     &all_start_end_points, // all used coordinates, ignoring waypoints= parameter
-                 util::json::Object &response) const
+    void MakeResponse(const InternalManyRoutesResult &raw_routes,
+                      util::json::Object &response) const
     {
         BOOST_ASSERT(!raw_routes.routes.empty());
 
@@ -65,14 +62,10 @@ class RouteAPI : public BaseAPI
                                                 route.target_traversed_in_reverse));
         }
 
-        response.values["waypoints"] = BaseAPI::MakeWaypoints(all_start_end_points);
+        response.values["waypoints"] =
+            BaseAPI::MakeWaypoints(raw_routes.routes[0].segment_end_coordinates);
         response.values["routes"] = std::move(jsRoutes);
         response.values["code"] = "Ok";
-        auto data_timestamp = facade.GetTimestamp();
-        if (!data_timestamp.empty())
-        {
-            response.values["data_version"] = data_timestamp;
-        }
     }
 
   protected:

include/engine/api/route_parameters.hpp

@@ -98,8 +98,7 @@ struct RouteParameters : public BaseParameters
           annotations_type{AnnotationsType::None},
           geometries{geometries_},
           overview{overview_},
-          continue_straight{continue_straight_},
-          waypoints()
+          continue_straight{continue_straight_}
     {
     }
 
@@ -115,9 +114,7 @@ struct RouteParameters : public BaseParameters
         : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
           number_of_alternatives{alternatives_ ? 1u : 0u}, annotations{annotations_},
           annotations_type{annotations_ ? AnnotationsType::All : AnnotationsType::None},
-          geometries{geometries_}, overview{overview_}, continue_straight{continue_straight_},
-          waypoints()
-
+          geometries{geometries_}, overview{overview_}, continue_straight{continue_straight_}
     {
     }
 
@@ -134,43 +131,7 @@ struct RouteParameters : public BaseParameters
           number_of_alternatives{alternatives_ ? 1u : 0u},
           annotations{annotations_ == AnnotationsType::None ? false : true},
           annotations_type{annotations_}, geometries{geometries_}, overview{overview_},
-          continue_straight{continue_straight_}, waypoints()
-    {
-    }
-
-    // RouteParameters constructor adding the `waypoints` parameter
-    template <typename... Args>
-    RouteParameters(const bool steps_,
-                    const bool alternatives_,
-                    const bool annotations_,
-                    const GeometriesType geometries_,
-                    const OverviewType overview_,
-                    const boost::optional<bool> continue_straight_,
-                    std::vector<std::size_t> waypoints_,
-                    const Args... args_)
-        : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
-          number_of_alternatives{alternatives_ ? 1u : 0u}, annotations{annotations_},
-          annotations_type{annotations_ ? AnnotationsType::All : AnnotationsType::None},
-          geometries{geometries_}, overview{overview_}, continue_straight{continue_straight_},
-          waypoints{waypoints_}
-    {
-    }
-
-    // RouteParameters constructor adding the `waypoints` parameter
-    template <typename... Args>
-    RouteParameters(const bool steps_,
-                    const bool alternatives_,
-                    const AnnotationsType annotations_,
-                    const GeometriesType geometries_,
-                    const OverviewType overview_,
-                    const boost::optional<bool> continue_straight_,
-                    std::vector<std::size_t> waypoints_,
-                    Args... args_)
-        : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
-          number_of_alternatives{alternatives_ ? 1u : 0u},
-          annotations{annotations_ == AnnotationsType::None ? false : true},
-          annotations_type{annotations_}, geometries{geometries_}, overview{overview_},
-          continue_straight{continue_straight_}, waypoints{waypoints_}
+          continue_straight{continue_straight_}
     {
     }
 
@@ -183,17 +144,12 @@ struct RouteParameters : public BaseParameters
     GeometriesType geometries = GeometriesType::Polyline;
     OverviewType overview = OverviewType::Simplified;
     boost::optional<bool> continue_straight;
-    std::vector<std::size_t> waypoints;
 
     bool IsValid() const
     {
         const auto coordinates_ok = coordinates.size() >= 2;
         const auto base_params_ok = BaseParameters::IsValid();
-        const auto valid_waypoints =
-            std::all_of(waypoints.begin(), waypoints.end(), [this](const auto &w) {
-                return w < coordinates.size();
-            });
-        return coordinates_ok && base_params_ok && valid_waypoints;
+        return coordinates_ok && base_params_ok;
     }
 };
 
@@ -217,8 +173,8 @@ inline RouteParameters::AnnotationsType operator|=(RouteParameters::AnnotationsT
 {
     return lhs = lhs | rhs;
 }
-} // ns api
-} // ns engine
-} // ns osrm
+}
+}
+}
 
 #endif

include/engine/datafacade/contiguous_internalmem_datafacade.hpp

@@ -137,7 +137,6 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
     extractor::Datasources *m_datasources;
 
     std::uint32_t m_check_sum;
-    StringView m_data_timestamp;
     util::vector_view<util::Coordinate> m_coordinate_list;
     extractor::PackedOSMIDsView m_osmnodeid_list;
     util::vector_view<std::uint32_t> m_lane_description_offsets;
@@ -184,8 +183,6 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
 
         m_check_sum = *index.GetBlockPtr<std::uint32_t>("/common/connectivity_checksum");
 
-        m_data_timestamp = make_timestamp_view(index, "/common/timestamp");
-
         std::tie(m_coordinate_list, m_osmnodeid_list) =
             make_nbn_data_view(index, "/common/nbn_data");
 
@@ -439,11 +436,6 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
 
     std::uint32_t GetCheckSum() const override final { return m_check_sum; }
 
-    std::string GetTimestamp() const override final
-    {
-        return std::string(m_data_timestamp.begin(), m_data_timestamp.end());
-    }
-
     GeometryID GetGeometryIndex(const NodeID id) const override final
     {
         return edge_based_node_data.GetGeometryID(id);

include/engine/datafacade/datafacade_base.hpp

@@ -74,8 +74,6 @@ class BaseDataFacade
 
     virtual std::uint32_t GetCheckSum() const = 0;
 
-    virtual std::string GetTimestamp() const = 0;
-
     // node and edge information access
     virtual util::Coordinate GetCoordinateOfNode(const NodeID id) const = 0;
 

include/extractor/extractor_config.hpp

@@ -55,7 +55,6 @@ struct ExtractorConfig final : storage::IOConfig
                                       ".osrm.geometry",
                                       ".osrm.nbg_nodes",
                                       ".osrm.ebg_nodes",
-                                      ".osrm.timestamp",
                                       ".osrm.edges",
                                       ".osrm.ebg",
                                       ".osrm.ramIndex",
@@ -83,7 +82,6 @@ struct ExtractorConfig final : storage::IOConfig
     boost::filesystem::path input_path;
     boost::filesystem::path profile_path;
     std::vector<boost::filesystem::path> location_dependent_data_paths;
-    std::string data_version;
 
     unsigned requested_num_threads;
     unsigned small_component_size;

include/extractor/files.hpp

@@ -308,26 +308,6 @@ inline void writeTurnLaneData(const boost::filesystem::path &path,
     storage::serialization::write(writer, "/common/turn_lanes/data", turn_lane_data);
 }
 
-// reads .osrm.timestamp
-template <typename TimestampDataT>
-inline void readTimestamp(const boost::filesystem::path &path, TimestampDataT &timestamp)
-{
-    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
-    storage::tar::FileReader reader{path, fingerprint};
-
-    storage::serialization::read(reader, "/common/timestamp", timestamp);
-}
-
-// writes .osrm.timestamp
-template <typename TimestampDataT>
-inline void writeTimestamp(const boost::filesystem::path &path, const TimestampDataT &timestamp)
-{
-    const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
-    storage::tar::FileWriter writer{path, fingerprint};
-
-    storage::serialization::write(writer, "/common/timestamp", timestamp);
-}
-
 // reads .osrm.maneuver_overrides
 template <typename StorageManeuverOverrideT, typename NodeSequencesT>
 inline void readManeuverOverrides(const boost::filesystem::path &path,

include/nodejs/node_osrm_support.hpp

@@ -692,6 +692,35 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo<v8::Value> &arg
         }
     }
 
+    if (obj->Has(Nan::New("snapping").ToLocalChecked()))
+    {
+        v8::Local<v8::Value> snapping = obj->Get(Nan::New("snapping").ToLocalChecked());
+        if (snapping.IsEmpty())
+            return false;
+
+        if (!snapping->IsString())
+        {
+            Nan::ThrowError("Snapping must be a string: [default, any]");
+            return false;
+        }
+        const Nan::Utf8String snapping_utf8str(snapping);
+        std::string snapping_str{*snapping_utf8str, *snapping_utf8str + snapping_utf8str.length()};
+
+        if (snapping_str == "default")
+        {
+            params->snapping = osrm::RouteParameters::SnappingType::Default;
+        }
+        else if (snapping_str == "any")
+        {
+            params->snapping = osrm::RouteParameters::SnappingType::Any;
+        }
+        else
+        {
+            Nan::ThrowError("'snapping' param must be one of [default, any]");
+            return false;
+        }
+    }
+
     return true;
 }
 
@@ -944,101 +973,6 @@ argumentsToRouteParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
         }
     }
 
-    if (obj->Has(Nan::New("waypoints").ToLocalChecked()))
-    {
-        v8::Local<v8::Value> waypoints = obj->Get(Nan::New("waypoints").ToLocalChecked());
-        if (waypoints.IsEmpty())
-            return route_parameters_ptr();
-
-        // must be array
-        if (!waypoints->IsArray())
-        {
-            Nan::ThrowError(
-                "Waypoints must be an array of integers corresponding to the input coordinates.");
-            return route_parameters_ptr();
-        }
-
-        auto waypoints_array = v8::Local<v8::Array>::Cast(waypoints);
-        // must have at least two elements
-        if (waypoints_array->Length() < 2)
-        {
-            Nan::ThrowError("At least two waypoints must be provided");
-            return route_parameters_ptr();
-        }
-        auto coords_size = params->coordinates.size();
-        auto waypoints_array_size = waypoints_array->Length();
-
-        const auto first_index = Nan::To<std::uint32_t>(waypoints_array->Get(0)).FromJust();
-        const auto last_index =
-            Nan::To<std::uint32_t>(waypoints_array->Get(waypoints_array_size - 1)).FromJust();
-        if (first_index != 0 || last_index != coords_size - 1)
-        {
-            Nan::ThrowError("First and last waypoints values must correspond to first and last "
-                            "coordinate indices");
-            return route_parameters_ptr();
-        }
-
-        for (uint32_t i = 0; i < waypoints_array_size; ++i)
-        {
-            v8::Local<v8::Value> waypoint_value = waypoints_array->Get(i);
-            // all elements must be numbers
-            if (!waypoint_value->IsNumber())
-            {
-                Nan::ThrowError("Waypoint values must be an array of integers");
-                return route_parameters_ptr();
-            }
-            // check that the waypoint index corresponds with an inpute coordinate
-            const auto index = Nan::To<std::uint32_t>(waypoint_value).FromJust();
-            if (index >= coords_size)
-            {
-                Nan::ThrowError("Waypoints must correspond with the index of an input coordinate");
-                return route_parameters_ptr();
-            }
-            params->waypoints.emplace_back(static_cast<unsigned>(waypoint_value->NumberValue()));
-        }
-
-        if (!params->waypoints.empty())
-        {
-            for (std::size_t i = 0; i < params->waypoints.size() - 1; i++)
-            {
-                if (params->waypoints[i] >= params->waypoints[i + 1])
-                {
-                    Nan::ThrowError("Waypoints must be supplied in increasing order");
-                    return route_parameters_ptr();
-                }
-            }
-        }
-    }
-
-    if (obj->Has(Nan::New("snapping").ToLocalChecked()))
-    {
-        v8::Local<v8::Value> snapping = obj->Get(Nan::New("snapping").ToLocalChecked());
-        if (snapping.IsEmpty())
-            return route_parameters_ptr();
-
-        if (!snapping->IsString())
-        {
-            Nan::ThrowError("Snapping must be a string: [default, any]");
-            return route_parameters_ptr();
-        }
-        const Nan::Utf8String snapping_utf8str(snapping);
-        std::string snapping_str{*snapping_utf8str, *snapping_utf8str + snapping_utf8str.length()};
-
-        if (snapping_str == "default")
-        {
-            params->snapping = osrm::RouteParameters::SnappingType::Default;
-        }
-        else if (snapping_str == "any")
-        {
-            params->snapping = osrm::RouteParameters::SnappingType::Any;
-        }
-        else
-        {
-            Nan::ThrowError("'snapping' param must be one of [default, any]");
-            return route_parameters_ptr();
-        }
-    }
-
     bool parsedSuccessfully = parseCommonParameters(obj, params);
     if (!parsedSuccessfully)
     {

include/server/api/match_parameter_grammar.hpp

@@ -42,12 +42,17 @@ struct MatchParametersGrammar final : public RouteParametersGrammar<Iterator, Si
             (qi::uint_ %
              ';')[ph::bind(&engine::api::MatchParameters::timestamps, qi::_r1) = qi::_1];
 
+        waypoints_rule =
+            qi::lit("waypoints=") >
+            (size_t_ % ';')[ph::bind(&engine::api::MatchParameters::waypoints, qi::_r1) = qi::_1];
+
         gaps_type.add("split", engine::api::MatchParameters::GapsType::Split)(
             "ignore", engine::api::MatchParameters::GapsType::Ignore);
 
         root_rule =
             BaseGrammar::query_rule(qi::_r1) > -qi::lit(".json") >
             -('?' > (timestamps_rule(qi::_r1) | BaseGrammar::base_rule(qi::_r1) |
+                     waypoints_rule(qi::_r1) |
                      (qi::lit("gaps=") >
                       gaps_type[ph::bind(&engine::api::MatchParameters::gaps, qi::_r1) = qi::_1]) |
                      (qi::lit("tidy=") >
@@ -58,6 +63,7 @@ struct MatchParametersGrammar final : public RouteParametersGrammar<Iterator, Si
   private:
     qi::rule<Iterator, Signature> root_rule;
     qi::rule<Iterator, Signature> timestamps_rule;
+    qi::rule<Iterator, Signature> waypoints_rule;
     qi::rule<Iterator, std::size_t()> size_t_;
 
     qi::symbols<char, engine::api::MatchParameters::GapsType> gaps_type;

include/server/api/route_parameters_grammar.hpp

@@ -48,14 +48,6 @@ struct RouteParametersGrammar : public BaseParametersGrammar<Iterator, Signature
 
     RouteParametersGrammar(qi::rule<Iterator, Signature> &root_rule_) : BaseGrammar(root_rule_)
     {
-#ifdef BOOST_HAS_LONG_LONG
-        if (std::is_same<std::size_t, unsigned long long>::value)
-            size_t_ = qi::ulong_long;
-        else
-            size_t_ = qi::ulong_;
-#else
-        size_t_ = qi::ulong_;
-#endif
         using AnnotationsType = engine::api::RouteParameters::AnnotationsType;
 
         const auto add_annotation = [](engine::api::RouteParameters &route_parameters,
@@ -78,12 +70,8 @@ struct RouteParametersGrammar : public BaseParametersGrammar<Iterator, Signature
             "distance", AnnotationsType::Distance)("weight", AnnotationsType::Weight)(
             "datasources", AnnotationsType::Datasources)("speed", AnnotationsType::Speed);
 
-        waypoints_rule =
-            qi::lit("waypoints=") >
-            (size_t_ % ';')[ph::bind(&engine::api::RouteParameters::waypoints, qi::_r1) = qi::_1];
-
         base_rule =
-            BaseGrammar::base_rule(qi::_r1) | waypoints_rule(qi::_r1) |
+            BaseGrammar::base_rule(qi::_r1) |
             (qi::lit("steps=") >
              qi::bool_[ph::bind(&engine::api::RouteParameters::steps, qi::_r1) = qi::_1]) |
             (qi::lit("geometries=") >
@@ -106,8 +94,6 @@ struct RouteParametersGrammar : public BaseParametersGrammar<Iterator, Signature
   private:
     qi::rule<Iterator, Signature> root_rule;
     qi::rule<Iterator, Signature> route_rule;
-    qi::rule<Iterator, Signature> waypoints_rule;
-    qi::rule<Iterator, std::size_t()> size_t_;
 
     qi::symbols<char, engine::api::RouteParameters::GeometriesType> geometries_type;
     qi::symbols<char, engine::api::RouteParameters::OverviewType> overview_type;

include/storage/storage_config.hpp

@@ -58,7 +58,6 @@ struct StorageConfig final : IOConfig
                     ".osrm.turn_duration_penalties",
                     ".osrm.datasource_names",
                     ".osrm.names",
-                    ".osrm.timestamp",
                     ".osrm.properties",
                     ".osrm.icd",
                     ".osrm.maneuver_overrides"},

include/storage/view_factory.hpp

@@ -272,11 +272,6 @@ inline auto make_partition_view(const SharedDataIndex &index, const std::string
         level_data_ptr, std::move(partition), std::move(cell_to_children)};
 }
 
-inline auto make_timestamp_view(const SharedDataIndex &index, const std::string &name)
-{
-    return util::StringView(index.GetBlockPtr<char>(name), index.GetBlockEntries(name));
-}
-
 inline auto make_cell_storage_view(const SharedDataIndex &index, const std::string &name)
 {
     auto source_boundary = make_vector_view<NodeID>(index, name + "/source_boundary");

include/util/typedefs.hpp

@@ -79,7 +79,6 @@ using EdgeDistance = float;
 using SegmentWeight = std::uint32_t;
 using SegmentDuration = std::uint32_t;
 using TurnPenalty = std::int16_t; // turn penalty in 100ms units
-using DataTimestamp = std::string;
 
 static const std::size_t INVALID_INDEX = std::numeric_limits<std::size_t>::max();
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "osrm",
-  "version": "5.22.0-customsnapping.2",
+  "version": "5.21.0-customsnapping.2",
   "private": false,
   "description": "The Open Source Routing Machine is a high performance routing engine written in C++14 designed to run on OpenStreetMap data.",
   "dependencies": {

src/engine/plugins/viaroute.cpp

@@ -73,16 +73,6 @@ Status ViaRoutePlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithm
         return Error("InvalidValue", "Invalid coordinate value.", json_result);
     }
 
-    // Error: first and last points should be waypoints
-    if (!route_parameters.waypoints.empty() &&
-        (route_parameters.waypoints[0] != 0 ||
-         route_parameters.waypoints.back() != (route_parameters.coordinates.size() - 1)))
-    {
-        return Error("InvalidValue",
-                     "First and last coordinates must be specified as waypoints.",
-                     json_result);
-    }
-
     if (!CheckAlgorithms(route_parameters, algorithms, json_result))
         return Status::Error;
 
@@ -142,27 +132,7 @@ Status ViaRoutePlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithm
 
     if (routes.routes[0].is_valid())
     {
-        auto collapse_legs = !route_parameters.waypoints.empty();
-        if (collapse_legs)
-        {
-            std::vector<bool> waypoint_legs(route_parameters.coordinates.size(), false);
-            std::for_each(route_parameters.waypoints.begin(),
-                          route_parameters.waypoints.end(),
-                          [&](const std::size_t waypoint_index) {
-                              BOOST_ASSERT(waypoint_index < waypoint_legs.size());
-                              waypoint_legs[waypoint_index] = true;
-                          });
-            // First and last coordinates should always be waypoints
-            // This gets validated earlier, but double-checking here, jic
-            BOOST_ASSERT(waypoint_legs.front());
-            BOOST_ASSERT(waypoint_legs.back());
-            for (std::size_t i = 0; i < routes.routes.size(); i++)
-            {
-                routes.routes[i] = CollapseInternalRouteResult(routes.routes[i], waypoint_legs);
-            }
-        }
-
-        route_api.MakeResponse(routes, start_end_nodes, json_result);
+        route_api.MakeResponse(routes, json_result);
     }
     else
     {

src/extractor/extractor.cpp

@@ -51,7 +51,6 @@
 #include <osmium/handler/node_locations_for_ways.hpp>
 #include <osmium/index/map/flex_mem.hpp>
 #include <osmium/io/any_input.hpp>
-#include <osmium/osm/timestamp.hpp>
 #include <osmium/thread/pool.hpp>
 #include <osmium/visitor.hpp>
 
@@ -426,14 +425,6 @@ Extractor::ParseOSMData(ScriptingEnvironment &scripting_environment,
 
         // write .timestamp data file
         std::string timestamp = header.get("osmosis_replication_timestamp");
-        if (config.data_version == "osmosis")
-        {
-            files::writeTimestamp(config.GetPath(".osrm.timestamp").string(), timestamp);
-        }
-        else
-        {
-            files::writeTimestamp(config.GetPath(".osrm.timestamp").string(), config.data_version);
-        }
         if (timestamp.empty())
         {
             timestamp = "n/a";

src/storage/storage.cpp

@@ -302,7 +302,6 @@ std::vector<std::pair<bool, boost::filesystem::path>> Storage::GetStaticFiles()
         {REQUIRED, config.GetPath(".osrm.ebg_nodes")},
         {REQUIRED, config.GetPath(".osrm.tls")},
         {REQUIRED, config.GetPath(".osrm.tld")},
-        {REQUIRED, config.GetPath(".osrm.timestamp")},
         {REQUIRED, config.GetPath(".osrm.maneuver_overrides")},
         {REQUIRED, config.GetPath(".osrm.edges")},
         {REQUIRED, config.GetPath(".osrm.names")},
@@ -402,17 +401,6 @@ void Storage::PopulateStaticData(const SharedDataIndex &index)
         extractor::files::readNames(config.GetPath(".osrm.names"), name_table);
     }
 
-    // Timestamp mark
-    {
-        auto timestamp_ref = make_timestamp_view(index, "/common/timestamp");
-        std::string ts;
-        extractor::files::readTimestamp(config.GetPath(".osrm.timestamp"), ts);
-        if (!ts.empty())
-        {
-            memcpy(const_cast<char *>(timestamp_ref.data()), ts.data(), ts.size());
-        }
-    }
-
     // Turn lane data
     {
         auto turn_lane_data = make_lane_data_view(index, "/common/turn_lanes");

src/tools/extract.cpp

@@ -43,10 +43,6 @@ return_code parseArguments(int argc,
         boost::program_options::value<boost::filesystem::path>(&extractor_config.profile_path)
             ->default_value("profiles/car.lua"),
         "Path to LUA routing profile")(
-        "data_version,d",
-        boost::program_options::value<std::string>(&extractor_config.data_version)
-            ->default_value(""),
-        "Data version. Leave blank to avoid. osmosis - to get timestamp from file")(
         "threads,t",
         boost::program_options::value<unsigned int>(&extractor_config.requested_num_threads)
             ->default_value(tbb::task_scheduler_init::default_num_threads()),

test/nodejs/match.js

@@ -319,30 +319,6 @@ test('match: throws on invalid waypoints values, waypoints must correspond with
         'Waypoints must correspond with the index of an input coordinate');
 });
 
-test('match: throws on invalid waypoints values, waypoints must be an array', function (assert) {
-    assert.plan(1);
-    var osrm = new OSRM(data_path);
-    var options = {
-        steps: true,
-        coordinates: three_test_coordinates,
-        waypoints: "string"
-    };
-    assert.throws(function () { osrm.match(options, function (err, response) { console.log(err); }); },
-        'Waypoints must be an array of integers corresponding to the input coordinates.');
-});
-
-test('match: throws on invalid waypoints values, waypoints must be an array of integers', function (assert) {
-    assert.plan(1);
-    var osrm = new OSRM(data_path);
-    var options = {
-        steps: true,
-        coordinates: three_test_coordinates,
-        waypoints: [0,1,"string"]
-    };
-    assert.throws(function () { osrm.match(options, function (err, response) { console.log(err); }); },
-        'Waypoint values must be an array of integers');
-});
-
 test('match: error on split trace', function(assert) {
     assert.plan(1);
     var osrm = new OSRM(data_path);

test/nodejs/route.js

@@ -606,91 +606,6 @@ test('route: route in Monaco without motorways', function(assert) {
     });
 });
 
-
-test('route: throws on invalid waypoints values needs at least two', function (assert) {
-    assert.plan(1);
-    var osrm = new OSRM(monaco_path);
-    var options = {
-        steps: true,
-        coordinates: three_test_coordinates,
-        waypoints: [0]
-    };
-    assert.throws(function () { osrm.route(options, function (err, response) { }); },
-        'At least two waypoints must be provided');
-});
-
-test('route: throws on invalid waypoints values, needs first and last coordinate indices', function (assert) {
-    assert.plan(1);
-    var osrm = new OSRM(monaco_path);
-    var options = {
-        steps: true,
-        coordinates: three_test_coordinates,
-        waypoints: [1, 2]
-    };
-    assert.throws(function () { osrm.route(options, function (err, response) { console.log(err); }); },
-        'First and last waypoints values must correspond to first and last coordinate indices');
-});
-
-test('route: throws on invalid waypoints values, order matters', function (assert) {
-    assert.plan(1);
-    var osrm = new OSRM(monaco_path);
-    var options = {
-        steps: true,
-        coordinates: three_test_coordinates,
-        waypoints: [2, 0]
-    };
-    assert.throws(function () { osrm.route(options, function (err, response) { console.log(err); }); },
-        'First and last waypoints values must correspond to first and last coordinate indices');
-});
-
-test('route: throws on invalid waypoints values, waypoints must correspond with a coordinate index', function (assert) {
-    assert.plan(1);
-    var osrm = new OSRM(monaco_path);
-    var options = {
-        steps: true,
-        coordinates: three_test_coordinates,
-        waypoints: [0, 3, 2]
-    };
-    assert.throws(function () { osrm.route(options, function (err, response) { console.log(err); }); },
-        'Waypoints must correspond with the index of an input coordinate');
-});
-
-test('route: throws on invalid waypoints values, waypoints must be an array', function (assert) {
-    assert.plan(1);
-    var osrm = new OSRM(monaco_path);
-    var options = {
-        steps: true,
-        coordinates: three_test_coordinates,
-        waypoints: "string"
-    };
-    assert.throws(function () { osrm.route(options, function (err, response) { console.log(err); }); },
-        'Waypoints must be an array of integers corresponding to the input coordinates.');
-});
-
-test('route: throws on invalid waypoints values, waypoints must be an array of integers', function (assert) {
-    assert.plan(1);
-    var osrm = new OSRM(monaco_path);
-    var options = {
-        steps: true,
-        coordinates: three_test_coordinates,
-        waypoints: [0,1,"string"]
-    };
-    assert.throws(function () { osrm.route(options, function (err, response) { console.log(err); }); },
-        'Waypoint values must be an array of integers');
-});
-
-test('route: throws on invalid waypoints values, waypoints must be an array of integers in increasing order', function (assert) {
-    assert.plan(1);
-    var osrm = new OSRM(monaco_path);
-    var options = {
-        steps: true,
-        coordinates: three_test_coordinates.concat(three_test_coordinates),
-        waypoints: [0,2,1,5]
-    };
-    assert.throws(function () { osrm.route(options, function (err, response) { console.error(`response: ${response}`); console.error(`error: ${err}`); }); },
-        /Waypoints must be supplied in increasing order/);
-});
-
 test('route: throws on invalid snapping values', function (assert) {
     assert.plan(1);
     var osrm = new OSRM(monaco_path);

test/nodejs/table.js

@@ -48,6 +48,21 @@ test('table: test annotations paramater combination', function(assert) {
     });
 });
 
+test('table: snapping parameter passed through OK', function(assert) {
+    assert.plan(2);
+    var osrm = new OSRM(data_path);
+    var options = {
+        coordinates: [[7.448205209414596,43.754001097311544],[7.447122039202185,43.75306156811368]],
+        annotations: ['duration', 'distance'],
+        snapping: 'any'
+    };
+    console.log(options);
+    osrm.table(options, function(err, result) {
+        assert.ifError(err);
+        assert.equal(Math.round(result.distances[0][1] * 10), 1315); // Round it to nearest 0.1m to eliminate floating point comparison error
+    });
+});
+
 test('table: returns buffer', function(assert) {
     assert.plan(3);
     var osrm = new OSRM(data_path);

unit_tests/engine/offline_facade.cpp

@@ -345,7 +345,6 @@ class ContiguousInternalMemoryDataFacade<routing_algorithms::offline::Algorithm>
     StringView GetDestinationsForID(const NameID /*id*/) const override { return StringView{}; }
     StringView GetExitsForID(const NameID /*id*/) const override { return StringView{}; }
     bool GetContinueStraightDefault() const override { return false; }
-    std::string GetTimestamp() const override { return ""; }
     double GetMapMatchingMaxSpeed() const override { return 0; }
     const char *GetWeightName() const override { return ""; }
     unsigned GetWeightPrecision() const override { return 0; }

unit_tests/mocks/mock_datafacade.hpp

@@ -10,6 +10,7 @@
 #include "extractor/turn_lane_types.hpp"
 #include "guidance/turn_bearing.hpp"
 #include "guidance/turn_instruction.hpp"
+#include "guidance/turn_instruction.hpp"
 
 #include "engine/algorithm.hpp"
 #include "engine/datafacade/algorithm_datafacade.hpp"
@@ -53,7 +54,6 @@ class MockBaseDataFacade : public engine::datafacade::BaseDataFacade
     {
         return 0;
     }
-    std::string GetTimestamp() const override { return ""; }
     NodeForwardRange GetUncompressedForwardGeometry(const EdgeID /* id */) const override
     {
         static NodeID data[] = {0, 1, 2, 3};