Merge branch 'master' into mbell/libosrm_api_2

.travis.yml

@@ -62,8 +62,8 @@ matrix:
         - npm ci --ignore-scripts
       script:
         - ./scripts/check_taginfo.py taginfo.json profiles/car.lua
-        - ${MASON} install clang-format 3.8.1
+        - ${MASON} install clang-format 10.0.0
-        - PATH=$(${MASON} prefix clang-format 3.8.1)/bin:${PATH} ./scripts/format.sh && ./scripts/error_on_dirty.sh
+        - PATH=$(${MASON} prefix clang-format 10.0.0)/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
@@ -177,9 +177,17 @@ matrix:
 
     - os: osx
       osx_image: xcode9.2
-      compiler: "mason-osx-release-node-8"
+      compiler: "mason-osx-release-node-12"
       # 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"
+      env: ENABLE_MASON=ON BUILD_TYPE='Release' CUCUMBER_TIMEOUT=60000 CCOMPILER='clang' CXXCOMPILER='clang++' ENABLE_ASSERTIONS=ON ENABLE_LTO=ON NODE="12"
+      after_success:
+        - ./scripts/travis/publish.sh
+
+    - os: osx
+      osx_image: xcode9.2
+      compiler: "mason-osx-release-node-14"
+      # 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="14"
       after_success:
         - ./scripts/travis/publish.sh
 
@@ -195,12 +203,12 @@ matrix:
     # Node build jobs. These skip running the tests.
     - os: linux
       sudo: false
-      compiler: "node-8-mason-linux-release"
+      compiler: "node-14-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"
+      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Release' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="14"
       install:
         - pushd ${OSRM_BUILD_DIR}
         - |
@@ -219,12 +227,60 @@ matrix:
 
     - os: linux
       sudo: false
-      compiler: "node-8-mason-linux-debug"
+      compiler: "node-14-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"
+      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Debug' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="14"
+      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-12-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="12"
+      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-12-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="12"
       install:
         - pushd ${OSRM_BUILD_DIR}
         - |
@@ -510,6 +566,7 @@ script:
   - ./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

CHANGELOG.md

@@ -1,4 +1,21 @@
 # Unreleased
+  - 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: 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)
+    - 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)
 

appveyor-build.bat

@@ -131,6 +131,10 @@ 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
+
 ECHO running engine-tests.exe ...
 unit_tests\%Configuration%\engine-tests.exe
 IF %ERRORLEVEL% EQU 1 GOTO ERROR
@@ -143,34 +147,41 @@ ECHO running server-tests.exe ...
 unit_tests\%Configuration%\server-tests.exe
 IF %ERRORLEVEL% EQU 1 GOTO ERROR
 
-::TODO: CH processing sometimes mysteriously hangs, need to find why and enable tests below.
+ECHO running partitioner-tests.exe ...
-::ECHO running library-tests.exe ...
+unit_tests\%Configuration%\partitioner-tests.exe
-::SET test_region=monaco
+IF %ERRORLEVEL% EQU 1 GOTO ERROR
-::SET test_region_ch=ch\monaco
+
-::SET test_region_corech=corech\monaco
+ECHO running customizer-tests.exe ...
-::SET test_region_mld=mld\monaco
+unit_tests\%Configuration%\customizer-tests.exe
-::SET test_osm=%test_region%.osm.pbf
+IF %ERRORLEVEL% EQU 1 GOTO ERROR
-::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%
+ECHO running library-tests.exe ...
-::%Configuration%\osrm-extract.exe
+SET test_region=monaco
-::%Configuration%\osrm-extract.exe -p ../profiles/car.lua %test_osm%
+SET test_region_ch=ch\monaco
-::MKDIR ch
+SET test_region_corech=corech\monaco
-::XCOPY %test_region%.osrm.* ch\
+SET test_region_mld=mld\monaco
-::XCOPY %test_region%.osrm ch\
+SET test_osm=%test_region%.osm.pbf
-::MKDIR corech
+IF NOT EXIST %test_osm% powershell Invoke-WebRequest http://project-osrm.wolt.com/testing/monaco.osm.pbf -OutFile %test_osm%
-::XCOPY %test_region%.osrm.* corech\
+ECHO running %Configuration%\osrm-extract.exe -p ../profiles/car.lua %test_osm%
-::XCOPY %test_region%.osrm corech\
+%Configuration%\osrm-extract.exe
-::MKDIR mld
+%Configuration%\osrm-extract.exe -p ../profiles/car.lua %test_osm%
-::XCOPY %test_region%.osrm.* mld\
+MKDIR ch
-::XCOPY %test_region%.osrm mld\
+XCOPY %test_region%.osrm.* ch\
-::%Configuration%\osrm-contract.exe %test_region_ch%.osrm
+XCOPY %test_region%.osrm ch\
-::%Configuration%\osrm-contract.exe --core 0.8 %test_region_corech%.osrm
+MKDIR corech
-::%Configuration%\osrm-partition.exe %test_region_mld%.osrm
+XCOPY %test_region%.osrm.* corech\
-::%Configuration%\osrm-customize.exe %test_region_mld%.osrm
+XCOPY %test_region%.osrm corech\
-::XCOPY /Y ch\*.* ..\test\data\ch\
+MKDIR mld
-::XCOPY /Y corech\*.* ..\test\data\corech\
+XCOPY %test_region%.osrm.* mld\
-::XCOPY /Y mld\*.* ..\test\data\mld\
+XCOPY %test_region%.osrm mld\
-::unit_tests\%Configuration%\library-tests.exe
+%Configuration%\osrm-contract.exe %test_region_ch%.osrm
+%Configuration%\osrm-contract.exe --core 0.8 %test_region_corech%.osrm
+%Configuration%\osrm-partition.exe %test_region_mld%.osrm
+%Configuration%\osrm-customize.exe %test_region_mld%.osrm
+XCOPY /Y ch\*.* ..\test\data\ch\
+XCOPY /Y corech\*.* ..\test\data\corech\
+XCOPY /Y mld\*.* ..\test\data\mld\
+unit_tests\%Configuration%\library-tests.exe
 
 :ERROR
 ECHO ~~~~~~~~~~~~~~~~~~~~~~ ERROR %~f0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~

docs/http.md

@@ -299,9 +299,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 waypoint to the j-th waypoint. Values are given in seconds. Can be `null` if no route between `i` and `j` can be found.
+  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.
 - `distances` array of arrays that stores the matrix in row-major order. `distances[i][j]` gives the travel distance from
-  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.
+  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.
 - `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.

features/car/conditional_restrictions.feature

@@ -387,217 +387,37 @@ Feature: Car - Turn restrictions
             | m    | p  | mj,jp,jp       |
 
     @no_turning @conditionals
-    Scenario: Car - only_right_turn
+    Scenario: Car - Multiple conditional restrictions applicable to same 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        | only_right_turn @ (Mo-Su 07:00-14:00) |
-
-        When I route I should get
-            | from | to | route          |
-            | 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
+            k - l - m
+                |
+                n
             """
 
         And the ways
-            | nodes | oneway |
+            | nodes |
-            | aj    | no     |
+            | kl    |
-            | jc    | no     |
+            | jl    |
-            | jp    | yes    |
+            | ln    |
-            | mj    | yes    |
+            | lm    |
 
         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) |
+            | 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) |
 
         When I route I should get
             | from | to | route          |
-            | a    | p  | aj,jc,jc,jp,jp |
+            | k    | m  | kl,ln,ln,lm,lm |
-            | m    | p  | mj,jp,jp       |
+
 
     @restriction-way
     Scenario: Car - prohibit turn
@@ -1047,7 +867,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 restrictino is off, way restriction is on
+        # node restriction 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 |

features/car/restrictions.feature

@@ -798,82 +798,6 @@ 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
@@ -984,8 +908,6 @@ 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 |

features/testbot/nil.feature

@@ -1,18 +1,18 @@
 @routing @testbot @nil
-Feature: Testbot - Check assigning nil values
+Feature: Testbot - Check assigning empty values
-    Scenario: Assign nil values to all way strings
+    Scenario: Assign empty values to all way strings
         Given the profile file
         """
         functions = require('testbot')
 
         function way_function(profile, way, result)
-          result.name = nil
+          result.name = ""
-          result.ref = nil
+          result.ref = ""
-          result.destinations = nil
+          result.destinations = ""
-          result.exits = nil
+          result.exits = ""
-          result.pronunciation = nil
+          result.pronunciation = ""
-          result.turn_lanes_forward = nil
+          result.turn_lanes_forward = ""
-          result.turn_lanes_backward = nil
+          result.turn_lanes_backward = ""
 
           result.forward_speed = 10
           result.backward_speed = 10

include/contractor/contract_excludable_graph.hpp

@@ -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

include/contractor/contracted_edge_container.hpp

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

include/contractor/contracted_metric.hpp

@@ -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

include/contractor/contractor.hpp

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

include/contractor/contractor_config.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

include/contractor/crc32_processor.hpp

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

include/contractor/files.hpp

@@ -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

include/contractor/query_edge.hpp

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

include/contractor/query_graph.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

include/contractor/serialization.hpp

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

include/customizer/cell_customizer.hpp

@@ -212,9 +212,8 @@ class CellCustomizer
             }
 
             const auto &data = graph.GetEdgeData(edge);
-            if (data.forward &&
+            if (data.forward && (first_level || partition.GetCell(level - 1, node) !=
-                (first_level ||
+                                                    partition.GetCell(level - 1, to)))
-                 partition.GetCell(level - 1, node) != partition.GetCell(level - 1, to)))
             {
                 const EdgeWeight to_weight = weight + data.weight;
                 const EdgeDuration to_duration = duration + data.duration;
@@ -237,7 +236,7 @@ class CellCustomizer
 
     const partitioner::MultiLevelPartition &partition;
 };
-}
+} // namespace customizer
-}
+} // namespace osrm
 
 #endif // OSRM_CELLS_CUSTOMIZER_HPP

include/customizer/cell_metric.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

include/customizer/customizer_config.hpp

@@ -39,7 +39,7 @@ struct CustomizationConfig final : storage::IOConfig
 
     updater::UpdaterConfig updater_config;
 };
-}
+} // namespace customizer
-}
+} // namespace osrm
 
 #endif // OSRM_CUSTOMIZE_CUSTOMIZER_CONFIG_HPP

include/customizer/edge_based_graph.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

include/customizer/files.hpp

@@ -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

include/customizer/serialization.hpp

@@ -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

include/engine/algorithm.hpp

@@ -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

include/engine/api/base_api.hpp

@@ -128,8 +128,8 @@ class BaseAPI
     const BaseParameters &parameters;
 };
 
-} // ns api
+} // namespace api
-} // ns engine
+} // namespace engine
-} // ns osrm
+} // namespace osrm
 
 #endif

include/engine/api/base_parameters.hpp

@@ -92,21 +92,21 @@ struct BaseParameters
 
     SnappingType snapping = SnappingType::Default;
 
-    BaseParameters(const std::vector<util::Coordinate> coordinates_ = {},
+    BaseParameters(std::vector<util::Coordinate> coordinates_ = {},
-                   const std::vector<boost::optional<Hint>> hints_ = {},
+                   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(coordinates_), hints(hints_), radiuses(radiuses_), bearings(bearings_),
+        : coordinates(std::move(coordinates_)), hints(std::move(hints_)),
-          approaches(approaches_), exclude(std::move(exclude)), generate_hints(generate_hints_),
+          radiuses(std::move(radiuses_)), bearings(std::move(bearings_)),
-          snapping(snapping_)
+          approaches(std::move(approaches_)), exclude(std::move(exclude)),
+          generate_hints(generate_hints_), snapping(snapping_)
     {
     }
 
-    // FIXME add validation for invalid bearing values
     bool IsValid() const
     {
         return (hints.empty() || hints.size() == coordinates.size()) &&
@@ -115,7 +115,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 +124,8 @@ struct BaseParameters
                            });
     }
 };
-}
+} // namespace api
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif // ROUTE_PARAMETERS_HPP

include/engine/api/base_result.hpp

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

include/engine/api/json_factory.hpp

@@ -112,8 +112,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
 

include/engine/api/match_api.hpp

@@ -248,8 +248,8 @@ class MatchAPI final : public RouteAPI
     const tidy::Result &tidy_result;
 };
 
-} // ns api
+} // namespace api
-} // ns engine
+} // namespace engine
-} // ns osrm
+} // namespace osrm
 
 #endif

include/engine/api/match_parameters.hpp

@@ -68,8 +68,11 @@ struct MatchParameters : public RouteParameters
     }
 
     template <typename... Args>
-    MatchParameters(std::vector<unsigned> timestamps_, GapsType gaps_, bool tidy_, Args... args_)
+    MatchParameters(const std::vector<unsigned> &timestamps_,
-        : MatchParameters(std::move(timestamps_), gaps_, tidy_, {}, std::forward<Args>(args_)...)
+                    GapsType gaps_,
+                    bool tidy_,
+                    Args &&... args_)
+        : MatchParameters(timestamps_, gaps_, tidy_, {}, std::forward<Args>(args_)...)
     {
     }
 
@@ -77,10 +80,11 @@ struct MatchParameters : public RouteParameters
     MatchParameters(std::vector<unsigned> timestamps_,
                     GapsType gaps_,
                     bool tidy_,
-                    std::vector<std::size_t> waypoints_,
+                    const std::vector<std::size_t> &waypoints_,
-                    Args... args_)
+                    Args &&... args_)
-        : RouteParameters{std::forward<Args>(args_)..., waypoints_},
+        : RouteParameters{std::forward<Args>(args_)..., waypoints_}, timestamps{std::move(
-          timestamps{std::move(timestamps_)}, gaps(gaps_), tidy(tidy_)
+                                                                         timestamps_)},
+          gaps(gaps_), tidy(tidy_)
     {
     }
 
@@ -94,8 +98,8 @@ struct MatchParameters : public RouteParameters
                (timestamps.empty() || timestamps.size() == coordinates.size());
     }
 };
-}
+} // namespace api
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif

include/engine/api/match_parameters_tidy.hpp

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

include/engine/api/nearest_api.hpp

@@ -159,8 +159,8 @@ class NearestAPI final : public BaseAPI
     }
 };
 
-} // ns api
+} // namespace api
-} // ns engine
+} // namespace engine
-} // ns osrm
+} // namespace osrm
 
 #endif

include/engine/api/nearest_parameters.hpp

@@ -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

include/engine/api/route_api.hpp

@@ -988,8 +988,8 @@ class RouteAPI : public BaseAPI
     }
 };
 
-} // ns api
+} // namespace api
-} // ns engine
+} // namespace engine
-} // ns osrm
+} // namespace osrm
 
 #endif

include/engine/api/route_parameters.hpp

@@ -87,19 +87,13 @@ 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_)...},
+        : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
-          steps{steps_},
+          number_of_alternatives{alternatives_ ? 1u : 0u}, annotations{false},
-          alternatives{alternatives_},
+          annotations_type{AnnotationsType::None}, geometries{geometries_}, overview{overview_},
-          number_of_alternatives{alternatives_ ? 1u : 0u},
+          continue_straight{continue_straight_}, waypoints()
-          annotations{false},
-          annotations_type{AnnotationsType::None},
-          geometries{geometries_},
-          overview{overview_},
-          continue_straight{continue_straight_},
-          waypoints()
     {
     }
 
@@ -111,7 +105,7 @@ 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},
@@ -129,12 +123,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 ? false : true},
+          annotations{annotations_ != AnnotationsType::None}, annotations_type{annotations_},
-          annotations_type{annotations_}, geometries{geometries_}, overview{overview_},
+          geometries{geometries_}, overview{overview_}, continue_straight{continue_straight_},
-          continue_straight{continue_straight_}, waypoints()
+          waypoints()
     {
     }
 
@@ -147,12 +141,12 @@ struct RouteParameters : public BaseParameters
                     const OverviewType overview_,
                     const boost::optional<bool> continue_straight_,
                     std::vector<std::size_t> waypoints_,
-                    const Args... args_)
+                    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_},
+          geometries{geometries_}, overview{overview_},
-          waypoints{waypoints_}
+          continue_straight{continue_straight_}, waypoints{std::move(waypoints_)}
     {
     }
 
@@ -165,12 +159,12 @@ struct RouteParameters : public BaseParameters
                     const OverviewType overview_,
                     const boost::optional<bool> continue_straight_,
                     std::vector<std::size_t> waypoints_,
-                    Args... args_)
+                    Args &&... args_)
         : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
-          number_of_alternatives{alternatives_ ? 1u : 0u},
+          number_of_alternatives{alternatives_ ? 1u : 0u}, annotations{annotations_ !=
-          annotations{annotations_ == AnnotationsType::None ? false : true},
+                                                                       AnnotationsType::None},
           annotations_type{annotations_}, geometries{geometries_}, overview{overview_},
-          continue_straight{continue_straight_}, waypoints{waypoints_}
+          continue_straight{continue_straight_}, waypoints{std::move(waypoints_)}
     {
     }
 
@@ -217,8 +211,8 @@ inline RouteParameters::AnnotationsType operator|=(RouteParameters::AnnotationsT
 {
     return lhs = lhs | rhs;
 }
-} // ns api
+} // namespace api
-} // ns engine
+} // namespace engine
-} // ns osrm
+} // namespace osrm
 
 #endif

include/engine/api/table_api.hpp

@@ -407,8 +407,8 @@ class TableAPI final : public BaseAPI
     const TableParameters &parameters;
 };
 
-} // ns api
+} // namespace api
-} // ns engine
+} // namespace engine
-} // ns osrm
+} // namespace osrm
 
 #endif

include/engine/api/table_parameters.hpp

@@ -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+ coodinates
+        // Distance Table makes only sense with 2+ coordinates
         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

include/engine/api/tile_parameters.hpp

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

include/engine/api/trip_api.hpp

@@ -175,8 +175,8 @@ class TripAPI final : public RouteAPI
     const TripParameters &parameters;
 };
 
-} // ns api
+} // namespace api
-} // ns engine
+} // namespace engine
-} // ns osrm
+} // namespace osrm
 
 #endif

include/engine/api/trip_parameters.hpp

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

include/engine/approach.hpp

@@ -42,5 +42,5 @@ enum class Approach : std::uint8_t
 
 };
 }
-}
+} // namespace osrm
 #endif

include/engine/base64.hpp

@@ -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
     >;
-} // ns detail
+} // namespace detail
 namespace engine
 {
 
@@ -135,7 +135,7 @@ template <typename T> T decodeBase64Bytewise(const std::string &encoded)
     return x;
 }
 
-} // ns engine
+} // namespace engine
-} // ns osrm
+} // namespace osrm
 
 #endif /* OSRM_BASE64_HPP */

include/engine/bearing.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

include/engine/data_watchdog.hpp

@@ -142,14 +142,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

include/engine/datafacade.hpp

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

include/engine/datafacade/algorithm_datafacade.hpp

@@ -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

include/engine/datafacade/contiguous_internalmem_datafacade.hpp

@@ -760,8 +760,8 @@ class ContiguousInternalMemoryDataFacade<MLD> final
     {
     }
 };
-}
+} // namespace datafacade
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif // CONTIGUOUS_INTERNALMEM_DATAFACADE_HPP

include/engine/datafacade/datafacade_base.hpp

@@ -223,8 +223,8 @@ class BaseDataFacade
     virtual std::vector<extractor::ManeuverOverride>
     GetOverridesThatStartAt(const NodeID edge_based_node_id) const = 0;
 };
-}
+} // namespace datafacade
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif // DATAFACADE_BASE_HPP

include/engine/datafacade_factory.hpp

@@ -70,7 +70,7 @@ template <template <typename A> class FacadeT, typename AlgorithmT> class DataFa
                              "The exclude prefix needs to be a valid data path.");
             std::size_t index =
                 std::stoi(exclude_prefix.substr(index_begin + 1, exclude_prefix.size()));
-            BOOST_ASSERT(index >= 0 && index < facades.size());
+            BOOST_ASSERT(index < facades.size());
             facades[index] = std::make_shared<const Facade>(allocator, metric_name, index);
         }
 
@@ -152,7 +152,7 @@ template <template <typename A> class FacadeT, typename AlgorithmT> class DataFa
     std::unordered_map<std::string, extractor::ClassData> name_to_class;
     const extractor::ProfileProperties *properties = nullptr;
 };
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif

include/engine/datafacade_provider.hpp

@@ -93,7 +93,7 @@ class WatchingProvider : public DataFacadeProvider<AlgorithmT, FacadeT>
         return watchdog.Get(params);
     }
 };
-}
+} // namespace detail
 
 template <typename AlgorithmT>
 using DataFacadeProvider = detail::DataFacadeProvider<AlgorithmT, DataFacade>;
@@ -103,7 +103,7 @@ template <typename AlgorithmT>
 using ImmutableProvider = detail::ImmutableProvider<AlgorithmT, DataFacade>;
 template <typename AlgorithmT>
 using ExternalProvider = detail::ExternalProvider<AlgorithmT, DataFacade>;
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif

include/engine/douglas_peucker.hpp

@@ -57,7 +57,7 @@ const constexpr std::uint64_t DOUGLAS_PEUCKER_THRESHOLDS[19] = {
 
 const constexpr auto DOUGLAS_PEUCKER_THRESHOLDS_SIZE =
     sizeof(DOUGLAS_PEUCKER_THRESHOLDS) / sizeof(*DOUGLAS_PEUCKER_THRESHOLDS);
-} // ns detail
+} // namespace detail
 
 // These functions compute the bitvector of indicating generalized input
 // points according to the (Ramer-)Douglas-Peucker algorithm.
@@ -75,7 +75,7 @@ inline std::vector<util::Coordinate> douglasPeucker(const std::vector<util::Coor
 {
     return douglasPeucker(begin(geometry), end(geometry), zoom_level);
 }
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif /* DOUGLAS_PEUCKER_HPP_ */

include/engine/engine.hpp

@@ -130,7 +130,7 @@ template <typename Algorithm> class Engine final : public EngineInterface
     const plugins::MatchPlugin match_plugin;
     const plugins::TilePlugin tile_plugin;
 };
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif // OSRM_IMPL_HPP

include/engine/engine_config.hpp

@@ -94,7 +94,7 @@ struct EngineConfig final
     std::string verbosity;
     std::string dataset_name;
 };
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif // SERVER_CONFIG_HPP

include/engine/geospatial_query.hpp

@@ -715,7 +715,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
     const CoordinateList &coordinates;
     DataFacadeT &datafacade;
 };
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif

include/engine/guidance/assemble_geometry.hpp

@@ -167,8 +167,8 @@ inline LegGeometry assembleGeometry(const datafacade::BaseDataFacade &facade,
 
     return geometry;
 }
-}
+} // namespace guidance
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif

include/engine/guidance/assemble_leg.hpp

@@ -122,7 +122,7 @@ std::array<std::uint32_t, SegmentNumber> summarizeRoute(const datafacade::BaseDa
                    [](const NamedSegment &segment) { return segment.name_id; });
     return summary;
 }
-}
+} // namespace detail
 
 inline RouteLeg assembleLeg(const datafacade::BaseDataFacade &facade,
                             const std::vector<PathData> &route_data,

include/engine/guidance/assemble_steps.hpp

@@ -35,7 +35,7 @@ std::pair<short, short> getDepartBearings(const LegGeometry &leg_geometry,
 std::pair<short, short> getArriveBearings(const LegGeometry &leg_geometry,
                                           const PhantomNode &target_node,
                                           const bool traversed_in_reverse);
-} // ns detail
+} // namespace detail
 
 inline std::vector<RouteStep> assembleSteps(const datafacade::BaseDataFacade &facade,
                                             const std::vector<PathData> &leg_data,

include/engine/guidance/collapse_turns.hpp

@@ -163,7 +163,7 @@ void combineRouteSteps(RouteStep &step_at_turn_location,
 void suppressStep(RouteStep &step_at_turn_location, RouteStep &step_after_turn_location);
 
 } /* namespace guidance */
-} /* namespace osrm */
+} // namespace engine
 } /* namespace osrm */
 
 #endif /* OSRM_ENGINE_GUIDANCE_COLLAPSE_HPP_ */

include/engine/guidance/leg_geometry.hpp

@@ -64,8 +64,8 @@ struct LegGeometry
         return segment_offsets.size() - 1;
     }
 };
-}
+} // namespace guidance
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif

include/engine/guidance/route.hpp

@@ -14,8 +14,8 @@ struct Route
     double duration;
     double weight;
 };
-}
+} // namespace guidance
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif

include/engine/guidance/route_leg.hpp

@@ -23,8 +23,8 @@ struct RouteLeg
     std::string summary;
     std::vector<RouteStep> steps;
 };
-}
+} // namespace guidance
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif

include/engine/guidance/step_maneuver.hpp

@@ -46,5 +46,5 @@ inline StepManeuver getInvalidStepManeuver()
 
 } // namespace guidance
 } // namespace engine
-} // namespace osrmn
+} // namespace osrm
 #endif

include/engine/hint.hpp

@@ -67,7 +67,7 @@ static_assert(sizeof(Hint) == 80 + 4, "Hint is bigger than expected");
 constexpr std::size_t ENCODED_HINT_SIZE = 112;
 static_assert(ENCODED_HINT_SIZE / 4 * 3 >= sizeof(Hint),
               "ENCODED_HINT_SIZE does not match size of Hint");
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif

include/engine/internal_route_result.hpp

@@ -173,7 +173,7 @@ inline InternalRouteResult CollapseInternalRouteResult(const InternalRouteResult
                  collapsed.unpacked_path_segments.size());
     return collapsed;
 }
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif // RAW_ROUTE_DATA_H

include/engine/map_matching/bayes_classifier.hpp

@@ -98,8 +98,8 @@ class BayesClassifier
     double positive_apriori_probability;
     double negative_apriori_probability;
 };
-}
+} // namespace map_matching
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif // BAYES_CLASSIFIER_HPP

include/engine/map_matching/hidden_markov_model.hpp

@@ -137,8 +137,8 @@ template <class CandidateLists> struct HiddenMarkovModel
         return initial_timestamp;
     }
 };
-}
+} // namespace map_matching
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif // HIDDEN_MARKOV_MODEL

include/engine/map_matching/matching_confidence.hpp

@@ -51,8 +51,8 @@ struct MatchingConfidence
   private:
     ClassifierT classifier;
 };
-}
+} // namespace map_matching
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif

include/engine/map_matching/sub_matching.hpp

@@ -19,8 +19,8 @@ struct SubMatching
     std::vector<unsigned> alternatives_count;
     double confidence;
 };
-}
+} // namespace map_matching
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif

include/engine/phantom_node.hpp

@@ -44,14 +44,15 @@ namespace engine
 struct PhantomNode
 {
     PhantomNode()
-        : forward_segment_id{SPECIAL_SEGMENTID, false},
+        : forward_segment_id{SPECIAL_SEGMENTID, false}, reverse_segment_id{SPECIAL_SEGMENTID,
-          reverse_segment_id{SPECIAL_SEGMENTID, false}, forward_weight(INVALID_EDGE_WEIGHT),
+                                                                           false},
-          reverse_weight(INVALID_EDGE_WEIGHT), forward_weight_offset(0), reverse_weight_offset(0),
+          forward_weight(INVALID_EDGE_WEIGHT), reverse_weight(INVALID_EDGE_WEIGHT),
+          forward_weight_offset(0), reverse_weight_offset(0),
           forward_distance(INVALID_EDGE_DISTANCE), reverse_distance(INVALID_EDGE_DISTANCE),
           forward_distance_offset(0), reverse_distance_offset(0),
           forward_duration(MAXIMAL_EDGE_DURATION), reverse_duration(MAXIMAL_EDGE_DURATION),
-          forward_duration_offset(0), reverse_duration_offset(0), fwd_segment_position(0),
+          forward_duration_offset(0), reverse_duration_offset(0),
-          is_valid_forward_source{false}, is_valid_forward_target{false},
+          fwd_segment_position(0), is_valid_forward_source{false}, is_valid_forward_target{false},
           is_valid_reverse_source{false}, is_valid_reverse_target{false}, bearing(0)
 
     {
@@ -109,7 +110,8 @@ struct PhantomNode
 
     bool IsValid(const unsigned number_of_nodes) const
     {
-        return location.IsValid() && ((forward_segment_id.id < number_of_nodes) ||
+        return location.IsValid() &&
+               ((forward_segment_id.id < number_of_nodes) ||
                 (reverse_segment_id.id < number_of_nodes)) &&
                ((forward_weight != INVALID_EDGE_WEIGHT) ||
                 (reverse_weight != INVALID_EDGE_WEIGHT)) &&
@@ -234,7 +236,7 @@ struct PhantomNodes
     PhantomNode source_phantom;
     PhantomNode target_phantom;
 };
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif // PHANTOM_NODES_H

include/engine/plugins/match.hpp

@@ -38,8 +38,8 @@ class MatchPlugin : public BasePlugin
     const int max_locations_map_matching;
     const double max_radius_map_matching;
 };
-}
+} // namespace plugins
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif // MATCH_HPP

include/engine/plugins/nearest.hpp

@@ -26,8 +26,8 @@ class NearestPlugin final : public BasePlugin
   private:
     const int max_results;
 };
-}
+} // namespace plugins
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif /* NEAREST_HPP */

include/engine/plugins/plugin_base.hpp

@@ -131,8 +131,10 @@ class BasePlugin
                 return phantom_pair.first;
             };
 
-        const auto use_closed_phantom = [](
+        const auto use_closed_phantom =
-            const std::pair<PhantomNode, PhantomNode> &phantom_pair) { return phantom_pair.first; };
+            [](const std::pair<PhantomNode, PhantomNode> &phantom_pair) {
+                return phantom_pair.first;
+            };
 
         const bool every_phantom_is_in_tiny_cc = std::all_of(std::begin(phantom_node_pair_list),
                                                              std::end(phantom_node_pair_list),
@@ -388,8 +390,8 @@ class BasePlugin
                std::to_string(missing_index);
     }
 };
-}
+} // namespace plugins
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif /* BASE_PLUGIN_HPP */

include/engine/plugins/table.hpp

@@ -27,8 +27,8 @@ class TablePlugin final : public BasePlugin
   private:
     const int max_locations_distance_table;
 };
-}
+} // namespace plugins
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif // TABLE_HPP

include/engine/plugins/tile.hpp

@@ -30,8 +30,8 @@ class TilePlugin final : public BasePlugin
                          const api::TileParameters &parameters,
                          osrm::engine::api::ResultT &pbf_buffer) const;
 };
-}
+} // namespace plugins
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif /* TILEPLUGIN_HPP */

include/engine/plugins/trip.hpp

@@ -42,8 +42,8 @@ class TripPlugin final : public BasePlugin
                          const api::TripParameters &parameters,
                          osrm::engine::api::ResultT &json_result) const;
 };
-}
+} // namespace plugins
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif // TRIP_HPP

include/engine/plugins/viaroute.hpp

@@ -35,8 +35,8 @@ class ViaRoutePlugin final : public BasePlugin
                          const api::RouteParameters &route_parameters,
                          osrm::engine::api::ResultT &json_result) const;
 };
-}
+} // namespace plugins
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif // VIA_ROUTE_HPP

include/engine/polyline_compressor.hpp

@@ -17,7 +17,7 @@ namespace detail
 std::string encode(std::vector<int> &numbers);
 std::int32_t decode_polyline_integer(std::string::const_iterator &first,
                                      std::string::const_iterator last);
-}
+} // namespace detail
 using CoordVectorForwardIter = std::vector<util::Coordinate>::const_iterator;
 // Encodes geometry into polyline format.
 // See: https://developers.google.com/maps/documentation/utilities/polylinealgorithm
@@ -80,7 +80,7 @@ std::vector<util::Coordinate> decodePolyline(const std::string &polyline)
     }
     return coordinates;
 }
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif /* POLYLINECOMPRESSOR_H_ */

include/engine/routing_algorithms.hpp

@@ -230,7 +230,7 @@ inline std::vector<routing_algorithms::TurnData> RoutingAlgorithms<Algorithm>::G
     return routing_algorithms::getTileTurns(*facade, edges, sorted_edge_indexes);
 }
 
-} // ns engine
+} // namespace engine
-} // ns osrm
+} // namespace osrm
 
 #endif

include/engine/routing_algorithms/routing_base_ch.hpp

@@ -24,11 +24,10 @@ namespace ch
 // Stalling
 template <bool DIRECTION, typename HeapT>
 bool stallAtNode(const DataFacade<Algorithm> &facade,
-                 const NodeID node,
+                 const typename HeapT::HeapNode &heapNode,
-                 const EdgeWeight weight,
                  const HeapT &query_heap)
 {
-    for (auto edge : facade.GetAdjacentEdgeRange(node))
+    for (auto edge : facade.GetAdjacentEdgeRange(heapNode.node))
     {
         const auto &data = facade.GetEdgeData(edge);
         if (DIRECTION == REVERSE_DIRECTION ? data.forward : data.backward)
@@ -36,9 +35,10 @@ bool stallAtNode(const DataFacade<Algorithm> &facade,
             const NodeID to = facade.GetTarget(edge);
             const EdgeWeight edge_weight = data.weight;
             BOOST_ASSERT_MSG(edge_weight > 0, "edge_weight invalid");
-            if (query_heap.WasInserted(to))
+            const auto toHeapNode = query_heap.GetHeapNodeIfWasInserted(to);
+            if (toHeapNode)
             {
-                if (query_heap.GetKey(to) + edge_weight < weight)
+                if (toHeapNode->weight + edge_weight < heapNode.weight)
                 {
                     return true;
                 }
@@ -50,11 +50,10 @@ bool stallAtNode(const DataFacade<Algorithm> &facade,
 
 template <bool DIRECTION>
 void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
-                        const NodeID node,
+                        const SearchEngineData<Algorithm>::QueryHeap::HeapNode &heapNode,
-                        const EdgeWeight weight,
                         SearchEngineData<Algorithm>::QueryHeap &heap)
 {
-    for (const auto edge : facade.GetAdjacentEdgeRange(node))
+    for (const auto edge : facade.GetAdjacentEdgeRange(heapNode.node))
     {
         const auto &data = facade.GetEdgeData(edge);
         if (DIRECTION == FORWARD_DIRECTION ? data.forward : data.backward)
@@ -63,19 +62,21 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
             const EdgeWeight edge_weight = data.weight;
 
             BOOST_ASSERT_MSG(edge_weight > 0, "edge_weight invalid");
-            const EdgeWeight to_weight = weight + edge_weight;
+            const EdgeWeight to_weight = heapNode.weight + edge_weight;
 
+            const auto toHeapNode = heap.GetHeapNodeIfWasInserted(to);
             // New Node discovered -> Add to Heap + Node Info Storage
-            if (!heap.WasInserted(to))
+            if (!toHeapNode)
             {
-                heap.Insert(to, to_weight, node);
+                heap.Insert(to, to_weight, heapNode.node);
             }
             // Found a shorter Path -> Update weight
-            else if (to_weight < heap.GetKey(to))
+            else if (to_weight < toHeapNode->weight)
             {
                 // new parent
-                heap.GetData(to).parent = node;
+                toHeapNode->data.parent = heapNode.node;
-                heap.DecreaseKey(to, to_weight);
+                toHeapNode->weight = to_weight;
+                heap.DecreaseKey(*toHeapNode);
             }
         }
     }
@@ -122,35 +123,35 @@ void routingStep(const DataFacade<Algorithm> &facade,
                  const bool force_loop_forward,
                  const bool force_loop_reverse)
 {
-    const NodeID node = forward_heap.DeleteMin();
+    auto heapNode = forward_heap.DeleteMinGetHeapNode();
-    const EdgeWeight weight = forward_heap.GetKey(node);
+    const auto reverseHeapNode = reverse_heap.GetHeapNodeIfWasInserted(heapNode.node);
 
-    if (reverse_heap.WasInserted(node))
+    if (reverseHeapNode)
     {
-        const EdgeWeight new_weight = reverse_heap.GetKey(node) + weight;
+        const EdgeWeight new_weight = reverseHeapNode->weight + heapNode.weight;
         if (new_weight < upper_bound)
         {
             // if loops are forced, they are so at the source
-            if ((force_loop_forward && forward_heap.GetData(node).parent == node) ||
+            if ((force_loop_forward && heapNode.data.parent == heapNode.node) ||
-                (force_loop_reverse && reverse_heap.GetData(node).parent == node) ||
+                (force_loop_reverse && reverseHeapNode->data.parent == heapNode.node) ||
                 // in this case we are looking at a bi-directional way where the source
                 // and target phantom are on the same edge based node
                 new_weight < 0)
             {
                 // check whether there is a loop present at the node
-                for (const auto edge : facade.GetAdjacentEdgeRange(node))
+                for (const auto edge : facade.GetAdjacentEdgeRange(heapNode.node))
                 {
                     const auto &data = facade.GetEdgeData(edge);
                     if (DIRECTION == FORWARD_DIRECTION ? data.forward : data.backward)
                     {
                         const NodeID to = facade.GetTarget(edge);
-                        if (to == node)
+                        if (to == heapNode.node)
                         {
                             const EdgeWeight edge_weight = data.weight;
                             const EdgeWeight loop_weight = new_weight + edge_weight;
                             if (loop_weight >= 0 && loop_weight < upper_bound)
                             {
-                                middle_node_id = node;
+                                middle_node_id = heapNode.node;
                                 upper_bound = loop_weight;
                             }
                         }
@@ -161,7 +162,7 @@ void routingStep(const DataFacade<Algorithm> &facade,
             {
                 BOOST_ASSERT(new_weight >= 0);
 
-                middle_node_id = node;
+                middle_node_id = heapNode.node;
                 upper_bound = new_weight;
             }
         }
@@ -170,19 +171,19 @@ void routingStep(const DataFacade<Algorithm> &facade,
     // make sure we don't terminate too early if we initialize the weight
     // for the nodes in the forward heap with the forward/reverse offset
     BOOST_ASSERT(min_edge_offset <= 0);
-    if (weight + min_edge_offset > upper_bound)
+    if (heapNode.weight + min_edge_offset > upper_bound)
     {
         forward_heap.DeleteAll();
         return;
     }
 
     // Stalling
-    if (STALLING && stallAtNode<DIRECTION>(facade, node, weight, forward_heap))
+    if (STALLING && stallAtNode<DIRECTION>(facade, heapNode, forward_heap))
     {
         return;
     }
 
-    relaxOutgoingEdges<DIRECTION>(facade, node, weight, forward_heap);
+    relaxOutgoingEdges<DIRECTION>(facade, heapNode, forward_heap);
 }
 
 template <bool UseDuration>

include/engine/routing_algorithms/routing_base_mld.hpp

@@ -97,7 +97,6 @@ inline LevelID getNodeQueryLevel(const MultiLevelPartition &partition,
                                  const std::vector<std::size_t> &phantom_indices)
 {
     auto min_level = [&partition, node](const PhantomNode &phantom_node) {
-
         const auto &forward_segment = phantom_node.forward_segment_id;
         const auto forward_level =
             forward_segment.enabled ? partition.GetHighestDifferentLevel(node, forward_segment.id)
@@ -120,7 +119,7 @@ inline LevelID getNodeQueryLevel(const MultiLevelPartition &partition,
     }
     return result;
 }
-}
+} // namespace
 
 // Heaps only record for each node its predecessor ("parent") on the shortest path.
 // For re-constructing the actual path we need to trace back all parent "pointers".
@@ -229,40 +228,42 @@ retrievePackedPathFromHeap(const SearchEngineData<Algorithm>::QueryHeap &forward
 template <bool DIRECTION, typename Algorithm, typename... Args>
 void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
                         typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                        const NodeID node,
+                        const typename SearchEngineData<Algorithm>::QueryHeap::HeapNode &heapNode,
-                        const EdgeWeight weight,
                         Args... args)
 {
     const auto &partition = facade.GetMultiLevelPartition();
     const auto &cells = facade.GetCellStorage();
     const auto &metric = facade.GetCellMetric();
 
-    const auto level = getNodeQueryLevel(partition, node, args...);
+    const auto level = getNodeQueryLevel(partition, heapNode.node, args...);
 
-    if (level >= 1 && !forward_heap.GetData(node).from_clique_arc)
+    if (level >= 1 && !heapNode.data.from_clique_arc)
     {
         if (DIRECTION == FORWARD_DIRECTION)
         {
             // Shortcuts in forward direction
-            const auto &cell = cells.GetCell(metric, level, partition.GetCell(level, node));
+            const auto &cell =
+                cells.GetCell(metric, level, partition.GetCell(level, heapNode.node));
             auto destination = cell.GetDestinationNodes().begin();
-            for (auto shortcut_weight : cell.GetOutWeight(node))
+            for (auto shortcut_weight : cell.GetOutWeight(heapNode.node))
             {
                 BOOST_ASSERT(destination != cell.GetDestinationNodes().end());
                 const NodeID to = *destination;
 
-                if (shortcut_weight != INVALID_EDGE_WEIGHT && node != to)
+                if (shortcut_weight != INVALID_EDGE_WEIGHT && heapNode.node != to)
                 {
-                    const EdgeWeight to_weight = weight + shortcut_weight;
+                    const EdgeWeight to_weight = heapNode.weight + shortcut_weight;
-                    BOOST_ASSERT(to_weight >= weight);
+                    BOOST_ASSERT(to_weight >= heapNode.weight);
-                    if (!forward_heap.WasInserted(to))
+                    const auto toHeapNode = forward_heap.GetHeapNodeIfWasInserted(to);
+                    if (!toHeapNode)
                     {
-                        forward_heap.Insert(to, to_weight, {node, true});
+                        forward_heap.Insert(to, to_weight, {heapNode.node, true});
                     }
-                    else if (to_weight < forward_heap.GetKey(to))
+                    else if (to_weight < toHeapNode->weight)
                     {
-                        forward_heap.GetData(to) = {node, true};
+                        toHeapNode->data = {heapNode.node, true};
-                        forward_heap.DecreaseKey(to, to_weight);
+                        toHeapNode->weight = to_weight;
+                        forward_heap.DecreaseKey(*toHeapNode);
                     }
                 }
                 ++destination;
@@ -271,25 +272,28 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
         else
         {
             // Shortcuts in backward direction
-            const auto &cell = cells.GetCell(metric, level, partition.GetCell(level, node));
+            const auto &cell =
+                cells.GetCell(metric, level, partition.GetCell(level, heapNode.node));
             auto source = cell.GetSourceNodes().begin();
-            for (auto shortcut_weight : cell.GetInWeight(node))
+            for (auto shortcut_weight : cell.GetInWeight(heapNode.node))
             {
                 BOOST_ASSERT(source != cell.GetSourceNodes().end());
                 const NodeID to = *source;
 
-                if (shortcut_weight != INVALID_EDGE_WEIGHT && node != to)
+                if (shortcut_weight != INVALID_EDGE_WEIGHT && heapNode.node != to)
                 {
-                    const EdgeWeight to_weight = weight + shortcut_weight;
+                    const EdgeWeight to_weight = heapNode.weight + shortcut_weight;
-                    BOOST_ASSERT(to_weight >= weight);
+                    BOOST_ASSERT(to_weight >= heapNode.weight);
-                    if (!forward_heap.WasInserted(to))
+                    const auto toHeapNode = forward_heap.GetHeapNodeIfWasInserted(to);
+                    if (!toHeapNode)
                     {
-                        forward_heap.Insert(to, to_weight, {node, true});
+                        forward_heap.Insert(to, to_weight, {heapNode.node, true});
                     }
-                    else if (to_weight < forward_heap.GetKey(to))
+                    else if (to_weight < toHeapNode->weight)
                     {
-                        forward_heap.GetData(to) = {node, true};
+                        toHeapNode->data = {heapNode.node, true};
-                        forward_heap.DecreaseKey(to, to_weight);
+                        toHeapNode->weight = to_weight;
+                        forward_heap.DecreaseKey(*toHeapNode);
                     }
                 }
                 ++source;
@@ -298,7 +302,7 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
     }
 
     // Boundary edges
-    for (const auto edge : facade.GetBorderEdgeRange(level, node))
+    for (const auto edge : facade.GetBorderEdgeRange(level, heapNode.node))
     {
         const auto &edge_data = facade.GetEdgeData(edge);
 
@@ -311,21 +315,23 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
                 checkParentCellRestriction(partition.GetCell(level + 1, to), args...))
             {
                 const auto node_weight =
-                    facade.GetNodeWeight(DIRECTION == FORWARD_DIRECTION ? node : to);
+                    facade.GetNodeWeight(DIRECTION == FORWARD_DIRECTION ? heapNode.node : to);
                 const auto turn_penalty = facade.GetWeightPenaltyForEdgeID(edge_data.turn_id);
 
                 // TODO: BOOST_ASSERT(edge_data.weight == node_weight + turn_penalty);
 
-                const EdgeWeight to_weight = weight + node_weight + turn_penalty;
+                const EdgeWeight to_weight = heapNode.weight + node_weight + turn_penalty;
 
-                if (!forward_heap.WasInserted(to))
+                const auto toHeapNode = forward_heap.GetHeapNodeIfWasInserted(to);
+                if (!toHeapNode)
                 {
-                    forward_heap.Insert(to, to_weight, {node, false});
+                    forward_heap.Insert(to, to_weight, {heapNode.node, false});
                 }
-                else if (to_weight < forward_heap.GetKey(to))
+                else if (to_weight < toHeapNode->weight)
                 {
-                    forward_heap.GetData(to) = {node, false};
+                    toHeapNode->data = {heapNode.node, false};
-                    forward_heap.DecreaseKey(to, to_weight);
+                    toHeapNode->weight = to_weight;
+                    forward_heap.DecreaseKey(*toHeapNode);
                 }
             }
         }
@@ -342,34 +348,35 @@ void routingStep(const DataFacade<Algorithm> &facade,
                  const bool force_loop_reverse,
                  Args... args)
 {
-    const auto node = forward_heap.DeleteMin();
+    const auto heapNode = forward_heap.DeleteMinGetHeapNode();
-    const auto weight = forward_heap.GetKey(node);
+    const auto weight = heapNode.weight;
 
-    BOOST_ASSERT(!facade.ExcludeNode(node));
+    BOOST_ASSERT(!facade.ExcludeNode(heapNode.node));
 
     // Upper bound for the path source -> target with
     // weight(source -> node) = weight weight(to -> target) ≤ reverse_weight
     // is weight + reverse_weight
     // More tighter upper bound requires additional condition reverse_heap.WasRemoved(to)
     // with weight(to -> target) = reverse_weight and all weights ≥ 0
-    if (reverse_heap.WasInserted(node))
+    const auto reverseHeapNode = reverse_heap.GetHeapNodeIfWasInserted(heapNode.node);
+    if (reverseHeapNode)
     {
-        auto reverse_weight = reverse_heap.GetKey(node);
+        auto reverse_weight = reverseHeapNode->weight;
         auto path_weight = weight + reverse_weight;
 
         // MLD uses loops forcing only to prune single node paths in forward and/or
         // backward direction (there is no need to force loops in MLD but in CH)
-        if (!(force_loop_forward && forward_heap.GetData(node).parent == node) &&
+        if (!(force_loop_forward && heapNode.data.parent == heapNode.node) &&
-            !(force_loop_reverse && reverse_heap.GetData(node).parent == node) &&
+            !(force_loop_reverse && reverseHeapNode->data.parent == heapNode.node) &&
             (path_weight >= 0) && (path_weight < path_upper_bound))
         {
-            middle_node = node;
+            middle_node = heapNode.node;
             path_upper_bound = path_weight;
         }
     }
 
     // Relax outgoing edges from node
-    relaxOutgoingEdges<DIRECTION>(facade, forward_heap, node, weight, args...);
+    relaxOutgoingEdges<DIRECTION>(facade, forward_heap, heapNode, args...);
 }
 
 // With (s, middle, t) we trace back the paths middle -> s and middle -> t.

include/engine/routing_algorithms/shortest_path_impl.hpp

@@ -226,7 +226,7 @@ inline void initializeHeap<mld::Algorithm>(SearchEngineData<mld::Algorithm> &eng
     const auto border_nodes_number = facade.GetMaxBorderNodeID() + 1;
     engine_working_data.InitializeOrClearFirstThreadLocalStorage(nodes_number, border_nodes_number);
 }
-}
+} // namespace
 
 template <typename Algorithm>
 InternalRouteResult shortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,

include/engine/search_engine_data.hpp

@@ -120,7 +120,7 @@ template <> struct SearchEngineData<routing_algorithms::mld::Algorithm>
     void InitializeOrClearManyToManyThreadLocalStorage(unsigned number_of_nodes,
                                                        unsigned number_of_boundary_nodes);
 };
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif // SEARCH_ENGINE_DATA_HPP

include/engine/status.hpp

@@ -42,7 +42,7 @@ enum class Status
     Ok,
     Error
 };
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif

include/engine/trip/trip_nearest_neighbour.hpp

@@ -92,8 +92,8 @@ std::vector<NodeID> NearestNeighbourTrip(const NodeIDIterator &start,
     }
     return route;
 }
-}
+} // namespace trip
-}
+} // namespace engine
-}
+} // namespace osrm
 
 #endif // TRIP_NEAREST_NEIGHBOUR_HPP

include/extractor/class_data.hpp

@@ -33,7 +33,7 @@ inline bool isValidClassName(const std::string &name)
                return std::isalnum(c);
            }) == name.end();
 }
-}
+} // namespace extractor
-}
+} // namespace osrm
 
 #endif

include/extractor/compressed_edge_container.hpp

@@ -82,7 +82,7 @@ class CompressedEdgeContainer
     std::unordered_map<EdgeID, unsigned> m_reverse_edge_id_to_zipped_index_map;
     std::unique_ptr<SegmentDataContainer> segment_data;
 };
-}
+} // namespace extractor
-}
+} // namespace osrm
 
 #endif // GEOMETRY_COMPRESSOR_HPP_

include/extractor/compressed_node_based_graph_edge.hpp

@@ -14,7 +14,7 @@ struct CompressedNodeBasedGraphEdge
     NodeID source;
     NodeID target;
 };
-}
+} // namespace extractor
-}
+} // namespace osrm
 
 #endif // OSRM_EXTRACTOR_COMPRESSED_NODE_BASED_GRAPH_EDGE_HPP

include/extractor/datasources.hpp

@@ -42,7 +42,7 @@ class Datasources
     std::array<std::uint32_t, MAX_NUM_SOURES> lengths;
     std::array<char, MAX_LENGTH_NAME * MAX_NUM_SOURES> sources;
 };
-}
+} // namespace extractor
-}
+} // namespace osrm
 
 #endif

include/extractor/edge_based_edge.hpp

@@ -96,7 +96,7 @@ inline bool EdgeBasedEdge::operator<(const EdgeBasedEdge &other) const
     return std::tie(source, target, data.weight, unidirectional) <
            std::tie(other.source, other.target, other.data.weight, other_is_unidirectional);
 }
-} // ns extractor
+} // namespace extractor
-} // ns osrm
+} // namespace osrm
 
 #endif /* EDGE_BASED_EDGE_HPP */

include/extractor/edge_based_graph_factory.hpp

@@ -12,8 +12,8 @@
 #include "extractor/name_table.hpp"
 #include "extractor/nbg_to_ebg.hpp"
 #include "extractor/node_data_container.hpp"
+#include "extractor/node_restriction_map.hpp"
 #include "extractor/query_node.hpp"
-#include "extractor/restriction_index.hpp"
 #include "extractor/turn_lane_types.hpp"
 #include "extractor/way_restriction_map.hpp"
 
@@ -54,7 +54,7 @@ struct TurnIndexBlock
 #pragma pack(pop)
 static_assert(std::is_trivial<TurnIndexBlock>::value, "TurnIndexBlock is not trivial");
 static_assert(sizeof(TurnIndexBlock) == 12, "TurnIndexBlock is not packed correctly");
-} // ns lookup
+} // namespace lookup
 
 struct NodeBasedGraphToEdgeBasedGraphMappingWriter; // fwd. decl
 

include/extractor/edge_based_node_segment.hpp

@@ -20,8 +20,9 @@ namespace extractor
 struct EdgeBasedNodeSegment
 {
     EdgeBasedNodeSegment()
-        : forward_segment_id{SPECIAL_SEGMENTID, false},
+        : forward_segment_id{SPECIAL_SEGMENTID, false}, reverse_segment_id{SPECIAL_SEGMENTID,
-          reverse_segment_id{SPECIAL_SEGMENTID, false}, u(SPECIAL_NODEID), v(SPECIAL_NODEID),
+                                                                           false},
+          u(SPECIAL_NODEID), v(SPECIAL_NODEID),
           fwd_segment_position(std::numeric_limits<unsigned short>::max() >>
                                1), // >> 1 because we've only got 15 bits
           is_startpoint(false)
@@ -47,7 +48,7 @@ struct EdgeBasedNodeSegment
     unsigned short fwd_segment_position : 15; // segment id in a compressed geometry
     bool is_startpoint : 1;
 };
-}
+} // namespace extractor
-}
+} // namespace osrm
 
 #endif // OSRM_EXTRACT_EDGE_BASED_NODE_SEGMENT_HPP

include/extractor/extraction_containers.hpp

@@ -1,14 +1,16 @@
 #ifndef EXTRACTION_CONTAINERS_HPP
 #define EXTRACTION_CONTAINERS_HPP
 
-#include "extractor/first_and_last_segment_of_way.hpp"
 #include "extractor/internal_extractor_edge.hpp"
+#include "extractor/nodes_of_way.hpp"
 #include "extractor/query_node.hpp"
 #include "extractor/restriction.hpp"
 #include "extractor/scripting_environment.hpp"
 
 #include "storage/tar_fwd.hpp"
 
+#include <unordered_map>
+
 namespace osrm
 {
 namespace extractor
@@ -22,9 +24,16 @@ namespace extractor
  */
 class ExtractionContainers
 {
+    using ReferencedWays = std::unordered_map<OSMWayID, NodesOfWay>;
+    // The relationship between way and nodes is lost during node preparation.
+    // We identify the ways and nodes relevant to restrictions/overrides prior to
+    // node processing so that they can be referenced in the preparation phase.
+    ReferencedWays IdentifyRestrictionWays();
+    ReferencedWays IdentifyManeuverOverrideWays();
+
     void PrepareNodes();
-    void PrepareManeuverOverrides();
+    void PrepareManeuverOverrides(const ReferencedWays &maneuver_override_ways);
-    void PrepareRestrictions();
+    void PrepareRestrictions(const ReferencedWays &restriction_ways);
     void PrepareEdges(ScriptingEnvironment &scripting_environment);
 
     void WriteNodes(storage::tar::FileWriter &file_out) const;
@@ -37,9 +46,10 @@ class ExtractionContainers
     using NodeVector = std::vector<QueryNode>;
     using EdgeVector = std::vector<InternalExtractorEdge>;
     using AnnotationDataVector = std::vector<NodeBasedEdgeAnnotation>;
-    using WayIDStartEndVector = std::vector<FirstAndLastSegmentOfWay>;
     using NameCharData = std::vector<unsigned char>;
-    using NameOffsets = std::vector<unsigned>;
+    using NameOffsets = std::vector<size_t>;
+    using WayIDVector = std::vector<OSMWayID>;
+    using WayNodeIDOffsets = std::vector<size_t>;
 
     std::vector<OSMNodeID> barrier_nodes;
     std::vector<OSMNodeID> traffic_signals;
@@ -49,20 +59,18 @@ class ExtractionContainers
     AnnotationDataVector all_edges_annotation_data_list;
     NameCharData name_char_data;
     NameOffsets name_offsets;
-    // an adjacency array containing all turn lane masks
+    WayIDVector ways_list;
-    WayIDStartEndVector way_start_end_id_list;
+    // Offsets into used nodes for each way_list entry
+    WayNodeIDOffsets way_node_id_offsets;
 
     unsigned max_internal_node_id;
 
-    // list of restrictions before we transform them into the output types. Input containers
+    // List of restrictions (conditional and unconditional) before we transform them into the
-    // reference OSMNodeIDs. We can only transform them to the correct internal IDs after we've read
+    // output types. Input containers reference OSMNodeIDs. We can only transform them to the
-    // everything. Without a multi-parse approach, we have to remember the output restrictions
+    // correct internal IDs after we've read everything. Without a multi-parse approach,
-    // before converting them to the internal formats
+    // we have to remember the output restrictions before converting them to the internal formats
-    std::vector<InputConditionalTurnRestriction> restrictions_list;
+    std::vector<InputTurnRestriction> restrictions_list;
-
+    std::vector<TurnRestriction> turn_restrictions;
-    // turn restrictions split into conditional and unconditional turn restrictions
-    std::vector<ConditionalTurnRestriction> conditional_turn_restrictions;
-    std::vector<TurnRestriction> unconditional_turn_restrictions;
 
     std::vector<InputManeuverOverride> external_maneuver_overrides_list;
     std::vector<UnresolvedManeuverOverride> internal_maneuver_overrides;
@@ -73,7 +81,7 @@ class ExtractionContainers
                      const std::string &osrm_path,
                      const std::string &names_data_path);
 };
-}
+} // namespace extractor
-}
+} // namespace osrm
 
 #endif /* EXTRACTION_CONTAINERS_HPP */

include/extractor/extraction_helper_functions.hpp

@@ -82,7 +82,7 @@ template <typename Iterator> struct iso_8601_grammar : qi::grammar<Iterator, uns
     qi::uint_parser<unsigned, 10, 1, 2> uint_p;
     qi::uint_parser<unsigned, 10, 2, 2> uint2_p;
 };
-}
+} // namespace detail
 
 inline bool durationIsValid(const std::string &s)
 {
@@ -127,14 +127,16 @@ inline std::string canonicalizeStringList(std::string strlist, const std::string
 
     // collapse spaces; this is needed in case we expand "; X" => ";  X" above
     // but also makes sense to do irregardless of the fact - canonicalizing strings.
-    const auto spaces = [](auto lhs, auto rhs) { return ::isspace(lhs) && ::isspace(rhs); };
+    const auto spaces = [](unsigned char lhs, unsigned char rhs) {
+        return ::isspace(lhs) && ::isspace(rhs);
+    };
     auto it = std::unique(begin(strlist), end(strlist), spaces);
     strlist.erase(it, end(strlist));
 
     return strlist;
 }
 
-} // extractor
+} // namespace extractor
-} // osrm
+} // namespace osrm
 
 #endif // EXTRACTION_HELPER_FUNCTIONS_HPP

include/extractor/extraction_node.hpp

@@ -13,7 +13,7 @@ struct ExtractionNode
     bool traffic_lights;
     bool barrier;
 };
-}
+} // namespace extractor
-}
+} // namespace osrm
 
 #endif // EXTRACTION_NODE_HPP

include/extractor/extraction_segment.hpp

@@ -26,7 +26,7 @@ struct ExtractionSegment
     double weight;
     double duration;
 };
-}
+} // namespace extractor
-}
+} // namespace osrm
 
 #endif

include/extractor/extraction_turn.hpp

@@ -33,16 +33,16 @@ struct ExtractionTurnLeg
     {
     }
 
-    const bool is_restricted;
+    bool is_restricted;
-    const bool is_motorway;
+    bool is_motorway;
-    const bool is_link;
+    bool is_link;
-    const int number_of_lanes;
+    int number_of_lanes;
-    const int highway_turn_classification;
+    int highway_turn_classification;
-    const int access_turn_classification;
+    int access_turn_classification;
-    const int speed;
+    int speed;
-    const RoadPriorityClass::Enum priority_class;
+    RoadPriorityClass::Enum priority_class;
-    const bool is_incoming;
+    bool is_incoming;
-    const bool is_outgoing;
+    bool is_outgoing;
 };
 
 struct ExtractionTurn
@@ -130,7 +130,7 @@ struct ExtractionTurn
     double weight;
     double duration;
 };
-}
+} // namespace extractor
-}
+} // namespace osrm
 
 #endif

include/extractor/extraction_way.hpp

@@ -26,7 +26,7 @@ inline void maybeSetString(std::string &str, const char *value)
         str = std::string(value);
     }
 }
-}
+} // namespace detail
 
 /**
  * This struct is the direct result of the call to ```way_function```
@@ -130,7 +130,7 @@ struct ExtractionWay
     std::uint8_t highway_turn_classification : 4;
     std::uint8_t access_turn_classification : 4;
 };
-}
+} // namespace extractor
-}
+} // namespace osrm
 
 #endif // EXTRACTION_WAY_HPP

include/extractor/extractor.hpp

@@ -42,6 +42,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "util/guidance/entry_class.hpp"
 #include "util/guidance/turn_lanes.hpp"
 
+#include "restriction_graph.hpp"
 #include "util/typedefs.hpp"
 
 namespace osrm
@@ -63,7 +64,6 @@ class Extractor
 
     std::tuple<LaneDescriptionMap,
                std::vector<TurnRestriction>,
-               std::vector<ConditionalTurnRestriction>,
                std::vector<UnresolvedManeuverOverride>>
     ParseOSMData(ScriptingEnvironment &scripting_environment, const unsigned number_of_threads);
 
@@ -74,8 +74,7 @@ class Extractor
         const CompressedEdgeContainer &compressed_edge_container,
         const std::unordered_set<NodeID> &barrier_nodes,
         const std::unordered_set<NodeID> &traffic_lights,
-        const std::vector<TurnRestriction> &turn_restrictions,
+        const RestrictionGraph &restriction_graph,
-        const std::vector<ConditionalTurnRestriction> &conditional_turn_restrictions,
         const std::unordered_set<EdgeID> &segregated_edges,
         const NameTable &name_table,
         const std::vector<UnresolvedManeuverOverride> &maneuver_overrides,
@@ -97,25 +96,18 @@ class Extractor
                         EdgeBasedNodeDataContainer &nodes_container) const;
     void BuildRTree(std::vector<EdgeBasedNodeSegment> edge_based_node_segments,
                     const std::vector<util::Coordinate> &coordinates);
-    std::shared_ptr<RestrictionMap> LoadRestrictionMap();
 
-    void WriteConditionalRestrictions(
+    void ProcessGuidanceTurns(const util::NodeBasedDynamicGraph &node_based_graph,
-        const std::string &path,
-        std::vector<ConditionalTurnRestriction> &conditional_turn_restrictions);
-
-    void ProcessGuidanceTurns(
-        const util::NodeBasedDynamicGraph &node_based_graph,
                               const EdgeBasedNodeDataContainer &edge_based_node_container,
                               const std::vector<util::Coordinate> &node_coordinates,
                               const CompressedEdgeContainer &compressed_edge_container,
                               const std::unordered_set<NodeID> &barrier_nodes,
-        const std::vector<TurnRestriction> &turn_restrictions,
+                              const RestrictionGraph &restriction_graph,
-        const std::vector<ConditionalTurnRestriction> &conditional_turn_restrictions,
                               const NameTable &name_table,
                               LaneDescriptionMap lane_description_map,
                               ScriptingEnvironment &scripting_environment);
 };
-}
+} // namespace extractor
-}
+} // namespace osrm
 
 #endif /* EXTRACTOR_HPP */

include/extractor/extractor_callbacks.hpp

@@ -16,15 +16,15 @@ namespace osmium
 class Node;
 class Way;
 class Relation;
-}
+} // namespace osmium
 
 namespace std
 {
 template <> struct hash<std::tuple<std::string, std::string, std::string, std::string, std::string>>
 {
     std::size_t operator()(
-        const std::tuple<std::string, std::string, std::string, std::string, std::string> &mk) const
+        const std::tuple<std::string, std::string, std::string, std::string, std::string> &mk)
-        noexcept
+        const noexcept
     {
         std::size_t seed = 0;
         boost::hash_combine(seed, std::get<0>(mk));
@@ -35,7 +35,7 @@ template <> struct hash<std::tuple<std::string, std::string, std::string, std::s
         return seed;
     }
 };
-}
+} // namespace std
 
 namespace osrm
 {
@@ -47,7 +47,7 @@ struct ExtractionNode;
 struct ExtractionWay;
 struct ExtractionRelation;
 struct ProfileProperties;
-struct InputConditionalTurnRestriction;
+struct InputTurnRestriction;
 struct InputManeuverOverride;
 
 /**
@@ -87,7 +87,7 @@ class ExtractorCallbacks
     void ProcessNode(const osmium::Node &current_node, const ExtractionNode &result_node);
 
     // warning: caller needs to take care of synchronization!
-    void ProcessRestriction(const InputConditionalTurnRestriction &restriction);
+    void ProcessRestriction(const InputTurnRestriction &restriction);
 
     // warning: caller needs to take care of synchronization!
     void ProcessWay(const osmium::Way &current_way, const ExtractionWay &result_way);
@@ -95,7 +95,7 @@ class ExtractorCallbacks
     // warning: caller needs to take care of synchronization!
     void ProcessManeuverOverride(const InputManeuverOverride &override);
 };
-}
+} // namespace extractor
-}
+} // namespace osrm
 
 #endif /* EXTRACTOR_CALLBACKS_HPP */