bump to rc 4

Include information on estimates in table response (#5259 )
* Revert "Remove estimated_cells value in the response." This reverts commit 364e35af06. * Update changelog. * fix linting * adjust fallback_speed check * change [].includes to [].indexOf !== -1 for compatibility with node 4 * change param name * more cuke tests * fix formatting
2018-12-11 13:20:18 -05:00 · 2018-12-11 13:17:34 -05:00 · 2018-12-11 13:16:44 -05:00 · 2018-12-10 22:56:55 -05:00 · 2018-12-10 22:48:57 -05:00 · 2018-12-10 17:37:09 -05:00
2005 changed files with 50776 additions and 566781 deletions
@@ -1,2 +0,0 @@
-features/support/flatbuffers.js
-features/support/fbresult_generated.js
@@ -1,588 +0,0 @@
-name: osrm-backend CI
-on:
-  push:
-    branches:
-      - master
-    tags:
-      - v[1-9]+.[0-9]+.[0-9]+
-      - v[1-9]+.[0-9]+.[0-9]+-[0-9a-zA-Z]+
-      - v[1-9]+.[0-9]+-[0-9a-zA-Z]+
-  pull_request:
-    branches:
-      - master
-
-env:
-  CCACHE_TEMPDIR: /tmp/.ccache-temp
-  CCACHE_COMPRESS: 1
-  CASHER_TIME_OUT: 599 # one second less than 10m to avoid 10m timeout error: https://github.com/Project-OSRM/osrm-backend/issues/2742
-  CCACHE_VERSION: 3.3.1
-  CMAKE_VERSION: 3.7.2
-  ENABLE_NODE_BINDINGS: "ON"
-
-jobs:
-  format-taginfo-docs:
-    runs-on: ubuntu-18.04
-    steps:
-    - uses: actions/checkout@v2
-    - name: Use Node.js
-      uses: actions/setup-node@v2
-      with:
-        node-version: 10
-    - name: Enable Node.js cache
-      uses: actions/cache@v2
-      with:
-        path: ~/.npm
-        key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
-        restore-keys: |
-          ${{ runner.os }}-node-
-    - name: Prepare environment
-      run: |
-        npm ci --ignore-scripts
-        export MASON=${GITHUB_WORKSPACE}/scripts/mason.sh
-        ${MASON} install clang-format 10.0.0
-        echo "$(${MASON} prefix clang-format 10.0.0)/bin" >> $GITHUB_PATH
-    - name: Run checks
-      run: |
-        ./scripts/check_taginfo.py taginfo.json profiles/car.lua
-        ./scripts/format.sh && ./scripts/error_on_dirty.sh
-        node ./scripts/validate_changelog.js
-        # See issue 4043
-        #- npm run docs && ./scripts/error_on_dirty.sh
-
-  build-test-publish:
-    needs: format-taginfo-docs
-    strategy:
-      matrix:
-        include:
-          - name: gcc-7-debug-cov
-            continue-on-error: false
-            node: 10
-            runs-on: ubuntu-18.04
-            BUILD_TOOLS: ON
-            BUILD_TYPE: Debug
-            CCOMPILER: gcc-7
-            CUCUMBER_TIMEOUT: 20000
-            CXXCOMPILER: g++-7
-            ENABLE_COVERAGE: ON
-
-          - name: gcc-7-debug-asan
-            continue-on-error: false
-            node: 10
-            runs-on: ubuntu-18.04
-            BUILD_TOOLS: ON
-            BUILD_TYPE: Debug
-            CCOMPILER: gcc-7
-            CUCUMBER_TIMEOUT: 20000
-            CXXCOMPILER: g++-7
-            ENABLE_SANITIZER: ON
-            TARGET_ARCH: x86_64-asan
-
-          - name: clang-5.0-debug
-            continue-on-error: false
-            node: 10
-            runs-on: ubuntu-18.04
-            BUILD_TOOLS: ON
-            BUILD_TYPE: Debug
-            CLANG_VERSION: 5.0.0
-            CUCUMBER_TIMEOUT: 60000
-
-          - name: mason-linux-debug-asan
-            continue-on-error: false
-            node: 10
-            runs-on: ubuntu-18.04
-            BUILD_TOOLS: ON
-            BUILD_TYPE: Release
-            CLANG_VERSION: 5.0.0
-            ENABLE_MASON: ON
-            ENABLE_SANITIZER: ON
-
-          - name: mason-linux-release
-            continue-on-error: false
-            node: 10
-            runs-on: ubuntu-18.04
-            BUILD_TOOLS: ON
-            BUILD_TYPE: Release
-            CLANG_VERSION: 5.0.0
-            ENABLE_MASON: ON
-
-          - name: gcc-9-release
-            continue-on-error: false
-            node: 10
-            runs-on: ubuntu-18.04
-            BUILD_TOOLS: ON
-            BUILD_TYPE: Release
-            CCOMPILER: gcc-9
-            CXXCOMPILER: g++-9
-            CXXFLAGS: -Wno-cast-function-type
-
-          - name: gcc-8-release
-            continue-on-error: false
-            node: 10
-            runs-on: ubuntu-18.04
-            BUILD_TOOLS: ON
-            BUILD_TYPE: Release
-            CCOMPILER: gcc-8
-            CXXCOMPILER: g++-8
-            CXXFLAGS: -Wno-cast-function-type
-
-          - name: gcc-7-release
-            continue-on-error: false
-            node: 10
-            runs-on: ubuntu-18.04
-            BUILD_TOOLS: ON
-            BUILD_TYPE: Release
-            CCOMPILER: gcc-7
-            CXXCOMPILER: g++-7
-
-          - name: gcc-7-release-i686
-            continue-on-error: false
-            node: 10
-            runs-on: ubuntu-18.04
-            BUILD_TOOLS: ON
-            BUILD_TYPE: Release
-            CCOMPILER: gcc-7
-            CFLAGS: "-m32 -msse2 -mfpmath=sse"
-            CXXCOMPILER: g++-7
-            CXXFLAGS: "-m32 -msse2 -mfpmath=sse"
-            TARGET_ARCH: i686
-
-          - name: gcc-5-release
-            continue-on-error: false
-            node: 10
-            runs-on: ubuntu-18.04
-            BUILD_TOOLS: ON
-            BUILD_TYPE: Release
-            CCOMPILER: gcc-5
-            CXXCOMPILER: g++-5
-
-          - name: gcc-6-release
-            continue-on-error: false
-            node: 10
-            runs-on: ubuntu-18.04
-            BUILD_TOOLS: ON
-            BUILD_TYPE: Release
-            CCOMPILER: gcc-6
-            CXXCOMPILER: g++-6
-
-          - name: mason-osx-release-node-10
-            build_node_package: true
-            continue-on-error: false
-            node: 10
-            runs-on: macos-10.15
-            BUILD_TOOLS: ON
-            BUILD_TYPE: Release
-            CCOMPILER: clang
-            CXXCOMPILER: clang++
-            CUCUMBER_TIMEOUT: 60000
-            ENABLE_ASSERTIONS: ON
-            ENABLE_MASON: ON
-
-          - name: mason-osx-release-node-12
-            build_node_package: true
-            continue-on-error: false
-            node: 12
-            runs-on: macos-10.15
-            BUILD_TOOLS: ON
-            BUILD_TYPE: Release
-            CCOMPILER: clang
-            CXXCOMPILER: clang++
-            CUCUMBER_TIMEOUT: 60000
-            ENABLE_ASSERTIONS: ON
-            ENABLE_MASON: ON
-
-          - name: mason-osx-release-node-14
-            build_node_package: true
-            continue-on-error: false
-            node: 14
-            runs-on: macos-10.15
-            BUILD_TOOLS: ON
-            BUILD_TYPE: Release
-            CCOMPILER: clang
-            CXXCOMPILER: clang++
-            CUCUMBER_TIMEOUT: 60000
-            ENABLE_ASSERTIONS: ON
-            ENABLE_MASON: ON
-
-          - name: gcc-7-release-shared
-            continue-on-error: false
-            node: 10
-            runs-on: ubuntu-18.04
-            BUILD_TOOLS: ON
-            BUILD_TYPE: Release
-            BUILD_SHARED_LIBS: ON
-            CCOMPILER: gcc-7
-            CXXCOMPILER: g++-7
-
-          - name: node-14-mason-linux-release
-            build_node_package: true
-            continue-on-error: false
-            node: 14
-            runs-on: ubuntu-18.04
-            BUILD_TYPE: Release
-            CLANG_VERSION: 5.0.0
-            ENABLE_GLIBC_WORKAROUND: ON
-            ENABLE_MASON: ON
-            NODE_PACKAGE_TESTS_ONLY: ON
-
-          - name: node-14-mason-linux-debug
-            build_node_package: true
-            continue-on-error: false
-            node: 14
-            runs-on: ubuntu-18.04
-            BUILD_TYPE: Debug
-            CLANG_VERSION: 5.0.0
-            ENABLE_GLIBC_WORKAROUND: ON
-            ENABLE_MASON: ON
-            NODE_PACKAGE_TESTS_ONLY: ON
-
-          - name: node-12-mason-linux-release
-            build_node_package: true
-            continue-on-error: false
-            node: 12
-            runs-on: ubuntu-18.04
-            BUILD_TYPE: Release
-            CLANG_VERSION: 5.0.0
-            ENABLE_GLIBC_WORKAROUND: ON
-            ENABLE_MASON: ON
-            NODE_PACKAGE_TESTS_ONLY: ON
-
-          - name: node-12-mason-linux-debug
-            build_node_package: true
-            continue-on-error: false
-            node: 12
-            runs-on: ubuntu-18.04
-            BUILD_TYPE: Debug
-            CLANG_VERSION: 5.0.0
-            ENABLE_GLIBC_WORKAROUND: ON
-            ENABLE_MASON: ON
-            NODE_PACKAGE_TESTS_ONLY: ON
-
-          - name: node-10-mason-linux-release
-            build_node_package: true
-            continue-on-error: false
-            node: 10
-            runs-on: ubuntu-18.04
-            BUILD_TYPE: Release
-            CLANG_VERSION: 5.0.0
-            ENABLE_GLIBC_WORKAROUND: ON
-            ENABLE_MASON: ON
-            NODE_PACKAGE_TESTS_ONLY: ON
-
-          - name: node-10-mason-linux-debug
-            build_node_package: true
-            continue-on-error: false
-            node: 10
-            runs-on: ubuntu-18.04
-            BUILD_TYPE: Debug
-            CLANG_VERSION: 5.0.0
-            ENABLE_GLIBC_WORKAROUND: ON
-            ENABLE_MASON: ON
-            NODE_PACKAGE_TESTS_ONLY: ON
-
-          - name: mason-osx-release-node-latest
-            build_node_package: true
-            continue-on-error: true
-            # TODO: Use node 'latest' once supported: https://github.com/actions/setup-node/issues/257
-            node: 16
-            runs-on: macos-10.15
-            BUILD_TYPE: Release
-            CCOMPILER: clang
-            CXXCOMPILER: clang++
-            CUCUMBER_TIMEOUT: 60000
-            ENABLE_ASSERTIONS: ON
-            ENABLE_MASON: ON
-
-          - name: node-latest-mason-linux-release
-            build_node_package: true
-            continue-on-error: true
-            # TODO: Use node 'latest' once supported: https://github.com/actions/setup-node/issues/257
-            node: 16
-            runs-on: ubuntu-18.04
-            BUILD_TYPE: Release
-            CLANG_VERSION: 5.0.0
-            ENABLE_GLIBC_WORKAROUND: ON
-            ENABLE_MASON: ON
-            NODE_PACKAGE_TESTS_ONLY: ON
-
-          - name: node-latest-mason-linux-debug
-            build_node_package: true
-            continue-on-error: true
-            # TODO: Use node 'latest' once supported: https://github.com/actions/setup-node/issues/257
-            node: 16
-            runs-on: ubuntu-18.04
-            BUILD_TYPE: Debug
-            CLANG_VERSION: 5.0.0
-            ENABLE_GLIBC_WORKAROUND: ON
-            ENABLE_MASON: ON
-            NODE_PACKAGE_TESTS_ONLY: ON
-
-          - name: mason-osx-release-node-lts
-            build_node_package: true
-            continue-on-error: true
-            node: "lts/*"
-            runs-on: macos-10.15
-            BUILD_TYPE: Release
-            CCOMPILER: clang
-            CXXCOMPILER: clang++
-            CUCUMBER_TIMEOUT: 60000
-            ENABLE_ASSERTIONS: ON
-            ENABLE_MASON: ON
-
-          - name: node-lts-mason-linux-release
-            build_node_package: true
-            continue-on-error: true
-            node: "lts/*"
-            runs-on: ubuntu-18.04
-            BUILD_TYPE: Release
-            CLANG_VERSION: 5.0.0
-            ENABLE_GLIBC_WORKAROUND: ON
-            ENABLE_MASON: ON
-            NODE_PACKAGE_TESTS_ONLY: ON
-
-          - name: node-lts-mason-linux-debug
-            build_node_package: true
-            continue-on-error: true
-            node: "lts/*"
-            runs-on: ubuntu-18.04
-            BUILD_TYPE: Debug
-            CLANG_VERSION: 5.0.0
-            ENABLE_GLIBC_WORKAROUND: ON
-            ENABLE_MASON: ON
-            NODE_PACKAGE_TESTS_ONLY: ON
-
-
-    name: ${{ matrix.name}}
-    continue-on-error: ${{ matrix.continue-on-error }}
-    runs-on: ${{ matrix.runs-on }}
-    env:
-      BUILD_TOOLS: ${{ matrix.BUILD_TOOLS }}
-      BUILD_TYPE: ${{ matrix.BUILD_TYPE }}
-      BUILD_SHARED_LIBS: ${{ matrix.BUILD_SHARED_LIBS }}
-      CCOMPILER: ${{ matrix.CCOMPILER }}
-      CFLAGS: ${{ matrix.CFLAGS }}
-      CLANG_VERSION: ${{ matrix.CLANG_VERSION }}
-      CUCUMBER_TIMEOUT: ${{ matrix.CUCUMBER_TIMEOUT }}
-      CXXCOMPILER: ${{ matrix.CXXCOMPILER }}
-      CXXFLAGS: ${{ matrix.CXXFLAGS }}
-      ENABLE_ASSERTIONS: ${{ matrix.ENABLE_ASSERTIONS }}
-      ENABLE_COVERAGE: ${{ matrix.ENABLE_COVERAGE }}
-      ENABLE_GLIBC_WORKAROUND: ${{ matrix.ENABLE_GLIBC_WORKAROUND }}
-      ENABLE_MASON: ${{ matrix.ENABLE_MASON }}
-      ENABLE_SANITIZER: ${{ matrix.ENABLE_SANITIZER }}
-      NODE_PACKAGE_TESTS_ONLY: ${{ matrix.NODE_PACKAGE_TESTS_ONLY }}
-      TARGET_ARCH: ${{ matrix.TARGET_ARCH }}
-    steps:
-    - uses: actions/checkout@v2
-
-    - name: Use Node.js
-      uses: actions/setup-node@v2
-      with:
-        node-version: ${{ matrix.node }}
-    - name: Enable Node.js cache
-      uses: actions/cache@v2
-      with:
-        path: ~/.npm
-        key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
-        restore-keys: |
-          ${{ runner.os }}-node-
-    - name: Enable compiler cache
-      uses: actions/cache@v2
-      with:
-        path: ~/.ccache
-        key: ccache-${{ matrix.name }}-${{ github.sha }}
-        restore-keys: |
-          ccache-${{ matrix.name }}-
-    - name: Enable test cache
-      uses: actions/cache@v2
-      with:
-        path: ${{github.workspace}}/test/cache
-        key: test-${{ matrix.name }}-${{ github.sha }}
-        restore-keys: |
-          test-${{ matrix.name }}-
-
-    - name: Prepare environment
-      run: |
-        PACKAGE_JSON_VERSION=$(node -e "console.log(require('./package.json').version)")
-        echo PUBLISH=$([[ "${GITHUB_REF:-}" == "refs/tags/v${PACKAGE_JSON_VERSION}" ]] && echo "On" || echo "Off") >> $GITHUB_ENV
-
-        echo "OSRM_INSTALL_DIR=${GITHUB_WORKSPACE}/install-osrm" >> $GITHUB_ENV
-        echo "OSRM_BUILD_DIR=${GITHUB_WORKSPACE}/build-osrm" >> $GITHUB_ENV
-
-        if [[ "$ENABLE_SANITIZER" == 'ON' ]]; then
-          # We can only set this after checkout once we know the workspace directory
-          echo "LSAN_OPTIONS=suppressions=${GITHUB_WORKSPACE}/scripts/ci/leaksanitizer.conf" >> $GITHUB_ENV
-        fi
-
-        if [[ "${RUNNER_OS}" == "Linux" ]]; then
-          echo "JOBS=$((`nproc` + 1))" >>  $GITHUB_ENV
-          export MASON_OS=linux
-        elif [[ "${RUNNER_OS}" == "macOS" ]]; then
-          echo "JOBS=$((`sysctl -n hw.ncpu` + 1))" >>  $GITHUB_ENV
-          sudo mdutil -i off /
-          export MASON_OS=osx
-        fi
-
-        echo "MASON=${GITHUB_WORKSPACE}/scripts/mason.sh" >> $GITHUB_ENV
-        echo "CMAKE_URL=https://mason-binaries.s3.amazonaws.com/${MASON_OS}-x86_64/cmake/${CMAKE_VERSION}.tar.gz" >> $GITHUB_ENV
-        echo "CMAKE_DIR=mason_packages/${MASON_OS}-x86_64/cmake/${CMAKE_VERSION}}" >> $GITHUB_ENV
-
-
-    - name: Install dev dependencies
-      run: |
-        # CMake
-        mkdir -p ${CMAKE_DIR}
-        wget --quiet -O - ${CMAKE_URL} | tar --strip-components=1 -xz -C ${CMAKE_DIR}
-        echo "${CMAKE_DIR}/bin" >> $GITHUB_PATH
-
-        # TBB
-        ${MASON} install tbb 2017_U7
-        echo "LD_LIBRARY_PATH=$(${MASON} prefix tbb 2017_U7)/lib/:${LD_LIBRARY_PATH}" >> $GITHUB_ENV
-
-        # ccache
-        ${MASON} install ccache ${CCACHE_VERSION}
-        echo "$(${MASON} prefix ccache ${CCACHE_VERSION})/bin" >> $GITHUB_PATH
-
-        # clang
-        if [[ -n ${CLANG_VERSION} ]]; then
-          echo "CCOMPILER=clang" >> $GITHUB_ENV
-          echo "CXXCOMPILER=clang++" >> $GITHUB_ENV
-          ${MASON} install clang++ ${CLANG_VERSION}
-          echo "$(${MASON} prefix clang++ ${CLANG_VERSION})/bin" >> $GITHUB_PATH
-          # we only enable lto for release builds
-          # and therefore don't need to us ld.gold or llvm tools for linking
-          # for debug builds
-          if [[ ${BUILD_TYPE} == 'Release' ]]; then
-            ${MASON} install binutils 2.27
-            echo "$(${MASON} prefix binutils 2.27)/bin" >> $GITHUB_PATH
-          fi
-        fi
-
-        # Linux dev packages
-        if [ "${TARGET_ARCH}" != "i686" ] && [ "${ENABLE_MASON}" != "ON" ]; then
-          sudo add-apt-repository ppa:ubuntu-toolchain-r/test -y
-          sudo apt-get update -y
-          sudo apt-get install -y libbz2-dev libxml2-dev libzip-dev liblua5.2-dev libtbb-dev libboost-all-dev
-          if [[ -z "${CLANG_VERSION}" ]]; then
-            sudo apt-get install -y ${CXXCOMPILER}
-          fi
-          if [[ "${ENABLE_COVERAGE}" == "ON" ]]; then
-            sudo apt-get install -y lcov
-          fi
-        elif [[ $TARGET_ARCH == "i686" ]]; then
-          source ./scripts/ci/before_install.${TARGET_ARCH}.sh
-        fi
-
-    - name: Prepare build
-      run: |
-        mkdir ${OSRM_BUILD_DIR}
-        ccache --max-size=256M
-        npm ci --ignore-scripts
-        if [[ "${ENABLE_COVERAGE}" == "ON" ]]; then
-          lcov --directory . --zerocounters # clean cached files
-        fi
-        echo "CC=${CCOMPILER}" >> $GITHUB_ENV
-        echo "CXX=${CXXCOMPILER}" >> $GITHUB_ENV
-
-    - name: Build and install OSRM
-      run: |
-        echo "Using ${JOBS} jobs"
-        pushd ${OSRM_BUILD_DIR}
-        cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
-                 -DENABLE_MASON=${ENABLE_MASON:-OFF} \
-                 -DENABLE_ASSERTIONS=${ENABLE_ASSERTIONS:-OFF}} \
-                 -DBUILD_SHARED_LIBS=${BUILD_SHARED_LIBS:-OFF} \
-                 -DENABLE_COVERAGE=${ENABLE_COVERAGE:-OFF} \
-                 -DENABLE_NODE_BINDINGS=${ENABLE_NODE_BINDINGS:-OFF} \
-                 -DENABLE_SANITIZER=${ENABLE_SANITIZER:-OFF} \
-                 -DBUILD_TOOLS=${BUILD_TOOLS:-OFF} \
-                 -DENABLE_CCACHE=ON \
-                 -DCMAKE_INSTALL_PREFIX=${OSRM_INSTALL_DIR} \
-                 -DENABLE_GLIBC_WORKAROUND=${ENABLE_GLIBC_WORKAROUND:-OFF}
-        make --jobs=${JOBS}
-
-        if [[ "${NODE_PACKAGE_TESTS_ONLY}" != "ON" ]]; then
-          make tests --jobs=${JOBS}
-          make benchmarks --jobs=${JOBS}
-          ccache -s
-          sudo make install
-          if [[ "${RUNNER_OS}" == "Linux" ]]; then
-            echo "LD_LIBRARY_PATH=$LD_LIBRARY_PATH:${OSRM_INSTALL_DIR}/lib" >> $GITHUB_ENV
-          fi
-          echo "PKG_CONFIG_PATH=${OSRM_INSTALL_DIR}/lib/pkgconfig" >> $GITHUB_ENV
-        fi
-        popd
-    - name: Build example
-      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY != 'ON' }}
-      run: |
-        mkdir example/build && pushd example/build
-        cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE}
-        make --jobs=${JOBS}
-        popd
-
-    - name: Run all tests
-      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY != 'ON' }}
-      run: |
-        make -C test/data benchmark
-
-        # macOS SIP strips the linker path. Reset this inside the running shell
-        export LD_LIBRARY_PATH=${{ env.LD_LIBRARY_PATH }}
-        ./example/build/osrm-example test/data/mld/monaco.osrm
-
-        # All tests assume to be run from the build directory
-        pushd ${OSRM_BUILD_DIR}
-        ./unit_tests/library-tests
-        ./unit_tests/extractor-tests
-        ./unit_tests/contractor-tests
-        ./unit_tests/engine-tests
-        ./unit_tests/util-tests
-        ./unit_tests/server-tests
-        ./unit_tests/partitioner-tests
-        ./unit_tests/customizer-tests
-        if [ -z "${ENABLE_SANITIZER}" ] && [ "$TARGET_ARCH" != "i686" ]; then
-          npm run nodejs-tests
-        fi
-        popd
-        npm test
-    - name: Run Node package tests only
-      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' }}
-      run: |
-        npm run nodejs-tests
-
-    - name: Generate code coverage
-      if: ${{ matrix.ENABLE_COVERAGE == 'ON' }}
-      run: |
-        lcov --directory . --capture --output-file coverage.info # capture coverage info
-        lcov --remove coverage.info '/usr/*' --output-file coverage.info # filter out system
-        lcov --list coverage.info #debug info
-        # Uploading report to CodeCov
-    - name: Upload code coverage
-      if: ${{ matrix.ENABLE_COVERAGE == 'ON' }}
-      uses: codecov/codecov-action@v1
-      with:
-        files: coverage.info
-        name: codecov-osrm-backend
-        fail_ci_if_error: true
-        verbose: true
-
-    - name: Build Node package
-      if: ${{ matrix.build_node_package && env.PUBLISH == 'On' }}
-      run: ./scripts/ci/node_package.sh
-    - name: Publish Node package
-      if: ${{ matrix.build_node_package && env.PUBLISH == 'On' }}
-      uses: ncipollo/release-action@v1
-      with:
-        allowUpdates: true
-        artifactErrorsFailBuild: true
-        artifacts: build/stage/**/*.tar.gz
-        omitBody: true
-        omitBodyDuringUpdate: true
-        omitName: true
-        omitNameDuringUpdate: true
-        replacesArtifacts: true
-        token: ${{ secrets.GITHUB_TOKEN }}
-
-  ci-complete:
-    runs-on: ubuntu-18.04
-    needs: build-test-publish
-    steps:
-    - run: echo "CI complete"
@@ -49,7 +49,7 @@ Thumbs.db
 /_build*
 /build/
 /example/build/
-/test/data/monaco.osrm*
+/test/data/monaco*
 /test/data/ch
 /test/data/corech
 /test/data/mld
@@ -68,9 +68,11 @@ Thumbs.db
 /*.local.bat
 /CMakeSettings.json

-# Jetbrains related files #
-###########################
-.idea/
+# stxxl related files #
+#######################
+.stxxl
+stxxl.log
+stxxl.errlog

 # Compiled Binary Files #
 ####################################
@@ -0,0 +1,441 @@
+language: cpp
+
+git:
+  depth: 10
+
+# sudo:required is needed for trusty images
+sudo: required
+dist: trusty
+
+notifications:
+  email: false
+
+branches:
+  only:
+    - master
+    - "5.20.1"
+    # enable building tags
+    - /^v\d+\.\d+(\.\d+)?(-\S*)?$/
+
+cache:
+  yarn: true
+  ccache: true
+  apt: true
+  directories:
+    - test/cache
+
+env:
+  global:
+   - secure: "hk+32aXXF5t1ApaM2Wjqooz3dx1si907L87WRMkO47WlpJmUUU/Ye+MJk9sViH8MdhOcceocVAmdYl5/WFWOIbDWNlBya9QvXDZyIu2KIre/0QyOCTZbrsif8paBXKIO5O/R4OTvIZ8rvWZsadBdmAT9GSbDhih6FzqXAEgeIYQ="
+   - secure: "VE+cFkseFwW4jK6XwkP0yW3h4DixPJ8+Eb3yKcchGZ5iIJxlZ/8i1vKHYxadgPRwSYwPSB14tF70xj2OmiT2keGzZUfphmPXinBaLEhYk+Bde+GZZkoSl5ND109I/LcyNr0nG9dDgtV6pkvFchgchpyP9JnVOOS0+crEZlAz0RE="
+   - CCACHE_TEMPDIR=/tmp/.ccache-temp
+   - CCACHE_COMPRESS=1
+   - CASHER_TIME_OUT=599 # one second less than 10m to avoid 10m timeout error: https://github.com/Project-OSRM/osrm-backend/issues/2742
+   - CCACHE_VERSION=3.3.1
+   - CMAKE_VERSION=3.7.2
+   - MASON="$(pwd)/scripts/mason.sh"
+   - ENABLE_NODE_BINDINGS=On
+   - NODE="4"
+
+matrix:
+  fast_finish: true
+
+  # We override the compiler names here to yield better ccache behavior, which uses this as key
+  include:
+
+    # Debug Builds
+    - os: linux
+      compiler: "format-taginfo-docs"
+      env: NODE=6
+      sudo: false
+      before_install:
+      install:
+        - source $NVM_DIR/nvm.sh
+        - nvm install $NODE
+        - nvm use $NODE
+        - npm --version
+        - npm install --ignore-scripts
+        - npm link --ignore-scripts
+      script:
+        - ./scripts/check_taginfo.py taginfo.json profiles/car.lua
+        - ${MASON} install clang-format 3.8.1
+        - PATH=$(${MASON} prefix clang-format 3.8.1)/bin:${PATH} ./scripts/format.sh && ./scripts/error_on_dirty.sh
+        - node ./scripts/validate_changelog.js
+        # See issue 4043
+        #- npm run docs && ./scripts/error_on_dirty.sh
+      after_success:
+
+    - os: linux
+      compiler: "gcc-7-debug-cov"
+      addons: &gcc7
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-7', 'libbz2-dev', 'libxml2-dev', 'libzip-dev', 'liblua5.2-dev', 'libtbb-dev', 'libboost-all-dev', 'lcov']
+      env: CCOMPILER='gcc-7' CXXCOMPILER='g++-7' BUILD_TYPE='Debug' ENABLE_COVERAGE=ON CUCUMBER_TIMEOUT=20000
+      before_script:
+        - cd ${TRAVIS_BUILD_DIR}
+        - lcov --directory . --zerocounters # clean cached da files
+      after_success:
+        # Creating report
+        - cd ${TRAVIS_BUILD_DIR}
+        - lcov --directory . --capture --output-file coverage.info # capture coverage info
+        - lcov --remove coverage.info '/usr/*' --output-file coverage.info # filter out system
+        - lcov --list coverage.info #debug info
+        # Uploading report to CodeCov
+        - bash <(curl -s https://codecov.io/bash) || echo "Codecov did not collect coverage reports"
+
+    - os: linux
+      compiler: "gcc-7-debug-asan"
+      addons: &gcc7
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-7', 'libbz2-dev', 'libxml2-dev', 'libzip-dev', 'liblua5.2-dev', 'libtbb-dev', 'libboost-all-dev']
+      env: CCOMPILER='gcc-7' CXXCOMPILER='g++-7' BUILD_TYPE='Debug' TARGET_ARCH='x86_64-asan' ENABLE_SANITIZER=ON CUCUMBER_TIMEOUT=20000 LSAN_OPTIONS="suppressions=$TRAVIS_BUILD_DIR/scripts/travis/leaksanitizer.conf"
+
+    - os: linux
+      compiler: "clang-5.0-debug"
+      addons: &clang50
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['libstdc++-5-dev', 'libbz2-dev', 'libxml2-dev', 'libzip-dev', 'liblua5.2-dev', 'libtbb-dev', 'libboost-all-dev']
+      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Debug' CUCUMBER_TIMEOUT=60000
+
+    - os: linux
+      compiler: "mason-linux-debug-asan"
+      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_SANITIZER=ON LSAN_OPTIONS="suppressions=$TRAVIS_BUILD_DIR/scripts/travis/leaksanitizer.conf"
+
+    # Release Builds
+    - os: linux
+      compiler: "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 RUN_CLANG_FORMAT=ON ENABLE_LTO=ON
+
+    - os: linux
+      compiler: "gcc-7-release"
+      addons: &gcc7
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-7', 'libbz2-dev', 'libxml2-dev', 'libzip-dev', 'liblua5.2-dev', 'libtbb-dev', 'libboost-all-dev']
+      env: CCOMPILER='gcc-7' CXXCOMPILER='g++-7' BUILD_TYPE='Release'
+
+    - os: linux
+      compiler: "gcc-7-release-i686"
+      env: >
+        TARGET_ARCH='i686' CCOMPILER='gcc-7' CXXCOMPILER='g++-7' BUILD_TYPE='Release'
+        CFLAGS='-m32 -msse2 -mfpmath=sse' CXXFLAGS='-m32 -msse2 -mfpmath=sse'
+
+    - os: linux
+      compiler: "gcc-7-stxxl"
+      addons: &gcc7
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-7', 'libbz2-dev', 'libstxxl-dev', 'libxml2-dev', 'libzip-dev', 'liblua5.2-dev', 'libtbb-dev', 'libboost-all-dev']
+      env: CCOMPILER='gcc-7' CXXCOMPILER='g++-7' BUILD_TYPE='Release' ENABLE_STXXL=On
+
+    - os: linux
+      compiler: "gcc-5-release"
+      addons: &gcc49
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-5', 'libbz2-dev', 'libxml2-dev', 'libzip-dev', 'liblua5.2-dev', 'libtbb-dev', 'libboost-all-dev', 'ccache']
+      env: CCOMPILER='gcc-5' CXXCOMPILER='g++-5' BUILD_TYPE='Release'
+
+    - os: linux
+      compiler: "gcc-6-release"
+      addons: &gcc49
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-6', 'libbz2-dev', 'libxml2-dev', 'libzip-dev', 'liblua5.2-dev', 'libtbb-dev', 'libboost-all-dev', 'ccache']
+      env: CCOMPILER='gcc-6' CXXCOMPILER='g++-6' BUILD_TYPE='Release'
+
+    - os: osx
+      osx_image: xcode9.2
+      compiler: "mason-osx-release-node-10"
+      # 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="10"
+      after_success:
+        - ./scripts/travis/publish.sh
+
+    - os: osx
+      osx_image: xcode9.2
+      compiler: "mason-osx-release-node-8"
+      # 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="8"
+      after_success:
+        - ./scripts/travis/publish.sh
+
+    - os: osx
+      osx_image: xcode9.2
+      compiler: "mason-osx-release-node-4"
+      # 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="4"
+      after_success:
+        - ./scripts/travis/publish.sh
+
+    # Shared Library
+    - os: linux
+      compiler: "gcc-7-release-shared"
+      addons: &gcc7
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-7', 'libbz2-dev', 'libxml2-dev', 'libzip-dev', 'liblua5.2-dev', 'libtbb-dev', 'libboost-all-dev']
+      env: CCOMPILER='gcc-7' CXXCOMPILER='g++-7' BUILD_TYPE='Release' BUILD_SHARED_LIBS=ON
+
+    # Node build jobs. These skip running the tests.
+    - os: linux
+      sudo: false
+      compiler: "node-4-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="4"
+      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-4-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="4"
+      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-8-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="8"
+      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-8-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="8"
+      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-10-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="10"
+      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-10-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="10"
+      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
+
+before_install:
+  - source $NVM_DIR/nvm.sh
+  - nvm install $NODE
+  - nvm use $NODE
+  - node --version
+  - if [[ ! -z $TARGET_ARCH ]] ; then source ./scripts/travis/before_install.$TARGET_ARCH.sh ; fi
+  - |
+    if [[ -z $JOBS ]]; then
+      if [[ "${TRAVIS_OS_NAME}" == "linux" ]]; then
+        export JOBS=$((`nproc` + 1))
+      elif [[ "${TRAVIS_OS_NAME}" == "osx" ]]; then
+        export JOBS=$((`sysctl -n hw.ncpu` + 1))
+      fi
+    fi
+  - |
+    if [[ "${TRAVIS_OS_NAME}" == "osx" ]]; then
+      sudo mdutil -i off /
+    fi
+  - |
+    if [[ ! -f $(which yarn) ]]; then
+      npm install -g yarn@1.11.1
+    fi
+  - export PACKAGE_JSON_VERSION=$(node -e "console.log(require('./package.json').version)")
+  - export PUBLISH=$([[ "${TRAVIS_TAG:-}" == "v${PACKAGE_JSON_VERSION}" ]] && echo "On" || echo "Off")
+  - echo "Using ${JOBS} jobs"
+  - yarn install --ignore-scripts
+  - yarn check --ignore-scripts --integrity
+    # Bootstrap cmake to be able to run mason
+  - CMAKE_URL="https://mason-binaries.s3.amazonaws.com/${TRAVIS_OS_NAME}-x86_64/cmake/${CMAKE_VERSION}.tar.gz"
+  - CMAKE_DIR="mason_packages/${TRAVIS_OS_NAME}-x86_64/cmake/${CMAKE_VERSION}"
+  - mkdir -p ${CMAKE_DIR}
+  - travis_retry wget --quiet -O - ${CMAKE_URL} | tar --strip-components=1 -xz -C ${CMAKE_DIR} || travis_terminate 1
+  - export PATH=${CMAKE_DIR}/bin:${PATH}
+  - ${MASON} install tbb 2017_U7 && export LD_LIBRARY_PATH=$(${MASON} prefix tbb 2017_U7)/lib/:${LD_LIBRARY_PATH}
+  - ${MASON} install ccache ${CCACHE_VERSION} && export PATH=$(${MASON} prefix ccache ${CCACHE_VERSION})/bin:${PATH}
+  - |
+    if [[ ! -z ${CLANG_VERSION} ]]; then
+      export CCOMPILER='clang'
+      export CXXCOMPILER='clang++'
+      ${MASON} install clang++ ${CLANG_VERSION} && export PATH=$(${MASON} prefix clang++ ${CLANG_VERSION})/bin:${PATH} || travis_terminate 1
+      # we only enable lto for release builds
+      # and therefore don't need to us ld.gold or llvm tools for linking
+      # for debug builds
+      if [[ ${BUILD_TYPE} == 'Release' ]]; then
+        ${MASON} install binutils 2.27 && export PATH=$(${MASON} prefix binutils 2.27)/bin:${PATH} || travis_terminate 1
+      fi
+    fi
+  - ccache --max-size=256M  # limiting the cache's size to roughly the previous job's object sizes
+  - export OSRM_INSTALL_DIR="$(pwd)/install-osrm"
+  - export OSRM_BUILD_DIR="$(pwd)/build-osrm"
+  - export CC=${CCOMPILER} CXX=${CXXCOMPILER}
+  - mkdir ${OSRM_BUILD_DIR}
+
+install:
+  - pushd ${OSRM_BUILD_DIR}
+  - |
+    cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
+             -DENABLE_MASON=${ENABLE_MASON:-OFF} \
+             -DENABLE_ASSERTIONS=${ENABLE_ASSERTIONS:-OFF} \
+             -DBUILD_SHARED_LIBS=${BUILD_SHARED_LIBS:-OFF} \
+             -DENABLE_COVERAGE=${ENABLE_COVERAGE:-OFF} \
+             -DENABLE_NODE_BINDINGS=${ENABLE_NODE_BINDINGS:-OFF} \
+             -DENABLE_SANITIZER=${ENABLE_SANITIZER:-OFF} \
+             -DENABLE_STXXL=${ENABLE_STXXL:-OFF} \
+             -DBUILD_TOOLS=ON \
+             -DENABLE_CCACHE=ON \
+             -DCMAKE_INSTALL_PREFIX=${OSRM_INSTALL_DIR} \
+             -DENABLE_GLIBC_WORKAROUND=${ENABLE_GLIBC_WORKAROUND:-OFF}
+  - echo "travis_fold:start:MAKE"
+  - make --jobs=${JOBS}
+  - make tests --jobs=${JOBS}
+  - make benchmarks --jobs=${JOBS}
+  - echo "travis_fold:end:MAKE"
+  - ccache -s
+  - sudo make install
+  - |
+    if [[ "${TRAVIS_OS_NAME}" == "linux" ]]; then
+      export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:${OSRM_INSTALL_DIR}/lib
+    fi
+  - popd
+  - mkdir example/build && pushd example/build
+  - export PKG_CONFIG_PATH=${OSRM_INSTALL_DIR}/lib/pkgconfig
+  - cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE}
+  - make --jobs=${JOBS}
+  - popd
+
+script:
+  - if [[ $TARGET_ARCH == armhf ]] ; then echo "Skip tests for $TARGET_ARCH" && exit 0 ; fi
+  - make -C test/data benchmark
+  - ./example/build/osrm-example test/data/mld/monaco.osrm
+  # All tests assume to be run from the build directory
+  - pushd ${OSRM_BUILD_DIR}
+  - ./unit_tests/library-tests
+  - ./unit_tests/extractor-tests
+  - ./unit_tests/contractor-tests
+  - ./unit_tests/engine-tests
+  - ./unit_tests/util-tests
+  - ./unit_tests/server-tests
+  - ./unit_tests/partitioner-tests
+  - |
+    if [ -z "${ENABLE_SANITIZER}" ] && [ "$TARGET_ARCH" != "i686" ]; then
+      npm run nodejs-tests
+    fi
+  - |
+  - popd
+  - yarn test
@@ -1,107 +1,11 @@
-# 5.26.0
-  - Changes from 5.25.0
-    - API:
-      - FIXED: Allow for special characters in the profile/method as part of the HTTP URL. [#6090](https://github.com/Project-OSRM/osrm-backend/pull/6090)
-      - FIXED: Set osrm-routed to immediately close bad connections [#6112](https://github.com/Project-OSRM/osrm-backend/pull/6112)
-    - Build:
-      - CHANGED: Replace Travis with Github Actions for CI builds [#6071](https://github.com/Project-OSRM/osrm-backend/pull/6071)
-      - FIXED: Fixed Boost link flags in pkg-config file. [#6083](https://github.com/Project-OSRM/osrm-backend/pull/6083)
-      - FIXED: Fixed test cache to consider MLD executable changes. [#6129](https://github.com/Project-OSRM/osrm-backend/pull/6129)
-    - Routing:
-      - FIXED: Fix generation of inefficient MLD partitions [#6084](https://github.com/Project-OSRM/osrm-backend/pull/6084)
-      - FIXED: Fix MLD level mask generation to support 64-bit masks. [#6123](https://github.com/Project-OSRM/osrm-backend/pull/6123)
-      - FIXED: Fix metric offset overflow for large MLD partitions. This breaks the **data format** [#6124](https://github.com/Project-OSRM/osrm-backend/pull/6124)
-
-# 5.25.0
-  - Changes from 5.24.0
-    - Build:
-      - CHANGED: Node binaries now use Github Releases for hosting [#6030](https://github.com/Project-OSRM/osrm-backend/pull/6030)
-    - Misc:
-      - FIXED: Upgrade to @mapbox/node-pre-gyp fix various bugs with Node 12/14 [#5991](https://github.com/Project-OSRM/osrm-backend/pull/5991)
-      - FIXED: `valid` type in documentation examples [#5990](https://github.com/Project-OSRM/osrm-backend/issues/5990)
-      - FIXED: Remove redundant loading of .osrm.cell_metrics [#6019](https://github.com/Project-OSRM/osrm-backend/issues/6019)
-      - CHANGED: Increase PackedOSMIDs size to 34 bits. This breaks the **data format** [#6020](https://github.com/Project-OSRM/osrm-backend/issues/6020)
-    - Profile:
-      - FIXED: Add kerb barrier exception to default car profile. [#5999](https://github.com/Project-OSRM/osrm-backend/pull/5999)
-
-# 5.24.0
-  - Changes from 5.23.0
-    - Features
-      - ADDED: Added support for multiple via-way restrictions. [#5907](https://github.com/Project-OSRM/osrm-backend/pull/5907)
-      - ADDED: Add node bindings support for Node 12, 14, and publish binaries [#5918](https://github.com/Project-OSRM/osrm-backend/pull/5918)
-      - REMOVED: we no longer publish Node 8 binary modules (they are still buildable from source) [#5918](https://github.com/Project-OSRM/osrm-backend/pull/5918)
-    - Routing:
-      - FIXED: Avoid copying ManyToMany table results [#5923](https://github.com/Project-OSRM/osrm-backend/pull/5923)
-      - FIXED: Reduce copying in API parameter constructors [#5925](https://github.com/Project-OSRM/osrm-backend/pull/5925)
-    - Misc:
-      - CHANGED: Cleanup NodeJS dependencies [#5945](https://github.com/Project-OSRM/osrm-backend/pull/5945)
-      - CHANGED: Unify `.osrm.turn_penalites_index` dump processing same with `.osrm.turn_weight_penalties` and `.osrm.turn_duration_penalties` [#5868](https://github.com/Project-OSRM/osrm-backend/pull/5868)
-      - FIXED: Properly validate source/destination validation in NodeJS table service [#5595](https://github.com/Project-OSRM/osrm-backend/pull/5595/files)
-      - FIXED: turn.roads_on_the_left not containing incoming roads and turn.roads_on_the_right not containing outgoing roads on two-way roads [#5128](https://github.com/Project-OSRM/osrm-backend/issues/5128)
-    - Profile:
-      - ADDED: Profile debug script which fetches a way from OSM then outputs the result of the profile. [#5908](https://github.com/Project-OSRM/osrm-backend/pull/5908)
-    - Infrastructure
-      - CHANGED: Bundled protozero updated to v1.7.0. [#5858](https://github.com/Project-OSRM/osrm-backend/pull/5858)
-    - Windows:
-      - FIXED: Fix bit-shift overflow in MLD partition step. [#5878](https://github.com/Project-OSRM/osrm-backend/pull/5878)
-      - FIXED: Fix vector bool permutation in graph contraction step [#5882](https://github.com/Project-OSRM/osrm-backend/pull/5882)
-    - API:
-      - FIXED: Undo libosrm API break by adding old interface as method overload [#5861](https://github.com/Project-OSRM/osrm-backend/pull/5861)
-      - FIXED: Fixed validation of sources/destinations when accessed via node bindings [#5595](https://github.com/Project-OSRM/osrm-backend/pull/5595)
-
-# 5.23.0
-  - Changes from 5.22.0
-    - Build:
-      - FIXED: pessimistic calls to std::move [#5560](https://github.com/Project-OSRM/osrm-backend/pull/5561)
-    - Features:
-      - ADDED: new API parameter - `snapping=any|default` to allow snapping to previously unsnappable edges [#5361](https://github.com/Project-OSRM/osrm-backend/pull/5361)
-      - ADDED: keepalive support to the osrm-routed HTTP server [#5518](https://github.com/Project-OSRM/osrm-backend/pull/5518)
-      - ADDED: flatbuffers output format support [#5513](https://github.com/Project-OSRM/osrm-backend/pull/5513)
-      - ADDED: Global 'skip_waypoints' option [#5556](https://github.com/Project-OSRM/osrm-backend/pull/5556)
-      - FIXED: Install the libosrm_guidance library correctly [#5604](https://github.com/Project-OSRM/osrm-backend/pull/5604)
-      - FIXED: Http Handler can now deal witch optional whitespace between header-key and -value [#5606](https://github.com/Project-OSRM/osrm-backend/issues/5606)
-    - Routing:
-      - CHANGED: allow routing past `barrier=arch` [#5352](https://github.com/Project-OSRM/osrm-backend/pull/5352)
-      - CHANGED: default car weight was reduced to 2000 kg. [#5371](https://github.com/Project-OSRM/osrm-backend/pull/5371)
-      - CHANGED: default car height was reduced to 2 meters. [#5389](https://github.com/Project-OSRM/osrm-backend/pull/5389)
-      - FIXED: treat `bicycle=use_sidepath` as no access on the tagged way. [#5622](https://github.com/Project-OSRM/osrm-backend/pull/5622)
-      - FIXED: fix table result when source and destination on same one-way segment. [#5828](https://github.com/Project-OSRM/osrm-backend/pull/5828)
-      - FIXED: fix occasional segfault when swapping data with osrm-datastore and using `exclude=` [#5844](https://github.com/Project-OSRM/osrm-backend/pull/5844)
-      - FIXED: fix crash in MLD alternative search if source or target are invalid [#5851](https://github.com/Project-OSRM/osrm-backend/pull/5851)
-    - Misc:
-      - CHANGED: Reduce memory usage for raster source handling. [#5572](https://github.com/Project-OSRM/osrm-backend/pull/5572)
-      - CHANGED: Add cmake option `ENABLE_DEBUG_LOGGING` to control whether output debug logging. [#3427](https://github.com/Project-OSRM/osrm-backend/issues/3427)
-      - CHANGED: updated extent of Hong Kong as left hand drive country. [#5535](https://github.com/Project-OSRM/osrm-backend/issues/5535)
-      - FIXED: corrected error message when failing to snap input coordinates [#5846](https://github.com/Project-OSRM/osrm-backend/pull/5846)
-    - Infrastructure
-      - REMOVED: STXXL support removed as STXXL became abandonware. [#5760](https://github.com/Project-OSRM/osrm-backend/pull/5760)
-
-# 5.22.0
-  - 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
+# 5.20.1 RC 4
  - Changes from 5.20.0
    - Features:
      - ADDED: all waypoints in responses now contain a distance property between the original coordinate and the snapped location. [#5255](https://github.com/Project-OSRM/osrm-backend/pull/5255)
      - ADDED: if `fallback_speed` is used, a new structure `fallback_speed_cells` will describe which cells contain estimated values [#5259](https://github.com/Project-OSRM/osrm-backend/pull/5259)
-      - REMOVED: we no longer publish Node 4 or 6 binary modules (they are still buildable from source) [#5314](https://github.com/Project-OSRM/osrm-backend/pull/5314)
    - Table:
      - ADDED: new parameter `scale_factor` which will scale the cell `duration` values by this factor. [#5298](https://github.com/Project-OSRM/osrm-backend/pull/5298)
      - FIXED: only trigger `scale_factor` code to scan matrix when necessary. [#5303](https://github.com/Project-OSRM/osrm-backend/pull/5303)
-      - FIXED: fix bug in reverse offset calculation that sometimes lead to negative (and other incorrect) values in distance table results [#5315](https://github.com/Project-OSRM/osrm-backend/pull/5315)
-    - Docker:
-      - FIXED: use consistent boost version between build and runtime [#5311](https://github.com/Project-OSRM/osrm-backend/pull/5311)
-      - FIXED: don't override default permissions on /opt [#5311](https://github.com/Project-OSRM/osrm-backend/pull/5311)
-    - Matching:
-      - CHANGED: matching will now consider edges marked with is_startpoint=false, allowing matching over ferries and other previously non-matchable edge types. [#5297](https://github.com/Project-OSRM/osrm-backend/pull/5297)
-    - Profile:
-      - ADDED: Parse `source:maxspeed` and `maxspeed:type` tags to apply maxspeeds and add belgian flanders rural speed limit. [#5217](https://github.com/Project-OSRM/osrm-backend/pull/5217)
-      - CHANGED: Refactor maxspeed parsing to use common library. [#5144](https://github.com/Project-OSRM/osrm-backend/pull/5144)

 # 5.20.0
  - Changes from 5.19.0:
@@ -116,8 +20,6 @@
      - ADDED: Now publishing Node 10.x LTS binary modules [#5246](https://github.com/Project-OSRM/osrm-backend/pull/5246)
    - Windows:
      - FIXED: Windows builds again. [#5249](https://github.com/Project-OSRM/osrm-backend/pull/5249)
-    - Docker:
-      - CHANGED: switch from Alpine Linux to Debian Buster base images [#5281](https://github.com/Project-OSRM/osrm-backend/pull/5281)

 # 5.19.0
  - Changes from 5.18.0:
@@ -129,7 +31,7 @@
 ](https://github.com/Project-OSRM/osrm-backend/pull/5076/)
      - CHANGED: Foot profile now blacklists barriers instead of whitelisting them [#5077
 ](https://github.com/Project-OSRM/osrm-backend/pull/5077/)
-      - CHANGED: Support maxlength and maxweight in car profile [#5101](https://github.com/Project-OSRM/osrm-backend/pull/5101)
+      - CHANGED: Support maxlength and maxweight in car profile [#5101](https://github.com/Project-OSRM/osrm-backend/pull/5101]
    - Bugfixes:
      - FIXED: collapsing of ExitRoundabout instructions [#5114](https://github.com/Project-OSRM/osrm-backend/issues/5114)
    - Misc:
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.2)
+cmake_minimum_required(VERSION 3.1)

 if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_CURRENT_BINARY_DIR AND NOT MSVC_IDE)
  message(FATAL_ERROR "In-source builds are not allowed.
@@ -23,9 +23,9 @@ option(ENABLE_CCACHE "Speed up incremental rebuilds via ccache" ON)
 option(BUILD_TOOLS "Build OSRM tools" OFF)
 option(BUILD_PACKAGE "Build OSRM package" OFF)
 option(ENABLE_ASSERTIONS "Use assertions in release mode" OFF)
-option(ENABLE_DEBUG_LOGGING "Use debug logging in release mode" OFF)
 option(ENABLE_COVERAGE "Build with coverage instrumentalisation" OFF)
 option(ENABLE_SANITIZER "Use memory sanitizer for Debug build" OFF)
+option(ENABLE_STXXL "Use STXXL library" OFF)
 option(ENABLE_LTO "Use LTO if available" OFF)
 option(ENABLE_FUZZING "Fuzz testing using LLVM's libFuzzer" OFF)
 option(ENABLE_GOLD_LINKER "Use GNU gold linker if available" ON)
@@ -37,6 +37,7 @@ list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 if(ENABLE_MASON)
  # versions in use
  set(MASON_BOOST_VERSION "1.65.1")
+  set(MASON_STXXL_VERSION "1.4.1-1")
  set(MASON_EXPAT_VERSION "2.2.0")
  set(MASON_LUA_VERSION "5.2.4")
  set(MASON_BZIP2_VERSION "1.0.6")
@@ -56,12 +57,6 @@ endif()
 if (POLICY CMP0048)
  cmake_policy(SET CMP0048 OLD)
 endif()
-if (POLICY CMP0057)
-  cmake_policy(SET CMP0057 NEW)
-endif()
-if (POLICY CMP0074)
-  cmake_policy(SET CMP0074 NEW)
-endif()
 project(OSRM C CXX)

 include(JSONParser)
@@ -232,7 +227,6 @@ endif()
 if(CMAKE_BUILD_TYPE MATCHES Debug OR CMAKE_BUILD_TYPE MATCHES RelWithDebInfo)
  message(STATUS "Configuring debug mode flags")
  set(ENABLE_ASSERTIONS ON)
-  set(ENABLE_DEBUG_LOGGING ON)
 endif()

 if(NOT CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
@@ -445,12 +439,6 @@ include_directories(SYSTEM ${PROTOZERO_INCLUDE_DIR})
 set(VTZERO_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/vtzero/include")
 include_directories(SYSTEM ${VTZERO_INCLUDE_DIR})

-set(FLATBUFFERS_SRC_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/flatbuffers")
-set(FLATBUFFERS_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/flatbuffers/include")
-include_directories(${FLATBUFFERS_INCLUDE_DIR})
-add_subdirectory(${FLATBUFFERS_SRC_DIR}
-        ${CMAKE_CURRENT_BINARY_DIR}/flatbuffers-build
-        EXCLUDE_FROM_ALL)

 # if mason is enabled no find_package calls are made
 # to ensure that we are only compiling and linking against
@@ -478,6 +466,13 @@ if(ENABLE_MASON)
  mason_use(boost_libsystem VERSION ${MASON_BOOST_VERSION})
  set(Boost_SYSTEM_LIBRARY ${MASON_PACKAGE_boost_libsystem_STATIC_LIBS})

+  if (ENABLE_STXXL)
+    mason_use(stxxl VERSION ${MASON_STXXL_VERSION})
+    add_dependency_includes(${MASON_PACKAGE_stxxl_INCLUDE_DIRS})
+    set(MAYBE_STXXL_LIBRARY ${MASON_PACKAGE_stxxl_STATIC_LIBS})
+    add_definitions(-DUSE_STXXL_LIBRARY)
+  endif()
+
  mason_use(expat VERSION ${MASON_EXPAT_VERSION})
  add_dependency_includes(${MASON_PACKAGE_expat_INCLUDE_DIRS})
  set(EXPAT_LIBRARIES ${MASON_PACKAGE_expat_STATIC_LIBS})
@@ -514,7 +509,7 @@ if(ENABLE_MASON)
  set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${LINKER_FLAGS}")

  # current mason packages target -D_GLIBCXX_USE_CXX11_ABI=0
-  add_dependency_defines(-D_GLIBCXX_USE_CXX11_ABI=0)
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_GLIBCXX_USE_CXX11_ABI=0")

  # note: we avoid calling find_package(Osmium ...) here to ensure that the
  # expat and bzip2 are used from mason rather than the system
@@ -523,16 +518,30 @@ else()

  find_package(Boost 1.54 REQUIRED COMPONENTS ${BOOST_COMPONENTS})
  add_dependency_includes(${Boost_INCLUDE_DIRS})
+  if(WIN32 AND Boost_VERSION VERSION_LESS 106200)
+    message(FATAL_ERROR "Building with MSVC needs Boost 1.62 with CXX11_CONSTEXPR support")
+  endif()

  find_package(TBB REQUIRED)
  add_dependency_includes(${TBB_INCLUDE_DIR})
-  if(WIN32)
-    set(TBB_LIBRARIES optimized ${TBB_LIBRARY} optimized ${TBB_MALLOC_LIBRARY} debug ${TBB_LIBRARY_DEBUG} debug ${TBB_MALLOC_LIBRARY_DEBUG})
+  if(WIN32 AND CMAKE_BUILD_TYPE MATCHES Debug)
+    set(TBB_LIBRARIES ${TBB_DEBUG_LIBRARIES})
  endif()

  find_package(EXPAT REQUIRED)
  add_dependency_includes(${EXPAT_INCLUDE_DIRS})

+  if (ENABLE_STXXL)
+    find_package(STXXL)
+    if (STXXL_FOUND)
+      add_dependency_includes(${STXXL_INCLUDE_DIR})
+      set(MAYBE_STXXL_LIBRARY ${STXXL_LIBRARY})
+      add_definitions(-DUSE_STXXL_LIBRARY)
+    else()
+      MESSAGE(STATUS "STXXL was requested but not found, default STL will be used")
+    endif()
+  endif()
+
  find_package(BZip2 REQUIRED)
  add_dependency_includes(${BZIP2_INCLUDE_DIR})

@@ -592,6 +601,15 @@ add_dependency_defines(-DBOOST_SPIRIT_USE_PHOENIX_V3)
 add_dependency_defines(-DBOOST_RESULT_OF_USE_DECLTYPE)
 add_dependency_defines(-DBOOST_FILESYSTEM_NO_DEPRECATED)

+if (ENABLE_STXXL)
+  set(OpenMP_FIND_QUIETLY ON)
+  find_package(OpenMP)
+  if(OPENMP_FOUND)
+    message(STATUS "OpenMP support found. Linking just in case for stxxl")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
+  endif()
+endif()
+
 add_definitions(${OSRM_DEFINES})
 include_directories(SYSTEM ${DEPENDENCIES_INCLUDE_DIRS})

@@ -624,6 +642,7 @@ set(EXTRACTOR_LIBRARIES
    ${EXPAT_LIBRARIES}
    ${USED_LUA_LIBRARIES}
    ${OSMIUM_LIBRARIES}
+    ${MAYBE_STXXL_LIBRARY}
    ${TBB_LIBRARIES}
    ${ZLIB_LIBRARY}
    ${MAYBE_COVERAGE_LIBRARIES})
@@ -657,6 +676,7 @@ set(CONTRACTOR_LIBRARIES
    ${BOOST_BASE_LIBRARIES}
    ${CMAKE_THREAD_LIBS_INIT}
    ${USED_LUA_LIBRARIES}
+    ${MAYBE_STXXL_LIBRARY}
    ${TBB_LIBRARIES}
    ${MAYBE_RT_LIBRARY}
    ${MAYBE_COVERAGE_LIBRARIES})
@@ -676,6 +696,7 @@ set(STORAGE_LIBRARIES
 set(UTIL_LIBRARIES
    ${BOOST_BASE_LIBRARIES}
    ${CMAKE_THREAD_LIBS_INIT}
+    ${MAYBE_STXXL_LIBRARY}
    ${TBB_LIBRARIES}
    ${MAYBE_COVERAGE_LIBRARIES}
    ${ZLIB_LIBRARY})
@@ -707,11 +728,6 @@ if (ENABLE_ASSERTIONS)
  add_definitions(-DBOOST_ENABLE_ASSERT_HANDLER)
 endif()

-if (ENABLE_DEBUG_LOGGING)
-  message(STATUS "Enabling debug logging")
-  add_definitions(-DENABLE_DEBUG_LOGGING)
-endif()
-
 # Add RPATH info to executables so that when they are run after being installed
 # (i.e., from /usr/local/bin/) the linker can find library dependencies. For
 # more info see http://www.cmake.org/Wiki/CMake_RPATH_handling
@@ -722,10 +738,8 @@ set_property(TARGET osrm-datastore PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
 set_property(TARGET osrm-routed PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)

 file(GLOB VariantGlob third_party/variant/include/mapbox/*.hpp)
-file(GLOB FlatbuffersGlob third_party/flatbuffers/include/flatbuffers/*.h)
 file(GLOB LibraryGlob include/osrm/*.hpp)
 file(GLOB ParametersGlob include/engine/api/*_parameters.hpp)
-set(ApiHeader include/engine/api/base_result.hpp)
 set(EngineHeader include/engine/status.hpp include/engine/engine_config.hpp include/engine/hint.hpp include/engine/bearing.hpp include/engine/approach.hpp include/engine/phantom_node.hpp)
 set(UtilHeader include/util/coordinate.hpp include/util/json_container.hpp include/util/typedefs.hpp include/util/alias.hpp include/util/exception.hpp include/util/bearing.hpp)
 set(ExtractorHeader include/extractor/extractor.hpp include/storage/io_config.hpp include/extractor/extractor_config.hpp include/extractor/travel_mode.hpp)
@@ -740,9 +754,7 @@ install(FILES ${PartitionerHeader} DESTINATION include/osrm/partitioner)
 install(FILES ${ContractorHeader} DESTINATION include/osrm/contractor)
 install(FILES ${LibraryGlob} DESTINATION include/osrm)
 install(FILES ${ParametersGlob} DESTINATION include/osrm/engine/api)
-install(FILES ${ApiHeader} DESTINATION include/osrm/engine/api)
 install(FILES ${VariantGlob} DESTINATION include/mapbox)
-install(FILES ${FlatbuffersGlob} DESTINATION include/flatbuffers)
 install(TARGETS osrm-extract DESTINATION bin)
 install(TARGETS osrm-partition DESTINATION bin)
 install(TARGETS osrm-customize DESTINATION bin)
@@ -756,7 +768,6 @@ install(TARGETS osrm_customize DESTINATION lib)
 install(TARGETS osrm_update DESTINATION lib)
 install(TARGETS osrm_contract DESTINATION lib)
 install(TARGETS osrm_store DESTINATION lib)
-install(TARGETS osrm_guidance DESTINATION lib)


 # Install profiles and support library to /usr/local/share/osrm/profiles by default
@@ -802,25 +813,9 @@ set(PKGCONFIG_INCLUDE_DIR "${CMAKE_INSTALL_PREFIX}/include")
 list(APPEND DEPENDENCIES_INCLUDE_DIRS "${PKGCONFIG_INCLUDE_DIR}")
 list(APPEND DEPENDENCIES_INCLUDE_DIRS "${PKGCONFIG_INCLUDE_DIR}/osrm")
 JOIN("-I${DEPENDENCIES_INCLUDE_DIRS}" " -I" PKGCONFIG_OSRM_INCLUDE_FLAGS)
+JOIN("${ENGINE_LIBRARIES}" " " PKGCONFIG_OSRM_DEPENDENT_LIBRARIES)

-# Boost uses imported targets, we need to use a generator expression to extract
-# the link libraries to be written to the pkg-config file.
-foreach(engine_lib ${ENGINE_LIBRARIES})
-  if("${engine_lib}" MATCHES "^Boost.*")
-    list(APPEND PKGCONFIG_DEPENDENT_LIBRARIES "$<TARGET_LINKER_FILE:${engine_lib}>")
-  else()
-    list(APPEND PKGCONFIG_DEPENDENT_LIBRARIES "${engine_lib}")
-  endif()
-endforeach(engine_lib)
-JOIN("${PKGCONFIG_DEPENDENT_LIBRARIES}" " " PKGCONFIG_OSRM_DEPENDENT_LIBRARIES)
-
-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/pkgconfig.in pkgconfig.configured @ONLY)
-file(GENERATE
-     OUTPUT
-     ${PROJECT_BINARY_DIR}/libosrm.pc
-     INPUT
-     ${PROJECT_BINARY_DIR}/pkgconfig.configured)
-
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/pkgconfig.in libosrm.pc @ONLY)
 install(FILES ${PROJECT_BINARY_DIR}/libosrm.pc DESTINATION ${PKGCONFIG_LIBRARY_DIR}/pkgconfig)

 # uninstall target
@@ -878,4 +873,4 @@ if (ENABLE_NODE_BINDINGS)
  endforeach()
  add_library(check-headers STATIC EXCLUDE_FROM_ALL ${sources})
  set_target_properties(check-headers PROPERTIES ARCHIVE_OUTPUT_DIRECTORY ${check_headers_dir})
-endif()
+endif()
@@ -50,7 +50,7 @@ If you want to use the CH pipeline instead replace `osrm-partition` and `osrm-cu

 ### Using Docker

-We base our Docker images ([backend](https://hub.docker.com/r/osrm/osrm-backend/), [frontend](https://hub.docker.com/r/osrm/osrm-frontend/)) on Debian and make sure they are as lightweight as possible.
+We base our Docker images ([backend](https://hub.docker.com/r/osrm/osrm-backend/), [frontend](https://hub.docker.com/r/osrm/osrm-frontend/)) on Alpine Linux and make sure they are as lightweight as possible.

 Download OpenStreetMap extracts for example from [Geofabrik](http://download.geofabrik.de/)

@@ -58,16 +58,16 @@ Download OpenStreetMap extracts for example from [Geofabrik](http://download.geo

 Pre-process the extract with the car profile and start a routing engine HTTP server on port 5000

-    docker run -t -v "${PWD}:/data" osrm/osrm-backend osrm-extract -p /opt/car.lua /data/berlin-latest.osm.pbf
+    docker run -t -v $(pwd):/data osrm/osrm-backend osrm-extract -p /opt/car.lua /data/berlin-latest.osm.pbf

-The flag `-v "${PWD}:/data"` creates the directory `/data` inside the docker container and makes the current working directory `"${PWD}"` available there. The file `/data/berlin-latest.osm.pbf` inside the container is referring to `"${PWD}/berlin-latest.osm.pbf"` on the host.
+The flag `-v $(pwd):/data` creates the directory `/data` inside the docker container and makes the current working directory `$(pwd)` available there. The file `/data/berlin-latest.osm.pbf` inside the container is referring to `$(pwd)/berlin-latest.osm.pbf` on the host.

-    docker run -t -v "${PWD}:/data" osrm/osrm-backend osrm-partition /data/berlin-latest.osrm
-    docker run -t -v "${PWD}:/data" osrm/osrm-backend osrm-customize /data/berlin-latest.osrm
+    docker run -t -v $(pwd):/data osrm/osrm-backend osrm-partition /data/berlin-latest.osrm
+    docker run -t -v $(pwd):/data osrm/osrm-backend osrm-customize /data/berlin-latest.osrm

 Note that `berlin-latest.osrm` has a different file extension. 

-    docker run -t -i -p 5000:5000 -v "${PWD}:/data" osrm/osrm-backend osrm-routed --algorithm mld /data/berlin-latest.osrm
+    docker run -t -i -p 5000:5000 -v $(pwd):/data osrm/osrm-backend osrm-routed --algorithm mld /data/berlin-latest.osrm

 Make requests against the HTTP server

@@ -10,7 +10,7 @@ ECHO NUMBER_OF_PROCESSORS^: %NUMBER_OF_PROCESSORS%


 :: Check CMake version
-SET CMAKE_VERSION=3.16.3
+SET CMAKE_VERSION=3.9.2
 SET PATH=%PROJECT_DIR%\cmake-%CMAKE_VERSION%-win32-x86\bin;%PATH%
 ECHO cmake^: && cmake --version
 IF %ERRORLEVEL% NEQ 0 ECHO CMAKE not found && GOTO CMAKE_NOT_OK
@@ -19,7 +19,7 @@ cmake --version | findstr /C:%CMAKE_VERSION% && GOTO CMAKE_OK

 :CMAKE_NOT_OK
 ECHO CMAKE NOT OK - downloading new CMake %CMAKE_VERSION%
-powershell Invoke-WebRequest https://cmake.org/files/v3.16/cmake-%CMAKE_VERSION%-win32-x86.zip -OutFile $env:PROJECT_DIR\cm.zip
+powershell Invoke-WebRequest https://cmake.org/files/v3.9/cmake-%CMAKE_VERSION%-win32-x86.zip -OutFile $env:PROJECT_DIR\cm.zip
 IF %ERRORLEVEL% NEQ 0 GOTO ERROR
 IF NOT EXIST cmake-%CMAKE_VERSION%-win32-x86 7z -y x cm.zip | %windir%\system32\FIND "ing archive"
 IF %ERRORLEVEL% NEQ 0 GOTO ERROR
@@ -29,8 +29,8 @@ ECHO CMAKE_OK
 cmake --version

 ECHO activating VS command prompt ...
-SET PATH=C:\Program Files (x86)\MSBuild\15.0\Bin;%PATH%
-CALL "C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\Build\vcvars64.bat"
+SET PATH=C:\Program Files (x86)\MSBuild\14.0\Bin;%PATH%
+CALL "C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat" amd64

 ECHO platform^: %platform%

@@ -40,7 +40,7 @@ ECHO msbuild version
 msbuild /version

 :: HARDCODE "x64" as it is uppercase on AppVeyor and download from S3 is case sensitive
-SET DEPSPKG=osrm-deps-win-x64-14.2-2019.01.7z
+SET DEPSPKG=osrm-deps-win-x64-14.0-2017.09.7z

 :: local development
 ECHO.
@@ -52,7 +52,7 @@ IF EXIST %DEPSPKG% DEL %DEPSPKG%
 IF %ERRORLEVEL% NEQ 0 GOTO ERROR

 ECHO downloading %DEPSPKG%
-powershell Invoke-WebRequest http://project-osrm.wolt.com/windows-build-deps/$env:DEPSPKG -OutFile $env:PROJECT_DIR\$env:DEPSPKG
+powershell Invoke-WebRequest https://mapbox.s3.amazonaws.com/windows-builds/windows-build-deps/$env:DEPSPKG -OutFile $env:PROJECT_DIR\$env:DEPSPKG
 IF %ERRORLEVEL% NEQ 0 GOTO ERROR

 :SKIPDL
@@ -74,35 +74,27 @@ IF %ERRORLEVEL% NEQ 0 GOTO ERROR

 SET OSRMDEPSDIR=%PROJECT_DIR%/osrm-deps
 set PREFIX=%OSRMDEPSDIR%/libs
-set BOOST_ROOT=%OSRMDEPSDIR%
+set BOOST_ROOT=%OSRMDEPSDIR%/boost
 set BOOST_LIBRARYDIR=%BOOST_ROOT%/lib
-set TBB_INSTALL_DIR=%OSRMDEPSDIR%
-REM set TBB_ARCH_PLATFORM=intel64/vc17
+set TBB_INSTALL_DIR=%OSRMDEPSDIR%/tbb
+set TBB_ARCH_PLATFORM=intel64/vc14

 ECHO OSRMDEPSDIR       ^: %OSRMDEPSDIR%
 ECHO PREFIX            ^: %PREFIX%
 ECHO BOOST_ROOT        ^: %BOOST_ROOT%
 ECHO BOOST_LIBRARYDIR  ^: %BOOST_LIBRARYDIR%
 ECHO TBB_INSTALL_DIR   ^: %TBB_INSTALL_DIR%
-REM ECHO TBB_ARCH_PLATFORM ^: %TBB_ARCH_PLATFORM%
+ECHO TBB_ARCH_PLATFORM ^: %TBB_ARCH_PLATFORM%


 ECHO calling cmake ....
 cmake .. ^
-G "Visual Studio 16 2019" ^
+-G "Visual Studio 14 2015 Win64" ^
 -DBOOST_ROOT=%BOOST_ROOT% ^
 -DBOOST_LIBRARYDIR=%BOOST_LIBRARYDIR% ^
-DBoost_ADDITIONAL_VERSIONS=1.73.0 ^
+-DBoost_ADDITIONAL_VERSIONS=1.58 ^
 -DBoost_USE_MULTITHREADED=ON ^
 -DBoost_USE_STATIC_LIBS=ON ^
-DEXPAT_INCLUDE_DIR=%OSRMDEPSDIR% ^
-DEXPAT_LIBRARY=%OSRMDEPSDIR%/lib/libexpat.lib ^
-DBZIP2_INCLUDE_DIR=%OSRMDEPSDIR% ^
-DBZIP2_LIBRARIES=%OSRMDEPSDIR%/lib/libbz2.lib ^
-DLUA_INCLUDE_DIR=%OSRMDEPSDIR% ^
-DLUA_LIBRARIES=%OSRMDEPSDIR%/lib/lua5.3.5.lib ^
-DZLIB_INCLUDE_DIR=%OSRMDEPSDIR% ^
-DZLIB_LIBRARY=%OSRMDEPSDIR%/lib/libz.lib ^
 -DCMAKE_BUILD_TYPE=%CONFIGURATION% ^
 -DCMAKE_INSTALL_PREFIX=%PREFIX%
 IF %ERRORLEVEL% NEQ 0 GOTO ERROR
@@ -114,46 +106,34 @@ msbuild OSRM.sln ^
 /t:rebuild ^
 /p:BuildInParallel=true ^
 /m:%NUMBER_OF_PROCESSORS% ^
-/toolsversion:Current ^
-/p:PlatformToolset=v142 ^
+/toolsversion:14.0 ^
+/p:PlatformToolset=v140 ^
 /clp:Verbosity=normal ^
 /nologo ^
 /flp1:logfile=build_errors.txt;errorsonly ^
 /flp2:logfile=build_warnings.txt;warningsonly
-IF %ERRORLEVEL% EQU 1 GOTO ERROR
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR

 CD %PROJECT_DIR%\build
-IF %ERRORLEVEL% EQU 1 GOTO ERROR
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR

-SET PATH=%PROJECT_DIR%\osrm-deps\lib;%PATH%
+SET PATH=%PROJECT_DIR%\osrm-deps\libs\bin;%PATH%

 ECHO running extractor-tests.exe ...
 unit_tests\%Configuration%\extractor-tests.exe
-IF %ERRORLEVEL% EQU 1 GOTO ERROR
-
-ECHO running contractor-tests.exe ...
-unit_tests\%Configuration%\contractor-tests.exe
-IF %ERRORLEVEL% EQU 1 GOTO ERROR
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR

 ECHO running engine-tests.exe ...
 unit_tests\%Configuration%\engine-tests.exe
-IF %ERRORLEVEL% EQU 1 GOTO ERROR
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR

 ECHO running util-tests.exe ...
 unit_tests\%Configuration%\util-tests.exe
-IF %ERRORLEVEL% EQU 1 GOTO ERROR
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR

 ECHO running server-tests.exe ...
 unit_tests\%Configuration%\server-tests.exe
-IF %ERRORLEVEL% EQU 1 GOTO ERROR
-
-ECHO running partitioner-tests.exe ...
-unit_tests\%Configuration%\partitioner-tests.exe
-IF %ERRORLEVEL% EQU 1 GOTO ERROR
-
-ECHO running customizer-tests.exe ...
-unit_tests\%Configuration%\customizer-tests.exe
-IF %ERRORLEVEL% EQU 1 GOTO ERROR
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR

 ECHO running library-tests.exe ...
 SET test_region=monaco
@@ -161,9 +141,7 @@ SET test_region_ch=ch\monaco
 SET test_region_corech=corech\monaco
 SET test_region_mld=mld\monaco
 SET test_osm=%test_region%.osm.pbf
-IF NOT EXIST %test_osm% powershell Invoke-WebRequest http://project-osrm.wolt.com/testing/monaco.osm.pbf -OutFile %test_osm%
-ECHO running %Configuration%\osrm-extract.exe -p ../profiles/car.lua %test_osm%
-%Configuration%\osrm-extract.exe
+IF NOT EXIST %test_osm% powershell Invoke-WebRequest https://s3.amazonaws.com/mapbox/osrm/testing/monaco.osm.pbf -OutFile %test_osm%
 %Configuration%\osrm-extract.exe -p ../profiles/car.lua %test_osm%
 MKDIR ch
 XCOPY %test_region%.osrm.* ch\
@@ -10,7 +10,7 @@ install:
 init:
  - git config --global core.autocrlf input

-os: Visual Studio 2019
+os: Visual Studio 2015

 # clone directory
 clone_folder: c:\projects\osrm
@@ -25,10 +25,9 @@ before_test:
  - npm --version
  - npm install --ignore-scripts
  - npm link --ignore-scripts
-  - SET PATH=%CD%\osrm-deps\lib;%PATH%
+  - SET PATH=%CD%\osrm-deps\libs\bin;%PATH%
  - SET OSRM_BUILD_DIR=build\%Configuration%
-# TODO tests fail with "JavaScript heap out of memory", need a better host?
-#  - npm test
+  - npm test

 branches:
  only:
@@ -11,6 +11,7 @@ SET CONFIGURATION=Release
 FOR /F "tokens=*" %%i in ('git rev-parse --abbrev-ref HEAD') do SET APPVEYOR_REPO_BRANCH=%%i
 ECHO APPVEYOR_REPO_BRANCH^: %APPVEYOR_REPO_BRANCH%

+SET PATH=C:\mb\windows-builds-64\tmp-bin\cmake-3.7.0-rc2-win32-x86\bin;%PATH%
 SET PATH=C:\Program Files\7-Zip;%PATH%

 powershell Set-ExecutionPolicy -Scope CurrentUser -ExecutionPolicy Unrestricted -Force
@@ -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/*)
@@ -44,7 +44,7 @@ unset(_lua_append_versions)

 # this is a function only to have all the variables inside go away automatically
 function(_lua_set_version_vars)
-    set(LUA_VERSIONS5 5.4 5.3 5.2 5.1 5.0)
+    set(LUA_VERSIONS5 5.3 5.2 5.1 5.0)

    if (Lua_FIND_VERSION_EXACT)
        if (Lua_FIND_VERSION_COUNT GREATER 1)
@@ -0,0 +1,51 @@
+# Locate STXXL library
+# This module defines
+#  STXXL_FOUND, if false, do not try to link to libstxxl
+#  STXXL_LIBRARY
+#  STXXL_INCLUDE_DIR, where to find stxxl.h
+#
+
+
+IF( NOT STXXL_FIND_QUIETLY )
+    MESSAGE(STATUS "Looking for STXXL...")
+ENDIF()
+
+FIND_PATH(STXXL_INCLUDE_DIR stxxl.h
+  HINTS
+  $ENV{STXXL_DIR}
+  PATH_SUFFIXES stxxl include/stxxl/stxxl include/stxxl include
+  PATHS
+  ~/Library/Frameworks
+  /Library/Frameworks
+  /usr/local
+  /usr
+  /opt/local # DarwinPorts
+  /opt
+)
+
+FIND_LIBRARY(STXXL_LIBRARY
+  NAMES stxxl stxxl_debug
+  HINTS
+  $ENV{STXXL_DIR}
+  PATH_SUFFIXES lib64 lib
+  PATHS
+  ~/Library/Frameworks
+  /Library/Frameworks
+  /usr/local
+  /usr
+  /opt/local
+  /opt
+)
+
+INCLUDE(FindPackageHandleStandardArgs)
+# handle the QUIETLY and REQUIRED arguments and set STXXL_FOUND to TRUE if
+# all listed variables are TRUE
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(STXXL  DEFAULT_MSG  STXXL_LIBRARY STXXL_INCLUDE_DIR)
+
+IF( NOT STXXL_FIND_QUIETLY )
+    IF( STXXL_FOUND )
+        MESSAGE(STATUS "Found STXXL: ${STXXL_LIBRARY}" )
+    ENDIF()
+ENDIF()
+
+MARK_AS_ADVANCED(STXXL_INCLUDE_DIR STXXL_LIBRARY)
@@ -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 libboost-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)" && \
@@ -24,26 +24,23 @@ RUN NPROC=${BUILD_CONCURRENCY:-$(grep -c ^processor /proc/cpuinfo 2>/dev/null ||
    make -j${NPROC} install && \
    cd ../profiles && \
    cp -r * /opt && \
+    \
    strip /usr/local/bin/* && \
    rm -rf /src /usr/local/lib/libosrm*


 # 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.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/*
 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
+RUN chmod 0644 -R /opt
 WORKDIR /opt

 EXPOSE 5000
@@ -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 ..
@@ -1,8 +1,3 @@
-# OSRM HTTP server
-
-Built-in HTTP server is a basic HTTP/1.0 server that supports 'keep-alive' extension. Persistent connections are limited to 512 requests per
-connection and allow no more then 5 seconds between requests.
-
 ## General options

 All OSRM HTTP requests use a common structure.
@@ -21,7 +16,7 @@ GET /{service}/{version}/{profile}/{coordinates}[.{format}]?option=value&option=
 | `version` | Version of the protocol implemented by the service. `v1` for all OSRM 5.x installations |
 | `profile` | Mode of transportation, is determined statically by the Lua profile that is used to prepare the data using `osrm-extract`. Typically `car`, `bike` or `foot` if using one of the supplied profiles. |
 | `coordinates`| String of format `{longitude},{latitude};{longitude},{latitude}[;{longitude},{latitude} ...]` or `polyline({polyline}) or polyline6({polyline6})`. |
-| `format`| `json` or `flatbuffers`. This parameter is optional and defaults to `json`. |
+| `format`| Only `json` is supported at the moment. This parameter is optional and defaults to `json`. |

 Passing any `option=value` is optional. `polyline` follows Google's polyline format with precision 5 by default and can be generated using [this package](https://www.npmjs.com/package/polyline).

@@ -29,16 +24,14 @@ To pass parameters to each location some options support an array like encoding:

 **Request options**

-| Option         | Values                                                 | Description                                                                                                                                                                                               |
-|----------------|--------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-|bearings        |`{bearing};{bearing}[;{bearing} ...]`                   |Limits the search to segments with given bearing in degrees towards true north in clockwise direction.                                                                                                     |
-|radiuses        |`{radius};{radius}[;{radius} ...]`                      |Limits the search to given radius in meters.                                                                                                                                                               |
-|generate\_hints |`true` (default), `false`                               |Adds a Hint to the response which can be used in subsequent requests, see `hints` parameter.                                                                                                               |
-|hints           |`{hint};{hint}[;{hint} ...]`                            |Hint from previous request to derive position in street network.                                                                                                                                           |
-|approaches      |`{approach};{approach}[;{approach} ...]`                |Keep waypoints on curb side.                                                                                                                                                                               |
-|exclude         |`{class}[,{class}]`                                     |Additive list of classes to avoid, order does not matter.                                                                                                                                                  |
-|snapping        |`default` (default), `any`                              |Default snapping avoids is_startpoint (see profile) edges, `any` will snap to any edge in the graph                                                                                                        |
-|skip_waypoints  |`true`, `false` (default)                               |Removes waypoints from the response. Waypoints are still calculated, but not serialized. Could be useful in case you are interested in some other part of response and do not want to transfer waste data. |
+| Option         | Values                                                 | Description                                                                                           |
+|----------------|--------------------------------------------------------|-------------------------------------------------------------------------------------------------------|
+|bearings        |`{bearing};{bearing}[;{bearing} ...]`                   |Limits the search to segments with given bearing in degrees towards true north in clockwise direction. |
+|radiuses        |`{radius};{radius}[;{radius} ...]`                      |Limits the search to given radius in meters.                                                           |
+|generate\_hints |`true` (default), `false`                               |Adds a Hint to the response which can be used in subsequent requests, see `hints` parameter.           |
+|hints           |`{hint};{hint}[;{hint} ...]`                            |Hint from previous request to derive position in street network.                                       |
+|approaches      |`{approach};{approach}[;{approach} ...]`                |Keep waypoints on curb side.                                                                           |
+|exclude         |`{class}[,{class}]`                                     |Additive list of classes to avoid, order does not matter.                                              |

 Where the elements follow the following format:

@@ -77,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                                                                      |
@@ -96,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"
 }
 ```

@@ -129,9 +115,6 @@ In addition to the [general options](#general-options) the following options are
 |------------|------------------------------|----------------------------------------------------|
 |number      |`integer >= 1` (default `1`)  |Number of nearest segments that should be returned. |

-As `waypoints` is a single thing, returned byt that service, using it with option `skip_waypoints` set to `true` is quite useless, but still
-possible. In that case only `code` field will be returned. 
-
 **Response**

 - `code` if the request was successful `Ok` otherwise see the service dependent and general status codes.
@@ -211,8 +194,7 @@ In addition to the [general options](#general-options) the following options are
 |annotations |`true`, `false` (default), `nodes`, `distance`, `duration`, `datasources`, `weight`, `speed`  |Returns additional metadata for each coordinate along the route geometry.      |
 |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.    |
+|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. |

 \* Please note that even if alternative routes are requested, a result cannot be guaranteed.

@@ -261,8 +243,6 @@ In addition to the [general options](#general-options) the following options are
 Unlike other array encoded options, the length of `sources` and `destinations` can be **smaller or equal**
 to number of input locations;

-With `skip_waypoints` set to `true`, both `sources` and `destinations` arrays will be skipped.
-
 **Example:**

 ```
@@ -299,9 +279,9 @@ curl 'http://router.project-osrm.org/table/v1/driving/13.388860,52.517037;13.397

 - `code` if the request was successful `Ok` otherwise see the service dependent and general status codes.
 - `durations` array of arrays that stores the matrix in row-major order. `durations[i][j]` gives the travel time from
-  the i-th source to the j-th destination. Values are given in seconds. Can be `null` if no route between `i` and `j` can be found.
+  the i-th waypoint to the j-th waypoint. Values are given in seconds. Can be `null` if no route between `i` and `j` can be found.
 - `distances` array of arrays that stores the matrix in row-major order. `distances[i][j]` gives the travel distance from
-  the i-th source to the j-th destination. Values are given in meters. Can be `null` if no route between `i` and `j` can be found.
+  the i-th waypoint to the j-th waypoint. Values are given in meters. Can be `null` if no route between `i` and `j` can be found. Note that computing the `distances` table is currently only implemented for CH. If `annotations=distance` or `annotations=duration,distance` is requested when running a MLD router, a `NotImplemented` error will be returned.
 - `sources` array of `Waypoint` objects describing all sources in order
 - `destinations` array of `Waypoint` objects describing all destinations in order
 - `fallback_speed_cells` (optional) array of arrays containing `i,j` pairs indicating which cells contain estimated values based on `fallback_speed`.  Will be absent if `fallback_speed` is not used.
@@ -577,7 +557,6 @@ Vector tiles contain two layers:
 | `weight  `   | `integer` | how long this segment takes to traverse, in units (may differ from `duration` when artificial biasing is applied in the Lua profiles).  ACTUAL ROUTING USES THIS VALUE. |
 | `name`       | `string`  | the name of the road this segment belongs to |
 | `rate`       | `float`   | the value of `length/weight` - analagous to `speed`, but using the `weight` value rather than `duration`, rounded to the nearest integer |
-| `is_startpoint` | `boolean` | whether this segment can be used as a start/endpoint for routes |

 `turns` layer:

@@ -762,8 +741,8 @@ step.
      {  "bearings" : [ 10, 92, 184, 270 ],
         "lanes" : [
            { "indications" : [ "left", "straight" ],
-               "valid" : false },
-            { "valid" : true,
+               "valid" : "false" },
+            { "valid" : "true",
               "indications" : [ "right" ] }
         ],
         "out" : 2,
@@ -774,9 +753,9 @@ step.
      {  "out" : 1,
         "lanes" : [
            { "indications" : [ "straight" ],
-               "valid" : true },
+               "valid" : "true" },
            { "indications" : [ "right" ],
-               "valid" : false }
+               "valid" : "false" }
         ],
         "bearings" : [ 60, 240, 330 ],
         "in" : 0,
@@ -884,7 +863,7 @@ A `Lane` represents a turn lane at the corresponding turn location.
 ```json
 {
    "indications": ["left", "straight"],
-    "valid": false
+    "valid": "false"
 }
 ```

@@ -919,7 +898,7 @@ location of the StepManeuver. Further intersections are listed for every cross-w
    "classes": ["toll", "restricted"],
    "lanes":{
        "indications": ["left", "straight"],
-        "valid": false
+        "valid": "false"
    }
 }
 ```
@@ -950,175 +929,3 @@ Object used to describe waypoint on a route.
   ]
 }
 ```
-
-## Flatbuffers format
-
-Default response format is `json`, but OSRM supports binary [`flatbuffers`](https://google.github.io/flatbuffers/) format, which 
-is much faster in serialization/deserialization, comparing to `json`.
-
-The format itself is described in message descriptors, located at `include/engine/api/flatbuffers directory`. Those descriptors could
-be compiled to provide protocol parsers in Go/Javascript/Typescript/Java/Dart/C#/Python/Lobster/Lua/Rust/PHP/Kotlin. Precompiled 
-protocol parser for C++ is supplied with OSRM.
-
-`Flatbuffers` format provides exactly same data, as `json` format with a slightly different layout, which was optimized to minimize
-in-transfer size.
-
-### Root object
-
-Root object is the only object, available from a 'raw' `flatbuffers` buffer. It can be constructed with a following call:
-
-         auto osrm = osrm::engine::api::fbresult::GetFBResult(some_input_buffer);
-
-**Properties**
-
- `error`: `bool` Marks response as erroneous. Erroneus response should include `code` field set, all the other field may not present. 
- `code`: `Error` Error description object, only present, when `error` is `true`
- `waypoints`: `[Waypoint]` Array of `Waypoint` objects. Should present for every service call, unless `skip_waypoints` is set to `true`. Table service will put `sources` array here.
- `routes`: `[RouteObject]` Array of `RouteObject` objects. May be empty or absent. Should present for Route/Trip/Match services call.
- `table`: `Table` Table object, may absent. Should be present in case of Table service call.
-
-### Error object
-
-Contains error information.
-
-**Properties**
-
- `code`: `string` Error code 
- `message`: `string` Detailed error message
-
-### Waypoint object
-
-Almost same as `json` Waypoint object. The following properties differ:
-
- `location`: `Position` Same as `json` location field, but different format. 
- `nodes`: `Uint64Pair` Same as `json` nodes field, but different format.
-
-### RouteObject object
-
-Almost same as `json` Route object. The following properties differ:
-
- `polyline`: `string` Same as `json` geometry.polyline or geometry.polyline6 fields. One field for both formats. 
- `coordinates`: `[Position]` Same as `json` geometry.coordinates field, but different format.
- `legs`: `[Leg]` Array of `Leg` objects.
-
-### Leg object
-
-Almost same as `json` Leg object. The following properties differ:
-
- `annotations`: `Annotation` Same as `json` annotation field, but different format.
- `steps`: `[Step]` Same as `step` annotation field, but different format.
-
-### Step object
-
-Almost same as `json` Step object. The following properties differ:
-
- `polyline`: `string` Same as `json` geometry.polyline or geometry.polyline6 fields. One field for both formats. 
- `coordinates`: `[Position]` Same as `json` geometry.coordinates field, but different format.
- `maneuver`: `StepManeuver` Same as `json` maneuver field, but different format.
-
-| `type`           | Description                                                                                                                                                                                                                                                                                                                  |
-|------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| `Turn`           | a basic turn into direction of the `modifier`                                                                                                                                                                                                                                                                                |
-| `NewName`        | no turn is taken/possible, but the road name changes. The road can take a turn itself, following `modifier`.                                                                                                                                                                                                                 |
-| `Depart`         | indicates the departure of the leg                                                                                                                                                                                                                                                                                           |
-| `Arrive`         | indicates the destination of the leg                                                                                                                                                                                                                                                                                         |
-| `Merge`          | merge onto a street (e.g. getting on the highway from a ramp, the `modifier specifies the direction of the merge`)                                                                                                                                                                                                           |
-| `OnRamp`         | take a ramp to enter a highway (direction given my `modifier`)                                                                                                                                                                                                                                                               |
-| `OffRamp`        | take a ramp to exit a highway (direction given my `modifier`)                                                                                                                                                                                                                                                                |
-| `Fork`           | take the left/right side at a fork depending on `modifier`                                                                                                                                                                                                                                                                   |
-| `EndOfRoad`      | road ends in a T intersection turn in direction of `modifier`                                                                                                                                                                                                                                                                |
-| `Continue`       | Turn in direction of `modifier` to stay on the same road                                                                                                                                                                                                                                                                     |
-| `Roundabout`     | traverse roundabout, if the route leaves the roundabout there will be an additional property `exit` for exit counting. The modifier specifies the direction of entering the roundabout.                                                                                                                                      |
-| `Rotary`         | a traffic circle. While very similar to a larger version of a roundabout, it does not necessarily follow roundabout rules for right of way. It can offer `rotary_name` and/or `rotary_pronunciation` parameters (located in the RouteStep object) in addition to the `exit` parameter (located on the StepManeuver object).  |
-| `RoundaboutTurn` | Describes a turn at a small roundabout that should be treated as normal turn. The `modifier` indicates the turn direciton. Example instruction: `At the roundabout turn left`.                                                                                                                                               |
-| `Notification`   | not an actual turn but a change in the driving conditions. For example the travel mode or classes. If the road takes a turn itself, the `modifier` describes the direction                                                                                                                                                   |
-| `ExitRoundabout` | Describes a maneuver exiting a roundabout (usually preceeded by a `roundabout` instruction)                                                                                                                                                                                                                                  |
-| `ExitRotary`     | Describes the maneuver exiting a rotary (large named roundabout)                                                                                                                                                                                                                                                             |
-
- `driving_side`: `bool` Ttrue stands for the left side driving. 
- `intersections`: `[Intersection]` Same as `json` intersections field, but different format.
-
-### Intersection object
-
-Almost same as `json` Intersection object. The following properties differ:
-
- `location`: `Position` Same as `json` location property, but in different format.
- `lanes`: `[Lane]` Array of `Lane` objects.
-
-### Lane object
-
-Almost same as `json` Lane object. The following properties differ:
-
- `indications`: `Turn` Array of `Turn` enum values. 
-
-| `value`                | Description                                                                                                               |
-|------------------------|---------------------------------------------------------------------------------------------------------------------------|
-| `None`                 | No dedicated indication is shown.                                                                                         |
-| `UTurn`                | An indication signaling the possibility to reverse (i.e. fully bend arrow).                                               |
-| `SharpRight`           | An indication indicating a sharp right turn (i.e. strongly bend arrow).                                                   |
-| `Right`                | An indication indicating a right turn (i.e. bend arrow).                                                                  |
-| `SlightRight`          | An indication indicating a slight right turn (i.e. slightly bend arrow).                                                  |
-| `Straight`             | No dedicated indication is shown (i.e. straight arrow).                                                                   |
-| `SlightLeft`           | An indication indicating a slight left turn (i.e. slightly bend arrow).                                                   |
-| `Left`                 | An indication indicating a left turn (i.e. bend arrow).                                                                   |
-| `SharpLeft`            | An indication indicating a sharp left turn (i.e. strongly bend arrow).                                                    |
-
-### StepManeuver object
-
-Almost same as `json` StepManeuver object. The following properties differ:
-
- `location`: `Position` Same as `json` location property, but in different format.
- `type`: `ManeuverType` Type of a maneuver (enum)
-
-| `type`           | Description                                                  |
-|------------------|--------------------------------------------------------------|
-| `Turn`           | a basic turn into direction of the `modifier`                |
-| `NewName`        | no turn is taken/possible, but the road name changes. The road can take a turn itself, following `modifier`.                  |
-| `Depart`         | indicates the departure of the leg                           |
-| `Arrive`         | indicates the destination of the leg                         |
-| `Merge`          | merge onto a street (e.g. getting on the highway from a ramp, the `modifier specifies the direction of the merge`) |
-| `OnRamp`         | take a ramp to enter a highway (direction given my `modifier`) |
-| `OffRamp`        | take a ramp to exit a highway (direction given my `modifier`)  |
-| `Fork`           | take the left/right side at a fork depending on `modifier`   |
-| `EndOfRoad`      | road ends in a T intersection turn in direction of `modifier`|
-| `Continue`       | Turn in direction of `modifier` to stay on the same road     |
-| `Roundabout`     | traverse roundabout, if the route leaves the roundabout there will be an additional property `exit` for exit counting. The modifier specifies the direction of entering the roundabout. |
-| `Rotary`         | a traffic circle. While very similar to a larger version of a roundabout, it does not necessarily follow roundabout rules for right of way. It can offer `rotary_name` and/or `rotary_pronunciation` parameters (located in the RouteStep object) in addition to the `exit` parameter (located on the StepManeuver object).  |
-| `RoundaboutTurn` | Describes a turn at a small roundabout that should be treated as normal turn. The `modifier` indicates the turn direciton. Example instruction: `At the roundabout turn left`. |
-| `Notification`   | not an actual turn but a change in the driving conditions. For example the travel mode or classes. If the road takes a turn itself, the `modifier` describes the direction |
-| `ExitRoundabout` | Describes a maneuver exiting a roundabout (usually preceeded by a `roundabout` instruction) |
-| `ExitRotary`    | Describes the maneuver exiting a rotary (large named roundabout) |
-
- `modifier`: `Turn` Maneuver turn (enum) 
-
-### Annotation object
-
-Exactly same as `json` annotation object. 
-
-
-### Position object
-
-A point on Earth. 
-
-***Properties***
- `longitute`: `float` Point's longitude
- `latitude`: `float` Point's latitude
-
-### Uint64Pair
-
-A pair of long long integers. Used only by `Waypoint` object.
-
-***Properties***
- `first`: `uint64` First pair value.
- `second`: `uint64` Second pair value.
-
-### Table object
-
-Almost same as `json` Table object. The main difference is that 'sources' field is absent and root's object 'waypoints' field is
-used instead. All the other differences follow:
-
- `durations`: `[float]` Flat representation of a durations matrix. Element at row;col can be adressed as [row * cols + col]
- `distances`: `[float]` Flat representation of a destinations matrix. Element at row;col can be adressed as [row * cols + col]
- `destinations`: `[Waypoint]` Array of `Waypoint` objects. Will be `null` if `skip_waypoints` will be set to `true`
- `rows`: `ushort` Number of rows in durations/destinations matrices.
- `cols`: `ushort` Number of cols in durations/destinations matrices.
@@ -25,8 +25,6 @@ var osrm = new OSRM('network.osrm');
               Make sure you prepared the dataset with the correct toolchain.
    -   `options.shared_memory` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Connects to the persistent shared memory datastore.
               This requires you to run `osrm-datastore` prior to creating an `OSRM` object.
-    -   `options.dataset_name` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?** Connects to the persistent shared memory datastore defined by `--dataset_name` option when running `osrm-datastore`
-               This requires you to run `osrm-datastore --dataset_name` prior to creating an `OSRM` object.
    -   `options.memory_file` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?** *DEPRECATED*
               Old behaviour: Path to a file on disk to store the memory using mmap.  Current behaviour: setting this value is the same as setting `mmap_memory: true`.
    -   `options.mmap_memory` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Map on-disk files to virtual memory addresses (mmap), rather than loading into RAM.
@@ -50,7 +48,6 @@ Returns the fastest route between two or more coordinates while visiting the way
                                          Can be `null` or an array of `[{value},{range}]` with `integer 0 .. 360,integer 0 .. 180`.
    -   `options.radiuses` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Limits the coordinate snapping to streets in the given radius in meters. Can be `null` (unlimited, default) or `double >= 0`.
    -   `options.hints` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Hints for the coordinate snapping. Array of base64 encoded strings.
-    -   `options.generate_hints` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Whether or not adds a Hint to the response which can be used in subsequent requests. (optional, default `true`)
    -   `options.alternatives` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** Search for alternative routes. (optional, default `false`)
    -   `options.alternatives` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** Search for up to this many alternative routes.
        _Please note that even if alternative routes are requested, a result cannot be guaranteed._ (optional, default `0`)
@@ -60,9 +57,7 @@ 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`
-    -   `options.snapping` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?** Which edges can be snapped to, either `default`, or `any`.  `default` only snaps to edges marked by the profile as `is_startpoint`, `any` will allow snapping to any edge in the routing graph.
 -   `callback` **[Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function)**

 **Examples**
@@ -92,11 +87,9 @@ Note: `coordinates` in the general options only supports a single `{longitude},{
                                          Can be `null` or an array of `[{value},{range}]` with `integer 0 .. 360,integer 0 .. 180`.
    -   `options.radiuses` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Limits the coordinate snapping to streets in the given radius in meters. Can be `null` (unlimited, default) or `double >= 0`.
    -   `options.hints` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Hints for the coordinate snapping. Array of base64 encoded strings.
-    -   `options.generate_hints` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Whether or not adds a Hint to the response which can be used in subsequent requests. (optional, default `true`)
    -   `options.number` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** Number of nearest segments that should be returned.
        Must be an integer greater than or equal to `1`. (optional, default `1`)
    -   `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.snapping` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?** Which edges can be snapped to, either `default`, or `any`.  `default` only snaps to edges marked by the profile as `is_startpoint`, `any` will allow snapping to any edge in the routing graph.
 -   `callback` **[Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function)**

 **Examples**
@@ -130,7 +123,6 @@ tables. Optionally returns distance table.
                                          Can be `null` or an array of `[{value},{range}]` with `integer 0 .. 360,integer 0 .. 180`.
    -   `options.radiuses` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Limits the coordinate snapping to streets in the given radius in meters. Can be `null` (unlimited, default) or `double >= 0`.
    -   `options.hints` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Hints for the coordinate snapping. Array of base64 encoded strings.
-    -   `options.generate_hints` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Whether or not adds a Hint to the response which can be used in subsequent requests. (optional, default `true`)
    -   `options.sources` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** An array of `index` elements (`0 <= integer < #coordinates`) to
        use
        location with given index as source. Default is to use all.
@@ -140,9 +132,6 @@ tables. Optionally returns distance table.
    -   `options.fallback_speed` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Replace `null` responses in result with as-the-crow-flies estimates based on `fallback_speed`.  Value is in metres/second.
    -   `options.fallback_coordinate` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?** Either `input` (default) or `snapped`.  If using a `fallback_speed`, use either the user-supplied coordinate (`input`), or the snapped coordinate (`snapped`) for calculating the as-the-crow-flies diestance between two points.
    -   `options.scale_factor` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Multiply the table duration values in the table by this number for more controlled input into a route optimization solver.
-    -   `options.snapping` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?** Which edges can be snapped to, either `default`, or `any`.  `default` only snaps to edges marked by the profile as `is_startpoint`, `any` will allow snapping to any edge in the routing graph.
-    -   `options.annotations` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Return the requested table or tables in response. Can be `['duration']` (return the duration matrix, default) or `['duration', distance']` (return both the duration matrix and the distance matrix). 
-     
 -   `callback` **[Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function)**

 **Examples**
@@ -213,7 +202,6 @@ if they can not be matched successfully.
    -   `options.bearings` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Limits the search to segments with given bearing in degrees towards true north in clockwise direction.
                                          Can be `null` or an array of `[{value},{range}]` with `integer 0 .. 360,integer 0 .. 180`.
    -   `options.hints` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Hints for the coordinate snapping. Array of base64 encoded strings.
-    -   `options.generate_hints` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Whether or not adds a Hint to the response which can be used in subsequent requests. (optional, default `true`)
    -   `options.steps` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** Return route steps for each route. (optional, default `false`)
    -   `options.annotations` **([Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array) \| [Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean))** An array with strings of `duration`, `nodes`, `distance`, `weight`, `datasources`, `speed` or boolean for enabling/disabling all. (optional, default `false`)
    -   `options.geometries` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** Returned route geometry format (influences overview and per step). Can also be `geojson`. (optional, default `polyline`)
@@ -222,8 +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.
-    -   `options.snapping` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?** Which edges can be snapped to, either `default`, or `any`.  `default` only snaps to edges marked by the profile as `is_startpoint`, `any` will allow snapping to any edge in the routing graph.
 -   `callback` **[Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function)**

 **Examples**
@@ -244,16 +230,9 @@ osrm.match(options, function(err, response) {
 Returns **[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)** containing `tracepoints` and `matchings`.
 **`tracepoints`** Array of [`Ẁaypoint`](#waypoint) objects representing all points of the trace in order.
                  If the trace point was ommited by map matching because it is an outlier, the entry will be null.
-                  Each `Waypoint` object has the following additional properties, 
-                  
-                  1) `matchings_index`: Index to the
-                  [`Route`](#route) object in matchings the sub-trace was matched to, 
-                  
-                  2) `waypoint_index`: Index of
+                  Each `Waypoint` object includes two additional properties, 1) `matchings_index`: Index to the
+                  [`Route`](#route) object in matchings the sub-trace was matched to, 2) `waypoint_index`: Index of
                  the waypoint inside the matched route.
-                  
-                  3) `alternatives_count`: Number of probable alternative matchings for this trace point. A value of zero indicate that this point was matched unambiguously. Split the trace at these points for incremental map matching.
-                  
 **`matchings`** is an array of [`Route`](#route) objects that assemble the trace. Each `Route` object has an additional `confidence` property,
                which is the confidence of the matching. float value between `0` and `1`. `1` is very confident that the matching is correct.

@@ -287,7 +266,6 @@ Right now, the following combinations are possible:
                                          Can be `null` or an array of `[{value},{range}]` with `integer 0 .. 360,integer 0 .. 180`.
    -   `options.radiuses` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Limits the coordinate snapping to streets in the given radius in meters. Can be `double >= 0` or `null` (unlimited, default).
    -   `options.hints` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Hints for the coordinate snapping. Array of base64 encoded strings.
-    -   `options.generate_hints` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Whether or not adds a Hint to the response which can be used in subsequent requests. (optional, default `true`)
    -   `options.steps` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** Return route steps for each route. (optional, default `false`)
    -   `options.annotations` **([Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array) \| [Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean))** An array with strings of `duration`, `nodes`, `distance`, `weight`, `datasources`, `speed` or boolean for enabling/disabling all. (optional, default `false`)
    -   `options.geometries` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** Returned route geometry format (influences overview and per step). Can also be `geojson`. (optional, default `polyline`)
@@ -296,7 +274,6 @@ Right now, the following combinations are possible:
    -   `options.source` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** Return route starts at `any` or `first` coordinate. (optional, default `any`)
    -   `options.destination` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** Return route ends at `any` or `last` coordinate. (optional, default `any`)
    -   `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.snapping` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?** Which edges can be snapped to, either `default`, or `any`.  `default` only snaps to edges marked by the profile as `is_startpoint`, `any` will allow snapping to any edge in the routing graph.
 -   `callback` **[Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function)**

 **Examples**
@@ -89,7 +89,7 @@ They all return a table of functions when you use `require` to load them. You ca
 ### setup()
 The `setup` function is called once when the profile is loaded and must return a table of configurations. It's also where you can do other global setup, like loading data sources that are used during processing.

-Note that processing of data is parallelized and several unconnected LUA interpreters will be running at the same time. The `setup` function will be called once for each. Each LUA interpreter will have its own set of globals.
+Note that processing of data is parallelized and several unconnected LUA interpreters will be running at the same time. The `setup` function will be called once for each. Each LUA iinterpreter will have its own set of globals.

 The following global properties can be set under `properties` in the hash you return in the `setup` function:

@@ -98,7 +98,7 @@ Attribute                            | Type     | Notes
 weight_name                          | String   | Name used in output for the routing weight property (default `'duration'`)
 weight_precision                     | Unsigned | Decimal precision of edge weights (default `1`)
 left_hand_driving                    | Boolean  | Are vehicles assumed to drive on the left? (used in guidance, default `false`)
-use_turn_restrictions                | Boolean  | Are turn restrictions followed? (default `false`)
+use_turn_restrictions                | Boolean  | Are turn instructions followed? (default `false`)
 continue_straight_at_waypoint        | Boolean  | Must the route continue straight on at a via point, or are U-turns allowed? (default `true`)
 max_speed_for_map_matching           | Float    | Maximum vehicle speed to be assumed in matching (in m/s)
 max_turn_weight                      | Float    | Maximum turn penalty weight
@@ -178,7 +178,7 @@ exits                                   | String   | The ramp's exit numbers or
 pronunciation                           | String   | Name pronunciation
 road_classification.motorway_class      | Boolean  | Guidance: way is a motorway
 road_classification.link_class          | Boolean  | Guidance: way is a slip/link road
-road_classification.road_priority_class | Enum     | Guidance: order in priority list. Defined in `include/extractor/road_classification.hpp`
+road_classification.road_priority_class | Enum     | Guidance: order in priority list. Defined in `include/extractor/guidance/road_classification.hpp`
 road_classification.may_be_ignored      | Boolean  | Guidance: way is non-highway
 road_classification.num_lanes           | Unsigned | Guidance: total number of lanes in way

@@ -223,7 +223,7 @@ source_number_of_lanes             | Read          | Integer                   |
 source_highway_turn_classification | Read          | Integer                   | Classification based on highway tag defined by user during setup. (default when not set: 0, allowed classification values are: 0-15))
 source_access_turn_classification  | Read          | Integer                   | Classification based on access tag defined by user during setup. (default when not set: 0, allowed classification values are: 0-15))
 source_speed                       | Read          | Integer                   | Speed on this source road in km/h
-source_priority_class              | Read          | Enum                      | The type of road priority class of the source. Defined in `include/extractor/road_classification.hpp`
+source_priority_class              | Read          | Enum                      | The type of road priority class of the source. Defined in `include/extractor/guidance/road_classification.hpp`
 target_restricted                  | Read          | Boolean                   | Is the target a restricted access road? (See definition in `process_way`)
 target_mode                        | Read          | Enum                      | Travel mode after the turn. Defined in `include/extractor/travel_mode.hpp`
 target_is_motorway                 | Read          | Boolean                   | Is the target road a motorway?
@@ -232,7 +232,7 @@ target_number_of_lanes             | Read          | Integer                   |
 target_highway_turn_classification | Read          | Integer                   | Classification based on highway tag defined by user during setup. (default when not set: 0, allowed classification values are: 0-15))
 target_access_turn_classification  | Read          | Integer                   | Classification based on access tag defined by user during setup. (default when not set: 0, allowed classification values are: 0-15))
 target_speed                       | Read          | Integer                   | Speed on this target road in km/h
-target_priority_class              | Read          | Enum                      | The type of road priority class of the target. Defined in `include/extractor/road_classification.hpp`
+target_priority_class              | Read          | Enum                      | The type of road priority class of the target. Defined in `include/extractor/guidance/road_classification.hpp`
 roads_on_the_right                 | Read          | Vector<ExtractionTurnLeg> | Vector with information about other roads on the right of the turn that are also connected at the intersection
 roads_on_the_left                  | Read          | Vector<ExtractionTurnLeg> | Vector with information about other roads on the left of the turn that are also connected at the intersection. If turn is a u turn, this is empty.
 weight                             | Read/write    | Float                     | Penalty to be applied for this turn (routing weight)
@@ -252,7 +252,7 @@ number_of_lanes             | Read          | Integer   | How many lanes does th
 highway_turn_classification | Read          | Integer   | Classification based on highway tag defined by user during setup. (default when not set: 0, allowed classification values are: 0-15)
 access_turn_classification  | Read          | Integer   | Classification based on access tag defined by user during setup. (default when not set: 0, allowed classification values are: 0-15)
 speed                       | Read          | Integer   | Speed on this road in km/h
-priority_class              | Read          | Enum      | The type of road priority class of the leg. Defined in `include/extractor/road_classification.hpp`
+priority_class              | Read          | Enum      | The type of road priority class of the leg. Defined in `include/extractor/guidance/road_classification.hpp`
 is_incoming                 | Read          | Boolean   | Is the road an incoming road of the intersection
 is_outgoing                 | Read          | Boolean   | Is the road an outgoing road of the intersection

@@ -50,8 +50,7 @@ We may introduce forward-compatible changes: query parameters and response prope
 7. Push tags and commits: `git push; git push --tags`
 8. On https://github.com/Project-OSRM/osrm-backend/releases press `Draft a new release`,
   write the release tag `vx.y.z` in the `Tag version` field, write the changelog entries in the `Describe this release` field
-   and press `Publish release`. Note that Travis deployments will create a release when publishing node binaries, so the release
-   may already exist. In which case the description should be updated with the changelog entries.
+   and press `Publish release`.
 9. If not a release-candidate: Write a mailing-list post to osrm-talk@openstreetmap.org to announce the release
 10. Wait until the travis build has been completed and check if the node binaries were published by doing:
    `rm -rf node_modules && npm install` locally.
@@ -1,97 +0,0 @@
-# Building OSRM for Windows
-
-## Dependencies
-
-Get a decent Windows with decent Visual Studio (14 at least for C++11 support). The published binaries are build with
-VS2019 and Windows SDK8.1.
-
-In case you are using [prepacked Windows VM with VS2019](https://developer.microsoft.com/en-us/windows/downloads/virtual-machines/), you
-have to install [Windows SDK 8.1](https://go.microsoft.com/fwlink/p/?LinkId=323507)
-
-Prepare directories for dependencies, build and target file location.Target directory ($target starting from that moment) should have /include and /lib subdirectories.
-
-### Bzip2
-
-1. Download either from Wolt OSRM mirror or original distribution and unpack.
-    * https://project-osrm.wolt.com/deps/bzip2-1.0.8.tar.gz
-    * https://sourceware.org/pub/bzip2/bzip2-1.0.8.tar.gz
-
-2. Start 'x64 Native Tools Command Prompt for VS2019' and change directory to unpacked source tree.
-3. Issue `nmake /f makefile.msc`
-4. Copy bzlib.h to $target\include and libbz2.lib to $target\lib
-
-### ZLib
-
-1. Download either from Wolt OSRM mirror or original distribution and unpack.
-    * https://project-osrm.wolt.com/deps/zlib-1.2.11.tar.gz
-    * https://www.zlib.net/zlib-1.2.11.tar.gz
-
-2. Start 'x64 Native Tools Command Prompt for VS2019' and change directory to unpacked source tree.
-3. Switch to `contrib\vstudio\vc14`
-4. If needed, open `zlibvc.sln` with Visual Studio and retarget to your version of compiler and SDK.
-5. Issue `msbuild zlibvc.sln /p:BuildInParallel=true /p:Configuration=Release /p:Platform=x64 /m:<Number of cpu cores>`
-6. Copy x64\ZlibStatRelease\zlibstat.lib to $target\lib\libz.lib, copy zlib.h and zconf.h to $target\include
-
-### ICU
-
-1. Download either from Wolt OSRM mirror or original distribution and unpack.
-    * https://wolt-project.wolt.com/deps/icu4c-66_1-src.zip
-    * https://github.com/unicode-org/icu/releases/download/release-66-1/icu4c-66_1-src.zip
-    * https://wolt-project.wolt.com/deps/icu4c-66_1-data.zip
-    * https://github.com/unicode-org/icu/releases/download/release-66-1/icu4c-66_1-data.zip
-2. Do retarget if neededby openinig .\source\allinone\allinone.sln and editing projects
-3. Start 'x64 Native Tools Command Prompt for VS2019' and change directory to unpacked source tree.
-4. Run build:
-    msbuild .\source\allinone\allinone.sln /nologo /p:BuildInParallel=true /p:Configuration=Release /p:Platform=x64 /m:<Number of cpu cores>
-5. Copy lib64\*.lib to $target\lib, copy include contents to $target\include
-6. Copy bin64\*dll to any dir withing your $PATH. At the same time copy them to $target\lib
-
-### Boost
-
-1. Download either from Wolt OSRM mirror or original distribution and unpack.
-    * https://project-osrm.wolt.com/deps/boost_1_73_0.zip
-    * https://dl.bintray.com/boostorg/release/1.73.0/source/boost_1_73_0.zip
-
-2. Start 'x64 Native Tools Command Prompt for VS2019' and change directory to unpacked source tree.
-3. Build b2:
-    bootstrap.bat --with-toolset=msvc-14.2
-4. Build boost:
-       b2 -a -d release state --build-type=minimal toolset=msvc-14.2 -q runtime-link=shared link=static address-model=64 --with-iostreams --with-test --with-thread --with-filesystem --with-date_time --with-system --with-program_options --with-regex --disable-filesystem2 -sHAVE_ICU=1 include=<target>\include library-path=<target>\lib -sZLIB_SOURCE=<builddir>/zlib -zBZIP2_BINARY=libbz2 -sBZIP2_INCLUDE=<target>\include -sBZIP2_LIBPATH=<target>\lib -sICU_ICUUC_NAME=icuuc -sICU_ICUDT_NAME=icudt -sICU_ICUIN_NAME=icuin -sBUILD=boost_unit_test_framework -j<number of cpu cores>
-5. Copy `boost` subdirectory to <target>\include and contents of `stage` to <target>\lib
-
-### Expat
-
-1. Download either from Wolt OSRM mirror or original distribution and unpack.
-    * https://project-osrm.wolt.com/deps/libexpat-2_2_9.zip
-    * https://github.com/libexpat/libexpat/archive/R_2_2_9.zip
-2. Start 'x64 Native Tools Command Prompt for VS2019' and change directory to unpacked source tree.
-3. Configure build my calling cmake:
-    mkdir expat\build
-    cd expat\build
-    cmake -G"Visual Studio 16 2019" -DCMAKE_BUILD_TYPE=Release -DEXPAT_MSVC_STATIC_CRT=ON -DEXPAT_BUILD_EXAMPLES=OFF -DEXPAT_BUILD_TESTS=OFF -DEXPAT_SHARED_LIBS=OFF ..
-4. Build expat: `msbuild expat.sln /nologo /p:Configuration=Release /p:Platform=x64`
-5. Copy `Release\libexpat.*` to <target>/lib. Copy `expat/lib/expat.h` and `expat/lib/expat_external.h` to <target>/include
-
-### LUA
-
-1. Download either from Wolt OSRM mirror or original distribution and unpack.
-    * https://project-osrm.wolt.com/deps/lua-5.3.5.tar.gz
-    * https://www.lua.org/ftp/lua-5.3.5.tar.gz
-2. Start 'x64 Native Tools Command Prompt for VS2019' and change directory to unpacked source tree.
-3. Lua doesn't have native MSVC support, so you have to compile it by hand:
-    cd src
-    cl /MD /O2 /c /DLUA_COMPAT_5_2 *.c
-    ren lua.obj lua.o
-    ren luac.obj luac.o
-    link /LIB /OUT:lua5.3.5.dll *.obj
-4. Copy `lua5.3.5.lib` to <target>/lib. Copy `lua.h`,`lauxlib,h`,`lua.hpp`,`lualib.h`,`luaconf.h` to <target>/include
-
-### TBB
-
-1. Download either from Wolt OSRM mirror or original distribution and unpack.
-    * https://project-osrm.wolt.com/deps/oneTBB-v2020.2.zip
-    * https://github.com/oneapi-src/oneTBB/archive/v2020.2.zip
-2. Retarget by opening build\vs2013\makefile.sln
-3. Start 'x64 Native Tools Command Prompt for VS2019' and change directory to unpacked source tree.
-4. Switch to build\vs2013 and build: `msbuild makefle.sln /nologo /p:Configuration=Release /p:Platform=x64`
-5. Copy x64/Release/*.{dll,lib} files to <target>/lib and copy contents of include directory to <target>/include
@@ -52,15 +52,14 @@ int main(int argc, const char *argv[])
    params.coordinates.push_back({util::FloatLongitude{7.419505}, util::FloatLatitude{43.736825}});

    // Response is in JSON format
-    engine::api::ResultT result = json::Object();
+    json::Object result;

    // Execute routing request, this does the heavy lifting
    const auto status = osrm.Route(params, result);

-    auto &json_result = result.get<json::Object>();
    if (status == Status::Ok)
    {
-        auto &routes = json_result.values["routes"].get<json::Array>();
+        auto &routes = result.values["routes"].get<json::Array>();

        // Let's just use the first route
        auto &route = routes.values.at(0).get<json::Object>();
@@ -80,8 +79,8 @@ int main(int argc, const char *argv[])
    }
    else if (status == Status::Error)
    {
-        const auto code = json_result.values["code"].get<json::String>().value;
-        const auto message = json_result.values["message"].get<json::String>().value;
+        const auto code = result.values["code"].get<json::String>().value;
+        const auto message = result.values["message"].get<json::String>().value;

        std::cout << "Code: " << code << "\n";
        std::cout << "Message: " << code << "\n";
@@ -127,7 +127,6 @@ Feature: Bike - Access tags on ways
            |              |              | agricultural |         |
            |              |              | forestry     |         |
            |              |              | delivery     |         |
-            |              |              | use_sidepath |         |

    Scenario: Bike - Access tags on both node and way
        Then routability should be
@@ -46,18 +46,6 @@ Feature: Car - Barriers
            | bollard      | rising        | x     |
            | bollard      | removable     |       |

-    # https://github.com/Project-OSRM/osrm-backend/issues/5996
-    Scenario: Car - Kerb exception for barriers
-        Then routability should be
-            | node/barrier | node/highway  | node/kerb  | bothw |
-            | kerb         |               |            |       |
-            | kerb         | crossing      |            |  x    |
-            | kerb         | crossing      | yes        |  x    |
-            | kerb         |               | lowered    |  x    |
-            | kerb         |               | flush      |  x    |
-            | kerb         |               | raised     |       |
-            | kerb         |               | yes        |       |
-
    Scenario: Car - Height restrictions
        Then routability should be
            | node/barrier      | node/maxheight | bothw |
@@ -387,37 +387,217 @@ Feature: Car - Turn restrictions
            | m    | p  | mj,jp,jp       |

    @no_turning @conditionals
-    Scenario: Car - Multiple conditional restrictions applicable to same turn
+    Scenario: Car - only_right_turn
        Given the extract extra arguments "--parse-conditional-restrictions"
                                            # time stamp for 10am on Tues, 02 May 2017 GMT
        Given the contract extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493719200"
        Given the customize extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493719200"
-
        Given the node map
            """
-                j
-                |
-            k - l - m
-                |
-                n
+              a
+            d j b
+              c
            """

        And the ways
-            | nodes |
-            | kl    |
-            | jl    |
-            | ln    |
-            | lm    |
+            | nodes | oneway |
+            | aj    | no     |
+            | jc    | no     |
+            | bj    | yes    |
+            | jd    | yes    |

        And the relations
            | type        | way:from | way:to | node:via | restriction:conditional               |
-            | restriction | kl       | lj     | l        | only_left_turn @ (Sa-Su 07:00-10:30)  |
-            | restriction | kl       | ln     | l        | only_right_turn @ (Mo-Fr 07:00-10:30) |
+            | restriction | bj       | aj     | j        | only_right_turn @ (Mo-Su 07:00-14:00) |

        When I route I should get
            | from | to | route          |
-            | k    | m  | kl,ln,ln,lm,lm |
+            | b    | c  | bj,aj,aj,jc,jc |
+            | b    | a  | bj,aj,aj       |
+            | b    | d  | bj,aj,aj,jd,jd |

+    @no_turning @conditionals
+    Scenario: Car - No right turn
+        Given the extract extra arguments "--parse-conditional-restrictions"
+                                            # time stamp for 10am on Tues, 02 May 2017 GMT
+        Given the contract extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493719200"
+        Given the customize extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493719200"
+        Given the node map
+            """
+              a
+            d j b
+              c
+            """
+
+        And the ways
+            | nodes | oneway |
+            | aj    | no     |
+            | jc    | no     |
+            | bj    | yes    |
+            | jd    | yes    |
+
+        And the relations
+            | type        | way:from | way:to | node:via | restriction:conditional               |
+            | restriction | bj       | aj     | j        | no_right_turn @ (Mo-Fr 07:00-13:00)   |
+
+        When I route I should get
+            | from | to | route          | # |
+            | b    | c  | bj,jc,jc       | normal turn |
+            | b    | a  | bj,jc,jc,aj,aj | avoids right turn |
+            | b    | d  | bj,jd,jd       | normal maneuver |
+
+    @only_turning @conditionals
+    Scenario: Car - only_left_turn
+        Given the extract extra arguments "--parse-conditional-restrictions"
+                                            # time stamp for 10am on Tues, 02 May 2017 GMT
+        Given the contract extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493719200"
+        Given the customize extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493719200"
+        Given the node map
+            """
+              a
+            d j b
+              c
+            """
+
+        And the ways
+            | nodes | oneway |
+            | aj    | no     |
+            | jc    | no     |
+            | bj    | yes    |
+            | jd    | yes    |
+
+        And the relations
+            | type        | way:from | way:to | node:via | restriction:conditional              |
+            | restriction | bj       | jc     | j        | only_left_turn @ (Mo-Fr 07:00-16:00) |
+
+        When I route I should get
+            | from | to | route          |
+            | b    | c  | bj,jc,jc       |
+            | b    | a  | bj,jc,jc,aj,aj |
+            | b    | d  | bj,jc,jc,jd,jd |
+
+    @no_turning @conditionals
+    Scenario: Car - No left turn
+        Given the extract extra arguments "--parse-conditional-restrictions"
+                                            # time stamp for 10am on Tues, 02 May 2017 GMT
+        Given the contract extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493719200"
+        Given the customize extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493719200"
+        Given the node map
+            """
+              a
+            d j b
+              c
+            """
+
+        And the ways
+            | nodes | oneway |
+            | aj    | no     |
+            | jc    | no     |
+            | bj    | yes    |
+            | jd    | yes    |
+
+        And the relations
+            | type        | way:from | way:to | node:via | restriction:conditional            |
+            | restriction | bj       | jc     | j        | no_left_turn @ (Mo-Su 00:00-23:59) |
+
+        When I route I should get
+            | from | to | route          |
+            | b    | c  | bj,aj,aj,jc,jc |
+            | b    | a  | bj,aj,aj       |
+            | b    | d  | bj,jd,jd       |
+
+    @no_turning @conditionals
+    Scenario: Car - Conditional restriction is off
+        Given the extract extra arguments "--parse-conditional-restrictions"
+                                            # time stamp for 10am on Tues, 02 May 2017 GMT
+        Given the contract extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493719200"
+        Given the customize extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493719200"
+        Given the node map
+            """
+              a
+            d j b
+              c
+            """
+
+        And the ways
+            | nodes | oneway |
+            | aj    | no     |
+            | jc    | no     |
+            | bj    | yes    |
+            | jd    | yes    |
+
+        And the relations
+            | type        | way:from | way:to | node:via | restriction:conditional             |
+            | restriction | bj       | aj     | j        | no_right_turn @ (Mo-Su 16:00-20:00) |
+
+        When I route I should get
+            | from | to | route    |
+            | b    | c  | bj,jc,jc |
+            | b    | a  | bj,aj,aj |
+            | b    | d  | bj,jd,jd |
+
+    @no_turning @conditionals
+    Scenario: Car - Conditional restriction is on
+        Given the extract extra arguments "--parse-conditional-restrictions"
+        # 10am utc, wed
+        Given the contract extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493805600"
+        Given the customize extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493805600"
+        Given the node map
+            """
+              a
+            d j b
+              c
+            """
+
+        And the ways
+            | nodes | oneway |
+            | aj    | no     |
+            | jc    | no     |
+            | bj    | yes    |
+            | jd    | yes    |
+
+        And the relations
+            | type        | way:from | way:to | node:via | restriction:conditional             |
+            | restriction | jb       | aj     | j        | no_right_turn @ (Mo-Fr 07:00-14:00) |
+
+        When I route I should get
+            | from | to | route          |
+            | b    | c  | bj,jc,jc       |
+            | b    | a  | bj,jc,jc,aj,aj |
+            | b    | d  | bj,jd,jd       |
+
+    @no_turning @conditionals
+    Scenario: Car - Conditional restriction with multiple time windows
+        Given the extract extra arguments "--parse-conditional-restrictions"
+        # 5pm Wed 02 May, 2017 GMT
+        Given the contract extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493744400"
+        Given the customize extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493744400"
+
+        Given the node map
+            """
+              a
+           p  |
+            \ |
+              j
+              | \
+              c  m
+            """
+
+        And the ways
+            | nodes | oneway |
+            | aj    | no     |
+            | jc    | no     |
+            | jp    | yes    |
+            | mj    | yes    |
+
+        And the relations
+            | type        | way:from | way:to | node:via | restriction:conditional                         |
+            | restriction | aj       | jp     | j        | no_right_turn @ (Mo-Fr 07:00-11:00,16:00-18:30) |
+
+        When I route I should get
+            | from | to | route          |
+            | a    | p  | aj,jc,jc,jp,jp |
+            | m    | p  | mj,jp,jp       |

    @restriction-way
    Scenario: Car - prohibit turn
@@ -539,7 +719,7 @@ Feature: Car - Turn restrictions
        When I route I should get
            | from | to | route                                      | turns                                       |
            | a    | e  | cap south,florida nw,florida nw,florida ne | depart,turn right,continue uturn,arrive     |
-            | f    | d  | cap north,florida nw,florida nw            | depart,turn left,arrive                     |
+            | f    | d  | cap north,florida nw,florida nw               | depart,turn left,arrive                     |
            | e    | c  | florida ne,florida nw,cap south,cap south  | depart,continue uturn,turn right,arrive     |

    @no_turning @conditionals
@@ -616,8 +796,8 @@ Feature: Car - Turn restrictions
            | nodes | name  |
            | ab    | albic |
            | bc    | albic |
-            | db    | dobe  |
-            | be    | dobe  |
+            | db    | dobe |
+            | be    | dobe |

        And the relations
            | type        | way:from  | way:to  | node:via | restriction:conditional               |
@@ -867,7 +1047,7 @@ Feature: Car - Turn restrictions
            | type        | way:from | node:via | way:to | restriction:conditional             |
            | restriction | be       | e        | de     | no_right_turn @ (Mo-Fr 07:00-11:00) |

-        # node restriction is off, way restriction is on
+        # node restrictino is off, way restriction is on
        When I route I should get
            | from | to | route             | turns                                                               | locations   |
            | a    | d  | ab,be,ef,ef,de,de | depart,turn right,turn left,continue uturn,new name straight,arrive | a,b,e,f,e,d |
@@ -109,12 +109,3 @@ Feature: Car - Handle ferry routes
        When I route I should get
            | from | to | route     | modes       | time  |
            | c    | d  | bcde,bcde | ferry,ferry | 600s  |
-
-        Given the query options
-          | geometries     | geojson                  |
-          | overview       | full                     |
-
-        # Note that matching *should* work across unsnappable ferries
-        When I match I should get
-          | trace | geometry             | duration |
-          | abcdef| 1,1,1.000899,1,1.000899,1,1.002697,1,1.002697,1,1.003596,1,1.003596,1,1.005394,1,1.005394,1,1.006293,1 | 610.9      |
@@ -137,28 +137,3 @@ OSRM will use 4/5 of the projected free-flow speed.
            | primary |          |                  | 30                | -1     |         | 23 km/h |           | 6.7        |
            | primary | 20       | 30               |                   | -1     |         | 15 km/h |           | 4.4        |
            | primary | 20       |                  | 30                | -1     |         | 23 km/h |           | 6.7        |
-
-
-    Scenario: Car - Respect source:maxspeed
-        Given the node map
-            """
-            a b c d e f g
-            """
-
-        And the ways
-            | nodes | highway | source:maxspeed    | maxspeed |
-            | ab    | trunk   |                    |          |
-            | bc    | trunk   |                    | 60       |
-            | cd    | trunk   | FR:urban           |          |
-            | de    | trunk   | CH:rural           |          |
-            | ef    | trunk   | CH:trunk           |          |
-            | fg    | trunk   | CH:motorway        |          |
-
-        When I route I should get
-            | from | to | route | speed   |
-            | a    | b  | ab,ab | 85 km/h |
-            | b    | c  | bc,bc | 48 km/h |
-            | c    | d  | cd,cd | 40 km/h |
-            | d    | e  | de,de | 64 km/h |
-            | e    | f  | ef,ef | 80 km/h |
-            | f    | g  | fg,fg | 96 km/h |
@@ -43,7 +43,6 @@ Feature: Car - Handle physical limitation
            | primary | 1                  |           |       |
            | primary | 3                  |           | x     |
            | primary |                    | 1         |       |
-            | primary |                    | 8'        | x     |
            | primary |                    | 3         | x     |
            | primary |                    | default   | x     |
            | primary |                    | none      | x     |
@@ -63,7 +62,6 @@ Feature: Car - Handle physical limitation
            | highway | maxweight | bothw |
            | primary |           | x     |
            | primary | 1         |       |
-            | primary | 2         | x     |
            | primary | 3.5       | x     |
            | primary | 35000 kg  | x     |
            | primary | 8.9t      | x     |
@@ -798,6 +798,82 @@ Feature: Car - Turn restrictions
            | from | to | route       |
            | a    | d  | ab,be,de,de |

+    @restriction-way
+    Scenario: Multi Way restriction
+        Given the node map
+            """
+                  k   j
+                  |   |
+            h - - g - f - - e
+                  |   |
+                  |   |
+            a - - b - c - - d
+                  |   |
+                  l   i
+            """
+
+        And the ways
+            | nodes | name  | oneway |
+            | ab    | horiz | yes    |
+            | bc    | horiz | yes    |
+            | cd    | horiz | yes    |
+            | ef    | horiz | yes    |
+            | fg    | horiz | yes    |
+            | gh    | horiz | yes    |
+            | ic    | vert  | yes    |
+            | cf    | vert  | yes    |
+            | fj    | vert  | yes    |
+            | kg    | vert  | yes    |
+            | gb    | vert  | yes    |
+            | bl    | vert  | yes    |
+
+        And the relations
+            | type        | way:from | way:via  | way:to | restriction |
+            | restriction | ab       | bc,cf,fg | gh     | no_u_turn   |
+
+        When I route I should get
+            | from | to | route                  |
+            | a    | h  | horiz,vert,horiz,horiz |
+
+    @restriction-way
+    Scenario: Multi-Way overlapping single-way
+        Given the node map
+            """
+                    e
+                    |
+            a - b - c - d
+                |
+                f - g
+                |
+                h
+            """
+
+        And the ways
+            | nodes | name |
+            | ab    | abcd |
+            | bc    | abcd |
+            | cd    | abcd |
+            | hf    | hfb  |
+            | fb    | hfb  |
+            | gf    | gf   |
+            | ce    | ce   |
+
+        And the relations
+            | type        | way:from | way:via | way:to | restriction    |
+            | restriction | ab       | bc      | ce     | only_left_turn |
+            | restriction | gf       | fb,bc   | cd     | only_u_turn    |
+
+        When I route I should get
+            | from | to | route                | turns                                            | locations |
+            | a    | d  | abcd,ce,ce,abcd,abcd | depart,turn left,continue uturn,turn left,arrive | a,c,e,c,d |
+            | a    | e  | abcd,ce,ce           | depart,turn left,arrive                          | a,c,e     |
+            | a    | f  | abcd,hfb,hfb         | depart,turn right,arrive                         | a,b,f     |
+            | g    | e  | gf,hfb,abcd,ce,ce    | depart,turn right,turn right,turn left,arrive    | g,f,b,c,e |
+            | g    | d  | gf,hfb,abcd,abcd     | depart,turn right,turn right,arrive              | g,f,b,d   |
+            | h    | e  | hfb,abcd,ce,ce       | depart,end of road right,turn left,arrive        | h,b,c,e   |
+            | h    | d  | hfb,abcd,abcd        | depart,end of road right,arrive                  | h,b,d     |
+
+
    @restriction-way
    Scenario: Car - prohibit turn, traffic lights
        Given the node map
@@ -908,6 +984,8 @@ Feature: Car - Turn restrictions
            | restriction | ab       | bge     | de     | no_right_turn |
            | restriction | bc       | bge     | ef     | no_left_turn  |

+        # this case is currently not handling the via-way restrictions and we need support for looking across traffic signals.
+        # It is mainly included to show limitations and to prove that we don't crash hard here
        When I route I should get
            | from | to | route              |
            | a    | d  | ab,bge,ef,ef,de,de |
@@ -35,91 +35,3 @@ Feature: Car - Allowed start/end modes
            | from | to | route | modes           |
            | 1    | 2  | ab,ab | driving,driving |
            | 2    | 1  | ab,ab | driving,driving |
-
-    Scenario: Car - URL override of non-startpoints
-        Given the node map
-            """
-            a 1 b   c 2 d
-            """
-
-        Given the query options
-            | snapping  | any          |
-
-        And the ways
-            | nodes | highway | access  |
-            | ab    | service | private |
-            | bc    | primary |         |
-            | cd    | service | private |
-
-        When I request a travel time matrix I should get
-            |   | 2    | c    |
-            | 1 | 59.1 | 35.1 |
-            | b | 35.1 | 11.1 |
-
-        When I route I should get
-            | from | to | route    |
-            | 1    | 2  | ab,bc,cd |
-            | 2    | 1  | cd,bc,ab |
-
-    Scenario: Car - URL override of non-startpoints
-        Given the node map
-            """
-            a 1 b   c 2 d
-            """
-
-        Given the query options
-            | snapping  | any          |
-            | bearings  | 90,180;      |
-
-        And the ways
-            | nodes | highway | access  |
-            | ab    | service | private |
-            | bc    | primary |         |
-            | cd    | service | private |
-
-        When I route I should get
-            | from | to | route    |
-            | 1    | 2  | ab,bc,cd |
-            | 2    | 1  | cd,bc,ab |
-
-    Scenario: Car - URL override of non-startpoints
-        Given the node map
-            """
-            a 1 b   c 2 d
-            """
-
-        Given the query options
-            | snapping  | any           |
-            | radiuses  | 100;unlimited |
-
-        And the ways
-            | nodes | highway | access  |
-            | ab    | service | private |
-            | bc    | primary |         |
-            | cd    | service | private |
-
-        When I route I should get
-            | from | to | route    |
-            | 1    | 2  | ab,bc,cd |
-            | 2    | 1  | cd,bc,ab |
-
-    Scenario: Car - URL override of non-startpoints
-        Given the node map
-            """
-            a 1 b   c 2 d
-            """
-
-        Given the query options
-            | snapping  | any            |
-            | bearings  | 90,180;0,180;; |
-
-        And the ways
-            | nodes | highway | access  |
-            | ab    | service | private |
-            | bc    | primary |         |
-            | cd    | service | private |
-
-        When I request a travel time matrix I should get
-            |   | 2    | c    |
-            | 1 | 59.1 | 35.1 |
-            | b | 35.1 | 11.1 |
@@ -111,28 +111,3 @@ Feature: Locating Nearest node on a Way - basic projection onto way
            | 7  | b   |
            | 8  | a   |
            | 9  | b   |
-
-    Scenario: Nearest - easy-west way with flatbuffers
-        Given the node map
-            """
-            0 1 2 3 4
-              a x b
-            5 6 7 8 9
-            """
-
-        And the ways
-            | nodes |
-            | ab    |
-
-        When I request nearest with flatbuffers I should get
-            | in | out |
-            | 0  | a   |
-            | 1  | a   |
-            | 2  | x   |
-            | 3  | b   |
-            | 4  | b   |
-            | 5  | a   |
-            | 6  | a   |
-            | 7  | x   |
-            | 8  | b   |
-            | 9  | b   |
@@ -180,30 +180,3 @@ Feature: Turn Function Information
        And stdout should contain /roads_on_the_right \[1\] speed: [0-9]+, is_incoming: true, is_outgoing: false, highway_turn_classification: 3, access_turn_classification: 0/
        # turning abc, give information about about db
        And stdout should contain /roads_on_the_left \[1\] speed: [0-9]+, is_incoming: true, is_outgoing: false, highway_turn_classification: 0, access_turn_classification: 1/
-
-    Scenario: Turns should have correct information of two-way roads at intersection
-        Given the node map
-            """
-              b
-              |
-            a-c-d
-              |
-              e
-            """
-        And the ways
-            | nodes | highway       | oneway |
-            | ac    | motorway      | yes    |
-            | cd    | motorway_link | yes    |
-            | bc    | trunk         | yes    |
-            | cb    | trunk_link    | yes    |
-            | ce    | primary       | yes    |
-            | ec    | primary_link  | yes    |
-        And the data has been saved to disk
-
-        When I run "osrm-extract --profile {profile_file} {osm_file}"
-        Then it should exit successfully
-        # Turn acd
-        # on the left there should be cb (and bc)
-        And stdout should contain /roads_on_the_left \[1\] speed: [0-9]+, is_incoming: true, is_outgoing: true, highway_turn_classification: [0-9]+, access_turn_classification: 0, priority_class: 3/
-        # on the right there should be ce and ec
-        And stdout should contain /roads_on_the_right \[1\] speed: [0-9]+, is_incoming: true, is_outgoing: true, highway_turn_classification: [0-9]+, access_turn_classification: 0, priority_class: 4/
@@ -295,7 +295,7 @@ module.exports = function () {
        this.reprocess(callback);
    });

-    this.Given(/^osrm-routed is stopped$/, (callback) => {
+    this.Given(/^osrm\-routed is stopped$/, (callback) => {
        this.OSRMLoader.shutdown(callback);
    });

@@ -1,38 +1,27 @@
 var util = require('util');

-var flatbuffers = require('../support/flatbuffers').flatbuffers;
-var FBResult = require('../support/fbresult_generated').osrm.engine.api.fbresult.FBResult;
-
 module.exports = function () {
    const durationsRegex = new RegExp(/^I request a travel time matrix I should get$/);
    const distancesRegex = new RegExp(/^I request a travel distance matrix I should get$/);
    const estimatesRegex = new RegExp(/^I request a travel time matrix I should get estimates for$/);
-    const durationsRegexFb = new RegExp(/^I request a travel time matrix with flatbuffers I should get$/);
-    const distancesRegexFb = new RegExp(/^I request a travel distance matrix with flatbuffers I should get$/);

    const DURATIONS_NO_ROUTE = 2147483647;     // MAX_INT
    const DISTANCES_NO_ROUTE = 3.40282e+38;    // MAX_FLOAT

-    const FORMAT_JSON = 'json';
-    const FORMAT_FB = 'flatbuffers';
-
-    this.When(durationsRegex, function(table, callback) {tableParse.call(this, table, DURATIONS_NO_ROUTE, 'durations', FORMAT_JSON, callback);}.bind(this));
-    this.When(distancesRegex, function(table, callback) {tableParse.call(this, table, DISTANCES_NO_ROUTE, 'distances', FORMAT_JSON, callback);}.bind(this));
-    this.When(estimatesRegex, function(table, callback) {tableParse.call(this, table, DISTANCES_NO_ROUTE, 'fallback_speed_cells', FORMAT_JSON, callback);}.bind(this));
-    this.When(durationsRegexFb, function(table, callback) {tableParse.call(this, table, DURATIONS_NO_ROUTE, 'durations', FORMAT_FB, callback);}.bind(this));
-    this.When(distancesRegexFb, function(table, callback) {tableParse.call(this, table, DISTANCES_NO_ROUTE, 'distances', FORMAT_FB, callback);}.bind(this));
+    this.When(durationsRegex, function(table, callback) {tableParse.call(this, table, DURATIONS_NO_ROUTE, 'durations', callback);}.bind(this));
+    this.When(distancesRegex, function(table, callback) {tableParse.call(this, table, DISTANCES_NO_ROUTE, 'distances', callback);}.bind(this));
+    this.When(estimatesRegex, function(table, callback) {tableParse.call(this, table, DISTANCES_NO_ROUTE, 'fallback_speed_cells', callback);}.bind(this));
 };

 const durationsParse = function(v) { return isNaN(parseInt(v)); };
 const distancesParse = function(v) { return isNaN(parseFloat(v)); };
 const estimatesParse = function(v) { return isNaN(parseFloat(v)); };

-function tableParse(table, noRoute, annotation, format, callback) {
+function tableParse(table, noRoute, annotation, callback) {

    const parse = annotation == 'distances' ? distancesParse : (annotation == 'durations' ? durationsParse : estimatesParse);
    const params = this.queryParams;
    params.annotations = ['durations','fallback_speed_cells'].indexOf(annotation) !== -1 ? 'duration' : 'distance';
-    params.output = format;

    var tableRows = table.raw();

@@ -73,53 +62,27 @@ function tableParse(table, noRoute, annotation, format, callback) {
            if (err) return callback(err);
            if (!response.body.length) return callback(new Error('Invalid response body'));

-            var result = [];
-            if (format === 'json') {
-                var json = JSON.parse(response.body);
+            var json = JSON.parse(response.body);

-                if (annotation === 'fallback_speed_cells') {
-                    result = table.raw().map(row => row.map(() => ''));
-                    json[annotation].forEach(pair => {
-                        result[pair[0]+1][pair[1]+1] = 'Y';
+            var result = {};
+            if (annotation === 'fallback_speed_cells') {
+                result = table.raw().map(row => row.map(() => ''));
+                json[annotation].forEach(pair => {
+                    result[pair[0]+1][pair[1]+1] = 'Y';
+                });
+                result = result.slice(1).map(row => {
+                    var hashes = {};
+                    row.slice(1).forEach((v,i) => {
+                        hashes[tableRows[0][i+1]] = v;
                    });
-                    result = result.slice(1).map(row => {
-                        var hashes = {};
-                        row.slice(1).forEach((v,i) => {
-                            hashes[tableRows[0][i+1]] = v;
-                        });
-                        return hashes;
-                    });
-                } else {
-                    result = json[annotation].map(row => {
-                        var hashes = {};
-                        row.forEach((v, i) => { hashes[tableRows[0][i+1]] = parse(v) ? '' : v; });
-                        return hashes;
-                    });
-                }
-            } else { //flatbuffers
-                var body = response.body;
-                var bytes = new Uint8Array(body.length);
-                for (var indx = 0; indx < body.length; ++indx) {
-                    bytes[indx] = body.charCodeAt(indx);
-                }
-                var buf = new flatbuffers.ByteBuffer(bytes);
-                var fb = FBResult.getRootAsFBResult(buf);
-
-                var matrix;
-                if (annotation === 'durations') {
-                    matrix = fb.table().durationsArray();
-                }
-                if (annotation === 'distances') {
-                    matrix = fb.table().distancesArray();
-                }
-                var cols = fb.table().cols();
-                var rows = fb.table().rows();
-                for (let r = 0; r < rows; ++r) {
-                    result[r]={};
-                    for(let c=0; c < cols; ++c) {
-                        result[r][tableRows[0][c+1]] = matrix[r*cols + c];
-                    }
-                }
+                    return hashes;
+                });
+            } else {
+                result = json[annotation].map(row => {
+                    var hashes = {};
+                    row.forEach((v, i) => { hashes[tableRows[0][i+1]] = parse(v) ? '' : v; });
+                    return hashes;
+                });
            }

            var testRow = (row, ri, cb) => {
@@ -1,8 +1,5 @@
 var util = require('util');

-var flatbuffers = require('../support/flatbuffers').flatbuffers;
-var FBResult = require('../support/fbresult_generated').osrm.engine.api.fbresult.FBResult;
-
 module.exports = function () {
    this.When(/^I request nearest I should get$/, (table, callback) => {
        this.reprocessAndLoadData((e) => {
@@ -46,55 +43,4 @@ module.exports = function () {
            this.processRowsAndDiff(table, testRow, callback);
        });
    });
-
-    this.When(/^I request nearest with flatbuffers I should get$/, (table, callback) => {
-        this.reprocessAndLoadData((e) => {
-            if (e) return callback(e);
-            var testRow = (row, ri, cb) => {
-                var inNode = this.findNodeByName(row.in);
-                if (!inNode) throw new Error(util.format('*** unknown in-node "%s"', row.in));
-
-                var outNode = this.findNodeByName(row.out);
-                if (!outNode) throw new Error(util.format('*** unknown out-node "%s"', row.out));
-
-                this.queryParams.output = 'flatbuffers';
-                this.requestNearest(inNode, this.queryParams, (err, response) => {
-                    if (err) return cb(err);
-                    var coord;
-
-                    if (response.statusCode === 200 && response.body.length) {
-                        var body = response.body;
-                        var bytes = new Uint8Array(body.length);
-                        for (var indx = 0; indx < body.length; ++indx) {
-                            bytes[indx] = body.charCodeAt(indx);
-                        }
-                        var buf = new flatbuffers.ByteBuffer(bytes);
-                        var fb = FBResult.getRootAsFBResult(buf);
-                        var location = fb.waypoints(0).location();
-
-                        coord = [location.longitude(), location.latitude()];
-
-                        var got = { in: row.in, out: row.out };
-
-                        Object.keys(row).forEach((key) => {
-                            if (key === 'out') {
-                                if (this.FuzzyMatch.matchLocation(coord, outNode)) {
-                                    got[key] = row[key];
-                                } else {
-                                    row[key] = util.format('%s [%d,%d]', row[key], outNode.lat, outNode.lon);
-                                }
-                            }
-                        });
-
-                        cb(null, got);
-                    }
-                    else {
-                        cb();
-                    }
-                });
-            };
-
-            this.processRowsAndDiff(table, testRow, callback);
-        });
-    });
 };
@@ -21,11 +21,11 @@ module.exports = function () {
        });
    };

-    this.When(/^I run "osrm-routed\s?(.*?)"$/, { timeout: this.TIMEOUT }, (options, callback) => {
+    this.When(/^I run "osrm\-routed\s?(.*?)"$/, { timeout: this.TIMEOUT }, (options, callback) => {
        this.runAndSafeOutput('osrm-routed', options, callback);
    });

-    this.When(/^I run "osrm-(extract|contract|partition|customize)\s?(.*?)"$/, (binary, options, callback) => {
+    this.When(/^I run "osrm\-(extract|contract|partition|customize)\s?(.*?)"$/, (binary, options, callback) => {
        const stamp = this.processedCacheFile + '.stamp_' + binary;
        this.runAndSafeOutput('osrm-' + binary, options, (err) => {
            if (err) return callback(err);
@@ -33,11 +33,11 @@ module.exports = function () {
        });
    });

-    this.When(/^I try to run "(osrm-[a-z]+)\s?(.*?)"$/, (binary, options, callback) => {
+    this.When(/^I try to run "(osrm\-[a-z]+)\s?(.*?)"$/, (binary, options, callback) => {
        this.runAndSafeOutput(binary, options, () => { callback(); });
    });

-    this.When(/^I run "osrm-datastore\s?(.*?)"(?: with input "([^"]*)")?$/, (options, input, callback) => {
+    this.When(/^I run "osrm\-datastore\s?(.*?)"(?: with input "([^"]*)")?$/, (options, input, callback) => {
        let child = this.runAndSafeOutput('osrm-datastore', options, callback);
        if (input !== undefined)
            child.stdin.write(input);
@@ -55,13 +55,13 @@ module.exports = function () {
    this.Then(/^stdout should( not)? contain "(.*?)"$/, (not, str) => {
        const contains = this.stdout.indexOf(str) > -1;
        assert.ok(typeof not === 'undefined' ? contains : !contains,
-            'stdout ' + (typeof not === 'undefined' ? 'does not contain' : 'contains') + ' "' + str + '"');
+                  'stdout ' + (typeof not === 'undefined' ? 'does not contain' : 'contains') + ' "' + str + '"');
    });

    this.Then(/^stderr should( not)? contain "(.*?)"$/, (not, str) => {
        const contains = this.stderr.indexOf(str) > -1;
        assert.ok(typeof not === 'undefined' ? contains : !contains,
-            'stderr ' + (typeof not === 'undefined' ? 'does not contain' : 'contains') + ' "' + str + '"');
+                 'stderr ' + (typeof not === 'undefined' ? 'does not contain' : 'contains') + ' "' + str + '"');
    });

    this.Then(/^stdout should contain \/(.*)\/$/, (regexStr) => {
@@ -69,7 +69,7 @@ module.exports = function () {
                                outputRow[direction] = result[direction].status ?
                                    'x' : '';
                                break;
-                            case /^[\d.]+ s/.test(want):
+                            case /^[\d\.]+ s/.test(want):
                                // the result here can come back as a non-number value like
                                // `diff`, but we only want to apply the unit when it comes
                                // back as a number, for tableDiff's literal comparison
@@ -12,9 +12,4 @@ module.exports = function () {

        q.awaitAll(callback);
    });
-
-    this.Given(/^skip waypoints$/, (callback) => {
-        this.queryParams['skip_waypoints'] = true;
-        callback();
-    });
 };
@@ -29,7 +29,7 @@ module.exports = function() {

            // setup cache for feature data
            // if OSRM_PROFILE is set to force a specific profile, then
-            // include the profile name in the hash of the profile file
+             // include the profile name in the hash of the profile file
            hash.hashOfFile(uri, this.OSRM_PROFILE, (err, hash) => {
                if (err) return callback(err);

@@ -45,10 +45,10 @@ module.exports = function() {
                this.featureProcessedCacheDirectories[uri] = featureProcessedCacheDirectory;

                d3.queue(1)
-                    .defer(mkdirp, featureProcessedCacheDirectory)
-                    .defer(this.cleanupFeatureCache.bind(this), featureCacheDirectory, hash)
-                    .defer(this.cleanupProcessedFeatureCache.bind(this), featureProcessedCacheDirectory, this.osrmHash)
-                    .awaitAll(callback);
+                  .defer(mkdirp, featureProcessedCacheDirectory)
+                  .defer(this.cleanupFeatureCache.bind(this), featureCacheDirectory, hash)
+                  .defer(this.cleanupProcessedFeatureCache.bind(this), featureProcessedCacheDirectory, this.osrmHash)
+                  .awaitAll(callback);
            });
        }

@@ -87,7 +87,7 @@ module.exports = function() {
        fs.readdir(parentPath, (err, files) => {
            let q = d3.queue();
            files.filter(name => { return name !== featureHash;})
-                .map((f) => { q.defer(rimraf, path.join(parentPath, f)); });
+                 .map((f) => { q.defer(rimraf, path.join(parentPath, f)); });
            q.awaitAll(callback);
        });
    };
@@ -114,12 +114,9 @@ module.exports = function() {
        let dependencies = [
            this.OSRM_EXTRACT_PATH,
            this.OSRM_CONTRACT_PATH,
-            this.OSRM_CUSTOMIZE_PATH,
-            this.OSRM_PARTITION_PATH,
            this.LIB_OSRM_EXTRACT_PATH,
-            this.LIB_OSRM_CONTRACT_PATH,
-            this.LIB_OSRM_CUSTOMIZE_PATH,
-            this.LIB_OSRM_PARTITION_PATH
+            this.LIB_OSRM_GUIDANCE_PATH,
+            this.LIB_OSRM_CONTRACT_PATH
        ];

        var addLuaFiles = (directory, callback) => {
@@ -148,7 +145,7 @@ module.exports = function() {

    // converts the scenario titles in file prefixes
    this.getScenarioID = (scenario) => {
-        let name = scenario.getName().toLowerCase().replace(/[/\-'=,():*#]/g, '')
+        let name = scenario.getName().toLowerCase().replace(/[\/\-'=,\(\):\*#]/g, '')
            .replace(/\s/g, '_').replace(/__/g, '_').replace(/\.\./g, '.')
            .substring(0, 64);
        return util.format('%d_%s', scenario.getLine(), name);
@@ -17,12 +17,12 @@ module.exports = {
                return true;

            var matchPercent = want.match(/(.*)\s+~(.+)%$/),
-                matchAbs = want.match(/(.*)\s+\+-(.+)$/),
+                matchAbs = want.match(/(.*)\s+\+\-(.+)$/),
                matchRe = want.match(/^\/(.*)\/$/),
                // we use this for matching before/after bearing
-                matchBearingListAbs = want.match(/^((\d+)->(\d+))(,(\d+)->(\d+))*\s+\+-(.+)$/),
-                matchIntersectionListAbs = want.match(/^(((((true|false):\d+)\s{0,1})+,{0,1})+;{0,1})+\s+\+-(.+)$/),
-                matchRangeNumbers = want.match(/\d+\+-\d+/);
+                matchBearingListAbs = want.match(/^((\d+)->(\d+))(,(\d+)->(\d+))*\s+\+\-(.+)$/),
+                matchIntersectionListAbs = want.match(/^(((((true|false):\d+)\s{0,1})+,{0,1})+;{0,1})+\s+\+\-(.+)$/),
+                matchRangeNumbers = want.match(/\d+\+\-\d+/);

            function inRange(margin, got, want) {
                var fromR = parseFloat(want) - margin,
@@ -31,12 +31,12 @@ module.exports = {
            }
            function parseIntersectionString(str) {
                return str.split(';')
-                    .map((turn_intersections) => turn_intersections
-                        .split(',')
-                        .map((intersection) => intersection
-                            .split(' ')
-                            .map((entry_bearing_pair) => entry_bearing_pair
-                                .split(':'))));
+                          .map((turn_intersections) => turn_intersections
+                                                       .split(',')
+                                                       .map((intersection) => intersection
+                                                                               .split(' ')
+                                                                               .map((entry_bearing_pair) => entry_bearing_pair
+                                                                                                            .split(':'))));
            }

            if (got === want) {
@@ -22,9 +22,14 @@ module.exports = function () {
        this.PROFILES_PATH = path.resolve(this.ROOT_PATH, 'profiles');
        this.FIXTURES_PATH = path.resolve(this.ROOT_PATH, 'unit_tests/fixtures');
        this.BIN_PATH = process.env.OSRM_BUILD_DIR && process.env.OSRM_BUILD_DIR || path.resolve(this.ROOT_PATH, 'build');
+        var stxxl_config = path.resolve(this.ROOT_PATH, 'test/.stxxl');
+        if (!fs.existsSync(stxxl_config)) {
+            return callback(new Error('*** '+stxxl_config+ 'does not exist'));
+        }
+
        this.DATASET_NAME = 'cucumber';
        this.PLATFORM_WINDOWS = process.platform.match(/^win.*/);
-        this.DEFAULT_ENVIRONMENT = process.env;
+        this.DEFAULT_ENVIRONMENT = Object.assign({STXXLCFG: stxxl_config}, process.env);
        this.DEFAULT_PROFILE = 'bicycle';
        this.DEFAULT_INPUT_FORMAT = 'osm';
        this.DEFAULT_LOAD_METHOD = process.argv[process.argv.indexOf('-m') +1].match('mmap') ? 'mmap' : 'datastore';
@@ -67,13 +72,10 @@ module.exports = function () {

        this.OSRM_EXTRACT_PATH = path.resolve(util.format('%s/%s%s', this.BIN_PATH, 'osrm-extract', this.EXE));
        this.OSRM_CONTRACT_PATH = path.resolve(util.format('%s/%s%s', this.BIN_PATH, 'osrm-contract', this.EXE));
-        this.OSRM_CUSTOMIZE_PATH = path.resolve(util.format('%s/%s%s', this.BIN_PATH, 'osrm-customize', this.EXE));
-        this.OSRM_PARTITION_PATH = path.resolve(util.format('%s/%s%s', this.BIN_PATH, 'osrm-partition', this.EXE));
        this.OSRM_ROUTED_PATH = path.resolve(util.format('%s/%s%s', this.BIN_PATH, 'osrm-routed', this.EXE));
        this.LIB_OSRM_EXTRACT_PATH = util.format('%s/' + this.LIB, this.BIN_PATH, 'osrm_extract'),
+        this.LIB_OSRM_GUIDANCE_PATH = util.format('%s/' + this.LIB, this.BIN_PATH, 'osrm_guidance'),
        this.LIB_OSRM_CONTRACT_PATH = util.format('%s/' + this.LIB, this.BIN_PATH, 'osrm_contract'),
-        this.LIB_OSRM_CUSTOMIZE_PATH = util.format('%s/' + this.LIB, this.BIN_PATH, 'osrm_customize'),
-        this.LIB_OSRM_PARTITION_PATH = util.format('%s/' + this.LIB, this.BIN_PATH, 'osrm_partition'),
        this.LIB_OSRM_PATH = util.format('%s/' + this.LIB, this.BIN_PATH, 'osrm');

        // eslint-disable-next-line no-console
@@ -114,7 +116,7 @@ module.exports = function () {
        };

        var q = d3.queue();
-        [this.OSRM_EXTRACT_PATH, this.OSRM_CONTRACT_PATH, this.OSRM_CUSTOMIZE_PATH, this.OSRM_PARTITION_PATH, this.OSRM_ROUTED_PATH].forEach(bin => { q.defer(verify, bin); });
+        [this.OSRM_EXTRACT_PATH, this.OSRM_CONTRACT_PATH, this.OSRM_ROUTED_PATH].forEach(bin => { q.defer(verify, bin); });
        q.awaitAll(callback);
    };

@@ -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['#'];
@@ -119,7 +115,7 @@ module.exports = function () {

                        if (headers.has('weight')) {
                            if (row.weight.length) {
-                                if (!row.weight.match(/[\d.]+/))
+                                if (!row.weight.match(/[\d\.]+/))
                                    return cb(new Error('*** Weight must be specified as a numeric value. (ex: 8)'));
                                got.weight = instructions ? util.format('%d', weight) : '';
                            } else {
@@ -155,14 +151,7 @@ module.exports = function () {
                        if (headers.has('locations')){
                            got.locations = (locations || '').trim();
                        }
-                        if (headers.has('waypoints_count')) {
-                            if ('waypoints' in json) {
-                                got.waypoints_count = json.waypoints.length;
-                            } else{
-                                got.waypoints_count = 0;
-                            }
-                        }
-                        /*
+/*
                        if (headers.has('approaches')){
                            got.approaches = (approaches || '').trim();
                        }*/
@@ -17,43 +17,9 @@ Feature: Basic Routing
            | ab    |

        When I route I should get
-            | from | to | route    | data_version | waypoints_count |
-            | a    | b  | ab,ab    |              | 2               |
-            | b    | a  | ab,ab    |              | 2               |
-
-    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 |
-
-    Scenario: Skip_waypoints test
-        Given the node map
-            """
-            a b
-            """
-
-        And skip waypoints
-
-        And the ways
-            | nodes |
-            | ab    |
-
-        When I route I should get
-            | from | to | route    | waypoints_count       |
-            | a    | b  | ab,ab    | 0                     |
-            | b    | a  | ab,ab    | 0                     |
+            | from | to | route    |
+            | a    | b  | ab,ab    |
+            | b    | a  | ab,ab    |

    Scenario: Routing in between two nodes of way
        Given the node map
@@ -616,7 +616,7 @@ Feature: Basic Distance Matrix
            |   | a      | b      | f     | 1      |
            | a | 0      | 300.2  | 900.7 | 1501.1 |
            | b | 300.2  | 0      | 600.5 | 1200.9 |
-            | f | 900.7  | 600.5  | 0     | 300.2  |
+            | f | 900.7  | 600.5  | 0     | 302.2  |
            | 1 | 1501.1 | 1200.9 | 300.2 | 0      |

        When I request a travel distance matrix I should get
@@ -651,7 +651,7 @@ Feature: Basic Distance Matrix
            |   | a      | b      | f     | 1      |
            | a | 0      | 300.2  | 900.7 | 1501.1 |
            | b | 300.2  | 0      | 600.5 | 1200.9 |
-            | f | 900.7  | 600.5  | 0     | 300.2  |
+            | f | 900.7  | 600.5  | 0     | 302.2  |
            | 1 | 1501.1 | 1200.9 | 300.2 | 0      |

        When I request a travel distance matrix I should get
@@ -687,7 +687,7 @@ Feature: Basic Distance Matrix
            |   | a      | b     | f     | 1      |
            | a | 0      | 300.2 | 900.7 | 1200.9 |
            | b | 300.2  | 0     | 600.5 | 900.7  |
-            | f | 900.7  | 600.5 | 0     | 300.2  |
+            | f | 900.7  | 600.5 | 0     | 302.2  |
            | 1 | 1200.9 | 900.7 | 300.2 | 0      |

        When I request a travel distance matrix I should get
@@ -701,25 +701,3 @@ Feature: Basic Distance Matrix
            | f | 900.7  |
            | 1 | 1200.9 |

-    Scenario: Ensure consistency with route, and make sure offsets work in both directions
-        Given a grid size of 100 meters
-        Given the node map
-            """
-            a   b   c   d   e   f   g   h  i  j
-                  1                   2
-            """
-
-        And the ways
-            | nodes |
-            | abcdef  |
-            | fghij  |
-
-        When I route I should get
-            | from | to | route              | distance |
-            | 1    | 2  | abcdef,fghij,fghij | 999.9m  |
-
-        # TODO: this is "correct", but inconsistent with viaroute
-        When I request a travel distance matrix I should get
-            |   |   1    | 2      |
-            | 1 |   0    | 1000.7 |
-            | 2 | 1000.7 | 0      |
@@ -21,21 +21,6 @@ Feature: Basic Duration Matrix
            | a | 0  | 10 |
            | b | 10 | 0  |

-    Scenario: Testbot - Travel time matrix of minimal network requested with flatbuffer format
-        Given the node map
-            """
-            a b
-            """
-
-        And the ways
-            | nodes |
-            | ab    |
-
-        When I request a travel time matrix with flatbuffers I should get
-            |   | a  | b  |
-            | a | 0  | 10 |
-            | b | 10 | 0  |
-
    @ch
    Scenario: Testbot - Travel time matrix of minimal network with toll exclude
        Given the query options
@@ -111,9 +111,9 @@ Feature: Multi level routing
        When I request a travel distance matrix I should get
            |   | a      | f      | l      | o      |
            | a | 0      | 2383.7 | 1566.9 | 1366.8 |
-            | f | 2383.7 | 0      | 1293.3 | 1617.3 |
-            | l | 1566.9 | 1293.3 | 0      | 800.5  |
-            | o | 1366.8 | 1617.3 | 800.5  | 0      |
+            | f | 2339.9 | 0      | 1198.1 | 1522.1 |
+            | l | 1618.3 | 1293.3 | 0      | 800.5  |
+            | o | 1418.2 | 1617.3 | 800.5  | 0      |

        When I request a travel distance matrix I should get
            |   | a | f      | l      | o      |
@@ -122,21 +122,21 @@ Feature: Multi level routing
        When I request a travel distance matrix I should get
            |   | a      |
            | a | 0      |
-            | f | 2383.7 |
-            | l | 1566.9 |
-            | o | 1366.8 |
+            | f | 2339.9 |
+            | l | 1618.3 |
+            | o | 1418.2 |

        When I request a travel distance matrix I should get
            |   | a      | f      | l      | o      |
            | a | 0      | 2383.7 | 1566.9 | 1366.8 |
-            | f | 2383.7 | 0      | 1293.3 | 1617.3 |
+            | f | 2339.9 | 0      | 1198.1 | 1522.1 |

        When I request a travel distance matrix I should get
            |   | a      | o      |
            | a | 0      | 1366.8 |
-            | f | 2383.7 | 1617.3 |
-            | l | 1566.9 | 800.5  |
-            | o | 1366.8 | 0      |
+            | f | 2339.9 | 1522.1 |
+            | l | 1618.3 | 800.5  |
+            | o | 1418.2 | 0      |

    Scenario: Testbot - Multi level routing: horizontal road
        Given the node map
@@ -1,18 +1,18 @@
@routing @testbot @nil
-Feature: Testbot - Check assigning empty values
-    Scenario: Assign empty values to all way strings
+Feature: Testbot - Check assigning nil values
+    Scenario: Assign nil values to all way strings
        Given the profile file
        """
        functions = require('testbot')

        function way_function(profile, way, result)
-          result.name = ""
-          result.ref = ""
-          result.destinations = ""
-          result.exits = ""
-          result.pronunciation = ""
-          result.turn_lanes_forward = ""
-          result.turn_lanes_backward = ""
+          result.name = nil
+          result.ref = nil
+          result.destinations = nil
+          result.exits = nil
+          result.pronunciation = nil
+          result.turn_lanes_forward = nil
+          result.turn_lanes_backward = nil

          result.forward_speed = 10
          result.backward_speed = 10
@@ -1,85 +0,0 @@
-@routing @testbot @oneway
-Feature: Handle multiple phantom nodes in one-way segment
-
-# Check we handle routes where source and destination are
-# phantom nodes on the same one-way segment.
-# See: https://github.com/Project-OSRM/osrm-backend/issues/5788
-
-    Background:
-    Given the profile "testbot"
-
-    Scenario: One-way segment with adjacent phantom nodes
-    Given the node map
-        """
-        d  c
-
-        a12b
-        """
-
-    And the ways
-       | nodes | oneway |
-       | ab    | yes    |
-       | bc    | no     |
-       | cd    | no     |
-       | da    | no     |
-
-    When I route I should get
-       | from | to | route          | time      | distance |
-       | 1    | 2  | ab,ab          | 5s  +-0.1 | 50m  ~1% |
-       | 1    | c  | ab,bc,bc       | 30s +-0.1 | 300m ~1% |
-       | 2    | 1  | ab,bc,cd,da,ab | 65s +-0.1 | 650m ~1% |
-       | 2    | c  | ab,bc,bc       | 25s +-0.1 | 250m ~1% |
-       | c    | 1  | cd,da,ab       | 40s +-0.1 | 400m ~1% |
-       | c    | 2  | cd,da,ab       | 45s +-0.1 | 450m ~1% |
-
-    When I request a travel time matrix I should get
-       |   | 1        | 2        | c         |
-       | 1 | 0        | 5  +-0.1 | 30 +-0.1  |
-       | 2 | 65 +-0.1 | 0        | 25 +-0.1  |
-       | c | 40 +-0.1 | 45 +-0.1 | 0         |
-
-    When I request a travel time matrix I should get
-       |   | 1  | 2       | c        |
-       | 1 | 0  | 5 +-0.1 | 30 +-0.1 |
-
-    When I request a travel time matrix I should get
-       |   | 1        | 2  | c        |
-       | 2 | 65 +-0.1 | 0  | 25 +-0.1 |
-
-    When I request a travel time matrix I should get
-       |   | 1        |
-       | 1 | 0        |
-       | 2 | 65 +-0.1 |
-       | c | 40 +-0.1 |
-
-    When I request a travel time matrix I should get
-       |   | 2        |
-       | 1 | 5  +-0.1 |
-       | 2 | 0        |
-       | c | 45 +-0.1 |
-
-    When I request a travel distance matrix I should get
-       |   | 1       | 2       | c       |
-       | 1 | 0       | 50  ~1% | 300 ~1% |
-       | 2 | 650 ~1% | 0       | 250 ~1% |
-       | c | 400 ~1% | 450 ~1% | 0       |
-
-    When I request a travel distance matrix I should get
-       |   | 1   | 2      | c       |
-       | 1 | 0   | 50 ~1% | 300 ~1% |
-
-    When I request a travel distance matrix I should get
-       |   | 1       | 2   | c       |
-       | 2 | 650 ~1% | 0   | 250 ~1% |
-
-    When I request a travel distance matrix I should get
-       |   | 1       |
-       | 1 | 0       |
-       | 2 | 650 ~1% |
-       | c | 400 ~1% |
-
-    When I request a travel distance matrix I should get
-       |   | 2       |
-       | 1 | 50  ~1% |
-       | 2 | 0       |
-       | c | 450 ~1% |
@@ -182,4 +182,4 @@ Feature: Snap start/end point to the nearest way
            | x    | m  | xe,xe |
            | x    | n  | xf,xf |
            | x    | o  | xg,xg |
-            | x    | p  | xh,xh |
+            | x    | p  | xh,xh |
@@ -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
@@ -93,31 +93,6 @@ Feature: Check zero speed updates
          |    1 |  2 | NoRoute |


-    Scenario: Routing with alternatives on restricted way
-        Given the node map
-            """
-            a-1-b-2-c
-            """
-
-        And the ways
-            | nodes | oneway |
-            | abc   | no     |
-        And the contract extra arguments "--segment-speed-file {speeds_file}"
-        And the customize extra arguments "--segment-speed-file {speeds_file}"
-        And the speed file
-            """
-            1,2,0
-            2,1,0
-            """
-        And the query options
-            | alternatives | true |
-
-
-        When I route I should get
-          | from | to | code    | alternative |
-          |    1 |  2 | NoRoute |             |
-
-
    Scenario: Routing on restricted oneway
        Given the node map
            """
@@ -94,7 +94,7 @@ inline auto contractExcludableGraph(ContractorGraph contractor_graph_,
    return GraphAndFilter{QueryGraph{num_nodes, std::move(edge_container.edges)},
                          edge_container.MakeEdgeFilters()};
 }
-} // namespace contractor
-} // namespace osrm
+}
+}

 #endif
@@ -164,7 +164,7 @@ struct ContractedEdgeContainer
    std::vector<MergedFlags> flags;
    std::vector<QueryEdge> edges;
 };
-} // namespace contractor
-} // namespace osrm
+}
+}

 #endif
@@ -15,11 +15,11 @@ template <storage::Ownership Ownership> struct ContractedMetric
    detail::QueryGraph<Ownership> graph;
    std::vector<util::ViewOrVector<bool, Ownership>> edge_filter;
 };
-} // namespace detail
+}

 using ContractedMetric = detail::ContractedMetric<storage::Ownership::Container>;
 using ContractedMetricView = detail::ContractedMetric<storage::Ownership::View>;
-} // namespace contractor
-} // namespace osrm
+}
+}

 #endif
@@ -49,7 +49,7 @@ class Contractor
  private:
    ContractorConfig config;
 };
-} // namespace contractor
-} // namespace osrm
+}
+}

 #endif // PROCESSING_CHAIN_HPP
@@ -73,7 +73,7 @@ struct ContractorConfig final : storage::IOConfig
    //(e.g. 0.8 contracts 80 percent of the hierarchy, leaving a core of 20%)
    double core_factor;
 };
-} // namespace contractor
-} // namespace osrm
+}
+}

 #endif // EXTRACTOR_OPTIONS_HPP
@@ -125,7 +125,7 @@ struct RangebasedCRC32
  private:
    IteratorbasedCRC32 crc32;
 };
-} // namespace contractor
-} // namespace osrm
+}
+}

 #endif /* ITERATOR_BASED_CRC32_H */
@@ -52,8 +52,8 @@ inline void writeGraph(const boost::filesystem::path &path,
        serialization::write(writer, "/ch/metrics/" + pair.first, pair.second);
    }
 }
-} // namespace files
-} // namespace contractor
-} // namespace osrm
+}
+}
+}

 #endif
@@ -77,7 +77,7 @@ struct QueryEdge
                data.distance == right.data.distance);
    }
 };
-} // namespace contractor
-} // namespace osrm
+}
+}

 #endif // QUERYEDGE_HPP
@@ -19,7 +19,7 @@ using QueryGraph = util::StaticGraph<typename QueryEdge::EdgeData, Ownership>;

 using QueryGraph = detail::QueryGraph<storage::Ownership::Container>;
 using QueryGraphView = detail::QueryGraph<storage::Ownership::View>;
-} // namespace contractor
-} // namespace osrm
+}
+}

 #endif // QUERYEDGE_HPP
@@ -46,8 +46,8 @@ void read(storage::tar::FileReader &reader,
                                     metric.edge_filter[index]);
    }
 }
-} // namespace serialization
-} // namespace contractor
-} // namespace osrm
+}
+}
+}

 #endif
@@ -212,8 +212,9 @@ class CellCustomizer
            }

            const auto &data = graph.GetEdgeData(edge);
-            if (data.forward && (first_level || partition.GetCell(level - 1, node) !=
-                                                    partition.GetCell(level - 1, to)))
+            if (data.forward &&
+                (first_level ||
+                 partition.GetCell(level - 1, node) != partition.GetCell(level - 1, to)))
            {
                const EdgeWeight to_weight = weight + data.weight;
                const EdgeDuration to_duration = duration + data.duration;
@@ -236,7 +237,7 @@ class CellCustomizer

    const partitioner::MultiLevelPartition &partition;
 };
-} // namespace customizer
-} // namespace osrm
+}
+}

 #endif // OSRM_CELLS_CUSTOMIZER_HPP
@@ -22,11 +22,11 @@ template <storage::Ownership Ownership> struct CellMetricImpl
    Vector<EdgeDuration> durations;
    Vector<EdgeDistance> distances;
 };
-} // namespace detail
+}

 using CellMetric = detail::CellMetricImpl<storage::Ownership::Container>;
 using CellMetricView = detail::CellMetricImpl<storage::Ownership::View>;
-} // namespace customizer
-} // namespace osrm
+}
+}

 #endif
@@ -39,7 +39,7 @@ struct CustomizationConfig final : storage::IOConfig

    updater::UpdaterConfig updater_config;
 };
-} // namespace customizer
-} // namespace osrm
+}
+}

 #endif // OSRM_CUSTOMIZE_CUSTOMIZER_CONFIG_HPP
@@ -34,7 +34,7 @@ template <typename EdgeDataT, storage::Ownership Ownership>
 void write(storage::tar::FileWriter &writer,
           const std::string &name,
           const MultiLevelGraph<EdgeDataT, Ownership> &graph);
-} // namespace serialization
+}

 template <typename EdgeDataT, storage::Ownership Ownership>
 class MultiLevelGraph : public partitioner::MultiLevelGraph<EdgeDataT, Ownership>
@@ -126,7 +126,7 @@ using MultiLevelEdgeBasedGraph =
    MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::Container>;
 using MultiLevelEdgeBasedGraphView =
    MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::View>;
-} // namespace customizer
-} // namespace osrm
+}
+}

 #endif
@@ -106,8 +106,8 @@ inline void writeGraph(const boost::filesystem::path &path,
    writer.WriteFrom("/mld/connectivity_checksum", connectivity_checksum);
    serialization::write(writer, "/mld/multilevelgraph", graph);
 }
-} // namespace files
-} // namespace customizer
-} // namespace osrm
+}
+}
+}

 #endif
@@ -65,8 +65,8 @@ inline void write(storage::tar::FileWriter &writer,
    storage::serialization::write(writer, name + "/is_backward_edge", graph.is_backward_edge);
    storage::serialization::write(writer, name + "/node_to_edge_offset", graph.node_to_edge_offset);
 }
-} // namespace serialization
-} // namespace customizer
-} // namespace osrm
+}
+}
+}

 #endif
@@ -16,14 +16,14 @@ namespace ch
 struct Algorithm final
 {
 };
-} // namespace ch
+}
 // Multi-Level Dijkstra
 namespace mld
 {
 struct Algorithm final
 {
 };
-} // namespace mld
+}

 // Algorithm names
 template <typename AlgorithmT> const char *name();
@@ -111,8 +111,8 @@ template <> struct HasGetTileTurns<mld::Algorithm> final : std::true_type
 template <> struct HasExcludeFlags<mld::Algorithm> final : std::true_type
 {
 };
-} // namespace routing_algorithms
-} // namespace engine
-} // namespace osrm
+}
+}
+}

 #endif
@@ -2,7 +2,6 @@
 #define ENGINE_API_BASE_API_HPP

 #include "engine/api/base_parameters.hpp"
-#include "engine/api/flatbuffers/fbresult_generated.h"
 #include "engine/datafacade/datafacade_base.hpp"

 #include "engine/api/json_factory.hpp"
@@ -12,7 +11,6 @@
 #include <boost/assert.hpp>
 #include <boost/range/algorithm/transform.hpp>

-#include <memory>
 #include <vector>

 namespace osrm
@@ -73,63 +71,12 @@ class BaseAPI
        }
    }

-    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbresult::Waypoint>>>
-    MakeWaypoints(flatbuffers::FlatBufferBuilder *builder,
-                  const std::vector<PhantomNodes> &segment_end_coordinates) const
-    {
-        BOOST_ASSERT(parameters.coordinates.size() > 0);
-        BOOST_ASSERT(parameters.coordinates.size() == segment_end_coordinates.size() + 1);
-
-        std::vector<flatbuffers::Offset<fbresult::Waypoint>> waypoints;
-        waypoints.resize(parameters.coordinates.size());
-        waypoints[0] =
-            MakeWaypoint(builder, segment_end_coordinates.front().source_phantom)->Finish();
-
-        std::transform(segment_end_coordinates.begin(),
-                       segment_end_coordinates.end(),
-                       std::next(waypoints.begin()),
-                       [this, builder](const PhantomNodes &phantom_pair) {
-                           return MakeWaypoint(builder, phantom_pair.target_phantom)->Finish();
-                       });
-        return builder->CreateVector(waypoints);
-    }
-
-    // FIXME: gcc 4.9 does not like MakeWaypoints to be protected
-    // protected:
-    std::unique_ptr<fbresult::WaypointBuilder> MakeWaypoint(flatbuffers::FlatBufferBuilder *builder,
-                                                            const PhantomNode &phantom) const
-    {
-
-        auto location =
-            fbresult::Position(static_cast<double>(util::toFloating(phantom.location.lon)),
-                               static_cast<double>(util::toFloating(phantom.location.lat)));
-        auto name_string = builder->CreateString(
-            facade.GetNameForID(facade.GetNameIndex(phantom.forward_segment_id.id)).to_string());
-
-        flatbuffers::Offset<flatbuffers::String> hint_string;
-        if (parameters.generate_hints)
-        {
-            hint_string = builder->CreateString(Hint{phantom, facade.GetCheckSum()}.ToBase64());
-        }
-
-        auto waypoint = std::make_unique<fbresult::WaypointBuilder>(*builder);
-        waypoint->add_location(&location);
-        waypoint->add_distance(util::coordinate_calculation::fccApproximateDistance(
-            phantom.location, phantom.input_location));
-        waypoint->add_name(name_string);
-        if (parameters.generate_hints)
-        {
-            waypoint->add_hint(hint_string);
-        }
-        return waypoint;
-    }
-
    const datafacade::BaseDataFacade &facade;
    const BaseParameters &parameters;
 };

-} // namespace api
-} // namespace engine
-} // namespace osrm
+} // ns api
+} // ns engine
+} // ns osrm

 #endif
@@ -63,50 +63,29 @@ namespace api
 */
 struct BaseParameters
 {
-
-    enum class SnappingType
-    {
-        Default,
-        Any
-    };
-
-    enum class OutputFormatType
-    {
-        JSON,
-        FLATBUFFERS
-    };
-
    std::vector<util::Coordinate> coordinates;
    std::vector<boost::optional<Hint>> hints;
    std::vector<boost::optional<double>> radiuses;
    std::vector<boost::optional<Bearing>> bearings;
    std::vector<boost::optional<Approach>> approaches;
    std::vector<std::string> exclude;
-    boost::optional<OutputFormatType> format = OutputFormatType::JSON;

    // Adds hints to response which can be included in subsequent requests, see `hints` above.
    bool generate_hints = true;

-    // Remove waypoints array from the response.
-    bool skip_waypoints = false;
-
-    SnappingType snapping = SnappingType::Default;
-
-    BaseParameters(std::vector<util::Coordinate> coordinates_ = {},
-                   std::vector<boost::optional<Hint>> hints_ = {},
+    BaseParameters(const std::vector<util::Coordinate> coordinates_ = {},
+                   const std::vector<boost::optional<Hint>> hints_ = {},
                   std::vector<boost::optional<double>> radiuses_ = {},
                   std::vector<boost::optional<Bearing>> bearings_ = {},
                   std::vector<boost::optional<Approach>> approaches_ = {},
                   bool generate_hints_ = true,
-                   std::vector<std::string> exclude = {},
-                   const SnappingType snapping_ = SnappingType::Default)
-        : coordinates(std::move(coordinates_)), hints(std::move(hints_)),
-          radiuses(std::move(radiuses_)), bearings(std::move(bearings_)),
-          approaches(std::move(approaches_)), exclude(std::move(exclude)),
-          generate_hints(generate_hints_), snapping(snapping_)
+                   std::vector<std::string> exclude = {})
+        : coordinates(coordinates_), hints(hints_), radiuses(radiuses_), bearings(bearings_),
+          approaches(approaches_), exclude(std::move(exclude)), generate_hints(generate_hints_)
    {
    }

+    // FIXME add validation for invalid bearing values
    bool IsValid() const
    {
        return (hints.empty() || hints.size() == coordinates.size()) &&
@@ -115,7 +94,7 @@ struct BaseParameters
               (approaches.empty() || approaches.size() == coordinates.size()) &&
               std::all_of(bearings.begin(),
                           bearings.end(),
-                           [](const boost::optional<Bearing> &bearing_and_range) {
+                           [](const boost::optional<Bearing> bearing_and_range) {
                               if (bearing_and_range)
                               {
                                   return bearing_and_range->IsValid();
@@ -124,8 +103,8 @@ struct BaseParameters
                           });
    }
 };
-} // namespace api
-} // namespace engine
-} // namespace osrm
+}
+}
+}

 #endif // ROUTE_PARAMETERS_HPP
@@ -1,23 +0,0 @@
-#ifndef ENGINE_API_BASE_RESULT_HPP
-#define ENGINE_API_BASE_RESULT_HPP
-
-#include <flatbuffers/flatbuffers.h>
-#include <mapbox/variant.hpp>
-
-#include <string>
-
-#include "util/json_container.hpp"
-
-namespace osrm
-{
-namespace engine
-{
-namespace api
-{
-using ResultT =
-    mapbox::util::variant<util::json::Object, std::string, flatbuffers::FlatBufferBuilder>;
-} // namespace api
-} // namespace engine
-} // namespace osrm
-
-#endif
@@ -1,20 +0,0 @@
-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: Table;
-}
-
-root_type FBResult;
@@ -1,6 +0,0 @@
-namespace osrm.engine.api.fbresult;
-
-struct Position {
-    longitude: float;
-    latitude:  float;
-}
@@ -1,110 +0,0 @@
-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];
-}
@@ -1,11 +0,0 @@
-include "waypoint.fbs";
-namespace osrm.engine.api.fbresult;
-
-table Table {
-    durations: [float];
-    rows: ushort;
-    cols: ushort;
-    distances: [float];
-    destinations: [Waypoint];
-    fallback_speed_cells: [uint];
-}
@@ -1,19 +0,0 @@
-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
-}
@@ -33,18 +33,6 @@ namespace json
 namespace detail
 {

-// Check whether to include a modifier in the result of the API
-inline bool isValidModifier(const guidance::StepManeuver maneuver)
-{
-    return (maneuver.waypoint_type == guidance::WaypointType::None ||
-            maneuver.instruction.direction_modifier != osrm::guidance::DirectionModifier::UTurn);
-}
-
-inline bool hasValidLanes(const guidance::IntermediateIntersection &intersection)
-{
-    return intersection.lanes.lanes_in_turn > 0;
-}
-
 util::json::Array coordinateToLonLat(const util::Coordinate &coordinate);

 /**
@@ -112,8 +100,8 @@ util::json::Object makeRouteLeg(guidance::RouteLeg leg, util::json::Array steps)
 util::json::Array makeRouteLegs(std::vector<guidance::RouteLeg> legs,
                                std::vector<util::json::Value> step_geometries,
                                std::vector<util::json::Object> annotations);
-} // namespace json
-} // namespace api
+}
+}
 } // namespace engine
 } // namespace osrm

@@ -29,44 +29,6 @@ class MatchAPI final : public RouteAPI
    {
    }

-    void MakeResponse(const std::vector<map_matching::SubMatching> &sub_matchings,
-                      const std::vector<InternalRouteResult> &sub_routes,
-                      osrm::engine::api::ResultT &response) const
-    {
-        BOOST_ASSERT(sub_matchings.size() == sub_routes.size());
-        if (response.is<flatbuffers::FlatBufferBuilder>())
-        {
-            auto &fb_result = response.get<flatbuffers::FlatBufferBuilder>();
-            MakeResponse(sub_matchings, sub_routes, fb_result);
-        }
-        else
-        {
-            auto &json_result = response.get<util::json::Object>();
-            MakeResponse(sub_matchings, sub_routes, json_result);
-        }
-    }
-    void MakeResponse(const std::vector<map_matching::SubMatching> &sub_matchings,
-                      const std::vector<InternalRouteResult> &sub_routes,
-                      flatbuffers::FlatBufferBuilder &fb_result) const
-    {
-        auto data_timestamp = facade.GetTimestamp();
-        flatbuffers::Offset<flatbuffers::String> data_version_string;
-        if (!data_timestamp.empty())
-        {
-            data_version_string = fb_result.CreateString(data_timestamp);
-        }
-
-        auto response = MakeFBResponse(sub_routes, fb_result, [this, &fb_result, &sub_matchings]() {
-            return MakeTracepoints(fb_result, sub_matchings);
-        });
-
-        if (!data_timestamp.empty())
-        {
-            response->add_data_version(data_version_string);
-        }
-
-        fb_result.Finish(response->Finish());
-    }
    void MakeResponse(const std::vector<map_matching::SubMatching> &sub_matchings,
                      const std::vector<InternalRouteResult> &sub_routes,
                      util::json::Object &response) const
@@ -74,6 +36,7 @@ class MatchAPI final : public RouteAPI
        auto number_of_routes = sub_matchings.size();
        util::json::Array routes;
        routes.values.reserve(number_of_routes);
+        BOOST_ASSERT(sub_matchings.size() == sub_routes.size());
        for (auto index : util::irange<std::size_t>(0UL, sub_matchings.size()))
        {
            auto route = MakeRoute(sub_routes[index].segment_end_coordinates,
@@ -83,10 +46,7 @@ class MatchAPI final : public RouteAPI
            route.values["confidence"] = sub_matchings[index].confidence;
            routes.values.push_back(std::move(route));
        }
-        if (!parameters.skip_waypoints)
-        {
-            response.values["tracepoints"] = MakeTracepoints(sub_matchings);
-        }
+        response.values["tracepoints"] = MakeTracepoints(sub_matchings);
        response.values["matchings"] = std::move(routes);
        response.values["code"] = "Ok";
    }
@@ -95,87 +55,47 @@ class MatchAPI final : public RouteAPI
    // FIXME this logic is a little backwards. We should change the output format of the
    // map_matching
    // routing algorithm to be easier to consume here.
-    struct MatchingIndex
-    {
-        MatchingIndex() = default;
-        MatchingIndex(unsigned sub_matching_index_, unsigned point_index_)
-            : sub_matching_index(sub_matching_index_), point_index(point_index_)
-        {
-        }
-
-        unsigned sub_matching_index = std::numeric_limits<unsigned>::max();
-        unsigned point_index = std::numeric_limits<unsigned>::max();
-
-        bool NotMatched()
-        {
-            return sub_matching_index == std::numeric_limits<unsigned>::max() &&
-                   point_index == std::numeric_limits<unsigned>::max();
-        }
-    };
-
-    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbresult::Waypoint>>>
-    MakeTracepoints(flatbuffers::FlatBufferBuilder &fb_result,
-                    const std::vector<map_matching::SubMatching> &sub_matchings) const
-    {
-        std::vector<flatbuffers::Offset<fbresult::Waypoint>> waypoints;
-        waypoints.reserve(parameters.coordinates.size());
-
-        auto trace_idx_to_matching_idx = MakeMatchingIndices(sub_matchings);
-
-        BOOST_ASSERT(parameters.waypoints.empty() || sub_matchings.size() == 1);
-
-        std::size_t was_waypoint_idx = 0;
-        for (auto trace_index : util::irange<std::size_t>(0UL, parameters.coordinates.size()))
-        {
-
-            if (tidy_result.can_be_removed[trace_index])
-            {
-                waypoints.push_back(fbresult::WaypointBuilder(fb_result).Finish());
-                continue;
-            }
-            auto matching_index = trace_idx_to_matching_idx[trace_index];
-            if (matching_index.NotMatched())
-            {
-                waypoints.push_back(fbresult::WaypointBuilder(fb_result).Finish());
-                continue;
-            }
-            const auto &phantom =
-                sub_matchings[matching_index.sub_matching_index].nodes[matching_index.point_index];
-            auto waypoint = BaseAPI::MakeWaypoint(&fb_result, phantom);
-            waypoint->add_matchings_index(matching_index.sub_matching_index);
-            waypoint->add_alternatives_count(sub_matchings[matching_index.sub_matching_index]
-                                                 .alternatives_count[matching_index.point_index]);
-            // waypoint indices need to be adjusted if route legs were collapsed
-            // waypoint parameter assumes there is only one match object
-            if (!parameters.waypoints.empty())
-            {
-                if (tidy_result.was_waypoint[trace_index])
-                {
-                    waypoint->add_waypoint_index(was_waypoint_idx);
-                    was_waypoint_idx++;
-                }
-                else
-                {
-                    waypoint->add_waypoint_index(0);
-                }
-            }
-            else
-            {
-                waypoint->add_waypoint_index(matching_index.point_index);
-            }
-            waypoints.push_back(waypoint->Finish());
-        }
-
-        return fb_result.CreateVector(waypoints);
-    }
-
    util::json::Array
    MakeTracepoints(const std::vector<map_matching::SubMatching> &sub_matchings) const
    {
        util::json::Array waypoints;
        waypoints.values.reserve(parameters.coordinates.size());

-        auto trace_idx_to_matching_idx = MakeMatchingIndices(sub_matchings);
+        struct MatchingIndex
+        {
+            MatchingIndex() = default;
+            MatchingIndex(unsigned sub_matching_index_, unsigned point_index_)
+                : sub_matching_index(sub_matching_index_), point_index(point_index_)
+            {
+            }
+
+            unsigned sub_matching_index = std::numeric_limits<unsigned>::max();
+            unsigned point_index = std::numeric_limits<unsigned>::max();
+
+            bool NotMatched()
+            {
+                return sub_matching_index == std::numeric_limits<unsigned>::max() &&
+                       point_index == std::numeric_limits<unsigned>::max();
+            }
+        };
+
+        std::vector<MatchingIndex> trace_idx_to_matching_idx(parameters.coordinates.size());
+        for (auto sub_matching_index :
+             util::irange(0u, static_cast<unsigned>(sub_matchings.size())))
+        {
+            for (auto point_index : util::irange(
+                     0u, static_cast<unsigned>(sub_matchings[sub_matching_index].indices.size())))
+            {
+                // tidied_to_original: index of the input coordinate that a tidied coordinate
+                // corresponds to.
+                // sub_matching indices: index of the coordinate passed to map matching plugin that
+                // a matched node corresponds to.
+                trace_idx_to_matching_idx[tidy_result
+                                              .tidied_to_original[sub_matchings[sub_matching_index]
+                                                                      .indices[point_index]]] =
+                    MatchingIndex{sub_matching_index, point_index};
+            }
+        }

        BOOST_ASSERT(parameters.waypoints.empty() || sub_matchings.size() == 1);

@@ -221,35 +141,12 @@ class MatchAPI final : public RouteAPI
        return waypoints;
    }

-    std::vector<MatchingIndex>
-    MakeMatchingIndices(const std::vector<map_matching::SubMatching> &sub_matchings) const
-    {
-        std::vector<MatchingIndex> trace_idx_to_matching_idx(parameters.coordinates.size());
-        for (auto sub_matching_index :
-             util::irange(0u, static_cast<unsigned>(sub_matchings.size())))
-        {
-            for (auto point_index : util::irange(
-                     0u, static_cast<unsigned>(sub_matchings[sub_matching_index].indices.size())))
-            {
-                // tidied_to_original: index of the input coordinate that a tidied coordinate
-                // corresponds to.
-                // sub_matching indices: index of the coordinate passed to map matching plugin that
-                // a matched node corresponds to.
-                trace_idx_to_matching_idx[tidy_result
-                                              .tidied_to_original[sub_matchings[sub_matching_index]
-                                                                      .indices[point_index]]] =
-                    MatchingIndex{sub_matching_index, point_index};
-            }
-        }
-        return trace_idx_to_matching_idx;
-    }
-
    const MatchParameters &parameters;
    const tidy::Result &tidy_result;
 };

-} // namespace api
-} // namespace engine
-} // namespace osrm
+} // ns api
+} // ns engine
+} // ns osrm

 #endif
@@ -63,16 +63,13 @@ struct MatchParameters : public RouteParameters
                          RouteParameters::GeometriesType::Polyline,
                          RouteParameters::OverviewType::Simplified,
                          {}),
-          gaps(GapsType::Split), tidy(false)
+          gaps(GapsType::Split), tidy(false), waypoints()
    {
    }

    template <typename... Args>
-    MatchParameters(const std::vector<unsigned> &timestamps_,
-                    GapsType gaps_,
-                    bool tidy_,
-                    Args &&... args_)
-        : MatchParameters(timestamps_, gaps_, tidy_, {}, std::forward<Args>(args_)...)
+    MatchParameters(std::vector<unsigned> timestamps_, GapsType gaps_, bool tidy_, Args... args_)
+        : MatchParameters(std::move(timestamps_), gaps_, tidy_, {}, std::forward<Args>(args_)...)
    {
    }

@@ -80,26 +77,30 @@ struct MatchParameters : public RouteParameters
    MatchParameters(std::vector<unsigned> timestamps_,
                    GapsType gaps_,
                    bool tidy_,
-                    const std::vector<std::size_t> &waypoints_,
-                    Args &&... args_)
-        : RouteParameters{std::forward<Args>(args_)..., waypoints_}, timestamps{std::move(
-                                                                         timestamps_)},
-          gaps(gaps_), tidy(tidy_)
+                    std::vector<std::size_t> waypoints_,
+                    Args... args_)
+        : 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;
    }
 };
-} // namespace api
-} // namespace engine
-} // namespace osrm
+}
+}
+}

 #endif
@@ -200,9 +200,9 @@ inline Result tidy(const MatchParameters &params, Thresholds cfg = {15., 5})
    return result;
 }

-} // namespace tidy
-} // namespace api
-} // namespace engine
-} // namespace osrm
+} // ns tidy
+} // ns api
+} // ns engine
+} // ns osrm

 #endif
@@ -2,7 +2,6 @@
 #define ENGINE_API_NEAREST_API_HPP

 #include "engine/api/base_api.hpp"
-#include "engine/api/base_result.hpp"
 #include "engine/api/nearest_parameters.hpp"

 #include "engine/api/json_factory.hpp"
@@ -28,139 +27,71 @@ class NearestAPI final : public BaseAPI
    }

    void MakeResponse(const std::vector<std::vector<PhantomNodeWithDistance>> &phantom_nodes,
-                      osrm::engine::api::ResultT &response) const
+                      util::json::Object &response) const
    {
        BOOST_ASSERT(phantom_nodes.size() == 1);
        BOOST_ASSERT(parameters.coordinates.size() == 1);

-        if (response.is<flatbuffers::FlatBufferBuilder>())
-        {
-            auto &fb_result = response.get<flatbuffers::FlatBufferBuilder>();
-            MakeResponse(phantom_nodes, fb_result);
-        }
-        else
-        {
-            auto &json_result = response.get<util::json::Object>();
-            MakeResponse(phantom_nodes, json_result);
-        }
-    }
+        util::json::Array waypoints;
+        waypoints.values.resize(phantom_nodes.front().size());
+        std::transform(
+            phantom_nodes.front().begin(),
+            phantom_nodes.front().end(),
+            waypoints.values.begin(),
+            [this](const PhantomNodeWithDistance &phantom_with_distance) {
+                auto &phantom_node = phantom_with_distance.phantom_node;
+                auto waypoint = MakeWaypoint(phantom_node);

-    void MakeResponse(const std::vector<std::vector<PhantomNodeWithDistance>> &phantom_nodes,
-                      flatbuffers::FlatBufferBuilder &fb_result) const
-    {
-        auto data_timestamp = facade.GetTimestamp();
-        boost::optional<flatbuffers::Offset<flatbuffers::String>> data_version_string = boost::none;
-        if (!data_timestamp.empty())
-        {
-            data_version_string = fb_result.CreateString(data_timestamp);
-        }
+                util::json::Array nodes;

-        flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbresult::Waypoint>>>
-            waypoints_vector;
-        if (!parameters.skip_waypoints)
-        {
-            std::vector<flatbuffers::Offset<fbresult::Waypoint>> waypoints;
-            waypoints.resize(phantom_nodes.front().size());
-            std::transform(
-                phantom_nodes.front().begin(),
-                phantom_nodes.front().end(),
-                waypoints.begin(),
-                [this, &fb_result](const PhantomNodeWithDistance &phantom_with_distance) {
-                    auto &phantom_node = phantom_with_distance.phantom_node;
+                std::uint64_t from_node = 0;
+                std::uint64_t to_node = 0;

-                    auto node_values = MakeNodes(phantom_node);
-                    fbresult::Uint64Pair nodes{node_values.first, node_values.second};
+                datafacade::BaseDataFacade::NodeForwardRange forward_geometry;
+                if (phantom_node.forward_segment_id.enabled)
+                {
+                    auto segment_id = phantom_node.forward_segment_id.id;
+                    const auto geometry_id = facade.GetGeometryIndex(segment_id).id;
+                    forward_geometry = facade.GetUncompressedForwardGeometry(geometry_id);

-                    auto waypoint = MakeWaypoint(&fb_result, phantom_node);
-                    waypoint->add_nodes(&nodes);
-                    return waypoint->Finish();
-                });
+                    auto osm_node_id = facade.GetOSMNodeIDOfNode(
+                        forward_geometry(phantom_node.fwd_segment_position));
+                    to_node = static_cast<std::uint64_t>(osm_node_id);
+                }

-            waypoints_vector = fb_result.CreateVector(waypoints);
-        }
+                if (phantom_node.reverse_segment_id.enabled)
+                {
+                    auto segment_id = phantom_node.reverse_segment_id.id;
+                    const auto geometry_id = facade.GetGeometryIndex(segment_id).id;
+                    const auto geometry = facade.GetUncompressedForwardGeometry(geometry_id);
+                    auto osm_node_id =
+                        facade.GetOSMNodeIDOfNode(geometry(phantom_node.fwd_segment_position + 1));
+                    from_node = static_cast<std::uint64_t>(osm_node_id);
+                }
+                else if (phantom_node.forward_segment_id.enabled &&
+                         phantom_node.fwd_segment_position > 0)
+                {
+                    // In the case of one way, rely on forward segment only
+                    auto osm_node_id = facade.GetOSMNodeIDOfNode(
+                        forward_geometry(phantom_node.fwd_segment_position - 1));
+                    from_node = static_cast<std::uint64_t>(osm_node_id);
+                }
+                nodes.values.push_back(from_node);
+                nodes.values.push_back(to_node);
+                waypoint.values["nodes"] = std::move(nodes);

-        fbresult::FBResultBuilder response(fb_result);
-
-        response.add_waypoints(waypoints_vector);
-        if (data_version_string)
-        {
-            response.add_data_version(*data_version_string);
-        }
-        fb_result.Finish(response.Finish());
-    }
-    void MakeResponse(const std::vector<std::vector<PhantomNodeWithDistance>> &phantom_nodes,
-                      util::json::Object &response) const
-    {
-        if (!parameters.skip_waypoints)
-        {
-            util::json::Array waypoints;
-            waypoints.values.resize(phantom_nodes.front().size());
-            std::transform(phantom_nodes.front().begin(),
-                           phantom_nodes.front().end(),
-                           waypoints.values.begin(),
-                           [this](const PhantomNodeWithDistance &phantom_with_distance) {
-                               auto &phantom_node = phantom_with_distance.phantom_node;
-                               auto waypoint = MakeWaypoint(phantom_node);
-
-                               util::json::Array nodes;
-
-                               auto node_values = MakeNodes(phantom_node);
-
-                               nodes.values.push_back(node_values.first);
-                               nodes.values.push_back(node_values.second);
-                               waypoint.values["nodes"] = std::move(nodes);
-
-                               return waypoint;
-                           });
-            response.values["waypoints"] = std::move(waypoints);
-        }
+                return waypoint;
+            });

        response.values["code"] = "Ok";
+        response.values["waypoints"] = std::move(waypoints);
    }

    const NearestParameters &parameters;
-
-  protected:
-    std::pair<uint64_t, uint64_t> MakeNodes(const PhantomNode &phantom_node) const
-    {
-        std::uint64_t from_node = 0;
-        std::uint64_t to_node = 0;
-
-        datafacade::BaseDataFacade::NodeForwardRange forward_geometry;
-        if (phantom_node.forward_segment_id.enabled)
-        {
-            auto segment_id = phantom_node.forward_segment_id.id;
-            const auto geometry_id = facade.GetGeometryIndex(segment_id).id;
-            forward_geometry = facade.GetUncompressedForwardGeometry(geometry_id);
-
-            auto osm_node_id =
-                facade.GetOSMNodeIDOfNode(forward_geometry(phantom_node.fwd_segment_position));
-            to_node = static_cast<std::uint64_t>(osm_node_id);
-        }
-
-        if (phantom_node.reverse_segment_id.enabled)
-        {
-            auto segment_id = phantom_node.reverse_segment_id.id;
-            const auto geometry_id = facade.GetGeometryIndex(segment_id).id;
-            const auto geometry = facade.GetUncompressedForwardGeometry(geometry_id);
-            auto osm_node_id =
-                facade.GetOSMNodeIDOfNode(geometry(phantom_node.fwd_segment_position + 1));
-            from_node = static_cast<std::uint64_t>(osm_node_id);
-        }
-        else if (phantom_node.forward_segment_id.enabled && phantom_node.fwd_segment_position > 0)
-        {
-            // In the case of one way, rely on forward segment only
-            auto osm_node_id =
-                facade.GetOSMNodeIDOfNode(forward_geometry(phantom_node.fwd_segment_position - 1));
-            from_node = static_cast<std::uint64_t>(osm_node_id);
-        }
-
-        return std::make_pair(from_node, to_node);
-    }
 };

-} // namespace api
-} // namespace engine
-} // namespace osrm
+} // ns api
+} // ns engine
+} // ns osrm

 #endif
@@ -52,8 +52,8 @@ struct NearestParameters : public BaseParameters

    bool IsValid() const { return BaseParameters::IsValid() && number_of_results >= 1; }
 };
-} // namespace api
-} // namespace engine
-} // namespace osrm
+}
+}
+}

 #endif // ENGINE_API_NEAREST_PARAMETERS_HPP
@@ -3,7 +3,6 @@

 #include "extractor/maneuver_override.hpp"
 #include "engine/api/base_api.hpp"
-#include "engine/api/base_result.hpp"
 #include "engine/api/json_factory.hpp"
 #include "engine/api/route_parameters.hpp"

@@ -45,58 +44,11 @@ class RouteAPI : public BaseAPI
    {
    }

-    void
-    MakeResponse(const InternalManyRoutesResult &raw_routes,
-                 const std::vector<PhantomNodes>
-                     &all_start_end_points, // all used coordinates, ignoring waypoints= parameter
-                 osrm::engine::api::ResultT &response) const
+    void MakeResponse(const InternalManyRoutesResult &raw_routes,
+                      util::json::Object &response) const
    {
        BOOST_ASSERT(!raw_routes.routes.empty());

-        if (response.is<flatbuffers::FlatBufferBuilder>())
-        {
-            auto &fb_result = response.get<flatbuffers::FlatBufferBuilder>();
-            MakeResponse(raw_routes, all_start_end_points, fb_result);
-        }
-        else
-        {
-            auto &json_result = response.get<util::json::Object>();
-            MakeResponse(raw_routes, all_start_end_points, json_result);
-        }
-    }
-
-    void
-    MakeResponse(const InternalManyRoutesResult &raw_routes,
-                 const std::vector<PhantomNodes>
-                     &all_start_end_points, // all used coordinates, ignoring waypoints= parameter
-                 flatbuffers::FlatBufferBuilder &fb_result) const
-    {
-
-        auto data_timestamp = facade.GetTimestamp();
-        flatbuffers::Offset<flatbuffers::String> data_version_string;
-        if (!data_timestamp.empty())
-        {
-            data_version_string = fb_result.CreateString(data_timestamp);
-        }
-
-        auto response =
-            MakeFBResponse(raw_routes, fb_result, [this, &all_start_end_points, &fb_result]() {
-                return BaseAPI::MakeWaypoints(&fb_result, all_start_end_points);
-            });
-
-        if (!data_timestamp.empty())
-        {
-            response->add_data_version(data_version_string);
-        }
-        fb_result.Finish(response->Finish());
-    }
-
-    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
-    {
        util::json::Array jsRoutes;

        for (const auto &route : raw_routes.routes)
@@ -110,115 +62,28 @@ class RouteAPI : public BaseAPI
                                                route.target_traversed_in_reverse));
        }

-        if (!parameters.skip_waypoints)
-        {
-            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:
-    template <typename GetWptsFn>
-    std::unique_ptr<fbresult::FBResultBuilder>
-    MakeFBResponse(const InternalManyRoutesResult &raw_routes,
-                   flatbuffers::FlatBufferBuilder &fb_result,
-                   GetWptsFn getWaypoints) const
-    {
-
-        std::vector<flatbuffers::Offset<fbresult::RouteObject>> routes;
-        for (const auto &raw_route : raw_routes.routes)
-        {
-            if (!raw_route.is_valid())
-                continue;
-
-            routes.push_back(MakeRoute(fb_result,
-                                       raw_route.segment_end_coordinates,
-                                       raw_route.unpacked_path_segments,
-                                       raw_route.source_traversed_in_reverse,
-                                       raw_route.target_traversed_in_reverse));
-        }
-
-        auto routes_vector = fb_result.CreateVector(routes);
-        flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbresult::Waypoint>>>
-            waypoints_vector;
-        if (!parameters.skip_waypoints)
-        {
-            waypoints_vector = getWaypoints();
-        }
-
-        auto response = std::make_unique<fbresult::FBResultBuilder>(fb_result);
-        response->add_routes(routes_vector);
-        response->add_waypoints(waypoints_vector);
-
-        return response;
-    }
-
    template <typename ForwardIter>
-    mapbox::util::variant<flatbuffers::Offset<flatbuffers::String>,
-                          flatbuffers::Offset<flatbuffers::Vector<const fbresult::Position *>>>
-    MakeGeometry(flatbuffers::FlatBufferBuilder &builder, ForwardIter begin, ForwardIter end) const
+    util::json::Value MakeGeometry(ForwardIter begin, ForwardIter end) const
    {
        if (parameters.geometries == RouteParameters::GeometriesType::Polyline)
        {
-            return builder.CreateString(encodePolyline<100000>(begin, end));
+            return json::makePolyline<100000>(begin, end);
        }
-        else if (parameters.geometries == RouteParameters::GeometriesType::Polyline6)
+
+        if (parameters.geometries == RouteParameters::GeometriesType::Polyline6)
        {
-            return builder.CreateString(encodePolyline<1000000>(begin, end));
-        }
-        std::vector<fbresult::Position> coordinates;
-        coordinates.resize(std::distance(begin, end));
-        std::transform(begin, end, coordinates.begin(), [](const Coordinate &c) {
-            return fbresult::Position{static_cast<float>(util::toFloating(c.lon).__value),
-                                      static_cast<float>(util::toFloating(c.lat).__value)};
-        });
-        return builder.CreateVectorOfStructs(coordinates);
-    }
-
-    boost::optional<util::json::Value>
-    MakeGeometry(boost::optional<std::vector<Coordinate>> &&annotations) const
-    {
-        boost::optional<util::json::Value> json_geometry;
-        if (annotations)
-        {
-            auto begin = annotations->begin();
-            auto end = annotations->end();
-            if (parameters.geometries == RouteParameters::GeometriesType::Polyline)
-            {
-                json_geometry = json::makePolyline<100000>(begin, end);
-            }
-            else if (parameters.geometries == RouteParameters::GeometriesType::Polyline6)
-            {
-                json_geometry = json::makePolyline<1000000>(begin, end);
-            }
-            else
-            {
-                BOOST_ASSERT(parameters.geometries == RouteParameters::GeometriesType::GeoJSON);
-                json_geometry = json::makeGeoJSONGeometry(begin, end);
-            }
-        }
-        return json_geometry;
-    }
-
-    template <typename ValueType, typename GetFn>
-    flatbuffers::Offset<flatbuffers::Vector<ValueType>> GetAnnotations(
-        flatbuffers::FlatBufferBuilder &fb_result, guidance::LegGeometry &leg, GetFn Get) const
-    {
-        std::vector<ValueType> annotations_store;
-        annotations_store.reserve(leg.annotations.size());
-
-        for (const auto &step : leg.annotations)
-        {
-            annotations_store.push_back(Get(step));
+            return json::makePolyline<1000000>(begin, end);
        }

-        return fb_result.CreateVector(annotations_store);
+        BOOST_ASSERT(parameters.geometries == RouteParameters::GeometriesType::GeoJSON);
+        return json::makeGeoJSONGeometry(begin, end);
    }

    template <typename GetFn>
@@ -235,491 +100,118 @@ class RouteAPI : public BaseAPI
        return annotations_store;
    }

-    fbresult::ManeuverType WaypointTypeToFB(guidance::WaypointType type) const
-    {
-        switch (type)
-        {
-        case guidance::WaypointType::Arrive:
-            return fbresult::ManeuverType_Arrive;
-        case guidance::WaypointType::Depart:
-            return fbresult::ManeuverType_Depart;
-        default:
-            return fbresult::ManeuverType_Notification;
-        }
-    }
-
-    fbresult::ManeuverType TurnTypeToFB(osrm::guidance::TurnType::Enum turn) const
-    {
-        static std::map<osrm::guidance::TurnType::Enum, fbresult::ManeuverType> mappings = {
-            {osrm::guidance::TurnType::Invalid, fbresult::ManeuverType_Notification},
-            {osrm::guidance::TurnType::NewName, fbresult::ManeuverType_NewName},
-            {osrm::guidance::TurnType::Continue, fbresult::ManeuverType_Continue},
-            {osrm::guidance::TurnType::Turn, fbresult::ManeuverType_Turn},
-            {osrm::guidance::TurnType::Merge, fbresult::ManeuverType_Merge},
-            {osrm::guidance::TurnType::OnRamp, fbresult::ManeuverType_OnRamp},
-            {osrm::guidance::TurnType::OffRamp, fbresult::ManeuverType_OffRamp},
-            {osrm::guidance::TurnType::Fork, fbresult::ManeuverType_Fork},
-            {osrm::guidance::TurnType::EndOfRoad, fbresult::ManeuverType_EndOfRoad},
-            {osrm::guidance::TurnType::Notification, fbresult::ManeuverType_Notification},
-            {osrm::guidance::TurnType::EnterRoundabout, fbresult::ManeuverType_Roundabout},
-            {osrm::guidance::TurnType::EnterAndExitRoundabout,
-             fbresult::ManeuverType_ExitRoundabout},
-            {osrm::guidance::TurnType::EnterRotary, fbresult::ManeuverType_Rotary},
-            {osrm::guidance::TurnType::EnterAndExitRotary, fbresult::ManeuverType_ExitRotary},
-            {osrm::guidance::TurnType::EnterRoundaboutIntersection,
-             fbresult::ManeuverType_Roundabout},
-            {osrm::guidance::TurnType::EnterAndExitRoundaboutIntersection,
-             fbresult::ManeuverType_ExitRoundabout},
-            {osrm::guidance::TurnType::NoTurn, fbresult::ManeuverType_Notification},
-            {osrm::guidance::TurnType::Suppressed, fbresult::ManeuverType_Notification},
-            {osrm::guidance::TurnType::EnterRoundaboutAtExit, fbresult::ManeuverType_Roundabout},
-            {osrm::guidance::TurnType::ExitRoundabout, fbresult::ManeuverType_ExitRoundabout},
-            {osrm::guidance::TurnType::EnterRotaryAtExit, fbresult::ManeuverType_Rotary},
-            {osrm::guidance::TurnType::ExitRotary, fbresult::ManeuverType_ExitRotary},
-            {osrm::guidance::TurnType::EnterRoundaboutIntersectionAtExit,
-             fbresult::ManeuverType_Roundabout},
-            {osrm::guidance::TurnType::ExitRoundaboutIntersection,
-             fbresult::ManeuverType_ExitRoundabout},
-            {osrm::guidance::TurnType::StayOnRoundabout, fbresult::ManeuverType_RoundaboutTurn},
-            {osrm::guidance::TurnType::Sliproad, fbresult::ManeuverType_Notification},
-            {osrm::guidance::TurnType::MaxTurnType, fbresult::ManeuverType_Notification}};
-        return mappings[turn];
-    }
-
-    fbresult::Turn TurnModifierToFB(osrm::guidance::DirectionModifier::Enum modifier) const
-    {
-        static std::map<osrm::guidance::DirectionModifier::Enum, fbresult::Turn> mappings = {
-            {osrm::guidance::DirectionModifier::UTurn, fbresult::Turn_UTurn},
-            {osrm::guidance::DirectionModifier::SharpRight, fbresult::Turn_SharpRight},
-            {osrm::guidance::DirectionModifier::Right, fbresult::Turn_Right},
-            {osrm::guidance::DirectionModifier::SlightRight, fbresult::Turn_SlightRight},
-            {osrm::guidance::DirectionModifier::Straight, fbresult::Turn_Straight},
-            {osrm::guidance::DirectionModifier::SlightLeft, fbresult::Turn_SlightLeft},
-            {osrm::guidance::DirectionModifier::Left, fbresult::Turn_Left},
-            {osrm::guidance::DirectionModifier::SharpLeft, fbresult::Turn_SharpLeft},
-        };
-        return mappings[modifier];
-    }
-
-    std::vector<int8_t> TurnLaneTypeToFB(const extractor::TurnLaneType::Mask lane_type) const
-    {
-        const static fbresult::Turn mapping[] = {fbresult::Turn_None,
-                                                 fbresult::Turn_Straight,
-                                                 fbresult::Turn_SharpLeft,
-                                                 fbresult::Turn_Left,
-                                                 fbresult::Turn_SlightLeft,
-                                                 fbresult::Turn_SlightRight,
-                                                 fbresult::Turn_Right,
-                                                 fbresult::Turn_SharpRight,
-                                                 fbresult::Turn_UTurn,
-                                                 fbresult::Turn_SlightLeft,
-                                                 fbresult::Turn_SlightRight};
-        std::vector<int8_t> result;
-        std::bitset<8 * sizeof(extractor::TurnLaneType::Mask)> mask(lane_type);
-        for (auto index : util::irange<std::size_t>(0, extractor::TurnLaneType::NUM_TYPES))
-        {
-            if (mask[index])
-            {
-                result.push_back(mapping[index]);
-            }
-        }
-        return result;
-    }
-
-    flatbuffers::Offset<fbresult::RouteObject>
-    MakeRoute(flatbuffers::FlatBufferBuilder &fb_result,
-              const std::vector<PhantomNodes> &segment_end_coordinates,
-              const std::vector<std::vector<PathData>> &unpacked_path_segments,
-              const std::vector<bool> &source_traversed_in_reverse,
-              const std::vector<bool> &target_traversed_in_reverse) const
-    {
-        auto legs_info = MakeLegs(segment_end_coordinates,
-                                  unpacked_path_segments,
-                                  source_traversed_in_reverse,
-                                  target_traversed_in_reverse);
-        std::vector<guidance::RouteLeg> legs = legs_info.first;
-        std::vector<guidance::LegGeometry> leg_geometries = legs_info.second;
-        auto route = guidance::assembleRoute(legs);
-
-        // Fill legs
-        std::vector<flatbuffers::Offset<fbresult::Leg>> routeLegs;
-        routeLegs.reserve(legs.size());
-        for (const auto idx : util::irange<std::size_t>(0UL, legs.size()))
-        {
-            auto leg = legs[idx];
-            auto &leg_geometry = leg_geometries[idx];
-
-            // Fill steps
-            std::vector<flatbuffers::Offset<fbresult::Step>> legSteps;
-            if (!leg.steps.empty())
-            {
-                legSteps.resize(leg.steps.size());
-                std::transform(leg.steps.begin(),
-                               leg.steps.end(),
-                               legSteps.begin(),
-                               [this, &fb_result, &leg_geometry](auto &step) {
-                                   return this->MakeFBStep(fb_result, leg_geometry, step);
-                               });
-            }
-            auto steps_vector = fb_result.CreateVector(legSteps);
-
-            // Fill annotations
-            // To maintain support for uses of the old default constructors, we check
-            // if annotations property was set manually after default construction
-            auto requested_annotations = parameters.annotations_type;
-            if ((parameters.annotations == true) &&
-                (parameters.annotations_type == RouteParameters::AnnotationsType::None))
-            {
-                requested_annotations = RouteParameters::AnnotationsType::All;
-            }
-
-            flatbuffers::Offset<fbresult::Annotation> annotation_buffer;
-            if (requested_annotations != RouteParameters::AnnotationsType::None)
-            {
-                annotation_buffer =
-                    MakeFBAnnotations(fb_result, leg_geometry, requested_annotations);
-            }
-
-            flatbuffers::Offset<flatbuffers::String> summary_string;
-            if (!leg.summary.empty())
-            {
-                summary_string = fb_result.CreateString(leg.summary);
-            }
-
-            fbresult::LegBuilder legBuilder(fb_result);
-            legBuilder.add_distance(leg.distance);
-            legBuilder.add_duration(leg.duration);
-            legBuilder.add_weight(leg.weight);
-            if (!leg.summary.empty())
-            {
-                legBuilder.add_summary(summary_string);
-            }
-            legBuilder.add_steps(steps_vector);
-
-            if (requested_annotations != RouteParameters::AnnotationsType::None)
-            {
-                legBuilder.add_annotations(annotation_buffer);
-            }
-            routeLegs.emplace_back(legBuilder.Finish());
-        }
-        auto legs_vector = fb_result.CreateVector(routeLegs);
-
-        // Fill geometry
-        auto overview = MakeOverview(leg_geometries);
-        mapbox::util::variant<flatbuffers::Offset<flatbuffers::String>,
-                              flatbuffers::Offset<flatbuffers::Vector<const fbresult::Position *>>>
-            geometry;
-        if (overview)
-        {
-            geometry = MakeGeometry(fb_result, overview->begin(), overview->end());
-        }
-
-        auto weight_name_string = fb_result.CreateString(facade.GetWeightName());
-
-        fbresult::RouteObjectBuilder routeObject(fb_result);
-        routeObject.add_distance(route.distance);
-        routeObject.add_duration(route.duration);
-        routeObject.add_weight(route.weight);
-        routeObject.add_weight_name(weight_name_string);
-        routeObject.add_legs(legs_vector);
-        if (overview)
-        {
-            mapbox::util::apply_visitor(GeometryVisitor<fbresult::RouteObjectBuilder>(routeObject),
-                                        geometry);
-        }
-
-        return routeObject.Finish();
-    }
-
-    flatbuffers::Offset<fbresult::Annotation>
-    MakeFBAnnotations(flatbuffers::FlatBufferBuilder &fb_result,
-                      guidance::LegGeometry &leg_geometry,
-                      const RouteParameters::AnnotationsType &requested_annotations) const
-    {
-        // AnnotationsType uses bit flags, & operator checks if a property is set
-        flatbuffers::Offset<flatbuffers::Vector<float>> speed;
-        if (parameters.annotations_type & RouteParameters::AnnotationsType::Speed)
-        {
-            double prev_speed = 0;
-            speed =
-                GetAnnotations<float>(fb_result,
-                                      leg_geometry,
-                                      [&prev_speed](const guidance::LegGeometry::Annotation &anno) {
-                                          if (anno.duration < std::numeric_limits<float>::min())
-                                          {
-                                              return prev_speed;
-                                          }
-                                          else
-                                          {
-                                              auto speed =
-                                                  round(anno.distance / anno.duration * 10.) / 10.;
-                                              prev_speed = speed;
-                                              return util::json::clamp_float(speed);
-                                          }
-                                      });
-        }
-
-        flatbuffers::Offset<flatbuffers::Vector<uint32_t>> duration;
-        if (requested_annotations & RouteParameters::AnnotationsType::Duration)
-        {
-            duration = GetAnnotations<uint32_t>(
-                fb_result, leg_geometry, [](const guidance::LegGeometry::Annotation &anno) {
-                    return anno.duration;
-                });
-        }
-
-        flatbuffers::Offset<flatbuffers::Vector<uint32_t>> distance;
-        if (requested_annotations & RouteParameters::AnnotationsType::Distance)
-        {
-            distance = GetAnnotations<uint32_t>(
-                fb_result, leg_geometry, [](const guidance::LegGeometry::Annotation &anno) {
-                    return anno.distance;
-                });
-        }
-
-        flatbuffers::Offset<flatbuffers::Vector<uint32_t>> weight;
-        if (requested_annotations & RouteParameters::AnnotationsType::Weight)
-        {
-            weight = GetAnnotations<uint32_t>(
-                fb_result, leg_geometry, [](const guidance::LegGeometry::Annotation &anno) {
-                    return anno.weight;
-                });
-        }
-
-        flatbuffers::Offset<flatbuffers::Vector<uint32_t>> datasources;
-        if (requested_annotations & RouteParameters::AnnotationsType::Datasources)
-        {
-            datasources = GetAnnotations<uint32_t>(
-                fb_result, leg_geometry, [](const guidance::LegGeometry::Annotation &anno) {
-                    return anno.datasource;
-                });
-        }
-        std::vector<uint32_t> nodes;
-        if (requested_annotations & RouteParameters::AnnotationsType::Nodes)
-        {
-            nodes.reserve(leg_geometry.osm_node_ids.size());
-            for (const auto node_id : leg_geometry.osm_node_ids)
-            {
-                nodes.emplace_back(static_cast<uint64_t>(node_id));
-            }
-        }
-        auto nodes_vector = fb_result.CreateVector(nodes);
-        // Add any supporting metadata, if needed
-        bool use_metadata = requested_annotations & RouteParameters::AnnotationsType::Datasources;
-        flatbuffers::Offset<fbresult::Metadata> metadata_buffer;
-        if (use_metadata)
-        {
-            const auto MAX_DATASOURCE_ID = 255u;
-            std::vector<flatbuffers::Offset<flatbuffers::String>> names;
-            for (auto i = 0u; i < MAX_DATASOURCE_ID; i++)
-            {
-                const auto name = facade.GetDatasourceName(i);
-                // Length of 0 indicates the first empty name, so we can stop here
-                if (name.size() == 0)
-                    break;
-                names.emplace_back(
-                    fb_result.CreateString(std::string(facade.GetDatasourceName(i))));
-            }
-            metadata_buffer = fbresult::CreateMetadataDirect(fb_result, &names);
-        }
-        fbresult::AnnotationBuilder annotation(fb_result);
-        annotation.add_speed(speed);
-        annotation.add_duration(duration);
-        annotation.add_distance(distance);
-        annotation.add_weight(weight);
-        annotation.add_datasources(datasources);
-        annotation.add_nodes(nodes_vector);
-        if (use_metadata)
-        {
-            annotation.add_metadata(metadata_buffer);
-        }
-
-        return annotation.Finish();
-    }
-
-    template <typename Builder> class GeometryVisitor
-    {
-      public:
-        GeometryVisitor(Builder &builder) : builder(builder) {}
-
-        void operator()(const flatbuffers::Offset<flatbuffers::String> &value)
-        {
-            builder.add_polyline(value);
-        }
-        void operator()(
-            const flatbuffers::Offset<flatbuffers::Vector<const fbresult::Position *>> &value)
-        {
-            builder.add_coordinates(value);
-        }
-
-      private:
-        Builder &builder;
-    };
-
-    flatbuffers::Offset<fbresult::Step> MakeFBStep(flatbuffers::FlatBufferBuilder &builder,
-                                                   const guidance::LegGeometry &leg_geometry,
-                                                   const guidance::RouteStep &step) const
-    {
-        auto name_string = builder.CreateString(step.name);
-
-        flatbuffers::Offset<flatbuffers::String> ref_string;
-        if (!step.ref.empty())
-        {
-            ref_string = builder.CreateString(step.ref);
-        }
-
-        flatbuffers::Offset<flatbuffers::String> pronunciation_string;
-        if (!step.pronunciation.empty())
-        {
-            pronunciation_string = builder.CreateString(step.pronunciation);
-        }
-
-        flatbuffers::Offset<flatbuffers::String> destinations_string;
-        if (!step.destinations.empty())
-        {
-            destinations_string = builder.CreateString(step.destinations);
-        }
-
-        flatbuffers::Offset<flatbuffers::String> exists_string;
-        if (!step.exits.empty())
-        {
-            exists_string = builder.CreateString(step.exits);
-        }
-
-        flatbuffers::Offset<flatbuffers::String> rotary_name_string;
-        flatbuffers::Offset<flatbuffers::String> rotary_pronunciation_string;
-        if (!step.rotary_name.empty())
-        {
-            rotary_name_string = builder.CreateString(step.rotary_name);
-            if (!step.rotary_pronunciation.empty())
-            {
-                rotary_pronunciation_string = builder.CreateString(step.rotary_pronunciation);
-            }
-        }
-        auto mode_string = builder.CreateString(extractor::travelModeToString(step.mode));
-
-        // Geometry
-        auto geometry = MakeGeometry(builder,
-                                     leg_geometry.locations.begin() + step.geometry_begin,
-                                     leg_geometry.locations.begin() + step.geometry_end);
-        // Maneuver
-        fbresult::StepManeuverBuilder maneuver(builder);
-        fbresult::Position maneuverPosition{
-            static_cast<float>(util::toFloating(step.maneuver.location.lon).__value),
-            static_cast<float>(util::toFloating(step.maneuver.location.lat).__value)};
-        maneuver.add_location(&maneuverPosition);
-        maneuver.add_bearing_before(step.maneuver.bearing_before);
-        maneuver.add_bearing_after(step.maneuver.bearing_after);
-        if (step.maneuver.waypoint_type == guidance::WaypointType::None)
-            maneuver.add_type(TurnTypeToFB(step.maneuver.instruction.type));
-        else
-            maneuver.add_type(WaypointTypeToFB(step.maneuver.waypoint_type));
-        if (osrm::engine::api::json::detail::isValidModifier(step.maneuver))
-        {
-            maneuver.add_modifier(TurnModifierToFB(step.maneuver.instruction.direction_modifier));
-        }
-        if (step.maneuver.exit != 0)
-        {
-            maneuver.add_exit(step.maneuver.exit);
-        }
-        auto maneuver_buffer = maneuver.Finish();
-
-        // intersections
-        auto intersections_vector = MakeFBIntersections(builder, step);
-
-        fbresult::StepBuilder stepBuilder(builder);
-        stepBuilder.add_duration(step.duration);
-        stepBuilder.add_distance(step.distance);
-        stepBuilder.add_weight(step.weight);
-        stepBuilder.add_name(name_string);
-        stepBuilder.add_mode(mode_string);
-        stepBuilder.add_driving_side(step.is_left_hand_driving);
-        stepBuilder.add_ref(ref_string);
-        stepBuilder.add_pronunciation(pronunciation_string);
-        stepBuilder.add_destinations(destinations_string);
-        stepBuilder.add_exits(exists_string);
-        stepBuilder.add_rotary_name(rotary_name_string);
-        stepBuilder.add_rotary_pronunciation(rotary_pronunciation_string);
-        stepBuilder.add_intersections(intersections_vector);
-        stepBuilder.add_maneuver(maneuver_buffer);
-        mapbox::util::apply_visitor(GeometryVisitor<fbresult::StepBuilder>(stepBuilder), geometry);
-        return stepBuilder.Finish();
-    };
-
-    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbresult::Intersection>>>
-    MakeFBIntersections(flatbuffers::FlatBufferBuilder &fb_result,
-                        const guidance::RouteStep &step) const
-    {
-        std::vector<flatbuffers::Offset<fbresult::Intersection>> intersections;
-        intersections.resize(step.intersections.size());
-        std::transform(
-            step.intersections.begin(),
-            step.intersections.end(),
-            intersections.begin(),
-            [&fb_result, this](const guidance::IntermediateIntersection &intersection) {
-                std::vector<flatbuffers::Offset<fbresult::Lane>> lanes;
-                if (json::detail::hasValidLanes(intersection))
-                {
-                    BOOST_ASSERT(intersection.lanes.lanes_in_turn >= 1);
-                    lanes.reserve(intersection.lane_description.size());
-                    LaneID lane_id = intersection.lane_description.size();
-
-                    for (const auto &lane_desc : intersection.lane_description)
-                    {
-                        --lane_id;
-                        auto indications = TurnLaneTypeToFB(lane_desc);
-
-                        auto lane_valid = lane_id >= intersection.lanes.first_lane_from_the_right &&
-                                          lane_id < intersection.lanes.first_lane_from_the_right +
-                                                        intersection.lanes.lanes_in_turn;
-                        lanes.push_back(
-                            fbresult::CreateLaneDirect(fb_result, &indications, lane_valid));
-                    }
-                }
-                auto lanes_vector = fb_result.CreateVector(lanes);
-
-                fbresult::Position maneuverPosition{
-                    static_cast<float>(util::toFloating(intersection.location.lon).__value),
-                    static_cast<float>(util::toFloating(intersection.location.lat).__value)};
-                auto bearings_vector = fb_result.CreateVector(intersection.bearings);
-                std::vector<flatbuffers::Offset<flatbuffers::String>> classes;
-                classes.resize(intersection.classes.size());
-                std::transform(
-                    intersection.classes.begin(),
-                    intersection.classes.end(),
-                    classes.begin(),
-                    [&fb_result](const std::string cls) { return fb_result.CreateString(cls); });
-                auto classes_vector = fb_result.CreateVector(classes);
-                auto entry_vector = fb_result.CreateVector(intersection.entry);
-
-                fbresult::IntersectionBuilder intersectionBuilder(fb_result);
-                intersectionBuilder.add_location(&maneuverPosition);
-                intersectionBuilder.add_bearings(bearings_vector);
-                intersectionBuilder.add_classes(classes_vector);
-                intersectionBuilder.add_entry(entry_vector);
-                intersectionBuilder.add_in_bearing(intersection.in);
-                intersectionBuilder.add_out_bearing(intersection.out);
-                intersectionBuilder.add_lanes(lanes_vector);
-                return intersectionBuilder.Finish();
-            });
-        return fb_result.CreateVector(intersections);
-    }
-
    util::json::Object MakeRoute(const std::vector<PhantomNodes> &segment_end_coordinates,
                                 const std::vector<std::vector<PathData>> &unpacked_path_segments,
                                 const std::vector<bool> &source_traversed_in_reverse,
                                 const std::vector<bool> &target_traversed_in_reverse) const
    {
-        auto legs_info = MakeLegs(segment_end_coordinates,
-                                  unpacked_path_segments,
-                                  source_traversed_in_reverse,
-                                  target_traversed_in_reverse);
-        std::vector<guidance::RouteLeg> legs = legs_info.first;
-        std::vector<guidance::LegGeometry> leg_geometries = legs_info.second;
+        std::vector<guidance::RouteLeg> legs;
+        std::vector<guidance::LegGeometry> leg_geometries;
+        auto number_of_legs = segment_end_coordinates.size();
+        legs.reserve(number_of_legs);
+        leg_geometries.reserve(number_of_legs);
+
+        for (auto idx : util::irange<std::size_t>(0UL, number_of_legs))
+        {
+            const auto &phantoms = segment_end_coordinates[idx];
+            const auto &path_data = unpacked_path_segments[idx];
+
+            const bool reversed_source = source_traversed_in_reverse[idx];
+            const bool reversed_target = target_traversed_in_reverse[idx];
+
+            auto leg_geometry = guidance::assembleGeometry(BaseAPI::facade,
+                                                           path_data,
+                                                           phantoms.source_phantom,
+                                                           phantoms.target_phantom,
+                                                           reversed_source,
+                                                           reversed_target);
+            auto leg = guidance::assembleLeg(facade,
+                                             path_data,
+                                             leg_geometry,
+                                             phantoms.source_phantom,
+                                             phantoms.target_phantom,
+                                             reversed_target,
+                                             parameters.steps);
+
+            util::Log(logDEBUG) << "Assembling steps " << std::endl;
+            if (parameters.steps)
+            {
+                auto steps = guidance::assembleSteps(BaseAPI::facade,
+                                                     path_data,
+                                                     leg_geometry,
+                                                     phantoms.source_phantom,
+                                                     phantoms.target_phantom,
+                                                     reversed_source,
+                                                     reversed_target);
+
+                // Apply maneuver overrides before any other post
+                // processing is performed
+                guidance::applyOverrides(BaseAPI::facade, steps, leg_geometry);
+
+                // Collapse segregated steps before others
+                steps = guidance::collapseSegregatedTurnInstructions(std::move(steps));
+
+                /* Perform step-based post-processing.
+                 *
+                 * Using post-processing on basis of route-steps for a single leg at a time
+                 * comes at the cost that we cannot count the correct exit for roundabouts.
+                 * We can only emit the exit nr/intersections up to/starting at a part of the leg.
+                 * If a roundabout is not terminated in a leg, we will end up with a
+                 *enter-roundabout
+                 * and exit-roundabout-nr where the exit nr is out of sync with the previous enter.
+                 *
+                 *         | S |
+                 *         *   *
+                 *  ----*        * ----
+                 *                  T
+                 *  ----*        * ----
+                 *       V *   *
+                 *         |   |
+                 *         |   |
+                 *
+                 * Coming from S via V to T, we end up with the legs S->V and V->T. V-T will say to
+                 *take
+                 * the second exit, even though counting from S it would be the third.
+                 * For S, we only emit `roundabout` without an exit number, showing that we enter a
+                 *roundabout
+                 * to find a via point.
+                 * The same exit will be emitted, though, if we should start routing at S, making
+                 * the overall response consistent.
+                 *
+                 * ⚠ CAUTION: order of post-processing steps is important
+                 *    - handleRoundabouts must be called before collapseTurnInstructions that
+                 *      expects post-processed roundabouts
+                 */
+
+                guidance::trimShortSegments(steps, leg_geometry);
+                leg.steps = guidance::handleRoundabouts(std::move(steps));
+                leg.steps = guidance::collapseTurnInstructions(std::move(leg.steps));
+                leg.steps = guidance::anticipateLaneChange(std::move(leg.steps));
+                leg.steps = guidance::buildIntersections(std::move(leg.steps));
+                leg.steps = guidance::suppressShortNameSegments(std::move(leg.steps));
+                leg.steps = guidance::assignRelativeLocations(std::move(leg.steps),
+                                                              leg_geometry,
+                                                              phantoms.source_phantom,
+                                                              phantoms.target_phantom);
+                leg_geometry = guidance::resyncGeometry(std::move(leg_geometry), leg.steps);
+            }
+
+            leg_geometries.push_back(std::move(leg_geometry));
+            legs.push_back(std::move(leg));
+        }

        auto route = guidance::assembleRoute(legs);
-        boost::optional<util::json::Value> json_overview =
-            MakeGeometry(MakeOverview(leg_geometries));
+        boost::optional<util::json::Value> json_overview;
+        if (parameters.overview != RouteParameters::OverviewType::False)
+        {
+            const auto use_simplification =
+                parameters.overview == RouteParameters::OverviewType::Simplified;
+            BOOST_ASSERT(use_simplification ||
+                         parameters.overview == RouteParameters::OverviewType::Full);
+
+            auto overview = guidance::assembleOverview(leg_geometries, use_simplification);
+            json_overview = MakeGeometry(overview.begin(), overview.end());
+        }

        std::vector<util::json::Value> step_geometries;
        const auto total_step_count =
@@ -865,131 +357,10 @@ class RouteAPI : public BaseAPI
    }

    const RouteParameters &parameters;
-
-    std::pair<std::vector<guidance::RouteLeg>, std::vector<guidance::LegGeometry>>
-    MakeLegs(const std::vector<PhantomNodes> &segment_end_coordinates,
-             const std::vector<std::vector<PathData>> &unpacked_path_segments,
-             const std::vector<bool> &source_traversed_in_reverse,
-             const std::vector<bool> &target_traversed_in_reverse) const
-    {
-        auto result =
-            std::make_pair(std::vector<guidance::RouteLeg>(), std::vector<guidance::LegGeometry>());
-        auto &legs = result.first;
-        auto &leg_geometries = result.second;
-        auto number_of_legs = segment_end_coordinates.size();
-        legs.reserve(number_of_legs);
-        leg_geometries.reserve(number_of_legs);
-
-        for (auto idx : util::irange<std::size_t>(0UL, number_of_legs))
-        {
-            const auto &phantoms = segment_end_coordinates[idx];
-            const auto &path_data = unpacked_path_segments[idx];
-
-            const bool reversed_source = source_traversed_in_reverse[idx];
-            const bool reversed_target = target_traversed_in_reverse[idx];
-
-            auto leg_geometry = guidance::assembleGeometry(BaseAPI::facade,
-                                                           path_data,
-                                                           phantoms.source_phantom,
-                                                           phantoms.target_phantom,
-                                                           reversed_source,
-                                                           reversed_target);
-            auto leg = guidance::assembleLeg(facade,
-                                             path_data,
-                                             leg_geometry,
-                                             phantoms.source_phantom,
-                                             phantoms.target_phantom,
-                                             reversed_target,
-                                             parameters.steps);
-
-            util::Log(logDEBUG) << "Assembling steps " << std::endl;
-            if (parameters.steps)
-            {
-                auto steps = guidance::assembleSteps(BaseAPI::facade,
-                                                     path_data,
-                                                     leg_geometry,
-                                                     phantoms.source_phantom,
-                                                     phantoms.target_phantom,
-                                                     reversed_source,
-                                                     reversed_target);
-
-                // Apply maneuver overrides before any other post
-                // processing is performed
-                guidance::applyOverrides(BaseAPI::facade, steps, leg_geometry);
-
-                // Collapse segregated steps before others
-                steps = guidance::collapseSegregatedTurnInstructions(std::move(steps));
-
-                /* Perform step-based post-processing.
-                 *
-                 * Using post-processing on basis of route-steps for a single leg at a time
-                 * comes at the cost that we cannot count the correct exit for roundabouts.
-                 * We can only emit the exit nr/intersections up to/starting at a part of the leg.
-                 * If a roundabout is not terminated in a leg, we will end up with a
-                 *enter-roundabout
-                 * and exit-roundabout-nr where the exit nr is out of sync with the previous enter.
-                 *
-                 *         | S |
-                 *         *   *
-                 *  ----*        * ----
-                 *                  T
-                 *  ----*        * ----
-                 *       V *   *
-                 *         |   |
-                 *         |   |
-                 *
-                 * Coming from S via V to T, we end up with the legs S->V and V->T. V-T will say to
-                 *take
-                 * the second exit, even though counting from S it would be the third.
-                 * For S, we only emit `roundabout` without an exit number, showing that we enter a
-                 *roundabout
-                 * to find a via point.
-                 * The same exit will be emitted, though, if we should start routing at S, making
-                 * the overall response consistent.
-                 *
-                 * ⚠ CAUTION: order of post-processing steps is important
-                 *    - handleRoundabouts must be called before collapseTurnInstructions that
-                 *      expects post-processed roundabouts
-                 */
-
-                guidance::trimShortSegments(steps, leg_geometry);
-                leg.steps = guidance::handleRoundabouts(std::move(steps));
-                leg.steps = guidance::collapseTurnInstructions(std::move(leg.steps));
-                leg.steps = guidance::anticipateLaneChange(std::move(leg.steps));
-                leg.steps = guidance::buildIntersections(std::move(leg.steps));
-                leg.steps = guidance::suppressShortNameSegments(std::move(leg.steps));
-                leg.steps = guidance::assignRelativeLocations(std::move(leg.steps),
-                                                              leg_geometry,
-                                                              phantoms.source_phantom,
-                                                              phantoms.target_phantom);
-                leg_geometry = guidance::resyncGeometry(std::move(leg_geometry), leg.steps);
-            }
-
-            leg_geometries.push_back(std::move(leg_geometry));
-            legs.push_back(std::move(leg));
-        }
-        return result;
-    }
-
-    boost::optional<std::vector<Coordinate>>
-    MakeOverview(const std::vector<guidance::LegGeometry> &leg_geometries) const
-    {
-        boost::optional<std::vector<Coordinate>> overview;
-        if (parameters.overview != RouteParameters::OverviewType::False)
-        {
-            const auto use_simplification =
-                parameters.overview == RouteParameters::OverviewType::Simplified;
-            BOOST_ASSERT(use_simplification ||
-                         parameters.overview == RouteParameters::OverviewType::Full);
-
-            overview = guidance::assembleOverview(leg_geometries, use_simplification);
-        }
-        return overview;
-    }
 };

-} // namespace api
-} // namespace engine
-} // namespace osrm
+} // ns api
+} // ns engine
+} // ns osrm

 #endif
@@ -87,13 +87,18 @@ struct RouteParameters : public BaseParameters
                    const GeometriesType geometries_,
                    const OverviewType overview_,
                    const boost::optional<bool> continue_straight_,
-                    Args &&... args_)
+                    Args... args_)
        // Once we perfectly-forward `args` (see #2990) this constructor can delegate to the one
        // below.
-        : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
-          number_of_alternatives{alternatives_ ? 1u : 0u}, annotations{false},
-          annotations_type{AnnotationsType::None}, geometries{geometries_}, overview{overview_},
-          continue_straight{continue_straight_}, waypoints()
+        : BaseParameters{std::forward<Args>(args_)...},
+          steps{steps_},
+          alternatives{alternatives_},
+          number_of_alternatives{alternatives_ ? 1u : 0u},
+          annotations{false},
+          annotations_type{AnnotationsType::None},
+          geometries{geometries_},
+          overview{overview_},
+          continue_straight{continue_straight_}
    {
    }

@@ -105,13 +110,11 @@ struct RouteParameters : public BaseParameters
                    const GeometriesType geometries_,
                    const OverviewType overview_,
                    const boost::optional<bool> continue_straight_,
-                    Args &&... args_)
+                    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()
-
+          geometries{geometries_}, overview{overview_}, continue_straight{continue_straight_}
    {
    }

@@ -123,48 +126,12 @@ struct RouteParameters : public BaseParameters
                    const GeometriesType geometries_,
                    const OverviewType overview_,
                    const boost::optional<bool> continue_straight_,
-                    Args &&... args_)
+                    Args... args_)
        : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
          number_of_alternatives{alternatives_ ? 1u : 0u},
-          annotations{annotations_ != AnnotationsType::None}, 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{std::move(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},
+          annotations{annotations_ == AnnotationsType::None ? false : true},
          annotations_type{annotations_}, geometries{geometries_}, overview{overview_},
-          continue_straight{continue_straight_}, waypoints{std::move(waypoints_)}
+          continue_straight{continue_straight_}
    {
    }

@@ -177,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;
    }
 };

@@ -211,8 +173,8 @@ inline RouteParameters::AnnotationsType operator|=(RouteParameters::AnnotationsT
 {
    return lhs = lhs | rhs;
 }
-} // namespace api
-} // namespace engine
-} // namespace osrm
+}
+}
+}

 #endif
@@ -2,7 +2,6 @@
 #define ENGINE_API_TABLE_HPP

 #include "engine/api/base_api.hpp"
-#include "engine/api/base_result.hpp"
 #include "engine/api/json_factory.hpp"
 #include "engine/api/table_parameters.hpp"

@@ -46,126 +45,6 @@ class TableAPI final : public BaseAPI
    {
    }

-    virtual void
-    MakeResponse(const std::pair<std::vector<EdgeDuration>, std::vector<EdgeDistance>> &tables,
-                 const std::vector<PhantomNode> &phantoms,
-                 const std::vector<TableCellRef> &fallback_speed_cells,
-                 osrm::engine::api::ResultT &response) const
-    {
-        if (response.is<flatbuffers::FlatBufferBuilder>())
-        {
-            auto &fb_result = response.get<flatbuffers::FlatBufferBuilder>();
-            MakeResponse(tables, phantoms, fallback_speed_cells, fb_result);
-        }
-        else
-        {
-            auto &json_result = response.get<util::json::Object>();
-            MakeResponse(tables, phantoms, fallback_speed_cells, json_result);
-        }
-    }
-
-    virtual void
-    MakeResponse(const std::pair<std::vector<EdgeDuration>, std::vector<EdgeDistance>> &tables,
-                 const std::vector<PhantomNode> &phantoms,
-                 const std::vector<TableCellRef> &fallback_speed_cells,
-                 flatbuffers::FlatBufferBuilder &fb_result) const
-    {
-        auto number_of_sources = parameters.sources.size();
-        auto number_of_destinations = parameters.destinations.size();
-
-        auto data_timestamp = facade.GetTimestamp();
-        flatbuffers::Offset<flatbuffers::String> data_version_string;
-        if (!data_timestamp.empty())
-        {
-            data_version_string = fb_result.CreateString(data_timestamp);
-        }
-
-        // symmetric case
-        flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbresult::Waypoint>>> sources;
-        if (parameters.sources.empty())
-        {
-            if (!parameters.skip_waypoints)
-            {
-                sources = MakeWaypoints(fb_result, phantoms);
-            }
-            number_of_sources = phantoms.size();
-        }
-        else
-        {
-            if (!parameters.skip_waypoints)
-            {
-                sources = MakeWaypoints(fb_result, phantoms, parameters.sources);
-            }
-        }
-
-        flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbresult::Waypoint>>>
-            destinations;
-        if (parameters.destinations.empty())
-        {
-            if (!parameters.skip_waypoints)
-            {
-                destinations = MakeWaypoints(fb_result, phantoms);
-            }
-            number_of_destinations = phantoms.size();
-        }
-        else
-        {
-            if (!parameters.skip_waypoints)
-            {
-                destinations = MakeWaypoints(fb_result, phantoms, parameters.destinations);
-            }
-        }
-
-        bool use_durations = parameters.annotations & TableParameters::AnnotationsType::Duration;
-        flatbuffers::Offset<flatbuffers::Vector<float>> durations;
-        if (use_durations)
-        {
-            durations = MakeDurationTable(fb_result, tables.first);
-        }
-
-        bool use_distances = parameters.annotations & TableParameters::AnnotationsType::Distance;
-        flatbuffers::Offset<flatbuffers::Vector<float>> distances;
-        if (use_distances)
-        {
-            distances = MakeDistanceTable(fb_result, tables.second);
-        }
-
-        bool have_speed_cells =
-            parameters.fallback_speed != INVALID_FALLBACK_SPEED && parameters.fallback_speed > 0;
-        flatbuffers::Offset<flatbuffers::Vector<uint32_t>> speed_cells;
-        if (have_speed_cells)
-        {
-            speed_cells = MakeEstimatesTable(fb_result, fallback_speed_cells);
-        }
-
-        fbresult::TableBuilder table(fb_result);
-        table.add_destinations(destinations);
-        table.add_rows(number_of_sources);
-        table.add_cols(number_of_destinations);
-        if (use_durations)
-        {
-            table.add_durations(durations);
-        }
-        if (use_distances)
-        {
-            table.add_distances(distances);
-        }
-        if (have_speed_cells)
-        {
-            table.add_fallback_speed_cells(speed_cells);
-        }
-        auto table_buffer = table.Finish();
-
-        fbresult::FBResultBuilder response(fb_result);
-        if (!data_timestamp.empty())
-        {
-            response.add_data_version(data_version_string);
-        }
-        response.add_table(table_buffer);
-        response.add_waypoints(sources);
-        fb_result.Finish(response.Finish());
-    }
-
    virtual void
    MakeResponse(const std::pair<std::vector<EdgeDuration>, std::vector<EdgeDistance>> &tables,
                 const std::vector<PhantomNode> &phantoms,
@@ -178,34 +57,22 @@ class TableAPI final : public BaseAPI
        // symmetric case
        if (parameters.sources.empty())
        {
-            if (!parameters.skip_waypoints)
-            {
-                response.values["sources"] = MakeWaypoints(phantoms);
-            }
+            response.values["sources"] = MakeWaypoints(phantoms);
            number_of_sources = phantoms.size();
        }
        else
        {
-            if (!parameters.skip_waypoints)
-            {
-                response.values["sources"] = MakeWaypoints(phantoms, parameters.sources);
-            }
+            response.values["sources"] = MakeWaypoints(phantoms, parameters.sources);
        }

        if (parameters.destinations.empty())
        {
-            if (!parameters.skip_waypoints)
-            {
-                response.values["destinations"] = MakeWaypoints(phantoms);
-            }
+            response.values["destinations"] = MakeWaypoints(phantoms);
            number_of_destinations = phantoms.size();
        }
        else
        {
-            if (!parameters.skip_waypoints)
-            {
-                response.values["destinations"] = MakeWaypoints(phantoms, parameters.destinations);
-            }
+            response.values["destinations"] = MakeWaypoints(phantoms, parameters.destinations);
        }

        if (parameters.annotations & TableParameters::AnnotationsType::Duration)
@@ -229,85 +96,6 @@ class TableAPI final : public BaseAPI
    }

  protected:
-    virtual flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbresult::Waypoint>>>
-    MakeWaypoints(flatbuffers::FlatBufferBuilder &builder,
-                  const std::vector<PhantomNode> &phantoms) const
-    {
-        std::vector<flatbuffers::Offset<fbresult::Waypoint>> waypoints;
-        waypoints.reserve(phantoms.size());
-        BOOST_ASSERT(phantoms.size() == parameters.coordinates.size());
-
-        boost::range::transform(
-            phantoms, std::back_inserter(waypoints), [this, &builder](const PhantomNode &phantom) {
-                return BaseAPI::MakeWaypoint(&builder, phantom)->Finish();
-            });
-        return builder.CreateVector(waypoints);
-    }
-
-    virtual flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbresult::Waypoint>>>
-    MakeWaypoints(flatbuffers::FlatBufferBuilder &builder,
-                  const std::vector<PhantomNode> &phantoms,
-                  const std::vector<std::size_t> &indices) const
-    {
-        std::vector<flatbuffers::Offset<fbresult::Waypoint>> waypoints;
-        waypoints.reserve(indices.size());
-        boost::range::transform(indices,
-                                std::back_inserter(waypoints),
-                                [this, &builder, phantoms](const std::size_t idx) {
-                                    BOOST_ASSERT(idx < phantoms.size());
-                                    return BaseAPI::MakeWaypoint(&builder, phantoms[idx])->Finish();
-                                });
-        return builder.CreateVector(waypoints);
-    }
-
-    virtual flatbuffers::Offset<flatbuffers::Vector<float>>
-    MakeDurationTable(flatbuffers::FlatBufferBuilder &builder,
-                      const std::vector<EdgeWeight> &values) const
-    {
-        std::vector<float> distance_table;
-        distance_table.resize(values.size());
-        std::transform(
-            values.begin(), values.end(), distance_table.begin(), [](const EdgeWeight duration) {
-                if (duration == MAXIMAL_EDGE_DURATION)
-                {
-                    return 0.;
-                }
-                return duration / 10.;
-            });
-        return builder.CreateVector(distance_table);
-    }
-
-    virtual flatbuffers::Offset<flatbuffers::Vector<float>>
-    MakeDistanceTable(flatbuffers::FlatBufferBuilder &builder,
-                      const std::vector<EdgeDistance> &values) const
-    {
-        std::vector<float> duration_table;
-        duration_table.resize(values.size());
-        std::transform(
-            values.begin(), values.end(), duration_table.begin(), [](const EdgeDistance distance) {
-                if (distance == INVALID_EDGE_DISTANCE)
-                {
-                    return 0.;
-                }
-                return std::round(distance * 10) / 10.;
-            });
-        return builder.CreateVector(duration_table);
-    }
-
-    virtual flatbuffers::Offset<flatbuffers::Vector<uint32_t>>
-    MakeEstimatesTable(flatbuffers::FlatBufferBuilder &builder,
-                       const std::vector<TableCellRef> &fallback_speed_cells) const
-    {
-        std::vector<uint32_t> fb_table;
-        fb_table.reserve(fallback_speed_cells.size());
-        std::for_each(
-            fallback_speed_cells.begin(), fallback_speed_cells.end(), [&](const auto &cell) {
-                fb_table.push_back(cell.row);
-                fb_table.push_back(cell.column);
-            });
-        return builder.CreateVector(fb_table);
-    }
-
    virtual util::json::Array MakeWaypoints(const std::vector<PhantomNode> &phantoms) const
    {
        util::json::Array json_waypoints;
@@ -407,8 +195,8 @@ class TableAPI final : public BaseAPI
    const TableParameters &parameters;
 };

-} // namespace api
-} // namespace engine
-} // namespace osrm
+} // ns api
+} // ns engine
+} // ns osrm

 #endif
@@ -85,7 +85,7 @@ struct TableParameters : public BaseParameters
    template <typename... Args>
    TableParameters(std::vector<std::size_t> sources_,
                    std::vector<std::size_t> destinations_,
-                    Args &&... args_)
+                    Args... args_)
        : BaseParameters{std::forward<Args>(args_)...}, sources{std::move(sources_)},
          destinations{std::move(destinations_)}
    {
@@ -95,7 +95,7 @@ struct TableParameters : public BaseParameters
    TableParameters(std::vector<std::size_t> sources_,
                    std::vector<std::size_t> destinations_,
                    const AnnotationsType annotations_,
-                    Args &&... args_)
+                    Args... args_)
        : BaseParameters{std::forward<Args>(args_)...}, sources{std::move(sources_)},
          destinations{std::move(destinations_)}, annotations{annotations_}
    {
@@ -108,7 +108,7 @@ struct TableParameters : public BaseParameters
                    double fallback_speed_,
                    FallbackCoordinateType fallback_coordinate_type_,
                    double scale_factor_,
-                    Args &&... args_)
+                    Args... args_)
        : BaseParameters{std::forward<Args>(args_)...}, sources{std::move(sources_)},
          destinations{std::move(destinations_)}, fallback_speed{fallback_speed_},
          fallback_coordinate_type{fallback_coordinate_type_}, annotations{annotations_},
@@ -122,7 +122,7 @@ struct TableParameters : public BaseParameters
        if (!BaseParameters::IsValid())
            return false;

-        // Distance Table makes only sense with 2+ coordinates
+        // Distance Table makes only sense with 2+ coodinates
        if (coordinates.size() < 2)
            return false;

@@ -166,8 +166,8 @@ inline TableParameters::AnnotationsType &operator|=(TableParameters::Annotations
 {
    return lhs = lhs | rhs;
 }
-} // namespace api
-} // namespace engine
-} // namespace osrm
+}
+}
+}

 #endif // ENGINE_API_TABLE_PARAMETERS_HPP
@@ -70,8 +70,8 @@ struct TileParameters final
        return valid_x && valid_y && valid_z;
    }
 };
-} // namespace api
-} // namespace engine
-} // namespace osrm
+}
+}
+}

 #endif
@@ -24,47 +24,7 @@ class TripAPI final : public RouteAPI
        : RouteAPI(facade_, parameters_), parameters(parameters_)
    {
    }
-    void MakeResponse(const std::vector<std::vector<NodeID>> &sub_trips,
-                      const std::vector<InternalRouteResult> &sub_routes,
-                      const std::vector<PhantomNode> &phantoms,
-                      osrm::engine::api::ResultT &response) const
-    {
-        BOOST_ASSERT(sub_trips.size() == sub_routes.size());

-        if (response.is<flatbuffers::FlatBufferBuilder>())
-        {
-            auto &fb_result = response.get<flatbuffers::FlatBufferBuilder>();
-            MakeResponse(sub_trips, sub_routes, phantoms, fb_result);
-        }
-        else
-        {
-            auto &json_result = response.get<util::json::Object>();
-            MakeResponse(sub_trips, sub_routes, phantoms, json_result);
-        }
-    }
-    void MakeResponse(const std::vector<std::vector<NodeID>> &sub_trips,
-                      const std::vector<InternalRouteResult> &sub_routes,
-                      const std::vector<PhantomNode> &phantoms,
-                      flatbuffers::FlatBufferBuilder &fb_result) const
-    {
-        auto data_timestamp = facade.GetTimestamp();
-        flatbuffers::Offset<flatbuffers::String> data_version_string;
-        if (!data_timestamp.empty())
-        {
-            data_version_string = fb_result.CreateString(data_timestamp);
-        }
-
-        auto response =
-            MakeFBResponse(sub_routes, fb_result, [this, &fb_result, &sub_trips, &phantoms]() {
-                return MakeWaypoints(fb_result, sub_trips, phantoms);
-            });
-
-        if (!data_timestamp.empty())
-        {
-            response->add_data_version(data_version_string);
-        }
-        fb_result.Finish(response->Finish());
-    }
    void MakeResponse(const std::vector<std::vector<NodeID>> &sub_trips,
                      const std::vector<InternalRouteResult> &sub_routes,
                      const std::vector<PhantomNode> &phantoms,
@@ -73,6 +33,7 @@ class TripAPI final : public RouteAPI
        auto number_of_routes = sub_trips.size();
        util::json::Array routes;
        routes.values.reserve(number_of_routes);
+        BOOST_ASSERT(sub_trips.size() == sub_routes.size());
        for (auto index : util::irange<std::size_t>(0UL, sub_trips.size()))
        {
            auto route = MakeRoute(sub_routes[index].segment_end_coordinates,
@@ -81,10 +42,7 @@ class TripAPI final : public RouteAPI
                                   sub_routes[index].target_traversed_in_reverse);
            routes.values.push_back(std::move(route));
        }
-        if (!parameters.skip_waypoints)
-        {
-            response.values["waypoints"] = MakeWaypoints(sub_trips, phantoms);
-        }
+        response.values["waypoints"] = MakeWaypoints(sub_trips, phantoms);
        response.values["trips"] = std::move(routes);
        response.values["code"] = "Ok";
    }
@@ -92,57 +50,39 @@ class TripAPI final : public RouteAPI
  protected:
    // FIXME this logic is a little backwards. We should change the output format of the
    // trip plugin routing algorithm to be easier to consume here.
-
-    struct TripIndex
-    {
-        TripIndex() = default;
-
-        TripIndex(unsigned sub_trip_index_, unsigned point_index_)
-            : sub_trip_index(sub_trip_index_), point_index(point_index_)
-        {
-        }
-
-        unsigned sub_trip_index = std::numeric_limits<unsigned>::max();
-        unsigned point_index = std::numeric_limits<unsigned>::max();
-
-        bool NotUsed()
-        {
-            return sub_trip_index == std::numeric_limits<unsigned>::max() &&
-                   point_index == std::numeric_limits<unsigned>::max();
-        }
-    };
-
-    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<fbresult::Waypoint>>>
-    MakeWaypoints(flatbuffers::FlatBufferBuilder &fb_result,
-                  const std::vector<std::vector<NodeID>> &sub_trips,
-                  const std::vector<PhantomNode> &phantoms) const
-    {
-        std::vector<flatbuffers::Offset<fbresult::Waypoint>> waypoints;
-        waypoints.reserve(parameters.coordinates.size());
-
-        auto input_idx_to_trip_idx = MakeTripIndices(sub_trips);
-
-        for (auto input_index : util::irange<std::size_t>(0UL, parameters.coordinates.size()))
-        {
-            auto trip_index = input_idx_to_trip_idx[input_index];
-            BOOST_ASSERT(!trip_index.NotUsed());
-
-            auto waypoint = BaseAPI::MakeWaypoint(&fb_result, phantoms[input_index]);
-            waypoint->add_waypoint_index(trip_index.point_index);
-            waypoint->add_trips_index(trip_index.sub_trip_index);
-            waypoints.push_back(waypoint->Finish());
-        }
-
-        return fb_result.CreateVector(waypoints);
-    }
-
    util::json::Array MakeWaypoints(const std::vector<std::vector<NodeID>> &sub_trips,
                                    const std::vector<PhantomNode> &phantoms) const
    {
        util::json::Array waypoints;
        waypoints.values.reserve(parameters.coordinates.size());

-        auto input_idx_to_trip_idx = MakeTripIndices(sub_trips);
+        struct TripIndex
+        {
+            TripIndex() = default;
+            TripIndex(unsigned sub_trip_index_, unsigned point_index_)
+                : sub_trip_index(sub_trip_index_), point_index(point_index_)
+            {
+            }
+
+            unsigned sub_trip_index = std::numeric_limits<unsigned>::max();
+            unsigned point_index = std::numeric_limits<unsigned>::max();
+
+            bool NotUsed()
+            {
+                return sub_trip_index == std::numeric_limits<unsigned>::max() &&
+                       point_index == std::numeric_limits<unsigned>::max();
+            }
+        };
+
+        std::vector<TripIndex> input_idx_to_trip_idx(parameters.coordinates.size());
+        for (auto sub_trip_index : util::irange<unsigned>(0u, sub_trips.size()))
+        {
+            for (auto point_index : util::irange<unsigned>(0u, sub_trips[sub_trip_index].size()))
+            {
+                input_idx_to_trip_idx[sub_trips[sub_trip_index][point_index]] =
+                    TripIndex{sub_trip_index, point_index};
+            }
+        }

        for (auto input_index : util::irange<std::size_t>(0UL, parameters.coordinates.size()))
        {
@@ -158,25 +98,11 @@ class TripAPI final : public RouteAPI
        return waypoints;
    }

-    std::vector<TripIndex> MakeTripIndices(const std::vector<std::vector<NodeID>> &sub_trips) const
-    {
-        std::vector<TripIndex> input_idx_to_trip_idx(parameters.coordinates.size());
-        for (auto sub_trip_index : util::irange<unsigned>(0u, sub_trips.size()))
-        {
-            for (auto point_index : util::irange<unsigned>(0u, sub_trips[sub_trip_index].size()))
-            {
-                input_idx_to_trip_idx[sub_trips[sub_trip_index][point_index]] =
-                    TripIndex{sub_trip_index, point_index};
-            }
-        }
-        return input_idx_to_trip_idx;
-    }
-
    const TripParameters &parameters;
 };

-} // namespace api
-} // namespace engine
-} // namespace osrm
+} // ns api
+} // ns engine
+} // ns osrm

 #endif
@@ -65,8 +65,8 @@ struct TripParameters : public RouteParameters
                   DestinationType destination_,
                   bool roundtrip_,
                   Args &&... args_)
-        : RouteParameters{std::forward<Args>(args_)...}, source{source_},
-          destination{destination_}, roundtrip{roundtrip_}
+        : RouteParameters{std::forward<Args>(args_)...}, source{source_}, destination{destination_},
+          roundtrip{roundtrip_}
    {
    }

@@ -76,8 +76,8 @@ struct TripParameters : public RouteParameters

    bool IsValid() const { return RouteParameters::IsValid(); }
 };
-} // namespace api
-} // namespace engine
-} // namespace osrm
+}
+}
+}

 #endif
@@ -42,5 +42,5 @@ enum class Approach : std::uint8_t

 };
 }
-} // namespace osrm
+}
 #endif
@@ -38,7 +38,7 @@ using BinaryFromBase64 = boost::archive::iterators::transform_width<
    8, // get a view of 8 bit
    6  // from a sequence of 6 bit
    >;
-} // namespace detail
+} // ns detail
 namespace engine
 {

@@ -135,7 +135,7 @@ template <typename T> T decodeBase64Bytewise(const std::string &encoded)
    return x;
 }

-} // namespace engine
-} // namespace osrm
+} // ns engine
+} // ns osrm

 #endif /* OSRM_BASE64_HPP */
@@ -46,7 +46,7 @@ inline bool operator==(const Bearing lhs, const Bearing rhs)
    return lhs.bearing == rhs.bearing && lhs.range == rhs.range;
 }
 inline bool operator!=(const Bearing lhs, const Bearing rhs) { return !(lhs == rhs); }
-} // namespace engine
-} // namespace osrm
+}
+}

 #endif
@@ -56,14 +56,11 @@ class DataWatchdogImpl<AlgorithmT, datafacade::ContiguousInternalMemoryDataFacad
            static_region = *static_shared_region;
            updatable_region = *updatable_shared_region;

-            {
-                boost::unique_lock<boost::shared_mutex> swap_lock(factory_mutex);
-                facade_factory =
-                    DataFacadeFactory<datafacade::ContiguousInternalMemoryDataFacade, AlgorithmT>(
-                        std::make_shared<datafacade::SharedMemoryAllocator>(
-                            std::vector<storage::SharedRegionRegister::ShmKey>{
-                                static_region.shm_key, updatable_region.shm_key}));
-            }
+            facade_factory =
+                DataFacadeFactory<datafacade::ContiguousInternalMemoryDataFacade, AlgorithmT>(
+                    std::make_shared<datafacade::SharedMemoryAllocator>(
+                        std::vector<storage::SharedRegionRegister::ShmKey>{
+                            static_region.shm_key, updatable_region.shm_key}));
        }

        watcher = std::thread(&DataWatchdogImpl::Run, this);
@@ -78,14 +75,10 @@ class DataWatchdogImpl<AlgorithmT, datafacade::ContiguousInternalMemoryDataFacad

    std::shared_ptr<const Facade> Get(const api::BaseParameters &params) const
    {
-        // make sure facade_factory stays stable while we call Get()
-        boost::shared_lock<boost::shared_mutex> swap_lock(factory_mutex);
        return facade_factory.Get(params);
    }
    std::shared_ptr<const Facade> Get(const api::TileParameters &params) const
    {
-        // make sure facade_factory stays stable while we call Get()
-        boost::shared_lock<boost::shared_mutex> swap_lock(factory_mutex);
        return facade_factory.Get(params);
    }

@@ -118,20 +111,16 @@ class DataWatchdogImpl<AlgorithmT, datafacade::ContiguousInternalMemoryDataFacad
                        << (int)updatable_region.shm_key << " with timestamps "
                        << static_region.timestamp << " and " << updatable_region.timestamp;

-            {
-                boost::unique_lock<boost::shared_mutex> swap_lock(factory_mutex);
-                facade_factory =
-                    DataFacadeFactory<datafacade::ContiguousInternalMemoryDataFacade, AlgorithmT>(
-                        std::make_shared<datafacade::SharedMemoryAllocator>(
-                            std::vector<storage::SharedRegionRegister::ShmKey>{
-                                static_region.shm_key, updatable_region.shm_key}));
-            }
+            facade_factory =
+                DataFacadeFactory<datafacade::ContiguousInternalMemoryDataFacade, AlgorithmT>(
+                    std::make_shared<datafacade::SharedMemoryAllocator>(
+                        std::vector<storage::SharedRegionRegister::ShmKey>{
+                            static_region.shm_key, updatable_region.shm_key}));
        }

        util::Log() << "DataWatchdog thread stopped";
    }

-    mutable boost::shared_mutex factory_mutex;
    const std::string dataset_name;
    storage::SharedMonitor<storage::SharedRegionRegister> barrier;
    std::thread watcher;
@@ -142,14 +131,14 @@ class DataWatchdogImpl<AlgorithmT, datafacade::ContiguousInternalMemoryDataFacad
    storage::SharedRegion *updatable_shared_region;
    DataFacadeFactory<datafacade::ContiguousInternalMemoryDataFacade, AlgorithmT> facade_factory;
 };
-} // namespace detail
+}

 // This class monitors the shared memory region that contains the pointers to
 // the data and layout regions that should be used. This region is updated
 // once a new dataset arrives.
 template <typename AlgorithmT, template <typename A> class FacadeT>
 using DataWatchdog = detail::DataWatchdogImpl<AlgorithmT, FacadeT<AlgorithmT>>;
-} // namespace engine
-} // namespace osrm
+}
+}

 #endif
@@ -11,7 +11,7 @@ namespace engine
 using DataFacadeBase = datafacade::ContiguousInternalMemoryDataFacadeBase;
 template <typename AlgorithmT>
 using DataFacade = datafacade::ContiguousInternalMemoryDataFacade<AlgorithmT>;
-} // namespace engine
-} // namespace osrm
+}
+}

 #endif
@@ -99,8 +99,8 @@ template <> class AlgorithmDataFacade<MLD>
    // searches for a specific edge
    virtual EdgeID FindEdge(const NodeID from, const NodeID to) const = 0;
 };
-} // namespace datafacade
-} // namespace engine
-} // namespace osrm
+}
+}
+}

 #endif
@@ -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");

@@ -315,13 +312,12 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
    std::vector<PhantomNodeWithDistance>
    NearestPhantomNodesInRange(const util::Coordinate input_coordinate,
                               const float max_distance,
-                               const Approach approach,
-                               const bool use_all_edges) const override final
+                               const Approach approach) const override final
    {
        BOOST_ASSERT(m_geospatial_query.get());

        return m_geospatial_query->NearestPhantomNodesInRange(
-            input_coordinate, max_distance, approach, use_all_edges);
+            input_coordinate, max_distance, approach);
    }

    std::vector<PhantomNodeWithDistance>
@@ -329,13 +325,12 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
                               const float max_distance,
                               const int bearing,
                               const int bearing_range,
-                               const Approach approach,
-                               const bool use_all_edges) const override final
+                               const Approach approach) const override final
    {
        BOOST_ASSERT(m_geospatial_query.get());

        return m_geospatial_query->NearestPhantomNodesInRange(
-            input_coordinate, max_distance, bearing, bearing_range, approach, use_all_edges);
+            input_coordinate, max_distance, bearing, bearing_range, approach);
    }

    std::vector<PhantomNodeWithDistance>
@@ -389,25 +384,23 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade

    std::pair<PhantomNode, PhantomNode>
    NearestPhantomNodeWithAlternativeFromBigComponent(const util::Coordinate input_coordinate,
-                                                      const Approach approach,
-                                                      const bool use_all_edges) const override final
+                                                      const Approach approach) const override final
    {
        BOOST_ASSERT(m_geospatial_query.get());

        return m_geospatial_query->NearestPhantomNodeWithAlternativeFromBigComponent(
-            input_coordinate, approach, use_all_edges);
+            input_coordinate, approach);
    }

    std::pair<PhantomNode, PhantomNode>
    NearestPhantomNodeWithAlternativeFromBigComponent(const util::Coordinate input_coordinate,
                                                      const double max_distance,
-                                                      const Approach approach,
-                                                      const bool use_all_edges) const override final
+                                                      const Approach approach) const override final
    {
        BOOST_ASSERT(m_geospatial_query.get());

        return m_geospatial_query->NearestPhantomNodeWithAlternativeFromBigComponent(
-            input_coordinate, max_distance, approach, use_all_edges);
+            input_coordinate, max_distance, approach);
    }

    std::pair<PhantomNode, PhantomNode>
@@ -415,35 +408,28 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
                                                      const double max_distance,
                                                      const int bearing,
                                                      const int bearing_range,
-                                                      const Approach approach,
-                                                      const bool use_all_edges) const override final
+                                                      const Approach approach) const override final
    {
        BOOST_ASSERT(m_geospatial_query.get());

        return m_geospatial_query->NearestPhantomNodeWithAlternativeFromBigComponent(
-            input_coordinate, max_distance, bearing, bearing_range, approach, use_all_edges);
+            input_coordinate, max_distance, bearing, bearing_range, approach);
    }

    std::pair<PhantomNode, PhantomNode>
    NearestPhantomNodeWithAlternativeFromBigComponent(const util::Coordinate input_coordinate,
                                                      const int bearing,
                                                      const int bearing_range,
-                                                      const Approach approach,
-                                                      const bool use_all_edges) const override final
+                                                      const Approach approach) const override final
    {
        BOOST_ASSERT(m_geospatial_query.get());

        return m_geospatial_query->NearestPhantomNodeWithAlternativeFromBigComponent(
-            input_coordinate, bearing, bearing_range, approach, use_all_edges);
+            input_coordinate, bearing, bearing_range, approach);
    }

    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);
@@ -609,7 +595,7 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
        auto found_range = std::equal_range(
            m_maneuver_overrides.begin(), m_maneuver_overrides.end(), edge_based_node_id, Comp{});

-        std::for_each(found_range.first, found_range.second, [&](const auto &override) {
+        std::for_each(found_range.first, found_range.second, [&](const auto & override) {
            std::vector<NodeID> sequence(
                m_maneuver_override_node_sequences.begin() + override.node_sequence_offset_begin,
                m_maneuver_override_node_sequences.begin() + override.node_sequence_offset_end);
@@ -760,8 +746,8 @@ class ContiguousInternalMemoryDataFacade<MLD> final
    {
    }
 };
-} // namespace datafacade
-} // namespace engine
-} // namespace osrm
+}
+}
+}

 #endif // CONTIGUOUS_INTERNALMEM_DATAFACADE_HPP
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Kajari Ghosh	fb343352bc	bump to rc 4	2018-12-11 13:20:18 -05:00
Daniel Patterson	4632ec3b67	Include information on estimates in table response (#5259 ) * Revert "Remove estimated_cells value in the response." This reverts commit `364e35af06`. * Update changelog. * fix linting * adjust fallback_speed check * change [].includes to [].indexOf !== -1 for compatibility with node 4 * change param name * more cuke tests * fix formatting	2018-12-11 13:17:34 -05:00
Daniel Patterson	7f9ac81028	Include distance from input to snapped for all waypoints, not just on the `nearest` service.	2018-12-11 13:16:44 -05:00
Kajari Ghosh	a123cb6efb	bump to rc3	2018-12-10 22:56:55 -05:00
Kajari Ghosh	63e713aa4a	Revert "Include distance from input to snapped for all waypoints, not just on the `nearest` service." This reverts commit `4dde9c7bbe`.	2018-12-10 22:48:57 -05:00
Kajari Ghosh	9daef767fa	bump to rc 2	2018-12-10 17:37:09 -05:00
Kajari Ghosh	d89a513183	Fix scale_factor bug (#5303 ) * check for scale_factor != 1 * changelog	2018-12-10 17:12:21 -05:00
Kajari Ghosh	c43ea37e05	5.20.1 rc 1	2018-12-10 15:16:10 -05:00
Kajari Ghosh	ec6c10661f	Fix fallback speed validity checks (#5300 ) * fix fallback_speeds check to only accept values > 0 * add invalid_fallback_speed	2018-12-10 15:09:46 -05:00
Kajari Ghosh	bcdc689ae9	Add a multiplier to the matrix (#5298 ) * add a multiplier to the matrix * add rounding * remove scale_factor restrictions * clamp for overflow error * update check to match error message * enforce clamping on < 0 and increase test coverage * add an invalid scale_factor value to node tests * increase test coverage * changelog	2018-12-10 15:09:37 -05:00
Kajari Ghosh	b3eb8970f1	bump to restart appveyor	2018-12-10 10:23:55 -05:00
Kajari Ghosh	ab22cc7516	Merge branch 'master' into 5.20	2018-12-10 10:02:44 -05:00
Kajari Ghosh	18f446735c	update CHANGELOG and osrm version in package.json for v5.20.0	2018-12-10 10:01:28 -05:00
allierowan	9234b2ae76	remove line from changelog about commit that isn't actually in here	2018-12-05 15:29:06 -05:00
allierowan	8b5ade3861	5.20.0	2018-12-05 14:43:21 -05:00
Kajari Ghosh	baa8214270	bump rc version	2018-12-05 00:44:44 -05:00
Kajari Ghosh	d41b03b778	Fix fallback_speed vector access (#5291 ) * add failing cuke test * correctly access durations vector * changelog * one more cuke test	2018-12-05 00:43:16 -05:00
Kajari Ghosh	31d8ff7a74	bump version to rc5	2018-12-04 14:19:23 -05:00
Daniel Paz-Soldan	cb2532d0da	Add node 10 builds to travis (#5246 ) * Add node 10 builds to travis * Add changelog	2018-12-04 14:18:31 -05:00
Kajari Ghosh	e222fcfb17	remove destination/sources length <= coordinates length check (#5289 )	2018-12-04 14:17:13 -05:00
Daniel Patterson	7a5b6dbede	Bump version.	2018-11-02 01:43:15 -07:00
Daniel Patterson	c08953c0e6	Merge branch 'master' into 5.20	2018-11-02 01:42:30 -07:00
Daniel Patterson	e5a6c73fdf	Prepare RC.1	2018-10-30 16:17:14 -07:00