Bump version to v5.10.0-rc.2

initial version of handling via-way turn restrictions (this is dirty)

 - requires update of data structures
 - requires clean-up
 - requires optimisation

.travis.yml

@@ -72,7 +72,7 @@ matrix:
       addons: &gcc6
         apt:
           sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-6', 'libbz2-dev', 'libstxxl-dev', 'libstxxl1', 'libxml2-dev', 'libzip-dev', 'lua5.1', 'liblua5.1-0-dev', 'libtbb-dev', 'libgdal-dev', 'libluabind-dev', 'libboost-all-dev']
+          packages: ['g++-6', 'libbz2-dev', 'libxml2-dev', 'libzip-dev', 'lua5.1', 'liblua5.1-0-dev', 'libtbb-dev', 'libgdal-dev', 'libboost-all-dev']
       env: CCOMPILER='gcc-6' CXXCOMPILER='g++-6' BUILD_TYPE='Debug' ENABLE_COVERAGE=ON CUCUMBER_TIMEOUT=20000
       after_success:
         - bash <(curl -s https://codecov.io/bash)
@@ -82,7 +82,7 @@ matrix:
       addons: &gcc6
         apt:
           sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-6', 'libbz2-dev', 'libstxxl-dev', 'libstxxl1', 'libxml2-dev', 'libzip-dev', 'lua5.1', 'liblua5.1-0-dev', 'libtbb-dev', 'libgdal-dev', 'libluabind-dev', 'libboost-all-dev']
+          packages: ['g++-6', 'libbz2-dev', 'libxml2-dev', 'libzip-dev', 'lua5.1', 'liblua5.1-0-dev', 'libtbb-dev', 'libgdal-dev', 'libboost-all-dev']
       env: CCOMPILER='gcc-6' CXXCOMPILER='g++-6' BUILD_TYPE='Debug' TARGET_ARCH='x86_64-asan' ENABLE_SANITIZER=ON CUCUMBER_TIMEOUT=20000
 
     - os: linux
@@ -90,7 +90,7 @@ matrix:
       addons: &clang40
         apt:
           sources: ['ubuntu-toolchain-r-test']
-          packages: ['libstdc++-5-dev', 'libbz2-dev', 'libstxxl-dev', 'libstxxl1', 'libxml2-dev', 'libzip-dev', 'lua5.1', 'liblua5.1-0-dev', 'libtbb-dev', 'libgdal-dev', 'libluabind-dev', 'libboost-all-dev']
+          packages: ['libstdc++-5-dev', 'libbz2-dev', 'libxml2-dev', 'libzip-dev', 'lua5.1', 'liblua5.1-0-dev', 'libtbb-dev', 'libgdal-dev', 'libboost-all-dev']
       env: CLANG_VERSION='4.0.0' BUILD_TYPE='Debug' CUCUMBER_TIMEOUT=60000
 
     - os: linux
@@ -115,7 +115,7 @@ matrix:
       addons: &gcc6
         apt:
           sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-6', 'libbz2-dev', 'libstxxl-dev', 'libstxxl1', 'libxml2-dev', 'libzip-dev', 'lua5.1', 'liblua5.1-0-dev', 'libtbb-dev', 'libgdal-dev', 'libluabind-dev', 'libboost-all-dev']
+          packages: ['g++-6', 'libbz2-dev', 'libxml2-dev', 'libzip-dev', 'lua5.1', 'liblua5.1-0-dev', 'libtbb-dev', 'libgdal-dev', 'libboost-all-dev']
       env: CCOMPILER='gcc-6' CXXCOMPILER='g++-6' BUILD_TYPE='Release'
 
     - os: linux
@@ -124,12 +124,20 @@ matrix:
         TARGET_ARCH='i686' CCOMPILER='gcc-6' CXXCOMPILER='g++-6' BUILD_TYPE='Release'
         CFLAGS='-m32 -msse2 -mfpmath=sse' CXXFLAGS='-m32 -msse2 -mfpmath=sse'
 
+    - os: linux
+      compiler: "gcc-6-stxxl"
+      addons: &gcc6
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-6', 'libbz2-dev', 'libstxxl-dev', 'libxml2-dev', 'libzip-dev', 'lua5.1', 'liblua5.1-0-dev', 'libtbb-dev', 'libgdal-dev', 'libboost-all-dev']
+      env: CCOMPILER='gcc-6' CXXCOMPILER='g++-6' BUILD_TYPE='Release' ENABLE_STXXL=On
+
     - os: linux
       compiler: "gcc-4.9-release"
       addons: &gcc49
         apt:
           sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-4.9', 'libbz2-dev', 'libstxxl-dev', 'libstxxl1', 'libxml2-dev', 'libzip-dev', 'lua5.1', 'liblua5.1-0-dev', 'libtbb-dev', 'libgdal-dev', 'libluabind-dev', 'libboost-all-dev', 'ccache']
+          packages: ['g++-4.9', 'libbz2-dev', 'libxml2-dev', 'libzip-dev', 'lua5.1', 'liblua5.1-0-dev', 'libtbb-dev', 'libgdal-dev', 'libluabind-dev', 'libboost-all-dev', 'ccache']
       env: CCOMPILER='gcc-4.9' CXXCOMPILER='g++-4.9' BUILD_TYPE='Release'
 
     - os: osx
@@ -146,7 +154,7 @@ matrix:
       #- addons: &clang40
       #-   apt:
       #-     sources: ['llvm-toolchain-trusty-4.0', 'ubuntu-toolchain-r-test']
-      #-     packages: ['clang-4.0', 'libbz2-dev', 'libstxxl-dev', 'libstxxl1', 'libxml2-dev', 'libzip-dev', 'lua5.1', 'liblua5.1-0-dev', 'libtbb-dev', 'libgdal-dev', 'libluabind-dev', 'libboost-all-dev']
+      #-     packages: ['clang-4.0', 'libbz2-dev', 'libxml2-dev', 'libzip-dev', 'lua5.1', 'liblua5.1-0-dev', 'libtbb-dev', 'libgdal-dev', 'libboost-all-dev']
       #- env: CCOMPILER='clang-4.0' CXXCOMPILER='clang++-4.0' BUILD_TYPE='Release'
 
     # Shared Library
@@ -155,7 +163,7 @@ matrix:
       addons: &gcc6
         apt:
           sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-6', 'libbz2-dev', 'libstxxl-dev', 'libstxxl1', 'libxml2-dev', 'libzip-dev', 'lua5.1', 'liblua5.1-0-dev', 'libtbb-dev', 'libgdal-dev', 'libluabind-dev', 'libboost-all-dev']
+          packages: ['g++-6', 'libbz2-dev', 'libxml2-dev', 'libzip-dev', 'lua5.1', 'liblua5.1-0-dev', 'libtbb-dev', 'libgdal-dev', 'libboost-all-dev']
       env: CCOMPILER='gcc-6' CXXCOMPILER='g++-6' BUILD_TYPE='Release' BUILD_SHARED_LIBS=ON
 
       # Disabled because CI slowness
@@ -164,7 +172,7 @@ matrix:
       #- addons: &clang40
       #-   apt:
       #-     sources: ['llvm-toolchain-trusty-4.0', 'ubuntu-toolchain-r-test']
-      #-     packages: ['clang-4.0', 'libbz2-dev', 'libstxxl-dev', 'libstxxl1', 'libxml2-dev', 'libzip-dev', 'lua5.1', 'liblua5.1-0-dev', 'libtbb-dev', 'libgdal-dev', 'libluabind-dev', 'libboost-all-dev']
+      #-     packages: ['clang-4.0', 'libbz2-dev', 'libxml2-dev', 'libzip-dev', 'lua5.1', 'liblua5.1-0-dev', 'libtbb-dev', 'libgdal-dev', 'libboost-all-dev']
       #- env: CCOMPILER='clang-4.0' CXXCOMPILER='clang++-4.0' BUILD_TYPE='Release' BUILD_SHARED_LIBS=ON
 
     # Node build jobs. These skip running the tests.
@@ -323,6 +331,7 @@ install:
              -DENABLE_COVERAGE=${ENABLE_COVERAGE:-OFF} \
              -DENABLE_NODE_BINDINGS=${ENABLE_NODE_BINDINGS:-OFF} \
              -DENABLE_SANITIZER=${ENABLE_SANITIZER:-OFF} \
+             -DENABLE_STXXL=${ENABLE_STXXL:-OFF} \
              -DBUILD_TOOLS=ON \
              -DENABLE_CCACHE=ON \
              -DCMAKE_INSTALL_PREFIX=${OSRM_INSTALL_DIR}

CHANGELOG.md

@@ -1,3 +1,35 @@
+# 5.10.0
+  - Changes from 5.9:
+    - Profiles:
+      - New version 2 profile API which cleans up a number of things and makes it easier to for profiles to include each other. Profiles using the old version 0 and 1 APIs are still supported.
+      - New required `setup()` function that must return a configuration hash. Storing configuration in globals is deprecated.
+      - Passes the config hash returned in `setup()` as an argument to `process_node/way/segment/turn`.
+      - Properties are now set in `.properties` in the config hash returend by setup().
+      - initialize raster sources in `setup()` instead of in a separate callback.
+      - Renames the `sources` helper to `raster`.
+      - Renames `way_functions` to `process_way` (same for node, segment and turn).
+      - Removes `get_restrictions()`. Instead set `.restrictions` in the config hash in `setup()`.
+      - Removes `get_name_suffix_list()`. Instead set `.suffix_list` in the config hash in `setup()`.
+      - Renames `Handlers` to `WayHandlers`.
+      - Pass functions instead of strings to `WayHandlers.run()`, so it's possible to mix in your own functions.
+      - Reorders arguments to `WayHandlers` functions to match `process_way()`.
+      - Profiles must return a hash of profile functions. This makes it easier for profiles to include each other.
+      - Guidance: add support for throughabouts
+    - Bugfixes
+      - Properly save/retrieve datasource annotations for road segments ([#4346](https://github.com/Project-OSRM/osrm-backend/issues/4346)
+      - Fix conditional restriction grammer parsing so it works for single-day-of-week restrictions ([#4357](https://github.com/Project-OSRM/osrm-backend/pull/4357))
+    - Algorithm)
+      - BREAKING: the file format requires re-processing due to the changes on via-ways
+      - Added support for via-way restrictions
+
+# 5.9.2
+    - API:
+      - `annotations=durations,weights,speeds` values no longer include turn penalty values ([#4330](https://github.com/Project-OSRM/osrm-backend/issues/4330))
+
+# 5.9.1
+    - Infrastructure
+      - STXXL is not required by default
+
 # 5.9.0
   - Changes from 5.8:
     - Algorithm:
@@ -7,15 +39,22 @@
     - API:
       - Exposes `alternatives=Number` parameter overload in addition to the boolean flag.
       - Support for exits numbers and names. New member `exits` in `RouteStep`, based on `junction:ref` on ways
-      - `RouteStep` now has new parameter `classes` that can be set in the profile on each way.
+      - `Intersection` now has new parameter `classes` that can be set in the profile on each way.
     - Profiles:
       - `result.exits` allows you to set a way's exit numbers and names, see [`junction:ref`](http://wiki.openstreetmap.org/wiki/Proposed_features/junction_details)
       - `ExtractionWay` now as new property `forward_classes` and `backward_classes` that can set in the `way_function`.
          The maximum number of classes is 8.
+      - We now respect the `construction` tag. If the `construction` tag value is not on our whitelist (`minor`, `widening`, `no`) we will exclude the road.
     - Node.js Bindings:
       - Exposes `alternatives=Number` parameter overload in addition to the boolean flag
+      - Expose `EngineConfig` options in the node bindings
     - Tools:
       - Exposes engine limit on number of alternatives to generate `--max-alternatives` in `osrm-routed` (3 by default)
+    - Infrastructure
+      - STXXL is not required to build OSRM and is an optional dependency for back-compatibility (ENABLE_STXXL=On)
+      - OpenMP is only required when the optional STXXL dependency is used
+    - Bug fixes:
+      - #4278: Remove superflous continious instruction on a motorway.
 
 # 5.8.0
   - Changes from 5.7

CMakeLists.txt

@@ -14,6 +14,11 @@ if(BUILD_AS_SUBPROJECT)
   message(STATUS "Building libosrm as subproject.")
 endif()
 
+# set OSRM_BUILD_DIR location (might be used in various scripts)
+if (NOT WIN32 AND NOT DEFINED ENV{OSRM_BUILD_DIR})
+  set(ENV{OSRM_BUILD_DIR} ${CMAKE_CURRENT_BINARY_DIR})
+endif()
+
 option(ENABLE_MASON "Use mason for dependencies" OFF)
 option(ENABLE_CCACHE "Speed up incremental rebuilds via ccache" ON)
 option(BUILD_TOOLS "Build OSRM tools" OFF)
@@ -21,6 +26,7 @@ option(BUILD_PACKAGE "Build OSRM package" OFF)
 option(ENABLE_ASSERTIONS "Use assertions in release mode" OFF)
 option(ENABLE_COVERAGE "Build with coverage instrumentalisation" OFF)
 option(ENABLE_SANITIZER "Use memory sanitizer for Debug build" OFF)
+option(ENABLE_STXXL "Use STXXL library" OFF)
 option(ENABLE_LTO "Use LTO if available" OFF)
 option(ENABLE_FUZZING "Fuzz testing using LLVM's libFuzzer" OFF)
 option(ENABLE_GOLD_LINKER "Use GNU gold linker if available" ON)
@@ -35,7 +41,7 @@ if(ENABLE_MASON)
   set(MASON_EXPAT_VERSION "2.2.0")
   set(MASON_LUA_VERSION "5.2.4")
   set(MASON_BZIP2_VERSION "1.0.6")
-  set(MASON_TBB_VERSION "2017_20161128")
+  set(MASON_TBB_VERSION "2017_U7")
   set(MASON_LIBSHP_VERSION "1.3.0")
 
   message(STATUS "Enabling mason")
@@ -54,7 +60,7 @@ if (POLICY CMP0048)
 endif()
 project(OSRM C CXX)
 set(OSRM_VERSION_MAJOR 5)
-set(OSRM_VERSION_MINOR 9)
+set(OSRM_VERSION_MINOR 10)
 set(OSRM_VERSION_PATCH 0)
 set(OSRM_VERSION "${OSRM_VERSION_MAJOR}.${OSRM_VERSION_MINOR}.${OSRM_VERSION_PATCH}")
 
@@ -428,9 +434,12 @@ if(ENABLE_MASON)
   mason_use(boost_libsystem VERSION ${MASON_BOOST_VERSION})
   set(Boost_SYSTEM_LIBRARY ${MASON_PACKAGE_boost_libsystem_STATIC_LIBS})
 
-  mason_use(stxxl VERSION ${MASON_STXXL_VERSION})
-  add_dependency_includes(${MASON_PACKAGE_stxxl_INCLUDE_DIRS})
-  set(STXXL_LIBRARY ${MASON_PACKAGE_stxxl_STATIC_LIBS})
+  if (ENABLE_STXXL)
+    mason_use(stxxl VERSION ${MASON_STXXL_VERSION})
+    add_dependency_includes(${MASON_PACKAGE_stxxl_INCLUDE_DIRS})
+    set(MAYBE_STXXL_LIBRARY ${MASON_PACKAGE_stxxl_STATIC_LIBS})
+    add_definitions(-DUSE_STXXL_LIBRARY)
+  endif()
 
   mason_use(expat VERSION ${MASON_EXPAT_VERSION})
   add_dependency_includes(${MASON_PACKAGE_expat_INCLUDE_DIRS})
@@ -493,8 +502,16 @@ else()
   find_package(EXPAT REQUIRED)
   add_dependency_includes(${EXPAT_INCLUDE_DIRS})
 
-  find_package(STXXL REQUIRED)
-  add_dependency_includes(${STXXL_INCLUDE_DIR})
+  if (ENABLE_STXXL)
+    find_package(STXXL)
+    if (STXXL_FOUND)
+      add_dependency_includes(${STXXL_INCLUDE_DIR})
+      set(MAYBE_STXXL_LIBRARY ${STXXL_LIBRARY})
+      add_definitions(-DUSE_STXXL_LIBRARY)
+    else()
+      MESSAGE(STATUS "STXXL was requested but not found, default STL will be used")
+    endif()
+  endif()
 
   find_package(BZip2 REQUIRED)
   add_dependency_includes(${BZIP2_INCLUDE_DIR})
@@ -578,11 +595,13 @@ add_dependency_defines(-DBOOST_SPIRIT_USE_PHOENIX_V3)
 add_dependency_defines(-DBOOST_RESULT_OF_USE_DECLTYPE)
 add_dependency_defines(-DBOOST_FILESYSTEM_NO_DEPRECATED)
 
-set(OpenMP_FIND_QUIETLY ON)
-find_package(OpenMP)
-if(OPENMP_FOUND)
-  message(STATUS "OpenMP support found. Linking just in case for stxxl")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
+if (ENABLE_STXXL)
+  set(OpenMP_FIND_QUIETLY ON)
+  find_package(OpenMP)
+  if(OPENMP_FOUND)
+    message(STATUS "OpenMP support found. Linking just in case for stxxl")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
+  endif()
 endif()
 
 add_definitions(${OSRM_DEFINES})
@@ -617,7 +636,7 @@ set(EXTRACTOR_LIBRARIES
     ${EXPAT_LIBRARIES}
     ${USED_LUA_LIBRARIES}
     ${OSMIUM_LIBRARIES}
-    ${STXXL_LIBRARY}
+    ${MAYBE_STXXL_LIBRARY}
     ${TBB_LIBRARIES}
     ${ZLIB_LIBRARY}
     ${MAYBE_COVERAGE_LIBRARIES})
@@ -645,7 +664,7 @@ set(CONTRACTOR_LIBRARIES
     ${BOOST_BASE_LIBRARIES}
     ${CMAKE_THREAD_LIBS_INIT}
     ${USED_LUA_LIBRARIES}
-    ${STXXL_LIBRARY}
+    ${MAYBE_STXXL_LIBRARY}
     ${TBB_LIBRARIES}
     ${MAYBE_RT_LIBRARY}
     ${MAYBE_COVERAGE_LIBRARIES})
@@ -665,7 +684,7 @@ set(STORAGE_LIBRARIES
 set(UTIL_LIBRARIES
     ${BOOST_BASE_LIBRARIES}
     ${CMAKE_THREAD_LIBS_INIT}
-    ${STXXL_LIBRARY}
+    ${MAYBE_STXXL_LIBRARY}
     ${TBB_LIBRARIES}
     ${MAYBE_COVERAGE_LIBRARIES})
 
@@ -719,10 +738,10 @@ file(GLOB LibraryGlob include/osrm/*.hpp)
 file(GLOB ParametersGlob include/engine/api/*_parameters.hpp)
 set(EngineHeader include/engine/status.hpp include/engine/engine_config.hpp include/engine/hint.hpp include/engine/bearing.hpp include/engine/approach.hpp include/engine/phantom_node.hpp)
 set(UtilHeader include/util/coordinate.hpp include/util/json_container.hpp include/util/typedefs.hpp include/util/alias.hpp include/util/exception.hpp)
-set(ExtractorHeader include/extractor/extractor.hpp include/extractor/extractor_config.hpp include/extractor/travel_mode.hpp)
+set(ExtractorHeader include/extractor/extractor.hpp include/storage/io_config.hpp include/extractor/extractor_config.hpp include/extractor/travel_mode.hpp)
 set(PartitionerHeader include/partition/partitioner.hpp include/partition/partition_config.hpp)
 set(ContractorHeader include/contractor/contractor.hpp include/contractor/contractor_config.hpp)
-set(StorageHeader include/storage/storage.hpp include/storage/storage_config.hpp)
+set(StorageHeader include/storage/storage.hpp include/storage/io_config.hpp include/storage/storage_config.hpp)
 install(FILES ${EngineHeader} DESTINATION include/osrm/engine)
 install(FILES ${UtilHeader} DESTINATION include/osrm/util)
 install(FILES ${StorageHeader} DESTINATION include/osrm/storage)
@@ -734,12 +753,14 @@ install(FILES ${ParametersGlob} DESTINATION include/osrm/engine/api)
 install(FILES ${VariantGlob} DESTINATION include/mapbox)
 install(TARGETS osrm-extract DESTINATION bin)
 install(TARGETS osrm-partition DESTINATION bin)
+install(TARGETS osrm-customize DESTINATION bin)
 install(TARGETS osrm-contract DESTINATION bin)
 install(TARGETS osrm-datastore DESTINATION bin)
 install(TARGETS osrm-routed DESTINATION bin)
 install(TARGETS osrm DESTINATION lib)
 install(TARGETS osrm_extract DESTINATION lib)
 install(TARGETS osrm_partition DESTINATION lib)
+install(TARGETS osrm_customize DESTINATION lib)
 install(TARGETS osrm_update DESTINATION lib)
 install(TARGETS osrm_contract DESTINATION lib)
 install(TARGETS osrm_store DESTINATION lib)

cmake/FindTBB.cmake

@@ -1,286 +1,286 @@
-# Locate Intel Threading Building Blocks include paths and libraries
-# FindTBB.cmake can be found at https://code.google.com/p/findtbb/
-# Written by Hannes Hofmann <hannes.hofmann _at_ informatik.uni-erlangen.de>
-# Improvements by Gino van den Bergen <gino _at_ dtecta.com>,
-#   Florian Uhlig <F.Uhlig _at_ gsi.de>,
-#   Jiri Marsik <jiri.marsik89 _at_ gmail.com>
-
-# The MIT License
-#
-# Copyright (c) 2011 Hannes Hofmann
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-
-# GvdB: This module uses the environment variable TBB_ARCH_PLATFORM which defines architecture and compiler.
-#   e.g. "ia32/vc8" or "em64t/cc4.1.0_libc2.4_kernel2.6.16.21"
-#   TBB_ARCH_PLATFORM is set by the build script tbbvars[.bat|.sh|.csh], which can be found
-#   in the TBB installation directory (TBB_INSTALL_DIR).
-#
-# GvdB: Mac OS X distribution places libraries directly in lib directory.
-#
-# For backwards compatibility, you may explicitely set the CMake variables TBB_ARCHITECTURE and TBB_COMPILER.
-# TBB_ARCHITECTURE [ ia32 | em64t | itanium ]
-#   which architecture to use
-# TBB_COMPILER e.g. vc9 or cc3.2.3_libc2.3.2_kernel2.4.21 or cc4.0.1_os10.4.9
-#   which compiler to use (detected automatically on Windows)
-
-# This module respects
-# TBB_INSTALL_DIR or $ENV{TBB21_INSTALL_DIR} or $ENV{TBB_INSTALL_DIR}
-
-# This module defines
-# TBB_INCLUDE_DIRS, where to find task_scheduler_init.h, etc.
-# TBB_LIBRARY_DIRS, where to find libtbb, libtbbmalloc
-# TBB_DEBUG_LIBRARY_DIRS, where to find libtbb_debug, libtbbmalloc_debug
-# TBB_INSTALL_DIR, the base TBB install directory
-# TBB_LIBRARIES, the libraries to link against to use TBB.
-# TBB_DEBUG_LIBRARIES, the libraries to link against to use TBB with debug symbols.
-# TBB_FOUND, If false, don't try to use TBB.
-# TBB_INTERFACE_VERSION, as defined in tbb/tbb_stddef.h
-
-
-if (WIN32)
-    # has em64t/vc8 em64t/vc9
-    # has ia32/vc7.1 ia32/vc8 ia32/vc9
-    set(_TBB_DEFAULT_INSTALL_DIR "C:/Program Files/Intel/TBB")
-    set(_TBB_LIB_NAME "tbb")
-    set(_TBB_LIB_MALLOC_NAME "${_TBB_LIB_NAME}malloc")
-    set(_TBB_LIB_DEBUG_NAME "${_TBB_LIB_NAME}_debug")
-    set(_TBB_LIB_MALLOC_DEBUG_NAME "${_TBB_LIB_MALLOC_NAME}_debug")
-    if (MSVC71)
-        set (_TBB_COMPILER "vc7.1")
-    endif(MSVC71)
-    if (MSVC80)
-        set(_TBB_COMPILER "vc8")
-    endif(MSVC80)
-    if (MSVC90)
-        set(_TBB_COMPILER "vc9")
-    endif(MSVC90)
-    if(MSVC10)
-        set(_TBB_COMPILER "vc10")
-    endif(MSVC10)
-    # Todo: add other Windows compilers such as ICL.
-    set(_TBB_ARCHITECTURE ${TBB_ARCHITECTURE})
-endif (WIN32)
-
-if (UNIX)
-    if (APPLE)
-        # MAC
-        set(_TBB_DEFAULT_INSTALL_DIR "/Library/Frameworks/Intel_TBB.framework/Versions")
-        # libs: libtbb.dylib, libtbbmalloc.dylib, *_debug
-        set(_TBB_LIB_NAME "tbb")
-        set(_TBB_LIB_MALLOC_NAME "${_TBB_LIB_NAME}malloc")
-        set(_TBB_LIB_DEBUG_NAME "${_TBB_LIB_NAME}_debug")
-        set(_TBB_LIB_MALLOC_DEBUG_NAME "${_TBB_LIB_MALLOC_NAME}_debug")
-        # default flavor on apple: ia32/cc4.0.1_os10.4.9
-        # Jiri: There is no reason to presume there is only one flavor and
-        #       that user's setting of variables should be ignored.
-        if(NOT TBB_COMPILER)
-            set(_TBB_COMPILER "cc4.0.1_os10.4.9")
-        elseif (NOT TBB_COMPILER)
-            set(_TBB_COMPILER ${TBB_COMPILER})
-        endif(NOT TBB_COMPILER)
-        if(NOT TBB_ARCHITECTURE)
-            set(_TBB_ARCHITECTURE "ia32")
-        elseif(NOT TBB_ARCHITECTURE)
-            set(_TBB_ARCHITECTURE ${TBB_ARCHITECTURE})
-        endif(NOT TBB_ARCHITECTURE)
-    else (APPLE)
-        # LINUX
-        set(_TBB_DEFAULT_INSTALL_DIR "/usr")
-        set(_TBB_LIB_NAME "tbb")
-        set(_TBB_LIB_MALLOC_NAME "${_TBB_LIB_NAME}malloc")
-        set(_TBB_LIB_DEBUG_NAME "${_TBB_LIB_NAME}_debug")
-        set(_TBB_LIB_MALLOC_DEBUG_NAME "${_TBB_LIB_MALLOC_NAME}_debug")
-        # has em64t/cc3.2.3_libc2.3.2_kernel2.4.21 em64t/cc3.3.3_libc2.3.3_kernel2.6.5 em64t/cc3.4.3_libc2.3.4_kernel2.6.9 em64t/cc4.1.0_libc2.4_kernel2.6.16.21
-        # has ia32/*
-        # has itanium/*
-        set(_TBB_COMPILER ${TBB_COMPILER})
-        set(_TBB_ARCHITECTURE ${TBB_ARCHITECTURE})
-    endif (APPLE)
-endif (UNIX)
-
-if (CMAKE_SYSTEM MATCHES "SunOS.*")
-# SUN
-# not yet supported
-# has em64t/cc3.4.3_kernel5.10
-# has ia32/*
-endif (CMAKE_SYSTEM MATCHES "SunOS.*")
-
-
-#-- Clear the public variables
-set (TBB_FOUND "NO")
-
-
-#-- Find TBB install dir and set ${_TBB_INSTALL_DIR} and cached ${TBB_INSTALL_DIR}
-# first: use CMake variable TBB_INSTALL_DIR
-if (TBB_INSTALL_DIR)
-    set (_TBB_INSTALL_DIR ${TBB_INSTALL_DIR})
-endif (TBB_INSTALL_DIR)
-# second: use environment variable
-if (NOT _TBB_INSTALL_DIR)
-    if (NOT "$ENV{TBB_INSTALL_DIR}" STREQUAL "")
-        set (_TBB_INSTALL_DIR $ENV{TBB_INSTALL_DIR})
-    endif (NOT "$ENV{TBB_INSTALL_DIR}" STREQUAL "")
-    # Intel recommends setting TBB21_INSTALL_DIR
-    if (NOT "$ENV{TBB21_INSTALL_DIR}" STREQUAL "")
-        set (_TBB_INSTALL_DIR $ENV{TBB21_INSTALL_DIR})
-    endif (NOT "$ENV{TBB21_INSTALL_DIR}" STREQUAL "")
-    if (NOT "$ENV{TBB22_INSTALL_DIR}" STREQUAL "")
-        set (_TBB_INSTALL_DIR $ENV{TBB22_INSTALL_DIR})
-    endif (NOT "$ENV{TBB22_INSTALL_DIR}" STREQUAL "")
-    if (NOT "$ENV{TBB30_INSTALL_DIR}" STREQUAL "")
-        set (_TBB_INSTALL_DIR $ENV{TBB30_INSTALL_DIR})
-    endif (NOT "$ENV{TBB30_INSTALL_DIR}" STREQUAL "")
-endif (NOT _TBB_INSTALL_DIR)
-# third: try to find path automatically
-if (NOT _TBB_INSTALL_DIR)
-    if (_TBB_DEFAULT_INSTALL_DIR)
-        set (_TBB_INSTALL_DIR ${_TBB_DEFAULT_INSTALL_DIR})
-    endif (_TBB_DEFAULT_INSTALL_DIR)
-endif (NOT _TBB_INSTALL_DIR)
-# sanity check
-if (NOT _TBB_INSTALL_DIR)
-    message ("ERROR: Unable to find Intel TBB install directory. ${_TBB_INSTALL_DIR}")
-else (NOT _TBB_INSTALL_DIR)
-# finally: set the cached CMake variable TBB_INSTALL_DIR
-if (NOT TBB_INSTALL_DIR)
-    set (TBB_INSTALL_DIR ${_TBB_INSTALL_DIR} CACHE PATH "Intel TBB install directory")
-    mark_as_advanced(TBB_INSTALL_DIR)
-endif (NOT TBB_INSTALL_DIR)
-
-
-#-- A macro to rewrite the paths of the library. This is necessary, because
-#   find_library() always found the em64t/vc9 version of the TBB libs
-macro(TBB_CORRECT_LIB_DIR var_name)
-#    if (NOT "${_TBB_ARCHITECTURE}" STREQUAL "em64t")
-        string(REPLACE em64t "${_TBB_ARCHITECTURE}" ${var_name} ${${var_name}})
-#    endif (NOT "${_TBB_ARCHITECTURE}" STREQUAL "em64t")
-    string(REPLACE ia32 "${_TBB_ARCHITECTURE}" ${var_name} ${${var_name}})
-    string(REPLACE vc7.1 "${_TBB_COMPILER}" ${var_name} ${${var_name}})
-    string(REPLACE vc8 "${_TBB_COMPILER}" ${var_name} ${${var_name}})
-    string(REPLACE vc9 "${_TBB_COMPILER}" ${var_name} ${${var_name}})
-    string(REPLACE vc10 "${_TBB_COMPILER}" ${var_name} ${${var_name}})
-endmacro(TBB_CORRECT_LIB_DIR var_content)
-
-
-#-- Look for include directory and set ${TBB_INCLUDE_DIR}
-set (TBB_INC_SEARCH_DIR ${_TBB_INSTALL_DIR}/include)
-# Jiri: tbbvars now sets the CPATH environment variable to the directory
-#       containing the headers.
-find_path(TBB_INCLUDE_DIR
-    tbb/task_scheduler_init.h
-    HINTS ${TBB_INC_SEARCH_DIR} ENV CPATH
-)
-mark_as_advanced(TBB_INCLUDE_DIR)
-
-#-- Look for libraries
-# GvdB: $ENV{TBB_ARCH_PLATFORM} is set by the build script tbbvars[.bat|.sh|.csh]
-if (NOT $ENV{TBB_ARCH_PLATFORM} STREQUAL "")
-    set (_TBB_LIBRARY_DIR
-         ${_TBB_INSTALL_DIR}/lib/$ENV{TBB_ARCH_PLATFORM}
-         ${_TBB_INSTALL_DIR}/$ENV{TBB_ARCH_PLATFORM}/lib
-        )
-endif (NOT $ENV{TBB_ARCH_PLATFORM} STREQUAL "")
-# Jiri: This block isn't mutually exclusive with the previous one
-#       (hence no else), instead I test if the user really specified
-#       the variables in question.
-if ((NOT ${TBB_ARCHITECTURE} STREQUAL "") AND (NOT ${TBB_COMPILER} STREQUAL ""))
-    # HH: deprecated
-    message(STATUS "[Warning] FindTBB.cmake: The use of TBB_ARCHITECTURE and TBB_COMPILER is deprecated and may not be supported in future versions. Please set \$ENV{TBB_ARCH_PLATFORM} (using tbbvars.[bat|csh|sh]).")
-    # Jiri: It doesn't hurt to look in more places, so I store the hints from
-    #       ENV{TBB_ARCH_PLATFORM} and the TBB_ARCHITECTURE and TBB_COMPILER
-    #       variables and search them both.
-    set (_TBB_LIBRARY_DIR "${_TBB_INSTALL_DIR}/${_TBB_ARCHITECTURE}/${_TBB_COMPILER}/lib" ${_TBB_LIBRARY_DIR})
-endif ((NOT ${TBB_ARCHITECTURE} STREQUAL "") AND (NOT ${TBB_COMPILER} STREQUAL ""))
-
-# GvdB: Mac OS X distribution places libraries directly in lib directory.
-list(APPEND _TBB_LIBRARY_DIR ${_TBB_INSTALL_DIR}/lib)
-
-if(EXISTS ${_TBB_INSTALL_DIR}/build)
-  file(GLOB _TBB_BUILD_DIR_RELEASE ${_TBB_INSTALL_DIR}/build/*_release)
-  file(GLOB _TBB_BUILD_DIR_DEBUG ${_TBB_INSTALL_DIR}/build/*_debug)
-endif()
-
-# Jiri: No reason not to check the default paths. From recent versions,
-#       tbbvars has started exporting the LIBRARY_PATH and LD_LIBRARY_PATH
-#       variables, which now point to the directories of the lib files.
-#       It all makes more sense to use the ${_TBB_LIBRARY_DIR} as a HINTS
-#       argument instead of the implicit PATHS as it isn't hard-coded
-#       but computed by system introspection. Searching the LIBRARY_PATH
-#       and LD_LIBRARY_PATH environment variables is now even more important
-#       that tbbvars doesn't export TBB_ARCH_PLATFORM and it facilitates
-#       the use of TBB built from sources.
-find_library(TBB_LIBRARY ${_TBB_LIB_NAME} HINTS ${_TBB_BUILD_DIR_RELEASE} ${_TBB_LIBRARY_DIR})
-find_library(TBB_MALLOC_LIBRARY ${_TBB_LIB_MALLOC_NAME} HINTS ${_TBB_BUILD_DIR_RELEASE} ${_TBB_LIBRARY_DIR})
-
-#Extract path from TBB_LIBRARY name
-get_filename_component(TBB_LIBRARY_DIR ${TBB_LIBRARY} PATH)
-
-#TBB_CORRECT_LIB_DIR(TBB_LIBRARY)
-#TBB_CORRECT_LIB_DIR(TBB_MALLOC_LIBRARY)
-mark_as_advanced(TBB_LIBRARY TBB_MALLOC_LIBRARY)
-
-#-- Look for debug libraries
-# Jiri: Changed the same way as for the release libraries.
-find_library(TBB_LIBRARY_DEBUG ${_TBB_LIB_DEBUG_NAME} HINTS ${_TBB_BUILD_DIR_DEBUG} ${_TBB_LIBRARY_DIR}
-        PATHS ENV LIBRARY_PATH ENV LD_LIBRARY_PATH)
-find_library(TBB_MALLOC_LIBRARY_DEBUG ${_TBB_LIB_MALLOC_DEBUG_NAME} HINTS ${_TBB_BUILD_DIR_DEBUG} ${_TBB_LIBRARY_DIR}
-        PATHS ENV LIBRARY_PATH ENV LD_LIBRARY_PATH)
-
-# Jiri: Self-built TBB stores the debug libraries in a separate directory.
-#       Extract path from TBB_LIBRARY_DEBUG name
-get_filename_component(TBB_LIBRARY_DEBUG_DIR ${TBB_LIBRARY_DEBUG} PATH)
-
-#TBB_CORRECT_LIB_DIR(TBB_LIBRARY_DEBUG)
-#TBB_CORRECT_LIB_DIR(TBB_MALLOC_LIBRARY_DEBUG)
-mark_as_advanced(TBB_LIBRARY_DEBUG TBB_MALLOC_LIBRARY_DEBUG)
-
-
-if (TBB_INCLUDE_DIR)
-    if (TBB_LIBRARY)
-        set (TBB_FOUND "YES")
-        set (TBB_LIBRARIES ${TBB_LIBRARY} ${TBB_MALLOC_LIBRARY} ${TBB_LIBRARIES})
-        set (TBB_DEBUG_LIBRARIES ${TBB_LIBRARY_DEBUG} ${TBB_MALLOC_LIBRARY_DEBUG} ${TBB_DEBUG_LIBRARIES})
-        set (TBB_INCLUDE_DIRS ${TBB_INCLUDE_DIR} CACHE PATH "TBB include directory" FORCE)
-        set (TBB_LIBRARY_DIRS ${TBB_LIBRARY_DIR} CACHE PATH "TBB library directory" FORCE)
-        # Jiri: Self-built TBB stores the debug libraries in a separate directory.
-        set (TBB_DEBUG_LIBRARY_DIRS ${TBB_LIBRARY_DEBUG_DIR} CACHE PATH "TBB debug library directory" FORCE)
-        mark_as_advanced(TBB_INCLUDE_DIRS TBB_LIBRARY_DIRS TBB_DEBUG_LIBRARY_DIRS TBB_LIBRARIES TBB_DEBUG_LIBRARIES)
-        message(STATUS "Found Intel TBB")
-    endif (TBB_LIBRARY)
-endif (TBB_INCLUDE_DIR)
-
-if (NOT TBB_FOUND)
-    message("ERROR: Intel TBB NOT found!")
-    message(STATUS "Looked for Threading Building Blocks in ${_TBB_INSTALL_DIR}")
-    # do only throw fatal, if this pkg is REQUIRED
-    if (TBB_FIND_REQUIRED)
-        message(FATAL_ERROR "Could NOT find TBB library.")
-    endif (TBB_FIND_REQUIRED)
-endif (NOT TBB_FOUND)
-
-endif (NOT _TBB_INSTALL_DIR)
-
-if (TBB_FOUND)
-	set(TBB_INTERFACE_VERSION 0)
-	FILE(READ "${TBB_INCLUDE_DIRS}/tbb/tbb_stddef.h" _TBB_VERSION_CONTENTS)
-	STRING(REGEX REPLACE ".*#define TBB_INTERFACE_VERSION ([0-9]+).*" "\\1" TBB_INTERFACE_VERSION "${_TBB_VERSION_CONTENTS}")
-	set(TBB_INTERFACE_VERSION "${TBB_INTERFACE_VERSION}")
-        message(STATUS "TBB interface version: ${TBB_INTERFACE_VERSION}")
-endif (TBB_FOUND)
+# Locate Intel Threading Building Blocks include paths and libraries
+# FindTBB.cmake can be found at https://code.google.com/p/findtbb/
+# Written by Hannes Hofmann <hannes.hofmann _at_ informatik.uni-erlangen.de>
+# Improvements by Gino van den Bergen <gino _at_ dtecta.com>,
+#   Florian Uhlig <F.Uhlig _at_ gsi.de>,
+#   Jiri Marsik <jiri.marsik89 _at_ gmail.com>
+
+# The MIT License
+#
+# Copyright (c) 2011 Hannes Hofmann
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+# GvdB: This module uses the environment variable TBB_ARCH_PLATFORM which defines architecture and compiler.
+#   e.g. "ia32/vc8" or "em64t/cc4.1.0_libc2.4_kernel2.6.16.21"
+#   TBB_ARCH_PLATFORM is set by the build script tbbvars[.bat|.sh|.csh], which can be found
+#   in the TBB installation directory (TBB_INSTALL_DIR).
+#
+# GvdB: Mac OS X distribution places libraries directly in lib directory.
+#
+# For backwards compatibility, you may explicitely set the CMake variables TBB_ARCHITECTURE and TBB_COMPILER.
+# TBB_ARCHITECTURE [ ia32 | em64t | itanium ]
+#   which architecture to use
+# TBB_COMPILER e.g. vc9 or cc3.2.3_libc2.3.2_kernel2.4.21 or cc4.0.1_os10.4.9
+#   which compiler to use (detected automatically on Windows)
+
+# This module respects
+# TBB_INSTALL_DIR or $ENV{TBB21_INSTALL_DIR} or $ENV{TBB_INSTALL_DIR}
+
+# This module defines
+# TBB_INCLUDE_DIRS, where to find task_scheduler_init.h, etc.
+# TBB_LIBRARY_DIRS, where to find libtbb, libtbbmalloc
+# TBB_DEBUG_LIBRARY_DIRS, where to find libtbb_debug, libtbbmalloc_debug
+# TBB_INSTALL_DIR, the base TBB install directory
+# TBB_LIBRARIES, the libraries to link against to use TBB.
+# TBB_DEBUG_LIBRARIES, the libraries to link against to use TBB with debug symbols.
+# TBB_FOUND, If false, don't try to use TBB.
+# TBB_INTERFACE_VERSION, as defined in tbb/tbb_stddef.h
+
+
+if (WIN32)
+    # has em64t/vc8 em64t/vc9
+    # has ia32/vc7.1 ia32/vc8 ia32/vc9
+    set(_TBB_DEFAULT_INSTALL_DIR "C:/Program Files/Intel/TBB")
+    set(_TBB_LIB_NAME "tbb")
+    set(_TBB_LIB_MALLOC_NAME "${_TBB_LIB_NAME}malloc")
+    set(_TBB_LIB_DEBUG_NAME "${_TBB_LIB_NAME}_debug")
+    set(_TBB_LIB_MALLOC_DEBUG_NAME "${_TBB_LIB_MALLOC_NAME}_debug")
+    if (MSVC71)
+        set (_TBB_COMPILER "vc7.1")
+    endif(MSVC71)
+    if (MSVC80)
+        set(_TBB_COMPILER "vc8")
+    endif(MSVC80)
+    if (MSVC90)
+        set(_TBB_COMPILER "vc9")
+    endif(MSVC90)
+    if(MSVC10)
+        set(_TBB_COMPILER "vc10")
+    endif(MSVC10)
+    # Todo: add other Windows compilers such as ICL.
+    set(_TBB_ARCHITECTURE ${TBB_ARCHITECTURE})
+endif (WIN32)
+
+if (UNIX)
+    if (APPLE)
+        # MAC
+        set(_TBB_DEFAULT_INSTALL_DIR "/Library/Frameworks/Intel_TBB.framework/Versions")
+        # libs: libtbb.dylib, libtbbmalloc.dylib, *_debug
+        set(_TBB_LIB_NAME "tbb")
+        set(_TBB_LIB_MALLOC_NAME "${_TBB_LIB_NAME}malloc")
+        set(_TBB_LIB_DEBUG_NAME "${_TBB_LIB_NAME}_debug")
+        set(_TBB_LIB_MALLOC_DEBUG_NAME "${_TBB_LIB_MALLOC_NAME}_debug")
+        # default flavor on apple: ia32/cc4.0.1_os10.4.9
+        # Jiri: There is no reason to presume there is only one flavor and
+        #       that user's setting of variables should be ignored.
+        if(NOT TBB_COMPILER)
+            set(_TBB_COMPILER "cc4.0.1_os10.4.9")
+        elseif (NOT TBB_COMPILER)
+            set(_TBB_COMPILER ${TBB_COMPILER})
+        endif(NOT TBB_COMPILER)
+        if(NOT TBB_ARCHITECTURE)
+            set(_TBB_ARCHITECTURE "ia32")
+        elseif(NOT TBB_ARCHITECTURE)
+            set(_TBB_ARCHITECTURE ${TBB_ARCHITECTURE})
+        endif(NOT TBB_ARCHITECTURE)
+    else (APPLE)
+        # LINUX
+        set(_TBB_DEFAULT_INSTALL_DIR "/usr")
+        set(_TBB_LIB_NAME "tbb")
+        set(_TBB_LIB_MALLOC_NAME "${_TBB_LIB_NAME}malloc")
+        set(_TBB_LIB_DEBUG_NAME "${_TBB_LIB_NAME}_debug")
+        set(_TBB_LIB_MALLOC_DEBUG_NAME "${_TBB_LIB_MALLOC_NAME}_debug")
+        # has em64t/cc3.2.3_libc2.3.2_kernel2.4.21 em64t/cc3.3.3_libc2.3.3_kernel2.6.5 em64t/cc3.4.3_libc2.3.4_kernel2.6.9 em64t/cc4.1.0_libc2.4_kernel2.6.16.21
+        # has ia32/*
+        # has itanium/*
+        set(_TBB_COMPILER ${TBB_COMPILER})
+        set(_TBB_ARCHITECTURE ${TBB_ARCHITECTURE})
+    endif (APPLE)
+endif (UNIX)
+
+if (CMAKE_SYSTEM MATCHES "SunOS.*")
+# SUN
+# not yet supported
+# has em64t/cc3.4.3_kernel5.10
+# has ia32/*
+endif (CMAKE_SYSTEM MATCHES "SunOS.*")
+
+
+#-- Clear the public variables
+set (TBB_FOUND "NO")
+
+
+#-- Find TBB install dir and set ${_TBB_INSTALL_DIR} and cached ${TBB_INSTALL_DIR}
+# first: use CMake variable TBB_INSTALL_DIR
+if (TBB_INSTALL_DIR)
+    set (_TBB_INSTALL_DIR ${TBB_INSTALL_DIR})
+endif (TBB_INSTALL_DIR)
+# second: use environment variable
+if (NOT _TBB_INSTALL_DIR)
+    if (NOT "$ENV{TBB_INSTALL_DIR}" STREQUAL "")
+        set (_TBB_INSTALL_DIR $ENV{TBB_INSTALL_DIR})
+    endif (NOT "$ENV{TBB_INSTALL_DIR}" STREQUAL "")
+    # Intel recommends setting TBB21_INSTALL_DIR
+    if (NOT "$ENV{TBB21_INSTALL_DIR}" STREQUAL "")
+        set (_TBB_INSTALL_DIR $ENV{TBB21_INSTALL_DIR})
+    endif (NOT "$ENV{TBB21_INSTALL_DIR}" STREQUAL "")
+    if (NOT "$ENV{TBB22_INSTALL_DIR}" STREQUAL "")
+        set (_TBB_INSTALL_DIR $ENV{TBB22_INSTALL_DIR})
+    endif (NOT "$ENV{TBB22_INSTALL_DIR}" STREQUAL "")
+    if (NOT "$ENV{TBB30_INSTALL_DIR}" STREQUAL "")
+        set (_TBB_INSTALL_DIR $ENV{TBB30_INSTALL_DIR})
+    endif (NOT "$ENV{TBB30_INSTALL_DIR}" STREQUAL "")
+endif (NOT _TBB_INSTALL_DIR)
+# third: try to find path automatically
+if (NOT _TBB_INSTALL_DIR)
+    if (_TBB_DEFAULT_INSTALL_DIR)
+        set (_TBB_INSTALL_DIR ${_TBB_DEFAULT_INSTALL_DIR})
+    endif (_TBB_DEFAULT_INSTALL_DIR)
+endif (NOT _TBB_INSTALL_DIR)
+# sanity check
+if (NOT _TBB_INSTALL_DIR)
+    message ("ERROR: Unable to find Intel TBB install directory. ${_TBB_INSTALL_DIR}")
+else (NOT _TBB_INSTALL_DIR)
+# finally: set the cached CMake variable TBB_INSTALL_DIR
+if (NOT TBB_INSTALL_DIR)
+    set (TBB_INSTALL_DIR ${_TBB_INSTALL_DIR} CACHE PATH "Intel TBB install directory")
+    mark_as_advanced(TBB_INSTALL_DIR)
+endif (NOT TBB_INSTALL_DIR)
+
+
+#-- A macro to rewrite the paths of the library. This is necessary, because
+#   find_library() always found the em64t/vc9 version of the TBB libs
+macro(TBB_CORRECT_LIB_DIR var_name)
+#    if (NOT "${_TBB_ARCHITECTURE}" STREQUAL "em64t")
+        string(REPLACE em64t "${_TBB_ARCHITECTURE}" ${var_name} ${${var_name}})
+#    endif (NOT "${_TBB_ARCHITECTURE}" STREQUAL "em64t")
+    string(REPLACE ia32 "${_TBB_ARCHITECTURE}" ${var_name} ${${var_name}})
+    string(REPLACE vc7.1 "${_TBB_COMPILER}" ${var_name} ${${var_name}})
+    string(REPLACE vc8 "${_TBB_COMPILER}" ${var_name} ${${var_name}})
+    string(REPLACE vc9 "${_TBB_COMPILER}" ${var_name} ${${var_name}})
+    string(REPLACE vc10 "${_TBB_COMPILER}" ${var_name} ${${var_name}})
+endmacro(TBB_CORRECT_LIB_DIR var_content)
+
+
+#-- Look for include directory and set ${TBB_INCLUDE_DIR}
+set (TBB_INC_SEARCH_DIR ${_TBB_INSTALL_DIR}/include)
+# Jiri: tbbvars now sets the CPATH environment variable to the directory
+#       containing the headers.
+find_path(TBB_INCLUDE_DIR
+    tbb/task_scheduler_init.h
+    HINTS ${TBB_INC_SEARCH_DIR} ENV CPATH
+)
+mark_as_advanced(TBB_INCLUDE_DIR)
+
+#-- Look for libraries
+# GvdB: $ENV{TBB_ARCH_PLATFORM} is set by the build script tbbvars[.bat|.sh|.csh]
+if (NOT $ENV{TBB_ARCH_PLATFORM} STREQUAL "")
+    set (_TBB_LIBRARY_DIR
+         ${_TBB_INSTALL_DIR}/lib/$ENV{TBB_ARCH_PLATFORM}
+         ${_TBB_INSTALL_DIR}/$ENV{TBB_ARCH_PLATFORM}/lib
+        )
+endif (NOT $ENV{TBB_ARCH_PLATFORM} STREQUAL "")
+# Jiri: This block isn't mutually exclusive with the previous one
+#       (hence no else), instead I test if the user really specified
+#       the variables in question.
+if ((NOT ${TBB_ARCHITECTURE} STREQUAL "") AND (NOT ${TBB_COMPILER} STREQUAL ""))
+    # HH: deprecated
+    message(STATUS "[Warning] FindTBB.cmake: The use of TBB_ARCHITECTURE and TBB_COMPILER is deprecated and may not be supported in future versions. Please set \$ENV{TBB_ARCH_PLATFORM} (using tbbvars.[bat|csh|sh]).")
+    # Jiri: It doesn't hurt to look in more places, so I store the hints from
+    #       ENV{TBB_ARCH_PLATFORM} and the TBB_ARCHITECTURE and TBB_COMPILER
+    #       variables and search them both.
+    set (_TBB_LIBRARY_DIR "${_TBB_INSTALL_DIR}/${_TBB_ARCHITECTURE}/${_TBB_COMPILER}/lib" ${_TBB_LIBRARY_DIR})
+endif ((NOT ${TBB_ARCHITECTURE} STREQUAL "") AND (NOT ${TBB_COMPILER} STREQUAL ""))
+
+# GvdB: Mac OS X distribution places libraries directly in lib directory.
+list(APPEND _TBB_LIBRARY_DIR ${_TBB_INSTALL_DIR}/lib)
+
+if(EXISTS ${_TBB_INSTALL_DIR}/build)
+  file(GLOB _TBB_BUILD_DIR_RELEASE ${_TBB_INSTALL_DIR}/build/*_release)
+  file(GLOB _TBB_BUILD_DIR_DEBUG ${_TBB_INSTALL_DIR}/build/*_debug)
+endif()
+
+# Jiri: No reason not to check the default paths. From recent versions,
+#       tbbvars has started exporting the LIBRARY_PATH and LD_LIBRARY_PATH
+#       variables, which now point to the directories of the lib files.
+#       It all makes more sense to use the ${_TBB_LIBRARY_DIR} as a HINTS
+#       argument instead of the implicit PATHS as it isn't hard-coded
+#       but computed by system introspection. Searching the LIBRARY_PATH
+#       and LD_LIBRARY_PATH environment variables is now even more important
+#       that tbbvars doesn't export TBB_ARCH_PLATFORM and it facilitates
+#       the use of TBB built from sources.
+find_library(TBB_LIBRARY ${_TBB_LIB_NAME} HINTS ${_TBB_BUILD_DIR_RELEASE} ${_TBB_LIBRARY_DIR})
+find_library(TBB_MALLOC_LIBRARY ${_TBB_LIB_MALLOC_NAME} HINTS ${_TBB_BUILD_DIR_RELEASE} ${_TBB_LIBRARY_DIR})
+
+#Extract path from TBB_LIBRARY name
+get_filename_component(TBB_LIBRARY_DIR ${TBB_LIBRARY} PATH)
+
+#TBB_CORRECT_LIB_DIR(TBB_LIBRARY)
+#TBB_CORRECT_LIB_DIR(TBB_MALLOC_LIBRARY)
+mark_as_advanced(TBB_LIBRARY TBB_MALLOC_LIBRARY)
+
+#-- Look for debug libraries
+# Jiri: Changed the same way as for the release libraries.
+find_library(TBB_LIBRARY_DEBUG ${_TBB_LIB_DEBUG_NAME} HINTS ${_TBB_BUILD_DIR_DEBUG} ${_TBB_LIBRARY_DIR}
+        PATHS ENV LIBRARY_PATH ENV LD_LIBRARY_PATH)
+find_library(TBB_MALLOC_LIBRARY_DEBUG ${_TBB_LIB_MALLOC_DEBUG_NAME} HINTS ${_TBB_BUILD_DIR_DEBUG} ${_TBB_LIBRARY_DIR}
+        PATHS ENV LIBRARY_PATH ENV LD_LIBRARY_PATH)
+
+# Jiri: Self-built TBB stores the debug libraries in a separate directory.
+#       Extract path from TBB_LIBRARY_DEBUG name
+get_filename_component(TBB_LIBRARY_DEBUG_DIR ${TBB_LIBRARY_DEBUG} PATH)
+
+#TBB_CORRECT_LIB_DIR(TBB_LIBRARY_DEBUG)
+#TBB_CORRECT_LIB_DIR(TBB_MALLOC_LIBRARY_DEBUG)
+mark_as_advanced(TBB_LIBRARY_DEBUG TBB_MALLOC_LIBRARY_DEBUG)
+
+
+if (TBB_INCLUDE_DIR)
+    if (TBB_LIBRARY)
+        set (TBB_FOUND "YES")
+        set (TBB_LIBRARIES ${TBB_LIBRARY} ${TBB_MALLOC_LIBRARY} ${TBB_LIBRARIES})
+        set (TBB_DEBUG_LIBRARIES ${TBB_LIBRARY_DEBUG} ${TBB_MALLOC_LIBRARY_DEBUG} ${TBB_DEBUG_LIBRARIES})
+        set (TBB_INCLUDE_DIRS ${TBB_INCLUDE_DIR} CACHE PATH "TBB include directory" FORCE)
+        set (TBB_LIBRARY_DIRS ${TBB_LIBRARY_DIR} CACHE PATH "TBB library directory" FORCE)
+        # Jiri: Self-built TBB stores the debug libraries in a separate directory.
+        set (TBB_DEBUG_LIBRARY_DIRS ${TBB_LIBRARY_DEBUG_DIR} CACHE PATH "TBB debug library directory" FORCE)
+        mark_as_advanced(TBB_INCLUDE_DIRS TBB_LIBRARY_DIRS TBB_DEBUG_LIBRARY_DIRS TBB_LIBRARIES TBB_DEBUG_LIBRARIES)
+        message(STATUS "Found Intel TBB")
+    endif (TBB_LIBRARY)
+endif (TBB_INCLUDE_DIR)
+
+if (NOT TBB_FOUND)
+    message("ERROR: Intel TBB NOT found!")
+    message(STATUS "Looked for Threading Building Blocks in ${_TBB_INSTALL_DIR}")
+    # do only throw fatal, if this pkg is REQUIRED
+    if (TBB_FIND_REQUIRED)
+        message(FATAL_ERROR "Could NOT find TBB library.")
+    endif (TBB_FIND_REQUIRED)
+endif (NOT TBB_FOUND)
+
+endif (NOT _TBB_INSTALL_DIR)
+
+if (TBB_FOUND)
+	set(TBB_INTERFACE_VERSION 0)
+	FILE(READ "${TBB_INCLUDE_DIRS}/tbb/tbb_stddef.h" _TBB_VERSION_CONTENTS)
+	STRING(REGEX REPLACE ".*#define TBB_INTERFACE_VERSION ([0-9]+).*" "\\1" TBB_INTERFACE_VERSION "${_TBB_VERSION_CONTENTS}")
+	set(TBB_INTERFACE_VERSION "${TBB_INTERFACE_VERSION}")
+        message(STATUS "TBB interface version: ${TBB_INTERFACE_VERSION}")
+endif (TBB_FOUND)

docs/http.md

@@ -539,10 +539,10 @@ Annotation of the whole route leg with fine-grained information about each segme
 **Properties**
 
 - `distance`: The distance, in metres, between each pair of coordinates
-- `duration`: The duration between each pair of coordinates, in seconds
+- `duration`: The duration between each pair of coordinates, in seconds.  Does not include the duration of any turns.
 - `datasources`: The index of the datasource for the speed between each pair of coordinates. `0` is the default profile, other values are supplied via `--segment-speed-file` to `osrm-contract`
 - `nodes`: The OSM node ID for each coordinate along the route, excluding the first/last user-supplied coordinates
-- `weight`: The weights between each pair of coordinates
+- `weight`: The weights between each pair of coordinates.  Does not include any turn costs.
 - `speed`: Convenience field, calculation of `distance / duration` rounded to one decimal place
 
 #### Example
@@ -583,7 +583,6 @@ step.
 - `destinations`: The destinations of the way. Will be `undefined` if there are no destinations.
 - `exits`: The exit numbers or names of the way. Will be `undefined` if there are no exit numbers or names.
 - `mode`: A string signifying the mode of transportation.
-- `classes`: An array of strings signifying the classes of the road as specified in the profile.
 - `maneuver`: A `StepManeuver` object representing the maneuver.
 - `intersections`: A list of `Intersection` objects that are passed along the segment, the very first belonging to the StepManeuver
 - `rotary_name`: The name for the rotary. Optionally included, if the step is a rotary and a rotary name is available.
@@ -597,7 +596,6 @@ step.
    "mode" : "driving",
    "duration" : 15.6,
    "weight" : 15.6,
-   "classes": ["toll", "restricted"],
    "intersections" : [
       {  "bearings" : [ 10, 92, 184, 270 ],
          "lanes" : [
@@ -657,7 +655,7 @@ step.
 | `off ramp`       | take a ramp to exit a highway (direction given my `modifier`)  |
 | `fork`           | take the left/right side at a fork depending on `modifier`   |
 | `end of road`    | road ends in a T intersection turn in direction of `modifier`|
-| `use lane`       | going straight on a specific lane                            |
+| `use lane`       | **Deprecated** replaced by lanes on all intersection entries |
 | `continue`       | Turn in direction of `modifier` to stay on the same road     |
 | `roundabout`     | traverse roundabout, has additional property `exit` with NR if the roundabout is left. The modifier specifies the direction of entering the roundabout. |
 | `rotary`         | a traffic circle. While very similar to a larger version of a roundabout, it does not necessarily follow roundabout rules for right of way. It can offer `rotary_name` and/or `rotary_pronunciation` parameters (located in the RouteStep object) in addition to the `exit` parameter (located on the StepManeuver object).  |
@@ -735,6 +733,7 @@ location of the StepManeuver. Further intersections are listed for every cross-w
 
 - `location`: A `[longitude, latitude]` pair describing the location of the turn.
 - `bearings`: A list of bearing values (e.g. [0,90,180,270]) that are available at the intersection. The bearings describe all available roads at the intersection.  Values are between 0-359 (0=true north)
+- `classes`: An array of strings signifying the classes (as specified in the profile) of the road exiting the intersection.
 - `entry`: A list of entry flags, corresponding in a 1:1 relationship to the bearings. A value of `true` indicates that the respective road could be entered on a valid route.
   `false` indicates that the turn onto the respective road would violate a restriction.
 - `in`: index into bearings/entry array. Used to calculate the bearing just before the turn. Namely, the clockwise angle from true north to the
@@ -753,6 +752,7 @@ location of the StepManeuver. Further intersections are listed for every cross-w
     "out":2,
     "bearings":[60,150,240,330],
     "entry":["false","true","true","true"],
+    "classes": ["toll", "restricted"],
     "lanes":{
         "indications": ["left", "straight"],
         "valid": "false"

docs/nodejs/api.md

@@ -26,6 +26,12 @@ var osrm = new OSRM('network.osrm');
     -   `options.shared_memory` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Connects to the persistent shared memory datastore.
                This requires you to run `osrm-datastore` prior to creating an `OSRM` object.
     -   `options.path` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?** The path to the `.osrm` files. This is mutually exclusive with setting {options.shared_memory} to true.
+    -   `options.max_locations_trip` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Max. locations supported in trip query (default: unlimited).
+    -   `options.max_locations_viaroute` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Max. locations supported in viaroute query 9default: unlimited).
+    -   `options.max_locations_distance_table` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Max. locations supported in distance table query (default: unlimited).
+    -   `options.max_locations_map_matching` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Max. locations supported in map matching query (default: unlimited).
+    -   `options.max_results_nearest` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Max. results supported in nearest query (default: unlimited).
+    -   `options.max_alternatives` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Max. number of alternative routes supported (default: 3).
 
 ### route
 

docs/profiles.md

@@ -1,31 +1,97 @@
-OSRM supports "profiles". Configurations representing different routing behaviours for (typically) different transport modes. A profile describes whether or not we route along a particular type of way, or over a particular node in the OpenStreetMap data, and also how quickly we'll be travelling when we do. This feeds into the way the routing graph is created and thus influences the output routes.
+# OSRM profiles
+OSRM supports "profiles". Profiles representing routing behavior for different transport modes like car, bike and foot. You can also create profiles for variations like a fastest/shortest car profile or fastest/safest/greenest bicycles profile.
+
+ A profile describes whether or not it's possible to route along a particular type of way, whether we can pass a particular node, and  how quickly we'll be traveling when we do. This feeds into the way the routing graph is created and thus influences the output routes.
 
 ## Available profiles
+Out-of-the-box OSRM comes with profiles for car, bicycle and foot. You can easily modify these or create new ones if you like.
 
-Out-of-the-box OSRM comes with several different profiles, including car, bicycle and foot.
+Profiles have a 'lua' extension, and are places in 'profiles' directory.
 
-Profile configuration files have a 'lua' extension, and are found under the 'profiles' subdirectory.
-Alternatively commands will take a lua profile specified with an explicit -p param, for example:
+When running OSRM preprocessing commands you specify the profile with the --profile (or the shorthand -p) option, for example:
 
-`osrm-extract -p ../profiles/car.lua planet-latest.osm.pbf`
+`osrm-extract --profile ../profiles/car.lua planet-latest.osm.pbf`
 
-And then **you will need to extract and contract again** (A change to the profile will typically affect the extract step as well as the contract step. See [Processing Flow](https://github.com/Project-OSRM/osrm-backend/wiki/Processing-Flow))
+## Processing flow
+It's important to understand that profiles are used when preprocessing the OSM data, NOT at query time when routes are computed.
 
-## lua scripts?
+This means that after modifying a profile **you will need to extract, contract and reload the data again** and to see changes in the routing results. See [Processing Flow](https://github.com/Project-OSRM/osrm-backend/wiki/Processing-Flow) for more.
 
-Profiles are not just configuration files. They are scripts written in the "lua" scripting language ( http://www.lua.org )  The reason for this, is that OpenStreetMap data is not sufficiently straightforward, to simply define tag mappings. Lua scripting offers a powerful way of coping with the complexity of different node,way,relation,tag combinations found within OpenStreetMap data.
+## Profiles are written in LUA
+Profiles are not just configuration files. They are scripts written in the [LUA scripting language](http://www.lua.org). The reason for this is that OpenStreetMap data is complex, and it's not possible to simply define tag mappings. LUA scripting offers a powerful way to handle all the possible tag combinations found in OpenStreetMap nodes and ways.
 
-## Basic structure of a profile
+## Basic structure of profiles
+A profile will process every node and way in the OSM input data to determine what ways are routable in which direction, at what speed, etc.
 
-You can understand these lua scripts enough to make interesting modifications, without needing to get to grips with how they work completely.
+A profile will typically:
 
-Towards the top of the file, a profile (such as [car.lua](../profiles/car.lua)) will typically define various configurations as global variables. A lot of these are look-up hashes of one sort or another.
+- Define api version (required)
+- Require library files (optional)
+- Define setup function (required)
+- Define process functions (some are required)
+- Return functions table (required)
 
-As you scroll down the file you'll see local variables, and then local functions, and finally...
+A profile can also define various local functions it needs.
 
-`way_function` and `node_function` are the important functions which are called when extracting OpenStreetMap data with `osrm-extract`.
+Looking at [car.lua](../profiles/car.lua) as an example, at the top of the file the api version is defined and then required library files are included.
 
-The following global properties can be set in your profile:
+Then follows the `setup` functions, which is called once when the profile is loaded. It returns a big hash table of configurations, specifying things like what speed to use for different way types. The configurations are used later in the various processing functions. Many adjustments can be done just be modifying this configuration table.
+
+The setup function is also where you can do other setup, like loading elevation data source if you want to consider that when processing ways.
+
+Then comes the `process_node` and `process_way` functions, which are called for each OSM node and way when extracting OpenStreetMap data with `osrm-extract`.
+
+The `process_turn` function processes every possible turn in the network, and sets a penalty depending on the angle and turn of the movement.
+
+Profiles can also define a `process_segment` function to handle differences in speed along an OSM way, for example to handle elevation. As you can see, this is not currently used in the car profile.
+
+At the end of the file, a table if returned with references to the setup and processing functions the profile has defined.
+
+## Understanding speed, weight and rate 
+When computing a route from A to B there can be different measure of what is the best route. That's why there's a need for different profiles.
+
+Because speeds very on different types of roads, the shortest and the fastest route are typically different. But there are many other possible preferences. For example a user might prefer a bicycle route that follow parks or other green areas, even though both duration and distance are a bit longer.
+
+To handle this, OSRM doesn't simply choose the ways with the highest speed. Instead it uses the concept of `weight` and `rate`. The rate is an abstract measure that you can assign to  ways as you like to make some ways preferable to others. Routing will prefer ways with high rate.
+
+The weight of a way normally computed as length / rate. The weight can be thought of as the resistance or cost when passing the way. Routing will prefer ways with low weight.
+
+You can also set the weight of a way to a fixed value, In this case it's not calculated based on the length or rate, and the rate is ignored.
+
+You should set the speed to you best estimate of the actual speed that will be used on a particular way. This will result in the best estimated travel times.
+
+If you want to prefer certain ways due to other factors than the speed, adjust the rate accordingly. If you adjust the speed, the time time estimation will be skewed.
+
+If you set the same rate on all ways, the result will be shortest path routing.
+If you set rate = speed on all ways, the result will be fastest path routing.
+If you want to prioritize certain street, increase the rate on these.
+
+## Elements
+### api_version
+A profile should set api_version at the top of your profile. This is done to ensure that older profiles are still supported when the api changes. If api_version is not defined, 0 will be assumed. The current api version is 2.
+
+### Library files
+The folder [profiles/lib/](../profiles/lib/) contains LUA library files for handling many common processing tasks.
+
+File              | Notes
+------------------|------------------------------
+way_handlers.lua  | Functions for processing way tags
+tags.lua          | Functions for general parsing of OSM tags
+set.lua           | Defines the Set helper for handling sets of values
+sequence.lua      | Defines the Sequence helper for handling sequences of values
+access.lua        | Function for finding relevant access tags
+destination.lua   | Function for finding relevant destination tags
+destination.lua   | Function for determining maximum speed
+guidance.lua      | Function for processing guidance attributes
+
+They all return a table of functions when you use `require` to load them. You can either store this table and reference it's functions later, of if you need only a single you can store that directly.
+
+### setup()
+The `setup` function is called once when the profile is loaded and must return a table of configurations. It's also where you can do other global setup, like loading data sources that are used during processing.
+
+Note that processing of data is parallelized and several unconnected LUA interpreters will be running at the same time. The `setup` function will be called once for each. Each LUA iinterpreter will have it's own set of globals.
+
+The following global properties can be set under `properties` in the hash you return in the `setup` function: 
 
 Attribute                            | Type     | Notes
 -------------------------------------|----------|----------------------------------------------------------------------------
@@ -36,17 +102,40 @@ use_turn_restrictions                | Boolean  | Are turn instructions followed
 continue_straight_at_waypoint        | Boolean  | Must the route continue straight on at a via point, or are U-turns allowed? (default `true`)
 max_speed_for_map_matching           | Float    | Maximum vehicle speed to be assumed in matching (in m/s)
 max_turn_weight                      | Float    | Maximum turn penalty weight
-force_split_edges                    | Boolean  | True value forces a split of forward and backward edges of extracted ways and guarantees that `segment_function` will be called for all segments (default `false`)
+force_split_edges                    | Boolean  | True value forces a split of forward and backward edges of extracted ways and guarantees that `process_segment` will be called for all segments (default `false`)
 
-## way_function
+### process_node(profile, node, result)
+Process an OSM node to determine whether this node is a barrier or can be passed and whether passing it incurs a delay.
 
-Given an OpenStreetMap way, the `way_function` will either return nothing (meaning we are not going to route over this way at all), or it will set up a result hash to be returned. The most important thing it will do is set the value of `result.forward_speed` and `result.backward_speed` as a suitable integer value representing the speed for traversing the way.
+Argument | Description
+---------|-------------------------------------------------------
+profile  | The configuration table you returned in `setup`.
+node     | The input node to process (read-only).
+result   | The output that you will modify.
 
-All other calculations stem from that, including the returned timings in driving directions, but also, less directly, it feeds into the actual routing decisions the engine will take (a way with a slow traversal speed, may be less favoured than a way with fast traversal speed, but it depends how long it is, and... what it connects to in the rest of the network graph)
+The following attributes can be set on `result`:
 
-Using the power of the scripting language you wouldn't typically see something as simple as a `result.forward_speed = 20` line within the `way_function`. Instead a `way_function` will examine the tagging (e.g. `way:get_value_by_key("highway")` and many others), process this information in various ways, calling other local functions, referencing the global variables and look-up hashes, before arriving at the result.
+Attribute       | Type    | Notes
+----------------|---------|---------------------------------------------------------
+barrier         | Boolean | Is it an impassable barrier?
+traffic_lights  | Boolean | Is it a traffic light (incurs delay in `process_turn`)?
 
-The following attributes can be set on the result in `way_function`:
+## process_way(profile, way, result)
+Given an OpenStreetMap way, the `process_way` function will either return nothing (meaning we are not going to route over this way at all), or it will set up a result hash.
+
+Argument | Description
+---------|-------------------------------------------------------
+profile  | The configuration table you returned in `setup`.
+node     | The input way to process (read-only).
+result   | The output that you will modify.
+
+Importantly it will set `result.forward_mode` and `result.backward_mode` to indicate the travel mode in each direction, as well as set `result.forward_speed` and `result.backward_speed` to integer values representing the speed for traversing the way.
+
+It will also set a number of other attributes on `result`.
+
+Using the power of the scripting language you wouldn't typically see something as simple as a `result.forward_speed = 20` line within the `process_way` function. Instead `process_way` will examine the tag set on the way, process this information in various ways, calling other local functions and referencing the configuration in `profile`, etc, before arriving at the result.
+
+The following attributes can be set on the result in `process_way`:
 
 Attribute                               | Type     | Notes
 ----------------------------------------|----------|--------------------------------------------------------------------------
@@ -60,7 +149,7 @@ forward_classes                         | Table    | Mark this way as being of a
 backward_classes                        | Table    |  "   "
 duration                                | Float    | Alternative setter for duration of the whole way in both directions
 weight                                  | Float    | Alternative setter for weight of the whole way in both directions
-turn_lanes_forward                      | String   | Directions for individual lanes (normalised OSM `turn:lanes` value)
+turn_lanes_forward                      | String   | Directions for individual lanes (normalized OSM `turn:lanes` value)
 turn_lanes_backward                     | String   |  "   "
 forward_restricted                      | Boolean  | Is this a restricted access road? (e.g. private, or deliveries only; used to enable high turn penalty, so that way is only chosen for start/end of route)
 backward_restricted                     | Boolean  |  "   "
@@ -78,32 +167,19 @@ road_classification.road_priority_class | Enum     | Guidance: order in priority
 road_classification.may_be_ignored      | Boolean  | Guidance: way is non-highway
 road_classification.num_lanes           | Unsigned | Guidance: total number of lanes in way
 
-### Guidance
+### process_segment(profile, segment)
+The `process_segment` function is called for every segment of OSM ways. A segment is a straight line between two OSM nodes. 
 
-The guidance parameters in profiles are currently a work in progress. They can and will change.
-Please be aware of this when using guidance configuration possibilities.
+On OpenStreetMap way cannot have different tags on different parts of a way. Instead you would split the way into several smaller ways. However many ways are long. For example, many ways pass hills without any change in tags. 
 
-Guidance uses road classes to decide on when/if to emit specific instructions and to discover which road is obvious when following a route.
-Classification uses three flags and a priority-category.
-The flags indicate whether a road is a motorway (required for on/off ramps), a link type (the ramps itself, if also a motorway) and whether a road may be omittted in considerations (is considered purely for connectivity).
-The priority-category influences the decision which road is considered the obvious choice and which roads can be seen as fork.
-Forks can be emitted between roads of similar priority category only. Obvious choices follow a major priority road, if the priority difference is large.
+Processing each segment of an OSM way makes it possible to have different speeds on different parts of a way based on external data like data about elevation, pollution, noise or scenic value and adjust weight and duration of the segment.
 
-## node_function
+In the `process_segment` you don't have access to OSM tags. Instead you use the geographical location of the start and end point of the way to lookup other data source, like elevation data. See [rasterbot.lua](../profiles/rasterbot.lua) for an example.
 
-The following attributes can be set on the result in `node_function`:
-
-Attribute       | Type    | Notes
-----------------|---------|-------------------------------------------------------
-barrier         | Boolean | Is it an impassable barrier?
-traffic_lights  | Boolean | Is it a traffic light (incurs delay in `turn_function`)?
-
-## segment_function
-
-The following attributes can be read and set on the result in `segment_function`:
+The following attributes can be read and set on the result in `process_segment`:
 
 Attribute          | Read/write? | Type    | Notes
--------------------|-------------|---------|------------------------------------------------------
+-------------------|-------------|---------|----------------------------------------
 source.lon         | Read        | Float   | Co-ordinates of segment start
 source.lat         | Read        | Float   |  "   "
 target.lon         | Read        | Float   | Co-ordinates of segment end
@@ -112,17 +188,88 @@ target.distance    | Read        | Float   | Length of segment
 weight             | Read/write  | Float   | Routing weight for this segment
 duration           | Read/write  | Float   | Duration for this segment
 
-## turn_function
+### process_turn(profile, turn)
+The `process_turn` function is called for every possible turn in the network. Based on the angle and type of turn you assign the weight and duration of the movement.
 
-The following attributes can be read and set on the result in `turn_function`:
+The following attributes can be read and set on the result in `process_turn`:
 
 Attribute          | Read/write? | Type    | Notes
 -------------------|-------------|---------|------------------------------------------------------
 direction_modifier | Read        | Enum    | Geometry of turn. Defined in `include/extractor/guidance/turn_instruction.hpp`
 turn_type          | Read        | Enum    | Priority of turn. Defined in `include/extractor/guidance/turn_instruction.hpp`
 has_traffic_light  | Read        | Boolean | Is a traffic light present at this turn?
-source_restricted  | Read        | Boolean | Is it from a restricted access road? (See definition in `way_function`)
-target_restricted  | Read        | Boolean | Is it to a restricted access road? (See definition in `way_function`)
+source_restricted  | Read        | Boolean | Is it from a restricted access road? (See definition in `process_way`)
+target_restricted  | Read        | Boolean | Is it to a restricted access road? (See definition in `process_way`)
 angle              | Read        | Float   | Angle of turn in degrees (`0-360`: `0`=u-turn, `180`=straight on)
 duration           | Read/write  | Float   | Penalty to be applied for this turn (duration in deciseconds)
 weight             | Read/write  | Float   | Penalty to be applied for this turn (routing weight)
+
+## Guidance
+The guidance parameters in profiles are currently a work in progress. They can and will change.
+Please be aware of this when using guidance configuration possibilities.
+
+Guidance uses road classes to decide on when/if to emit specific instructions and to discover which road is obvious when following a route.
+Classification uses three flags and a priority-category.
+The flags indicate whether a road is a motorway (required for on/off ramps), a link type (the ramps itself, if also a motorway) and whether a road may be omitted in considerations (is considered purely for connectivity).
+The priority-category influences the decision which road is considered the obvious choice and which roads can be seen as fork.
+Forks can be emitted between roads of similar priority category only. Obvious choices follow a major priority road, if the priority difference is large.
+
+### Using raster data
+OSRM has build-in support for loading an interpolating raster data in ASCII format. This can be used e.g. for factoring in elevation when computing routes.
+
+Use `raster:load()` in your `setup` function to load data and store the source in your configuration hash:
+
+```lua
+function setup()
+  return {
+    raster_source = raster:load(
+      "rastersource.asc",  -- file to load
+      0,    -- longitude min
+      0.1,  -- longitude max
+      0,    -- latitude min
+      0.1,  -- latitude max
+      5,    -- number of rows
+      4     -- number of columns
+    )
+  }
+end
+```
+
+The input data must an ASCII file with rows of integers. e.g.:
+
+```
+0  0  0   0
+0  0  0   250
+0  0  250 500
+0  0  0   250
+0  0  0   0
+```
+
+In your `segment_function` you can then access the raster source and use `raster:query()` to query to find the nearest data point, or `raster:interpolate()` to interpolate a value based on nearby data points.
+
+You must check whether the result is valid before use it.
+
+Example:
+
+```lua
+function process_segment (profile, segment)
+  local sourceData = raster:query(profile.raster_source, segment.source.lon, segment.source.lat)
+  local targetData = raster:query(profile.raster_source, segment.target.lon, segment.target.lat)
+  
+  local invalid = sourceData.invalid_data()
+  if sourceData.datum ~= invalid and targetData.datum ~= invalid then
+      -- use values to adjust weight and duration
+    [...]
+end
+```
+
+See [rasterbot.lua](../profiles/rasterbot.lua) and [rasterbotinterp.lua](../profiles/rasterbotinterp.lua) for examples.
+
+### Helper functions
+There are a few helper functions defined in the global scope that profiles can use:
+
+durationIsValid
+parseDuration
+trimLaneString
+applyAccessTokens
+canonicalizeStringList

example/cmake/FindTBB.cmake

@@ -1,283 +1,283 @@
-# Locate Intel Threading Building Blocks include paths and libraries
-# FindTBB.cmake can be found at https://code.google.com/p/findtbb/
-# Written by Hannes Hofmann <hannes.hofmann _at_ informatik.uni-erlangen.de>
-# Improvements by Gino van den Bergen <gino _at_ dtecta.com>,
-#   Florian Uhlig <F.Uhlig _at_ gsi.de>,
-#   Jiri Marsik <jiri.marsik89 _at_ gmail.com>
-
-# The MIT License
-#
-# Copyright (c) 2011 Hannes Hofmann
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-
-# GvdB: This module uses the environment variable TBB_ARCH_PLATFORM which defines architecture and compiler.
-#   e.g. "ia32/vc8" or "em64t/cc4.1.0_libc2.4_kernel2.6.16.21"
-#   TBB_ARCH_PLATFORM is set by the build script tbbvars[.bat|.sh|.csh], which can be found
-#   in the TBB installation directory (TBB_INSTALL_DIR).
-#
-# GvdB: Mac OS X distribution places libraries directly in lib directory.
-#
-# For backwards compatibility, you may explicitely set the CMake variables TBB_ARCHITECTURE and TBB_COMPILER.
-# TBB_ARCHITECTURE [ ia32 | em64t | itanium ]
-#   which architecture to use
-# TBB_COMPILER e.g. vc9 or cc3.2.3_libc2.3.2_kernel2.4.21 or cc4.0.1_os10.4.9
-#   which compiler to use (detected automatically on Windows)
-
-# This module respects
-# TBB_INSTALL_DIR or $ENV{TBB21_INSTALL_DIR} or $ENV{TBB_INSTALL_DIR}
-
-# This module defines
-# TBB_INCLUDE_DIRS, where to find task_scheduler_init.h, etc.
-# TBB_LIBRARY_DIRS, where to find libtbb, libtbbmalloc
-# TBB_DEBUG_LIBRARY_DIRS, where to find libtbb_debug, libtbbmalloc_debug
-# TBB_INSTALL_DIR, the base TBB install directory
-# TBB_LIBRARIES, the libraries to link against to use TBB.
-# TBB_DEBUG_LIBRARIES, the libraries to link against to use TBB with debug symbols.
-# TBB_FOUND, If false, don't try to use TBB.
-# TBB_INTERFACE_VERSION, as defined in tbb/tbb_stddef.h
-
-
-if (WIN32)
-    # has em64t/vc8 em64t/vc9
-    # has ia32/vc7.1 ia32/vc8 ia32/vc9
-    set(_TBB_DEFAULT_INSTALL_DIR "C:/Program Files/Intel/TBB" "C:/Program Files (x86)/Intel/TBB")
-    set(_TBB_LIB_NAME "tbb")
-    set(_TBB_LIB_MALLOC_NAME "${_TBB_LIB_NAME}malloc")
-    set(_TBB_LIB_DEBUG_NAME "${_TBB_LIB_NAME}_debug")
-    set(_TBB_LIB_MALLOC_DEBUG_NAME "${_TBB_LIB_MALLOC_NAME}_debug")
-    if (MSVC71)
-        set (_TBB_COMPILER "vc7.1")
-    endif(MSVC71)
-    if (MSVC80)
-        set(_TBB_COMPILER "vc8")
-    endif(MSVC80)
-    if (MSVC90)
-        set(_TBB_COMPILER "vc9")
-    endif(MSVC90)
-    if(MSVC10)
-        set(_TBB_COMPILER "vc10")
-    endif(MSVC10)
-    # Todo: add other Windows compilers such as ICL.
-    set(_TBB_ARCHITECTURE ${TBB_ARCHITECTURE})
-endif (WIN32)
-
-if (UNIX)
-    if (APPLE)
-        # MAC
-        set(_TBB_DEFAULT_INSTALL_DIR "/Library/Frameworks/Intel_TBB.framework/Versions")
-        # libs: libtbb.dylib, libtbbmalloc.dylib, *_debug
-        set(_TBB_LIB_NAME "tbb")
-        set(_TBB_LIB_MALLOC_NAME "${_TBB_LIB_NAME}malloc")
-        set(_TBB_LIB_DEBUG_NAME "${_TBB_LIB_NAME}_debug")
-        set(_TBB_LIB_MALLOC_DEBUG_NAME "${_TBB_LIB_MALLOC_NAME}_debug")
-        # default flavor on apple: ia32/cc4.0.1_os10.4.9
-        # Jiri: There is no reason to presume there is only one flavor and
-        #       that user's setting of variables should be ignored.
-        if(NOT TBB_COMPILER)
-            set(_TBB_COMPILER "cc4.0.1_os10.4.9")
-        elseif (NOT TBB_COMPILER)
-            set(_TBB_COMPILER ${TBB_COMPILER})
-        endif(NOT TBB_COMPILER)
-        if(NOT TBB_ARCHITECTURE)
-            set(_TBB_ARCHITECTURE "ia32")
-        elseif(NOT TBB_ARCHITECTURE)
-            set(_TBB_ARCHITECTURE ${TBB_ARCHITECTURE})
-        endif(NOT TBB_ARCHITECTURE)
-    else (APPLE)
-        # LINUX
-        set(_TBB_DEFAULT_INSTALL_DIR "/opt/intel/tbb" "/usr/local/include" "/usr/include")
-        set(_TBB_LIB_NAME "tbb")
-        set(_TBB_LIB_MALLOC_NAME "${_TBB_LIB_NAME}malloc")
-        set(_TBB_LIB_DEBUG_NAME "${_TBB_LIB_NAME}_debug")
-        set(_TBB_LIB_MALLOC_DEBUG_NAME "${_TBB_LIB_MALLOC_NAME}_debug")
-        # has em64t/cc3.2.3_libc2.3.2_kernel2.4.21 em64t/cc3.3.3_libc2.3.3_kernel2.6.5 em64t/cc3.4.3_libc2.3.4_kernel2.6.9 em64t/cc4.1.0_libc2.4_kernel2.6.16.21
-        # has ia32/*
-        # has itanium/*
-        set(_TBB_COMPILER ${TBB_COMPILER})
-        set(_TBB_ARCHITECTURE ${TBB_ARCHITECTURE})
-    endif (APPLE)
-endif (UNIX)
-
-if (CMAKE_SYSTEM MATCHES "SunOS.*")
-# SUN
-# not yet supported
-# has em64t/cc3.4.3_kernel5.10
-# has ia32/*
-endif (CMAKE_SYSTEM MATCHES "SunOS.*")
-
-
-#-- Clear the public variables
-set (TBB_FOUND "NO")
-
-
-#-- Find TBB install dir and set ${_TBB_INSTALL_DIR} and cached ${TBB_INSTALL_DIR}
-# first: use CMake variable TBB_INSTALL_DIR
-if (TBB_INSTALL_DIR)
-    set (_TBB_INSTALL_DIR ${TBB_INSTALL_DIR})
-endif (TBB_INSTALL_DIR)
-# second: use environment variable
-if (NOT _TBB_INSTALL_DIR)
-    if (NOT "$ENV{TBB_INSTALL_DIR}" STREQUAL "")
-        set (_TBB_INSTALL_DIR $ENV{TBB_INSTALL_DIR})
-    endif (NOT "$ENV{TBB_INSTALL_DIR}" STREQUAL "")
-    # Intel recommends setting TBB21_INSTALL_DIR
-    if (NOT "$ENV{TBB21_INSTALL_DIR}" STREQUAL "")
-        set (_TBB_INSTALL_DIR $ENV{TBB21_INSTALL_DIR})
-    endif (NOT "$ENV{TBB21_INSTALL_DIR}" STREQUAL "")
-    if (NOT "$ENV{TBB22_INSTALL_DIR}" STREQUAL "")
-        set (_TBB_INSTALL_DIR $ENV{TBB22_INSTALL_DIR})
-    endif (NOT "$ENV{TBB22_INSTALL_DIR}" STREQUAL "")
-    if (NOT "$ENV{TBB30_INSTALL_DIR}" STREQUAL "")
-        set (_TBB_INSTALL_DIR $ENV{TBB30_INSTALL_DIR})
-    endif (NOT "$ENV{TBB30_INSTALL_DIR}" STREQUAL "")
-endif (NOT _TBB_INSTALL_DIR)
-# third: try to find path automatically
-if (NOT _TBB_INSTALL_DIR)
-    if (_TBB_DEFAULT_INSTALL_DIR)
-        set (_TBB_INSTALL_DIR ${_TBB_DEFAULT_INSTALL_DIR})
-    endif (_TBB_DEFAULT_INSTALL_DIR)
-endif (NOT _TBB_INSTALL_DIR)
-# sanity check
-if (NOT _TBB_INSTALL_DIR)
-    message ("ERROR: Unable to find Intel TBB install directory. ${_TBB_INSTALL_DIR}")
-else (NOT _TBB_INSTALL_DIR)
-# finally: set the cached CMake variable TBB_INSTALL_DIR
-if (NOT TBB_INSTALL_DIR)
-    set (TBB_INSTALL_DIR ${_TBB_INSTALL_DIR} CACHE PATH "Intel TBB install directory")
-    mark_as_advanced(TBB_INSTALL_DIR)
-endif (NOT TBB_INSTALL_DIR)
-
-
-#-- A macro to rewrite the paths of the library. This is necessary, because
-#   find_library() always found the em64t/vc9 version of the TBB libs
-macro(TBB_CORRECT_LIB_DIR var_name)
-#    if (NOT "${_TBB_ARCHITECTURE}" STREQUAL "em64t")
-        string(REPLACE em64t "${_TBB_ARCHITECTURE}" ${var_name} ${${var_name}})
-#    endif (NOT "${_TBB_ARCHITECTURE}" STREQUAL "em64t")
-    string(REPLACE ia32 "${_TBB_ARCHITECTURE}" ${var_name} ${${var_name}})
-    string(REPLACE vc7.1 "${_TBB_COMPILER}" ${var_name} ${${var_name}})
-    string(REPLACE vc8 "${_TBB_COMPILER}" ${var_name} ${${var_name}})
-    string(REPLACE vc9 "${_TBB_COMPILER}" ${var_name} ${${var_name}})
-    string(REPLACE vc10 "${_TBB_COMPILER}" ${var_name} ${${var_name}})
-endmacro(TBB_CORRECT_LIB_DIR var_content)
-
-
-#-- Look for include directory and set ${TBB_INCLUDE_DIR}
-set (TBB_INC_SEARCH_DIR ${_TBB_INSTALL_DIR}/include)
-# Jiri: tbbvars now sets the CPATH environment variable to the directory
-#       containing the headers.
-find_path(TBB_INCLUDE_DIR
-    tbb/task_scheduler_init.h
-    PATHS ${TBB_INC_SEARCH_DIR} ENV CPATH
-)
-mark_as_advanced(TBB_INCLUDE_DIR)
-
-
-#-- Look for libraries
-# GvdB: $ENV{TBB_ARCH_PLATFORM} is set by the build script tbbvars[.bat|.sh|.csh]
-if (NOT $ENV{TBB_ARCH_PLATFORM} STREQUAL "")
-    set (_TBB_LIBRARY_DIR 
-         ${_TBB_INSTALL_DIR}/lib/$ENV{TBB_ARCH_PLATFORM}
-         ${_TBB_INSTALL_DIR}/$ENV{TBB_ARCH_PLATFORM}/lib
-        )
-endif (NOT $ENV{TBB_ARCH_PLATFORM} STREQUAL "")
-# Jiri: This block isn't mutually exclusive with the previous one
-#       (hence no else), instead I test if the user really specified
-#       the variables in question.
-if ((NOT ${TBB_ARCHITECTURE} STREQUAL "") AND (NOT ${TBB_COMPILER} STREQUAL ""))
-    # HH: deprecated
-    message(STATUS "[Warning] FindTBB.cmake: The use of TBB_ARCHITECTURE and TBB_COMPILER is deprecated and may not be supported in future versions. Please set \$ENV{TBB_ARCH_PLATFORM} (using tbbvars.[bat|csh|sh]).")
-    # Jiri: It doesn't hurt to look in more places, so I store the hints from
-    #       ENV{TBB_ARCH_PLATFORM} and the TBB_ARCHITECTURE and TBB_COMPILER
-    #       variables and search them both.
-    set (_TBB_LIBRARY_DIR "${_TBB_INSTALL_DIR}/${_TBB_ARCHITECTURE}/${_TBB_COMPILER}/lib" ${_TBB_LIBRARY_DIR})
-endif ((NOT ${TBB_ARCHITECTURE} STREQUAL "") AND (NOT ${TBB_COMPILER} STREQUAL ""))
-
-# GvdB: Mac OS X distribution places libraries directly in lib directory.
-list(APPEND _TBB_LIBRARY_DIR ${_TBB_INSTALL_DIR}/lib)
-
-# Jiri: No reason not to check the default paths. From recent versions,
-#       tbbvars has started exporting the LIBRARY_PATH and LD_LIBRARY_PATH
-#       variables, which now point to the directories of the lib files.
-#       It all makes more sense to use the ${_TBB_LIBRARY_DIR} as a HINTS
-#       argument instead of the implicit PATHS as it isn't hard-coded
-#       but computed by system introspection. Searching the LIBRARY_PATH
-#       and LD_LIBRARY_PATH environment variables is now even more important
-#       that tbbvars doesn't export TBB_ARCH_PLATFORM and it facilitates
-#       the use of TBB built from sources.
-find_library(TBB_LIBRARY ${_TBB_LIB_NAME} HINTS ${_TBB_LIBRARY_DIR}
-        PATHS ENV LIBRARY_PATH ENV LD_LIBRARY_PATH)
-find_library(TBB_MALLOC_LIBRARY ${_TBB_LIB_MALLOC_NAME} HINTS ${_TBB_LIBRARY_DIR}
-        PATHS ENV LIBRARY_PATH ENV LD_LIBRARY_PATH)
-
-#Extract path from TBB_LIBRARY name
-get_filename_component(TBB_LIBRARY_DIR ${TBB_LIBRARY} PATH)
-
-#TBB_CORRECT_LIB_DIR(TBB_LIBRARY)
-#TBB_CORRECT_LIB_DIR(TBB_MALLOC_LIBRARY)
-mark_as_advanced(TBB_LIBRARY TBB_MALLOC_LIBRARY)
-
-#-- Look for debug libraries
-# Jiri: Changed the same way as for the release libraries.
-find_library(TBB_LIBRARY_DEBUG ${_TBB_LIB_DEBUG_NAME} HINTS ${_TBB_LIBRARY_DIR}
-        PATHS ENV LIBRARY_PATH ENV LD_LIBRARY_PATH)
-find_library(TBB_MALLOC_LIBRARY_DEBUG ${_TBB_LIB_MALLOC_DEBUG_NAME} HINTS ${_TBB_LIBRARY_DIR}
-        PATHS ENV LIBRARY_PATH ENV LD_LIBRARY_PATH)
-
-# Jiri: Self-built TBB stores the debug libraries in a separate directory.
-#       Extract path from TBB_LIBRARY_DEBUG name
-get_filename_component(TBB_LIBRARY_DEBUG_DIR ${TBB_LIBRARY_DEBUG} PATH)
-
-#TBB_CORRECT_LIB_DIR(TBB_LIBRARY_DEBUG)
-#TBB_CORRECT_LIB_DIR(TBB_MALLOC_LIBRARY_DEBUG)
-mark_as_advanced(TBB_LIBRARY_DEBUG TBB_MALLOC_LIBRARY_DEBUG)
-
-
-if (TBB_INCLUDE_DIR)
-    if (TBB_LIBRARY)
-        set (TBB_FOUND "YES")
-        set (TBB_LIBRARIES ${TBB_LIBRARY} ${TBB_MALLOC_LIBRARY} ${TBB_LIBRARIES})
-        set (TBB_DEBUG_LIBRARIES ${TBB_LIBRARY_DEBUG} ${TBB_MALLOC_LIBRARY_DEBUG} ${TBB_DEBUG_LIBRARIES})
-        set (TBB_INCLUDE_DIRS ${TBB_INCLUDE_DIR} CACHE PATH "TBB include directory" FORCE)
-        set (TBB_LIBRARY_DIRS ${TBB_LIBRARY_DIR} CACHE PATH "TBB library directory" FORCE)
-        # Jiri: Self-built TBB stores the debug libraries in a separate directory.
-        set (TBB_DEBUG_LIBRARY_DIRS ${TBB_LIBRARY_DEBUG_DIR} CACHE PATH "TBB debug library directory" FORCE)
-        mark_as_advanced(TBB_INCLUDE_DIRS TBB_LIBRARY_DIRS TBB_DEBUG_LIBRARY_DIRS TBB_LIBRARIES TBB_DEBUG_LIBRARIES)
-        message(STATUS "Found Intel TBB")
-    endif (TBB_LIBRARY)
-endif (TBB_INCLUDE_DIR)
-
-if (NOT TBB_FOUND)
-    message("ERROR: Intel TBB NOT found!")
-    message(STATUS "Looked for Threading Building Blocks in ${_TBB_INSTALL_DIR}")
-    # do only throw fatal, if this pkg is REQUIRED
-    if (TBB_FIND_REQUIRED)
-        message(FATAL_ERROR "Could NOT find TBB library.")
-    endif (TBB_FIND_REQUIRED)
-endif (NOT TBB_FOUND)
-
-endif (NOT _TBB_INSTALL_DIR)
-
-if (TBB_FOUND)
-	set(TBB_INTERFACE_VERSION 0)
-	FILE(READ "${TBB_INCLUDE_DIRS}/tbb/tbb_stddef.h" _TBB_VERSION_CONTENTS)
-	STRING(REGEX REPLACE ".*#define TBB_INTERFACE_VERSION ([0-9]+).*" "\\1" TBB_INTERFACE_VERSION "${_TBB_VERSION_CONTENTS}")
-	set(TBB_INTERFACE_VERSION "${TBB_INTERFACE_VERSION}")
-endif (TBB_FOUND)
+# Locate Intel Threading Building Blocks include paths and libraries
+# FindTBB.cmake can be found at https://code.google.com/p/findtbb/
+# Written by Hannes Hofmann <hannes.hofmann _at_ informatik.uni-erlangen.de>
+# Improvements by Gino van den Bergen <gino _at_ dtecta.com>,
+#   Florian Uhlig <F.Uhlig _at_ gsi.de>,
+#   Jiri Marsik <jiri.marsik89 _at_ gmail.com>
+
+# The MIT License
+#
+# Copyright (c) 2011 Hannes Hofmann
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+# GvdB: This module uses the environment variable TBB_ARCH_PLATFORM which defines architecture and compiler.
+#   e.g. "ia32/vc8" or "em64t/cc4.1.0_libc2.4_kernel2.6.16.21"
+#   TBB_ARCH_PLATFORM is set by the build script tbbvars[.bat|.sh|.csh], which can be found
+#   in the TBB installation directory (TBB_INSTALL_DIR).
+#
+# GvdB: Mac OS X distribution places libraries directly in lib directory.
+#
+# For backwards compatibility, you may explicitely set the CMake variables TBB_ARCHITECTURE and TBB_COMPILER.
+# TBB_ARCHITECTURE [ ia32 | em64t | itanium ]
+#   which architecture to use
+# TBB_COMPILER e.g. vc9 or cc3.2.3_libc2.3.2_kernel2.4.21 or cc4.0.1_os10.4.9
+#   which compiler to use (detected automatically on Windows)
+
+# This module respects
+# TBB_INSTALL_DIR or $ENV{TBB21_INSTALL_DIR} or $ENV{TBB_INSTALL_DIR}
+
+# This module defines
+# TBB_INCLUDE_DIRS, where to find task_scheduler_init.h, etc.
+# TBB_LIBRARY_DIRS, where to find libtbb, libtbbmalloc
+# TBB_DEBUG_LIBRARY_DIRS, where to find libtbb_debug, libtbbmalloc_debug
+# TBB_INSTALL_DIR, the base TBB install directory
+# TBB_LIBRARIES, the libraries to link against to use TBB.
+# TBB_DEBUG_LIBRARIES, the libraries to link against to use TBB with debug symbols.
+# TBB_FOUND, If false, don't try to use TBB.
+# TBB_INTERFACE_VERSION, as defined in tbb/tbb_stddef.h
+
+
+if (WIN32)
+    # has em64t/vc8 em64t/vc9
+    # has ia32/vc7.1 ia32/vc8 ia32/vc9
+    set(_TBB_DEFAULT_INSTALL_DIR "C:/Program Files/Intel/TBB" "C:/Program Files (x86)/Intel/TBB")
+    set(_TBB_LIB_NAME "tbb")
+    set(_TBB_LIB_MALLOC_NAME "${_TBB_LIB_NAME}malloc")
+    set(_TBB_LIB_DEBUG_NAME "${_TBB_LIB_NAME}_debug")
+    set(_TBB_LIB_MALLOC_DEBUG_NAME "${_TBB_LIB_MALLOC_NAME}_debug")
+    if (MSVC71)
+        set (_TBB_COMPILER "vc7.1")
+    endif(MSVC71)
+    if (MSVC80)
+        set(_TBB_COMPILER "vc8")
+    endif(MSVC80)
+    if (MSVC90)
+        set(_TBB_COMPILER "vc9")
+    endif(MSVC90)
+    if(MSVC10)
+        set(_TBB_COMPILER "vc10")
+    endif(MSVC10)
+    # Todo: add other Windows compilers such as ICL.
+    set(_TBB_ARCHITECTURE ${TBB_ARCHITECTURE})
+endif (WIN32)
+
+if (UNIX)
+    if (APPLE)
+        # MAC
+        set(_TBB_DEFAULT_INSTALL_DIR "/Library/Frameworks/Intel_TBB.framework/Versions")
+        # libs: libtbb.dylib, libtbbmalloc.dylib, *_debug
+        set(_TBB_LIB_NAME "tbb")
+        set(_TBB_LIB_MALLOC_NAME "${_TBB_LIB_NAME}malloc")
+        set(_TBB_LIB_DEBUG_NAME "${_TBB_LIB_NAME}_debug")
+        set(_TBB_LIB_MALLOC_DEBUG_NAME "${_TBB_LIB_MALLOC_NAME}_debug")
+        # default flavor on apple: ia32/cc4.0.1_os10.4.9
+        # Jiri: There is no reason to presume there is only one flavor and
+        #       that user's setting of variables should be ignored.
+        if(NOT TBB_COMPILER)
+            set(_TBB_COMPILER "cc4.0.1_os10.4.9")
+        elseif (NOT TBB_COMPILER)
+            set(_TBB_COMPILER ${TBB_COMPILER})
+        endif(NOT TBB_COMPILER)
+        if(NOT TBB_ARCHITECTURE)
+            set(_TBB_ARCHITECTURE "ia32")
+        elseif(NOT TBB_ARCHITECTURE)
+            set(_TBB_ARCHITECTURE ${TBB_ARCHITECTURE})
+        endif(NOT TBB_ARCHITECTURE)
+    else (APPLE)
+        # LINUX
+        set(_TBB_DEFAULT_INSTALL_DIR "/opt/intel/tbb" "/usr/local/include" "/usr/include")
+        set(_TBB_LIB_NAME "tbb")
+        set(_TBB_LIB_MALLOC_NAME "${_TBB_LIB_NAME}malloc")
+        set(_TBB_LIB_DEBUG_NAME "${_TBB_LIB_NAME}_debug")
+        set(_TBB_LIB_MALLOC_DEBUG_NAME "${_TBB_LIB_MALLOC_NAME}_debug")
+        # has em64t/cc3.2.3_libc2.3.2_kernel2.4.21 em64t/cc3.3.3_libc2.3.3_kernel2.6.5 em64t/cc3.4.3_libc2.3.4_kernel2.6.9 em64t/cc4.1.0_libc2.4_kernel2.6.16.21
+        # has ia32/*
+        # has itanium/*
+        set(_TBB_COMPILER ${TBB_COMPILER})
+        set(_TBB_ARCHITECTURE ${TBB_ARCHITECTURE})
+    endif (APPLE)
+endif (UNIX)
+
+if (CMAKE_SYSTEM MATCHES "SunOS.*")
+# SUN
+# not yet supported
+# has em64t/cc3.4.3_kernel5.10
+# has ia32/*
+endif (CMAKE_SYSTEM MATCHES "SunOS.*")
+
+
+#-- Clear the public variables
+set (TBB_FOUND "NO")
+
+
+#-- Find TBB install dir and set ${_TBB_INSTALL_DIR} and cached ${TBB_INSTALL_DIR}
+# first: use CMake variable TBB_INSTALL_DIR
+if (TBB_INSTALL_DIR)
+    set (_TBB_INSTALL_DIR ${TBB_INSTALL_DIR})
+endif (TBB_INSTALL_DIR)
+# second: use environment variable
+if (NOT _TBB_INSTALL_DIR)
+    if (NOT "$ENV{TBB_INSTALL_DIR}" STREQUAL "")
+        set (_TBB_INSTALL_DIR $ENV{TBB_INSTALL_DIR})
+    endif (NOT "$ENV{TBB_INSTALL_DIR}" STREQUAL "")
+    # Intel recommends setting TBB21_INSTALL_DIR
+    if (NOT "$ENV{TBB21_INSTALL_DIR}" STREQUAL "")
+        set (_TBB_INSTALL_DIR $ENV{TBB21_INSTALL_DIR})
+    endif (NOT "$ENV{TBB21_INSTALL_DIR}" STREQUAL "")
+    if (NOT "$ENV{TBB22_INSTALL_DIR}" STREQUAL "")
+        set (_TBB_INSTALL_DIR $ENV{TBB22_INSTALL_DIR})
+    endif (NOT "$ENV{TBB22_INSTALL_DIR}" STREQUAL "")
+    if (NOT "$ENV{TBB30_INSTALL_DIR}" STREQUAL "")
+        set (_TBB_INSTALL_DIR $ENV{TBB30_INSTALL_DIR})
+    endif (NOT "$ENV{TBB30_INSTALL_DIR}" STREQUAL "")
+endif (NOT _TBB_INSTALL_DIR)
+# third: try to find path automatically
+if (NOT _TBB_INSTALL_DIR)
+    if (_TBB_DEFAULT_INSTALL_DIR)
+        set (_TBB_INSTALL_DIR ${_TBB_DEFAULT_INSTALL_DIR})
+    endif (_TBB_DEFAULT_INSTALL_DIR)
+endif (NOT _TBB_INSTALL_DIR)
+# sanity check
+if (NOT _TBB_INSTALL_DIR)
+    message ("ERROR: Unable to find Intel TBB install directory. ${_TBB_INSTALL_DIR}")
+else (NOT _TBB_INSTALL_DIR)
+# finally: set the cached CMake variable TBB_INSTALL_DIR
+if (NOT TBB_INSTALL_DIR)
+    set (TBB_INSTALL_DIR ${_TBB_INSTALL_DIR} CACHE PATH "Intel TBB install directory")
+    mark_as_advanced(TBB_INSTALL_DIR)
+endif (NOT TBB_INSTALL_DIR)
+
+
+#-- A macro to rewrite the paths of the library. This is necessary, because
+#   find_library() always found the em64t/vc9 version of the TBB libs
+macro(TBB_CORRECT_LIB_DIR var_name)
+#    if (NOT "${_TBB_ARCHITECTURE}" STREQUAL "em64t")
+        string(REPLACE em64t "${_TBB_ARCHITECTURE}" ${var_name} ${${var_name}})
+#    endif (NOT "${_TBB_ARCHITECTURE}" STREQUAL "em64t")
+    string(REPLACE ia32 "${_TBB_ARCHITECTURE}" ${var_name} ${${var_name}})
+    string(REPLACE vc7.1 "${_TBB_COMPILER}" ${var_name} ${${var_name}})
+    string(REPLACE vc8 "${_TBB_COMPILER}" ${var_name} ${${var_name}})
+    string(REPLACE vc9 "${_TBB_COMPILER}" ${var_name} ${${var_name}})
+    string(REPLACE vc10 "${_TBB_COMPILER}" ${var_name} ${${var_name}})
+endmacro(TBB_CORRECT_LIB_DIR var_content)
+
+
+#-- Look for include directory and set ${TBB_INCLUDE_DIR}
+set (TBB_INC_SEARCH_DIR ${_TBB_INSTALL_DIR}/include)
+# Jiri: tbbvars now sets the CPATH environment variable to the directory
+#       containing the headers.
+find_path(TBB_INCLUDE_DIR
+    tbb/task_scheduler_init.h
+    PATHS ${TBB_INC_SEARCH_DIR} ENV CPATH
+)
+mark_as_advanced(TBB_INCLUDE_DIR)
+
+
+#-- Look for libraries
+# GvdB: $ENV{TBB_ARCH_PLATFORM} is set by the build script tbbvars[.bat|.sh|.csh]
+if (NOT $ENV{TBB_ARCH_PLATFORM} STREQUAL "")
+    set (_TBB_LIBRARY_DIR 
+         ${_TBB_INSTALL_DIR}/lib/$ENV{TBB_ARCH_PLATFORM}
+         ${_TBB_INSTALL_DIR}/$ENV{TBB_ARCH_PLATFORM}/lib
+        )
+endif (NOT $ENV{TBB_ARCH_PLATFORM} STREQUAL "")
+# Jiri: This block isn't mutually exclusive with the previous one
+#       (hence no else), instead I test if the user really specified
+#       the variables in question.
+if ((NOT ${TBB_ARCHITECTURE} STREQUAL "") AND (NOT ${TBB_COMPILER} STREQUAL ""))
+    # HH: deprecated
+    message(STATUS "[Warning] FindTBB.cmake: The use of TBB_ARCHITECTURE and TBB_COMPILER is deprecated and may not be supported in future versions. Please set \$ENV{TBB_ARCH_PLATFORM} (using tbbvars.[bat|csh|sh]).")
+    # Jiri: It doesn't hurt to look in more places, so I store the hints from
+    #       ENV{TBB_ARCH_PLATFORM} and the TBB_ARCHITECTURE and TBB_COMPILER
+    #       variables and search them both.
+    set (_TBB_LIBRARY_DIR "${_TBB_INSTALL_DIR}/${_TBB_ARCHITECTURE}/${_TBB_COMPILER}/lib" ${_TBB_LIBRARY_DIR})
+endif ((NOT ${TBB_ARCHITECTURE} STREQUAL "") AND (NOT ${TBB_COMPILER} STREQUAL ""))
+
+# GvdB: Mac OS X distribution places libraries directly in lib directory.
+list(APPEND _TBB_LIBRARY_DIR ${_TBB_INSTALL_DIR}/lib)
+
+# Jiri: No reason not to check the default paths. From recent versions,
+#       tbbvars has started exporting the LIBRARY_PATH and LD_LIBRARY_PATH
+#       variables, which now point to the directories of the lib files.
+#       It all makes more sense to use the ${_TBB_LIBRARY_DIR} as a HINTS
+#       argument instead of the implicit PATHS as it isn't hard-coded
+#       but computed by system introspection. Searching the LIBRARY_PATH
+#       and LD_LIBRARY_PATH environment variables is now even more important
+#       that tbbvars doesn't export TBB_ARCH_PLATFORM and it facilitates
+#       the use of TBB built from sources.
+find_library(TBB_LIBRARY ${_TBB_LIB_NAME} HINTS ${_TBB_LIBRARY_DIR}
+        PATHS ENV LIBRARY_PATH ENV LD_LIBRARY_PATH)
+find_library(TBB_MALLOC_LIBRARY ${_TBB_LIB_MALLOC_NAME} HINTS ${_TBB_LIBRARY_DIR}
+        PATHS ENV LIBRARY_PATH ENV LD_LIBRARY_PATH)
+
+#Extract path from TBB_LIBRARY name
+get_filename_component(TBB_LIBRARY_DIR ${TBB_LIBRARY} PATH)
+
+#TBB_CORRECT_LIB_DIR(TBB_LIBRARY)
+#TBB_CORRECT_LIB_DIR(TBB_MALLOC_LIBRARY)
+mark_as_advanced(TBB_LIBRARY TBB_MALLOC_LIBRARY)
+
+#-- Look for debug libraries
+# Jiri: Changed the same way as for the release libraries.
+find_library(TBB_LIBRARY_DEBUG ${_TBB_LIB_DEBUG_NAME} HINTS ${_TBB_LIBRARY_DIR}
+        PATHS ENV LIBRARY_PATH ENV LD_LIBRARY_PATH)
+find_library(TBB_MALLOC_LIBRARY_DEBUG ${_TBB_LIB_MALLOC_DEBUG_NAME} HINTS ${_TBB_LIBRARY_DIR}
+        PATHS ENV LIBRARY_PATH ENV LD_LIBRARY_PATH)
+
+# Jiri: Self-built TBB stores the debug libraries in a separate directory.
+#       Extract path from TBB_LIBRARY_DEBUG name
+get_filename_component(TBB_LIBRARY_DEBUG_DIR ${TBB_LIBRARY_DEBUG} PATH)
+
+#TBB_CORRECT_LIB_DIR(TBB_LIBRARY_DEBUG)
+#TBB_CORRECT_LIB_DIR(TBB_MALLOC_LIBRARY_DEBUG)
+mark_as_advanced(TBB_LIBRARY_DEBUG TBB_MALLOC_LIBRARY_DEBUG)
+
+
+if (TBB_INCLUDE_DIR)
+    if (TBB_LIBRARY)
+        set (TBB_FOUND "YES")
+        set (TBB_LIBRARIES ${TBB_LIBRARY} ${TBB_MALLOC_LIBRARY} ${TBB_LIBRARIES})
+        set (TBB_DEBUG_LIBRARIES ${TBB_LIBRARY_DEBUG} ${TBB_MALLOC_LIBRARY_DEBUG} ${TBB_DEBUG_LIBRARIES})
+        set (TBB_INCLUDE_DIRS ${TBB_INCLUDE_DIR} CACHE PATH "TBB include directory" FORCE)
+        set (TBB_LIBRARY_DIRS ${TBB_LIBRARY_DIR} CACHE PATH "TBB library directory" FORCE)
+        # Jiri: Self-built TBB stores the debug libraries in a separate directory.
+        set (TBB_DEBUG_LIBRARY_DIRS ${TBB_LIBRARY_DEBUG_DIR} CACHE PATH "TBB debug library directory" FORCE)
+        mark_as_advanced(TBB_INCLUDE_DIRS TBB_LIBRARY_DIRS TBB_DEBUG_LIBRARY_DIRS TBB_LIBRARIES TBB_DEBUG_LIBRARIES)
+        message(STATUS "Found Intel TBB")
+    endif (TBB_LIBRARY)
+endif (TBB_INCLUDE_DIR)
+
+if (NOT TBB_FOUND)
+    message("ERROR: Intel TBB NOT found!")
+    message(STATUS "Looked for Threading Building Blocks in ${_TBB_INSTALL_DIR}")
+    # do only throw fatal, if this pkg is REQUIRED
+    if (TBB_FIND_REQUIRED)
+        message(FATAL_ERROR "Could NOT find TBB library.")
+    endif (TBB_FIND_REQUIRED)
+endif (NOT TBB_FOUND)
+
+endif (NOT _TBB_INSTALL_DIR)
+
+if (TBB_FOUND)
+	set(TBB_INTERFACE_VERSION 0)
+	FILE(READ "${TBB_INCLUDE_DIRS}/tbb/tbb_stddef.h" _TBB_VERSION_CONTENTS)
+	STRING(REGEX REPLACE ".*#define TBB_INTERFACE_VERSION ([0-9]+).*" "\\1" TBB_INTERFACE_VERSION "${_TBB_VERSION_CONTENTS}")
+	set(TBB_INTERFACE_VERSION "${TBB_INTERFACE_VERSION}")
+endif (TBB_FOUND)

features/bicycle/alley.feature

@@ -2,10 +2,9 @@
 Feature: Bicycle - Route around alleys
 
     Background:
-        Given the profile file
+        Given the profile file "bicycle" initialized with
         """
-        require 'bicycle'
-        properties.weight_name = 'cyclability'
+        profile.properties.weight_name = 'cyclability'
         """
 
     Scenario: Bicycle - Avoid taking alleys

features/bicycle/bridge.feature

@@ -4,7 +4,7 @@ Feature: Bicycle - Handle cycling
     Background:
         Given the profile "bicycle"
 
-    Scenario: Bicycle - Use a ferry route
+    Scenario: Bicycle - Use a movable bridge
         Given the node map
             """
             a b   c

features/bicycle/safety.feature

@@ -2,10 +2,9 @@
 Feature: Bicycle - Adds penalties to unsafe roads
 
     Background:
-        Given the profile file
+        Given the profile file "bicycle" initialized with
         """
-        require 'bicycle'
-        properties.weight_name = 'cyclability'
+        profile.properties.weight_name = 'cyclability'
         """
 
     Scenario: Bike - Apply penalties to ways without cycleways

features/bicycle/turn_penalty.feature

@@ -7,10 +7,9 @@ Feature: Turn Penalties
 
 
     Scenario: Bicycle - Turn penalties on cyclability
-        Given the profile file
+        Given the profile file "bicycle" initialized with
         """
-        require 'bicycle'
-        properties.weight_name = 'cyclability'
+        profile.properties.weight_name = 'cyclability'
         """
 
         Given the node map

features/car/classes.feature

@@ -17,13 +17,13 @@ Feature: Car - Mode flag
             | cd    | primary |       |
 
         When I route I should get
-            | from | to | route       | turns                                              | classes      |
-            | a    | d  | ab,bc,cd,cd | depart,notification right,notification left,arrive | ,ferry,,     |
-            | d    | a  | cd,bc,ab,ab | depart,notification right,notification left,arrive | ,ferry,,     |
-            | c    | a  | bc,ab,ab    | depart,notification left,arrive                    | ferry,,      |
-            | d    | b  | cd,bc,bc    | depart,notification right,arrive                   | ,ferry,ferry |
-            | a    | c  | ab,bc,bc    | depart,notification right,arrive                   | ,ferry,ferry |
-            | b    | d  | bc,cd,cd    | depart,notification left,arrive                    | ferry,,      |
+            | from | to | route       | turns                                              | classes                  |
+            | a    | d  | ab,bc,cd,cd | depart,notification right,notification left,arrive | [()],[(ferry)],[()],[()] |
+            | d    | a  | cd,bc,ab,ab | depart,notification right,notification left,arrive | [()],[(ferry)],[()],[()] |
+            | c    | a  | bc,ab,ab    | depart,notification left,arrive                    | [(ferry)],[()],[()]      |
+            | d    | b  | cd,bc,bc    | depart,notification right,arrive                   | [()],[(ferry)],[()]      |
+            | a    | c  | ab,bc,bc    | depart,notification right,arrive                   | [()],[(ferry)],[()]      |
+            | b    | d  | bc,cd,cd    | depart,notification left,arrive                    | [(ferry)],[()],[()]      |
 
 
     Scenario: Car - We tag motorways with a class
@@ -40,10 +40,10 @@ Feature: Car - Mode flag
             | cd    | primary |
 
         When I route I should get
-            | from | to | route    | turns                            | classes            | #                                           |
-            | a    | d  | ab,bc,cd | depart,notification right,arrive | ,motorway,         |                                             |
-            | a    | c  | ab,bc,bc | depart,notification right,arrive | ,motorway,motorway |                                             |
-            | b    | d  | bc,cd    | depart,arrive                    | motorway,          | we don't announce when we leave the highway |
+            | from | to | route    | turns         | classes                 |
+            | a    | d  | ab,cd    | depart,arrive | [(),(motorway),()],[()] |
+            | a    | c  | ab,bc    | depart,arrive | [(),(motorway)],[()]    |
+            | b    | d  | bc,cd    | depart,arrive | [(motorway),()],[()]    |
 
     Scenario: Car - We tag motorway_link with a class
         Given the node map
@@ -59,10 +59,10 @@ Feature: Car - Mode flag
             | cd    | primary       |
 
         When I route I should get
-            | from | to | route    | turns                       | classes            | #                                |
-            | a    | d  | ab,bc,cd | depart,on ramp right,arrive | ,motorway,         | notification replaced by on-ramp |
-            | a    | c  | ab,bc,bc | depart,on ramp right,arrive | ,motorway,motorway |    "                "            |
-            | b    | d  | bc,cd    | depart,arrive               | motorway,          | no announcement                  |
+            | from | to | route    | turns                       | classes                   | #                                |
+            | a    | d  | ab,bc,cd | depart,on ramp right,arrive | [()],[(motorway),()],[()] | on-ramp at class change          |
+            | a    | c  | ab,bc,bc | depart,on ramp right,arrive | [()],[(motorway)],[()]    |    "                "            |
+            | b    | d  | bc,cd    | depart,arrive               | [(motorway),()],[()]      | no announcement                  |
 
 
     Scenario: Car - We tag restricted with a class
@@ -79,8 +79,8 @@ Feature: Car - Mode flag
             | cd    | primary |          |
 
         When I route I should get
-            | from | to | route    | turns                           | classes                         |
-            | a    | d  | ab,bc,cd | depart,notification right,arrive| restricted,motorway;restricted, |
+            | from | to | route | turns        | classes                                      |
+            | a    | d  | ab,cd | depart,arrive| [(restricted),(motorway,restricted),()],[()] |
 
     Scenario: Car - We toll restricted with a class
         Given the node map
@@ -96,6 +96,32 @@ Feature: Car - Mode flag
             | cd    | primary |          |
 
         When I route I should get
-            | from | to | route    | turns                            | classes             |
-            | a    | d  | ab,bc,cd | depart,notification right,arrive | toll,motorway;toll, |
+            | from | to | route    | turns         | classes                          |
+            | a    | d  | ab,cd    | depart,arrive | [(toll),(motorway,toll),()],[()] |
+
+    Scenario: Car - From roundabout on toll road
+        Given the node map
+            """
+                     c
+                  /     \
+            a---b         d---f
+                  \     /
+                     e
+                     |
+                     g
+            """
+
+        And the ways
+            | nodes | oneway | highway | junction   | toll     |
+            | ab    | yes    | primary |            |          |
+            | cb    | yes    | primary | roundabout |          |
+            | dc    | yes    | primary | roundabout |          |
+            | be    | yes    | primary | roundabout |          |
+            | ed    | yes    | motorway| roundabout |          |
+            | eg    | yes    | primary |            |          |
+            | df    | yes    | motorway|            | yes      |
+
+        When I route I should get
+            | from | to | route    | turns                           | classes                                   |
+            | a    | f  | ab,df,df | depart,roundabout-exit-2,arrive | [()],[(),(motorway),(toll,motorway)],[()] |
 

features/car/conditional_restrictions.feature

@@ -739,3 +739,45 @@ Feature: Car - Turn restrictions
             | from | to | route                       | turns                                            |
             | a    | c  | albic,dobe,dobe,albic,albic | depart,turn left,continue uturn,turn left,arrive |
             | a    | e  | albic,dobe,dobe             | depart,turn left,arrive                          |
+
+    @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   f
+            |   |
+            b - e - h
+            |   |   |
+            c   d - g
+                  1
+            """
+
+        And the ways
+            | nodes |
+            | ab    |
+            | bc    |
+            | de    |
+            | ef    |
+            | be    |
+            | eh    |
+            | gh    |
+            | dg    |
+
+        And the relations
+            | type        | way:from | way:to | way:via | restriction:conditional                    |
+            | restriction | ab       | be     | ef      | no_uturn @ (Mo-Fr 07:00-11:00,16:00-18:30) |
+
+        And the relations
+            | type        | way:from | way:to | node:via | restriction:conditional                    |
+            | restriction | ed       | dg     | d        | no_uturn @ (Mo-Fr 07:00-11:00,16:00-18:30) |
+
+        When I route I should get
+            | from | to | route          | #                                                                                         |
+            | a    | f  | ab,be,ef,ef    | currently we do not handle conditional via-ways, this test will have to change when we do |
+            | f    | 1  | ef,eh,gh,dg,dg |                                                                                           |
+

features/car/construction.feature

@@ -0,0 +1,17 @@
+@routing @car @construction
+Feature: Car - all construction tags the OpenStreetMap community could think of and then some
+
+    Background:
+        Given the profile "car"
+
+    Scenario: Various ways to tag construction and proposed roads
+        Then routability should be
+            | highway      | construction | proposed | bothw |
+            | primary      |              |          | x     |
+            | construction |              |          |       |
+            | proposed     |              |          |       |
+            | primary      |          yes |          |       |
+            | primary      |              |     yes  |       |
+            | primary      |           no |          | x     |
+            | primary      |     widening |          | x     |
+            | primary      |        minor |          | x     |

features/car/destination.feature

@@ -23,11 +23,11 @@ Feature: Car - Destination only, no passing through
         When I route I should get
             | from | to | route      |
             | a    | b  | ab,ab      |
-            | a    | c  | ab,bcd,bcd |
+            | a    | c  | ab,bcd     |
             | a    | d  | ab,bcd,bcd |
             | a    | e  | axye,axye  |
             | e    | d  | de,de      |
-            | e    | c  | de,bcd,bcd |
+            | e    | c  | de,bcd     |
             | e    | b  | de,bcd,bcd |
             | e    | a  | axye,axye  |
 
@@ -51,12 +51,12 @@ Feature: Car - Destination only, no passing through
         When I route I should get
             | from | to | route       |
             | a    | b  | ab,ab       |
-            | a    | c  | ab,bc,bc    |
-            | a    | d  | ab,bc,cd    |
+            | a    | c  | ab,bc       |
+            | a    | d  | ab,cd       |
             | a    | e  | axye,axye   |
             | e    | d  | de,de       |
-            | e    | c  | de,cd,cd    |
-            | e    | b  | de,cd,bc    |
+            | e    | c  | de,cd       |
+            | e    | b  | de,bc       |
             | e    | a  | axye,axye   |
 
     Scenario: Car - Routing inside a destination only area

features/car/restrictions.feature

@@ -506,3 +506,488 @@ Feature: Car - Turn restrictions
             | s    | n  | sj,nj,nj |
             | s    | e  | sj,ej,ej |
 
+    @restriction @compression
+    Scenario: Restriction On Compressed Geometry
+        Given the node map
+            """
+                        i
+                        |
+                    f - e
+                    |   |
+            a - b - c - d
+                    |
+                    g
+                    |
+                    h
+            """
+
+        And the ways
+            | nodes |
+            | abc   |
+            | cde   |
+            | efc   |
+            | cgh   |
+            | ei    |
+
+        And the relations
+            | type        | way:from | node:via | way:to | restriction   |
+            | restriction | abc      | c        | cgh    | no_right_turn |
+
+        When I route I should get
+            | from | to | route               |
+            | a    | h  | abc,cde,efc,cgh,cgh |
+
+    @restriction-way
+    Scenario: Car - prohibit turn
+        Given the node map
+            """
+            c
+            |
+            |   f
+            |   |
+            b---e
+            |   |
+            a   d
+            """
+
+        And the ways
+            | nodes |
+            | ab    |
+            | bc    |
+            | be    |
+            | de    |
+            | ef    |
+
+        And the relations
+            | type        | way:from | way:via | way:to | restriction   |
+            | restriction | ab       | be      | de     | no_right_turn |
+
+        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 |
+            | a    | f  | ab,be,ef,ef       | depart,turn right,turn left,arrive                                  | a,b,e,f     |
+            | c    | d  | bc,be,de,de       | depart,turn left,turn right,arrive                                  | c,b,e,d     |
+            | c    | f  | bc,be,ef,ef       | depart,turn left,turn left,arrive                                   | c,b,e,f     |
+
+    @restriction @overlap
+    Scenario: Car - prohibit turn
+        Given the node map
+            """
+            c
+            |
+            |   f
+            |   |
+            b---e
+            |   |
+            |   d
+            |
+            a
+            """
+
+        And the ways
+            | nodes |
+            | ab    |
+            | bc    |
+            | be    |
+            | de    |
+            | ef    |
+
+        And the relations
+            | type        | way:from | way:via | way:to | restriction   |
+            | restriction | ab       | be      | de     | no_right_turn |
+            | restriction | bc       | be      | ef     | no_left_turn  |
+
+        When I route I should get
+            | from | to | route             |
+            | a    | d  | ab,be,ef,ef,de,de |
+            | a    | f  | ab,be,ef,ef       |
+            | c    | d  | bc,be,de,de       |
+            | c    | f  | bc,be,de,de,ef,ef |
+
+    @restriction-way @overlap
+    Scenario: Two times same way
+        Given the node map
+            """
+                h   g
+                |   |
+                |   |
+                |   |
+                |   |
+                |   |
+                |   |
+                |   |
+                |   |
+                |   |
+                |   |
+                |   |
+                |   |
+                |   |
+                |   |
+                |   |
+                |   |
+                |   |
+                |   |
+                |   |
+                |   |
+                |   |
+                |   |
+                |   |
+                |   |
+                |   |
+                |   |
+            a - b - c - - - - - - - - - - - - - - - - - - - f
+                |   | \                                     /
+                i - d - e - - - - - - - - - - - - - - - - -
+            """
+        # The long distances here are required to make other turns undesriable in comparison to the restricted turns.
+        # Otherwise they might just be picked without the actual turns being restricted
+
+        And the ways
+            | nodes | oneway |
+            | ab    | no     |
+            | bc    | no     |
+            | cd    | yes    |
+            | ce    | yes    |
+            | cf    | yes    |
+            | cg    | yes    |
+            | bh    | no     |
+            | fedib | yes    |
+
+       And the relations
+            | type        | way:from | way:via | way:to | restriction   |
+            | restriction | ab       | bc      | ce     | no_right_turn |
+            | restriction | ab       | bc      | cd     | no_right_turn |
+
+       When I route I should get
+            | from | to | route                |
+            | a    | i  | ab,bc,cf,fedib,fedib |
+
+
+    @restriction-way @overlap
+    Scenario: Car - prohibit turn
+        Given the node map
+            """
+            a   j
+            |   |
+            b---i
+            |   |
+            c---h
+            |   |
+            d---g
+            |   |
+            e   f
+            """
+
+        And the ways
+            | nodes | name   | oneway |
+            | ab    | left   | yes    |
+            | bc    | left   | yes    |
+            | cd    | left   | yes    |
+            | de    | left   | yes    |
+            | fg    | right  | yes    |
+            | gh    | right  | yes    |
+            | hi    | right  | yes    |
+            | ij    | right  | yes    |
+            | dg    | first  | no     |
+            | ch    | second | no     |
+            | bi    | third  | no     |
+
+        And the relations
+            | type        | way:from | way:via | way:to | restriction   |
+            | restriction | ab       | bi      | ij     | no_u_turn     |
+            | restriction | bc       | ch      | hi     | no_u_turn     |
+            | restriction | fg       | dg      | de     | no_u_turn     |
+            | restriction | gh       | ch      | cd     | no_u_turn     |
+
+        When I route I should get
+            | from | to | route                  |
+            | a    | j  | left,first,right,right |
+            | f    | e  | right,third,left,left  |
+
+    @restriction
+    Scenario: Car - allow only turn
+        Given the node map
+            """
+            c
+            |
+            |   f
+            |   |
+            b---e
+            |   |
+            a   d
+            """
+
+        And the ways
+            | nodes |
+            | ab    |
+            | bc    |
+            | be    |
+            | de    |
+            | ef    |
+
+        And the relations
+            | type        | way:from | way:via | way:to | restriction  |
+            | restriction | ab       | be      | ef     | only_left_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 |
+            | a    | f  | ab,be,ef,ef       | depart,turn right,turn left,arrive                                  | a,b,e,f     |
+            | c    | d  | bc,be,de,de       | depart,turn left,turn right,arrive                                  | c,b,e,d     |
+            | c    | f  | bc,be,ef,ef       | depart,turn left,turn left,arrive                                   | c,b,e,f     |
+
+    @restriction
+    Scenario: Car - allow only turn
+        Given the node map
+            """
+            c
+            |
+            |   f
+            |   |
+            b---e
+            |   |
+            a   d
+            """
+
+        And the ways
+            | nodes |
+            | ab    |
+            | bc    |
+            | be    |
+            | de    |
+            | ef    |
+
+        And the relations
+            | type        | way:from | way:via | way:to | restriction   |
+            | restriction | ab       | be      | ed     | only_right_on |
+
+        When I route I should get
+            | from | to | route       |
+            | a    | d  | ab,be,de,de |
+
+    @restriction
+    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
+    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
+    Scenario: Car - prohibit turn, traffic lights
+        Given the node map
+            """
+            c
+            |
+            |   f
+            |   |
+            b---e
+            |   |
+            a   d
+            |   |
+            g   i
+            |   |
+            h   j
+            """
+
+        And the ways
+            | nodes | name |
+            | hgab  | ab   |
+            | bc    | bc   |
+            | be    | be   |
+            | jide  | de   |
+            | ef    | ef   |
+
+        And the relations
+            | type        | way:from | way:via | way:to | restriction   |
+            | restriction | hgab     | be      | jide   | no_right_turn |
+
+        And the nodes
+            | node | highway         |
+            | g    | traffic_signals |
+            | i    | traffic_signals |
+
+
+        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 |
+            | a    | f  | ab,be,ef,ef       | depart,turn right,turn left,arrive                                  | a,b,e,f     |
+            | c    | d  | bc,be,de,de       | depart,turn left,turn right,arrive                                  | c,b,e,d     |
+            | c    | f  | bc,be,ef,ef       | depart,turn left,turn left,arrive                                   | c,b,e,f     |
+
+
+      @restriction @overlap @geometry
+      Scenario: Geometry
+        Given the node map
+            """
+            c
+            |
+            |   f
+            |   |
+            b-g-e
+            |   |
+            |   d
+            |
+            a
+            """
+
+        And the ways
+            | nodes |
+            | ab    |
+            | bc    |
+            | bge   |
+            | de    |
+            | ef    |
+
+        And the relations
+            | type        | way:from | way:via | way:to | restriction   |
+            | restriction | ab       | bge     | de     | no_right_turn |
+            | restriction | bc       | bge     | ef     | no_left_turn  |
+
+        When I route I should get
+            | from | to | route              |
+            | a    | d  | ab,bge,ef,ef,de,de |
+            | a    | f  | ab,bge,ef,ef       |
+            | c    | d  | bc,bge,de,de       |
+            | c    | f  | bc,bge,de,de,ef,ef |
+
+      @restriction @overlap @geometry @traffic-signals
+      Scenario: Geometry
+        Given the node map
+            """
+            c
+            |
+            |   f
+            |   |
+            b-g-e
+            |   |
+            |   d
+            |
+            a
+            """
+
+        And the ways
+            | nodes |
+            | ab    |
+            | bc    |
+            | bge   |
+            | de    |
+            | ef    |
+
+        And the nodes
+            | node | highway         |
+            | g    | traffic_signals |
+
+        And the relations
+            | type        | way:from | way:via | way:to | restriction   |
+            | 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,de,de |
+            | a    | f  | ab,bge,ef,ef |
+            | c    | d  | bc,bge,de,de |
+            | c    | f  | bc,bge,ef,ef |
+
+      # don't crash hard on invalid restrictions
+      @restriction @invalid
+      Scenario: Geometry
+        Given the node map
+            """
+            c
+            |
+            |   f
+            |   |
+            b---e
+            |   |
+            |   d
+            |
+            a
+            """
+
+        And the ways
+            | nodes | oneway |
+            | ab    |        |
+            | bc    |        |
+            | be    | yes    |
+            | de    |        |
+            | ef    |        |
+
+        And the relations
+            | type        | way:from | way:via | way:to | restriction   |
+            | restriction | de       | be      | ab     | no_left_turn  |
+
+        When I route I should get
+            | from | to | route       |
+            | a    | f  | ab,be,ef,ef |

features/car/side_bias.feature

@@ -1,18 +1,11 @@
 @routing @testbot @sidebias
 Feature: Testbot - side bias
 
-    Background:
-        Given the profile file
+    Scenario: Left-hand bias
+        Given the profile file "car" initialized with
         """
-        require 'testbot'
-        properties.left_hand_driving = true
-        """
-
-    Scenario: Left hand bias
-        Given the profile file "car" extended with
-        """
-        properties.left_hand_driving = true
-        profile.turn_bias = properties.left_hand_driving and 1/1.075 or 1.075
+        profile.left_hand_driving = true
+        profile.turn_bias = 1/1.075
         """
         Given the node map
             """
@@ -31,11 +24,11 @@ Feature: Testbot - side bias
             | d    | a  | bd,ab,ab | 24s +-1    |
             | d    | c  | bd,bc,bc | 27s +-1    |
 
-    Scenario: Right hand bias
-        Given the profile file "car" extended with
+    Scenario: Right-hand bias
+        Given the profile file "car" initialized with
         """
-        properties.left_hand_driving = false
-        profile.turn_bias = properties.left_hand_driving and 1/1.075 or 1.075
+        profile.left_hand_driving = true
+        profile.turn_bias = 1.075
         """
         And the node map
             """
@@ -56,6 +49,11 @@ Feature: Testbot - side bias
             | d    | c  | bd,bc,bc | 24s +-1    |
 
     Scenario: Roundabout exit counting for left sided driving
+        Given the profile file "testbot" initialized with
+        """
+        profile.left_hand_driving = true
+        profile.turn_bias = 1/1.075
+        """
         And a grid size of 10 meters
         And the node map
             """

features/car/weight.feature

@@ -1,11 +1,9 @@
 @routing @car @weight
 Feature: Car - weights
 
-    Background: Use specific speeds
-        Given the profile "car"
-
     Scenario: Only routes down service road when that's the destination
-        Given the node map
+        Given the profile "car"
+        And the node map
             """
             a--b--c
                |
@@ -25,7 +23,8 @@ Feature: Car - weights
             | a    | d  | abc,bdf,bdf    | 18 km/h | 71.7   |
 
     Scenario: Does not jump off the highway to go down service road
-        Given the node map
+        Given the profile "car"
+        And the node map
             """
             a
             |
@@ -63,10 +62,9 @@ Feature: Car - weights
             | a    | e  | ab,be,be    | 14 km/h | 112    |
 
     Scenario: Distance weights
-        Given the profile file "car" extended with
+        Given the profile file "car" initialized with
         """
-        api_version = 1
-        properties.weight_name = 'distance'
+        profile.properties.weight_name = 'distance'
         """
 
         Given the node map

features/guidance/advanced-lanes.feature

@@ -35,10 +35,10 @@ Feature: Turn Lane Guidance
             | restriction | bc       | cd     | c        | no_right_turn |
 
        When I route I should get
-            | waypoints | route                | turns                           | lanes                      |
-            | a,e       | in,cross,cross       | depart,turn left,arrive         | ,left:true straight:false, |
-            | a,g       | in,straight,straight | depart,new name straight,arrive | ,left:false straight:true, |
-            | a,f       | in,cross,cross       | depart,continue right,arrive    | ,,                         |
+            | waypoints | route                | turns                           | lanes                       |
+            | a,e       | in,cross,cross       | depart,turn left,arrive         | ;,left:true straight:false, |
+            | a,g       | in,straight,straight | depart,new name straight,arrive | ;,left:false straight:true, |
+            | a,f       | in,cross,cross       | depart,continue right,arrive    | ,;right:true,               |
 
     @sliproads
     Scenario: Separate Turn Lanes
@@ -68,10 +68,10 @@ Feature: Turn Lane Guidance
             | restriction | bc       | cd     | c        | no_right_turn |
 
        When I route I should get
-            | waypoints | route                | turns                           | lanes                                  |
-            | a,e       | in,cross,cross       | depart,turn left,arrive         | ,left:true straight:false right:false, |
-            | a,g       | in,straight,straight | depart,new name straight,arrive | ,left:false straight:true right:false, |
-            | a,f       | in,cross,cross       | depart,turn right,arrive        | ,left:false straight:false right:true, |
+            | waypoints | route                | turns                           | lanes                                                                       |
+            | a,e       | in,cross,cross       | depart,turn left,arrive         | ;,left:true straight:false right:false,                                     |
+            | a,g       | in,straight,straight | depart,new name straight,arrive | ;,left:false straight:true right:false,                                     |
+            | a,f       | in,cross,cross       | depart,turn right,arrive        | ,left:false straight:false right:true;left:false straight:false right:true, |
 
 
     @sliproads
@@ -109,12 +109,12 @@ Feature: Turn Lane Guidance
             | restriction | bc       | cd     | c        | no_right_turn |
 
        When I route I should get
-            | waypoints | route                | turns                               | lanes                                  |
-            | a,e       | in,cross,cross       | depart,turn left,arrive             | ,left:true straight:false right:false, |
-            | a,g       | in,straight,straight | depart,new name straight,arrive     | ,left:false straight:true right:false, |
-            | a,f       | in,cross,cross       | depart,turn right,arrive            | ,left:false straight:false right:true, |
-            | a,j       | in,turn,other,other  | depart,turn right,turn left,arrive  | ,,left:true right:false,               |
-            | a,i       | in,turn,other,other  | depart,turn right,turn right,arrive | ,,left:false right:true,               |
+            | waypoints | route                | turns                               | lanes                                                                       |
+            | a,e       | in,cross,cross       | depart,turn left,arrive             | ;,left:true straight:false right:false,                                     |
+            | a,g       | in,straight,straight | depart,new name straight,arrive     | ;,left:false straight:true right:false,                                     |
+            | a,f       | in,cross,cross       | depart,turn right,arrive            | ,left:false straight:false right:true;left:false straight:false right:true, |
+            | a,j       | in,turn,other,other  | depart,turn right,turn left,arrive  | ,,left:true right:false,                                                    |
+            | a,i       | in,turn,other,other  | depart,turn right,turn right,arrive | ,,left:false right:true,                                                    |
 
 
     @todo @2654 @none

features/guidance/anticipate-lanes.feature

@@ -3,7 +3,7 @@ Feature: Turn Lane Guidance
 
     Background:
         Given the profile "car"
-        Given a grid size of 20 meters
+        Given a grid size of 100 meters
 
     @anticipate
     Scenario: Anticipate Lane Change for subsequent multi-lane intersections
@@ -151,9 +151,9 @@ Feature: Turn Lane Guidance
             | cj    |                    | 1     | motorway_link | yes    | xbcj |
 
        When I route I should get
-            | waypoints | route        | turns                           | lanes                          |
-            | a,i       | ab,ci,ci     | depart,turn slight right,arrive | ,none:false slight right:true, |
-            | a,j       | ab,xbcj      | depart,arrive                   | ,                              |
+            | waypoints | route        | turns                           | lanes                           |
+            | a,i       | ab,ci,ci     | depart,turn slight right,arrive | ;,none:false slight right:true, |
+            | a,j       | ab,xbcj      | depart,arrive                   | ;;none:true slight right:false, |
 
 
     @anticipate
@@ -308,8 +308,8 @@ Feature: Turn Lane Guidance
                | di    |                                        | off  |             | yes    |
 
           When I route I should get
-               | waypoints | route          | turns                           | destinations  | lanes                                                                | locations |
-               | a,e       | main,main,main | depart,use lane straight,arrive | One,Two,Three | ,left:false straight:false straight:true straight:false right:false, | a,c,e     |
+               | waypoints | route     | turns         | destinations | locations | lanes                                                                                                     |
+               | a,e       | main,main | depart,arrive | One,Three    | a,e       | ;left:false straight:false straight:true straight:false right:false;left:false straight:true right:false, |
 
        @anticipate
        Scenario: Anticipate Lanes for through and collapse multiple use lanes
@@ -335,9 +335,9 @@ Feature: Turn Lane Guidance
                | dj    |                                        | off  |
 
           When I route I should get
-               | waypoints | route     | turns         | lanes |
-               | a,c       | main,main | depart,arrive | ,     |
-               | a,d       | main,main | depart,arrive | ,     |
+               | waypoints | route     | turns         | lanes                                                                                                   |
+               | a,c       | main,main | depart,arrive | ;left:false straight:true straight:true right:false,                                                    |
+               | a,d       | main,main | depart,arrive | ;left:false straight:true straight:true right:false;left:false straight:true straight:true right:false, |
 
        @anticipate
        Scenario: Anticipate Lanes for through followed by left/right
@@ -363,17 +363,17 @@ Feature: Turn Lane Guidance
                | ci    |                                                 | off   |
 
           When I route I should get
-               | waypoints | route                      | turns                                                        | lanes                                                                                                                                                         |
-               | a,d       | main,main,main,left,left   | depart,use lane straight,use lane straight,turn left,arrive  | ,left:false straight:false straight:true straight:false straight:false right:false,left:false straight:true straight:false right:false,left:true right:false, |
-               | a,e       | main,main,main,right,right | depart,use lane straight,use lane straight,turn right,arrive | ,left:false straight:false straight:false straight:true straight:false right:false,left:false straight:false straight:true right:false,left:false right:true, |
+               | waypoints | route            | turns                           | lanes                                                                                                                                                         |
+               | a,d       | main,left,left   | depart,end of road left,arrive  | ;left:false straight:false straight:true straight:false straight:false right:false;left:false straight:true straight:false right:false,left:true right:false, |
+               | a,e       | main,right,right | depart,end of road right,arrive | ;left:false straight:false straight:false straight:true straight:false right:false;left:false straight:false straight:true right:false,left:false right:true, |
 
        @anticipate
        Scenario: Anticipate Lanes for through with turn before / after
            Given the node map
                """
-               c       g       l
-               b – d – e – h - i
-               a       f       j
+               c   g   l
+               b d e h i
+               a   f   j
                """
 
            And the ways
@@ -390,15 +390,15 @@ Feature: Turn Lane Guidance
                | il    |                                                              | il    |        |
 
           When I route I should get
-               | waypoints | route                | turns                                                 | lanes                                                                                                                                                                                               | #           |
-               | a,f       | ab,bdehi,ef,ef       | depart,turn right,turn right,arrive                   | ,right:false right:false right:true right:true,left:false left:false straight:false straight:false straight:false straight:false right:true right:true,                                             |             |
-               | a,g       | ab,bdehi,eg,eg       | depart,turn right,turn left,arrive                    | ,right:true right:true right:false right:false,left:true left:true straight:false straight:false straight:false straight:false right:false right:false,                                             |             |
-               | a,j       | ab,bdehi,bdehi,ij,ij | depart,turn right,use lane straight,turn right,arrive | ,right:true right:true right:false right:false,left:false left:false straight:false straight:false straight:true straight:true right:false right:false,left:false left:false right:true right:true, |             |
-               | a,l       | ab,bdehi,bdehi,il,il | depart,turn right,use lane straight,turn left,arrive  | ,right:false right:false right:true right:true,left:false left:false straight:true straight:true straight:false straight:false right:false right:false,left:true left:true right:false right:false, | not perfect |
-               | c,g       | cb,bdehi,eg,eg       | depart,turn left,turn left,arrive                     | ,left:true left:true left:false left:false,left:true left:true straight:false straight:false straight:false straight:false right:false right:false,                                                 |             |
-               | c,f       | cb,bdehi,ef,ef       | depart,turn left,turn right,arrive                    | ,left:false left:false left:true left:true,left:false left:false straight:false straight:false straight:false straight:false right:true right:true,                                                 |             |
-               | c,l       | cb,bdehi,bdehi,il,il | depart,turn left,use lane straight,turn left,arrive   | ,left:false left:false left:true left:true,left:false left:false straight:true straight:true straight:false straight:false right:false right:false,left:true left:true right:false right:false,     |             |
-               | c,j       | cb,bdehi,bdehi,ij,ij | depart,turn left,use lane straight,turn right,arrive  | ,left:true left:true left:false left:false,left:false left:false straight:false straight:false straight:true straight:true right:false right:false,left:false left:false right:true right:true,     | not perfect |
+               | waypoints | route          | turns                                      | lanes                                                                                                                                                                                               | #           |
+               | a,f       | ab,bdehi,ef,ef | depart,turn right,turn right,arrive        | ,right:false right:false right:true right:true,left:false left:false straight:false straight:false straight:false straight:false right:true right:true,                                             |             |
+               | a,g       | ab,bdehi,eg,eg | depart,turn right,turn left,arrive         | ,right:true right:true right:false right:false,left:true left:true straight:false straight:false straight:false straight:false right:false right:false,                                             |             |
+               | a,j       | ab,bdehi,ij,ij | depart,turn right,end of road right,arrive | ,right:true right:true right:false right:false;left:false left:false straight:false straight:false straight:true straight:true right:false right:false,left:false left:false right:true right:true, |             |
+               | a,l       | ab,bdehi,il,il | depart,turn right,end of road left,arrive  | ,right:false right:false right:true right:true;left:false left:false straight:true straight:true straight:false straight:false right:false right:false,left:true left:true right:false right:false, | not perfect |
+               | c,g       | cb,bdehi,eg,eg | depart,turn left,turn left,arrive          | ,left:true left:true left:false left:false,left:true left:true straight:false straight:false straight:false straight:false right:false right:false,                                                 |             |
+               | c,f       | cb,bdehi,ef,ef | depart,turn left,turn right,arrive         | ,left:false left:false left:true left:true,left:false left:false straight:false straight:false straight:false straight:false right:true right:true,                                                 |             |
+               | c,l       | cb,bdehi,il,il | depart,turn left,end of road left,arrive   | ,left:false left:false left:true left:true;left:false left:false straight:true straight:true straight:false straight:false right:false right:false,left:true left:true right:false right:false,     |             |
+               | c,j       | cb,bdehi,ij,ij | depart,turn left,end of road right,arrive  | ,left:true left:true left:false left:false;left:false left:false straight:false straight:false straight:true straight:true right:false right:false,left:false left:false right:true right:true,     | not perfect |
 
        @anticipate
        Scenario: Anticipate Lanes for turns with through before and after
@@ -431,11 +431,11 @@ Feature: Turn Lane Guidance
                | jk    |                                                 | bot  | primary | yes    |
 
           When I route I should get
-               | waypoints | route                 | turns                                                  | lanes                                                                                                                                                                           |
-               | a,i       | top,main,main,top,top | depart,turn right,use lane straight,turn left,arrive   | ,straight:false right:false right:true right:true,left:false straight:true straight:true straight:false straight:false right:false,left:true left:true right:false right:false, |
-               | a,k       | top,main,main,bot,bot | depart,turn right,use lane straight,turn right,arrive  | ,straight:false right:true right:true right:false,left:false straight:false straight:false straight:true straight:true right:false,left:false left:false right:true right:true, |
-               | c,i       | bot,main,main,top,top | depart,turn left,use lane straight,turn left,arrive    | ,left:false left:true left:true straight:false,left:false straight:true straight:true straight:false straight:false right:false,left:true left:true right:false right:false,    |
-               | c,k       | bot,main,main,bot,bot | depart,turn left,use lane straight,turn right,arrive   | ,left:true left:true left:false straight:false,left:false straight:false straight:false straight:true straight:true right:false,left:false left:false right:true right:true,    |
+               | waypoints | route            | turns                                | lanes                                                                                                                                                                           |
+               | a,i       | top,main,top,top | depart,turn right,turn left,arrive   | ,straight:false right:true right:true right:true;;left:false straight:true straight:true straight:false straight:false right:false,left:true left:true right:false right:false, |
+               | a,k       | top,main,bot,bot | depart,turn right,turn right,arrive  | ,straight:false right:true right:true right:true;;left:false straight:false straight:false straight:true straight:true right:false,left:false left:false right:true right:true, |
+               | c,i       | bot,main,top,top | depart,turn left,turn left,arrive    | ,left:true left:true left:true straight:false;;left:false straight:true straight:true straight:false straight:false right:false,left:true left:true right:false right:false,    |
+               | c,k       | bot,main,bot,bot | depart,turn left,turn right,arrive   | ,left:true left:true left:true straight:false;;left:false straight:false straight:false straight:true straight:true right:false,left:false left:false right:true right:true,    |
 
        @anticipate
        Scenario: Anticipate Lanes for turn between throughs
@@ -462,8 +462,8 @@ Feature: Turn Lane Guidance
                | dt    |                                                          | off  |
 
           When I route I should get
-               | waypoints | route               | turns                                          | lanes                                                                                                                                                             |
-               | a,e       | main,main,main,main | depart,use lane straight,continue right,arrive | ,left:false straight:false straight:false straight:false straight:true straight:true right:false,straight:false straight:false right:false right:true right:true, |
+               | waypoints | route          | turns                        | lanes                                                                                                                                                                                                    |
+               | a,e       | main,main,main | depart,continue right,arrive | ;left:false straight:false straight:false straight:false straight:true straight:true right:false,straight:false straight:false right:false right:true right:true;left:false straight:true straight:true, |
 
     @anticipate @todo @2661
     Scenario: Anticipate with lanes in roundabout: roundabouts as the unit of anticipation
@@ -520,8 +520,8 @@ Feature: Turn Lane Guidance
             | df    |                                        | primary |            |
 
         When I route I should get
-            | waypoints | route    | turns                                                 | lanes                                                    |
-            | a,f       | ab,df,df | depart,roundabout-exit-1,use lane slight right,arrive | ,,slight left:false slight left:false slight right:true, |
+            | waypoints | route    | turns                           | lanes | intersection_lanes |
+            | a,f       | ab,df,df | depart,roundabout-exit-1,arrive | ,, | |
 
     @anticipate
     Scenario: No Lanes for Roundabouts, see #2626
@@ -553,8 +553,8 @@ Feature: Turn Lane Guidance
             | fy    |                            | primary |            |
 
         When I route I should get
-            | waypoints | route    | turns                           | lanes |
-            | a,h       | ab,gh,gh | depart,roundabout-exit-5,arrive | ,,    |
+            | waypoints | route    | turns                           | lanes    |
+            | a,h       | ab,gh,gh | depart,roundabout-exit-5,arrive |  ,;;;;;, |
 
     @anticipate
     Scenario: No Lanes for Roundabouts, see #2626
@@ -576,15 +576,15 @@ Feature: Turn Lane Guidance
 
         When I route I should get
             | waypoints | route                    | turns                                   | lanes |
-            | x,y       | xb,dy,dy                 | depart,roundabout-exit-1,arrive         | ,,    |
+            | x,y       | xb,dy,dy                 | depart,roundabout-exit-1,arrive         | ,;,   |
             | x,c       | xb,roundabout,roundabout | depart,roundabout-exit-undefined,arrive | ,,    |
-            | x,a       | xb,roundabout,roundabout | depart,roundabout-exit-undefined,arrive | ,,    |
+            | x,a       | xb,roundabout,roundabout | depart,roundabout-exit-undefined,arrive | ,;,   |
 
     @anticipate
     Scenario: No Lanes for Roundabouts, see #2626
-        Given the profile file "car" extended with
+        Given the profile file "car" initialized with
         """
-        properties.left_hand_driving = true
+        profile.left_hand_driving = true
         """
         And the node map
             """
@@ -614,8 +614,8 @@ Feature: Turn Lane Guidance
             | fy    |                            | primary |            |
 
         When I route I should get
-            | waypoints | route      | turns                           | lanes |
-            | a,h       | ab,ch,ch   | depart,roundabout-exit-5,arrive | ,,    |
+            | waypoints | route      | turns                           | lanes      |
+            | a,h       | ab,ch,ch   | depart,roundabout-exit-5,arrive | ,;;;;;,    |
 
     @anticipate
     Scenario: No Lanes for Roundabouts, see #2626
@@ -623,40 +623,11 @@ Feature: Turn Lane Guidance
             """
                  /a\
             x – b   d – y
-                |   |
-                |   |
-                |   |
-                |   |
-                |   |
-                |   |
-                |   |
-                |   |
                 |   |
                 |   |
                  | |
                  | |
-                 | |
-                 | |
-                 | |
-                 | |
-                 | |
-                 | |
-                 | |
-                 | |
-                 | |
-                 | |
-                  |
-                  |
-                  |
-                  |
-                  |
-                  |
-                  |
-                  |
-                  |
-                  |
-                  |
-                  |
+                 \ /
                   c
             """
 
@@ -671,9 +642,9 @@ Feature: Turn Lane Guidance
 
         When I route I should get
             | waypoints | route                    | turns                                   | lanes |
-            | x,y       | xb,dy,dy                 | depart,roundabout-exit-1,arrive         | ,,    |
+            | x,y       | xb,dy,dy                 | depart,roundabout-exit-1,arrive         | ,;,   |
             | x,c       | xb,roundabout,roundabout | depart,roundabout-exit-undefined,arrive | ,,    |
-            | x,a       | xb,roundabout,roundabout | depart,roundabout-exit-undefined,arrive | ,,    |
+            | x,a       | xb,roundabout,roundabout | depart,roundabout-exit-undefined,arrive | ,;,   |
 
     @anticipate @todo @2032
     Scenario: No Lanes for Roundabouts, see #2626
@@ -789,13 +760,6 @@ Feature: Turn Lane Guidance
         Given the node map
             """
             a – b – x
-                |
-                |
-                |
-                |
-                |
-                |
-                |
                 |
                 |
                 |
@@ -823,11 +787,9 @@ Feature: Turn Lane Guidance
     Scenario: Don't Overdo It
         Given the node map
             """
-                                  q                     r                     s                     t                     u                     v
-                                  |                     |                     |                     |                     |                     |
-            a - - - - - - - - - - b - - - - - - - - - - c - - - - - - - - - - d - - - - - - - - - - e - - - - - - - - - - f - - - - - - - - - - g - h - i
-                                  |                     |                     |                     |                     |                     |   |
-                                  p                     o                     n                     m                     l                     k   j
+                  q     r     s     t     u   v
+            a - - b - - c - - d - - e - - f - g - h - i
+                  p     o     n     m     l   k   j
             """
 
         And the ways
@@ -849,6 +811,35 @@ Feature: Turn Lane Guidance
             | hj    | 7th  |                    | no     |
 
         When I route I should get
-            | waypoints | route             | turns                                      | locations | lanes                                                                         |
-            | a,i       | road,road,road    | depart,use lane straight,arrive            | a,g,i     | ,left:false none:true none:true none:false,                                   |
-            | a,j       | road,road,7th,7th | depart,use lane straight,turn right,arrive | a,f,h,j   | ,left:false none:false none:false none:true,none:false none:false right:true, |
+            | waypoints | route        | turns                    | locations | lanes                                                                                                                                                                                                                                                                                        |
+            | a,i       | road,road    | depart,arrive            | a,i       | ;left:false none:true none:true none:true;left:false none:true none:true none:true;left:false none:true none:true none:true;left:false none:true none:true none:true;left:false none:true none:true none:true;left:false none:true none:true none:false;none:true none:true right:false,     |
+            | a,j       | road,7th,7th | depart,turn right,arrive | a,h,j     | ;left:false none:true none:true none:true;left:false none:true none:true none:true;left:false none:true none:true none:true;left:false none:true none:true none:true;left:false none:false none:false none:true;left:false none:false none:false none:true,none:false none:false right:true, |
+
+    @anticipate
+    Scenario: Oak St, Franklin St
+        Given a grid size of 10 meters
+        Given the node map
+            """
+                   g
+                   .     . f
+                 . d `
+            e `    .
+                   .
+                   .
+                   .     . c
+                 . b `
+            a `
+
+            """
+
+        And the ways
+            | nodes | name        | turn:lanes                                  | oneway | highway   |
+            | ab    | Oak St      | left\|left\|left                            | yes    | secondary |
+            | cb    | Oak St      | right                                       | yes    | tertiary  |
+            | bd    | Franklin St | left;through\|through\|through;right\|right | yes    | secondary |
+            | dg    | Franklin St |                                             | yes    | secondary |
+            | edf   | Fell St     |                                             |        | secondary |
+
+        When I route I should get
+            | waypoints | route                              | turns                               | lanes                                                                                              |
+            | a,f       | Oak St,Franklin St,Fell St,Fell St | depart,turn left,turn right,arrive  | ,left:false left:true left:true,straight;left:false straight:false straight;right:true right:true, |

features/guidance/collapse.feature

@@ -807,8 +807,8 @@ Feature: Collapse
             | di    |                                        | off  |
 
        When I route I should get
-            | waypoints | route          | turns                           | locations |
-            | a,e       | main,main,main | depart,use lane straight,arrive | a,c,e     |
+            | waypoints | route     | turns         | locations | lanes                                                                                                     |
+            | a,e       | main,main | depart,arrive | a,e       | ;left:false straight:false straight:true straight:false right:false;left:false straight:true right:false, |
 
     Scenario: But _do_ collapse UseLane step when lanes stay the same
         Given the node map

features/guidance/exit-numbers-names.feature

@@ -41,8 +41,8 @@ Feature: Exit Numbers and Names
             | ef     | motorway_link | ExitRamp |              |
 
        When I route I should get
-            | waypoints | route                      | turns                               | exits   |
-            | a,f       | MainRoad,ExitRamp,ExitRamp | depart,off ramp slight right,arrive | ,10;12, |
+            | waypoints | route                      | turns                               | exits    |
+            | a,f       | MainRoad,ExitRamp,ExitRamp | depart,off ramp slight right,arrive | ,10; 12, |
 
 
     Scenario: Exit number on the ways after the motorway junction, multiple exits

features/guidance/motorway.feature

@@ -261,3 +261,23 @@ Feature: Motorway Guidance
        When I route I should get
             | waypoints | route               | turns                                           |
             | a,d       | On,Hwy,Off,Off      | depart,merge slight right,off ramp right,arrive |
+
+    #http://0.0.0.0:9966/?z=18&center=38.893323%2C-77.055117&loc=38.893551%2C-77.054833&loc=38.893112%2C-77.055536&hl=en&alt=0
+    Scenario: Merging with same name
+        Given the node map
+            """
+            a - - -
+                    > c - d
+                 b
+            """
+
+        And the ways
+            | nodes | name | ref         | highway  | oneway |
+            | ac    |      | US 50       | motorway | yes    |
+            | bc    |      | I 66        | motorway | yes    |
+            | cd    |      | US 50; I 66 | motorway | yes    |
+
+        When I route I should get
+            | waypoints | route | turns         |
+            | a,d       | ,     | depart,arrive |
+            | b,d       | ,     | depart,arrive |

features/guidance/roundabout-left-sided.feature

@@ -3,11 +3,10 @@ Feature: Basic Roundabout
 
     Background:
         Given a grid size of 10 meters
-        Given the profile file
-           """
-           require 'car'
-            properties.left_hand_driving = true
-           """
+        Given the profile file "car" initialized with
+            """
+            profile.properties.left_hand_driving = true
+            """
 
     Scenario: Roundabout exit counting for left sided driving
         And a grid size of 10 meters

features/guidance/roundabout-turn.feature

@@ -567,5 +567,5 @@ Feature: Basic Roundabout
             | ab    | residential   | in      |            |        |
 
         When I route I should get
-            | waypoints | turns                                                    | route                      |
-            | a,f       | depart,turn right,roundabout turn straight exit-1,arrive | in,through,through,through |
+            | waypoints | turns                    | route              |
+            | a,f       | depart,turn right,arrive | in,through,through |

features/guidance/roundabout.feature

@@ -606,11 +606,11 @@ Feature: Basic Roundabout
             | ob    | trunk       | yes    | roundabout | Europaplatz   |                                        |
 
        When I route I should get
-           | waypoints | route                        | turns                            | lanes |
-           | a,d       | ,Europastrasse,Europastrasse | depart,Europaplatz-exit-1,arrive | ,,    |
-           | a,h       | ,Allee Cite,Allee Cite       | depart,Europaplatz-exit-2,arrive | ,,    |
-           | a,l       | ,Europastrasse,Europastrasse | depart,Europaplatz-exit-3,arrive | ,,    |
-           | a,p       | ,,                           | depart,Europaplatz-exit-4,arrive | ,,    |
+           | waypoints | route                        | turns                            |
+           | a,d       | ,Europastrasse,Europastrasse | depart,Europaplatz-exit-1,arrive |
+           | a,h       | ,Allee Cite,Allee Cite       | depart,Europaplatz-exit-2,arrive |
+           | a,l       | ,Europastrasse,Europastrasse | depart,Europaplatz-exit-3,arrive |
+           | a,p       | ,,                           | depart,Europaplatz-exit-4,arrive |
 
     @turboroundabout
     # http://www.openstreetmap.org/?mlat=50.180039&mlon=8.474939&zoom=16#map=19/50.17999/8.47506
@@ -658,14 +658,14 @@ Feature: Basic Roundabout
             | wb    | primary      | yes    | roundabout |                              | through\|through;right             |
 
        When I route I should get
-           | waypoints | route                                                                      | turns                                   | lanes |
-           | a,w       | Le-Cannet-Rocheville-Strasse,,                                             | depart,roundabout-exit-undefined,arrive | ,,    |
-           | a,r       | Le-Cannet-Rocheville-Strasse,,                                             | depart,roundabout-exit-4,arrive         | ,,    |
-           | a,f       | Le-Cannet-Rocheville-Strasse,Frankfurter Strasse,Frankfurter Strasse       | depart,roundabout-exit-1,arrive         | ,,    |
-           | a,h       | Le-Cannet-Rocheville-Strasse,Bischof-Kaller-Strasse,Bischof-Kaller-Strasse | depart,roundabout-exit-2,arrive         | ,,    |
-           | u,r       | ,,                                                                         | depart,roundabout-exit-5,arrive         | ,,    |
-           | j,h       | Bischof-Kaller-Strasse,Bischof-Kaller-Strasse,Bischof-Kaller-Strasse       | depart,roundabout-exit-5,arrive         | ,,    |
-           | n,m       | ,                                                                          | depart,arrive                           | ,     |
+           | waypoints | route                                                                      | turns                                   |
+           | a,w       | Le-Cannet-Rocheville-Strasse,,                                             | depart,roundabout-exit-undefined,arrive |
+           | a,r       | Le-Cannet-Rocheville-Strasse,,                                             | depart,roundabout-exit-4,arrive         |
+           | a,f       | Le-Cannet-Rocheville-Strasse,Frankfurter Strasse,Frankfurter Strasse       | depart,roundabout-exit-1,arrive         |
+           | a,h       | Le-Cannet-Rocheville-Strasse,Bischof-Kaller-Strasse,Bischof-Kaller-Strasse | depart,roundabout-exit-2,arrive         |
+           | u,r       | ,,                                                                         | depart,roundabout-exit-5,arrive         |
+           | j,h       | Bischof-Kaller-Strasse,Bischof-Kaller-Strasse,Bischof-Kaller-Strasse       | depart,roundabout-exit-5,arrive         |
+           | n,m       | ,                                                                          | depart,arrive                           |
 
     @turboroundabout
     # http://www.openstreetmap.org/?mlat=47.57723&mlon=7.796765&zoom=16#map=19/47.57720/7.79711
@@ -763,7 +763,7 @@ Feature: Basic Roundabout
 
         When I route I should get
            | waypoints | bearings | route       | turns                           |
-           | e,f       | 90 90    | edf,edf,edf | depart,roundabout-exit-1,arrive |
+           | e,f       | 90 90    | edf,edf     | depart,arrive                   |
            | e,h       | 90 135   | edf,gch,gch | depart,roundabout-exit-2,arrive |
            | g,f       | 45 90    | gch,edf,edf | depart,roundabout-exit-2,arrive |
            | g,h       | 45 135   | gch,gch,gch | depart,roundabout-exit-1,arrive |
@@ -843,6 +843,6 @@ Feature: Basic Roundabout
 
 
         When I route I should get
-            | from | to | route                        | turns                                                             | distance |
-            | e    | k  | ebds,ebds,ds,ufghl,jhik,jhik | depart,rotary-exit-1,rotary-exit-1,rstur-exit-2,turn right,arrive | 189.1m   |
-            | 1    | k  | ebds,ds,ufghl,jhik,jhik      | depart,rotary-exit-1,rstur-exit-2,turn right,arrive               | 159.1m   |
+            | from | to | route                | turns                                 | distance |
+            | e    | k  | ebds,ufghl,jhik,jhik | depart,rstur-exit-2,turn right,arrive | 189.1m   |
+            | 1    | k  | ebds,ufghl,jhik,jhik | depart,rstur-exit-2,turn right,arrive | 159.1m   |

features/guidance/turn-lanes.feature

@@ -156,7 +156,7 @@ Feature: Turn Lane Guidance
         When I route I should get
             | waypoints | route          | turns                    | lanes                       |
             | a,d       | road,turn,turn | depart,turn right,arrive | ,straight:false right:true, |
-            | a,c       | road,road      | depart,arrive            | ,                           |
+            | a,c       | road,road      | depart,arrive            | ;straight:true right:false, |
 
     Scenario: Turn with Bus-Lane Left
         Given the node map
@@ -178,7 +178,7 @@ Feature: Turn Lane Guidance
         When I route I should get
             | waypoints | route          | turns                   | lanes                       |
             | a,d       | road,turn,turn | depart,turn left,arrive | ,left:true straight:false,  |
-            | a,c       | road,road      | depart,arrive           | ,                           |
+            | a,c       | road,road      | depart,arrive           | ;left:false straight:true,  |
 
     # This tests whether empty/invalid PSV tags cause osrm-extract to crash
     Scenario: Turn with Bus-Lane
@@ -248,23 +248,23 @@ Feature: Turn Lane Guidance
             | fl    | cross |                          | yes    |
 
         When I route I should get
-            | waypoints | route             | turns                           | lanes                                           |
-            | a,j       | road,cross,cross  | depart,turn right,arrive        | ,left:false straight:false right:true           |
-            | a,d       | road,road,road    | depart,use lane straight,arrive | ,left:false straight:true right:false,          |
-            | a,l       | road,cross,cross  | depart,turn left,arrive         | ,left:true straight:false right:false,          |
-            | a,h       | road,road,road    | depart,continue uturn,arrive    | ,left:true straight:false right:false,          |
-            | k,d       | cross,road,road   | depart,turn right,arrive        | ,left:false straight;right:true,                |
-            | k,l       | cross,cross,cross | depart,use lane straight,arrive | ,left:false straight;right:true,                |
-            | k,h       | cross,road,road   | depart,turn left,arrive         | ,left:true straight;right:false,                |
-            | k,j       | cross,cross,cross | depart,continue uturn,arrive    | ,left:true straight;right:false,                |
-            | e,l       | road,cross,cross  | depart,turn right,arrive        | ,none:false straight:false straight;right:true, |
-            | e,h       | road,road         | depart,arrive                   | ,none:false straight:true straight;right:true   |
-            | e,j       | road,cross,cross  | depart,turn left,arrive         | ,none:true straight:false straight;right:false, |
-            | e,d       | road,road,road    | depart,continue uturn,arrive    | ,none:true straight:false straight;right:false, |
-            | i,h       | cross,road,road   | depart,turn right,arrive        | ,,                                              |
-            | i,j       | cross,cross,cross | depart,use lane straight,arrive | ,left:false straight:true,                      |
-            | i,d       | cross,road,road   | depart,turn left,arrive         | ,left:true straight:false,                      |
-            | i,l       | cross,cross,cross | depart,continue uturn,arrive    | ,left:true straight:false,                      |
+            | waypoints | route             | turns                           | lanes                                           | intersection_lanes                              |
+            | a,j       | road,cross,cross  | depart,turn right,arrive        | ,left:false straight:false right:true           | ,left:false straight:false right:true           |
+            | a,d       | road,road         | depart,arrive                   | ,                                               | left:false straight:true right:false,           |
+            | a,l       | road,cross,cross  | depart,turn left,arrive         | ,left:true straight:false right:false,          | ,left:true straight:false right:false,          |
+            | a,h       | road,road,road    | depart,continue uturn,arrive    | ,left:true straight:false right:false,          | ,left:true straight:false right:false           |
+            | k,d       | cross,road,road   | depart,turn right,arrive        | ,left:false straight;right:true,                | ,left:false straight;right:true,                |
+            | k,l       | cross,cross       | depart,arrive                   | ,                                               | left:false straight;right:true,                 |
+            | k,h       | cross,road,road   | depart,turn left,arrive         | ,left:true straight;right:false,                | ,left:true straight;right:false,                |
+            | k,j       | cross,cross,cross | depart,continue uturn,arrive    | ,left:true straight;right:false,                | ,left:true straight;right:false,                |
+            | e,l       | road,cross,cross  | depart,turn right,arrive        | ,none:false straight:false straight;right:true, | ,none:false straight:false straight;right:true, |
+            | e,h       | road,road         | depart,arrive                   | ,                                               | none:false straight:true straight;right:true,   |
+            | e,j       | road,cross,cross  | depart,turn left,arrive         | ,none:true straight:false straight;right:false, | ,none:true straight:false straight;right:false, |
+            | e,d       | road,road,road    | depart,continue uturn,arrive    | ,none:true straight:false straight;right:false, | ,none:true straight:false straight;right:false, |
+            | i,h       | cross,road,road   | depart,turn right,arrive        | ,,                                              |                                                 |
+            | i,j       | cross,cross       | depart,arrive                   |                                                 | left:false straight:true,                       |
+            | i,d       | cross,road,road   | depart,turn left,arrive         | ,left:true straight:false,                      | ,left:true straight:false,                      |
+            | i,l       | cross,cross,cross | depart,continue uturn,arrive    | ,left:true straight:false,                      | ,left:true straight:false,                      |
 
     #copy of former case to prevent further regression
     @collapse @partition-lanes
@@ -295,13 +295,13 @@ Feature: Turn Lane Guidance
             | fl    | cross |                          | yes    |
 
         When I route I should get
-            | waypoints | route             | turns                        | lanes                                           |
-            | a,j       | road,cross,cross  | depart,turn right,arrive     | ,left:false straight:false right:true,          |
-            | k,d       | cross,road,road   | depart,turn right,arrive     | ,left:false straight;right:true,                |
-            | e,l       | road,cross,cross  | depart,turn right,arrive     | ,none:false straight:false straight;right:true, |
-            | i,h       | cross,road,road   | depart,turn right,arrive     | ,,                                              |
-            | i,j       | cross,cross       | depart,arrive                | ,                                               |
-            | i,l       | cross,cross,cross | depart,continue uturn,arrive | ,left:true straight:false,                      |
+            | waypoints | route             | turns                        | lanes                                                                         |
+            | a,j       | road,cross,cross  | depart,turn right,arrive     | ,left:false straight:false right:true,                                        |
+            | k,d       | cross,road,road   | depart,turn right,arrive     | ,left:false straight;right:true,                                              |
+            | e,l       | road,cross,cross  | depart,turn right,arrive     | ,none:false straight:false straight;right:true,                               |
+            | i,h       | cross,road,road   | depart,turn right,arrive     | ,,                                                                            |
+            | i,j       | cross,cross       | depart,arrive                | ;;left:false straight:true,                                                   |
+            | i,l       | cross,cross,cross | depart,continue uturn,arrive | ;,left:true straight:false;left:true straight:false;left:false straight:true, |
 
     @partition-lanes
     Scenario: Turn Lanes at Segregated Road
@@ -347,7 +347,7 @@ Feature: Turn Lane Guidance
         When I route I should get
             | waypoints | route          | turns                    | lanes                   |
             | a,e       | road,turn,turn | depart,turn right,arrive | ,none:false right:true, |
-            | a,d       | road,road      | depart,arrive            | ,                       |
+            | a,d       | road,road      | depart,arrive            | ;none:true right:false, |
 
     @2654 @previous-lanes
     Scenario: Turn Lanes Given earlier than actual turn
@@ -368,11 +368,11 @@ Feature: Turn Lane Guidance
             | hk    | second-turn |                    |                     |
 
         When I route I should get
-            | waypoints | route                        | turns                    | lanes                   |
-            | a,k       | road,second-turn,second-turn | depart,turn right,arrive | ,none:false right:true, |
-            | a,i       | road,road                    | depart,arrive            | ,                       |
-            | i,j       | road,first-turn,first-turn   | depart,turn left,arrive  | ,left:true none:false,  |
-            | i,a       | road,road                    | depart,arrive            | ,                       |
+            | waypoints | route                        | turns                    | lanes                    |
+            | a,k       | road,second-turn,second-turn | depart,turn right,arrive | ;,none:false right:true, |
+            | a,i       | road,road                    | depart,arrive            | ;;none:true right:false, |
+            | i,j       | road,first-turn,first-turn   | depart,turn left,arrive  | ;,left:true none:false,  |
+            | i,a       | road,road                    | depart,arrive            | ;;left:false none:true,  |
 
     @previous-lanes
     Scenario: Passing a one-way street
@@ -390,8 +390,8 @@ Feature: Turn Lane Guidance
             | cf    | turn |                    |        |
 
         When I route I should get
-            | waypoints | route          | turns                   | lanes                      |
-            | a,f       | road,turn,turn | depart,turn left,arrive | ,left:true straight:false, |
+            | waypoints | route          | turns                   | lanes                                               |
+            | a,f       | road,turn,turn | depart,turn left,arrive | ;left:true straight:false,left:true straight:false, |
 
     @partition-lanes
     Scenario: Passing a one-way street, partly pulled back lanes
@@ -411,10 +411,10 @@ Feature: Turn Lane Guidance
             | bg    | right |                     | no     |
 
         When I route I should get
-            | waypoints | route            | turns                    | lanes                            |
-            | a,f       | road,turn,turn   | depart,turn left,arrive  | ,left:true straight;right:false, |
-            | a,d       | road,road        | depart,arrive            | ,                                |
-            | a,g       | road,right,right | depart,turn right,arrive | ,left:false straight;right:true, |
+            | waypoints | route            | turns                    | lanes                                                           |
+            | a,f       | road,turn,turn   | depart,turn left,arrive  | ;left:true straight;right:false,left:true straight;right:false, |
+            | a,d       | road,road        | depart,arrive            | ;left:false straight;right:true;left:false straight;right:true, |
+            | a,g       | road,right,right | depart,turn right,arrive | ,left:false straight;right:true,                                |
 
     @partition-lanes @previous-lanes
     Scenario: Passing a one-way street, partly pulled back lanes, no through
@@ -434,9 +434,9 @@ Feature: Turn Lane Guidance
             | bg    | right |                     | no     |
 
         When I route I should get
-            | waypoints | route            | turns                    | lanes                   |
-            | a,f       | road,turn,turn   | depart,turn left,arrive  | ,left:true right:false, |
-            | a,g       | road,right,right | depart,turn right,arrive | ,left:false right:true, |
+            | waypoints | route            | turns                    | lanes                                         |
+            | a,f       | road,turn,turn   | depart,turn left,arrive  | ,left:true right:false;left:true right:false, |
+            | a,g       | road,right,right | depart,turn right,arrive | ,left:false right:true,                       |
 
     @todo @partition-lanes @previous-lanes
     Scenario: Narrowing Turn Lanes
@@ -484,7 +484,7 @@ Feature: Turn Lane Guidance
 
         When I route I should get
             | waypoints | route          | turns                    | lanes                       |
-            | a,d       | road,road      | depart,arrive            | ,                           |
+            | a,d       | road,road      | depart,arrive            | ;straight:true right:false, |
             | a,e       | road,turn,turn | depart,turn right,arrive | ,straight:false right:true, |
 
     @todo @roundabout
@@ -554,9 +554,9 @@ Feature: Turn Lane Guidance
             | restriction | bc       | dc     | c        | no_right_turn |
 
         When I route I should get
-            | waypoints | route            | turns                   | lanes                                                           |
-            | a,g       | road,cross,cross | depart,turn left,arrive | ,left:true left:true straight:false straight:false right:false, |
-            | a,e       | road,road        | depart,arrive           | ,                                                               |
+            | waypoints | route            | turns                   | lanes                                                                                                                          |
+            | a,g       | road,cross,cross | depart,turn left,arrive |  ,left:true left:true straight:false straight:false right:false;left:true left:true straight:false straight:false right:false, |
+            | a,e       | road,road        | depart,arrive           | ;left:false left:false straight:true straight:true right:false;left:false left:false straight:true straight:true right:false,  |
 
     #NEEDS TO BE INVESTIGATED. Turn restriction shouldn't be here. See #2867
     @reverse @previous-lanes
@@ -589,11 +589,11 @@ Feature: Turn Lane Guidance
             | restriction | de       | ef     | e        | no_left_turn  |
 
         When I route I should get
-            | from | to | bearings        | route            | turns                        | lanes                                  |
-            | a    | g  | 180,180 180,180 | road,cross,cross | depart,turn right,arrive     | ,none:false straight:false right:true, |
-            | a    | h  | 180,180 180,180 | road,cross,cross | depart,turn left,arrive      | ,none:true straight:false right:false, |
-            | a    | i  | 180,180 180,180 | road,road        | depart,arrive                | ,                                      |
-            | b    | a  | 90,2 270,2      | road,road,road   | depart,continue uturn,arrive | ,none:true straight:false right:false, |
+            | from | to | bearings        | route            | turns                        | lanes                                                                        |
+            | a    | g  | 180,180 180,180 | road,cross,cross | depart,turn right,arrive     | ;none:false straight:false right:true,none:false straight:false right:true,  |
+            | a    | h  | 180,180 180,180 | road,cross,cross | depart,turn left,arrive      | ;none:true straight:false right:false,none:true straight:false right:false;, |
+            | a    | i  | 180,180 180,180 | road,road        | depart,arrive                | ;none:true straight:true right:false;none:true straight:true right:false,    |
+            | b    | a  | 90,2 270,2      | road,road,road   | depart,continue uturn,arrive | ,none:true straight:false right:false;,                                      |
 
     @reverse
     Scenario: Segregated Intersection Merges With Lanes
@@ -681,7 +681,7 @@ Feature: Turn Lane Guidance
 
         When I route I should get
             | waypoints | route            | turns                           | lanes                                                                        |
-            | a,d       | road,road        | depart,arrive                   | ,                                                                            |
+            | a,d       | road,road        | depart,arrive                   |  ;straight:true straight:true straight;slight right:true slight right:false, |
             | a,e       | road,cross,cross | depart,turn slight right,arrive | ,straight:false straight:false straight;slight right:true slight right:true, |
 
     @ramp
@@ -700,7 +700,7 @@ Feature: Turn Lane Guidance
 
         When I route I should get
             | waypoints | route         | turns                               | lanes                                                                        |
-            | a,d       | hwy,hwy       | depart,arrive                       | ,                                                                            |
+            | a,d       | hwy,hwy       | depart,arrive                       | ;straight:true straight:true straight;slight right:true slight right:false,  |
             | a,e       | hwy,ramp,ramp | depart,off ramp slight right,arrive | ,straight:false straight:false straight;slight right:true slight right:true, |
 
     @todo
@@ -745,7 +745,7 @@ Feature: Turn Lane Guidance
 
         When I route I should get
             | waypoints | route         | turns                               | lanes                                             |
-            | a,c       | hwy,hwy       | depart,arrive                       | ,                                                 |
+            | a,c       | hwy,hwy       | depart,arrive                       | ;straight:true straight:true slight right:false,  |
             | a,d       | hwy,ramp,ramp | depart,off ramp slight right,arrive | ,straight:false straight:false slight right:true, |
 
     @reverse
@@ -766,8 +766,8 @@ Feature: Turn Lane Guidance
             | fgh   | road |                           | primary      | yes    |
 
         When I route I should get
-            | waypoints | route          | turns                        | lanes                                     |
-            | a,h       | road,road,road | depart,continue uturn,arrive | ,uturn:true straight:false straight:false,|
+            | waypoints | route          | turns                        | lanes                                      |
+            | a,h       | road,road,road | depart,continue uturn,arrive | ,uturn:true straight:false straight:false;,|
 
     @reverse
     Scenario: Reverse Lane in Segregated Road with none
@@ -787,8 +787,8 @@ Feature: Turn Lane Guidance
             | fgh   | road |                        | primary      | yes    |
 
         When I route I should get
-            | waypoints | route          | turns                        | lanes                                  |
-            | a,h       | road,road,road | depart,continue uturn,arrive | ,uturn:true straight:false none:false, |
+            | waypoints | route          | turns                        | lanes                                   |
+            | a,h       | road,road,road | depart,continue uturn,arrive | ,uturn:true straight:false none:false;, |
 
     @reverse
     Scenario: Reverse Lane in Segregated Road with none, Service Turn Prior
@@ -810,8 +810,8 @@ Feature: Turn Lane Guidance
             | ji    | park |                        | service      | no     |
 
         When I route I should get
-            | waypoints | route          | turns                        | lanes                                  |
-            | a,h       | road,road,road | depart,continue uturn,arrive | ,uturn:true straight:false none:false, |
+            | waypoints | route          | turns                        | lanes                                   |
+            | a,h       | road,road,road | depart,continue uturn,arrive | ,uturn:true straight:false none:false;, |
 
     @simple
     Scenario: Don't collapse everything to u-turn / too wide
@@ -873,9 +873,9 @@ Feature: Turn Lane Guidance
             | ab    | on   | motorway_link |                    |
 
         When I route I should get
-            | waypoints | route        | turns                    | lanes                          |
-            | a,j       | on,xbcj      | depart,arrive            | ,                              |
-            | a,i       | on,off,off   | depart,turn right,arrive | ,none:false slight right:true, |
+            | waypoints | route        | turns                    | lanes                           |
+            | a,j       | on,xbcj      | depart,arrive            | ;;none:true slight right:false, |
+            | a,i       | on,off,off   | depart,turn right,arrive | ;,none:false slight right:true, |
 
     #http://www.openstreetmap.org/#map=17/52.47414/13.35712
     @todo @ramp @2645
@@ -929,8 +929,8 @@ Feature: Turn Lane Guidance
             | cf    | turn | primary |                    |
 
         When I route I should get
-            | waypoints | route     | turns         | lanes |
-            | x,d       | road,road | depart,arrive | ,     |
+            | waypoints | route     | turns         | lanes                                     |
+            | x,d       | road,road | depart,arrive | ;straight;right:true;straight;right:true, |
 
     @partition-lanes
     Scenario: Partitioned turn, Slight Curve - maxspeed
@@ -952,9 +952,9 @@ Feature: Turn Lane Guidance
             | dce   | cross | primary | yes    |                    | 1        |
 
         When I route I should get
-            | waypoints | route            | turns                          | lanes                   | locations |
-            | a,g       | road,cross,cross | depart,turn right,arrive       | ,left:false right:true, | a,b,g     |
-            | a,e       | road,cross,cross | depart,end of road left,arrive | ,left:true right:false, | a,c,e     |
+            | waypoints | route            | turns                          | lanes                                         | locations |
+            | a,g       | road,cross,cross | depart,turn right,arrive       | ,left:false right:true,                       | a,b,g     |
+            | a,e       | road,cross,cross | depart,end of road left,arrive | ;left:true right:false,left:true right:false, | a,c,e     |
 
     Scenario: Partitioned turn, Slight Curve
         Given the node map
@@ -975,9 +975,9 @@ Feature: Turn Lane Guidance
             | dce   | cross | primary | yes    |                    |
 
         When I route I should get
-            | waypoints | route            | turns                          | lanes                   | locations |
-            | a,g       | road,cross,cross | depart,turn right,arrive       | ,left:false right:true, | a,b,g     |
-            | a,e       | road,cross,cross | depart,end of road left,arrive | ,left:true right:false, | a,c,e     |
+            | waypoints | route            | turns                          | lanes                                         | locations |
+            | a,g       | road,cross,cross | depart,turn right,arrive       | ,left:false right:true,                       | a,b,g     |
+            | a,e       | road,cross,cross | depart,end of road left,arrive | ;left:true right:false,left:true right:false, | a,c,e     |
 
     Scenario: Lane Parsing Issue #2694
         Given the node map
@@ -1193,7 +1193,7 @@ Feature: Turn Lane Guidance
         When I route I should get
             | waypoints | route            | turns                    | lanes                             |
             | a,e       | road,cross,cross | depart,turn right,arrive | ,left:false none:false none:true, |
-            | a,c       | road,road        | depart,arrive            | ,                                 |
+            | a,c       | road,road        | depart,arrive            | ;left:false none:true none:true,  |
 
     @3379
     Scenario: Don't Turn through potential through lanes
@@ -1214,7 +1214,7 @@ Feature: Turn Lane Guidance
         When I route I should get
             | waypoints | route            | turns                   | lanes                              |
             | a,d       | road,cross,cross | depart,turn left,arrive | ,none:true none:false right:false, |
-            | a,c       | road,road        | depart,arrive           | ,                                  |
+            | a,c       | road,road        | depart,arrive           |  ;none:true none:true right:false, |
 
     @4189
     Scenario: U-turn after a traffic light
@@ -1242,5 +1242,5 @@ Feature: Turn Lane Guidance
             | mdhk  | road2 | 2     |                              | yes    |
 
         When I route I should get
-            | waypoints | route             | turns                        | lanes                                                | locations |
-            | a,f       | road1,road1,road1 | depart,continue uturn,arrive | ,left:true straight:false straight;right:false,      | a,d,f     |
+            | waypoints | route             | turns                        | lanes                                                                                           | locations |
+            | a,f       | road1,road1,road1 | depart,continue uturn,arrive | ;left:false straight:true straight;right:false,left:true straight:false straight;right:false;;, | a,d,f     |

features/options/contract/edge-weight-updates-over-factor.feature

@@ -33,15 +33,25 @@ Feature: osrm-contract command line option: edge-weight-updates-over-factor
 
 
     Scenario: Logging using weigts as durations for non-duration profile
-        Given the profile file "testbot" extended with
+        Given the profile file
         """
-        properties.weight_name = 'steps'
-        function way_function(way, result)
+        local functions = require('testbot')
+        functions.setup_testbot = functions.setup
+
+        functions.setup = function()
+          local profile = functions.setup_testbot()
+          profile.properties.weight_name = 'steps'
+          return profile
+        end
+
+        functions.process_way = function(profile, way, result)
           result.forward_mode = mode.driving
           result.backward_mode = mode.driving
           result.weight = 1
           result.duration = 1
         end
+
+        return functions
         """
         And the data has been saved to disk
 

features/options/extract/lua.feature

@@ -12,15 +12,20 @@ Feature: osrm-extract lua ways:get_nodes()
         And the data has been saved to disk
 
     Scenario: osrm-extract - Passing base file
-        Given the profile file "testbot" extended with
+        Given the profile file
         """
-        function way_function(way, result)
+        functions = require('testbot')
+
+        function way_function(profile, way, result)
           for _, node in ipairs(way:get_nodes()) do
             print('node id ' .. node:id())
           end
           result.forward_mode = mode.driving
           result.forward_speed = 1
         end
+
+        functions.process_way = way_function
+        return functions
         """
         When I run "osrm-extract --profile {profile_file} {osm_file}"
         Then it should exit successfully

features/options/profiles/invalid_version.feature

@@ -0,0 +1,40 @@
+Feature: Invalid profile API versions
+
+    Background:
+        Given a grid size of 100 meters
+
+    Scenario: Profile API version too low
+        Given the profile file
+          """
+          api_version = -1
+          """
+        And the node map
+          """
+            ab
+          """
+        And the ways
+            | nodes  |
+            | ab     |
+        And the data has been saved to disk
+
+        When I try to run "osrm-extract --profile {profile_file} {osm_file}"
+        Then it should exit with an error
+        And stderr should contain "Invalid profile API version"
+
+    Scenario: Profile API version too high
+        Given the profile file
+          """
+          api_version = 3
+          """
+        And the node map
+          """
+            ab
+          """
+        And the ways
+            | nodes  |
+            | ab     |
+        And the data has been saved to disk
+
+        When I try to run "osrm-extract --profile {profile_file} {osm_file}"
+        Then it should exit with an error
+        And stderr should contain "Invalid profile API version"

features/options/profiles/version0.feature

@@ -1,84 +1,36 @@
 Feature: Profile API version 0
 
-    Background:
-        Given a grid size of 100 meters
-
-    Scenario: Not-defined API version
+    Scenario: Profile api version 0
         Given the profile file
-          """
-function way_function(way, result)
-  result.forward_mode = mode.driving
-  result.forward_speed = 1
-end
-          """
-        And the node map
-          """
-            ab
-          """
-        And the ways
-            | nodes  |
-            | ab     |
-        And the data has been saved to disk
-
-        When I try to run "osrm-extract --profile {profile_file} {osm_file}"
-        Then it should exit successfully
-        And stderr should not contain "Invalid profile API version"
-
-    Scenario: Out-bound API version
-        Given the profile file
-          """
-api_version = 2
-          """
-        And the node map
-          """
-            ab
-          """
-        And the ways
-            | nodes  |
-            | ab     |
-        And the data has been saved to disk
-
-        When I try to run "osrm-extract --profile {profile_file} {osm_file}"
-        Then it should exit with an error
-        And stderr should contain "Invalid profile API version"
-
-
-    Scenario: Basic profile function calls and property values
-        Given the profile file
-           """
-api_version = 0
-
--- set profile properties
-properties.u_turn_penalty                  = 20
-properties.traffic_signal_penalty          = 2
-properties.max_speed_for_map_matching      = 180/3.6
-properties.use_turn_restrictions           = true
-properties.continue_straight_at_waypoint   = true
-properties.left_hand_driving               = false
-properties.weight_name                     = 'duration'
-
-function node_function (node, result)
-  print ('node_function ' .. node:id())
-end
-
-function way_function(way, result)
-  result.name = way:get_value_by_key('name')
-  result.forward_mode = mode.driving
-  result.backward_mode = mode.driving
-  result.forward_speed = 36
-  result.backward_speed = 36
-  print ('way_function ' .. way:id() .. ' ' .. result.name)
-end
-
-function turn_function (angle)
-  print('turn_function ' .. angle)
-  return angle == 0 and 0 or 42
-end
-
-function segment_function (source, target, distance, weight)
-    print ('segment_function ' .. source.lon .. ' ' .. source.lat)
-end
-           """
+        """
+        api_version = 0
+        -- set profile properties
+        properties.u_turn_penalty                  = 20
+        properties.traffic_signal_penalty          = 2
+        properties.max_speed_for_map_matching      = 180/3.6
+        properties.use_turn_restrictions           = true
+        properties.continue_straight_at_waypoint   = true
+        properties.left_hand_driving               = false
+        properties.weight_name                     = 'duration'
+        function node_function (node, result)
+          print ('node_function ' .. node:id())
+        end
+        function way_function(way, result)
+          result.name = way:get_value_by_key('name')
+          result.forward_mode = mode.driving
+          result.backward_mode = mode.driving
+          result.forward_speed = 36
+          result.backward_speed = 36
+          print ('way_function ' .. way:id() .. ' ' .. result.name)
+        end
+        function turn_function (angle)
+          print('turn_function ' .. angle)
+          return angle == 0 and 0 or 42
+        end
+        function segment_function (source, target, distance, weight)
+            print ('segment_function ' .. source.lon .. ' ' .. source.lat)
+        end
+        """
         And the node map
            """
                a
@@ -105,3 +57,60 @@ end
            | a    | b  | ac,cb,cb | 24.2s |
            | a    | d  | ac,cd,cd | 24.2s |
            | a    | e  | ac,ce    | 20s   |
+
+    Scenario: Profile version undefined, assume version 0
+        Given the profile file
+        """
+        -- set profile properties
+        properties.u_turn_penalty                  = 20
+        properties.traffic_signal_penalty          = 2
+        properties.max_speed_for_map_matching      = 180/3.6
+        properties.use_turn_restrictions           = true
+        properties.continue_straight_at_waypoint   = true
+        properties.left_hand_driving               = false
+        properties.weight_name                     = 'duration'
+        function node_function (node, result)
+          print ('node_function ' .. node:id())
+        end
+        function way_function(way, result)
+          result.name = way:get_value_by_key('name')
+          result.forward_mode = mode.driving
+          result.backward_mode = mode.driving
+          result.forward_speed = 36
+          result.backward_speed = 36
+          print ('way_function ' .. way:id() .. ' ' .. result.name)
+        end
+        function turn_function (angle)
+          print('turn_function ' .. angle)
+          return angle == 0 and 0 or 42
+        end
+        function segment_function (source, target, distance, weight)
+            print ('segment_function ' .. source.lon .. ' ' .. source.lat)
+        end
+        """
+        And the node map
+           """
+               a
+             b c d
+               e
+           """
+        And the ways
+            | nodes  |
+            | ac     |
+            | cb     |
+            | cd     |
+            | ce     |
+        And the data has been saved to disk
+
+        When I run "osrm-extract --profile {profile_file} {osm_file}"
+        Then it should exit successfully
+        And stdout should contain "node_function"
+        And stdout should contain "way_function"
+        And stdout should contain "turn_function"
+        And stdout should contain "segment_function"
+
+        When I route I should get
+           | from | to | route    | time  |
+           | a    | b  | ac,cb,cb | 24.2s |
+           | a    | d  | ac,cd,cd | 24.2s |
+           | a    | e  | ac,ce    | 20s   |

features/options/profiles/version1.feature

@@ -6,41 +6,42 @@ Feature: Profile API version 1
     Scenario: Basic profile function calls and property values
         Given the profile file
            """
-api_version = 1
+          api_version = 1
 
--- set profile properties
-properties.max_speed_for_map_matching      = 180/3.6
-properties.use_turn_restrictions           = true
-properties.continue_straight_at_waypoint   = true
-properties.weight_name                     = 'test_version1'
-properties.weight_precision                = 2
+          -- set profile properties
+          properties.max_speed_for_map_matching      = 180/3.6
+          properties.use_turn_restrictions           = true
+          properties.continue_straight_at_waypoint   = true
+          properties.weight_name                     = 'test_version1'
+          properties.weight_precision                = 2
 
-assert(properties.max_turn_weight == 327.67)
+          assert(properties.max_turn_weight == 327.67)
 
-function node_function (node, result)
-  print ('node_function ' .. node:id())
-end
+          function node_function (node, result)
+            print(node, result)
+            print ('node_function ' .. node:id())
+          end
 
-function way_function(way, result)
-  result.name = way:get_value_by_key('name')
-  result.weight = 10
-  result.forward_mode = mode.driving
-  result.backward_mode = mode.driving
-  result.forward_speed = 36
-  result.backward_speed = 36
-  print ('way_function ' .. way:id() .. ' ' .. result.name)
-end
+          function way_function(way, result)
+            result.name = way:get_value_by_key('name')
+            result.weight = 10
+            result.forward_mode = mode.driving
+            result.backward_mode = mode.driving
+            result.forward_speed = 36
+            result.backward_speed = 36
+            print ('way_function ' .. way:id() .. ' ' .. result.name)
+          end
 
-function turn_function (turn)
-  print('turn_function', turn.angle, turn.turn_type, turn.direction_modifier, turn.has_traffic_light)
-  turn.weight = turn.angle == 0 and 0 or 4.2
-  turn.duration = turn.weight
-end
+          function turn_function (turn)
+            print('turn_function', turn.angle, turn.turn_type, turn.direction_modifier, turn.has_traffic_light)
+            turn.weight = turn.angle == 0 and 0 or 4.2
+            turn.duration = turn.weight
+          end
 
-function segment_function (segment)
-    print ('segment_function ' .. segment.source.lon .. ' ' .. segment.source.lat)
-end
-           """
+          function segment_function (segment)
+              print ('segment_function ' .. segment.source.lon .. ' ' .. segment.source.lat)
+          end
+          """
         And the node map
            """
                a
@@ -67,3 +68,165 @@ end
            | a    | b  | ac,cb,cb | 19.2s |
            | a    | d  | ac,cd,cd | 19.2s |
            | a    | e  | ac,ce    | 20s   |
+
+    Scenario: Basic profile function calls and property values
+        Given the profile file
+           """
+          api_version = 1
+
+          -- set profile properties
+          properties.max_speed_for_map_matching      = 180/3.6
+          properties.use_turn_restrictions           = true
+          properties.continue_straight_at_waypoint   = true
+          properties.weight_name                     = 'test_version1'
+          properties.weight_precision                = 2
+
+          assert(properties.max_turn_weight == 327.67)
+
+          function node_function (node, result)
+            print(node, result)
+            print ('node_function ' .. node:id())
+          end
+
+          function way_function(way, result)
+            result.name = way:get_value_by_key('name')
+            result.weight = 10
+            result.forward_mode = mode.driving
+            result.backward_mode = mode.driving
+            result.forward_speed = 36
+            result.backward_speed = 36
+            print ('way_function ' .. way:id() .. ' ' .. result.name)
+          end
+
+          function turn_function (turn)
+            print('turn_function', turn.angle, turn.turn_type, turn.direction_modifier, turn.has_traffic_light)
+            turn.weight = turn.angle == 0 and 0 or 4.2
+            turn.duration = turn.weight
+          end
+
+          function segment_function (segment)
+              print ('segment_function ' .. segment.source.lon .. ' ' .. segment.source.lat)
+          end
+          """
+        And the node map
+           """
+               a
+              bcd
+               e
+           """
+        And the ways
+            | nodes  |
+            | ac     |
+            | cb     |
+            | cd     |
+            | ce     |
+        And the data has been saved to disk
+
+        When I run "osrm-extract --profile {profile_file} {osm_file}"
+        Then it should exit successfully
+        And stdout should contain "node_function"
+        And stdout should contain "way_function"
+        And stdout should contain "turn_function"
+        And stdout should contain "segment_function"
+
+        When I route I should get
+           | from | to | route    | time  |
+           | a    | b  | ac,cb,cb | 19.2s |
+           | a    | d  | ac,cd,cd | 19.2s |
+           | a    | e  | ac,ce    | 20s   |
+
+    Scenario: Weighting based on raster sources
+        Given the profile file
+        """
+        api_version = 1
+
+        properties.force_split_edges = true
+
+        function source_function()
+          local path = os.getenv('OSRM_RASTER_SOURCE')
+          if not path then
+            path = 'rastersource.asc'
+          end
+          raster_source = sources:load(
+            path,
+            0,    -- lon_min
+            0.1,  -- lon_max
+            0,    -- lat_min
+            0.1,  -- lat_max
+            5,    -- nrows
+            4     -- ncols
+          )
+        end
+
+        function way_function (way, result)
+          result.name = way:get_value_by_key('name')
+          result.forward_mode = mode.cycling
+          result.backward_mode = mode.cycling
+          result.forward_speed = 15
+          result.backward_speed = 15
+        end
+
+        function segment_function (segment)
+          local sourceData = sources:query(raster_source, segment.source.lon, segment.source.lat)
+          local targetData = sources:query(raster_source, segment.target.lon, segment.target.lat)
+          io.write('evaluating segment: ' .. sourceData.datum .. ' ' .. targetData.datum .. '\n')
+          local invalid = sourceData.invalid_data()
+          local scaled_weight = segment.weight
+          local scaled_duration = segment.duration
+
+          if sourceData.datum ~= invalid and targetData.datum ~= invalid then
+            local slope = (targetData.datum - sourceData.datum) / segment.distance
+            scaled_weight = scaled_weight / (1.0 - (slope * 5.0))
+            scaled_duration = scaled_duration / (1.0 - (slope * 5.0))
+            io.write('   slope: ' .. slope .. '\n')
+            io.write('   was weight: ' .. segment.weight .. '\n')
+            io.write('   new weight: ' .. scaled_weight .. '\n')
+            io.write('   was duration: ' .. segment.duration .. '\n')
+            io.write('   new duration: ' .. scaled_duration .. '\n')
+          end
+
+          segment.weight = scaled_weight
+          segment.duration = scaled_duration
+        end
+        """
+        And the node locations
+            | node | lat        | lon      |
+            | a    | 0.1        | 0.1      |
+            | b    | 0.05       | 0.1      |
+            | c    | 0.0        | 0.1      |
+            | d    | 0.05       | 0.03     |
+            | e    | 0.05       | 0.066    |
+            | f    | 0.075      | 0.066    |
+        And the ways
+            | nodes | highway |
+            | ab    | primary |
+            | ad    | primary |
+            | bc    | primary |
+            | dc    | primary |
+            | de    | primary |
+            | eb    | primary |
+            | df    | primary |
+            | fb    | primary |
+        And the raster source
+            """
+            0  0  0   0
+            0  0  0   250
+            0  0  250 500
+            0  0  0   250
+            0  0  0   0
+            """
+        And the data has been saved to disk
+
+        When I route I should get
+            | from | to | route    | speed   |
+            | a    | b  | ab,ab    | 8 km/h  |
+            | b    | a  | ab,ab    | 22 km/h |
+            | a    | c  | ab,bc,bc | 12 km/h |
+            | b    | c  | bc,bc    | 22 km/h |
+            | a    | d  | ad,ad    | 15 km/h |
+            | d    | c  | dc,dc    | 15 km/h |
+            | d    | e  | de,de    | 10 km/h |
+            | e    | b  | eb,eb    | 10 km/h |
+            | d    | f  | df,df    | 15 km/h |
+            | f    | b  | fb,fb    | 7 km/h  |
+            | d    | b  | de,eb,eb | 10 km/h |

features/options/profiles/version2.feature

@@ -0,0 +1,87 @@
+Feature: Profile API version 2
+
+    Background:
+        Given a grid size of 100 meters
+
+    Scenario: Basic profile function calls and property values
+        Given the profile file
+            """
+            api_version = 2
+
+            Set = require('lib/set')
+            Sequence = require('lib/sequence')
+            Handlers = require("lib/way_handlers")
+            find_access_tag = require("lib/access").find_access_tag
+            limit = require("lib/maxspeed").limit
+
+
+            function setup()
+              return {
+                properties = {
+                  max_speed_for_map_matching      = 180/3.6,
+                  use_turn_restrictions           = true,
+                  continue_straight_at_waypoint   = true,
+                  weight_name                     = 'test_version2',
+                  weight_precision                = 2
+                }
+              }
+            end
+
+            function process_node(profile, node, result)
+              print ('process_node ' .. node:id())
+            end
+
+            function process_way(profile, way, result)
+              result.name = way:get_value_by_key('name')
+              result.weight = 10
+              result.forward_mode = mode.driving
+              result.backward_mode = mode.driving
+              result.forward_speed = 36
+              result.backward_speed = 36
+              print ('process_way ' .. way:id() .. ' ' .. result.name)
+            end
+
+            function process_turn (profile, turn)
+              print('process_turn', turn.angle, turn.turn_type, turn.direction_modifier, turn.has_traffic_light)
+              turn.weight = turn.angle == 0 and 0 or 4.2
+              turn.duration = turn.weight
+            end
+
+            function process_segment (profile, segment)
+                print ('process_segment ' .. segment.source.lon .. ' ' .. segment.source.lat)
+            end
+
+            return {
+              setup = setup,
+              process_node = process_node,
+              process_way = process_way,
+              process_segment = process_segment,
+              process_turn = process_turn
+            }
+            """
+        And the node map
+            """
+               a
+              bcd
+               e
+            """
+        And the ways
+            | nodes  |
+            | ac     |
+            | cb     |
+            | cd     |
+            | ce     |
+        And the data has been saved to disk
+
+        When I run "osrm-extract --profile {profile_file} {osm_file}"
+        Then it should exit successfully
+        And stdout should contain "process_node"
+        And stdout should contain "process_way"
+        And stdout should contain "process_turn"
+        And stdout should contain "process_segment"
+
+        When I route I should get
+           | from | to | route    | time  |
+           | a    | b  | ac,cb,cb | 19.2s |
+           | a    | d  | ac,cd,cd | 19.2s |
+           | a    | e  | ac,ce    | 20s   |

features/step_definitions/data.js

@@ -248,17 +248,20 @@ module.exports = function () {
         fs.writeFile(this.penaltiesCacheFile, data, callback);
     });
 
-    this.Given(/^the profile file(?: "([^"]*)" extended with)?$/, (profile, data, callback) => {
+    this.Given(/^the profile file(?: "([^"]*)" initialized with)?$/, (profile, data, callback) => {
         const lua_profiles_path = this.PROFILES_PATH.split(path.sep).join('/');
         let text = 'package.path = "' + lua_profiles_path + '/?.lua;" .. package.path\n';
         if (profile == null) {
             text += data + '\n';
         } else {
-            text += 'local f = assert(io.open("' + lua_profiles_path + '/' + profile + '.lua", "r"))\n';
-            text += 'local s = f:read("*all") .. [[\n' + data + '\n]]\n';
-            text += 'f:close()\n';
-            text += 'local m = assert(loadstring and loadstring(s) or load(s))\n';
-            text += 'm()\n';
+            text += 'local functions = require("' + profile + '")\n';
+            text += 'functions.setup_parent = functions.setup\n';
+            text += 'functions.setup = function()\n';
+            text += 'local profile = functions.setup_parent()\n';
+            text += data + '\n';
+            text += 'return profile\n';
+            text += 'end\n';
+            text += 'return functions\n';
         }
         this.profileFile = this.profileCacheFile;
         // TODO: Don't overwrite if it exists

features/support/route.js

@@ -171,6 +171,24 @@ module.exports = function () {
                                                               ('out' in s.intersections[0] ? s.intersections[0].bearings[s.intersections[0].out] : 0));
     };
 
+    this.lanesList = (instructions) => {
+        return this.extractInstructionList(instructions, s => {
+            return s.intersections.map( i => {
+                if(i.lanes)
+                {
+                    return i.lanes.map( l => {
+                        let indications = l.indications.join(';');
+                        return indications + ':' + (l.valid ? 'true' : 'false');
+                    }).join(' ');
+                }
+                else
+                {
+                    return '';
+                }
+            }).join(';');
+        });
+    };
+
     this.approachList = (instructions) => {
         return this.extractInstructionList(instructions, s => s.approaches || '');
     };
@@ -197,17 +215,6 @@ module.exports = function () {
         return instructions.tracepoints.map(t => t.alternatives_count.toString()).join(',');
     };
 
-    this.lanesList = (instructions) => {
-        return this.extractInstructionList(instructions, instruction => {
-            if( 'lanes' in instruction.intersections[0] )
-            {
-                return instruction.intersections[0].lanes.map( p => { return (p.indications).join(';') + ':' + p.valid; } ).join(' ');
-            } else
-            {
-                return '';
-            }});
-    };
-
     this.turnList = (instructions) => {
         return instructions.legs.reduce((m, v) => m.concat(v.steps), [])
             .map(v => {
@@ -261,7 +268,7 @@ module.exports = function () {
     };
 
     this.classesList = (instructions) => {
-        return this.extractInstructionList(instructions, s => s.classes ? s.classes.join(';') : '');
+        return this.extractInstructionList(instructions, s => '[' + s.intersections.map(i => '(' + (i.classes ? i.classes.join(',') : '') + ')').join(',') + ']');
     };
 
     this.timeList = (instructions) => {

features/testbot/annotations.feature

@@ -0,0 +1,61 @@
+@routing @speed @annotations
+Feature: Annotations
+
+    Scenario: Ensure that turn penalties aren't included in annotations
+        Given the profile "turnbot"
+        Given a grid size of 100 meters
+        Given the node map
+            """
+              h i
+            j k l m
+            """
+
+        And the query options
+          | annotations | duration,speed,weight |
+
+        And the ways
+            | nodes | highway     |
+            | hk    | residential |
+            | il    | residential |
+            | jk    | residential |
+            | lk    | residential |
+            | lm    | residential |
+
+        When I route I should get
+            | from | to | route    | a:speed     | a:weight |
+            | h    | j  | hk,jk,jk | 6.7:6.7     | 15:15    |
+            | i    | m  | il,lm,lm | 6.7:6.7     | 15:15    |
+            | j    | m  | jk,lm    | 6.7:6.7:6.7 | 15:15:15 |
+
+
+    Scenario: There should be different forward/reverse datasources
+        Given the profile "testbot"
+
+        And the node map
+            """
+            a b c d e f g h i
+            """
+
+        And the ways
+            | nodes     | highway |
+            | abcdefghi | primary |
+
+        And the contract extra arguments "--segment-speed-file {speeds_file}"
+        And the customize extra arguments "--segment-speed-file {speeds_file}"
+
+        # Note: 180km/h == 50m/s for speed annotations
+        And the speed file
+        """
+        1,2,180,1
+        2,1,180,1
+        3,4,180,1
+        5,6,180,1
+        8,7,180,1
+        """
+        And the query options
+          | annotations | datasources,speed |
+
+        When I route I should get
+          | from | to | route               | a:datasources   | a:speed                 |
+          | a    | i  | abcdefghi,abcdefghi | 1:0:1:0:1:0:0:0 | 50:10:50:10:50:10:10:10 |
+          | i    | a  | abcdefghi,abcdefghi | 0:1:0:0:0:0:0:1 | 10:50:10:10:10:10:10:50 |

features/testbot/distance_matrix.feature

@@ -221,15 +221,24 @@ Feature: Basic Distance Matrix
             | 4 | 30 +-1 | 40 +-1 | 70 +-1 | 0  |
 
     Scenario: Testbot - Travel time matrix based on segment durations
-        Given the profile file "testbot" extended with
+        Given the profile file
         """
-        api_version = 1
-        properties.traffic_signal_penalty = 0
-        properties.u_turn_penalty = 0
-        function segment_function (segment)
+        local functions = require('testbot')
+        functions.setup_testbot = functions.setup
+
+        functions.setup = function()
+          local profile = functions.setup_testbot()
+          profile.traffic_signal_penalty = 0
+          profile.u_turn_penalty = 0
+          return profile
+        end
+
+        functions.process_segment = function(profile, segment)
           segment.weight = 2
           segment.duration = 11
         end
+
+        return functions
         """
 
         And the node map
@@ -254,16 +263,25 @@ Feature: Basic Distance Matrix
 
 
     Scenario: Testbot - Travel time matrix for alternative loop paths
-        Given the profile file "testbot" extended with
+        Given the profile file
         """
-        api_version = 1
-        properties.traffic_signal_penalty = 0
-        properties.u_turn_penalty = 0
-        properties.weight_precision = 3
-        function segment_function (segment)
+        local functions = require('testbot')
+        functions.setup_testbot = functions.setup
+
+        functions.setup = function()
+          local profile = functions.setup_testbot()
+          profile.traffic_signal_penalty = 0
+          profile.u_turn_penalty = 0
+          profile.weight_precision = 3
+          return profile
+        end
+
+        functions.process_segment = function(profile, segment)
           segment.weight = 777
           segment.duration = 3
         end
+
+        return functions
         """
         And the node map
             """

features/testbot/nil.feature

@@ -1,29 +1,27 @@
 @routing @testbot @nil
 Feature: Testbot - Check assigning nil values
     Scenario: Assign nil values to all way strings
-        Given the profile file "testbot" extended with
+        Given the profile file
         """
-        function way_function (way, result)
-            result.name = "name"
-            result.ref = "ref"
-            result.destinations = "destinations"
-            result.pronunciation = "pronunciation"
-            result.turn_lanes_forward = "turn_lanes_forward"
-            result.turn_lanes_backward = "turn_lanes_backward"
+        functions = require('testbot')
 
-            result.name = nil
-            result.ref = nil
-            result.destinations = nil
-            result.exits = nil
-            result.pronunciation = nil
-            result.turn_lanes_forward = nil
-            result.turn_lanes_backward = nil
+        function way_function(profile, way, result)
+          result.name = nil
+          result.ref = nil
+          result.destinations = nil
+          result.exits = nil
+          result.pronunciation = nil
+          result.turn_lanes_forward = nil
+          result.turn_lanes_backward = nil
 
-            result.forward_speed = 10
-            result.backward_speed = 10
-            result.forward_mode = mode.driving
-            result.backward_mode = mode.driving
+          result.forward_speed = 10
+          result.backward_speed = 10
+          result.forward_mode = mode.driving
+          result.backward_mode = mode.driving
         end
+
+        functions.process_way = way_function
+        return functions
         """
         Given the node map
             """

features/testbot/projection.feature

@@ -39,13 +39,17 @@ Feature: Projection to nearest point on road
 
 
     Scenario: Projection results negative duration
-        Given the profile file "testbot" extended with
+        Given the profile file
         """
-        api_version = 1
-        function segment_function (segment)
+        functions = require('testbot')
+
+        function segment_function(profile, segment)
           segment.weight = 5.5
           segment.duration = 2.8
         end
+
+        functions.process_segment = segment_function
+        return functions
         """
 
         Given the node locations

features/testbot/traffic_speeds.feature

@@ -84,12 +84,11 @@ Feature: Traffic - speeds
 
 
     Scenario: Weighting based on speed file weights, ETA based on file durations
-        Given the profile file "testbot" extended with
+        Given the profile file "testbot" initialized with
         """
-        api_version = 1
-        properties.traffic_signal_penalty = 0
-        properties.u_turn_penalty = 0
-        properties.weight_precision = 2
+        profile.properties.traffic_signal_penalty = 0
+        profile.properties.u_turn_penalty = 0
+        profile.properties.weight_precision = 2
         """
         And the contract extra arguments "--segment-speed-file {speeds_file}"
         And the customize extra arguments "--segment-speed-file {speeds_file}"

features/testbot/traffic_speeds_overflow.feature

@@ -8,12 +8,11 @@ Feature: Traffic - speeds edge cases
         And the ways
           | nodes | highway |
           | ab    | primary |
-        And the profile file "testbot" extended with
+        And the profile file "testbot" initialized with
         """
-        api_version = 1
-        properties.traffic_signal_penalty = 0
-        properties.u_turn_penalty = 0
-        properties.weight_precision = 2
+        profile.properties.traffic_signal_penalty = 0
+        profile.properties.u_turn_penalty = 0
+        profile.properties.weight_precision = 2
         """
         And the contract extra arguments "--segment-speed-file {speeds_file}"
         And the customize extra arguments "--segment-speed-file {speeds_file}"

features/testbot/turn_penalty.feature

@@ -1,12 +1,9 @@
 @routing @testbot @turn_penalty
 Feature: Turn Penalties
 
-    Background:
+    Scenario: Turns should incur a delay that depend on the angle
         Given the profile "turnbot"
         Given a grid size of 200 meters
-
-
-    Scenario: Turns should incur a delay that depend on the angle
         Given the node map
             """
             c d e

features/testbot/weight.feature

@@ -60,18 +60,27 @@ Feature: Weight tests
 
 
     Scenario: Step weights -- way_function: fail if no weight or weight_per_meter property
-        Given the profile file "testbot" extended with
+        Given the profile file
         """
-        api_version = 1
-        properties.traffic_signal_penalty = 0
-        properties.u_turn_penalty = 0
-        properties.weight_name = 'steps'
-        function way_function(way, result)
+        local functions = require('testbot')
+        functions.setup_testbot = functions.setup
+
+        functions.setup = function()
+          local profile = functions.setup_testbot()
+          profile.properties.traffic_signal_penalty = 0
+          profile.properties.u_turn_penalty = 0
+          profile.properties.weight_name = 'steps'
+          return profile
+        end
+
+        functions.process_way = function(profile, way, result)
           result.forward_mode = mode.driving
           result.backward_mode = mode.driving
           result.forward_speed = 42
           result.backward_speed = 42
         end
+
+        return functions
         """
         And the node map
             """
@@ -87,18 +96,27 @@ Feature: Weight tests
         And it should exit with an error
 
     Scenario: Step weights -- way_function: second way wins
-        Given the profile file "testbot" extended with
+        Given the profile file
         """
-        api_version = 1
-        properties.traffic_signal_penalty = 0
-        properties.u_turn_penalty = 0
-        properties.weight_name = 'steps'
-        function way_function(way, result)
+        local functions = require('testbot')
+        functions.setup_testbot = functions.setup
+
+        functions.setup = function()
+          local profile = functions.setup_testbot()
+          profile.properties.traffic_signal_penalty = 0
+          profile.properties.u_turn_penalty = 0
+          profile.properties.weight_name = 'steps'
+          return profile
+        end
+
+        functions.process_way = function(profile, way, result)
           result.forward_mode = mode.driving
           result.backward_mode = mode.driving
           result.duration = 42
           result.weight = 35
         end
+
+        return functions
         """
 
         Given the node map
@@ -119,19 +137,28 @@ Feature: Weight tests
             | h,a       | ,     | 140m +-1 | 35,0    | 42s,0s |
 
     Scenario: Step weights -- way_function: higher weight_per_meter is preferred
-        Given the profile file "testbot" extended with
+        Given the profile file
         """
-        api_version = 1
-        properties.traffic_signal_penalty = 0
-        properties.u_turn_penalty = 0
-        properties.weight_name = 'steps'
-        function way_function(way, result)
+        local functions = require('testbot')
+        functions.setup_testbot = functions.setup
+
+        functions.setup = function()
+          local profile = functions.setup_testbot()
+          profile.properties.traffic_signal_penalty = 0
+          profile.properties.u_turn_penalty = 0
+          profile.properties.weight_name = 'steps'
+          return profile
+        end
+
+        functions.process_way = function(profile, way, result)
           result.forward_mode = mode.driving
           result.backward_mode = mode.driving
           result.duration = 42
           result.forward_rate = 1
           result.backward_rate = 0.5
         end
+
+        return functions
         """
 
         Given the node map
@@ -155,22 +182,32 @@ Feature: Weight tests
             | h,f       | ,     | 40m      | 80,0    | 12s,0s |
 
     Scenario: Step weights -- segment_function
-        Given the profile file "testbot" extended with
+        Given the profile file
         """
-        api_version = 1
-        properties.traffic_signal_penalty = 0
-        properties.u_turn_penalty = 0
-        properties.weight_name = 'steps'
-        function way_function(way, result)
+        local functions = require('testbot')
+        functions.setup_testbot = functions.setup
+
+        functions.setup = function()
+          local profile = functions.setup_testbot()
+          profile.properties.traffic_signal_penalty = 0
+          profile.properties.u_turn_penalty = 0
+          profile.properties.weight_name = 'steps'
+          return profile
+        end
+
+        functions.process_way = function(profile, way, result)
           result.forward_mode = mode.driving
           result.backward_mode = mode.driving
           result.weight = 42
           result.duration = 3
         end
-        function segment_function (segment)
+
+        functions.process_segment = function(profile, segment)
           segment.weight = 1
           segment.duration = 11
         end
+
+        return functions
         """
 
         Given the node map
@@ -195,28 +232,39 @@ Feature: Weight tests
 
 
     Scenario: Step weights -- segment_function and turn_function with weight precision
-        Given the profile file "testbot" extended with
+        Given the profile file
         """
-        api_version = 1
-        properties.traffic_signal_penalty = 0
-        properties.u_turn_penalty = 0
-        properties.weight_name = 'steps'
-        properties.weight_precision = 3
-        function way_function(way, result)
+        local functions = require('testbot')
+        functions.setup_testbot = functions.setup
+
+        functions.setup = function()
+          local profile = functions.setup_testbot()
+          profile.properties.traffic_signal_penalty = 0
+          profile.properties.u_turn_penalty = 0
+          profile.properties.weight_name = 'steps'
+          profile.properties.weight_precision = 3
+          return profile
+        end
+
+        functions.process_way = function(profile, way, result)
           result.forward_mode = mode.driving
           result.backward_mode = mode.driving
           result.weight = 42
           result.duration = 3
         end
-        function segment_function (segment)
+
+        functions.process_segment = function(profile, segment)
           segment.weight = 1.11
           segment.duration = 100
         end
-        function turn_function (turn)
+
+        functions.process_turn = function(profile, turn)
           print (turn.angle)
           turn.weight = 2 + turn.angle / 100
           turn.duration = turn.angle
         end
+
+        return functions
         """
 
         Given the node map
@@ -241,22 +289,32 @@ Feature: Weight tests
 
     @traffic @speed
     Scenario: Step weights -- segment_function with speed and turn updates
-        Given the profile file "testbot" extended with
+        Given the profile file
         """
-        api_version = 1
-        properties.traffic_signal_penalty = 0
-        properties.u_turn_penalty = 0
-        properties.weight_name = 'steps'
-        function way_function(way, result)
+        local functions = require('testbot')
+        functions.setup_testbot = functions.setup
+
+        functions.setup = function()
+          local profile = functions.setup_testbot()
+          profile.properties.traffic_signal_penalty = 0
+          profile.properties.u_turn_penalty = 0
+          profile.properties.weight_name = 'steps'
+          return profile
+        end
+
+        functions.process_way = function(profile, way, result)
           result.forward_mode = mode.driving
           result.backward_mode = mode.driving
           result.weight = 42
           result.duration = 3
         end
-        function segment_function (segment)
+
+        functions.process_segment = function(profile, segment)
           segment.weight = 10
           segment.duration = 11
         end
+
+        return functions
         """
 
         And the node map
@@ -289,10 +347,9 @@ Feature: Weight tests
 
     @traffic @speed
     Scenario: Step weights -- segment_function with speed and turn updates with fallback to durations
-        Given the profile file "testbot" extended with
+        Given the profile file "testbot" initialized with
         """
-        api_version = 1
-        properties.weight_precision = 3
+        profile.properties.weight_precision = 3
         """
 
         And the node map

include/contractor/contractor_config.hpp

@@ -28,6 +28,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef CONTRACTOR_OPTIONS_HPP
 #define CONTRACTOR_OPTIONS_HPP
 
+#include "storage/io_config.hpp"
 #include "updater/updater_config.hpp"
 
 #include <boost/filesystem/path.hpp>
@@ -39,31 +40,30 @@ namespace osrm
 namespace contractor
 {
 
-struct ContractorConfig
+struct ContractorConfig final : storage::IOConfig
 {
-    ContractorConfig() : requested_num_threads(0) {}
-
-    // Infer the output names from the path of the .osrm file
-    void UseDefaultOutputNames()
+    ContractorConfig()
+        : IOConfig(
+              {
+                  ".osrm",
+              },
+              {},
+              {".osrm.level", ".osrm.core", ".osrm.hsgr", ".osrm.enw"}),
+          requested_num_threads(0)
     {
-        level_output_path = osrm_input_path.string() + ".level";
-        core_output_path = osrm_input_path.string() + ".core";
-        graph_output_path = osrm_input_path.string() + ".hsgr";
-        node_file_path = osrm_input_path.string() + ".enw";
-        updater_config.osrm_input_path = osrm_input_path;
-        updater_config.UseDefaultOutputNames();
     }
 
+    // Infer the output names from the path of the .osrm file
+    void UseDefaultOutputNames(const boost::filesystem::path &base)
+    {
+        IOConfig::UseDefaultOutputNames(base);
+        updater_config.UseDefaultOutputNames(base);
+    }
+
+    bool IsValid() const { return IOConfig::IsValid() && updater_config.IsValid(); }
+
     updater::UpdaterConfig updater_config;
 
-    boost::filesystem::path osrm_input_path;
-
-    std::string level_output_path;
-    std::string core_output_path;
-    std::string graph_output_path;
-
-    std::string node_file_path;
-
     bool use_cached_priority;
 
     unsigned requested_num_threads;

include/contractor/graph_contractor.hpp

@@ -14,8 +14,6 @@
 
 #include <boost/assert.hpp>
 
-#include <stxxl/vector>
-
 #include <tbb/enumerable_thread_specific.h>
 #include <tbb/parallel_for.h>
 #include <tbb/parallel_sort.h>
@@ -25,6 +23,10 @@
 #include <memory>
 #include <vector>
 
+#if USE_STXXL_LIBRARY
+#include <stxxl/vector>
+#endif
+
 namespace osrm
 {
 namespace contractor
@@ -33,6 +35,12 @@ namespace contractor
 class GraphContractor
 {
   private:
+#if USE_STXXL_LIBRARY
+    template <typename T> using ExternalVector = stxxl::vector<T>;
+#else
+    template <typename T> using ExternalVector = std::vector<T>;
+#endif
+
     struct ContractorThreadData
     {
         ContractorDijkstra dijkstra;
@@ -401,7 +409,7 @@ class GraphContractor
     bool Bias(const NodeID a, const NodeID b) const;
 
     std::shared_ptr<ContractorGraph> contractor_graph;
-    stxxl::vector<QueryEdge> external_edge_list;
+    ExternalVector<QueryEdge> external_edge_list;
     std::vector<NodeID> orig_node_id_from_new_node_id_map;
     std::vector<float> node_levels;
 

include/customizer/customizer_config.hpp

@@ -1,52 +1,37 @@
 #ifndef OSRM_CUSTOMIZE_CUSTOMIZER_CONFIG_HPP
 #define OSRM_CUSTOMIZE_CUSTOMIZER_CONFIG_HPP
 
-#include "updater/updater_config.hpp"
-
 #include <boost/filesystem/path.hpp>
 
 #include <array>
 #include <string>
 
+#include "storage/io_config.hpp"
+#include "updater/updater_config.hpp"
+
 namespace osrm
 {
 namespace customizer
 {
 
-struct CustomizationConfig
+struct CustomizationConfig final : storage::IOConfig
 {
-    CustomizationConfig() : requested_num_threads(0) {}
-
-    void UseDefaults()
+    CustomizationConfig()
+        : IOConfig(
+              {
+                  ".osrm",
+              },
+              {},
+              {".osrm.ebg", ".osrm.partition", ".osrm.cells", ".osrm.mldgr"}),
+          requested_num_threads(0)
     {
-        std::string basepath = base_path.string();
-
-        const std::string ext = ".osrm";
-        const auto pos = basepath.find(ext);
-        if (pos != std::string::npos)
-        {
-            basepath.replace(pos, ext.size(), "");
-        }
-        else
-        {
-            // unknown extension
-        }
-
-        edge_based_graph_path = basepath + ".osrm.ebg";
-        mld_partition_path = basepath + ".osrm.partition";
-        mld_storage_path = basepath + ".osrm.cells";
-        mld_graph_path = basepath + ".osrm.mldgr";
-
-        updater_config.osrm_input_path = basepath + ".osrm";
-        updater_config.UseDefaultOutputNames();
     }
 
-    // might be changed to the node based graph at some point
-    boost::filesystem::path base_path;
-    boost::filesystem::path edge_based_graph_path;
-    boost::filesystem::path mld_partition_path;
-    boost::filesystem::path mld_storage_path;
-    boost::filesystem::path mld_graph_path;
+    void UseDefaultOutputNames(const boost::filesystem::path &base)
+    {
+        IOConfig::UseDefaultOutputNames(base);
+        updater_config.UseDefaultOutputNames(base);
+    }
 
     unsigned requested_num_threads;
 

include/engine/api/route_api.hpp

@@ -174,14 +174,13 @@ class RouteAPI : public BaseAPI
                 guidance::trimShortSegments(steps, leg_geometry);
                 leg.steps = guidance::postProcess(std::move(steps));
                 leg.steps = guidance::collapseTurnInstructions(std::move(leg.steps));
+                leg.steps = guidance::anticipateLaneChange(std::move(leg.steps));
                 leg.steps = guidance::buildIntersections(std::move(leg.steps));
                 leg.steps = guidance::suppressShortNameSegments(std::move(leg.steps));
                 leg.steps = guidance::assignRelativeLocations(std::move(leg.steps),
                                                               leg_geometry,
                                                               phantoms.source_phantom,
                                                               phantoms.target_phantom);
-                leg.steps = guidance::anticipateLaneChange(std::move(leg.steps));
-                leg.steps = guidance::collapseUseLane(std::move(leg.steps));
                 leg_geometry = guidance::resyncGeometry(std::move(leg_geometry), leg.steps);
             }
 

include/engine/datafacade.hpp

@@ -0,0 +1,26 @@
+#ifndef OSRM_ENGINE_DATAFACADE_DATAFACADE_HPP
+#define OSRM_ENGINE_DATAFACADE_DATAFACADE_HPP
+
+#ifdef OSRM_EXTERNAL_MEMORY
+
+// Register your own data backend here
+#error "No external memory implementation found"
+
+#else
+
+#include "engine/datafacade/contiguous_internalmem_datafacade.hpp"
+
+namespace osrm
+{
+namespace engine
+{
+
+using DataFacadeBase = datafacade::ContiguousInternalMemoryDataFacadeBase;
+template <typename AlgorithmT>
+using DataFacade = datafacade::ContiguousInternalMemoryDataFacade<AlgorithmT>;
+}
+}
+
+#endif
+
+#endif

include/engine/datafacade/contiguous_internalmem_datafacade.hpp

@@ -480,10 +480,17 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
                 data_layout.num_entries[storage::DataLayout::GEOMETRIES_REV_DURATION_LIST]),
             num_entries);
 
-        auto datasources_list_ptr = data_layout.GetBlockPtr<DatasourceID>(
-            memory_block, storage::DataLayout::DATASOURCES_LIST);
-        util::vector_view<DatasourceID> datasources_list(
-            datasources_list_ptr, data_layout.num_entries[storage::DataLayout::DATASOURCES_LIST]);
+        auto geometries_fwd_datasources_list_ptr = data_layout.GetBlockPtr<DatasourceID>(
+            memory_block, storage::DataLayout::GEOMETRIES_FWD_DATASOURCES_LIST);
+        util::vector_view<DatasourceID> geometry_fwd_datasources_list(
+            geometries_fwd_datasources_list_ptr,
+            data_layout.num_entries[storage::DataLayout::GEOMETRIES_FWD_DATASOURCES_LIST]);
+
+        auto geometries_rev_datasources_list_ptr = data_layout.GetBlockPtr<DatasourceID>(
+            memory_block, storage::DataLayout::GEOMETRIES_REV_DATASOURCES_LIST);
+        util::vector_view<DatasourceID> geometry_rev_datasources_list(
+            geometries_rev_datasources_list_ptr,
+            data_layout.num_entries[storage::DataLayout::GEOMETRIES_REV_DATASOURCES_LIST]);
 
         segment_data = extractor::SegmentDataView{std::move(geometry_begin_indices),
                                                   std::move(geometry_node_list),
@@ -491,7 +498,8 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
                                                   std::move(geometry_rev_weight_list),
                                                   std::move(geometry_fwd_duration_list),
                                                   std::move(geometry_rev_duration_list),
-                                                  std::move(datasources_list)};
+                                                  std::move(geometry_fwd_datasources_list),
+                                                  std::move(geometry_rev_datasources_list)};
 
         m_datasources = data_layout.GetBlockPtr<extractor::Datasources>(
             memory_block, storage::DataLayout::DATASOURCES_NAMES);

include/engine/datafacade_provider.hpp

@@ -2,6 +2,7 @@
 #define OSRM_ENGINE_DATAFACADE_PROVIDER_HPP
 
 #include "engine/data_watchdog.hpp"
+#include "engine/datafacade.hpp"
 #include "engine/datafacade/contiguous_internalmem_datafacade.hpp"
 #include "engine/datafacade/process_memory_allocator.hpp"
 
@@ -9,48 +10,56 @@ namespace osrm
 {
 namespace engine
 {
-
-template <typename AlgorithmT> class DataFacadeProvider
+namespace detail
 {
-    using FacadeT = datafacade::ContiguousInternalMemoryDataFacade<AlgorithmT>;
 
+template <typename AlgorithmT, template <typename A> class FacadeT> class DataFacadeProvider
+{
   public:
+    using Facade = FacadeT<AlgorithmT>;
+
     virtual ~DataFacadeProvider() = default;
 
-    virtual std::shared_ptr<const FacadeT> Get() const = 0;
+    virtual std::shared_ptr<const Facade> Get() const = 0;
 };
 
-template <typename AlgorithmT> class ImmutableProvider final : public DataFacadeProvider<AlgorithmT>
+template <typename AlgorithmT, template <typename A> class FacadeT>
+class ImmutableProvider final : public DataFacadeProvider<AlgorithmT, FacadeT>
 {
-    using FacadeT = datafacade::ContiguousInternalMemoryDataFacade<AlgorithmT>;
-
   public:
+    using Facade = typename DataFacadeProvider<AlgorithmT, FacadeT>::Facade;
+
     ImmutableProvider(const storage::StorageConfig &config)
-        : immutable_data_facade(std::make_shared<FacadeT>(
+        : immutable_data_facade(std::make_shared<Facade>(
               std::make_shared<datafacade::ProcessMemoryAllocator>(config)))
     {
     }
 
-    std::shared_ptr<const FacadeT> Get() const override final { return immutable_data_facade; }
+    std::shared_ptr<const Facade> Get() const override final { return immutable_data_facade; }
 
   private:
-    std::shared_ptr<const FacadeT> immutable_data_facade;
+    std::shared_ptr<const Facade> immutable_data_facade;
 };
 
-template <typename AlgorithmT> class WatchingProvider final : public DataFacadeProvider<AlgorithmT>
+template <typename AlgorithmT, template <typename A> class FacadeT>
+class WatchingProvider : public DataFacadeProvider<AlgorithmT, FacadeT>
 {
-    using FacadeT = datafacade::ContiguousInternalMemoryDataFacade<AlgorithmT>;
     DataWatchdog<AlgorithmT> watchdog;
 
   public:
-    std::shared_ptr<const FacadeT> Get() const override final
-    {
-        // We need a singleton here because multiple instances of DataWatchdog
-        // conflict on shared memory mappings
-        return watchdog.Get();
-    }
+    using Facade = typename DataFacadeProvider<AlgorithmT, FacadeT>::Facade;
+
+    std::shared_ptr<const Facade> Get() const override final { return watchdog.Get(); }
 };
 }
+
+template <typename AlgorithmT>
+using DataFacadeProvider = detail::DataFacadeProvider<AlgorithmT, DataFacade>;
+template <typename AlgorithmT>
+using WatchingProvider = detail::WatchingProvider<AlgorithmT, DataFacade>;
+template <typename AlgorithmT>
+using ImmutableProvider = detail::ImmutableProvider<AlgorithmT, DataFacade>;
+}
 }
 
 #endif

include/engine/engine.hpp

@@ -85,47 +85,41 @@ template <typename Algorithm> class Engine final : public EngineInterface
     Status Route(const api::RouteParameters &params,
                  util::json::Object &result) const override final
     {
-        auto facade = facade_provider->Get();
-        auto algorithms = RoutingAlgorithms<Algorithm>{heaps, *facade};
-        return route_plugin.HandleRequest(*facade, algorithms, params, result);
+        auto algorithms = RoutingAlgorithms<Algorithm>{heaps, facade_provider->Get()};
+        return route_plugin.HandleRequest(algorithms, params, result);
     }
 
     Status Table(const api::TableParameters &params,
                  util::json::Object &result) const override final
     {
-        auto facade = facade_provider->Get();
-        auto algorithms = RoutingAlgorithms<Algorithm>{heaps, *facade};
-        return table_plugin.HandleRequest(*facade, algorithms, params, result);
+        auto algorithms = RoutingAlgorithms<Algorithm>{heaps, facade_provider->Get()};
+        return table_plugin.HandleRequest(algorithms, params, result);
     }
 
     Status Nearest(const api::NearestParameters &params,
                    util::json::Object &result) const override final
     {
-        auto facade = facade_provider->Get();
-        auto algorithms = RoutingAlgorithms<Algorithm>{heaps, *facade};
-        return nearest_plugin.HandleRequest(*facade, algorithms, params, result);
+        auto algorithms = RoutingAlgorithms<Algorithm>{heaps, facade_provider->Get()};
+        return nearest_plugin.HandleRequest(algorithms, params, result);
     }
 
     Status Trip(const api::TripParameters &params, util::json::Object &result) const override final
     {
-        auto facade = facade_provider->Get();
-        auto algorithms = RoutingAlgorithms<Algorithm>{heaps, *facade};
-        return trip_plugin.HandleRequest(*facade, algorithms, params, result);
+        auto algorithms = RoutingAlgorithms<Algorithm>{heaps, facade_provider->Get()};
+        return trip_plugin.HandleRequest(algorithms, params, result);
     }
 
     Status Match(const api::MatchParameters &params,
                  util::json::Object &result) const override final
     {
-        auto facade = facade_provider->Get();
-        auto algorithms = RoutingAlgorithms<Algorithm>{heaps, *facade};
-        return match_plugin.HandleRequest(*facade, algorithms, params, result);
+        auto algorithms = RoutingAlgorithms<Algorithm>{heaps, facade_provider->Get()};
+        return match_plugin.HandleRequest(algorithms, params, result);
     }
 
     Status Tile(const api::TileParameters &params, std::string &result) const override final
     {
-        auto facade = facade_provider->Get();
-        auto algorithms = RoutingAlgorithms<Algorithm>{heaps, *facade};
-        return tile_plugin.HandleRequest(*facade, algorithms, params, result);
+        auto algorithms = RoutingAlgorithms<Algorithm>{heaps, facade_provider->Get()};
+        return tile_plugin.HandleRequest(algorithms, params, result);
     }
 
     static bool CheckCompability(const EngineConfig &config);
@@ -158,9 +152,9 @@ bool Engine<routing_algorithms::ch::Algorithm>::CheckCompability(const EngineCon
     }
     else
     {
-        if (!boost::filesystem::exists(config.storage_config.hsgr_data_path))
+        if (!boost::filesystem::exists(config.storage_config.GetPath(".osrm.hsgr")))
             return false;
-        storage::io::FileReader in(config.storage_config.hsgr_data_path,
+        storage::io::FileReader in(config.storage_config.GetPath(".osrm.hsgr"),
                                    storage::io::FileReader::VerifyFingerprint);
 
         auto size = in.GetSize();
@@ -189,9 +183,9 @@ bool Engine<routing_algorithms::corech::Algorithm>::CheckCompability(const Engin
     }
     else
     {
-        if (!boost::filesystem::exists(config.storage_config.core_data_path))
+        if (!boost::filesystem::exists(config.storage_config.GetPath(".osrm.core")))
             return false;
-        storage::io::FileReader in(config.storage_config.core_data_path,
+        storage::io::FileReader in(config.storage_config.GetPath(".osrm.core"),
                                    storage::io::FileReader::VerifyFingerprint);
 
         auto size = in.GetSize();
@@ -214,9 +208,9 @@ bool Engine<routing_algorithms::mld::Algorithm>::CheckCompability(const EngineCo
     }
     else
     {
-        if (!boost::filesystem::exists(config.storage_config.mld_partition_path))
+        if (!boost::filesystem::exists(config.storage_config.GetPath(".osrm.partition")))
             return false;
-        storage::io::FileReader in(config.storage_config.mld_partition_path,
+        storage::io::FileReader in(config.storage_config.GetPath(".osrm.partition"),
                                    storage::io::FileReader::VerifyFingerprint);
 
         auto size = in.GetSize();

include/engine/guidance/assemble_geometry.hpp

@@ -78,11 +78,19 @@ inline LegGeometry assembleGeometry(const datafacade::BaseDataFacade &facade,
         }
 
         prev_coordinate = coordinate;
-        geometry.annotations.emplace_back(
-            LegGeometry::Annotation{current_distance,
-                                    path_point.duration_until_turn / 10.,
-                                    path_point.weight_until_turn / facade.GetWeightMultiplier(),
-                                    path_point.datasource_id});
+        geometry.annotations.emplace_back(LegGeometry::Annotation{
+            current_distance,
+            // NOTE: we want annotations to include only the duration/weight
+            //       of the segment itself.  For segments immediately before
+            //       a turn, the duration_until_turn/weight_until_turn values
+            //       include the turn cost.  To counter this, we subtract
+            //       the duration_of_turn/weight_of_turn value, which is 0 for
+            //       non-preceeding-turn segments, but contains the turn value
+            //       for segments before a turn.
+            (path_point.duration_until_turn - path_point.duration_of_turn) / 10.,
+            (path_point.weight_until_turn - path_point.weight_of_turn) /
+                facade.GetWeightMultiplier(),
+            path_point.datasource_id});
         geometry.locations.push_back(std::move(coordinate));
         geometry.osm_node_ids.push_back(facade.GetOSMNodeIDOfNode(path_point.turn_via_node));
     }

include/engine/guidance/assemble_steps.hpp

@@ -63,7 +63,6 @@ inline std::vector<RouteStep> assembleSteps(const datafacade::BaseDataFacade &fa
                                                             : target_node.forward_segment_id.id;
     const auto target_name_id = facade.GetNameIndex(target_node_id);
     const auto target_mode = facade.GetTravelMode(target_node_id);
-    auto target_classes = facade.GetClasses(facade.GetClassData(target_node_id));
 
     const auto number_of_segments = leg_geometry.GetNumberOfSegments();
 
@@ -88,7 +87,8 @@ inline std::vector<RouteStep> assembleSteps(const datafacade::BaseDataFacade &fa
                                           IntermediateIntersection::NO_INDEX,
                                           0,
                                           util::guidance::LaneTuple(),
-                                          {}};
+                                          {},
+                                          source_classes};
 
     if (leg_data.size() > 0)
     {
@@ -118,7 +118,8 @@ inline std::vector<RouteStep> assembleSteps(const datafacade::BaseDataFacade &fa
                 const auto destinations = facade.GetDestinationsForID(step_name_id);
                 const auto exits = facade.GetExitsForID(step_name_id);
                 const auto distance = leg_geometry.segment_distances[segment_index];
-                auto classes = facade.GetClasses(path_point.classes);
+                // intersections contain the classes of exiting road
+                intersection.classes = facade.GetClasses(path_point.classes);
 
                 steps.push_back(RouteStep{step_name_id,
                                           name.to_string(),
@@ -135,8 +136,7 @@ inline std::vector<RouteStep> assembleSteps(const datafacade::BaseDataFacade &fa
                                           maneuver,
                                           leg_geometry.FrontIndex(segment_index),
                                           leg_geometry.BackIndex(segment_index) + 1,
-                                          {intersection},
-                                          std::move(classes)});
+                                          {intersection}});
 
                 if (leg_data_index + 1 < leg_data.size())
                 {
@@ -196,6 +196,8 @@ inline std::vector<RouteStep> assembleSteps(const datafacade::BaseDataFacade &fa
         const auto distance = leg_geometry.segment_distances[segment_index];
         const EdgeWeight duration = segment_duration + target_duration;
         const EdgeWeight weight = segment_weight + target_weight;
+        // intersections contain the classes of exiting road
+        intersection.classes = facade.GetClasses(facade.GetClassData(target_node_id));
         BOOST_ASSERT(duration >= 0);
         steps.push_back(RouteStep{step_name_id,
                                   facade.GetNameForID(step_name_id).to_string(),
@@ -212,8 +214,7 @@ inline std::vector<RouteStep> assembleSteps(const datafacade::BaseDataFacade &fa
                                   maneuver,
                                   leg_geometry.FrontIndex(segment_index),
                                   leg_geometry.BackIndex(segment_index) + 1,
-                                  {intersection},
-                                  std::move(target_classes)});
+                                  {intersection}});
     }
     // In this case the source + target are on the same edge segment
     else
@@ -255,8 +256,7 @@ inline std::vector<RouteStep> assembleSteps(const datafacade::BaseDataFacade &fa
                                   std::move(maneuver),
                                   leg_geometry.FrontIndex(segment_index),
                                   leg_geometry.BackIndex(segment_index) + 1,
-                                  {intersection},
-                                  std::move(source_classes)});
+                                  {intersection}});
     }
 
     BOOST_ASSERT(segment_index == number_of_segments - 1);
@@ -269,6 +269,7 @@ inline std::vector<RouteStep> assembleSteps(const datafacade::BaseDataFacade &fa
         0,
         IntermediateIntersection::NO_INDEX,
         util::guidance::LaneTuple(),
+        {},
         {}};
 
     // This step has length zero, the only reason we need it is the target location
@@ -295,8 +296,7 @@ inline std::vector<RouteStep> assembleSteps(const datafacade::BaseDataFacade &fa
                               std::move(maneuver),
                               leg_geometry.locations.size() - 1,
                               leg_geometry.locations.size(),
-                              {intersection},
-                              std::move(target_classes)});
+                              {intersection}});
 
     BOOST_ASSERT(steps.front().intersections.size() == 1);
     BOOST_ASSERT(steps.front().intersections.front().bearings.size() == 1);

include/engine/guidance/lane_processing.hpp

@@ -20,7 +20,7 @@ namespace guidance
 // as separate maneuvers.
 OSRM_ATTR_WARN_UNUSED
 std::vector<RouteStep> anticipateLaneChange(std::vector<RouteStep> steps,
-                                            const double min_duration_needed_for_lane_change = 10);
+                                            const double min_distance_needed_for_lane_change = 200);
 
 } // namespace guidance
 } // namespace engine

include/engine/guidance/leg_geometry.hpp

@@ -38,8 +38,12 @@ struct LegGeometry
     struct Annotation
     {
         double distance; // distance in meters
-        double duration; // duration in seconds
-        double weight;   // weight value
+
+        // Total duration of a segment, in seconds, NOT including
+        // the turn penalty if the segment preceeds a turn
+        double duration;
+        double weight; // weight value, NOT including the turn weight
+
         DatasourceID datasource;
     };
     std::vector<Annotation> annotations;

include/engine/guidance/route_step.hpp

@@ -42,6 +42,7 @@ struct IntermediateIntersection
     // turn lane information
     util::guidance::LaneTuple lanes;
     extractor::guidance::TurnLaneDescription lane_description;
+    std::vector<std::string> classes;
 };
 
 inline IntermediateIntersection getInvalidIntersection()
@@ -52,6 +53,7 @@ inline IntermediateIntersection getInvalidIntersection()
             IntermediateIntersection::NO_INDEX,
             IntermediateIntersection::NO_INDEX,
             util::guidance::LaneTuple(),
+            {},
             {}};
 }
 
@@ -74,7 +76,6 @@ struct RouteStep
     std::size_t geometry_begin;
     std::size_t geometry_end;
     std::vector<IntermediateIntersection> intersections;
-    std::vector<std::string> classes;
 
     // remove all information from the route step, marking it as invalid (used to indicate empty
     // steps to be removed).
@@ -128,7 +129,6 @@ inline void RouteStep::Invalidate()
     geometry_end = 0;
     intersections.clear();
     intersections.push_back(getInvalidIntersection());
-    classes.clear();
 }
 
 // Elongate by another step in front

include/engine/guidance/verbosity_reduction.hpp

@@ -20,16 +20,6 @@ namespace guidance
 OSRM_ATTR_WARN_UNUSED
 std::vector<RouteStep> suppressShortNameSegments(std::vector<RouteStep> steps);
 
-// remove use lane information that is not actually a turn. For post-processing, we need to
-// associate lanes with every turn. Some of these use-lane instructions are not required after lane
-// anticipation anymore. This function removes all use lane instructions that are not actually used
-// anymore since all lanes going straight are used anyhow.
-// FIXME this is currently only a heuristic. We need knowledge on which lanes actually might become
-// turn lanes. If a straight lane becomes a turn lane, this might be something to consider. Right
-// now we bet on lane-anticipation to catch this.
-OSRM_ATTR_WARN_UNUSED
-std::vector<RouteStep> collapseUseLane(std::vector<RouteStep> steps);
-
 } // namespace guidance
 } // namespace engine
 } // namespace osrm

include/engine/internal_route_result.hpp

@@ -24,9 +24,17 @@ struct PathData
     // name of the street that leads to the turn
     unsigned name_id;
     // weight that is traveled on the segment until the turn is reached
+    // including the turn weight, if one exists
     EdgeWeight weight_until_turn;
-    // duration that is traveled on the segment until the turn is reached
+    // If this segment immediately preceeds a turn, then duration_of_turn
+    // will contain the weight of the turn.  Otherwise it will be 0.
+    EdgeWeight weight_of_turn;
+    // duration that is traveled on the segment until the turn is reached,
+    // including a turn if the segment preceeds one.
     EdgeWeight duration_until_turn;
+    // If this segment immediately preceeds a turn, then duration_of_turn
+    // will contain the duration of the turn.  Otherwise it will be 0.
+    EdgeWeight duration_of_turn;
     // instruction to execute at the turn
     extractor::guidance::TurnInstruction turn_instruction;
     // turn lane data

include/engine/plugins/match.hpp

@@ -32,8 +32,7 @@ class MatchPlugin : public BasePlugin
     {
     }
 
-    Status HandleRequest(const datafacade::ContiguousInternalMemoryDataFacadeBase &facade,
-                         const RoutingAlgorithmsInterface &algorithms,
+    Status HandleRequest(const RoutingAlgorithmsInterface &algorithms,
                          const api::MatchParameters &parameters,
                          util::json::Object &json_result) const;
 

include/engine/plugins/nearest.hpp

@@ -19,8 +19,7 @@ class NearestPlugin final : public BasePlugin
   public:
     explicit NearestPlugin(const int max_results);
 
-    Status HandleRequest(const datafacade::ContiguousInternalMemoryDataFacadeBase &facade,
-                         const RoutingAlgorithmsInterface &algorithms,
+    Status HandleRequest(const RoutingAlgorithmsInterface &algorithms,
                          const api::NearestParameters &params,
                          util::json::Object &result) const;
 

include/engine/plugins/table.hpp

@@ -21,8 +21,7 @@ class TablePlugin final : public BasePlugin
   public:
     explicit TablePlugin(const int max_locations_distance_table);
 
-    Status HandleRequest(const datafacade::ContiguousInternalMemoryDataFacadeBase &facade,
-                         const RoutingAlgorithmsInterface &algorithms,
+    Status HandleRequest(const RoutingAlgorithmsInterface &algorithms,
                          const api::TableParameters &params,
                          util::json::Object &result) const;
 

include/engine/plugins/tile.hpp

@@ -26,8 +26,7 @@ namespace plugins
 class TilePlugin final : public BasePlugin
 {
   public:
-    Status HandleRequest(const datafacade::ContiguousInternalMemoryDataFacadeBase &facade,
-                         const RoutingAlgorithmsInterface &algorithms,
+    Status HandleRequest(const RoutingAlgorithmsInterface &algorithms,
                          const api::TileParameters &parameters,
                          std::string &pbf_buffer) const;
 };

include/engine/plugins/trip.hpp

@@ -38,8 +38,7 @@ class TripPlugin final : public BasePlugin
   public:
     explicit TripPlugin(const int max_locations_trip_) : max_locations_trip(max_locations_trip_) {}
 
-    Status HandleRequest(const datafacade::ContiguousInternalMemoryDataFacadeBase &facade,
-                         const RoutingAlgorithmsInterface &algorithms,
+    Status HandleRequest(const RoutingAlgorithmsInterface &algorithms,
                          const api::TripParameters &parameters,
                          util::json::Object &json_result) const;
 };

include/engine/plugins/viaroute.hpp

@@ -32,8 +32,7 @@ class ViaRoutePlugin final : public BasePlugin
   public:
     explicit ViaRoutePlugin(int max_locations_viaroute, int max_alternatives);
 
-    Status HandleRequest(const datafacade::ContiguousInternalMemoryDataFacadeBase &facade,
-                         const RoutingAlgorithmsInterface &algorithms,
+    Status HandleRequest(const RoutingAlgorithmsInterface &algorithms,
                          const api::RouteParameters &route_parameters,
                          util::json::Object &json_result) const;
 };

include/engine/routing_algorithms.hpp

@@ -46,6 +46,8 @@ class RoutingAlgorithmsInterface
     GetTileTurns(const std::vector<datafacade::BaseDataFacade::RTreeLeaf> &edges,
                  const std::vector<std::size_t> &sorted_edge_indexes) const = 0;
 
+    virtual const DataFacadeBase &GetFacade() const = 0;
+
     virtual bool HasAlternativePathSearch() const = 0;
     virtual bool HasShortestPathSearch() const = 0;
     virtual bool HasDirectShortestPathSearch() const = 0;
@@ -59,7 +61,7 @@ template <typename Algorithm> class RoutingAlgorithms final : public RoutingAlgo
 {
   public:
     RoutingAlgorithms(SearchEngineData<Algorithm> &heaps,
-                      const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade)
+                      std::shared_ptr<const DataFacade<Algorithm>> facade)
         : heaps(heaps), facade(facade)
     {
     }
@@ -93,6 +95,8 @@ template <typename Algorithm> class RoutingAlgorithms final : public RoutingAlgo
     GetTileTurns(const std::vector<datafacade::BaseDataFacade::RTreeLeaf> &edges,
                  const std::vector<std::size_t> &sorted_edge_indexes) const final override;
 
+    const DataFacadeBase &GetFacade() const final override { return *facade; }
+
     bool HasAlternativePathSearch() const final override
     {
         return routing_algorithms::HasAlternativePathSearch<Algorithm>::value;
@@ -125,9 +129,7 @@ template <typename Algorithm> class RoutingAlgorithms final : public RoutingAlgo
 
   private:
     SearchEngineData<Algorithm> &heaps;
-
-    // Owned by shared-ptr passed to the query
-    const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade;
+    std::shared_ptr<const DataFacade<Algorithm>> facade;
 };
 
 template <typename Algorithm>
@@ -136,7 +138,7 @@ RoutingAlgorithms<Algorithm>::AlternativePathSearch(const PhantomNodes &phantom_
                                                     unsigned number_of_alternatives) const
 {
     return routing_algorithms::alternativePathSearch(
-        heaps, facade, phantom_node_pair, number_of_alternatives);
+        heaps, *facade, phantom_node_pair, number_of_alternatives);
 }
 
 template <typename Algorithm>
@@ -145,14 +147,14 @@ InternalRouteResult RoutingAlgorithms<Algorithm>::ShortestPathSearch(
     const boost::optional<bool> continue_straight_at_waypoint) const
 {
     return routing_algorithms::shortestPathSearch(
-        heaps, facade, phantom_node_pair, continue_straight_at_waypoint);
+        heaps, *facade, phantom_node_pair, continue_straight_at_waypoint);
 }
 
 template <typename Algorithm>
 InternalRouteResult
 RoutingAlgorithms<Algorithm>::DirectShortestPathSearch(const PhantomNodes &phantom_nodes) const
 {
-    return routing_algorithms::directShortestPathSearch(heaps, facade, phantom_nodes);
+    return routing_algorithms::directShortestPathSearch(heaps, *facade, phantom_nodes);
 }
 
 template <typename Algorithm>
@@ -162,7 +164,7 @@ RoutingAlgorithms<Algorithm>::ManyToManySearch(const std::vector<PhantomNode> &p
                                                const std::vector<std::size_t> &target_indices) const
 {
     return routing_algorithms::manyToManySearch(
-        heaps, facade, phantom_nodes, source_indices, target_indices);
+        heaps, *facade, phantom_nodes, source_indices, target_indices);
 }
 
 template <typename Algorithm>
@@ -174,7 +176,7 @@ inline routing_algorithms::SubMatchingList RoutingAlgorithms<Algorithm>::MapMatc
     const bool allow_splitting) const
 {
     return routing_algorithms::mapMatching(heaps,
-                                           facade,
+                                           *facade,
                                            candidates_list,
                                            trace_coordinates,
                                            trace_timestamps,
@@ -187,7 +189,7 @@ inline std::vector<routing_algorithms::TurnData> RoutingAlgorithms<Algorithm>::G
     const std::vector<datafacade::BaseDataFacade::RTreeLeaf> &edges,
     const std::vector<std::size_t> &sorted_edge_indexes) const
 {
-    return routing_algorithms::getTileTurns(facade, edges, sorted_edge_indexes);
+    return routing_algorithms::getTileTurns(*facade, edges, sorted_edge_indexes);
 }
 
 // CoreCH overrides

include/engine/routing_algorithms/alternative_path.hpp

@@ -1,7 +1,7 @@
 #ifndef ALTERNATIVE_PATH_ROUTING_HPP
 #define ALTERNATIVE_PATH_ROUTING_HPP
 
-#include "engine/datafacade/contiguous_internalmem_datafacade.hpp"
+#include "engine/datafacade.hpp"
 #include "engine/internal_route_result.hpp"
 
 #include "engine/algorithm.hpp"
@@ -16,17 +16,15 @@ namespace engine
 namespace routing_algorithms
 {
 
-InternalManyRoutesResult
-alternativePathSearch(SearchEngineData<ch::Algorithm> &search_engine_data,
-                      const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm> &facade,
-                      const PhantomNodes &phantom_node_pair,
-                      unsigned number_of_alternatives);
+InternalManyRoutesResult alternativePathSearch(SearchEngineData<ch::Algorithm> &search_engine_data,
+                                               const DataFacade<ch::Algorithm> &facade,
+                                               const PhantomNodes &phantom_node_pair,
+                                               unsigned number_of_alternatives);
 
-InternalManyRoutesResult
-alternativePathSearch(SearchEngineData<mld::Algorithm> &search_engine_data,
-                      const datafacade::ContiguousInternalMemoryDataFacade<mld::Algorithm> &facade,
-                      const PhantomNodes &phantom_node_pair,
-                      unsigned number_of_alternatives);
+InternalManyRoutesResult alternativePathSearch(SearchEngineData<mld::Algorithm> &search_engine_data,
+                                               const DataFacade<mld::Algorithm> &facade,
+                                               const PhantomNodes &phantom_node_pair,
+                                               unsigned number_of_alternatives);
 
 } // namespace routing_algorithms
 } // namespace engine

include/engine/routing_algorithms/direct_shortest_path.hpp

@@ -2,7 +2,7 @@
 #define DIRECT_SHORTEST_PATH_HPP
 
 #include "engine/algorithm.hpp"
-#include "engine/datafacade/contiguous_internalmem_datafacade.hpp"
+#include "engine/datafacade.hpp"
 #include "engine/internal_route_result.hpp"
 #include "engine/search_engine_data.hpp"
 
@@ -22,10 +22,9 @@ namespace routing_algorithms
 /// This variation is only an optimazation for graphs with slow queries, for example
 /// not fully contracted graphs.
 template <typename Algorithm>
-InternalRouteResult
-directShortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,
-                         const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-                         const PhantomNodes &phantom_nodes);
+InternalRouteResult directShortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,
+                                             const DataFacade<Algorithm> &facade,
+                                             const PhantomNodes &phantom_nodes);
 
 } // namespace routing_algorithms
 } // namespace engine

include/engine/routing_algorithms/many_to_many.hpp

@@ -2,7 +2,7 @@
 #define MANY_TO_MANY_ROUTING_HPP
 
 #include "engine/algorithm.hpp"
-#include "engine/datafacade/contiguous_internalmem_datafacade.hpp"
+#include "engine/datafacade.hpp"
 #include "engine/search_engine_data.hpp"
 
 #include "util/typedefs.hpp"
@@ -17,12 +17,11 @@ namespace routing_algorithms
 {
 
 template <typename Algorithm>
-std::vector<EdgeWeight>
-manyToManySearch(SearchEngineData<Algorithm> &engine_working_data,
-                 const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-                 const std::vector<PhantomNode> &phantom_nodes,
-                 const std::vector<std::size_t> &source_indices,
-                 const std::vector<std::size_t> &target_indices);
+std::vector<EdgeWeight> manyToManySearch(SearchEngineData<Algorithm> &engine_working_data,
+                                         const DataFacade<Algorithm> &facade,
+                                         const std::vector<PhantomNode> &phantom_nodes,
+                                         const std::vector<std::size_t> &source_indices,
+                                         const std::vector<std::size_t> &target_indices);
 
 } // namespace routing_algorithms
 } // namespace engine

include/engine/routing_algorithms/map_matching.hpp

@@ -2,7 +2,7 @@
 #define MAP_MATCHING_HPP
 
 #include "engine/algorithm.hpp"
-#include "engine/datafacade/contiguous_internalmem_datafacade.hpp"
+#include "engine/datafacade.hpp"
 #include "engine/map_matching/sub_matching.hpp"
 #include "engine/search_engine_data.hpp"
 
@@ -24,7 +24,7 @@ static const constexpr double DEFAULT_GPS_PRECISION = 5;
 //     P. Newson and J. Krumm; 2009; ACM GIS
 template <typename Algorithm>
 SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,
-                            const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+                            const DataFacade<Algorithm> &facade,
                             const CandidateLists &candidates_list,
                             const std::vector<util::Coordinate> &trace_coordinates,
                             const std::vector<unsigned> &trace_timestamps,

include/engine/routing_algorithms/routing_base.hpp

@@ -4,7 +4,7 @@
 #include "extractor/guidance/turn_instruction.hpp"
 
 #include "engine/algorithm.hpp"
-#include "engine/datafacade/contiguous_internalmem_datafacade.hpp"
+#include "engine/datafacade.hpp"
 #include "engine/internal_route_result.hpp"
 #include "engine/phantom_node.hpp"
 #include "engine/search_engine_data.hpp"
@@ -186,7 +186,9 @@ void annotatePath(const FacadeT &facade,
             unpacked_path.push_back(PathData{id_vector[segment_idx + 1],
                                              name_index,
                                              weight_vector[segment_idx],
+                                             0,
                                              duration_vector[segment_idx],
+                                             0,
                                              extractor::guidance::TurnInstruction::NO_TURN(),
                                              {{0, INVALID_LANEID}, INVALID_LANE_DESCRIPTIONID},
                                              travel_mode,
@@ -200,10 +202,15 @@ void annotatePath(const FacadeT &facade,
         if (facade.HasLaneData(turn_id))
             unpacked_path.back().lane_data = facade.GetLaneData(turn_id);
 
+        const auto turn_duration = facade.GetDurationPenaltyForEdgeID(turn_id);
+        const auto turn_weight = facade.GetWeightPenaltyForEdgeID(turn_id);
+
         unpacked_path.back().entry_class = facade.GetEntryClass(turn_id);
         unpacked_path.back().turn_instruction = turn_instruction;
-        unpacked_path.back().duration_until_turn += facade.GetDurationPenaltyForEdgeID(turn_id);
-        unpacked_path.back().weight_until_turn += facade.GetWeightPenaltyForEdgeID(turn_id);
+        unpacked_path.back().duration_until_turn += turn_duration;
+        unpacked_path.back().duration_of_turn = turn_duration;
+        unpacked_path.back().weight_until_turn += turn_weight;
+        unpacked_path.back().weight_of_turn = turn_weight;
         unpacked_path.back().pre_turn_bearing = facade.PreTurnBearing(turn_id);
         unpacked_path.back().post_turn_bearing = facade.PostTurnBearing(turn_id);
     }
@@ -262,7 +269,9 @@ void annotatePath(const FacadeT &facade,
             PathData{id_vector[start_index < end_index ? segment_idx + 1 : segment_idx - 1],
                      facade.GetNameIndex(target_node_id),
                      weight_vector[segment_idx],
+                     0,
                      duration_vector[segment_idx],
+                     0,
                      extractor::guidance::TurnInstruction::NO_TURN(),
                      {{0, INVALID_LANEID}, INVALID_LANE_DESCRIPTIONID},
                      facade.GetTravelMode(target_node_id),
@@ -320,7 +329,7 @@ void annotatePath(const FacadeT &facade,
 }
 
 template <typename Algorithm>
-double getPathDistance(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+double getPathDistance(const DataFacade<Algorithm> &facade,
                        const std::vector<PathData> unpacked_path,
                        const PhantomNode &source_phantom,
                        const PhantomNode &target_phantom)
@@ -373,12 +382,11 @@ double getPathDistance(const datafacade::ContiguousInternalMemoryDataFacade<Algo
 }
 
 template <typename AlgorithmT>
-InternalRouteResult
-extractRoute(const datafacade::ContiguousInternalMemoryDataFacade<AlgorithmT> &facade,
-             const EdgeWeight weight,
-             const PhantomNodes &phantom_nodes,
-             const std::vector<NodeID> &unpacked_nodes,
-             const std::vector<EdgeID> &unpacked_edges)
+InternalRouteResult extractRoute(const DataFacade<AlgorithmT> &facade,
+                                 const EdgeWeight weight,
+                                 const PhantomNodes &phantom_nodes,
+                                 const std::vector<NodeID> &unpacked_nodes,
+                                 const std::vector<EdgeID> &unpacked_edges)
 {
     InternalRouteResult raw_route_data;
     raw_route_data.segment_end_coordinates = {phantom_nodes};

include/engine/routing_algorithms/routing_base_ch.hpp

@@ -2,7 +2,7 @@
 #define OSRM_ENGINE_ROUTING_BASE_CH_HPP
 
 #include "engine/algorithm.hpp"
-#include "engine/datafacade/contiguous_internalmem_datafacade.hpp"
+#include "engine/datafacade.hpp"
 #include "engine/routing_algorithms/routing_base.hpp"
 #include "engine/search_engine_data.hpp"
 
@@ -23,7 +23,7 @@ namespace ch
 
 // Stalling
 template <bool DIRECTION, typename HeapT>
-bool stallAtNode(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+bool stallAtNode(const DataFacade<Algorithm> &facade,
                  const NodeID node,
                  const EdgeWeight weight,
                  const HeapT &query_heap)
@@ -49,7 +49,7 @@ bool stallAtNode(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm>
 }
 
 template <bool DIRECTION>
-void relaxOutgoingEdges(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
                         const NodeID node,
                         const EdgeWeight weight,
                         SearchEngineData<Algorithm>::QueryHeap &heap)
@@ -113,7 +113,7 @@ we need to add an offset to the termination criterion.
 static constexpr bool ENABLE_STALLING = true;
 static constexpr bool DISABLE_STALLING = false;
 template <bool DIRECTION, bool STALLING = ENABLE_STALLING>
-void routingStep(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+void routingStep(const DataFacade<Algorithm> &facade,
                  SearchEngineData<Algorithm>::QueryHeap &forward_heap,
                  SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
                  NodeID &middle_node_id,
@@ -186,8 +186,7 @@ void routingStep(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm>
 }
 
 template <bool UseDuration>
-EdgeWeight getLoopWeight(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-                         NodeID node)
+EdgeWeight getLoopWeight(const DataFacade<Algorithm> &facade, NodeID node)
 {
     EdgeWeight loop_weight = UseDuration ? MAXIMAL_EDGE_DURATION : INVALID_EDGE_WEIGHT;
     for (auto edge : facade.GetAdjacentEdgeRange(node))
@@ -227,7 +226,7 @@ EdgeWeight getLoopWeight(const datafacade::ContiguousInternalMemoryDataFacade<Al
  * original edge found.
  */
 template <typename BidirectionalIterator, typename Callback>
-void unpackPath(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+void unpackPath(const DataFacade<Algorithm> &facade,
                 BidirectionalIterator packed_path_begin,
                 BidirectionalIterator packed_path_end,
                 Callback &&callback)
@@ -327,7 +326,7 @@ void unpackPath(const FacadeT &facade,
  * @param to the node the CH edge finishes at
  * @param unpacked_path the sequence of original NodeIDs that make up the expanded CH edge
  */
-void unpackEdge(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+void unpackEdge(const DataFacade<Algorithm> &facade,
                 const NodeID from,
                 const NodeID to,
                 std::vector<NodeID> &unpacked_path);
@@ -354,7 +353,7 @@ void retrievePackedPathFromSingleHeap(const SearchEngineData<Algorithm>::QueryHe
 // requires
 // a force loop, if the heaps have been initialized with positive offsets.
 void search(SearchEngineData<Algorithm> &engine_working_data,
-            const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+            const DataFacade<Algorithm> &facade,
             SearchEngineData<Algorithm>::QueryHeap &forward_heap,
             SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
             std::int32_t &weight,
@@ -367,14 +366,13 @@ void search(SearchEngineData<Algorithm> &engine_working_data,
 // Requires the heaps for be empty
 // If heaps should be adjusted to be initialized outside of this function,
 // the addition of force_loop parameters might be required
-double
-getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
-                   const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm> &facade,
-                   SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                   SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
-                   const PhantomNode &source_phantom,
-                   const PhantomNode &target_phantom,
-                   int duration_upper_bound = INVALID_EDGE_WEIGHT);
+double getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
+                          const DataFacade<ch::Algorithm> &facade,
+                          SearchEngineData<Algorithm>::QueryHeap &forward_heap,
+                          SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
+                          const PhantomNode &source_phantom,
+                          const PhantomNode &target_phantom,
+                          int duration_upper_bound = INVALID_EDGE_WEIGHT);
 
 } // namespace ch
 
@@ -390,7 +388,7 @@ namespace corech
 // requires
 // a force loop, if the heaps have been initialized with positive offsets.
 void search(SearchEngineData<Algorithm> &engine_working_data,
-            const datafacade::ContiguousInternalMemoryDataFacade<corech::Algorithm> &facade,
+            const DataFacade<corech::Algorithm> &facade,
             SearchEngineData<ch::Algorithm>::QueryHeap &forward_heap,
             SearchEngineData<ch::Algorithm>::QueryHeap &reverse_heap,
             int &weight,
@@ -403,14 +401,13 @@ void search(SearchEngineData<Algorithm> &engine_working_data,
 // Requires the heaps for be empty
 // If heaps should be adjusted to be initialized outside of this function,
 // the addition of force_loop parameters might be required
-double
-getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
-                   const datafacade::ContiguousInternalMemoryDataFacade<corech::Algorithm> &facade,
-                   SearchEngineData<ch::Algorithm>::QueryHeap &forward_heap,
-                   SearchEngineData<ch::Algorithm>::QueryHeap &reverse_heap,
-                   const PhantomNode &source_phantom,
-                   const PhantomNode &target_phantom,
-                   int duration_upper_bound = INVALID_EDGE_WEIGHT);
+double getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
+                          const DataFacade<corech::Algorithm> &facade,
+                          SearchEngineData<ch::Algorithm>::QueryHeap &forward_heap,
+                          SearchEngineData<ch::Algorithm>::QueryHeap &reverse_heap,
+                          const PhantomNode &source_phantom,
+                          const PhantomNode &target_phantom,
+                          int duration_upper_bound = INVALID_EDGE_WEIGHT);
 
 template <typename RandomIter, typename FacadeT>
 void unpackPath(const FacadeT &facade,

include/engine/routing_algorithms/routing_base_mld.hpp

@@ -2,7 +2,7 @@
 #define OSRM_ENGINE_ROUTING_BASE_MLD_HPP
 
 #include "engine/algorithm.hpp"
-#include "engine/datafacade/contiguous_internalmem_datafacade.hpp"
+#include "engine/datafacade.hpp"
 #include "engine/routing_algorithms/routing_base.hpp"
 #include "engine/search_engine_data.hpp"
 
@@ -131,7 +131,7 @@ retrievePackedPathFromHeap(const SearchEngineData<Algorithm>::QueryHeap &forward
 }
 
 template <bool DIRECTION, typename... Args>
-void routingStep(const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+void routingStep(const DataFacade<Algorithm> &facade,
                  SearchEngineData<Algorithm>::QueryHeap &forward_heap,
                  SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
                  NodeID &middle_node,
@@ -262,7 +262,7 @@ using UnpackedPath = std::tuple<EdgeWeight, UnpackedNodes, UnpackedEdges>;
 
 template <typename... Args>
 UnpackedPath search(SearchEngineData<Algorithm> &engine_working_data,
-                    const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+                    const DataFacade<Algorithm> &facade,
                     SearchEngineData<Algorithm>::QueryHeap &forward_heap,
                     SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
                     const bool force_loop_forward,
@@ -390,7 +390,7 @@ UnpackedPath search(SearchEngineData<Algorithm> &engine_working_data,
 
 // Alias to be compatible with the CH-based search
 inline void search(SearchEngineData<Algorithm> &engine_working_data,
-                   const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
+                   const DataFacade<Algorithm> &facade,
                    SearchEngineData<Algorithm>::QueryHeap &forward_heap,
                    SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
                    EdgeWeight &weight,
@@ -442,14 +442,13 @@ void unpackPath(const FacadeT &facade,
     annotatePath(facade, phantom_nodes, unpacked_nodes, unpacked_edges, unpacked_path);
 }
 
-inline double
-getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
-                   const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-                   SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                   SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
-                   const PhantomNode &source_phantom,
-                   const PhantomNode &target_phantom,
-                   EdgeWeight weight_upper_bound = INVALID_EDGE_WEIGHT)
+inline double getNetworkDistance(SearchEngineData<Algorithm> &engine_working_data,
+                                 const DataFacade<Algorithm> &facade,
+                                 SearchEngineData<Algorithm>::QueryHeap &forward_heap,
+                                 SearchEngineData<Algorithm>::QueryHeap &reverse_heap,
+                                 const PhantomNode &source_phantom,
+                                 const PhantomNode &target_phantom,
+                                 EdgeWeight weight_upper_bound = INVALID_EDGE_WEIGHT)
 {
     forward_heap.Clear();
     reverse_heap.Clear();

include/engine/routing_algorithms/shortest_path.hpp

@@ -14,11 +14,10 @@ namespace routing_algorithms
 {
 
 template <typename Algorithm>
-InternalRouteResult
-shortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,
-                   const datafacade::ContiguousInternalMemoryDataFacade<Algorithm> &facade,
-                   const std::vector<PhantomNodes> &phantom_nodes_vector,
-                   const boost::optional<bool> continue_straight_at_waypoint);
+InternalRouteResult shortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,
+                                       const DataFacade<Algorithm> &facade,
+                                       const std::vector<PhantomNodes> &phantom_nodes_vector,
+                                       const boost::optional<bool> continue_straight_at_waypoint);
 
 } // namespace routing_algorithms
 } // namespace engine

include/engine/routing_algorithms/tile_turns.hpp

@@ -2,7 +2,8 @@
 #define OSRM_ENGINE_ROUTING_ALGORITHMS_TILE_TURNS_HPP
 
 #include "engine/algorithm.hpp"
-#include "engine/datafacade/contiguous_internalmem_datafacade.hpp"
+#include "engine/datafacade.hpp"
+#include "engine/datafacade/datafacade_base.hpp"
 
 #include "util/coordinate.hpp"
 #include "util/typedefs.hpp"
@@ -28,15 +29,13 @@ struct TurnData final
 
 using RTreeLeaf = datafacade::BaseDataFacade::RTreeLeaf;
 
-std::vector<TurnData>
-getTileTurns(const datafacade::ContiguousInternalMemoryDataFacade<ch::Algorithm> &facade,
-             const std::vector<RTreeLeaf> &edges,
-             const std::vector<std::size_t> &sorted_edge_indexes);
+std::vector<TurnData> getTileTurns(const DataFacade<ch::Algorithm> &facade,
+                                   const std::vector<RTreeLeaf> &edges,
+                                   const std::vector<std::size_t> &sorted_edge_indexes);
 
-std::vector<TurnData>
-getTileTurns(const datafacade::ContiguousInternalMemoryDataFacade<mld::Algorithm> &facade,
-             const std::vector<RTreeLeaf> &edges,
-             const std::vector<std::size_t> &sorted_edge_indexes);
+std::vector<TurnData> getTileTurns(const DataFacade<mld::Algorithm> &facade,
+                                   const std::vector<RTreeLeaf> &edges,
+                                   const std::vector<std::size_t> &sorted_edge_indexes);
 
 } // namespace routing_algorithms
 } // namespace engine

include/extractor/edge_based_graph_factory.hpp

@@ -17,6 +17,7 @@
 #include "extractor/profile_properties.hpp"
 #include "extractor/query_node.hpp"
 #include "extractor/restriction_map.hpp"
+#include "extractor/way_restriction_map.hpp"
 
 #include "util/concurrent_id_map.hpp"
 #include "util/deallocating_vector.hpp"
@@ -78,7 +79,6 @@ class EdgeBasedGraphFactory
                                    CompressedEdgeContainer &compressed_edge_container,
                                    const std::unordered_set<NodeID> &barrier_nodes,
                                    const std::unordered_set<NodeID> &traffic_lights,
-                                   std::shared_ptr<const RestrictionMap> restriction_map,
                                    const std::vector<util::Coordinate> &coordinates,
                                    const extractor::PackedOSMIDs &osm_node_ids,
                                    ProfileProperties profile_properties,
@@ -91,7 +91,9 @@ class EdgeBasedGraphFactory
              const std::string &turn_weight_penalties_filename,
              const std::string &turn_duration_penalties_filename,
              const std::string &turn_penalties_index_filename,
-             const std::string &cnbg_ebg_mapping_path);
+             const std::string &cnbg_ebg_mapping_path,
+             const RestrictionMap &node_restriction_map,
+             const WayRestrictionMap &way_restriction_map);
 
     // The following get access functions destroy the content in the factory
     void GetEdgeBasedEdges(util::DeallocatingVector<EdgeBasedEdge> &edges);
@@ -106,7 +108,7 @@ class EdgeBasedGraphFactory
     std::vector<util::guidance::BearingClass> GetBearingClasses() const;
     std::vector<util::guidance::EntryClass> GetEntryClasses() const;
 
-    unsigned GetHighestEdgeID();
+    std::uint64_t GetNumberOfEdgeBasedNodes() const;
 
     // Basic analysis of a turn (u --(e1)-- v --(e2)-- w)
     // with known angle.
@@ -134,12 +136,17 @@ class EdgeBasedGraphFactory
     std::vector<EdgeBasedNodeSegment> m_edge_based_node_segments;
     EdgeBasedNodeDataContainer m_edge_based_node_container;
     util::DeallocatingVector<EdgeBasedEdge> m_edge_based_edge_list;
-    EdgeID m_max_edge_id;
+
+    // The number of edge-based nodes is mostly made up out of the edges in the node-based graph.
+    // Any edge in the node-based graph represents a node in the edge-based graph. In addition, we
+    // add a set of artificial edge-based nodes into the mix to model via-way turn restrictions.
+    // See https://github.com/Project-OSRM/osrm-backend/issues/2681#issuecomment-313080353 for
+    // reference
+    std::uint64_t m_number_of_edge_based_nodes;
 
     const std::vector<util::Coordinate> &m_coordinates;
     const extractor::PackedOSMIDs &m_osm_node_ids;
     std::shared_ptr<util::NodeBasedDynamicGraph> m_node_based_graph;
-    std::shared_ptr<RestrictionMap const> m_restriction_map;
 
     const std::unordered_set<NodeID> &m_barrier_nodes;
     const std::unordered_set<NodeID> &m_traffic_lights;
@@ -152,14 +159,22 @@ class EdgeBasedGraphFactory
 
     unsigned RenumberEdges();
 
-    std::vector<NBGToEBG> GenerateEdgeExpandedNodes();
+    // During the generation of the edge-expanded nodes, we need to also generate duplicates that
+    // represent state during via-way restrictions (see
+    // https://github.com/Project-OSRM/osrm-backend/issues/2681#issuecomment-313080353). Access to
+    // the information on what to duplicate and how is provided via the way_restriction_map
+    std::vector<NBGToEBG> GenerateEdgeExpandedNodes(const WayRestrictionMap &way_restriction_map);
 
+    // Edge-expanded edges are generate for all valid turns. The validity can be checked via the
+    // restriction maps
     void GenerateEdgeExpandedEdges(ScriptingEnvironment &scripting_environment,
                                    const std::string &original_edge_data_filename,
                                    const std::string &turn_lane_data_filename,
                                    const std::string &turn_weight_penalties_filename,
                                    const std::string &turn_duration_penalties_filename,
-                                   const std::string &turn_penalties_index_filename);
+                                   const std::string &turn_penalties_index_filename,
+                                   const RestrictionMap &node_restriction_map,
+                                   const WayRestrictionMap &way_restriction_map);
 
     NBGToEBG InsertEdgeBasedNode(const NodeID u, const NodeID v);
 

include/extractor/extraction_containers.hpp

@@ -2,7 +2,6 @@
 #define EXTRACTION_CONTAINERS_HPP
 
 #include "extractor/first_and_last_segment_of_way.hpp"
-#include "extractor/guidance/turn_lane_types.hpp"
 #include "extractor/internal_extractor_edge.hpp"
 #include "extractor/query_node.hpp"
 #include "extractor/restriction.hpp"
@@ -10,69 +9,64 @@
 
 #include "storage/io.hpp"
 
-#include <cstdint>
-#include <stxxl/vector>
-#include <unordered_map>
-
 namespace osrm
 {
 namespace extractor
 {
 
 /**
- * Uses external memory containers from stxxl to store all the data that
+ * Uses  memory containers to store all the data that
  * is collected by the extractor callbacks.
  *
  * The data is the filtered, aggregated and finally written to disk.
  */
 class ExtractionContainers
 {
-#ifndef _MSC_VER
-    constexpr static unsigned stxxl_memory =
-        ((sizeof(std::size_t) == 4) ? std::numeric_limits<int>::max()
-                                    : std::numeric_limits<unsigned>::max());
-#else
-    const static unsigned stxxl_memory = ((sizeof(std::size_t) == 4) ? INT_MAX : UINT_MAX);
-#endif
-    void FlushVectors();
     void PrepareNodes();
     void PrepareRestrictions();
     void PrepareEdges(ScriptingEnvironment &scripting_environment);
 
     void WriteNodes(storage::io::FileWriter &file_out) const;
-    void WriteRestrictions(const std::string &restrictions_file_name);
+    void WriteConditionalRestrictions(const std::string &restrictions_file_name);
     void WriteEdges(storage::io::FileWriter &file_out) const;
     void WriteCharData(const std::string &file_name);
 
   public:
-    using STXXLNodeIDVector = stxxl::vector<OSMNodeID>;
-    using STXXLNodeVector = stxxl::vector<QueryNode>;
-    using STXXLEdgeVector = stxxl::vector<InternalExtractorEdge>;
-    using RestrictionsVector = std::vector<InputRestrictionContainer>;
-    using STXXLWayIDStartEndVector = stxxl::vector<FirstAndLastSegmentOfWay>;
-    using STXXLNameCharData = stxxl::vector<unsigned char>;
-    using STXXLNameOffsets = stxxl::vector<unsigned>;
+    using NodeIDVector = std::vector<OSMNodeID>;
+    using NodeVector = std::vector<QueryNode>;
+    using EdgeVector = std::vector<InternalExtractorEdge>;
+    using WayIDStartEndVector = std::vector<FirstAndLastSegmentOfWay>;
+    using NameCharData = std::vector<unsigned char>;
+    using NameOffsets = std::vector<unsigned>;
 
     std::vector<OSMNodeID> barrier_nodes;
     std::vector<OSMNodeID> traffic_lights;
-    STXXLNodeIDVector used_node_id_list;
-    STXXLNodeVector all_nodes_list;
-    STXXLEdgeVector all_edges_list;
-    STXXLNameCharData name_char_data;
-    STXXLNameOffsets name_offsets;
+    NodeIDVector used_node_id_list;
+    NodeVector all_nodes_list;
+    EdgeVector all_edges_list;
+    NameCharData name_char_data;
+    NameOffsets name_offsets;
     // an adjacency array containing all turn lane masks
-    RestrictionsVector restrictions_list;
-    STXXLWayIDStartEndVector way_start_end_id_list;
-    std::unordered_map<OSMNodeID, NodeID> external_to_internal_node_id_map;
+    WayIDStartEndVector way_start_end_id_list;
+
     unsigned max_internal_node_id;
+
+    // list of restrictions before we transform them into the output types. Input containers
+    // reference OSMNodeIDs. We can only transform them to the correct internal IDs after we've read
+    // everything. Without a multi-parse approach, we have to remember the output restrictions
+    // before converting them to the internal formats
+    std::vector<InputConditionalTurnRestriction> restrictions_list;
+
+    // turn restrictions split into conditional and unconditional turn restrictions
+    std::vector<ConditionalTurnRestriction> conditional_turn_restrictions;
     std::vector<TurnRestriction> unconditional_turn_restrictions;
 
     ExtractionContainers();
 
     void PrepareData(ScriptingEnvironment &scripting_environment,
-                     const std::string &output_file_name,
+                     const std::string &osrm_path,
                      const std::string &restrictions_file_name,
-                     const std::string &names_file_name);
+                     const std::string &names_data_path);
 };
 }
 }

include/extractor/extractor.hpp

@@ -85,12 +85,6 @@ class Extractor
                        std::vector<util::Coordinate> &coordinates,
                        extractor::PackedOSMIDs &osm_node_ids);
 
-    void WriteIntersectionClassificationData(
-        const std::string &output_file_name,
-        const std::vector<std::uint32_t> &node_based_intersection_classes,
-        const std::vector<util::guidance::BearingClass> &bearing_classes,
-        const std::vector<util::guidance::EntryClass> &entry_classes) const;
-
     // Writes compressed node based graph and its embedding into a file for osrm-partition to use.
     static void WriteCompressedNodeBasedGraph(const std::string &path,
                                               const util::NodeBasedDynamicGraph &graph,

include/extractor/extractor_callbacks.hpp

@@ -42,10 +42,10 @@ namespace extractor
 {
 
 class ExtractionContainers;
-struct InputRestrictionContainer;
 struct ExtractionNode;
 struct ExtractionWay;
 struct ProfileProperties;
+struct InputConditionalTurnRestriction;
 
 /**
  * This class is used by the extractor with the results of the
@@ -83,7 +83,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 boost::optional<InputRestrictionContainer> &restriction);
+    void ProcessRestriction(const InputConditionalTurnRestriction &restriction);
 
     // warning: caller needs to take care of synchronization!
     void ProcessWay(const osmium::Way &current_way, const ExtractionWay &result_way);

include/extractor/extractor_config.hpp

@@ -33,83 +33,57 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <array>
 #include <string>
 
+#include "storage/io_config.hpp"
+
 namespace osrm
 {
 namespace extractor
 {
 
-struct ExtractorConfig
+struct ExtractorConfig final : storage::IOConfig
 {
-    ExtractorConfig() noexcept : requested_num_threads(0) {}
-    void UseDefaultOutputNames()
+    ExtractorConfig() noexcept : IOConfig(
+                                     {
+                                         "",
+                                     },
+                                     {},
+                                     {".osrm",
+                                      ".osrm.restrictions",
+                                      ".osrm.names",
+                                      ".osrm.tls",
+                                      ".osrm.tld",
+                                      ".osrm.timestamp",
+                                      ".osrm.geometry",
+                                      ".osrm.nbg_nodes",
+                                      ".osrm.ebg_nodes",
+                                      ".osrm.edges",
+                                      ".osrm.ebg",
+                                      ".osrm.ramIndex",
+                                      ".osrm.fileIndex",
+                                      ".osrm.turn_duration_penalties",
+                                      ".osrm.turn_weight_penalties",
+                                      ".osrm.turn_penalties_index",
+                                      ".osrm.enw",
+                                      ".osrm.properties",
+                                      ".osrm.icd",
+                                      ".osrm.cnbg",
+                                      ".osrm.cnbg_to_ebg"}),
+                                 requested_num_threads(0)
     {
-        std::string basepath = input_path.string();
+    }
 
-        auto pos = std::string::npos;
-        std::array<std::string, 5> known_extensions{
-            {".osm.bz2", ".osm.pbf", ".osm.xml", ".pbf", ".osm"}};
-        for (auto ext : known_extensions)
-        {
-            pos = basepath.find(ext);
-            if (pos != std::string::npos)
-            {
-                basepath.replace(pos, ext.size(), "");
-                break;
-            }
-        }
-
-        output_file_name = basepath + ".osrm";
-        restriction_file_name = basepath + ".osrm.restrictions";
-        names_file_name = basepath + ".osrm.names";
-        turn_lane_descriptions_file_name = basepath + ".osrm.tls";
-        turn_lane_data_file_name = basepath + ".osrm.tld";
-        timestamp_file_name = basepath + ".osrm.timestamp";
-        geometry_output_path = basepath + ".osrm.geometry";
-        node_based_nodes_data_path = basepath + ".osrm.nbg_nodes";
-        edge_based_nodes_data_path = basepath + ".osrm.ebg_nodes";
-        edge_output_path = basepath + ".osrm.edges";
-        edge_graph_output_path = basepath + ".osrm.ebg";
-        rtree_nodes_output_path = basepath + ".osrm.ramIndex";
-        rtree_leafs_output_path = basepath + ".osrm.fileIndex";
-        turn_duration_penalties_path = basepath + ".osrm.turn_duration_penalties";
-        turn_weight_penalties_path = basepath + ".osrm.turn_weight_penalties";
-        turn_penalties_index_path = basepath + ".osrm.turn_penalties_index";
-        edge_based_node_weights_output_path = basepath + ".osrm.enw";
-        profile_properties_output_path = basepath + ".osrm.properties";
-        intersection_class_data_output_path = basepath + ".osrm.icd";
-        compressed_node_based_graph_output_path = basepath + ".osrm.cnbg";
-        cnbg_ebg_graph_mapping_output_path = basepath + ".osrm.cnbg_to_ebg";
+    void UseDefaultOutputNames(const boost::filesystem::path &base)
+    {
+        IOConfig::UseDefaultOutputNames(base);
     }
 
     boost::filesystem::path input_path;
     boost::filesystem::path profile_path;
 
-    std::string output_file_name;
-    std::string restriction_file_name;
-    std::string names_file_name;
-    std::string turn_lane_data_file_name;
-    std::string turn_lane_descriptions_file_name;
-    std::string timestamp_file_name;
-    std::string geometry_output_path;
-    std::string edge_output_path;
-    std::string edge_graph_output_path;
-    std::string node_based_nodes_data_path;
-    std::string edge_based_nodes_data_path;
-    std::string edge_based_node_weights_output_path;
-    std::string rtree_nodes_output_path;
-    std::string rtree_leafs_output_path;
-    std::string profile_properties_output_path;
-    std::string intersection_class_data_output_path;
-    std::string turn_weight_penalties_path;
-    std::string turn_duration_penalties_path;
-    std::string compressed_node_based_graph_output_path;
-    std::string cnbg_ebg_graph_mapping_output_path;
-
     unsigned requested_num_threads;
     unsigned small_component_size;
 
     bool generate_edge_lookup;
-    std::string turn_penalties_index_path;
 
     bool use_metadata;
     bool parse_conditionals;

include/extractor/files.hpp

@@ -225,7 +225,7 @@ inline void writeTurnData(const boost::filesystem::path &path, const TurnDataT &
     serialization::write(writer, turn_data);
 }
 
-// reads .osrm.nodes_data
+// reads .osrm.ebg_nodes
 template <typename NodeDataT>
 inline void readNodeData(const boost::filesystem::path &path, NodeDataT &node_data)
 {
@@ -239,7 +239,7 @@ inline void readNodeData(const boost::filesystem::path &path, NodeDataT &node_da
     serialization::read(reader, node_data);
 }
 
-// writes .osrm.nodes_data
+// writes .osrm.ebg_nodes
 template <typename NodeDataT>
 inline void writeNodeData(const boost::filesystem::path &path, const NodeDataT &node_data)
 {

include/extractor/first_and_last_segment_of_way.hpp

@@ -43,7 +43,7 @@ struct FirstAndLastSegmentOfWay
     }
 };
 
-struct FirstAndLastSegmentOfWayStxxlCompare
+struct FirstAndLastSegmentOfWayCompare
 {
     using value_type = FirstAndLastSegmentOfWay;
     bool operator()(const FirstAndLastSegmentOfWay &a, const FirstAndLastSegmentOfWay &b) const

include/extractor/graph_compressor.hpp

@@ -7,6 +7,7 @@
 
 #include <memory>
 #include <unordered_set>
+#include <vector>
 
 namespace osrm
 {
@@ -14,7 +15,7 @@ namespace extractor
 {
 
 class CompressedEdgeContainer;
-class RestrictionMap;
+struct TurnRestriction;
 
 class GraphCompressor
 {
@@ -23,7 +24,7 @@ class GraphCompressor
   public:
     void Compress(const std::unordered_set<NodeID> &barrier_nodes,
                   const std::unordered_set<NodeID> &traffic_lights,
-                  RestrictionMap &restriction_map,
+                  std::vector<TurnRestriction> &turn_restrictions,
                   util::NodeBasedDynamicGraph &graph,
                   CompressedEdgeContainer &geometry_compressor);
 

include/extractor/guidance/turn_classification.hpp

@@ -3,6 +3,7 @@
 
 #include "extractor/guidance/intersection.hpp"
 
+#include "util/coordinate.hpp"
 #include "util/guidance/bearing_class.hpp"
 #include "util/guidance/entry_class.hpp"
 
@@ -16,7 +17,7 @@ namespace guidance
 {
 
 std::pair<util::guidance::EntryClass, util::guidance::BearingClass>
-classifyIntersection(Intersection intersection);
+classifyIntersection(Intersection intersection, const osrm::util::Coordinate &location);
 
 } // namespace guidance
 } // namespace extractor

include/extractor/guidance/turn_instruction.hpp

@@ -49,7 +49,7 @@ const constexpr Enum EnterRotary = 12;                 // Enter a rotary
 const constexpr Enum EnterAndExitRotary = 13;          // Touching a rotary
 const constexpr Enum EnterRoundaboutIntersection = 14; // Entering a small Roundabout
 const constexpr Enum EnterAndExitRoundaboutIntersection = 15; // Touching a roundabout
-const constexpr Enum UseLane = 16; // No Turn, but you need to stay on a given lane!
+// depreacted: const constexpr Enum UseLane = 16; // No Turn, but you need to stay on a given lane!
 
 // Values below here are silent instructions
 const constexpr Enum NoTurn = 17;                // end of segment without turn/middle of a segment

include/extractor/guidance/turn_lane_data.hpp

@@ -24,7 +24,6 @@ struct TurnLaneData
     // a temporary data entry that does not need to be assigned to an entry.
     // This is the case in situations that use partition and require the entry to perform the
     // one-to-one mapping.
-    bool suppress_assignment;
     bool operator<(const TurnLaneData &other) const;
 };
 typedef std::vector<TurnLaneData> LaneDataVector;

include/extractor/node_data_container.hpp

@@ -104,6 +104,16 @@ template <storage::Ownership Ownership> class EdgeBasedNodeDataContainerImpl
         util::inplacePermutation(classes.begin(), classes.end(), permutation);
     }
 
+    // all containers have the exact same size
+    std::size_t Size() const
+    {
+        BOOST_ASSERT(geometry_ids.size() == name_ids.size());
+        BOOST_ASSERT(geometry_ids.size() == component_ids.size());
+        BOOST_ASSERT(geometry_ids.size() == travel_modes.size());
+        BOOST_ASSERT(geometry_ids.size() == classes.size());
+        return geometry_ids.size();
+    }
+
   private:
     Vector<GeometryID> geometry_ids;
     Vector<NameID> name_ids;

include/extractor/raster_source.hpp

@@ -125,10 +125,10 @@ class RasterSource
                  int _ymax);
 };
 
-class SourceContainer
+class RasterContainer
 {
   public:
-    SourceContainer() = default;
+    RasterContainer() = default;
 
     int LoadRasterSource(const std::string &path_string,
                          double xmin,

include/extractor/restriction.hpp

@@ -5,6 +5,7 @@
 #include "util/opening_hours.hpp"
 #include "util/typedefs.hpp"
 
+#include "mapbox/variant.hpp"
 #include <limits>
 
 namespace osrm
@@ -12,104 +13,242 @@ namespace osrm
 namespace extractor
 {
 
+// OSM offers two types of restrictions, via node and via-way restrictions. We parse both into the
+// same input container
+//
+// A restriction turning at a single node. This is the most common type of restriction:
+//
+// a - b - c
+//     |
+//     d
+//
+// ab via b to bd
+struct InputNodeRestriction
+{
+    OSMWayID from;
+    OSMNodeID via;
+    OSMWayID to;
+};
+
+// A restriction that uses a single via-way in between
+//
+// f - e - d
+//     |
+// a - b - c
+//
+// ab via be to ef -- no u turn
+struct InputWayRestriction
+{
+    OSMWayID from;
+    OSMWayID via;
+    OSMWayID to;
+};
+
+// Outside view of the variant, these are equal to the `which()` results
+enum RestrictionType
+{
+    NODE_RESTRICTION = 0,
+    WAY_RESTRICTION = 1,
+    NUM_RESTRICTION_TYPES = 2
+};
+
+struct InputTurnRestriction
+{
+    // keep in the same order as the turn restrictions below
+    mapbox::util::variant<InputNodeRestriction, InputWayRestriction> node_or_way;
+    bool is_only;
+
+    OSMWayID From() const
+    {
+        return node_or_way.which() == RestrictionType::NODE_RESTRICTION
+                   ? mapbox::util::get<InputNodeRestriction>(node_or_way).from
+                   : mapbox::util::get<InputWayRestriction>(node_or_way).from;
+    }
+
+    OSMWayID To() const
+    {
+        return node_or_way.which() == RestrictionType::NODE_RESTRICTION
+                   ? mapbox::util::get<InputNodeRestriction>(node_or_way).to
+                   : mapbox::util::get<InputWayRestriction>(node_or_way).to;
+    }
+
+    RestrictionType Type() const
+    {
+        BOOST_ASSERT(node_or_way.which() < RestrictionType::NUM_RESTRICTION_TYPES);
+        return static_cast<RestrictionType>(node_or_way.which());
+    }
+
+    InputWayRestriction &AsWayRestriction()
+    {
+        BOOST_ASSERT(node_or_way.which() == RestrictionType::WAY_RESTRICTION);
+        return mapbox::util::get<InputWayRestriction>(node_or_way);
+    }
+
+    const InputWayRestriction &AsWayRestriction() const
+    {
+        BOOST_ASSERT(node_or_way.which() == RestrictionType::WAY_RESTRICTION);
+        return mapbox::util::get<InputWayRestriction>(node_or_way);
+    }
+
+    InputNodeRestriction &AsNodeRestriction()
+    {
+        BOOST_ASSERT(node_or_way.which() == RestrictionType::NODE_RESTRICTION);
+        return mapbox::util::get<InputNodeRestriction>(node_or_way);
+    }
+
+    const InputNodeRestriction &AsNodeRestriction() const
+    {
+        BOOST_ASSERT(node_or_way.which() == RestrictionType::NODE_RESTRICTION);
+        return mapbox::util::get<InputNodeRestriction>(node_or_way);
+    }
+};
+struct InputConditionalTurnRestriction : InputTurnRestriction
+{
+    std::vector<util::OpeningHours> condition;
+};
+
+// OSRM manages restrictions based on node IDs which refer to the last node along the edge. Note
+// that this has the side-effect of not allowing parallel edges!
+struct NodeRestriction
+{
+    NodeID from;
+    NodeID via;
+    NodeID to;
+
+    // check if all parts of the restriction reference an actual node
+    bool Valid() const
+    {
+        return from != SPECIAL_NODEID && to != SPECIAL_NODEID && via != SPECIAL_NODEID;
+    };
+
+    bool operator==(const NodeRestriction &other) const
+    {
+        return std::tie(from, via, to) == std::tie(other.from, other.via, other.to);
+    }
+};
+
+// A way restriction in the context of OSRM requires translation into NodeIDs. This is due to the
+// compression happening in the graph creation process which would make it difficult to track
+// way-ids over a series of operations. Having access to the nodes directly allows look-up of the
+// edges in the processed structures
+struct WayRestriction
+{
+    // a way restriction in OSRM is essentially a dual node turn restriction;
+    //
+    // |     |
+    // c -x- b
+    // |     |
+    // d     a
+    //
+    // from ab via bxc to cd: no_uturn
+    //
+    // Technically, we would need only a,b,c,d to describe the full turn in terms of nodes. When
+    // parsing the relation, though, we do not know about the final representation in the node-based
+    // graph for the restriction. In case of a traffic light, for example, we might end up with bxc
+    // not being compressed to bc. For that reason, we need to maintain two node restrictions in
+    // case a way restrction is not fully collapsed
+    NodeRestriction in_restriction;
+    NodeRestriction out_restriction;
+
+    bool operator==(const WayRestriction &other) const
+    {
+        return std::tie(in_restriction, out_restriction) ==
+               std::tie(other.in_restriction, other.out_restriction);
+    }
+};
+
+// Wrapper for turn restrictions that gives more information on its type / handles the switch
+// between node/way/multi-way restrictions
 struct TurnRestriction
 {
-    union WayOrNode {
-        OSMNodeID_weak node;
-        OSMEdgeID_weak way;
-    };
-    WayOrNode via;
-    WayOrNode from;
-    WayOrNode to;
+    // keep in the same order as the turn restrictions above
+    mapbox::util::variant<NodeRestriction, WayRestriction> node_or_way;
+    bool is_only;
 
-    std::vector<util::OpeningHours> condition;
+    // construction for NodeRestrictions
+    explicit TurnRestriction(NodeRestriction node_restriction, bool is_only = false)
+        : node_or_way(node_restriction), is_only(is_only)
+    {
+    }
 
-    struct Bits
-    { // mostly unused
-        Bits()
-            : is_only(false), uses_via_way(false), unused2(false), unused3(false), unused4(false),
-              unused5(false), unused6(false), unused7(false)
+    // construction for WayRestrictions
+    explicit TurnRestriction(WayRestriction way_restriction, bool is_only = false)
+        : node_or_way(way_restriction), is_only(is_only)
+    {
+    }
+
+    explicit TurnRestriction()
+    {
+        node_or_way = NodeRestriction{SPECIAL_EDGEID, SPECIAL_NODEID, SPECIAL_EDGEID};
+    }
+
+    WayRestriction &AsWayRestriction()
+    {
+        BOOST_ASSERT(node_or_way.which() == RestrictionType::WAY_RESTRICTION);
+        return mapbox::util::get<WayRestriction>(node_or_way);
+    }
+
+    const WayRestriction &AsWayRestriction() const
+    {
+        BOOST_ASSERT(node_or_way.which() == RestrictionType::WAY_RESTRICTION);
+        return mapbox::util::get<WayRestriction>(node_or_way);
+    }
+
+    NodeRestriction &AsNodeRestriction()
+    {
+        BOOST_ASSERT(node_or_way.which() == RestrictionType::NODE_RESTRICTION);
+        return mapbox::util::get<NodeRestriction>(node_or_way);
+    }
+
+    const NodeRestriction &AsNodeRestriction() const
+    {
+        BOOST_ASSERT(node_or_way.which() == RestrictionType::NODE_RESTRICTION);
+        return mapbox::util::get<NodeRestriction>(node_or_way);
+    }
+
+    RestrictionType Type() const
+    {
+        BOOST_ASSERT(node_or_way.which() < RestrictionType::NUM_RESTRICTION_TYPES);
+        return static_cast<RestrictionType>(node_or_way.which());
+    }
+
+    // check if all elements of the edge are considered valid
+    bool Valid() const
+    {
+        if (node_or_way.which() == RestrictionType::WAY_RESTRICTION)
         {
+            auto const &restriction = AsWayRestriction();
+            return restriction.in_restriction.Valid() && restriction.out_restriction.Valid();
+        }
+        else
+        {
+            auto const &restriction = AsNodeRestriction();
+            return restriction.Valid();
         }
-
-        bool is_only : 1;
-        bool uses_via_way : 1;
-        bool unused2 : 1;
-        bool unused3 : 1;
-        bool unused4 : 1;
-        bool unused5 : 1;
-        bool unused6 : 1;
-        bool unused7 : 1;
-    } flags;
-
-    explicit TurnRestriction(NodeID node)
-    {
-        via.node = node;
-        from.node = SPECIAL_NODEID;
-        to.node = SPECIAL_NODEID;
     }
 
-    explicit TurnRestriction(const bool is_only = false)
+    bool operator==(const TurnRestriction &other) const
     {
-        via.node = SPECIAL_NODEID;
-        from.node = SPECIAL_NODEID;
-        to.node = SPECIAL_NODEID;
-        flags.is_only = is_only;
+        if (is_only != other.is_only)
+            return false;
+
+        if (Type() != other.Type())
+            return false;
+
+        if (Type() == RestrictionType::WAY_RESTRICTION)
+        {
+            return AsWayRestriction() == other.AsWayRestriction();
+        }
+        else
+        {
+            return AsNodeRestriction() == other.AsNodeRestriction();
+        }
     }
 };
 
-/**
- * This is just a wrapper around TurnRestriction used in the extractor.
- *
- * Could be merged with TurnRestriction. For now the type-destiction makes sense
- * as the format in which the restriction is presented in the extractor and in the
- * preprocessing is different. (see restriction_parser.cpp)
- */
-struct InputRestrictionContainer
+struct ConditionalTurnRestriction : TurnRestriction
 {
-    TurnRestriction restriction;
-
-    InputRestrictionContainer(EdgeID fromWay, EdgeID toWay, EdgeID vw)
-    {
-        restriction.from.way = fromWay;
-        restriction.to.way = toWay;
-        restriction.via.way = vw;
-    }
-    explicit InputRestrictionContainer(bool is_only = false)
-    {
-        restriction.from.way = SPECIAL_EDGEID;
-        restriction.to.way = SPECIAL_EDGEID;
-        restriction.via.node = SPECIAL_NODEID;
-        restriction.flags.is_only = is_only;
-    }
-
-    static InputRestrictionContainer min_value() { return InputRestrictionContainer(0, 0, 0); }
-    static InputRestrictionContainer max_value()
-    {
-        return InputRestrictionContainer(SPECIAL_EDGEID, SPECIAL_EDGEID, SPECIAL_EDGEID);
-    }
-};
-
-struct CmpRestrictionContainerByFrom
-{
-    using value_type = InputRestrictionContainer;
-    bool operator()(const InputRestrictionContainer &a, const InputRestrictionContainer &b) const
-    {
-        return a.restriction.from.way < b.restriction.from.way;
-    }
-    value_type max_value() const { return InputRestrictionContainer::max_value(); }
-    value_type min_value() const { return InputRestrictionContainer::min_value(); }
-};
-
-struct CmpRestrictionContainerByTo
-{
-    using value_type = InputRestrictionContainer;
-    bool operator()(const InputRestrictionContainer &a, const InputRestrictionContainer &b) const
-    {
-        return a.restriction.to.way < b.restriction.to.way;
-    }
-    value_type max_value() const { return InputRestrictionContainer::max_value(); }
-    value_type min_value() const { return InputRestrictionContainer::min_value(); }
+    std::vector<util::OpeningHours> condition;
 };
 }
 }

include/extractor/restriction_compressor.hpp

@@ -0,0 +1,46 @@
+#ifndef OSRM_EXTRACTOR_RESTRICTION_COMPRESSOR_HPP_
+#define OSRM_EXTRACTOR_RESTRICTION_COMPRESSOR_HPP_
+
+#include "util/typedefs.hpp"
+
+#include <boost/unordered_map.hpp>
+#include <vector>
+
+namespace osrm
+{
+namespace extractor
+{
+
+struct NodeRestriction;
+struct TurnRestriction;
+
+// OSRM stores restrictions in the form node -> node -> node instead of way -> node -> way (or
+// way->way->way) as it is done in OSM. These restrictions need to match the state of graph
+// compression which we perform in the graph compressor that removes certain degree two nodes from
+// the graph (all but the ones with penalties/barriers, as of the state of writing).
+// Since this graph compression ins performed after creating the restrictions in the extraction
+// phase, we need to update the involved nodes whenever one of the nodes is compressed.
+//
+//
+// !!!! Will bind to the restrictions vector and modify it in-place !!!!
+class RestrictionCompressor
+{
+  public:
+    RestrictionCompressor(std::vector<TurnRestriction> &restrictions);
+
+    // account for the compression of `from-via-to` into `from-to`
+    void Compress(const NodeID from, const NodeID via, const NodeID to);
+
+  private:
+    // a turn restriction is given as `from star via node to end`. Edges ending at `head` being
+    // contracted move the head pointer to their respective head. Edges starting at tail move the
+    // tail values to their respective tails. Way turn restrictions are represented by two
+    // node-restrictions, so we can focus on them alone
+    boost::unordered_multimap<NodeID, NodeRestriction *> starts;
+    boost::unordered_multimap<NodeID, NodeRestriction *> ends;
+};
+
+} // namespace extractor
+} // namespace osrm
+
+#endif // OSRM_EXTRACTOR_RESTRICTION_COMPRESSOR_HPP_

include/extractor/restriction_filter.hpp

@@ -0,0 +1,23 @@
+#ifndef OSRM_EXTRACTOR_RESTRICTION_FILTER_HPP_
+#define OSRM_EXTRACTOR_RESTRICTION_FILTER_HPP_
+
+#include "extractor/restriction.hpp"
+#include "util/node_based_graph.hpp"
+
+#include <vector>
+
+namespace osrm
+{
+namespace extractor
+{
+
+// To avoid handling invalid restrictions / creating unnecessary duplicate nodes for via-ways, we do
+// a pre-flight check for restrictions and remove all invalid restrictions from the data. Use as
+// `restrictions = removeInvalidRestrictions(std::move(restrictions))`
+std::vector<TurnRestriction> removeInvalidRestrictions(std::vector<TurnRestriction>,
+                                                       const util::NodeBasedDynamicGraph &);
+
+} // namespace extractor
+} // namespace osrm
+
+#endif // OSRM_EXTRACTOR_RESTRICTION_FILTER_HPP_

include/extractor/restriction_map.hpp

@@ -79,61 +79,8 @@ class RestrictionMap
     RestrictionMap() : m_count(0) {}
     RestrictionMap(const std::vector<TurnRestriction> &restriction_list);
 
-    // Replace end v with w in each turn restriction containing u as via node
-    template <class GraphT>
-    void FixupArrivingTurnRestriction(const NodeID node_u,
-                                      const NodeID node_v,
-                                      const NodeID node_w,
-                                      const GraphT &graph)
-    {
-        BOOST_ASSERT(node_u != SPECIAL_NODEID);
-        BOOST_ASSERT(node_v != SPECIAL_NODEID);
-        BOOST_ASSERT(node_w != SPECIAL_NODEID);
-
-        if (!IsViaNode(node_u))
-        {
-            return;
-        }
-
-        // find all potential start edges. It is more efficient to get a (small) list
-        // of potential start edges than iterating over all buckets
-        std::vector<NodeID> predecessors;
-        for (const EdgeID current_edge_id : graph.GetAdjacentEdgeRange(node_u))
-        {
-            const NodeID target = graph.GetTarget(current_edge_id);
-            if (node_v != target)
-            {
-                predecessors.push_back(target);
-            }
-        }
-
-        for (const NodeID node_x : predecessors)
-        {
-            const auto restriction_iterator = m_restriction_map.find({node_x, node_u});
-            if (restriction_iterator == m_restriction_map.end())
-            {
-                continue;
-            }
-
-            const unsigned index = restriction_iterator->second;
-            auto &bucket = m_restriction_bucket_list.at(index);
-
-            for (RestrictionTarget &restriction_target : bucket)
-            {
-                if (node_v == restriction_target.target_node)
-                {
-                    restriction_target.target_node = node_w;
-                }
-            }
-        }
-    }
-
     bool IsViaNode(const NodeID node) const;
 
-    // Replaces start edge (v, w) with (u, w). Only start node changes.
-    void
-    FixupStartingTurnRestriction(const NodeID node_u, const NodeID node_v, const NodeID node_w);
-
     // Check if edge (u, v) is the start of any turn restriction.
     // If so returns id of first target node.
     NodeID CheckForEmanatingIsOnlyTurn(const NodeID node_u, const NodeID node_v) const;

include/extractor/restriction_parser.hpp

@@ -44,7 +44,8 @@ class RestrictionParser
     RestrictionParser(bool use_turn_restrictions,
                       bool parse_conditionals,
                       std::vector<std::string> &restrictions);
-    std::vector<InputRestrictionContainer> TryParse(const osmium::Relation &relation) const;
+    boost::optional<InputConditionalTurnRestriction>
+    TryParse(const osmium::Relation &relation) const;
 
   private:
     bool ShouldIgnoreRestriction(const std::string &except_tag_string) const;

include/extractor/scripting_environment.hpp

@@ -54,16 +54,15 @@ class ScriptingEnvironment
 
     virtual std::vector<std::string> GetNameSuffixList() = 0;
     virtual std::vector<std::string> GetRestrictions() = 0;
-    virtual void SetupSources() = 0;
     virtual void ProcessTurn(ExtractionTurn &turn) = 0;
     virtual void ProcessSegment(ExtractionSegment &segment) = 0;
 
-    virtual void ProcessElements(
-        const osmium::memory::Buffer &buffer,
-        const RestrictionParser &restriction_parser,
-        std::vector<std::pair<const osmium::Node &, ExtractionNode>> &resulting_nodes,
-        std::vector<std::pair<const osmium::Way &, ExtractionWay>> &resulting_ways,
-        std::vector<boost::optional<InputRestrictionContainer>> &resulting_restrictions) = 0;
+    virtual void
+    ProcessElements(const osmium::memory::Buffer &buffer,
+                    const RestrictionParser &restriction_parser,
+                    std::vector<std::pair<const osmium::Node &, ExtractionNode>> &resulting_nodes,
+                    std::vector<std::pair<const osmium::Way &, ExtractionWay>> &resulting_ways,
+                    std::vector<InputConditionalTurnRestriction> &resulting_restrictions) = 0;
 };
 }
 }

include/extractor/scripting_environment_lua.hpp

@@ -23,7 +23,7 @@ struct LuaScriptingContext final
     void ProcessWay(const osmium::Way &, ExtractionWay &result);
 
     ProfileProperties properties;
-    SourceContainer sources;
+    RasterContainer raster_sources;
     sol::state state;
 
     bool has_turn_penalty_function;
@@ -37,6 +37,7 @@ struct LuaScriptingContext final
     sol::function segment_function;
 
     int api_version;
+    sol::table profile_table;
 };
 
 /**
@@ -50,7 +51,7 @@ class Sol2ScriptingEnvironment final : public ScriptingEnvironment
 {
   public:
     static const constexpr int SUPPORTED_MIN_API_VERSION = 0;
-    static const constexpr int SUPPORTED_MAX_API_VERSION = 1;
+    static const constexpr int SUPPORTED_MAX_API_VERSION = 2;
 
     explicit Sol2ScriptingEnvironment(const std::string &file_name);
     ~Sol2ScriptingEnvironment() override = default;
@@ -59,18 +60,19 @@ class Sol2ScriptingEnvironment final : public ScriptingEnvironment
 
     LuaScriptingContext &GetSol2Context();
 
+    std::vector<std::string> GetStringListFromTable(const std::string &table_name);
+    std::vector<std::string> GetStringListFromFunction(const std::string &function_name);
     std::vector<std::string> GetNameSuffixList() override;
     std::vector<std::string> GetRestrictions() override;
-    void SetupSources() override;
     void ProcessTurn(ExtractionTurn &turn) override;
     void ProcessSegment(ExtractionSegment &segment) override;
 
-    void ProcessElements(
-        const osmium::memory::Buffer &buffer,
-        const RestrictionParser &restriction_parser,
-        std::vector<std::pair<const osmium::Node &, ExtractionNode>> &resulting_nodes,
-        std::vector<std::pair<const osmium::Way &, ExtractionWay>> &resulting_ways,
-        std::vector<boost::optional<InputRestrictionContainer>> &resulting_restrictions) override;
+    void
+    ProcessElements(const osmium::memory::Buffer &buffer,
+                    const RestrictionParser &restriction_parser,
+                    std::vector<std::pair<const osmium::Node &, ExtractionNode>> &resulting_nodes,
+                    std::vector<std::pair<const osmium::Way &, ExtractionWay>> &resulting_ways,
+                    std::vector<InputConditionalTurnRestriction> &resulting_restrictions) override;
 
   private:
     void InitContext(LuaScriptingContext &context);

include/extractor/segment_data_container.hpp

@@ -55,6 +55,7 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
     using SegmentOffset = std::uint32_t;
     using SegmentWeightVector = PackedVector<SegmentWeight, SEGMENT_WEIGHT_BITS>;
     using SegmentDurationVector = PackedVector<SegmentDuration, SEGMENT_DURAITON_BITS>;
+    using SegmentDatasourceVector = Vector<DatasourceID>;
 
     SegmentDataContainerImpl() = default;
 
@@ -64,10 +65,12 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
                              SegmentWeightVector rev_weights_,
                              SegmentDurationVector fwd_durations_,
                              SegmentDurationVector rev_durations_,
-                             Vector<DatasourceID> datasources_)
+                             SegmentDatasourceVector fwd_datasources_,
+                             SegmentDatasourceVector rev_datasources_)
         : index(std::move(index_)), nodes(std::move(nodes_)), fwd_weights(std::move(fwd_weights_)),
           rev_weights(std::move(rev_weights_)), fwd_durations(std::move(fwd_durations_)),
-          rev_durations(std::move(rev_durations_)), datasources(std::move(datasources_))
+          rev_durations(std::move(rev_durations_)), fwd_datasources(std::move(fwd_datasources_)),
+          rev_datasources(std::move(rev_datasources_))
     {
     }
 
@@ -118,16 +121,16 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
 
     auto GetForwardDatasources(const DirectionalGeometryID id)
     {
-        const auto begin = datasources.begin() + index[id] + 1;
-        const auto end = datasources.begin() + index[id + 1];
+        const auto begin = fwd_datasources.begin() + index[id] + 1;
+        const auto end = fwd_datasources.begin() + index[id + 1];
 
         return boost::make_iterator_range(begin, end);
     }
 
     auto GetReverseDatasources(const DirectionalGeometryID id)
     {
-        const auto begin = datasources.begin() + index[id];
-        const auto end = datasources.begin() + index[id + 1] - 1;
+        const auto begin = rev_datasources.begin() + index[id];
+        const auto end = rev_datasources.begin() + index[id + 1] - 1;
 
         return boost::adaptors::reverse(boost::make_iterator_range(begin, end));
     }
@@ -179,16 +182,16 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
 
     auto GetForwardDatasources(const DirectionalGeometryID id) const
     {
-        const auto begin = datasources.cbegin() + index[id] + 1;
-        const auto end = datasources.cbegin() + index[id + 1];
+        const auto begin = fwd_datasources.cbegin() + index[id] + 1;
+        const auto end = fwd_datasources.cbegin() + index[id + 1];
 
         return boost::make_iterator_range(begin, end);
     }
 
     auto GetReverseDatasources(const DirectionalGeometryID id) const
     {
-        const auto begin = datasources.cbegin() + index[id];
-        const auto end = datasources.cbegin() + index[id + 1] - 1;
+        const auto begin = rev_datasources.cbegin() + index[id];
+        const auto end = rev_datasources.cbegin() + index[id + 1] - 1;
 
         return boost::adaptors::reverse(boost::make_iterator_range(begin, end));
     }
@@ -210,7 +213,8 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
     SegmentWeightVector rev_weights;
     SegmentDurationVector fwd_durations;
     SegmentDurationVector rev_durations;
-    Vector<DatasourceID> datasources;
+    SegmentDatasourceVector fwd_datasources;
+    SegmentDatasourceVector rev_datasources;
 };
 }
 

include/extractor/serialization.hpp

@@ -74,7 +74,8 @@ inline void read(storage::io::FileReader &reader,
     util::serialization::read(reader, segment_data.rev_weights);
     util::serialization::read(reader, segment_data.fwd_durations);
     util::serialization::read(reader, segment_data.rev_durations);
-    storage::serialization::read(reader, segment_data.datasources);
+    storage::serialization::read(reader, segment_data.fwd_datasources);
+    storage::serialization::read(reader, segment_data.rev_datasources);
 }
 
 template <storage::Ownership Ownership>
@@ -87,7 +88,8 @@ inline void write(storage::io::FileWriter &writer,
     util::serialization::write(writer, segment_data.rev_weights);
     util::serialization::write(writer, segment_data.fwd_durations);
     util::serialization::write(writer, segment_data.rev_durations);
-    storage::serialization::write(writer, segment_data.datasources);
+    storage::serialization::write(writer, segment_data.fwd_datasources);
+    storage::serialization::write(writer, segment_data.rev_datasources);
 }
 
 // read/write for turn data file
@@ -135,41 +137,71 @@ inline void write(storage::io::FileWriter &writer,
     storage::serialization::write(writer, node_data_container.classes);
 }
 
-// read/write for conditional turn restrictions file
-inline void read(storage::io::FileReader &reader, std::vector<TurnRestriction> &restrictions)
+inline void read(storage::io::FileReader &reader, NodeRestriction &restriction)
 {
-    auto num_indices = reader.ReadElementCount64();
-    restrictions.reserve(num_indices);
-    TurnRestriction restriction;
-    while (num_indices > 0)
-    {
-        bool is_only;
-        reader.ReadInto(restriction.via);
-        reader.ReadInto(restriction.from);
-        reader.ReadInto(restriction.to);
-        reader.ReadInto(is_only);
-        auto num_conditions = reader.ReadElementCount64();
-        restriction.condition.resize(num_conditions);
-        for (uint64_t i = 0; i < num_conditions; i++)
-        {
-            reader.ReadInto(restriction.condition[i].modifier);
-            storage::serialization::read(reader, restriction.condition[i].times);
-            storage::serialization::read(reader, restriction.condition[i].weekdays);
-            storage::serialization::read(reader, restriction.condition[i].monthdays);
-        }
-        restriction.flags.is_only = is_only;
+    reader.ReadInto(restriction.from);
+    reader.ReadInto(restriction.via);
+    reader.ReadInto(restriction.to);
+}
 
-        restrictions.push_back(std::move(restriction));
-        num_indices--;
+inline void write(storage::io::FileWriter &writer, const NodeRestriction &restriction)
+{
+    writer.WriteOne(restriction.from);
+    writer.WriteOne(restriction.via);
+    writer.WriteOne(restriction.to);
+}
+
+inline void read(storage::io::FileReader &reader, WayRestriction &restriction)
+{
+    read(reader, restriction.in_restriction);
+    read(reader, restriction.out_restriction);
+}
+
+inline void write(storage::io::FileWriter &writer, const WayRestriction &restriction)
+{
+    write(writer, restriction.in_restriction);
+    write(writer, restriction.out_restriction);
+}
+
+inline void read(storage::io::FileReader &reader, TurnRestriction &restriction)
+{
+    reader.ReadInto(restriction.is_only);
+    std::uint32_t restriction_type;
+    reader.ReadInto(restriction_type);
+    if (restriction_type == RestrictionType::WAY_RESTRICTION)
+    {
+        WayRestriction way_restriction;
+        read(reader, way_restriction);
+        restriction.node_or_way = std::move(way_restriction);
+    }
+    else
+    {
+        BOOST_ASSERT(restriction_type == RestrictionType::NODE_RESTRICTION);
+        NodeRestriction node_restriction;
+        read(reader, node_restriction);
+        restriction.node_or_way = std::move(node_restriction);
     }
 }
 
 inline void write(storage::io::FileWriter &writer, const TurnRestriction &restriction)
 {
-    writer.WriteOne(restriction.via);
-    writer.WriteOne(restriction.from);
-    writer.WriteOne(restriction.to);
-    writer.WriteOne(restriction.flags.is_only);
+    writer.WriteOne(restriction.is_only);
+    const std::uint32_t restriction_type = restriction.Type();
+    writer.WriteOne(restriction_type);
+    if (restriction.Type() == RestrictionType::WAY_RESTRICTION)
+    {
+        write(writer, mapbox::util::get<WayRestriction>(restriction.node_or_way));
+    }
+    else
+    {
+        BOOST_ASSERT(restriction.Type() == RestrictionType::NODE_RESTRICTION);
+        write(writer, mapbox::util::get<NodeRestriction>(restriction.node_or_way));
+    }
+}
+
+inline void write(storage::io::FileWriter &writer, const ConditionalTurnRestriction &restriction)
+{
+    write(writer, static_cast<const TurnRestriction &>(restriction));
     writer.WriteElementCount64(restriction.condition.size());
     for (const auto &c : restriction.condition)
     {
@@ -179,6 +211,68 @@ inline void write(storage::io::FileWriter &writer, const TurnRestriction &restri
         storage::serialization::write(writer, c.monthdays);
     }
 }
+
+inline void read(storage::io::FileReader &reader, ConditionalTurnRestriction &restriction)
+{
+    read(reader, static_cast<TurnRestriction &>(restriction));
+    const auto num_conditions = reader.ReadElementCount64();
+    restriction.condition.resize(num_conditions);
+    for (uint64_t i = 0; i < num_conditions; i++)
+    {
+        reader.ReadInto(restriction.condition[i].modifier);
+        storage::serialization::read(reader, restriction.condition[i].times);
+        storage::serialization::read(reader, restriction.condition[i].weekdays);
+        storage::serialization::read(reader, restriction.condition[i].monthdays);
+    }
+}
+
+// read/write for conditional turn restrictions file
+inline void read(storage::io::FileReader &reader, std::vector<TurnRestriction> &restrictions)
+{
+    auto num_indices = reader.ReadElementCount64();
+    restrictions.reserve(num_indices);
+    TurnRestriction restriction;
+    while (num_indices-- > 0)
+    {
+        read(reader, restriction);
+        restrictions.push_back(std::move(restriction));
+    }
+}
+
+inline void write(storage::io::FileWriter &writer, const std::vector<TurnRestriction> &restrictions)
+{
+    const auto num_indices = restrictions.size();
+    writer.WriteElementCount64(num_indices);
+    const auto write_restriction = [&writer](const auto &restriction) {
+        write(writer, restriction);
+    };
+    std::for_each(restrictions.begin(), restrictions.end(), write_restriction);
+}
+
+// read/write for conditional turn restrictions file
+inline void read(storage::io::FileReader &reader,
+                 std::vector<ConditionalTurnRestriction> &restrictions)
+{
+    auto num_indices = reader.ReadElementCount64();
+    restrictions.reserve(num_indices);
+    ConditionalTurnRestriction restriction;
+    while (num_indices-- > 0)
+    {
+        read(reader, restriction);
+        restrictions.push_back(std::move(restriction));
+    }
+}
+
+inline void write(storage::io::FileWriter &writer,
+                  const std::vector<ConditionalTurnRestriction> &restrictions)
+{
+    const auto num_indices = restrictions.size();
+    writer.WriteElementCount64(num_indices);
+    const auto write_restriction = [&writer](const auto &restriction) {
+        write(writer, restriction);
+    };
+    std::for_each(restrictions.begin(), restrictions.end(), write_restriction);
+}
 }
 }
 }

include/extractor/way_restriction_map.hpp

@@ -0,0 +1,89 @@
+#ifndef OSRM_EXTRACTOR_WAY_RESTRICTION_MAP_HPP_
+#define OSRM_EXTRACTOR_WAY_RESTRICTION_MAP_HPP_
+
+#include <utility>
+#include <vector>
+
+// to access the turn restrictions
+#include <boost/unordered_map.hpp>
+
+#include "extractor/restriction.hpp"
+#include "util/integer_range.hpp"
+#include "util/typedefs.hpp"
+
+// Given the compressed representation of via-way turn restrictions, we provide a fast access into
+// the restrictions to indicate which turns may be restricted due to a way in between
+namespace osrm
+{
+namespace extractor
+{
+
+class WayRestrictionMap
+{
+  public:
+    struct ViaWay
+    {
+        NodeID from;
+        NodeID to;
+    };
+    WayRestrictionMap(const std::vector<TurnRestriction> &turn_restrictions);
+
+    // Check if an edge between two nodes is a restricted turn. The check needs to be performed to
+    // find duplicated nodes during the creation of edge-based-edges
+    bool IsViaWay(const NodeID from, const NodeID to) const;
+
+    // Every via-way results in a duplicated node that is required in the edge-based-graph. This
+    // count is essentially the same as the number of valid via-way restrictions (except for
+    // non-only restrictions that share the same in/via combination)
+    std::size_t NumberOfDuplicatedNodes() const;
+
+    // Returns a representative for each duplicated node, consisting of the representative ID (first
+    // ID of the nodes restrictions) and the from/to vertices of the via-way
+    // This is used to construct edge based nodes that act as intermediate nodes.
+    std::vector<ViaWay> DuplicatedNodeRepresentatives() const;
+
+    // Access all duplicated NodeIDs for a set of nodes indicating a via way
+    util::range<DuplicatedNodeID> DuplicatedNodeIDs(const NodeID from, const NodeID to) const;
+
+    // check whether a turn onto a given node is restricted, when coming from a duplicated node
+    bool IsRestricted(DuplicatedNodeID duplicated_node, const NodeID to) const;
+
+    // changes edge_based_node to the correct duplicated_node_id in case node_based_from,
+    // node_based_via, node_based_to can be identified with a restriction group
+    NodeID RemapIfRestricted(const NodeID edge_based_node,
+                             const NodeID node_based_from,
+                             const NodeID node_based_via,
+                             const NodeID node_based_to,
+                             const NodeID number_of_edge_based_nodes) const;
+
+  private:
+    DuplicatedNodeID AsDuplicatedNodeID(const RestrictionID restriction_id) const;
+
+    // access all restrictions that have the same starting way and via way. Any duplicated node
+    // represents the same in-way + via-way combination. This vector contains data about all
+    // restrictions and their assigned duplicated nodes. It indicates the minimum restriciton ID
+    // that is represented by the next node. The ID of a node is defined as the position of the
+    // lower bound of the restrictions ID within this array
+    //
+    // a - b
+    //     |
+    // y - c - x
+    //
+    // restriction nodes | restriction id
+    // a - b - c - x : 5
+    // a - b - c - y : 6
+    //
+    //                    EBN: 0 . | 2 | 3 | 4 ...
+    // duplicated node groups: ... | 5 | 7 | ...
+    std::vector<DuplicatedNodeID> duplicated_node_groups;
+
+    boost::unordered_multimap<std::pair<NodeID, NodeID>, RestrictionID> restriction_starts;
+    boost::unordered_multimap<std::pair<NodeID, NodeID>, RestrictionID> restriction_ends;
+
+    std::vector<TurnRestriction> restriction_data;
+};
+
+} // namespace extractor
+} // namespace osrm
+
+#endif // OSRM_EXTRACTOR_WAY_RESTRICTION_MAP_HPP_

include/nodejs/node_osrm_support.hpp

@@ -176,6 +176,64 @@ inline engine_config_ptr argumentsToEngineConfig(const Nan::FunctionCallbackInfo
         return engine_config_ptr();
     }
 
+    // Set EngineConfig system-wide limits on construction, if requested
+
+    auto max_locations_trip = params->Get(Nan::New("max_locations_trip").ToLocalChecked());
+    auto max_locations_viaroute = params->Get(Nan::New("max_locations_viaroute").ToLocalChecked());
+    auto max_locations_distance_table =
+        params->Get(Nan::New("max_locations_distance_table").ToLocalChecked());
+    auto max_locations_map_matching =
+        params->Get(Nan::New("max_locations_map_matching").ToLocalChecked());
+    auto max_results_nearest = params->Get(Nan::New("max_results_nearest").ToLocalChecked());
+    auto max_alternatives = params->Get(Nan::New("max_alternatives").ToLocalChecked());
+
+    if (!max_locations_trip->IsUndefined() && !max_locations_trip->IsNumber())
+    {
+        Nan::ThrowError("max_locations_trip must be an integral number");
+        return engine_config_ptr();
+    }
+    if (!max_locations_viaroute->IsUndefined() && !max_locations_viaroute->IsNumber())
+    {
+        Nan::ThrowError("max_locations_viaroute must be an integral number");
+        return engine_config_ptr();
+    }
+    if (!max_locations_distance_table->IsUndefined() && !max_locations_distance_table->IsNumber())
+    {
+        Nan::ThrowError("max_locations_distance_table must be an integral number");
+        return engine_config_ptr();
+    }
+    if (!max_locations_map_matching->IsUndefined() && !max_locations_map_matching->IsNumber())
+    {
+        Nan::ThrowError("max_locations_map_matching must be an integral number");
+        return engine_config_ptr();
+    }
+    if (!max_results_nearest->IsUndefined() && !max_results_nearest->IsNumber())
+    {
+        Nan::ThrowError("max_results_nearest must be an integral number");
+        return engine_config_ptr();
+    }
+    if (!max_alternatives->IsUndefined() && !max_alternatives->IsNumber())
+    {
+        Nan::ThrowError("max_alternatives must be an integral number");
+        return engine_config_ptr();
+    }
+
+    if (max_locations_trip->IsNumber())
+        engine_config->max_locations_trip = static_cast<int>(max_locations_trip->NumberValue());
+    if (max_locations_viaroute->IsNumber())
+        engine_config->max_locations_viaroute =
+            static_cast<int>(max_locations_viaroute->NumberValue());
+    if (max_locations_distance_table->IsNumber())
+        engine_config->max_locations_distance_table =
+            static_cast<int>(max_locations_distance_table->NumberValue());
+    if (max_locations_map_matching->IsNumber())
+        engine_config->max_locations_map_matching =
+            static_cast<int>(max_locations_map_matching->NumberValue());
+    if (max_results_nearest->IsNumber())
+        engine_config->max_results_nearest = static_cast<int>(max_results_nearest->NumberValue());
+    if (max_alternatives->IsNumber())
+        engine_config->max_alternatives = static_cast<int>(max_alternatives->NumberValue());
+
     return engine_config;
 }
 
@@ -721,7 +779,7 @@ argumentsToRouteParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
         if (value->IsBoolean())
         {
             params->alternatives = value->BooleanValue();
-            params->number_of_alternatives = 1u;
+            params->number_of_alternatives = value->BooleanValue() ? 1u : 0u;
         }
         else if (value->IsNumber())
         {

include/partition/partition_config.hpp

@@ -6,56 +6,31 @@
 #include <array>
 #include <string>
 
+#include "storage/io_config.hpp"
+
 namespace osrm
 {
 namespace partition
 {
 
-struct PartitionConfig
+struct PartitionConfig final : storage::IOConfig
 {
     PartitionConfig()
-        : requested_num_threads(0), balance(1.2), boundary_factor(0.25), num_optimizing_cuts(10),
+        : IOConfig(
+              {".osrm", ".osrm.fileIndex", ".osrm.ebg_nodes"},
+              {".osrm.hsgr", ".osrm.cnbg"},
+              {".osrm.ebg", ".osrm.cnbg", ".osrm.cnbg_to_ebg", ".osrm.partition", ".osrm.cells"}),
+          requested_num_threads(0), balance(1.2), boundary_factor(0.25), num_optimizing_cuts(10),
           small_component_size(1000),
-          max_cell_sizes{128, 128 * 32, 128 * 32 * 16, 128 * 32 * 16 * 32}
+          max_cell_sizes({128, 128 * 32, 128 * 32 * 16, 128 * 32 * 16 * 32})
     {
     }
 
-    void UseDefaults()
+    void UseDefaultOutputNames(const boost::filesystem::path &base)
     {
-        std::string basepath = base_path.string();
-
-        const std::string ext = ".osrm";
-        const auto pos = basepath.find(ext);
-        if (pos != std::string::npos)
-        {
-            basepath.replace(pos, ext.size(), "");
-        }
-        else
-        {
-            // unknown extension
-        }
-
-        edge_based_graph_path = basepath + ".osrm.ebg";
-        compressed_node_based_graph_path = basepath + ".osrm.cnbg";
-        cnbg_ebg_mapping_path = basepath + ".osrm.cnbg_to_ebg";
-        file_index_path = basepath + ".osrm.fileIndex";
-        partition_path = basepath + ".osrm.partition";
-        storage_path = basepath + ".osrm.cells";
-        node_data_path = basepath + ".osrm.ebg_nodes";
-        hsgr_path = basepath + ".osrm.hsgr";
+        IOConfig::UseDefaultOutputNames(base);
     }
 
-    // might be changed to the node based graph at some point
-    boost::filesystem::path base_path;
-    boost::filesystem::path edge_based_graph_path;
-    boost::filesystem::path compressed_node_based_graph_path;
-    boost::filesystem::path cnbg_ebg_mapping_path;
-    boost::filesystem::path partition_path;
-    boost::filesystem::path file_index_path;
-    boost::filesystem::path storage_path;
-    boost::filesystem::path node_data_path;
-    boost::filesystem::path hsgr_path;
-
     unsigned requested_num_threads;
 
     double balance;