Merge pull request #1902 from Project-OSRM/4.9.1

Bug fix release 4.9.1
Include the travel mode in the last instruction by copying it from the previous instruction.
2016-01-19 19:00:11 -05:00 · 2016-01-19 23:23:32 +01:00 · 2016-01-19 21:26:30 +01:00 · 2016-01-19 20:31:14 +01:00 · 2016-01-19 20:31:03 +01:00 · 2016-01-19 17:38:02 +01:00
716 changed files with 36373 additions and 37423 deletions
@@ -1,14 +0,0 @@
-# Kind-specific patterns to check AST nodes against. Both python-clang and
-# libclang docs explain CursorKind, with differences in detail. See also:
-#  - https://github.com/llvm-mirror/clang/blob/aca4fe314a55cacae29e1548cb7bfd2119c6df4c/bindings/python/clang/cindex.py#L599
-#  - http://clang.llvm.org/doxygen/group__CINDEX.html#gaaccc432245b4cd9f2d470913f9ef0013
-#  - https://docs.python.org/2/library/re.html#regular-expression-syntax
-
-class_decl: '^([A-Z]+[a-z]+)+$'
-struct_decl: '^([A-Z]+[a-z]+)+$'
-field_decl: '^[a-z_]+$'
-var_decl: '^[a-z]+[a-z0-9_]*$'
-parm_decl: '^[a-z]*[a-z0-9_]*$'
-namespace: '^[a-z_]*$'
-cxx_method: '^([A-Z]+[a-z]+)+$'
-function_decl: '^[a-z]+([A-Z]+[a-z]+)*$'
@@ -40,7 +40,6 @@ Thumbs.db
 # build related files #
 #######################
 /build/
-/example/build/
 /cmake/postinst

 # Eclipse related files #
@@ -79,5 +78,3 @@ stxxl.errlog
 # Deprecated config file #
 ##########################
 /server.ini
-
-*.swp
@@ -1,9 +1,4 @@
-#language: cpp
-# This makes travis use the thin image which boots faster
-language: generic
-
-
-# sudo:required is needed for trusty images
+language: cpp
 sudo: required
 dist: trusty

@@ -16,26 +11,9 @@ branches:
    - develop

 matrix:
-  fast_finish: true
-
  include:

-    # Debug Builds
-    - os: linux
-      compiler: gcc
-      addons: &gcc5
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-5', 'libbz2-dev', 'libstxxl-dev', 'libstxxl1', 'libxml2-dev', 'libzip-dev', 'lua5.1', 'liblua5.1-0-dev', 'rubygems-integration', 'libtbb-dev', 'libgdal-dev', 'libluabind-dev', 'libboost-all-dev']
-      env: COMPILER='g++-5' BUILD_TYPE='Debug'
-
-    - os: linux
-      compiler: gcc
-      addons: &gcc48
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-4.8', 'libbz2-dev', 'libstxxl-dev', 'libstxxl1', 'libxml2-dev', 'libzip-dev', 'lua5.1', 'liblua5.1-0-dev', 'rubygems-integration', 'libtbb-dev', 'libgdal-dev', 'libluabind-dev', 'libboost-all-dev']
-      env: COMPILER='g++-4.8' BUILD_TYPE='Debug'
+    # 1/ Linux Clang Builds

    - os: linux
      compiler: clang
@@ -43,14 +21,37 @@ matrix:
        apt:
          sources: ['llvm-toolchain-precise', 'ubuntu-toolchain-r-test']
          packages: ['clang-3.8', 'libbz2-dev', 'libstxxl-dev', 'libstxxl1', 'libxml2-dev', 'libzip-dev', 'lua5.1', 'liblua5.1-0-dev', 'rubygems-integration', 'libtbb-dev', 'libgdal-dev', 'libluabind-dev', 'libboost-all-dev']
-      env: COMPILER='clang++-3.8' BUILD_TYPE='Debug' RUN_CLANG_FORMAT=ON
+      env: COMPILER='clang++-3.8' BUILD_TYPE='Release'

-    - os: osx
-      osx_image: xcode7.3
+    - os: linux
      compiler: clang
-      env: COMPILER='clang++' BUILD_TYPE='Debug'
+      addons: &clang38
+        apt:
+          sources: ['llvm-toolchain-precise', 'ubuntu-toolchain-r-test']
+          packages: ['clang-3.8', 'libbz2-dev', 'libstxxl-dev', 'libstxxl1', 'libxml2-dev', 'libzip-dev', 'lua5.1', 'liblua5.1-0-dev', 'rubygems-integration', 'libtbb-dev', 'libgdal-dev', 'libluabind-dev', 'libboost-all-dev']
+      env: COMPILER='clang++-3.8' BUILD_TYPE='Release' BUILD_SHARED_LIBS=ON
+
+    - os: linux
+      compiler: clang
+      addons: *clang38
+      env: COMPILER='clang++-3.8' BUILD_TYPE='Debug'
+
+
+    # 2/ Linux GCC Builds
+    - os: linux
+      compiler: gcc
+      addons: &gcc48
+        apt:
+          sources: ['ubuntu-toolchain-r-test']
+          packages: ['g++-4.8', 'libbz2-dev', 'libstxxl-dev', 'libstxxl1', 'libxml2-dev', 'libzip-dev', 'lua5.1', 'liblua5.1-0-dev', 'rubygems-integration', 'libtbb-dev', 'libgdal-dev', 'libluabind-dev', 'libboost-all-dev']
+      env: COMPILER='g++-4.8' BUILD_TYPE='Release'
+
+    - os: linux
+      compiler: gcc
+      addons: *gcc48
+      env: COMPILER='g++-4.8' BUILD_TYPE='Debug'
+

-    # Release Builds
    - os: linux
      compiler: gcc
      addons: &gcc5
@@ -59,28 +60,6 @@ matrix:
          packages: ['g++-5', 'libbz2-dev', 'libstxxl-dev', 'libstxxl1', 'libxml2-dev', 'libzip-dev', 'lua5.1', 'liblua5.1-0-dev', 'rubygems-integration', 'libtbb-dev', 'libgdal-dev', 'libluabind-dev', 'libboost-all-dev']
      env: COMPILER='g++-5' BUILD_TYPE='Release'

-    - os: linux
-      compiler: gcc
-      addons: &gcc48
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-4.8', 'libbz2-dev', 'libstxxl-dev', 'libstxxl1', 'libxml2-dev', 'libzip-dev', 'lua5.1', 'liblua5.1-0-dev', 'rubygems-integration', 'libtbb-dev', 'libgdal-dev', 'libluabind-dev', 'libboost-all-dev']
-      env: COMPILER='g++-4.8' BUILD_TYPE='Release'
-
-    - os: linux
-      compiler: clang
-      addons: &clang38
-        apt:
-          sources: ['llvm-toolchain-precise', 'ubuntu-toolchain-r-test']
-          packages: ['clang-3.8', 'libbz2-dev', 'libstxxl-dev', 'libstxxl1', 'libxml2-dev', 'libzip-dev', 'lua5.1', 'liblua5.1-0-dev', 'rubygems-integration', 'libtbb-dev', 'libgdal-dev', 'libluabind-dev', 'libboost-all-dev']
-      env: COMPILER='clang++-3.8' BUILD_TYPE='Release'
-
-    - os: osx
-      osx_image: xcode7.3
-      compiler: clang
-      env: COMPILER='clang++' BUILD_TYPE='Release'
-
-    # Shared Library
    - os: linux
      compiler: gcc
      addons: &gcc5
@@ -90,12 +69,9 @@ matrix:
      env: COMPILER='g++-5' BUILD_TYPE='Release' BUILD_SHARED_LIBS=ON

    - os: linux
-      compiler: clang
-      addons: &clang38
-        apt:
-          sources: ['llvm-toolchain-precise', 'ubuntu-toolchain-r-test']
-          packages: ['clang-3.8', 'libbz2-dev', 'libstxxl-dev', 'libstxxl1', 'libxml2-dev', 'libzip-dev', 'lua5.1', 'liblua5.1-0-dev', 'rubygems-integration', 'libtbb-dev', 'libgdal-dev', 'libluabind-dev', 'libboost-all-dev']
-      env: COMPILER='clang++-3.8' BUILD_TYPE='Release' BUILD_SHARED_LIBS=ON
+      compiler: gcc
+      addons: *gcc5
+      env: COMPILER='g++-5' BUILD_TYPE='Debug'


    # Disabled until tests all pass on OSX:
@@ -116,6 +92,16 @@ matrix:
    #  compiler: clang
    #  env: COMPILER='clang++' BUILD_TYPE='Release' BUILD_SHARED_LIBS=ON

+    #- os: osx
+    #  osx_image: xcode7
+    #  compiler: clang
+    #  env: COMPILER='clang++' BUILD_TYPE='Debug'
+
+    #- os: osx
+    #  osx_image: xcode7
+    #  compiler: clang
+    #  env: COMPILER='clang++' BUILD_TYPE='Release'
+
    #- os: osx
    #  osx_image: xcode7
    #  compiler: clang
@@ -131,46 +117,30 @@ install:
      mkdir cmake && travis_retry wget --quiet -O - ${CMAKE_URL} | tar --strip-components=1 -xz -C cmake
      export PATH=${DEPS_DIR}/cmake/bin:${PATH}

+      OSMOSIS_URL="http://bretth.dev.openstreetmap.org/osmosis-build/osmosis-latest.tgz"
+      mkdir osmosis && travis_retry wget --quiet -O - ${OSMOSIS_URL} | tar -xz -C osmosis
+      export PATH=${DEPS_DIR}/osmosis/bin:${PATH}
+
    elif [[ "${TRAVIS_OS_NAME}" == "osx" ]]; then
-      # implicit deps, but seem to be installed by default with recent images: libxml2 GDAL boost
-      brew install cmake libzip libstxxl lua51 luabind tbb md5sha1sum
+      brew install cmake boost libzip libstxxl libxml2 lua51 luabind tbb GDAL osmosis
    fi

 before_script:
  - cd ${TRAVIS_BUILD_DIR}
-  - |
-    if [[ "${TRAVIS_OS_NAME}" == "linux" ]]; then
-      ./scripts/check_taginfo.py taginfo.json profiles/car.lua
-    fi
  - rvm use 1.9.3
  - gem install bundler
  - bundle install
-  - mkdir build && pushd build
+  - mkdir build && cd build
  - export CXX=${COMPILER}
  - export OSRM_PORT=5000 OSRM_TIMEOUT=60
-  - cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DBUILD_SHARED_LIBS=${BUILD_SHARED_LIBS:-OFF} -DBUILD_TOOLS=1 -DENABLE_CCACHE=0
+  - cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DBUILD_SHARED_LIBS=${BUILD_SHARED_LIBS:-OFF} -DBUILD_TOOLS=1

 script:
  - make --jobs=2
  - make tests --jobs=2
  - make benchmarks
-  - sudo make install
-  - |
-    if [[ "${TRAVIS_OS_NAME}" == "linux" ]]; then
-      sudo ldconfig
-    fi
-  - ./extractor-tests
-  - ./engine-tests
+  - ./algorithm-tests
+  - ./datastructure-tests
  - ./util-tests
-  - popd
+  - cd ..
  - cucumber -p verify
-  - make -C test/data
-  - mkdir example/build && pushd example/build
-  - cmake ..
-  - make
-  - ./osrm-example ../../test/data/monaco.osrm
-  - popd
-  - |
-    if [ -n "$RUN_CLANG_FORMAT" ]; then
-      ./scripts/format.sh || true # we don't want to fail just yet
-    fi
@@ -1,3 +0,0 @@
-# 5.0.0
-   - Renamed osrm-prepare into osrm-contract
-   - osrm-contract does not need a profile parameter anymore
@@ -9,7 +9,7 @@ endif()
 project(OSRM C CXX)
 set(OSRM_VERSION_MAJOR 4)
 set(OSRM_VERSION_MINOR 9)
-set(OSRM_VERSION_PATCH 1)
+set(OSRM_VERSION_PATCH 0)

 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 include(CheckCXXCompilerFlag)
@@ -29,14 +29,15 @@ if(WIN32 AND MSVC_VERSION LESS 1800)
  message(FATAL_ERROR "Building with Microsoft compiler needs Visual Studio 2013 or later (Express version works too)")
 endif()

-option(ENABLE_CCACHE "Speed up incremental rebuilds via ccache" ON)
 option(ENABLE_JSON_LOGGING "Adds additional JSON debug logging to the response" OFF)
+option(DEBUG_GEOMETRY "Enables an option to dump GeoJSON of the final routing graph" OFF)
 option(BUILD_TOOLS "Build OSRM tools" OFF)
-option(ENABLE_ASSERTIONS OFF)

-include_directories(BEFORE ${CMAKE_CURRENT_BINARY_DIR}/include/)
-include_directories(BEFORE ${CMAKE_CURRENT_SOURCE_DIR}/include/)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR})
+include_directories(${CMAKE_CURRENT_BINARY_DIR})
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include/)
 include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/third_party/)
+include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/third_party/libosmium/include/)

 add_custom_target(FingerPrintConfigure ALL ${CMAKE_COMMAND}
  "-DOUTPUT_DIR=${CMAKE_CURRENT_BINARY_DIR}"
@@ -45,57 +46,74 @@ add_custom_target(FingerPrintConfigure ALL ${CMAKE_COMMAND}
  COMMENT "Configuring revision fingerprint"
  VERBATIM)

-add_custom_target(tests DEPENDS engine-tests extractor-tests util-tests server-tests)
+add_custom_target(tests DEPENDS datastructure-tests algorithm-tests util-tests)
 add_custom_target(benchmarks DEPENDS rtree-bench)

 set(BOOST_COMPONENTS date_time filesystem iostreams program_options regex system thread unit_test_framework)

 configure_file(
-  ${CMAKE_CURRENT_SOURCE_DIR}/include/util/version.hpp.in
-  ${CMAKE_CURRENT_BINARY_DIR}/include/util/version.hpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/util/version.hpp.in
+  ${CMAKE_CURRENT_BINARY_DIR}/util/version.hpp
 )
-file(GLOB UtilGlob src/util/*.cpp)
-file(GLOB ExtractorGlob src/extractor/*.cpp src/extractor/*/*.cpp)
-file(GLOB ContractorGlob src/contractor/*.cpp)
-file(GLOB StorageGlob src/storage/*.cpp)
-file(GLOB ServerGlob src/server/*.cpp src/server/**/*.cpp)
-file(GLOB EngineGlob src/engine/*.cpp src/engine/**/*.cpp)
-file(GLOB ExtractorTestsGlob unit_tests/extractor/*.cpp)
-file(GLOB EngineTestsGlob unit_tests/engine/*.cpp)
+file(GLOB ExtractorGlob extractor/*.cpp data_structures/hilbert_value.cpp)
+file(GLOB ImporterGlob data_structures/import_edge.cpp data_structures/external_memory_node.cpp data_structures/raster_source.cpp)
+add_library(IMPORT OBJECT ${ImporterGlob})
+add_library(LOGGER OBJECT util/simple_logger.cpp)
+add_library(PHANTOMNODE OBJECT data_structures/phantom_node.cpp)
+add_library(RASTERSOURCE OBJECT data_structures/raster_source.cpp)
+add_library(EXCEPTION OBJECT util/osrm_exception.cpp)
+add_library(MERCATOR OBJECT util/mercator.cpp)
+add_library(ANGLE OBJECT util/compute_angle.cpp)
+
+set(ExtractorSources extract.cpp ${ExtractorGlob})
+add_executable(osrm-extract ${ExtractorSources} $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:FINGERPRINT> $<TARGET_OBJECTS:IMPORT> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:MERCATOR> $<TARGET_OBJECTS:COMPRESSEDEDGE> $<TARGET_OBJECTS:GRAPHCOMPRESSOR> $<TARGET_OBJECTS:RESTRICTION> $<TARGET_OBJECTS:ANGLE>)
+
+add_library(RESTRICTION OBJECT data_structures/restriction_map.cpp)
+add_library(COMPRESSEDEDGE OBJECT data_structures/compressed_edge_container.cpp)
+add_library(GRAPHCOMPRESSOR OBJECT algorithms/graph_compressor.cpp)
+
+file(GLOB PrepareGlob contractor/*.cpp data_structures/hilbert_value.cpp {RestrictionMapGlob})
+set(PrepareSources prepare.cpp ${PrepareGlob})
+add_executable(osrm-prepare ${PrepareSources} $<TARGET_OBJECTS:ANGLE> $<TARGET_OBJECTS:FINGERPRINT> $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:IMPORT> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:RESTRICTION> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:MERCATOR> $<TARGET_OBJECTS:COMPRESSEDEDGE> $<TARGET_OBJECTS:GRAPHCOMPRESSOR>)
+
+file(GLOB ServerGlob server/*.cpp)
+file(GLOB DescriptorGlob descriptors/*.cpp)
+file(GLOB DatastructureGlob data_structures/search_engine_data.cpp data_structures/route_parameters.cpp util/bearing.cpp)
+file(GLOB CoordinateGlob data_structures/coordinate.cpp algorithms/coordinate_calculation.cpp)
+file(GLOB AlgorithmGlob algorithms/polyline_compressor.cpp algorithms/polyline_formatter.cpp algorithms/douglas_peucker.cpp)
+file(GLOB HttpGlob server/http/*.cpp)
+file(GLOB LibOSRMGlob library/*.cpp)
+file(GLOB DataStructureTestsGlob unit_tests/data_structures/*.cpp data_structures/hilbert_value.cpp)
+file(GLOB AlgorithmTestsGlob unit_tests/algorithms/*.cpp algorithms/graph_compressor.cpp)
 file(GLOB UtilTestsGlob unit_tests/util/*.cpp)
-file(GLOB ServerTestsGlob unit_tests/server/*.cpp)
-file(GLOB IOTestsGlob unit_tests/io/*.cpp)

-add_library(UTIL OBJECT ${UtilGlob})
-add_library(EXTRACTOR OBJECT ${ExtractorGlob})
-add_library(CONTRACTOR OBJECT ${ContractorGlob})
-add_library(STORAGE OBJECT ${StorageGlob})
-add_library(ENGINE OBJECT ${EngineGlob})
-add_library(SERVER OBJECT ${ServerGlob})
+set(
+  OSRMSources
+  ${LibOSRMGlob}
+  ${DescriptorGlob}
+  ${DatastructureGlob}
+  ${AlgorithmGlob}
+  ${HttpGlob}
+)

-add_dependencies(UTIL FingerPrintConfigure)
-set_target_properties(UTIL PROPERTIES LINKER_LANGUAGE CXX)
+add_library(COORDINATE OBJECT ${CoordinateGlob})
+add_library(OSRM ${OSRMSources} $<TARGET_OBJECTS:ANGLE> $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:FINGERPRINT> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:RESTRICTION> $<TARGET_OBJECTS:PHANTOMNODE> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:MERCATOR> $<TARGET_OBJECTS:IMPORT>)

-add_executable(osrm-extract src/tools/extract.cpp)
-add_executable(osrm-contract src/tools/contract.cpp)
-add_executable(osrm-routed src/tools/routed.cpp $<TARGET_OBJECTS:SERVER> $<TARGET_OBJECTS:UTIL>)
-add_executable(osrm-datastore src/tools/store.cpp $<TARGET_OBJECTS:UTIL>)
-add_library(osrm src/osrm/osrm.cpp $<TARGET_OBJECTS:ENGINE> $<TARGET_OBJECTS:UTIL>)
-add_library(osrm_extract $<TARGET_OBJECTS:EXTRACTOR> $<TARGET_OBJECTS:UTIL>)
-add_library(osrm_contract $<TARGET_OBJECTS:CONTRACTOR> $<TARGET_OBJECTS:UTIL>)
-add_library(osrm_store $<TARGET_OBJECTS:STORAGE> $<TARGET_OBJECTS:UTIL>)
+add_library(FINGERPRINT OBJECT util/fingerprint.cpp)
+add_dependencies(FINGERPRINT FingerPrintConfigure)
+add_dependencies(OSRM FingerPrintConfigure)
+set_target_properties(FINGERPRINT PROPERTIES LINKER_LANGUAGE CXX)
+
+add_executable(osrm-routed routed.cpp ${ServerGlob} $<TARGET_OBJECTS:EXCEPTION>)
+add_executable(osrm-datastore datastore.cpp $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:FINGERPRINT> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:MERCATOR>)

 # Unit tests
-add_executable(engine-tests EXCLUDE_FROM_ALL unit_tests/engine_tests.cpp ${EngineTestsGlob} $<TARGET_OBJECTS:ENGINE> $<TARGET_OBJECTS:UTIL>)
-add_executable(extractor-tests EXCLUDE_FROM_ALL unit_tests/extractor_tests.cpp ${ExtractorTestsGlob} $<TARGET_OBJECTS:EXTRACTOR> $<TARGET_OBJECTS:UTIL>)
-add_executable(util-tests EXCLUDE_FROM_ALL unit_tests/util_tests.cpp ${UtilTestsGlob} $<TARGET_OBJECTS:UTIL>)
-add_executable(server-tests EXCLUDE_FROM_ALL unit_tests/server_tests.cpp ${ServerTestsGlob} $<TARGET_OBJECTS:UTIL> $<TARGET_OBJECTS:SERVER>)
+add_executable(datastructure-tests EXCLUDE_FROM_ALL unit_tests/datastructure_tests.cpp ${DataStructureTestsGlob} $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:PHANTOMNODE> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:MERCATOR> $<TARGET_OBJECTS:COMPRESSEDEDGE> $<TARGET_OBJECTS:GRAPHCOMPRESSOR> $<TARGET_OBJECTS:RESTRICTION> $<TARGET_OBJECTS:RASTERSOURCE>)
+add_executable(algorithm-tests EXCLUDE_FROM_ALL unit_tests/algorithm_tests.cpp ${AlgorithmTestsGlob} $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:PHANTOMNODE> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:RESTRICTION> $<TARGET_OBJECTS:COMPRESSEDEDGE>)
+add_executable(util-tests EXCLUDE_FROM_ALL unit_tests/util_tests.cpp ${UtilTestsGlob})

 # Benchmarks
-add_executable(rtree-bench EXCLUDE_FROM_ALL src/benchmarks/static_rtree.cpp $<TARGET_OBJECTS:UTIL>)
-
-target_include_directories(util-tests PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/unit_tests)
-target_include_directories(rtree-bench PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/unit_tests)
+add_executable(rtree-bench EXCLUDE_FROM_ALL benchmarks/static_rtree.cpp $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:PHANTOMNODE> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:MERCATOR>)

 # Check the release mode
 if(NOT CMAKE_BUILD_TYPE MATCHES Debug)
@@ -103,7 +121,6 @@ if(NOT CMAKE_BUILD_TYPE MATCHES Debug)
 endif()
 if(CMAKE_BUILD_TYPE MATCHES Debug)
  message(STATUS "Configuring OSRM in debug mode")
-  set(ENABLE_ASSERTIONS ON)
  if(NOT ${CMAKE_CXX_COMPILER_ID} STREQUAL "MSVC")

  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-inline -fno-omit-frame-pointer")
@@ -158,7 +175,7 @@ endif()

 # Configuring compilers
 if(${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pedantic -Wuninitialized -Wunreachable-code -Wstrict-overflow=2 -D_FORTIFY_SOURCE=2 -fPIC -fcolor-diagnostics")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pedantic -Wuninitialized -Wunreachable-code -Wstrict-overflow=2 -D_FORTIFY_SOURCE=2 -fPIC")
 elseif(${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU")
  set(COLOR_FLAG "-fdiagnostics-color=auto")
  check_cxx_compiler_flag("-fdiagnostics-color=auto" HAS_COLOR_FLAG)
@@ -168,6 +185,7 @@ elseif(${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU")
  # using GCC
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pedantic -Wuninitialized -Wunreachable-code -Wstrict-overflow=1 -D_FORTIFY_SOURCE=2 ${COLOR_FLAG} -fPIC")
  if(WIN32) # using mingw
+    add_definitions(-D_USE_MATH_DEFINES) # define M_PI, M_1_PI etc.
    add_definitions(-DWIN32)
    set(OPTIONAL_SOCKET_LIBS ws2_32 wsock32)
  endif()
@@ -179,6 +197,7 @@ elseif(${CMAKE_CXX_COMPILER_ID} STREQUAL "MSVC")
  set(BOOST_COMPONENTS ${BOOST_COMPONENTS} date_time chrono zlib)
  add_definitions(-D_CRT_SECURE_NO_WARNINGS)
  add_definitions(-DNOMINMAX) # avoid min and max macros that can break compilation
+  add_definitions(-D_USE_MATH_DEFINES) # define M_PI
  add_definitions(-D_WIN32_WINNT=0x0501)
  add_definitions(-DXML_STATIC)
  find_library(ws2_32_LIBRARY_PATH ws2_32)
@@ -226,42 +245,76 @@ if(APPLE)
 endif()

 if(UNIX AND NOT APPLE)
-  set(MAYBE_RT_LIBRARY rt)
+  target_link_libraries(osrm-prepare rt)
+  target_link_libraries(osrm-datastore rt)
+  target_link_libraries(OSRM rt)
 endif()

-list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/third_party/libosmium/cmake")
-set(OSMIUM_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/libosmium/include")
-find_package(Osmium REQUIRED COMPONENTS io)
-include_directories(SYSTEM ${OSMIUM_INCLUDE_DIRS})
-
-
+#Check Boost
 find_package(Boost 1.49.0 COMPONENTS ${BOOST_COMPONENTS} REQUIRED)
-add_definitions(-DBOOST_TEST_DYN_LINK -DBOOST_SPIRIT_USE_PHOENIX_V3 -DBOOST_RESULT_OF_USE_DECLTYPE)
+if(NOT Boost_FOUND)
+  message(FATAL_ERROR "Fatal error: Boost (version >= 1.49.0) required.\n")
+endif()
 include_directories(SYSTEM ${Boost_INCLUDE_DIRS})

+target_link_libraries(OSRM ${Boost_LIBRARIES})
+target_link_libraries(osrm-extract ${Boost_LIBRARIES})
+target_link_libraries(osrm-prepare ${Boost_LIBRARIES})
+target_link_libraries(osrm-routed ${Boost_LIBRARIES} ${OPTIONAL_SOCKET_LIBS} OSRM)
+target_link_libraries(osrm-datastore ${Boost_LIBRARIES})
+target_link_libraries(datastructure-tests ${Boost_LIBRARIES})
+target_link_libraries(algorithm-tests ${Boost_LIBRARIES} ${OPTIONAL_SOCKET_LIBS} OSRM)
+target_link_libraries(util-tests ${Boost_LIBRARIES})
+target_link_libraries(rtree-bench ${Boost_LIBRARIES})
+
 find_package(Threads REQUIRED)
+target_link_libraries(osrm-extract ${CMAKE_THREAD_LIBS_INIT})
+target_link_libraries(osrm-datastore ${CMAKE_THREAD_LIBS_INIT})
+target_link_libraries(osrm-prepare ${CMAKE_THREAD_LIBS_INIT})
+target_link_libraries(OSRM ${CMAKE_THREAD_LIBS_INIT})
+target_link_libraries(datastructure-tests ${CMAKE_THREAD_LIBS_INIT})
+target_link_libraries(algorithm-tests ${CMAKE_THREAD_LIBS_INIT})
+target_link_libraries(rtree-bench ${CMAKE_THREAD_LIBS_INIT})

 find_package(TBB REQUIRED)
-include_directories(SYSTEM ${TBB_INCLUDE_DIR})
 if(WIN32 AND CMAKE_BUILD_TYPE MATCHES Debug)
  set(TBB_LIBRARIES ${TBB_DEBUG_LIBRARIES})
 endif()
+target_link_libraries(osrm-datastore ${TBB_LIBRARIES})
+target_link_libraries(osrm-extract ${TBB_LIBRARIES})
+target_link_libraries(osrm-prepare ${TBB_LIBRARIES})
+target_link_libraries(osrm-routed ${TBB_LIBRARIES})
+target_link_libraries(datastructure-tests ${TBB_LIBRARIES})
+target_link_libraries(algorithm-tests ${TBB_LIBRARIES})
+target_link_libraries(rtree-bench ${TBB_LIBRARIES})
+include_directories(SYSTEM ${TBB_INCLUDE_DIR})

 find_package( Luabind REQUIRED )
 include(check_luabind)
-include_directories(SYSTEM ${LUABIND_INCLUDE_DIR})

-set(USED_LUA_LIBRARIES ${LUA_LIBRARY})
+include_directories(SYSTEM ${LUABIND_INCLUDE_DIR})
+target_link_libraries(osrm-extract ${LUABIND_LIBRARY})
+target_link_libraries(osrm-prepare ${LUABIND_LIBRARY})
+
 if(LUAJIT_FOUND)
-  set(USED_LUA_LIBRARIES, LUAJIT_LIBRARIES)
+  target_link_libraries(osrm-extract ${LUAJIT_LIBRARIES})
+  target_link_libraries(osrm-prepare ${LUAJIT_LIBRARIES})
+else()
+  target_link_libraries(osrm-extract ${LUA_LIBRARY})
+  target_link_libraries(osrm-prepare ${LUA_LIBRARY})
 endif()
 include_directories(SYSTEM ${LUA_INCLUDE_DIR})

 find_package(EXPAT REQUIRED)
 include_directories(SYSTEM ${EXPAT_INCLUDE_DIRS})
+target_link_libraries(osrm-extract ${EXPAT_LIBRARIES})

 find_package(STXXL REQUIRED)
 include_directories(SYSTEM ${STXXL_INCLUDE_DIR})
+target_link_libraries(OSRM ${STXXL_LIBRARY})
+target_link_libraries(osrm-extract ${STXXL_LIBRARY})
+target_link_libraries(osrm-prepare ${STXXL_LIBRARY})
+target_link_libraries(datastructure-tests ${STXXL_LIBRARY})

 set(OpenMP_FIND_QUIETLY ON)
 find_package(OpenMP)
@@ -272,139 +325,91 @@ endif()

 find_package(BZip2 REQUIRED)
 include_directories(SYSTEM ${BZIP_INCLUDE_DIRS})
+target_link_libraries(osrm-extract ${BZIP2_LIBRARIES})

 find_package(ZLIB REQUIRED)
 include_directories(SYSTEM ${ZLIB_INCLUDE_DIRS})
+target_link_libraries(osrm-extract ${ZLIB_LIBRARY})
+target_link_libraries(osrm-routed ${ZLIB_LIBRARY})

 if (ENABLE_JSON_LOGGING)
  message(STATUS "Enabling json logging")
  add_definitions(-DENABLE_JSON_LOGGING)
 endif()

-# Binaries
-target_link_libraries(osrm-datastore osrm_store ${Boost_LIBRARIES})
-target_link_libraries(osrm-extract osrm_extract ${Boost_LIBRARIES})
-target_link_libraries(osrm-contract osrm_contract ${Boost_LIBRARIES})
-target_link_libraries(osrm-routed osrm ${Boost_LIBRARIES} ${OPTIONAL_SOCKET_LIBS} ${ZLIB_LIBRARY})
-
-set(EXTRACTOR_LIBRARIES
-    ${BZIP2_LIBRARIES}
-    ${Boost_LIBRARIES}
-    ${CMAKE_THREAD_LIBS_INIT}
-    ${EXPAT_LIBRARIES}
-    ${LUABIND_LIBRARY}
-    ${USED_LUA_LIBRARIES}
-    ${OSMIUM_LIBRARIES}
-    ${STXXL_LIBRARY}
-    ${TBB_LIBRARIES}
-    ${ZLIB_LIBRARY})
-set(CONTRACTOR_LIBRARIES
-    ${Boost_LIBRARIES}
-    ${CMAKE_THREAD_LIBS_INIT}
-    ${LUABIND_LIBRARY}
-    ${USED_LUA_LIBRARIES}
-    ${STXXL_LIBRARY}
-    ${TBB_LIBRARIES}
-    ${MAYBE_RT_LIBRARY})
-set(ENGINE_LIBRARIES
-    ${Boost_LIBRARIES}
-    ${CMAKE_THREAD_LIBS_INIT}
-    ${STXXL_LIBRARY}
-    ${TBB_LIBRARIES}
-    ${MAYBE_RT_LIBRARY})
-set(STORAGE_LIBRARIES
-    ${Boost_LIBRARIES}
-    ${CMAKE_THREAD_LIBS_INIT}
-    ${TBB_LIBRARIES}
-    ${MAYBE_RT_LIBRARY})
-set(UTIL_LIBRARIES
-    ${Boost_LIBRARIES}
-    ${CMAKE_THREAD_LIBS_INIT}
-    ${STXXL_LIBRARY}
-    ${TBB_LIBRARIES})
-# Libraries
-target_link_libraries(osrm ${ENGINE_LIBRARIES})
-target_link_libraries(osrm_contract ${CONTRACTOR_LIBRARIES})
-target_link_libraries(osrm_extract ${EXTRACTOR_LIBRARIES})
-target_link_libraries(osrm_store ${STORAGE_LIBRARIES})
-# Tests
-target_link_libraries(engine-tests ${ENGINE_LIBRARIES})
-target_link_libraries(server-tests osrm ${Boost_LIBRARIES})
-target_link_libraries(extractor-tests ${EXTRACTOR_LIBRARIES})
-target_link_libraries(rtree-bench ${Boost_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} ${TBB_LIBRARIES})
-target_link_libraries(util-tests ${UTIL_LIBRARIES})
+if (DEBUG_GEOMETRY)
+  message(STATUS "Enabling final edge weight GeoJSON output option")
+  add_definitions(-DDEBUG_GEOMETRY)
+endif()

 if(BUILD_TOOLS)
  message(STATUS "Activating OSRM internal tools")
  find_package(GDAL)
  if(GDAL_FOUND)
-    add_executable(osrm-components src/tools/components.cpp $<TARGET_OBJECTS:UTIL>)
+    add_executable(osrm-components tools/components.cpp $<TARGET_OBJECTS:FINGERPRINT> $<TARGET_OBJECTS:IMPORT> $<TARGET_OBJECTS:COORDINATE> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:RESTRICTION> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:MERCATOR>)
    target_link_libraries(osrm-components ${TBB_LIBRARIES})
    include_directories(SYSTEM ${GDAL_INCLUDE_DIR})
    target_link_libraries(osrm-components ${GDAL_LIBRARIES} ${Boost_LIBRARIES})
    install(TARGETS osrm-components DESTINATION bin)
  else()
-    message(WARNING "libgdal and/or development headers not found")
+    message(FATAL_ERROR "libgdal and/or development headers not found")
  endif()
-  add_executable(osrm-io-benchmark src/tools/io-benchmark.cpp $<TARGET_OBJECTS:UTIL>)
+  add_executable(osrm-cli tools/simpleclient.cpp $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:COORDINATE>)
+  target_link_libraries(osrm-cli ${Boost_LIBRARIES} ${OPTIONAL_SOCKET_LIBS} OSRM)
+  target_link_libraries(osrm-cli ${TBB_LIBRARIES})
+  add_executable(osrm-io-benchmark tools/io-benchmark.cpp $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:LOGGER>)
  target_link_libraries(osrm-io-benchmark ${Boost_LIBRARIES})
-  add_executable(osrm-unlock-all src/tools/unlock_all_mutexes.cpp $<TARGET_OBJECTS:UTIL>)
+  add_executable(osrm-unlock-all tools/unlock_all_mutexes.cpp $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:EXCEPTION>)
  target_link_libraries(osrm-unlock-all ${Boost_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
  if(UNIX AND NOT APPLE)
    target_link_libraries(osrm-unlock-all rt)
  endif()
-  add_executable(osrm-springclean src/tools/springclean.cpp $<TARGET_OBJECTS:UTIL>)
+  add_executable(osrm-check-hsgr tools/check-hsgr.cpp $<TARGET_OBJECTS:FINGERPRINT> $<TARGET_OBJECTS:EXCEPTION> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:IMPORT>)
+  target_link_libraries(osrm-check-hsgr ${Boost_LIBRARIES} ${TBB_LIBRARIES})
+  add_executable(osrm-springclean tools/springclean.cpp $<TARGET_OBJECTS:FINGERPRINT> $<TARGET_OBJECTS:LOGGER> $<TARGET_OBJECTS:EXCEPTION>)
  target_link_libraries(osrm-springclean ${Boost_LIBRARIES})

+  install(TARGETS osrm-cli DESTINATION bin)
  install(TARGETS osrm-io-benchmark DESTINATION bin)
  install(TARGETS osrm-unlock-all DESTINATION bin)
+  install(TARGETS osrm-check-hsgr DESTINATION bin)
  install(TARGETS osrm-springclean DESTINATION bin)
 endif()

-if (ENABLE_ASSERTIONS)
-  message(STATUS "Enabling assertions")
-  add_definitions(-DBOOST_ENABLE_ASSERT_HANDLER)
-endif()
+file(GLOB InstallGlob include/osrm/*.hpp)
+file(GLOB VariantGlob third_party/variant/*.hpp)

 # Add RPATH info to executables so that when they are run after being installed
 # (i.e., from /usr/local/bin/) the linker can find library dependencies. For
 # more info see http://www.cmake.org/Wiki/CMake_RPATH_handling
 set_property(TARGET osrm-extract PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
-set_property(TARGET osrm-contract PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
+set_property(TARGET osrm-prepare PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
 set_property(TARGET osrm-datastore PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
 set_property(TARGET osrm-routed PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)

-file(GLOB VariantGlob third_party/variant/*.hpp)
-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/phantom_node.hpp)
-set(UtilHeader include/util/coordinate.hpp include/util/json_container.hpp include/util/typedefs.hpp include/util/strong_typedef.hpp)
-set(ExtractorHeader include/extractor/extractor.hpp include/extractor/extractor_config.hpp include/extractor/travel_mode.hpp)
-set(ContractorHeader include/contractor/contractor.hpp include/contractor/contractor_config.hpp)
-#set(StorageHeader include/storage/storage.hpp include/storage/storage_config.hpp)
-install(FILES ${EngineHeader} DESTINATION include/osrm/engine)
-install(FILES ${UtilHeader} DESTINATION include/osrm/util)
-install(FILES ${ExtractorHeader} DESTINATION include/osrm/extractor)
-install(FILES ${ContractorHeader} DESTINATION include/osrm/contractor)
-install(FILES ${LibraryGlob} DESTINATION include/osrm)
-install(FILES ${ParametersGlob} DESTINATION include/osrm/engine/api)
+install(FILES ${InstallGlob} DESTINATION include/osrm)
 install(FILES ${VariantGlob} DESTINATION include/variant)
 install(TARGETS osrm-extract DESTINATION bin)
-install(TARGETS osrm-contract DESTINATION bin)
+install(TARGETS osrm-prepare 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_contract DESTINATION lib)
-install(TARGETS osrm_store DESTINATION lib)
+install(TARGETS OSRM DESTINATION lib)

-list(GET ENGINE_LIBRARIES 1 ENGINE_LIBRARY_FIRST)
-foreach(lib ${ENGINE_LIBRARIES})
-  get_filename_component(ENGINE_LIBRARY_PATH "${ENGINE_LIBRARY_FIRST}" PATH)
-  get_filename_component(ENGINE_LIBRARY_NAME "${lib}" NAME_WE)
-  string(REPLACE "lib" "" ENGINE_LIBRARY_NAME ${ENGINE_LIBRARY_NAME})
-  string(REPLACE "-l" "" ENGINE_LIBRARY_NAME ${ENGINE_LIBRARY_NAME})
-  set(ENGINE_LIBRARY_LISTING "${ENGINE_LIBRARY_LISTING} -L${ENGINE_LIBRARY_PATH} -l${ENGINE_LIBRARY_NAME}")
+list(GET Boost_LIBRARIES 1 BOOST_LIBRARY_FIRST)
+get_filename_component(BOOST_LIBRARY_LISTING "${BOOST_LIBRARY_FIRST}" PATH)
+set(BOOST_LIBRARY_LISTING "-L${BOOST_LIBRARY_LISTING}")
+foreach(lib ${Boost_LIBRARIES})
+  get_filename_component(BOOST_LIBRARY_NAME "${lib}" NAME_WE)
+  string(REPLACE "lib" "" BOOST_LIBRARY_NAME ${BOOST_LIBRARY_NAME})
+  set(BOOST_LIBRARY_LISTING "${BOOST_LIBRARY_LISTING} -l${BOOST_LIBRARY_NAME}")
+endforeach()
+list(GET TBB_LIBRARIES 1 TBB_LIBRARY_FIRST)
+get_filename_component(TBB_LIBRARY_LISTING "${TBB_LIBRARY_FIRST}" PATH)
+set(TBB_LIBRARY_LISTING "-L${TBB_LIBRARY_LISTING}")
+foreach(lib ${TBB_LIBRARIES})
+  get_filename_component(TBB_LIBRARY_NAME "${lib}" NAME_WE)
+  string(REPLACE "lib" "" TBB_LIBRARY_NAME ${TBB_LIBRARY_NAME})
+  set(TBB_LIBRARY_LISTING "${TBB_LIBRARY_LISTING} -l${TBB_LIBRARY_NAME}")
 endforeach()

 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/pkgconfig.in libosrm.pc @ONLY)
@@ -427,21 +432,11 @@ COMMENT "Generating API documentation with Doxygen" VERBATIM
 endif()

 # prefix compilation with ccache by default if available and on clang or gcc
-if(ENABLE_CCACHE AND (${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang" OR ${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU"))
+if(${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang" OR ${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU")
  find_program(CCACHE_FOUND ccache)
  if(CCACHE_FOUND)
-    message(STATUS "Using ccache to speed up incremental builds")
    set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache)
    set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ccache)
    set(ENV{CCACHE_CPP2} "true")
  endif()
 endif()
-
-# uninstall target
-configure_file(
-    "${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake_uninstall.cmake.in"
-    "${CMAKE_CURRENT_BINARY_DIR}/cmake/cmake_uninstall.cmake"
-    IMMEDIATE @ONLY)
-
-add_custom_target(uninstall
-    COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake/cmake_uninstall.cmake)
@@ -1,4 +1,4 @@
-Copyright (c) 2016, Project OSRM contributors
+Copyright (c) 2015, Project OSRM contributors
 All rights reserved.

 Redistribution and use in source and binary forms, with or without modification,
@@ -98,7 +98,7 @@ task :crop do
 end

 desc "Reprocess OSM data."
-task :process => [:extract,:contract] do
+task :process => [:extract,:prepare] do
 end

 desc "Extract OSM data."
@@ -108,10 +108,10 @@ task :extract do
  end
 end

-desc "Contract OSM data."
-task :contract do
+desc "Prepare OSM data."
+task :prepare do
  Dir.chdir DATA_FOLDER do
-    raise "Error while contracting data." unless system "../#{BUILD_FOLDER}/osrm-contract #{osm_data_area_name}.osrm"
+    raise "Error while preparing data." unless system "../#{BUILD_FOLDER}/osrm-prepare #{osm_data_area_name}.osrm --profile ../profiles/#{PROFILE}.lua"
  end
 end

@@ -161,17 +161,17 @@ task :down do
  end 
 end

-desc "Kill all osrm-extract, osrm-contract and osrm-routed processes."
+desc "Kill all osrm-extract, osrm-prepare and osrm-routed processes."
 task :kill do
  each_process('osrm-routed') { |pid,state| Process.kill 'KILL', pid }
-  each_process('osrm-contract') { |pid,state| Process.kill 'KILL', pid }
+  each_process('osrm-prepare') { |pid,state| Process.kill 'KILL', pid }
  each_process('osrm-extract') { |pid,state| Process.kill 'KILL', pid }
  wait_for_shutdown 'osrm-routed'
-  wait_for_shutdown 'osrm-contract'
+  wait_for_shutdown 'osrm-prepare'
  wait_for_shutdown 'osrm-extract'  
 end

-desc "Get PIDs of all osrm-extract, osrm-contract and osrm-routed processes."
+desc "Get PIDs of all osrm-extract, osrm-prepare and osrm-routed processes."
 task :pid do
  each_process 'osrm-routed' do |pid,state|
    puts "#{pid}\t#{state}"
@@ -1,3 +1,30 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
 #ifndef BAYES_CLASSIFIER_HPP
 #define BAYES_CLASSIFIER_HPP

@@ -6,15 +33,6 @@
 #include <vector>
 #include <utility>

-#include <boost/math/constants/constants.hpp>
-
-namespace osrm
-{
-namespace engine
-{
-namespace map_matching
-{
-
 struct NormalDistribution
 {
    NormalDistribution(const double mean, const double standard_deviation)
@@ -22,13 +40,11 @@ struct NormalDistribution
    {
    }

-    // FIXME implement log-probability version since it's faster
+    // FIXME implement log-probability version since its faster
    double density_function(const double val) const
    {
-        using namespace boost::math::constants;
-
        const double x = val - mean;
-        return 1.0 / (std::sqrt(two_pi<double>()) * standard_deviation) *
+        return 1.0 / (std::sqrt(2. * M_PI) * standard_deviation) *
               std::exp(-x * x / (standard_deviation * standard_deviation));
    }

@@ -43,7 +59,7 @@ struct LaplaceDistribution
    {
    }

-    // FIXME implement log-probability version since it's faster
+    // FIXME implement log-probability version since its faster
    double density_function(const double val) const
    {
        const double x = std::abs(val - location);
@@ -98,8 +114,5 @@ class BayesClassifier
    double positive_apriori_probability;
    double negative_apriori_probability;
 };
-}
-}
-}

 #endif // BAYES_CLASSIFIER_HPP
@@ -0,0 +1,174 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef BFS_COMPONENTS_HPP_
+#define BFS_COMPONENTS_HPP_
+
+#include "../typedefs.h"
+#include "../data_structures/restriction_map.hpp"
+
+#include <queue>
+#include <unordered_set>
+
+// Explores the components of the given graph while respecting turn restrictions
+// and barriers.
+template <typename GraphT> class BFSComponentExplorer
+{
+  public:
+    BFSComponentExplorer(const GraphT &dynamic_graph,
+                         const RestrictionMap &restrictions,
+                         const std::unordered_set<NodeID> &barrier_nodes)
+        : m_graph(dynamic_graph), m_restriction_map(restrictions), m_barrier_nodes(barrier_nodes)
+    {
+        BOOST_ASSERT(m_graph.GetNumberOfNodes() > 0);
+    }
+
+    /*!
+     * Returns the size of the component that the node belongs to.
+     */
+    unsigned int GetComponentSize(const NodeID node) const
+    {
+        BOOST_ASSERT(node < m_component_index_list.size());
+
+        return m_component_index_size[m_component_index_list[node]];
+    }
+
+    unsigned int GetNumberOfComponents() { return m_component_index_size.size(); }
+
+    /*!
+     * Computes the component sizes.
+     */
+    void run()
+    {
+        std::queue<std::pair<NodeID, NodeID>> bfs_queue;
+        unsigned current_component = 0;
+
+        BOOST_ASSERT(m_component_index_list.empty());
+        BOOST_ASSERT(m_component_index_size.empty());
+
+        unsigned num_nodes = m_graph.GetNumberOfNodes();
+
+        m_component_index_list.resize(num_nodes, std::numeric_limits<unsigned>::max());
+
+        BOOST_ASSERT(num_nodes > 0);
+
+        // put unexplorered node with parent pointer into queue
+        for (NodeID node = 0; node < num_nodes; ++node)
+        {
+            if (std::numeric_limits<unsigned>::max() == m_component_index_list[node])
+            {
+                unsigned size = ExploreComponent(bfs_queue, node, current_component);
+
+                // push size into vector
+                m_component_index_size.emplace_back(size);
+                ++current_component;
+            }
+        }
+    }
+
+  private:
+    /*!
+     * Explores the current component that starts at node using BFS.
+     */
+    unsigned ExploreComponent(std::queue<std::pair<NodeID, NodeID>> &bfs_queue,
+                              NodeID node,
+                              unsigned current_component)
+    {
+        /*
+           Graphical representation of variables:
+
+           u           v           w
+           *---------->*---------->*
+                            e2
+        */
+
+        bfs_queue.emplace(node, node);
+        // mark node as read
+        m_component_index_list[node] = current_component;
+
+        unsigned current_component_size = 1;
+
+        while (!bfs_queue.empty())
+        {
+            // fetch element from BFS queue
+            std::pair<NodeID, NodeID> current_queue_item = bfs_queue.front();
+            bfs_queue.pop();
+
+            const NodeID v = current_queue_item.first;  // current node
+            const NodeID u = current_queue_item.second; // parent
+            // increment size counter of current component
+            ++current_component_size;
+            if (m_barrier_nodes.find(v) != m_barrier_nodes.end())
+            {
+                continue;
+            }
+            const NodeID to_node_of_only_restriction =
+                m_restriction_map.CheckForEmanatingIsOnlyTurn(u, v);
+
+            for (auto e2 : m_graph.GetAdjacentEdgeRange(v))
+            {
+                const NodeID w = m_graph.GetTarget(e2);
+
+                if (to_node_of_only_restriction != std::numeric_limits<unsigned>::max() &&
+                    w != to_node_of_only_restriction)
+                {
+                    // At an only_-restriction but not at the right turn
+                    continue;
+                }
+
+                if (u != w)
+                {
+                    // only add an edge if turn is not a U-turn except
+                    // when it is at the end of a dead-end street.
+                    if (!m_restriction_map.CheckIfTurnIsRestricted(u, v, w))
+                    {
+                        // only add an edge if turn is not prohibited
+                        if (std::numeric_limits<unsigned>::max() == m_component_index_list[w])
+                        {
+                            // insert next (node, parent) only if w has
+                            // not yet been explored
+                            // mark node as read
+                            m_component_index_list[w] = current_component;
+                            bfs_queue.emplace(w, v);
+                        }
+                    }
+                }
+            }
+        }
+
+        return current_component_size;
+    }
+
+    std::vector<unsigned> m_component_index_list;
+    std::vector<NodeID> m_component_index_size;
+
+    const GraphT &m_graph;
+    const RestrictionMap &m_restriction_map;
+    const std::unordered_set<NodeID> &m_barrier_nodes;
+};
+
+#endif // BFS_COMPONENTS_HPP_
@@ -0,0 +1,273 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#include "coordinate_calculation.hpp"
+
+#include "../util/mercator.hpp"
+#include "../util/string_util.hpp"
+
+#include <boost/assert.hpp>
+
+#include <osrm/coordinate.hpp>
+
+#include <cmath>
+
+#include <limits>
+
+namespace
+{
+constexpr static const float RAD = 0.017453292519943295769236907684886f;
+// earth radius varies between 6,356.750-6,378.135 km (3,949.901-3,963.189mi)
+// The IUGG value for the equatorial radius is 6378.137 km (3963.19 miles)
+constexpr static const float earth_radius = 6372797.560856f;
+}
+
+namespace coordinate_calculation
+{
+
+double haversine_distance(const int lat1,
+                                                     const int lon1,
+                                                     const int lat2,
+                                                     const int lon2)
+{
+    BOOST_ASSERT(lat1 != std::numeric_limits<int>::min());
+    BOOST_ASSERT(lon1 != std::numeric_limits<int>::min());
+    BOOST_ASSERT(lat2 != std::numeric_limits<int>::min());
+    BOOST_ASSERT(lon2 != std::numeric_limits<int>::min());
+    const double lt1 = lat1 / COORDINATE_PRECISION;
+    const double ln1 = lon1 / COORDINATE_PRECISION;
+    const double lt2 = lat2 / COORDINATE_PRECISION;
+    const double ln2 = lon2 / COORDINATE_PRECISION;
+    const double dlat1 = lt1 * (RAD);
+
+    const double dlong1 = ln1 * (RAD);
+    const double dlat2 = lt2 * (RAD);
+    const double dlong2 = ln2 * (RAD);
+
+    const double dLong = dlong1 - dlong2;
+    const double dLat = dlat1 - dlat2;
+
+    const double aHarv = std::pow(std::sin(dLat / 2.0), 2.0) +
+                         std::cos(dlat1) * std::cos(dlat2) * std::pow(std::sin(dLong / 2.), 2);
+    const double cHarv = 2. * std::atan2(std::sqrt(aHarv), std::sqrt(1.0 - aHarv));
+    return earth_radius * cHarv;
+}
+
+double haversine_distance(const FixedPointCoordinate &coordinate_1,
+                                                     const FixedPointCoordinate &coordinate_2)
+{
+    return haversine_distance(coordinate_1.lat, coordinate_1.lon, coordinate_2.lat,
+                                 coordinate_2.lon);
+}
+
+float great_circle_distance(const FixedPointCoordinate &coordinate_1,
+                                                 const FixedPointCoordinate &coordinate_2)
+{
+    return great_circle_distance(coordinate_1.lat, coordinate_1.lon, coordinate_2.lat,
+                              coordinate_2.lon);
+}
+
+float great_circle_distance(const int lat1,
+                                                 const int lon1,
+                                                 const int lat2,
+                                                 const int lon2)
+{
+    BOOST_ASSERT(lat1 != std::numeric_limits<int>::min());
+    BOOST_ASSERT(lon1 != std::numeric_limits<int>::min());
+    BOOST_ASSERT(lat2 != std::numeric_limits<int>::min());
+    BOOST_ASSERT(lon2 != std::numeric_limits<int>::min());
+
+    const float float_lat1 = (lat1 / COORDINATE_PRECISION) * RAD;
+    const float float_lon1 = (lon1 / COORDINATE_PRECISION) * RAD;
+    const float float_lat2 = (lat2 / COORDINATE_PRECISION) * RAD;
+    const float float_lon2 = (lon2 / COORDINATE_PRECISION) * RAD;
+
+    const float x_value = (float_lon2 - float_lon1) * std::cos((float_lat1 + float_lat2) / 2.f);
+    const float y_value = float_lat2 - float_lat1;
+    return std::hypot(x_value, y_value) * earth_radius;
+}
+
+float perpendicular_distance(const FixedPointCoordinate &source_coordinate,
+                                                     const FixedPointCoordinate &target_coordinate,
+                                                     const FixedPointCoordinate &query_location)
+{
+    float ratio;
+    FixedPointCoordinate nearest_location;
+
+    return perpendicular_distance(source_coordinate, target_coordinate, query_location,
+                                  nearest_location, ratio);
+}
+
+float perpendicular_distance(const FixedPointCoordinate &segment_source,
+                                                     const FixedPointCoordinate &segment_target,
+                                                     const FixedPointCoordinate &query_location,
+                                                     FixedPointCoordinate &nearest_location,
+                                                     float &ratio)
+{
+    return perpendicular_distance_from_projected_coordinate(
+        segment_source, segment_target, query_location,
+        {mercator::lat2y(query_location.lat / COORDINATE_PRECISION),
+         query_location.lon / COORDINATE_PRECISION},
+        nearest_location, ratio);
+}
+
+float perpendicular_distance_from_projected_coordinate(
+    const FixedPointCoordinate &source_coordinate,
+    const FixedPointCoordinate &target_coordinate,
+    const FixedPointCoordinate &query_location,
+    const std::pair<double, double> &projected_coordinate)
+{
+    float ratio;
+    FixedPointCoordinate nearest_location;
+
+    return perpendicular_distance_from_projected_coordinate(source_coordinate, target_coordinate,
+                                                            query_location, projected_coordinate,
+                                                            nearest_location, ratio);
+}
+
+float perpendicular_distance_from_projected_coordinate(
+    const FixedPointCoordinate &segment_source,
+    const FixedPointCoordinate &segment_target,
+    const FixedPointCoordinate &query_location,
+    const std::pair<double, double> &projected_coordinate,
+    FixedPointCoordinate &nearest_location,
+    float &ratio)
+{
+    BOOST_ASSERT(query_location.is_valid());
+
+    // initialize values
+    const double x = projected_coordinate.first;
+    const double y = projected_coordinate.second;
+    const double a = mercator::lat2y(segment_source.lat / COORDINATE_PRECISION);
+    const double b = segment_source.lon / COORDINATE_PRECISION;
+    const double c = mercator::lat2y(segment_target.lat / COORDINATE_PRECISION);
+    const double d = segment_target.lon / COORDINATE_PRECISION;
+    double p, q /*,mX*/, nY;
+    if (std::abs(a - c) > std::numeric_limits<double>::epsilon())
+    {
+        const double m = (d - b) / (c - a); // slope
+        // Projection of (x,y) on line joining (a,b) and (c,d)
+        p = ((x + (m * y)) + (m * m * a - m * b)) / (1.f + m * m);
+        q = b + m * (p - a);
+    }
+    else
+    {
+        p = c;
+        q = y;
+    }
+    nY = (d * p - c * q) / (a * d - b * c);
+
+    // discretize the result to coordinate precision. it's a hack!
+    if (std::abs(nY) < (1.f / COORDINATE_PRECISION))
+    {
+        nY = 0.f;
+    }
+
+    // compute ratio
+    ratio =
+        static_cast<float>((p - nY * a) / c); // These values are actually n/m+n and m/m+n , we need
+    // not calculate the explicit values of m an n as we
+    // are just interested in the ratio
+    if (std::isnan(ratio))
+    {
+        ratio = (segment_target == query_location ? 1.f : 0.f);
+    }
+    else if (std::abs(ratio) <= std::numeric_limits<float>::epsilon())
+    {
+        ratio = 0.f;
+    }
+    else if (std::abs(ratio - 1.f) <= std::numeric_limits<float>::epsilon())
+    {
+        ratio = 1.f;
+    }
+
+    // compute nearest location
+    BOOST_ASSERT(!std::isnan(ratio));
+    if (ratio <= 0.f)
+    {
+        nearest_location = segment_source;
+    }
+    else if (ratio >= 1.f)
+    {
+        nearest_location = segment_target;
+    }
+    else
+    {
+        // point lies in between
+        nearest_location.lat = static_cast<int>(mercator::y2lat(p) * COORDINATE_PRECISION);
+        nearest_location.lon = static_cast<int>(q * COORDINATE_PRECISION);
+    }
+    BOOST_ASSERT(nearest_location.is_valid());
+
+    const float approximate_distance =
+        great_circle_distance(query_location, nearest_location);
+    BOOST_ASSERT(0.f <= approximate_distance);
+    return approximate_distance;
+}
+
+void lat_or_lon_to_string(const int value, std::string &output)
+{
+    char buffer[12];
+    buffer[11] = 0; // zero termination
+    output = printInt<11, 6>(buffer, value);
+}
+
+float deg_to_rad(const float degree)
+{
+    return degree * (static_cast<float>(M_PI) / 180.f);
+}
+
+float rad_to_deg(const float radian)
+{
+    return radian * (180.f * static_cast<float>(M_1_PI));
+}
+
+float bearing(const FixedPointCoordinate &first_coordinate,
+                                      const FixedPointCoordinate &second_coordinate)
+{
+    const float lon_diff =
+        second_coordinate.lon / COORDINATE_PRECISION - first_coordinate.lon / COORDINATE_PRECISION;
+    const float lon_delta = deg_to_rad(lon_diff);
+    const float lat1 = deg_to_rad(first_coordinate.lat / COORDINATE_PRECISION);
+    const float lat2 = deg_to_rad(second_coordinate.lat / COORDINATE_PRECISION);
+    const float y = std::sin(lon_delta) * std::cos(lat2);
+    const float x =
+        std::cos(lat1) * std::sin(lat2) - std::sin(lat1) * std::cos(lat2) * std::cos(lon_delta);
+    float result = rad_to_deg(std::atan2(y, x));
+    while (result < 0.f)
+    {
+        result += 360.f;
+    }
+
+    while (result >= 360.f)
+    {
+        result -= 360.f;
+    }
+    return result;
+}
+
+}
@@ -0,0 +1,82 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef COORDINATE_CALCULATION
+#define COORDINATE_CALCULATION
+
+struct FixedPointCoordinate;
+
+#include <string>
+#include <utility>
+
+namespace coordinate_calculation
+{
+    double
+    haversine_distance(const int lat1, const int lon1, const int lat2, const int lon2);
+
+    double haversine_distance(const FixedPointCoordinate &first_coordinate,
+                                 const FixedPointCoordinate &second_coordinate);
+
+    float great_circle_distance(const FixedPointCoordinate &first_coordinate,
+                             const FixedPointCoordinate &second_coordinate);
+
+    float great_circle_distance(const int lat1, const int lon1, const int lat2, const int lon2);
+
+    void lat_or_lon_to_string(const int value, std::string &output);
+
+    float perpendicular_distance(const FixedPointCoordinate &segment_source,
+                                 const FixedPointCoordinate &segment_target,
+                                 const FixedPointCoordinate &query_location);
+
+    float perpendicular_distance(const FixedPointCoordinate &segment_source,
+                                 const FixedPointCoordinate &segment_target,
+                                 const FixedPointCoordinate &query_location,
+                                 FixedPointCoordinate &nearest_location,
+                                 float &ratio);
+
+    float perpendicular_distance_from_projected_coordinate(
+        const FixedPointCoordinate &segment_source,
+        const FixedPointCoordinate &segment_target,
+        const FixedPointCoordinate &query_location,
+        const std::pair<double, double> &projected_coordinate);
+
+    float perpendicular_distance_from_projected_coordinate(
+        const FixedPointCoordinate &segment_source,
+        const FixedPointCoordinate &segment_target,
+        const FixedPointCoordinate &query_location,
+        const std::pair<double, double> &projected_coordinate,
+        FixedPointCoordinate &nearest_location,
+        float &ratio);
+
+    float deg_to_rad(const float degree);
+    float rad_to_deg(const float radian);
+
+    float bearing(const FixedPointCoordinate &first_coordinate,
+                  const FixedPointCoordinate &second_coordinate);
+}
+
+#endif // COORDINATE_CALCULATION
@@ -1,3 +1,30 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
 #ifndef ITERATOR_BASED_CRC32_H
 #define ITERATOR_BASED_CRC32_H

@@ -9,11 +36,6 @@

 #include <iterator>

-namespace osrm
-{
-namespace contractor
-{
-
 class IteratorbasedCRC32
 {
  public:
@@ -119,7 +141,5 @@ struct RangebasedCRC32
  private:
    IteratorbasedCRC32 crc32;
 };
-}
-}

 #endif /* ITERATOR_BASED_CRC32_H */
@@ -0,0 +1,164 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#include "douglas_peucker.hpp"
+
+#include "../data_structures/segment_information.hpp"
+
+#include <boost/assert.hpp>
+#include <osrm/coordinate.hpp>
+
+#include <cmath>
+#include <algorithm>
+#include <iterator>
+
+namespace
+{
+struct CoordinatePairCalculator
+{
+    CoordinatePairCalculator() = delete;
+    CoordinatePairCalculator(const FixedPointCoordinate &coordinate_a,
+                             const FixedPointCoordinate &coordinate_b)
+    {
+        // initialize distance calculator with two fixed coordinates a, b
+        const float RAD = 0.017453292519943295769236907684886f;
+        first_lat = (coordinate_a.lat / COORDINATE_PRECISION) * RAD;
+        first_lon = (coordinate_a.lon / COORDINATE_PRECISION) * RAD;
+        second_lat = (coordinate_b.lat / COORDINATE_PRECISION) * RAD;
+        second_lon = (coordinate_b.lon / COORDINATE_PRECISION) * RAD;
+    }
+
+    int operator()(FixedPointCoordinate &other) const
+    {
+        // set third coordinate c
+        const float RAD = 0.017453292519943295769236907684886f;
+        const float earth_radius = 6372797.560856f;
+        const float float_lat1 = (other.lat / COORDINATE_PRECISION) * RAD;
+        const float float_lon1 = (other.lon / COORDINATE_PRECISION) * RAD;
+
+        // compute distance (a,c)
+        const float x_value_1 = (first_lon - float_lon1) * cos((float_lat1 + first_lat) / 2.f);
+        const float y_value_1 = first_lat - float_lat1;
+        const float dist1 = std::hypot(x_value_1, y_value_1) * earth_radius;
+
+        // compute distance (b,c)
+        const float x_value_2 = (second_lon - float_lon1) * cos((float_lat1 + second_lat) / 2.f);
+        const float y_value_2 = second_lat - float_lat1;
+        const float dist2 = std::hypot(x_value_2, y_value_2) * earth_radius;
+
+        // return the minimum
+        return static_cast<int>(std::min(dist1, dist2));
+    }
+
+    float first_lat;
+    float first_lon;
+    float second_lat;
+    float second_lon;
+};
+}
+
+void DouglasPeucker::Run(std::vector<SegmentInformation> &input_geometry, const unsigned zoom_level)
+{
+    Run(std::begin(input_geometry), std::end(input_geometry), zoom_level);
+}
+
+void DouglasPeucker::Run(RandomAccessIt begin, RandomAccessIt end, const unsigned zoom_level)
+{
+    const auto size = std::distance(begin, end);
+    if (size < 2)
+    {
+        return;
+    }
+
+    begin->necessary = true;
+    std::prev(end)->necessary = true;
+
+    {
+        BOOST_ASSERT_MSG(zoom_level < DOUGLAS_PEUCKER_THRESHOLDS.size(), "unsupported zoom level");
+        auto left_border = begin;
+        auto right_border = std::next(begin);
+        // Sweep over array and identify those ranges that need to be checked
+        do
+        {
+            // traverse list until new border element found
+            if (right_border->necessary)
+            {
+                // sanity checks
+                BOOST_ASSERT(left_border->necessary);
+                BOOST_ASSERT(right_border->necessary);
+                recursion_stack.emplace(left_border, right_border);
+                left_border = right_border;
+            }
+            ++right_border;
+        } while (right_border != end);
+    }
+
+    // mark locations as 'necessary' by divide-and-conquer
+    while (!recursion_stack.empty())
+    {
+        // pop next element
+        const GeometryRange pair = recursion_stack.top();
+        recursion_stack.pop();
+        // sanity checks
+        BOOST_ASSERT_MSG(pair.first->necessary, "left border must be necessary");
+        BOOST_ASSERT_MSG(pair.second->necessary, "right border must be necessary");
+        BOOST_ASSERT_MSG(std::distance(pair.second, end) > 0, "right border outside of geometry");
+        BOOST_ASSERT_MSG(std::distance(pair.first, pair.second) >= 0,
+                         "left border on the wrong side");
+
+        int max_int_distance = 0;
+        auto farthest_entry_it = pair.second;
+        const CoordinatePairCalculator dist_calc(pair.first->location, pair.second->location);
+
+        // sweep over range to find the maximum
+        for (auto it = std::next(pair.first); it != pair.second; ++it)
+        {
+            const int distance = dist_calc(it->location);
+            // found new feasible maximum?
+            if (distance > max_int_distance && distance > DOUGLAS_PEUCKER_THRESHOLDS[zoom_level])
+            {
+                farthest_entry_it = it;
+                max_int_distance = distance;
+            }
+        }
+
+        // check if maximum violates a zoom level dependent threshold
+        if (max_int_distance > DOUGLAS_PEUCKER_THRESHOLDS[zoom_level])
+        {
+            //  mark idx as necessary
+            farthest_entry_it->necessary = true;
+            if (1 < std::distance(pair.first, farthest_entry_it))
+            {
+                recursion_stack.emplace(pair.first, farthest_entry_it);
+            }
+            if (1 < std::distance(farthest_entry_it, pair.second))
+            {
+                recursion_stack.emplace(farthest_entry_it, pair.second);
+            }
+        }
+    }
+}
@@ -0,0 +1,81 @@
+/*
+
+Copyright (c) 2013, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef DOUGLAS_PEUCKER_HPP_
+#define DOUGLAS_PEUCKER_HPP_
+
+#include "../data_structures/segment_information.hpp"
+
+#include <array>
+#include <stack>
+#include <utility>
+#include <vector>
+
+/* This class object computes the bitvector of indicating generalized input
+ * points according to the (Ramer-)Douglas-Peucker algorithm.
+ *
+ * Input is vector of pairs. Each pair consists of the point information and a
+ * bit indicating if the points is present in the generalization.
+ * Note: points may also be pre-selected*/
+
+static const std::array<int, 19> DOUGLAS_PEUCKER_THRESHOLDS{{
+    512440, // z0
+    256720, // z1
+    122560, // z2
+    56780,  // z3
+    28800,  // z4
+    14400,  // z5
+    7200,   // z6
+    3200,   // z7
+    2400,   // z8
+    1000,   // z9
+    600,    // z10
+    120,    // z11
+    60,     // z12
+    45,     // z13
+    36,     // z14
+    20,     // z15
+    8,      // z16
+    6,      // z17
+    4       // z18
+}};
+
+class DouglasPeucker
+{
+  public:
+    using RandomAccessIt = std::vector<SegmentInformation>::iterator;
+
+    using GeometryRange = std::pair<RandomAccessIt, RandomAccessIt>;
+    // Stack to simulate the recursion
+    std::stack<GeometryRange> recursion_stack;
+
+  public:
+    void Run(RandomAccessIt begin, RandomAccessIt end, const unsigned zoom_level);
+    void Run(std::vector<SegmentInformation> &input_geometry, const unsigned zoom_level);
+};
+
+#endif /* DOUGLAS_PEUCKER_HPP_ */
@@ -0,0 +1,180 @@
+#ifndef GEOSPATIAL_QUERY_HPP
+#define GEOSPATIAL_QUERY_HPP
+
+#include "coordinate_calculation.hpp"
+#include "../typedefs.h"
+#include "../data_structures/phantom_node.hpp"
+#include "../util/bearing.hpp"
+
+#include <osrm/coordinate.hpp>
+
+#include <vector>
+#include <memory>
+#include <algorithm>
+
+// Implements complex queries on top of an RTree and builds PhantomNodes from it.
+//
+// Only holds a weak reference on the RTree!
+template <typename RTreeT> class GeospatialQuery
+{
+    using EdgeData = typename RTreeT::EdgeData;
+    using CoordinateList = typename RTreeT::CoordinateList;
+
+  public:
+    GeospatialQuery(RTreeT &rtree_, std::shared_ptr<CoordinateList> coordinates_)
+        : rtree(rtree_), coordinates(coordinates_)
+    {
+    }
+
+    // Returns nearest PhantomNodes in the given bearing range within max_distance.
+    // Does not filter by small/big component!
+    std::vector<PhantomNodeWithDistance>
+    NearestPhantomNodesInRange(const FixedPointCoordinate &input_coordinate,
+                               const float max_distance,
+                               const int bearing = 0,
+                               const int bearing_range = 180)
+    {
+        auto results =
+            rtree.Nearest(input_coordinate,
+                          [this, bearing, bearing_range, max_distance](const EdgeData &data)
+                          {
+                              return checkSegmentBearing(data, bearing, bearing_range);
+                          },
+                          [max_distance](const std::size_t, const float min_dist)
+                          {
+                              return min_dist > max_distance;
+                          });
+
+        return MakePhantomNodes(input_coordinate, results);
+    }
+
+    // Returns max_results nearest PhantomNodes in the given bearing range.
+    // Does not filter by small/big component!
+    std::vector<PhantomNodeWithDistance>
+    NearestPhantomNodes(const FixedPointCoordinate &input_coordinate,
+                        const unsigned max_results,
+                        const int bearing = 0,
+                        const int bearing_range = 180)
+    {
+        auto results = rtree.Nearest(input_coordinate,
+                                     [this, bearing, bearing_range](const EdgeData &data)
+                                     {
+                                         return checkSegmentBearing(data, bearing, bearing_range);
+                                     },
+                                     [max_results](const std::size_t num_results, const float)
+                                     {
+                                         return num_results >= max_results;
+                                     });
+
+        return MakePhantomNodes(input_coordinate, results);
+    }
+
+    // Returns the nearest phantom node. If this phantom node is not from a big component
+    // a second phantom node is return that is the nearest coordinate in a big component.
+    std::pair<PhantomNode, PhantomNode>
+    NearestPhantomNodeWithAlternativeFromBigComponent(const FixedPointCoordinate &input_coordinate,
+                                                      const int bearing = 0,
+                                                      const int bearing_range = 180)
+    {
+        bool has_small_component = false;
+        bool has_big_component = false;
+        auto results = rtree.Nearest(
+            input_coordinate,
+            [this, bearing, bearing_range, &has_big_component,
+             &has_small_component](const EdgeData &data)
+            {
+                auto use_segment =
+                    (!has_small_component || (!has_big_component && !data.component.is_tiny));
+                auto use_directions = std::make_pair(use_segment, use_segment);
+
+                if (use_segment)
+                {
+                    use_directions = checkSegmentBearing(data, bearing, bearing_range);
+                    if (use_directions.first || use_directions.second)
+                    {
+                        has_big_component = has_big_component || !data.component.is_tiny;
+                        has_small_component = has_small_component || data.component.is_tiny;
+                    }
+                }
+
+                return use_directions;
+            },
+            [&has_big_component](const std::size_t num_results, const float)
+            {
+                return num_results > 0 && has_big_component;
+            });
+
+        if (results.size() == 0)
+        {
+            return std::make_pair(PhantomNode{}, PhantomNode{});
+        }
+
+        BOOST_ASSERT(results.size() > 0);
+        return std::make_pair(MakePhantomNode(input_coordinate, results.front()).phantom_node,
+                              MakePhantomNode(input_coordinate, results.back()).phantom_node);
+    }
+
+  private:
+    std::vector<PhantomNodeWithDistance>
+    MakePhantomNodes(const FixedPointCoordinate &input_coordinate,
+                     const std::vector<EdgeData> &results) const
+    {
+        std::vector<PhantomNodeWithDistance> distance_and_phantoms(results.size());
+        std::transform(results.begin(), results.end(), distance_and_phantoms.begin(),
+                       [this, &input_coordinate](const EdgeData &data)
+                       {
+                           return MakePhantomNode(input_coordinate, data);
+                       });
+        return distance_and_phantoms;
+    }
+
+    PhantomNodeWithDistance MakePhantomNode(const FixedPointCoordinate &input_coordinate,
+                                                   const EdgeData &data) const
+    {
+        FixedPointCoordinate point_on_segment;
+        float ratio;
+        const auto current_perpendicular_distance = coordinate_calculation::perpendicular_distance(
+            coordinates->at(data.u), coordinates->at(data.v), input_coordinate, point_on_segment,
+            ratio);
+
+        auto transformed =
+            PhantomNodeWithDistance { PhantomNode{data, point_on_segment}, current_perpendicular_distance };
+
+        ratio = std::min(1.f, std::max(0.f, ratio));
+
+        if (SPECIAL_NODEID != transformed.phantom_node.forward_node_id)
+        {
+            transformed.phantom_node.forward_weight *= ratio;
+        }
+        if (SPECIAL_NODEID != transformed.phantom_node.reverse_node_id)
+        {
+            transformed.phantom_node.reverse_weight *= 1.f - ratio;
+        }
+        return transformed;
+    }
+
+    std::pair<bool, bool> checkSegmentBearing(const EdgeData &segment,
+                                              const float filter_bearing,
+                                              const float filter_bearing_range)
+    {
+        const float forward_edge_bearing =
+            coordinate_calculation::bearing(coordinates->at(segment.u), coordinates->at(segment.v));
+
+        const float backward_edge_bearing = (forward_edge_bearing + 180) > 360
+                                                ? (forward_edge_bearing - 180)
+                                                : (forward_edge_bearing + 180);
+
+        const bool forward_bearing_valid =
+            bearing::CheckInBounds(forward_edge_bearing, filter_bearing, filter_bearing_range) &&
+            segment.forward_edge_based_node_id != SPECIAL_NODEID;
+        const bool backward_bearing_valid =
+            bearing::CheckInBounds(backward_edge_bearing, filter_bearing, filter_bearing_range) &&
+            segment.reverse_edge_based_node_id != SPECIAL_NODEID;
+        return std::make_pair(forward_bearing_valid, backward_bearing_valid);
+    }
+
+    RTreeT &rtree;
+    const std::shared_ptr<CoordinateList> coordinates;
+};
+
+#endif
@@ -1,35 +1,31 @@
-#include "extractor/graph_compressor.hpp"
+#include "graph_compressor.hpp"

-#include "extractor/compressed_edge_container.hpp"
-#include "extractor/restriction_map.hpp"
-#include "util/dynamic_graph.hpp"
-#include "util/node_based_graph.hpp"
-#include "util/percent.hpp"
+#include "../data_structures/compressed_edge_container.hpp"
+#include "../data_structures/dynamic_graph.hpp"
+#include "../data_structures/node_based_graph.hpp"
+#include "../data_structures/restriction_map.hpp"
+#include "../data_structures/percent.hpp"

-#include "util/simple_logger.hpp"
-
-namespace osrm
-{
-namespace extractor
-{
+#include "../util/simple_logger.hpp"

 GraphCompressor::GraphCompressor(SpeedProfileProperties speed_profile)
    : speed_profile(std::move(speed_profile))
 {
 }

-void GraphCompressor::Compress(const std::unordered_set<NodeID> &barrier_nodes,
-                               const std::unordered_set<NodeID> &traffic_lights,
-                               RestrictionMap &restriction_map,
-                               util::NodeBasedDynamicGraph &graph,
-                               CompressedEdgeContainer &geometry_compressor)
+
+void GraphCompressor::Compress(const std::unordered_set<NodeID>& barrier_nodes,
+                               const std::unordered_set<NodeID>& traffic_lights,
+                               RestrictionMap& restriction_map,
+                               NodeBasedDynamicGraph& graph,
+                               CompressedEdgeContainer& geometry_compressor)
 {
    const unsigned original_number_of_nodes = graph.GetNumberOfNodes();
    const unsigned original_number_of_edges = graph.GetNumberOfEdges();

-    util::Percent progress(original_number_of_nodes);
+    Percent progress(original_number_of_nodes);

-    for (const NodeID node_v : util::irange(0u, original_number_of_nodes))
+    for (const NodeID node_v : osrm::irange(0u, original_number_of_nodes))
    {
        progress.printStatus(node_v);

@@ -68,10 +64,12 @@ void GraphCompressor::Compress(const std::unordered_set<NodeID> &barrier_nodes,
        const bool reverse_edge_order = graph.GetEdgeData(graph.BeginEdges(node_v)).reversed;
        const EdgeID forward_e2 = graph.BeginEdges(node_v) + reverse_edge_order;
        BOOST_ASSERT(SPECIAL_EDGEID != forward_e2);
-        BOOST_ASSERT(forward_e2 >= graph.BeginEdges(node_v) && forward_e2 < graph.EndEdges(node_v));
+        BOOST_ASSERT(forward_e2 >= graph.BeginEdges(node_v) &&
+                     forward_e2 < graph.EndEdges(node_v));
        const EdgeID reverse_e2 = graph.BeginEdges(node_v) + 1 - reverse_edge_order;
        BOOST_ASSERT(SPECIAL_EDGEID != reverse_e2);
-        BOOST_ASSERT(reverse_e2 >= graph.BeginEdges(node_v) && reverse_e2 < graph.EndEdges(node_v));
+        BOOST_ASSERT(reverse_e2 >= graph.BeginEdges(node_v) &&
+                     reverse_e2 < graph.EndEdges(node_v));

        const EdgeData &fwd_edge_data2 = graph.GetEdgeData(forward_e2);
        const EdgeData &rev_edge_data2 = graph.GetEdgeData(reverse_e2);
@@ -105,24 +103,13 @@ void GraphCompressor::Compress(const std::unordered_set<NodeID> &barrier_nodes,
            continue;
        }

-        if (fwd_edge_data1.IsCompatibleTo(fwd_edge_data2) &&
-            rev_edge_data1.IsCompatibleTo(rev_edge_data2))
+        if (fwd_edge_data1.IsCompatibleTo(fwd_edge_data2) && rev_edge_data1.IsCompatibleTo(rev_edge_data2))
        {
            BOOST_ASSERT(graph.GetEdgeData(forward_e1).name_id ==
                         graph.GetEdgeData(reverse_e1).name_id);
            BOOST_ASSERT(graph.GetEdgeData(forward_e2).name_id ==
                         graph.GetEdgeData(reverse_e2).name_id);

-            // Do not compress edge if it crosses a traffic signal.
-            // This can't be done in IsCompatibleTo, becase we only store the
-            // traffic signals in the `traffic_lights` list, which EdgeData
-            // doesn't have access to.
-            const bool has_node_penalty = traffic_lights.find(node_v) != traffic_lights.end();
-            if (has_node_penalty)
-            {
-                continue;
-            }
-
            // Get distances before graph is modified
            const int forward_weight1 = graph.GetEdgeData(forward_e1).distance;
            const int forward_weight2 = graph.GetEdgeData(forward_e2).distance;
@@ -136,9 +123,18 @@ void GraphCompressor::Compress(const std::unordered_set<NodeID> &barrier_nodes,
            BOOST_ASSERT(0 != reverse_weight1);
            BOOST_ASSERT(0 != reverse_weight2);

+            const bool has_node_penalty = traffic_lights.find(node_v) != traffic_lights.end();
+
            // add weight of e2's to e1
            graph.GetEdgeData(forward_e1).distance += fwd_edge_data2.distance;
            graph.GetEdgeData(reverse_e1).distance += rev_edge_data2.distance;
+            if (has_node_penalty)
+            {
+                graph.GetEdgeData(forward_e1).distance +=
+                    speed_profile.traffic_signal_penalty;
+                graph.GetEdgeData(reverse_e1).distance +=
+                    speed_profile.traffic_signal_penalty;
+            }

            // extend e1's to targets of e2's
            graph.SetTarget(forward_e1, node_w);
@@ -156,38 +152,28 @@ void GraphCompressor::Compress(const std::unordered_set<NodeID> &barrier_nodes,
            restriction_map.FixupArrivingTurnRestriction(node_w, node_v, node_u, graph);

            // store compressed geometry in container
-            geometry_compressor.CompressEdge(forward_e1, forward_e2, node_v, node_w,
-                                             forward_weight1, forward_weight2);
-            geometry_compressor.CompressEdge(reverse_e1, reverse_e2, node_v, node_u,
-                                             reverse_weight1, reverse_weight2);
+            geometry_compressor.CompressEdge(
+                forward_e1, forward_e2, node_v, node_w,
+                forward_weight1 + (has_node_penalty ? speed_profile.traffic_signal_penalty : 0),
+                forward_weight2);
+            geometry_compressor.CompressEdge(
+                reverse_e1, reverse_e2, node_v, node_u, reverse_weight1,
+                reverse_weight2 + (has_node_penalty ? speed_profile.traffic_signal_penalty : 0));
        }
    }

    PrintStatistics(original_number_of_nodes, original_number_of_edges, graph);
-
-    // Repeate the loop, but now add all edges as uncompressed values.
-    // The function AddUncompressedEdge does nothing if the edge is already
-    // in the CompressedEdgeContainer.
-    for (const NodeID node_u : util::irange(0u, original_number_of_nodes))
-    {
-        for (const auto edge_id : util::irange(graph.BeginEdges(node_u), graph.EndEdges(node_u)))
-        {
-            const EdgeData &data = graph.GetEdgeData(edge_id);
-            const NodeID target = graph.GetTarget(edge_id);
-            geometry_compressor.AddUncompressedEdge(edge_id, target, data.distance);
-        }
-    }
 }

 void GraphCompressor::PrintStatistics(unsigned original_number_of_nodes,
                                      unsigned original_number_of_edges,
-                                      const util::NodeBasedDynamicGraph &graph) const
+                                      const NodeBasedDynamicGraph& graph) const
 {

    unsigned new_node_count = 0;
    unsigned new_edge_count = 0;

-    for (const auto i : util::irange(0u, graph.GetNumberOfNodes()))
+    for (const auto i : osrm::irange(0u, graph.GetNumberOfNodes()))
    {
        if (graph.GetOutDegree(i) > 0)
        {
@@ -195,10 +181,8 @@ void GraphCompressor::PrintStatistics(unsigned original_number_of_nodes,
            new_edge_count += (graph.EndEdges(i) - graph.BeginEdges(i));
        }
    }
-    util::SimpleLogger().Write() << "Node compression ratio: "
-                                 << new_node_count / (double)original_number_of_nodes;
-    util::SimpleLogger().Write() << "Edge compression ratio: "
-                                 << new_edge_count / (double)original_number_of_edges;
-}
-}
+    SimpleLogger().Write() << "Node compression ratio: "
+                           << new_node_count / (double)original_number_of_nodes;
+    SimpleLogger().Write() << "Edge compression ratio: "
+                           << new_edge_count / (double)original_number_of_edges;
 }
@@ -0,0 +1,62 @@
+/*
+
+Copyright (c) 2014, Project OSRM, Dennis Luxen, others
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+#ifndef GEOMETRY_COMPRESSOR_HPP
+#define GEOMETRY_COMPRESSOR_HPP
+
+#include "../typedefs.h"
+
+#include "../extractor/speed_profile.hpp"
+#include "../data_structures/node_based_graph.hpp"
+
+#include <memory>
+#include <unordered_set>
+
+class CompressedEdgeContainer;
+class RestrictionMap;
+
+class GraphCompressor
+{
+    using EdgeData = NodeBasedDynamicGraph::EdgeData;
+
+public:
+  GraphCompressor(SpeedProfileProperties speed_profile);
+
+    void Compress(const std::unordered_set<NodeID>& barrier_nodes,
+                  const std::unordered_set<NodeID>& traffic_lights,
+                  RestrictionMap& restriction_map,
+                  NodeBasedDynamicGraph& graph,
+                  CompressedEdgeContainer& geometry_compressor);
+private:
+
+   void PrintStatistics(unsigned original_number_of_nodes,
+                        unsigned original_number_of_edges,
+                        const NodeBasedDynamicGraph& graph) const;
+
+    SpeedProfileProperties speed_profile;
+};
+
+#endif
@@ -0,0 +1,89 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef OBJECT_ENCODER_HPP
+#define OBJECT_ENCODER_HPP
+
+#include <boost/assert.hpp>
+#include <boost/archive/iterators/base64_from_binary.hpp>
+#include <boost/archive/iterators/binary_from_base64.hpp>
+#include <boost/archive/iterators/transform_width.hpp>
+
+#include <algorithm>
+#include <iterator>
+#include <string>
+#include <vector>
+
+struct ObjectEncoder
+{
+    using base64_t = boost::archive::iterators::base64_from_binary<
+        boost::archive::iterators::transform_width<const char *, 6, 8>>;
+
+    using binary_t = boost::archive::iterators::transform_width<
+        boost::archive::iterators::binary_from_base64<std::string::const_iterator>,
+        8,
+        6>;
+
+    template <class ObjectT> static void EncodeToBase64(const ObjectT &object, std::string &encoded)
+    {
+        const char *char_ptr_to_object = reinterpret_cast<const char *>(&object);
+        std::vector<unsigned char> data(sizeof(object));
+        std::copy(char_ptr_to_object, char_ptr_to_object + sizeof(ObjectT), data.begin());
+
+        unsigned char number_of_padded_chars = 0; // is in {0,1,2};
+        while (data.size() % 3 != 0)
+        {
+            ++number_of_padded_chars;
+            data.push_back(0x00);
+        }
+
+        BOOST_ASSERT_MSG(0 == data.size() % 3, "base64 input data size is not a multiple of 3!");
+        encoded.resize(sizeof(ObjectT));
+        encoded.assign(base64_t(&data[0]),
+                       base64_t(&data[0] + (data.size() - number_of_padded_chars)));
+        std::replace(begin(encoded), end(encoded), '+', '-');
+        std::replace(begin(encoded), end(encoded), '/', '_');
+    }
+
+    template <class ObjectT> static void DecodeFromBase64(const std::string &input, ObjectT &object)
+    {
+        try
+        {
+            std::string encoded(input);
+            std::replace(begin(encoded), end(encoded), '-', '+');
+            std::replace(begin(encoded), end(encoded), '_', '/');
+
+            std::copy(binary_t(encoded.begin()), binary_t(encoded.begin() + encoded.length()),
+                      reinterpret_cast<char *>(&object));
+        }
+        catch (...)
+        {
+        }
+    }
+};
+
+#endif /* OBJECT_ENCODER_HPP */
@@ -0,0 +1,128 @@
+/*
+
+Copyright (c) 2014, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#include "polyline_compressor.hpp"
+#include "../data_structures/segment_information.hpp"
+
+#include <osrm/coordinate.hpp>
+
+std::string PolylineCompressor::encode_vector(std::vector<int> &numbers) const
+{
+    std::string output;
+    const auto end = numbers.size();
+    for (std::size_t i = 0; i < end; ++i)
+    {
+        numbers[i] <<= 1;
+        if (numbers[i] < 0)
+        {
+            numbers[i] = ~(numbers[i]);
+        }
+    }
+    for (const int number : numbers)
+    {
+        output += encode_number(number);
+    }
+    return output;
+}
+
+std::string PolylineCompressor::encode_number(int number_to_encode) const
+{
+    std::string output;
+    while (number_to_encode >= 0x20)
+    {
+        const int next_value = (0x20 | (number_to_encode & 0x1f)) + 63;
+        output += static_cast<char>(next_value);
+        number_to_encode >>= 5;
+    }
+
+    number_to_encode += 63;
+    output += static_cast<char>(number_to_encode);
+    return output;
+}
+
+std::string
+PolylineCompressor::get_encoded_string(const std::vector<SegmentInformation> &polyline) const
+{
+    if (polyline.empty())
+    {
+        return {};
+    }
+
+    std::vector<int> delta_numbers;
+    delta_numbers.reserve((polyline.size() - 1) * 2);
+    FixedPointCoordinate previous_coordinate = {0, 0};
+    for (const auto &segment : polyline)
+    {
+        if (segment.necessary)
+        {
+            const int lat_diff = segment.location.lat - previous_coordinate.lat;
+            const int lon_diff = segment.location.lon - previous_coordinate.lon;
+            delta_numbers.emplace_back(lat_diff);
+            delta_numbers.emplace_back(lon_diff);
+            previous_coordinate = segment.location;
+        }
+    }
+    return encode_vector(delta_numbers);
+}
+
+std::vector<FixedPointCoordinate> PolylineCompressor::decode_string(const std::string &geometry_string) const
+{
+    std::vector<FixedPointCoordinate> new_coordinates;
+    int index = 0, len = geometry_string.size();
+    int lat = 0, lng = 0;
+  
+    while (index < len) 
+    {
+        int b, shift = 0, result = 0;
+        do 
+        {
+            b = geometry_string.at(index++) - 63;
+            result |= (b & 0x1f) << shift;
+            shift += 5;
+        } while (b >= 0x20);
+        int dlat = ((result & 1) != 0 ? ~(result >> 1) : (result >> 1));
+        lat += dlat;
+
+        shift = 0;
+        result = 0;
+        do 
+        {
+            b = geometry_string.at(index++) - 63;
+            result |= (b & 0x1f) << shift;
+            shift += 5;
+        } while (b >= 0x20);
+        int dlng = ((result & 1) != 0 ? ~(result >> 1) : (result >> 1));
+        lng += dlng;
+
+        FixedPointCoordinate p;
+        p.lat = COORDINATE_PRECISION * (((double) lat / 1E6));
+        p.lon = COORDINATE_PRECISION * (((double) lng / 1E6));
+        new_coordinates.push_back(p);
+    }
+
+    return new_coordinates;
+}
@@ -0,0 +1,51 @@
+/*
+
+Copyright (c) 2013, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef POLYLINECOMPRESSOR_H_
+#define POLYLINECOMPRESSOR_H_
+
+struct SegmentInformation;
+
+#include <osrm/coordinate.hpp>
+
+#include <string>
+#include <vector>
+
+class PolylineCompressor
+{
+  private:
+    std::string encode_vector(std::vector<int> &numbers) const;
+
+    std::string encode_number(const int number_to_encode) const;
+
+  public:
+    std::string get_encoded_string(const std::vector<SegmentInformation> &polyline) const;
+    
+    std::vector<FixedPointCoordinate> decode_string(const std::string &geometry_string) const;
+};
+
+#endif /* POLYLINECOMPRESSOR_H_ */
@@ -0,0 +1,56 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#include "polyline_formatter.hpp"
+
+#include "polyline_compressor.hpp"
+#include "../data_structures/segment_information.hpp"
+
+#include <osrm/coordinate.hpp>
+
+osrm::json::String
+PolylineFormatter::printEncodedString(const std::vector<SegmentInformation> &polyline) const
+{
+    return osrm::json::String(PolylineCompressor().get_encoded_string(polyline));
+}
+
+osrm::json::Array
+PolylineFormatter::printUnencodedString(const std::vector<SegmentInformation> &polyline) const
+{
+    osrm::json::Array json_geometry_array;
+    for (const auto &segment : polyline)
+    {
+        if (segment.necessary)
+        {
+            osrm::json::Array json_coordinate;
+            json_coordinate.values.push_back(segment.location.lat / COORDINATE_PRECISION);
+            json_coordinate.values.push_back(segment.location.lon / COORDINATE_PRECISION);
+            json_geometry_array.values.push_back(json_coordinate);
+        }
+    }
+    return json_geometry_array;
+}
@@ -0,0 +1,45 @@
+/*
+
+Copyright (c) 2014, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef POLYLINE_FORMATTER_HPP
+#define POLYLINE_FORMATTER_HPP
+
+struct SegmentInformation;
+
+#include <osrm/json_container.hpp>
+
+#include <string>
+#include <vector>
+
+struct PolylineFormatter
+{
+    osrm::json::String printEncodedString(const std::vector<SegmentInformation> &polyline) const;
+
+    osrm::json::Array printUnencodedString(const std::vector<SegmentInformation> &polyline) const;
+};
+
+#endif /* POLYLINE_FORMATTER_HPP */
@@ -0,0 +1,162 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef EXTRACT_ROUTE_NAMES_H
+#define EXTRACT_ROUTE_NAMES_H
+
+#include <boost/assert.hpp>
+
+#include <algorithm>
+#include <string>
+#include <vector>
+
+struct RouteNames
+{
+    std::string shortest_path_name_1;
+    std::string shortest_path_name_2;
+    std::string alternative_path_name_1;
+    std::string alternative_path_name_2;
+};
+
+// construct routes names
+template <class DataFacadeT, class SegmentT> struct ExtractRouteNames
+{
+  private:
+    SegmentT PickNextLongestSegment(const std::vector<SegmentT> &segment_list,
+                                    const unsigned blocked_name_id) const
+    {
+        SegmentT result_segment;
+        result_segment.length = 0;
+
+        for (const SegmentT &segment : segment_list)
+        {
+            if (segment.name_id != blocked_name_id && segment.length > result_segment.length &&
+                segment.name_id != 0)
+            {
+                result_segment = segment;
+            }
+        }
+        return result_segment;
+    }
+
+  public:
+    RouteNames operator()(std::vector<SegmentT> &shortest_path_segments,
+                          std::vector<SegmentT> &alternative_path_segments,
+                          const DataFacadeT *facade) const
+    {
+        RouteNames route_names;
+
+        SegmentT shortest_segment_1, shortest_segment_2;
+        SegmentT alternative_segment_1, alternative_segment_2;
+
+        auto length_comperator = [](const SegmentT &a, const SegmentT &b)
+        {
+            return a.length > b.length;
+        };
+        auto name_id_comperator = [](const SegmentT &a, const SegmentT &b)
+        {
+            return a.name_id < b.name_id;
+        };
+
+        if (shortest_path_segments.empty())
+        {
+            return route_names;
+        }
+
+        // pick the longest segment for the shortest path.
+        std::sort(shortest_path_segments.begin(), shortest_path_segments.end(), length_comperator);
+        shortest_segment_1 = shortest_path_segments[0];
+        if (!alternative_path_segments.empty())
+        {
+            std::sort(alternative_path_segments.begin(), alternative_path_segments.end(),
+                      length_comperator);
+
+            // also pick the longest segment for the alternative path
+            alternative_segment_1 = alternative_path_segments[0];
+        }
+
+        // compute the set difference (for shortest path) depending on names between shortest and
+        // alternative
+        std::vector<SegmentT> shortest_path_set_difference(shortest_path_segments.size());
+        std::sort(shortest_path_segments.begin(), shortest_path_segments.end(), name_id_comperator);
+        std::sort(alternative_path_segments.begin(), alternative_path_segments.end(),
+                  name_id_comperator);
+        std::set_difference(shortest_path_segments.begin(), shortest_path_segments.end(),
+                            alternative_path_segments.begin(), alternative_path_segments.end(),
+                            shortest_path_set_difference.begin(), name_id_comperator);
+
+        std::sort(shortest_path_set_difference.begin(), shortest_path_set_difference.end(),
+                  length_comperator);
+        shortest_segment_2 =
+            PickNextLongestSegment(shortest_path_set_difference, shortest_segment_1.name_id);
+
+        // compute the set difference (for alternative path) depending on names between shortest and
+        // alternative
+        // vectors are still sorted, no need to do again
+        BOOST_ASSERT(std::is_sorted(shortest_path_segments.begin(), shortest_path_segments.end(),
+                                    name_id_comperator));
+        BOOST_ASSERT(std::is_sorted(alternative_path_segments.begin(),
+                                    alternative_path_segments.end(), name_id_comperator));
+
+        std::vector<SegmentT> alternative_path_set_difference(alternative_path_segments.size());
+        std::set_difference(alternative_path_segments.begin(), alternative_path_segments.end(),
+                            shortest_path_segments.begin(), shortest_path_segments.end(),
+                            alternative_path_set_difference.begin(), name_id_comperator);
+
+        std::sort(alternative_path_set_difference.begin(), alternative_path_set_difference.end(),
+                  length_comperator);
+
+        if (!alternative_path_segments.empty())
+        {
+            alternative_segment_2 = PickNextLongestSegment(alternative_path_set_difference,
+                                                           alternative_segment_1.name_id);
+        }
+
+        // move the segments into the order in which they occur.
+        if (shortest_segment_1.position > shortest_segment_2.position)
+        {
+            std::swap(shortest_segment_1, shortest_segment_2);
+        }
+        if (alternative_segment_1.position > alternative_segment_2.position)
+        {
+            std::swap(alternative_segment_1, alternative_segment_2);
+        }
+
+        // fetching names for the selected segments
+        route_names.shortest_path_name_1 = facade->get_name_for_id(shortest_segment_1.name_id);
+        route_names.shortest_path_name_2 = facade->get_name_for_id(shortest_segment_2.name_id);
+
+        route_names.alternative_path_name_1 =
+            facade->get_name_for_id(alternative_segment_1.name_id);
+        route_names.alternative_path_name_2 =
+            facade->get_name_for_id(alternative_segment_2.name_id);
+
+        return route_names;
+    }
+};
+
+#endif // EXTRACT_ROUTE_NAMES_H
@@ -1,18 +1,45 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
 #ifndef TARJAN_SCC_HPP
 #define TARJAN_SCC_HPP

-#include "util/typedefs.hpp"
-#include "util/deallocating_vector.hpp"
-#include "extractor/node_based_edge.hpp"
-#include "extractor/query_node.hpp"
-#include "util/percent.hpp"
+#include "../typedefs.h"
+#include "../data_structures/deallocating_vector.hpp"
+#include "../data_structures/import_edge.hpp"
+#include "../data_structures/query_node.hpp"
+#include "../data_structures/percent.hpp"

-#include "util/integer_range.hpp"
-#include "util/simple_logger.hpp"
-#include "util/std_hash.hpp"
-#include "util/timing_util.hpp"
+#include "../util/integer_range.hpp"
+#include "../util/simple_logger.hpp"
+#include "../util/std_hash.hpp"
+#include "../util/timing_util.hpp"

-#include "osrm/coordinate.hpp"
+#include <osrm/coordinate.hpp>
 #include <boost/assert.hpp>
 #include <cstdint>

@@ -22,11 +49,6 @@
 #include <stack>
 #include <vector>

-namespace osrm
-{
-namespace extractor
-{
-
 template <typename GraphT> class TarjanSCC
 {
    struct TarjanStackFrame
@@ -71,7 +93,7 @@ template <typename GraphT> class TarjanSCC
        unsigned component_index = 0, size_of_current_component = 0;
        unsigned index = 0;
        std::vector<bool> processing_node_before_recursion(max_node_id, true);
-        for (const NodeID node : util::irange(0u, max_node_id))
+        for (const NodeID node : osrm::irange(0u, max_node_id))
        {
            if (SPECIAL_NODEID == components_index[node])
            {
@@ -146,8 +168,8 @@ template <typename GraphT> class TarjanSCC

                        if (size_of_current_component > 1000)
                        {
-                            util::SimpleLogger().Write() << "large component [" << component_index
-                                                         << "]=" << size_of_current_component;
+                            SimpleLogger().Write() << "large component [" << component_index
+                                                   << "]=" << size_of_current_component;
                        }

                        ++component_index;
@@ -158,7 +180,7 @@ template <typename GraphT> class TarjanSCC
        }

        TIMER_STOP(SCC_RUN);
-        util::SimpleLogger().Write() << "SCC run took: " << TIMER_MSEC(SCC_RUN) / 1000. << "s";
+        SimpleLogger().Write() << "SCC run took: " << TIMER_MSEC(SCC_RUN) / 1000. << "s";

        size_one_counter = std::count_if(component_size_vector.begin(), component_size_vector.end(),
                                         [](unsigned value)
@@ -178,7 +200,5 @@ template <typename GraphT> class TarjanSCC

    unsigned get_component_id(const NodeID node) const { return components_index[node]; }
 };
-}
-}

 #endif /* TARJAN_SCC_HPP */
@@ -1,11 +1,38 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
 #ifndef TRIP_BRUTE_FORCE_HPP
 #define TRIP_BRUTE_FORCE_HPP

-#include "util/typedefs.hpp"
-#include "util/dist_table_wrapper.hpp"
-#include "util/simple_logger.hpp"
+#include "../data_structures/search_engine.hpp"
+#include "../util/dist_table_wrapper.hpp"
+#include "../util/simple_logger.hpp"

-#include "osrm/json_container.hpp"
+#include <osrm/json_container.hpp>

 #include <cstdlib>
 #include <algorithm>
@@ -16,13 +43,11 @@

 namespace osrm
 {
-namespace engine
-{
 namespace trip
 {

 // computes the distance of a given permutation
-EdgeWeight ReturnDistance(const util::DistTableWrapper<EdgeWeight> &dist_table,
+EdgeWeight ReturnDistance(const DistTableWrapper<EdgeWeight> &dist_table,
                          const std::vector<NodeID> &location_order,
                          const EdgeWeight min_route_dist,
                          const std::size_t component_size)
@@ -46,7 +71,7 @@ template <typename NodeIDIterator>
 std::vector<NodeID> BruteForceTrip(const NodeIDIterator start,
                                   const NodeIDIterator end,
                                   const std::size_t number_of_locations,
-                                   const util::DistTableWrapper<EdgeWeight> &dist_table)
+                                   const DistTableWrapper<EdgeWeight> &dist_table)
 {
    (void)number_of_locations; // unused

@@ -77,8 +102,7 @@ std::vector<NodeID> BruteForceTrip(const NodeIDIterator start,

    return route;
 }
-}
-}
-}

+} // end namespace trip
+} // end namespace osrm
 #endif // TRIP_BRUTE_FORCE_HPP
@@ -1,10 +1,37 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
 #ifndef TRIP_FARTHEST_INSERTION_HPP
 #define TRIP_FARTHEST_INSERTION_HPP

-#include "util/typedefs.hpp"
-#include "util/dist_table_wrapper.hpp"
+#include "../data_structures/search_engine.hpp"
+#include "../util/dist_table_wrapper.hpp"

-#include "osrm/json_container.hpp"
+#include <osrm/json_container.hpp>
 #include <boost/assert.hpp>

 #include <cstdlib>
@@ -15,8 +42,6 @@

 namespace osrm
 {
-namespace engine
-{
 namespace trip
 {

@@ -25,7 +50,7 @@ namespace trip
 using NodeIDIter = std::vector<NodeID>::iterator;
 std::pair<EdgeWeight, NodeIDIter>
 GetShortestRoundTrip(const NodeID new_loc,
-                     const util::DistTableWrapper<EdgeWeight> &dist_table,
+                     const DistTableWrapper<EdgeWeight> &dist_table,
                     const std::size_t number_of_locations,
                     std::vector<NodeID> &route)
 {
@@ -78,7 +103,7 @@ std::vector<NodeID> FindRoute(const std::size_t &number_of_locations,
                              const std::size_t &component_size,
                              const NodeIDIterator &start,
                              const NodeIDIterator &end,
-                              const util::DistTableWrapper<EdgeWeight> &dist_table,
+                              const DistTableWrapper<EdgeWeight> &dist_table,
                              const NodeID &start1,
                              const NodeID &start2)
 {
@@ -140,7 +165,7 @@ template <typename NodeIDIterator>
 std::vector<NodeID> FarthestInsertionTrip(const NodeIDIterator &start,
                                          const NodeIDIterator &end,
                                          const std::size_t number_of_locations,
-                                          const util::DistTableWrapper<EdgeWeight> &dist_table)
+                                          const DistTableWrapper<EdgeWeight> &dist_table)
 {
    //////////////////////////////////////////////////////////////////////////////////////////////////
    // START FARTHEST INSERTION HERE
@@ -190,8 +215,8 @@ std::vector<NodeID> FarthestInsertionTrip(const NodeIDIterator &start,
    BOOST_ASSERT_MSG(static_cast<std::size_t>(max_to) < number_of_locations, "start node");
    return FindRoute(number_of_locations, component_size, start, end, dist_table, max_from, max_to);
 }
-}
-}
-}
+
+} // end namespace trip
+} // end namespace osrm

 #endif // TRIP_FARTHEST_INSERTION_HPP
@@ -1,11 +1,38 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
 #ifndef TRIP_NEAREST_NEIGHBOUR_HPP
 #define TRIP_NEAREST_NEIGHBOUR_HPP

-#include "util/typedefs.hpp"
-#include "util/simple_logger.hpp"
-#include "util/dist_table_wrapper.hpp"
+#include "../data_structures/search_engine.hpp"
+#include "../util/simple_logger.hpp"
+#include "../util/dist_table_wrapper.hpp"

-#include "osrm/json_container.hpp"
+#include <osrm/json_container.hpp>

 #include <cstdlib>
 #include <algorithm>
@@ -15,16 +42,13 @@

 namespace osrm
 {
-namespace engine
-{
 namespace trip
 {
-
 template <typename NodeIDIterator>
 std::vector<NodeID> NearestNeighbourTrip(const NodeIDIterator &start,
                                         const NodeIDIterator &end,
                                         const std::size_t number_of_locations,
-                                         const util::DistTableWrapper<EdgeWeight> &dist_table)
+                                         const DistTableWrapper<EdgeWeight> &dist_table)
 {
    //////////////////////////////////////////////////////////////////////////////////////////////////
    // START GREEDY NEAREST NEIGHBOUR HERE
@@ -92,8 +116,7 @@ std::vector<NodeID> NearestNeighbourTrip(const NodeIDIterator &start,
    }
    return route;
 }
-}
-}
-}

-#endif // TRIP_NEAREST_NEIGHBOUR_HPP
+} // end namespace trip
+} // end namespace osrm
+#endif // TRIP_NEAREST_NEIGHBOUR_HPP
@@ -1,6 +1,6 @@
 /*

-Copyright (c) 2016, Project OSRM contributors
+Copyright (c) 2015, Project OSRM contributors
 All rights reserved.

 Redistribution and use in source and binary forms, with or without modification,
@@ -25,46 +25,40 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

-#ifndef ENGINE_API_MATCH_PARAMETERS_HPP
-#define ENGINE_API_MATCH_PARAMETERS_HPP
+#ifndef TRIP_BRUTE_FORCE_HPP
+#define TRIP_BRUTE_FORCE_HPP

-#include "engine/api/route_parameters.hpp"
+#include "../data_structures/search_engine.hpp"
+#include "../util/simple_logger.hpp"

+#include <osrm/json_container.hpp>
+
+#include <cstdlib>
+#include <algorithm>
+#include <string>
 #include <vector>
+#include <limits>

 namespace osrm
 {
-namespace engine
-{
-namespace api
+namespace trip
 {

-struct MatchParameters : public RouteParameters
+// todo: yet to be implemented
+void TabuSearchTrip(std::vector<unsigned> &location,
+                    const PhantomNodeArray &phantom_node_vector,
+                    const std::vector<EdgeWeight> &dist_table,
+                    InternalRouteResult &min_route,
+                    std::vector<int> &min_loc_permutation)
 {
-    MatchParameters()
-        : RouteParameters(false,
-                          false,
-                          RouteParameters::GeometriesType::Polyline,
-                          RouteParameters::OverviewType::Simplified,
-                          {})
-    {
-    }
+}

-    template <typename... Args>
-    MatchParameters(std::vector<unsigned> timestamps_, Args... args_)
-        : RouteParameters{std::forward<Args>(args_)...}, timestamps{std::move(timestamps_)}
-    {
-    }
-
-    std::vector<unsigned> timestamps;
-    bool IsValid() const
-    {
-        return RouteParameters::IsValid() &&
-               (timestamps.empty() || timestamps.size() == coordinates.size());
-    }
-};
+void TabuSearchTrip(const PhantomNodeArray &phantom_node_vector,
+                    const std::vector<EdgeWeight> &dist_table,
+                    InternalRouteResult &min_route,
+                    std::vector<int> &min_loc_permutation)
+{
 }
 }
 }
-
-#endif
+#endif // TRIP_BRUTE_FORCE_HPP
@@ -81,14 +81,11 @@ IF %ERRORLEVEL% NEQ 0 GOTO ERROR

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

-ECHO running engine-tests.exe ...
-%Configuration%\engine-tests.exe
+ECHO running datastructure-tests.exe ...
+%Configuration%\datastructure-tests.exe
 IF %ERRORLEVEL% NEQ 0 GOTO ERROR
-ECHO running extractor-tests.exe ...
-%Configuration%\extractor-tests.exe
-IF %ERRORLEVEL% NEQ 0 GOTO ERROR
-ECHO running util-tests.exe ...
-%Configuration%\util-tests.exe
+ECHO running algorithm-tests.exe ...
+%Configuration%\algorithm-tests.exe
 IF %ERRORLEVEL% NEQ 0 GOTO ERROR

 IF NOT "%APPVEYOR_REPO_BRANCH%"=="develop" GOTO DONE
@@ -25,11 +25,6 @@ artifacts:
 #  - path: osrm_Debug.zip
 #    name: osrm_Debug.zip

-branches:
-  only:
-    - master
-    - develop
-
 deploy:
  provider: FTP
  server:
@@ -0,0 +1,152 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#include "../data_structures/query_node.hpp"
+#include "../data_structures/static_rtree.hpp"
+#include "../data_structures/edge_based_node.hpp"
+#include "../algorithms/geospatial_query.hpp"
+#include "../util/timing_util.hpp"
+
+#include <osrm/coordinate.hpp>
+
+#include <random>
+#include <iostream>
+
+// Choosen by a fair W20 dice roll (this value is completely arbitrary)
+constexpr unsigned RANDOM_SEED = 13;
+constexpr int32_t WORLD_MIN_LAT = -90 * COORDINATE_PRECISION;
+constexpr int32_t WORLD_MAX_LAT = 90 * COORDINATE_PRECISION;
+constexpr int32_t WORLD_MIN_LON = -180 * COORDINATE_PRECISION;
+constexpr int32_t WORLD_MAX_LON = 180 * COORDINATE_PRECISION;
+
+using RTreeLeaf = EdgeBasedNode;
+using FixedPointCoordinateListPtr = std::shared_ptr<std::vector<FixedPointCoordinate>>;
+using BenchStaticRTree = StaticRTree<RTreeLeaf, ShM<FixedPointCoordinate, false>::vector, false>;
+using BenchQuery = GeospatialQuery<BenchStaticRTree>;
+
+FixedPointCoordinateListPtr LoadCoordinates(const boost::filesystem::path &nodes_file)
+{
+    boost::filesystem::ifstream nodes_input_stream(nodes_file, std::ios::binary);
+
+    QueryNode current_node;
+    unsigned coordinate_count = 0;
+    nodes_input_stream.read((char *)&coordinate_count, sizeof(unsigned));
+    auto coords = std::make_shared<std::vector<FixedPointCoordinate>>(coordinate_count);
+    for (unsigned i = 0; i < coordinate_count; ++i)
+    {
+        nodes_input_stream.read((char *)&current_node, sizeof(QueryNode));
+        coords->at(i) = FixedPointCoordinate(current_node.lat, current_node.lon);
+        BOOST_ASSERT((std::abs(coords->at(i).lat) >> 30) == 0);
+        BOOST_ASSERT((std::abs(coords->at(i).lon) >> 30) == 0);
+    }
+    nodes_input_stream.close();
+    return coords;
+}
+
+template <typename QueryT>
+void BenchmarkQuery(const std::vector<FixedPointCoordinate> &queries,
+                    const std::string& name,
+                    QueryT query)
+{
+    std::cout << "Running " << name << " with " << queries.size() << " coordinates: " << std::flush;
+
+    TIMER_START(query);
+    for (const auto &q : queries)
+    {
+        auto result = query(q);
+    }
+    TIMER_STOP(query);
+
+    std::cout << "Took " << TIMER_SEC(query) << " seconds "
+              << "(" << TIMER_MSEC(query) << "ms"
+              << ")  ->  " << TIMER_MSEC(query) / queries.size() << " ms/query "
+              << "(" << TIMER_MSEC(query) << "ms"
+              << ")" << std::endl;
+}
+
+void Benchmark(BenchStaticRTree &rtree, BenchQuery &geo_query, unsigned num_queries)
+{
+    std::mt19937 mt_rand(RANDOM_SEED);
+    std::uniform_int_distribution<> lat_udist(WORLD_MIN_LAT, WORLD_MAX_LAT);
+    std::uniform_int_distribution<> lon_udist(WORLD_MIN_LON, WORLD_MAX_LON);
+    std::vector<FixedPointCoordinate> queries;
+    for (unsigned i = 0; i < num_queries; i++)
+    {
+        queries.emplace_back(lat_udist(mt_rand), lon_udist(mt_rand));
+    }
+
+    BenchmarkQuery(queries, "raw RTree queries (1 result)", [&rtree](const FixedPointCoordinate &q)
+                   {
+                       return rtree.Nearest(q, 1);
+                   });
+    BenchmarkQuery(queries, "raw RTree queries (10 results)",
+                   [&rtree](const FixedPointCoordinate &q)
+                   {
+                       return rtree.Nearest(q, 10);
+                   });
+
+    BenchmarkQuery(queries, "big component alternative queries",
+                   [&geo_query](const FixedPointCoordinate &q)
+                   {
+                       return geo_query.NearestPhantomNodeWithAlternativeFromBigComponent(q);
+                   });
+    BenchmarkQuery(queries, "max distance 1000", [&geo_query](const FixedPointCoordinate &q)
+                   {
+                       return geo_query.NearestPhantomNodesInRange(q, 1000);
+                   });
+    BenchmarkQuery(queries, "PhantomNode query (1 result)", [&geo_query](const FixedPointCoordinate &q)
+                   {
+                       return geo_query.NearestPhantomNodes(q, 1);
+                   });
+    BenchmarkQuery(queries, "PhantomNode query (10 result)", [&geo_query](const FixedPointCoordinate &q)
+                   {
+                       return geo_query.NearestPhantomNodes(q, 10);
+                   });
+}
+
+int main(int argc, char **argv)
+{
+    if (argc < 4)
+    {
+        std::cout << "./rtree-bench file.ramIndex file.fileIndx file.nodes"
+                  << "\n";
+        return 1;
+    }
+
+    const char *ramPath = argv[1];
+    const char *filePath = argv[2];
+    const char *nodesPath = argv[3];
+
+    auto coords = LoadCoordinates(nodesPath);
+
+    BenchStaticRTree rtree(ramPath, filePath, coords);
+    BenchQuery query(rtree, coords);
+
+    Benchmark(rtree, query, 10000);
+
+    return 0;
+}
@@ -7,13 +7,15 @@ INCLUDE(FindDebArch)
 SET(CPACK_RESOURCE_FILE_README "${CMAKE_SOURCE_DIR}/README.md")
 SET(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_SOURCE_DIR}/LICENCE.TXT")
 SET(CPACK_PACKAGE_DESCRIPTION_FILE "${CPACK_RESOURCE_FILE_README}")
-SET(CPACK_PACKAGE_UPSTREAM_VERSION "${OSRM_VERSION_MAJOR}.${OSRM_VERSION_MINOR}.${OSRM_VERSION_PATCH}")
-SET(CPACK_PACKAGE_DEBIAN_REVISION "1")
-SET(CPACK_PACKAGE_VERSION "${CPACK_PACKAGE_UPSTREAM_VERSION}-${CPACK_PACKAGE_DEBIAN_REVISION}")
+SET(CPACK_PACKAGE_VERSION_MAJOR "0")
+SET(CPACK_PACKAGE_VERSION_MINOR "4")
+SET(CPACK_PACKAGE_VERSION_PATCH "3")
+
+SET(CPACK_PACKAGE_VERSION "${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH}")

 string(TOLOWER "${CMAKE_PROJECT_NAME}" LOWER_PROJECT_NAME)
 SET(CPACK_PACKAGE_FILE_NAME "${LOWER_PROJECT_NAME}_${CPACK_PACKAGE_VERSION}_${CPACK_DEBIAN_PACKAGE_ARCHITECTURE}")
-SET(CPACK_SOURCE_PACKAGE_FILE_NAME "${LOWER_PROJECT_NAME}_${CPACK_PACKAGE_UPSTREAM_VERSION}_orig")
+SET(CPACK_SOURCE_PACKAGE_FILE_NAME "${LOWER_PROJECT_NAME}_${CPACK_PACKAGE_VERSION}_orig")
 SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Open Source Routing Machine (OSRM).")
 SET(CPACK_PACKAGE_DESCRIPTION "Open Source Routing Machine (OSRM) is a routing engine.")

@@ -25,7 +27,7 @@ SET(CPACK_INCLUDE_TOPLEVEL_DIRECTORY "FALSE")
 SET(CPACK_GENERATOR "DEB")

 SET(CPACK_DEBIAN_PACKAGE_NAME        "${CPACK_PACKAGE_NAME}${VERSION_SUFFIX}")
-SET(CPACK_DEBIAN_PACKAGE_VERSION     "${CPACK_PACKAGE_VERSION}")
+SET(CPACK_DEBIAN_PACKAGE_VERSION     "${CPACK_PACKAGE_VERSION}${CPACK_PACKAGE_REVISION}")
 SET(CPACK_DEBIAN_PACKAGE_MAINTAINER  "Dennis Luxen <info@project-osrm.org>")
 SET(CPACK_DEBIAN_PACKAGE_PRIORITY    "optional")
 SET(CPACK_DEBIAN_PACKAGE_SECTION     "devel")
@@ -36,6 +38,7 @@ SET(CPACK_DEBIAN_PACKAGE_DEPENDS     "libc6-dev, libbz2-1.0, libstxxl1, libxml2,

 file(GLOB_RECURSE ProfileGlob ${CMAKE_SOURCE_DIR}/profiles/*)
 install(FILES ${ProfileGlob} DESTINATION "share/doc/${LOWER_PROJECT_NAME}/profiles")
-set(CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA "${CMAKE_CURRENT_BINARY_DIR}/copyright;")
+CONFIGURE_FILE (${CMAKE_SOURCE_DIR}/cmake/postinst.in postinst)
+set(CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA "${CMAKE_CURRENT_BINARY_DIR}/postinst;${CMAKE_CURRENT_BINARY_DIR}/copyright;")

 MESSAGE(STATUS "Debian Package: ${CPACK_DEBIAN_PACKAGE_NAME} (${CPACK_DEBIAN_PACKAGE_VERSION}) [${CPACK_PACKAGE_FILE_NAME}.deb]")
@@ -14,7 +14,7 @@

 #=============================================================================
 # Copyright 2007-2009 Kitware, Inc.
-# Copyright 2016 for Project-OSRM, Lua5.1 => Lua5.2
+# Copyright 2013 for Project-OSRM, Lua5.1 => Lua5.2
 #
 # Distributed under the OSI-approved BSD License (the "License");
 # see accompanying file Copyright.txt for details.
@@ -24,7 +24,7 @@ FIND_PATH(STXXL_INCLUDE_DIR stxxl.h
 )

 FIND_LIBRARY(STXXL_LIBRARY
-  NAMES stxxl stxxl_debug
+  NAMES stxxl
  HINTS
  $ENV{STXXL_DIR}
  PATH_SUFFIXES lib64 lib
@@ -1,10 +1,10 @@
-set(OLDFILE ${OUTPUT_DIR}/include/util/fingerprint_impl.hpp)
+set(OLDFILE ${OUTPUT_DIR}/util/fingerprint_impl.hpp)
 set(NEWFILE ${OLDFILE}.tmp)
-set(INFILE ${SOURCE_DIR}/include/util/fingerprint_impl.hpp.in)
-file(MD5 ${SOURCE_DIR}/src/tools/contract.cpp MD5PREPARE)
-file(MD5 ${SOURCE_DIR}/include/util/static_rtree.hpp MD5RTREE)
-file(MD5 ${SOURCE_DIR}/include/util/graph_loader.hpp MD5GRAPH)
-file(MD5 ${SOURCE_DIR}/include/engine/datafacade/internal_datafacade.hpp MD5OBJECTS)
+set(INFILE ${SOURCE_DIR}/util/fingerprint_impl.hpp.in)
+file(MD5 ${SOURCE_DIR}/prepare.cpp MD5PREPARE)
+file(MD5 ${SOURCE_DIR}/data_structures/static_rtree.hpp MD5RTREE)
+file(MD5 ${SOURCE_DIR}/util/graph_loader.hpp MD5GRAPH)
+file(MD5 ${SOURCE_DIR}/server/data_structures/internal_datafacade.hpp MD5OBJECTS)

 CONFIGURE_FILE(${INFILE} ${NEWFILE})

@@ -32,11 +32,13 @@ cache_file = "%s/cached_options.txt" % (scriptpath)
 db = None
 if os.access(cache_file, os.R_OK) == 0:
    db = load_db(sys.argv[1])
-    with open(cache_file, "wb") as f:
-        pickle.dump(db, f)
+    f = open(cache_file, "wb")
+    pickle.dump(db, f)
+    f.close()
 else:
-    with open(cache_file) as f:
-        db = pickle.load(f)
+    f = open(cache_file)
+    db = pickle.load(f)
+    f.close()

 if db and sys.argv[2] in db:
    for option in db[sys.argv[2]]:
@@ -1,21 +0,0 @@
-if(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
-  message(FATAL_ERROR "Cannot find install manifest: @CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
-endif(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
-
-file(READ "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt" files)
-string(REGEX REPLACE "\n" ";" files "${files}")
-foreach(file ${files})
-  message(STATUS "Uninstalling $ENV{DESTDIR}${file}")
-  if(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}")
-    exec_program(
-      "@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\""
-      OUTPUT_VARIABLE rm_out
-      RETURN_VALUE rm_retval
-      )
-    if(NOT "${rm_retval}" STREQUAL 0)
-      message(FATAL_ERROR "Problem when removing $ENV{DESTDIR}${file}")
-    endif(NOT "${rm_retval}" STREQUAL 0)
-  else(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}")
-    message(STATUS "File $ENV{DESTDIR}${file} does not exist.")
-  endif(IS_SYMLINK "$ENV{DESTDIR}${file}" OR EXISTS "$ENV{DESTDIR}${file}")
-endforeach(file)
@@ -1,11 +1,11 @@
 prefix=@CMAKE_INSTALL_PREFIX@
-includedir=${prefix}/include ${prefix}/include/osrm
+includedir=${prefix}/include
 libdir=${prefix}/lib

 Name: libOSRM
 Description: Project OSRM library
 Version: v@OSRM_VERSION_MAJOR@.@OSRM_VERSION_MINOR@.@OSRM_VERSION_PATCH@
 Requires:
-Libs: -L${libdir} -losrm
-Libs.private: @ENGINE_LIBRARY_LISTING@
+Libs: -L${libdir} -lOSRM
+Libs.private: @BOOST_LIBRARY_LISTING@ @TBB_LIBRARY_LISTING@
 Cflags: -I${includedir}
@@ -0,0 +1,2 @@
+#/usr/bin/env bash
+ln -s /usr/share/doc/@CMAKE_PROJECT_NAME@/profiles/car.lua @CMAKE_INSTALL_PREFIX@/profile.lua
@@ -1,17 +1,44 @@
-#ifndef GRAPH_CONTRACTOR_HPP
-#define GRAPH_CONTRACTOR_HPP
+/*

-#include "util/binary_heap.hpp"
-#include "util/deallocating_vector.hpp"
-#include "util/dynamic_graph.hpp"
-#include "util/percent.hpp"
-#include "contractor/query_edge.hpp"
-#include "util/xor_fast_hash.hpp"
-#include "util/xor_fast_hash_storage.hpp"
-#include "util/integer_range.hpp"
-#include "util/simple_logger.hpp"
-#include "util/timing_util.hpp"
-#include "util/typedefs.hpp"
+Copyright (c) 2015, Project OSRM, Dennis Luxen, others
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef CONTRACTOR_HPP
+#define CONTRACTOR_HPP
+
+#include "../data_structures/binary_heap.hpp"
+#include "../data_structures/deallocating_vector.hpp"
+#include "../data_structures/dynamic_graph.hpp"
+#include "../data_structures/percent.hpp"
+#include "../data_structures/query_edge.hpp"
+#include "../data_structures/xor_fast_hash.hpp"
+#include "../data_structures/xor_fast_hash_storage.hpp"
+#include "../util/integer_range.hpp"
+#include "../util/simple_logger.hpp"
+#include "../util/timing_util.hpp"
+#include "../typedefs.h"

 #include <boost/assert.hpp>

@@ -26,13 +53,9 @@
 #include <memory>
 #include <vector>

-namespace osrm
-{
-namespace contractor
+class Contractor
 {

-class GraphContractor
-{
  private:
    struct ContractorEdgeData
    {
@@ -63,22 +86,18 @@ class GraphContractor

    struct ContractorHeapData
    {
-        ContractorHeapData() {}
-        ContractorHeapData(short hop_, bool target_) : hop(hop_), target(target_) {}
-
-        short hop = 0;
-        bool target = false;
+        short hop;
+        bool target;
+        ContractorHeapData() : hop(0), target(false) {}
+        ContractorHeapData(short h, bool t) : hop(h), target(t) {}
    };

-    using ContractorGraph = util::DynamicGraph<ContractorEdgeData>;
-    //    using ContractorHeap = util::BinaryHeap<NodeID, NodeID, int, ContractorHeapData,
+    using ContractorGraph = DynamicGraph<ContractorEdgeData>;
+    //    using ContractorHeap = BinaryHeap<NodeID, NodeID, int, ContractorHeapData,
    //    ArrayStorage<NodeID, NodeID>
    //    >;
-    using ContractorHeap = util::BinaryHeap<NodeID,
-                                            NodeID,
-                                            int,
-                                            ContractorHeapData,
-                                            util::XORFastHashStorage<NodeID, NodeID>>;
+    using ContractorHeap =
+        BinaryHeap<NodeID, NodeID, int, ContractorHeapData, XORFastHashStorage<NodeID, NodeID>>;
    using ContractorEdge = ContractorGraph::InputEdge;

    struct ContractorThreadData
@@ -89,7 +108,11 @@ class GraphContractor
        explicit ContractorThreadData(NodeID nodes) : heap(nodes) {}
    };

-    using NodeDepth = int;
+    struct NodePriorityData
+    {
+        int depth;
+        NodePriorityData() : depth(0) {}
+    };

    struct ContractionStats
    {
@@ -134,18 +157,16 @@ class GraphContractor
    };

  public:
-    template <class ContainerT>
-    GraphContractor(int nodes, ContainerT &input_edge_list)
-        : GraphContractor(nodes, input_edge_list, {}, {})
+    template <class ContainerT> Contractor(int nodes, ContainerT &input_edge_list)
+      : Contractor(nodes, input_edge_list, {}, {})
    {
    }

    template <class ContainerT>
-    GraphContractor(int nodes,
-                    ContainerT &input_edge_list,
-                    std::vector<float> &&node_levels_,
-                    std::vector<EdgeWeight> &&node_weights_)
-        : node_levels(std::move(node_levels_)), node_weights(std::move(node_weights_))
+    Contractor(int nodes,
+               ContainerT &input_edge_list,
+               std::vector<float> &&node_levels_)
+        : node_levels(std::move(node_levels_))
    {
        std::vector<ContractorEdge> edges;
        edges.reserve(input_edge_list.size() * 2);
@@ -158,7 +179,7 @@ class GraphContractor
 #ifndef NDEBUG
            if (static_cast<unsigned int>(std::max(diter->weight, 1)) > 24 * 60 * 60 * 10)
            {
-                util::SimpleLogger().Write(logWARNING)
+                SimpleLogger().Write(logWARNING)
                    << "Edge weight large -> "
                    << static_cast<unsigned int>(std::max(diter->weight, 1)) << " : "
                    << static_cast<unsigned int>(diter->source) << " -> "
@@ -202,7 +223,8 @@ class GraphContractor
            forward_edge.data.shortcut = reverse_edge.data.shortcut = false;
            forward_edge.data.id = reverse_edge.data.id = id;
            forward_edge.data.originalEdges = reverse_edge.data.originalEdges = 1;
-            forward_edge.data.distance = reverse_edge.data.distance = INVALID_EDGE_WEIGHT;
+            forward_edge.data.distance = reverse_edge.data.distance =
+                std::numeric_limits<int>::max();
            // remove parallel edges
            while (i < edges.size() && edges[i].source == source && edges[i].target == target)
            {
@@ -221,7 +243,7 @@ class GraphContractor
            // merge edges (s,t) and (t,s) into bidirectional edge
            if (forward_edge.data.distance == reverse_edge.data.distance)
            {
-                if ((int)forward_edge.data.distance != INVALID_EDGE_WEIGHT)
+                if ((int)forward_edge.data.distance != std::numeric_limits<int>::max())
                {
                    forward_edge.data.backward = true;
                    edges[edge++] = forward_edge;
@@ -229,47 +251,70 @@ class GraphContractor
            }
            else
            { // insert seperate edges
-                if (((int)forward_edge.data.distance) != INVALID_EDGE_WEIGHT)
+                if (((int)forward_edge.data.distance) != std::numeric_limits<int>::max())
                {
                    edges[edge++] = forward_edge;
                }
-                if ((int)reverse_edge.data.distance != INVALID_EDGE_WEIGHT)
+                if ((int)reverse_edge.data.distance != std::numeric_limits<int>::max())
                {
                    edges[edge++] = reverse_edge;
                }
            }
        }
-        util::SimpleLogger().Write() << "merged " << edges.size() - edge << " edges out of "
-                                     << edges.size();
+        std::cout << "merged " << edges.size() - edge << " edges out of " << edges.size()
+                  << std::endl;
        edges.resize(edge);
        contractor_graph = std::make_shared<ContractorGraph>(nodes, edges);
        edges.clear();
        edges.shrink_to_fit();

        BOOST_ASSERT(0 == edges.capacity());
-        util::SimpleLogger().Write() << "contractor finished initalization";
+        //        unsigned maxdegree = 0;
+        //        NodeID highestNode = 0;
+        //
+        //        for(unsigned i = 0; i < contractor_graph->GetNumberOfNodes(); ++i) {
+        //            unsigned degree = contractor_graph->EndEdges(i) -
+        //            contractor_graph->BeginEdges(i);
+        //            if(degree > maxdegree) {
+        //                maxdegree = degree;
+        //                highestNode = i;
+        //            }
+        //        }
+        //
+        //        SimpleLogger().Write() << "edges at node with id " << highestNode << " has degree
+        //        " << maxdegree;
+        //        for(unsigned i = contractor_graph->BeginEdges(highestNode); i <
+        //        contractor_graph->EndEdges(highestNode); ++i) {
+        //            SimpleLogger().Write() << " ->(" << highestNode << "," <<
+        //            contractor_graph->GetTarget(i)
+        //            << "); via: " << contractor_graph->GetEdgeData(i).via;
+        //        }
+
+        std::cout << "contractor finished initalization" << std::endl;
    }

+    ~Contractor() {}
+
    void Run(double core_factor = 1.0)
    {
        // for the preperation we can use a big grain size, which is much faster (probably cache)
-        const constexpr size_t InitGrainSize = 100000;
-        const constexpr size_t PQGrainSize = 100000;
+        constexpr size_t InitGrainSize = 100000;
+        constexpr size_t PQGrainSize = 100000;
        // auto_partitioner will automatically increase the blocksize if we have
        // a lot of data. It is *important* for the last loop iterations
        // (which have a very small dataset) that it is devisible.
-        const constexpr size_t IndependentGrainSize = 1;
-        const constexpr size_t ContractGrainSize = 1;
-        const constexpr size_t NeighboursGrainSize = 1;
-        const constexpr size_t DeleteGrainSize = 1;
+        constexpr size_t IndependentGrainSize = 1;
+        constexpr size_t ContractGrainSize = 1;
+        constexpr size_t NeighboursGrainSize = 1;
+        constexpr size_t DeleteGrainSize = 1;

        const NodeID number_of_nodes = contractor_graph->GetNumberOfNodes();
-        util::Percent p(number_of_nodes);
+        Percent p(number_of_nodes);

        ThreadDataContainer thread_data_list(number_of_nodes);

        NodeID number_of_contracted_nodes = 0;
-        std::vector<NodeDepth> node_depth;
+        std::vector<NodePriorityData> node_data;
        std::vector<float> node_priorities;
        is_core_node.resize(number_of_nodes, false);

@@ -293,20 +338,20 @@ class GraphContractor
        }
        else
        {
-            node_depth.resize(number_of_nodes, 0);
+            node_data.resize(number_of_nodes);
            node_priorities.resize(number_of_nodes);
            node_levels.resize(number_of_nodes);

            std::cout << "initializing elimination PQ ..." << std::flush;
            tbb::parallel_for(tbb::blocked_range<int>(0, number_of_nodes, PQGrainSize),
-                              [this, &node_priorities, &node_depth,
-                               &thread_data_list](const tbb::blocked_range<int> &range)
+                              [this, &node_priorities, &node_data, &thread_data_list](
+                                  const tbb::blocked_range<int> &range)
                              {
                                  ContractorThreadData *data = thread_data_list.getThreadData();
                                  for (int x = range.begin(), end = range.end(); x != end; ++x)
                                  {
                                      node_priorities[x] =
-                                          this->EvaluateNodePriority(data, node_depth[x], x);
+                                          this->EvaluateNodePriority(data, &node_data[x], x);
                                  }
                              });
            std::cout << "ok" << std::endl;
@@ -323,10 +368,9 @@ class GraphContractor
            if (!flushed_contractor && (number_of_contracted_nodes >
                                        static_cast<NodeID>(number_of_nodes * 0.65 * core_factor)))
            {
-                util::DeallocatingVector<ContractorEdge>
-                    new_edge_set; // this one is not explicitely
-                                  // cleared since it goes out of
-                                  // scope anywa
+                DeallocatingVector<ContractorEdge> new_edge_set; // this one is not explicitely
+                                                                 // cleared since it goes out of
+                                                                 // scope anywa
                std::cout << " [flush " << number_of_contracted_nodes << " nodes] " << std::flush;

                // Delete old heap data to free memory that we need for the coming operations
@@ -334,27 +378,24 @@ class GraphContractor

                // Create new priority array
                std::vector<float> new_node_priority(remaining_nodes.size());
-                std::vector<EdgeWeight> new_node_weights(remaining_nodes.size());
                // this map gives the old IDs from the new ones, necessary to get a consistent graph
                // at the end of contraction
                orig_node_id_from_new_node_id_map.resize(remaining_nodes.size());
                // this map gives the new IDs from the old ones, necessary to remap targets from the
                // remaining graph
-                std::vector<NodeID> new_node_id_from_orig_id_map(number_of_nodes, SPECIAL_NODEID);
+                std::vector<NodeID> new_node_id_from_orig_id_map(number_of_nodes, UINT_MAX);

-                for (const auto new_node_id : util::irange<std::size_t>(0, remaining_nodes.size()))
+                for (const auto new_node_id : osrm::irange<std::size_t>(0, remaining_nodes.size()))
                {
-                    auto &node = remaining_nodes[new_node_id];
+                    auto& node = remaining_nodes[new_node_id];
                    BOOST_ASSERT(node_priorities.size() > node.id);
                    new_node_priority[new_node_id] = node_priorities[node.id];
-                    BOOST_ASSERT(node_weights.size() > node.id);
-                    new_node_weights[new_node_id] = node_weights[node.id];
                }

                // build forward and backward renumbering map and remap ids in remaining_nodes
-                for (const auto new_node_id : util::irange<std::size_t>(0, remaining_nodes.size()))
+                for (const auto new_node_id : osrm::irange<std::size_t>(0, remaining_nodes.size()))
                {
-                    auto &node = remaining_nodes[new_node_id];
+                    auto& node = remaining_nodes[new_node_id];
                    // create renumbering maps in both directions
                    orig_node_id_from_new_node_id_map[new_node_id] = node.id;
                    new_node_id_from_orig_id_map[node.id] = new_node_id;
@@ -362,7 +403,7 @@ class GraphContractor
                }
                // walk over all nodes
                for (const auto source :
-                     util::irange<NodeID>(0, contractor_graph->GetNumberOfNodes()))
+                     osrm::irange<NodeID>(0, contractor_graph->GetNumberOfNodes()))
                {
                    for (auto current_edge : contractor_graph->GetAdjacentEdgeRange(source))
                    {
@@ -376,14 +417,15 @@ class GraphContractor
                        else
                        {
                            // node is not yet contracted.
-                            // add (renumbered) outgoing edges to new util::DynamicGraph.
+                            // add (renumbered) outgoing edges to new DynamicGraph.
                            ContractorEdge new_edge = {new_node_id_from_orig_id_map[source],
-                                                       new_node_id_from_orig_id_map[target], data};
+                                                       new_node_id_from_orig_id_map[target],
+                                                       data};

                            new_edge.data.is_original_via_node_ID = true;
-                            BOOST_ASSERT_MSG(SPECIAL_NODEID != new_node_id_from_orig_id_map[source],
+                            BOOST_ASSERT_MSG(UINT_MAX != new_node_id_from_orig_id_map[source],
                                             "new source id not resolveable");
-                            BOOST_ASSERT_MSG(SPECIAL_NODEID != new_node_id_from_orig_id_map[target],
+                            BOOST_ASSERT_MSG(UINT_MAX != new_node_id_from_orig_id_map[target],
                                             "new target id not resolveable");
                            new_edge_set.push_back(new_edge);
                        }
@@ -397,12 +439,8 @@ class GraphContractor
                // Replace old priorities array by new one
                node_priorities.swap(new_node_priority);
                // Delete old node_priorities vector
-                // Due to the scope, these should get cleared automatically? @daniel-j-h do you
-                // agree?
                new_node_priority.clear();
                new_node_priority.shrink_to_fit();
-
-                node_weights.swap(new_node_weights);
                // old Graph is removed
                contractor_graph.reset();

@@ -419,44 +457,39 @@ class GraphContractor
                thread_data_list.number_of_nodes = contractor_graph->GetNumberOfNodes();
            }

-            tbb::parallel_for(
-                tbb::blocked_range<std::size_t>(0, remaining_nodes.size(), IndependentGrainSize),
-                [this, &node_priorities, &remaining_nodes,
-                 &thread_data_list](const tbb::blocked_range<std::size_t> &range)
-                {
-                    ContractorThreadData *data = thread_data_list.getThreadData();
-                    // determine independent node set
-                    for (auto i = range.begin(), end = range.end(); i != end; ++i)
-                    {
-                        const NodeID node = remaining_nodes[i].id;
-                        remaining_nodes[i].is_independent =
-                            this->IsNodeIndependent(node_priorities, data, node);
-                    }
-                });
+            tbb::parallel_for(tbb::blocked_range<std::size_t>(0, remaining_nodes.size(), IndependentGrainSize),
+                              [this, &node_priorities, &remaining_nodes, &thread_data_list](
+                                  const tbb::blocked_range<std::size_t> &range)
+                              {
+                                  ContractorThreadData *data = thread_data_list.getThreadData();
+                                  // determine independent node set
+                                  for (auto i = range.begin(), end = range.end(); i != end; ++i)
+                                  {
+                                      const NodeID node = remaining_nodes[i].id;
+                                      remaining_nodes[i].is_independent =
+                                          this->IsNodeIndependent(node_priorities, data, node);
+                                  }
+                              });

            // sort all remaining nodes to the beginning of the sequence
-            const auto begin_independent_nodes = stable_partition(
-                remaining_nodes.begin(), remaining_nodes.end(), [](RemainingNodeData node_data)
-                {
-                    return !node_data.is_independent;
-                });
-            auto begin_independent_nodes_idx =
-                std::distance(remaining_nodes.begin(), begin_independent_nodes);
+            const auto begin_independent_nodes = stable_partition(remaining_nodes.begin(), remaining_nodes.end(),
+                                                [](RemainingNodeData node_data)
+                                                {
+                                                    return !node_data.is_independent;
+                                                });
+            auto begin_independent_nodes_idx = std::distance(remaining_nodes.begin(), begin_independent_nodes);
            auto end_independent_nodes_idx = remaining_nodes.size();

            if (!use_cached_node_priorities)
            {
                // write out contraction level
                tbb::parallel_for(
-                    tbb::blocked_range<std::size_t>(begin_independent_nodes_idx,
-                                                    end_independent_nodes_idx, ContractGrainSize),
-                    [this, remaining_nodes, flushed_contractor,
-                     current_level](const tbb::blocked_range<std::size_t> &range)
+                    tbb::blocked_range<std::size_t>(begin_independent_nodes_idx, end_independent_nodes_idx, ContractGrainSize),
+                    [this, remaining_nodes, flushed_contractor, current_level](const tbb::blocked_range<std::size_t> &range)
                    {
                        if (flushed_contractor)
                        {
-                            for (int position = range.begin(), end = range.end(); position != end;
-                                 ++position)
+                            for (int position = range.begin(), end = range.end(); position != end; ++position)
                            {
                                const NodeID x = remaining_nodes[position].id;
                                node_levels[orig_node_id_from_new_node_id_map[x]] = current_level;
@@ -464,8 +497,7 @@ class GraphContractor
                        }
                        else
                        {
-                            for (int position = range.begin(), end = range.end(); position != end;
-                                 ++position)
+                            for (int position = range.begin(), end = range.end(); position != end; ++position)
                            {
                                const NodeID x = remaining_nodes[position].id;
                                node_levels[x] = current_level;
@@ -475,29 +507,24 @@ class GraphContractor
            }

            // contract independent nodes
-            tbb::parallel_for(tbb::blocked_range<std::size_t>(begin_independent_nodes_idx,
-                                                              end_independent_nodes_idx,
-                                                              ContractGrainSize),
-                              [this, &remaining_nodes,
-                               &thread_data_list](const tbb::blocked_range<std::size_t> &range)
-                              {
-                                  ContractorThreadData *data = thread_data_list.getThreadData();
-                                  for (int position = range.begin(), end = range.end();
-                                       position != end; ++position)
-                                  {
-                                      const NodeID x = remaining_nodes[position].id;
-                                      this->ContractNode<false>(data, x);
-                                  }
-                              });
+            tbb::parallel_for(
+                tbb::blocked_range<std::size_t>(begin_independent_nodes_idx, end_independent_nodes_idx, ContractGrainSize),
+                [this, &remaining_nodes, &thread_data_list](const tbb::blocked_range<std::size_t> &range)
+                {
+                    ContractorThreadData *data = thread_data_list.getThreadData();
+                    for (int position = range.begin(), end = range.end(); position != end; ++position)
+                    {
+                        const NodeID x = remaining_nodes[position].id;
+                        this->ContractNode<false>(data, x);
+                    }
+                });

            tbb::parallel_for(
-                tbb::blocked_range<int>(begin_independent_nodes_idx, end_independent_nodes_idx,
-                                        DeleteGrainSize),
+                tbb::blocked_range<int>(begin_independent_nodes_idx, end_independent_nodes_idx, DeleteGrainSize),
                [this, &remaining_nodes, &thread_data_list](const tbb::blocked_range<int> &range)
                {
                    ContractorThreadData *data = thread_data_list.getThreadData();
-                    for (int position = range.begin(), end = range.end(); position != end;
-                         ++position)
+                    for (int position = range.begin(), end = range.end(); position != end; ++position)
                    {
                        const NodeID x = remaining_nodes[position].id;
                        this->DeleteIncomingEdges(data, x);
@@ -542,17 +569,15 @@ class GraphContractor
            if (!use_cached_node_priorities)
            {
                tbb::parallel_for(
-                    tbb::blocked_range<int>(begin_independent_nodes_idx, end_independent_nodes_idx,
-                                            NeighboursGrainSize),
-                    [this, &node_priorities, &remaining_nodes, &node_depth,
-                     &thread_data_list](const tbb::blocked_range<int> &range)
+                    tbb::blocked_range<int>(begin_independent_nodes_idx, end_independent_nodes_idx, NeighboursGrainSize),
+                    [this, &node_priorities, &remaining_nodes, &node_data, &thread_data_list](
+                        const tbb::blocked_range<int> &range)
                    {
                        ContractorThreadData *data = thread_data_list.getThreadData();
-                        for (int position = range.begin(), end = range.end(); position != end;
-                             ++position)
+                        for (int position = range.begin(), end = range.end(); position != end; ++position)
                        {
                            NodeID x = remaining_nodes[position].id;
-                            this->UpdateNodeNeighbours(node_priorities, node_depth, data, x);
+                            this->UpdateNodeNeighbours(node_priorities, node_data, data, x);
                        }
                    });
            }
@@ -560,6 +585,30 @@ class GraphContractor
            // remove contracted nodes from the pool
            number_of_contracted_nodes += end_independent_nodes_idx - begin_independent_nodes_idx;
            remaining_nodes.resize(begin_independent_nodes_idx);
+            //            unsigned maxdegree = 0;
+            //            unsigned avgdegree = 0;
+            //            unsigned mindegree = UINT_MAX;
+            //            unsigned quaddegree = 0;
+            //
+            //            for(unsigned i = 0; i < remaining_nodes.size(); ++i) {
+            //                unsigned degree = contractor_graph->EndEdges(remaining_nodes[i].id)
+            //                -
+            //                contractor_graph->BeginEdges(remaining_nodes[i].first);
+            //                if(degree > maxdegree)
+            //                    maxdegree = degree;
+            //                if(degree < mindegree)
+            //                    mindegree = degree;
+            //
+            //                avgdegree += degree;
+            //                quaddegree += (degree*degree);
+            //            }
+            //
+            //            avgdegree /= std::max((unsigned)1,(unsigned)remaining_nodes.size() );
+            //            quaddegree /= std::max((unsigned)1,(unsigned)remaining_nodes.size() );
+            //
+            //            SimpleLogger().Write() << "rest: " << remaining_nodes.size() << ", max: "
+            //            << maxdegree << ", min: " << mindegree << ", avg: " << avgdegree << ",
+            //            quad: " << quaddegree;

            p.printStatus(number_of_contracted_nodes);
            ++current_level;
@@ -567,31 +616,32 @@ class GraphContractor

        if (remaining_nodes.size() > 2)
        {
-            if (orig_node_id_from_new_node_id_map.size() > 0)
-            {
-                tbb::parallel_for(tbb::blocked_range<int>(0, remaining_nodes.size(), InitGrainSize),
-                                  [this, &remaining_nodes](const tbb::blocked_range<int> &range)
-                                  {
-                                      for (int x = range.begin(), end = range.end(); x != end; ++x)
-                                      {
-                                          const auto orig_id = remaining_nodes[x].id;
-                                          is_core_node[orig_node_id_from_new_node_id_map[orig_id]] =
-                                              true;
-                                      }
-                                  });
-            }
-            else
-            {
-                tbb::parallel_for(tbb::blocked_range<int>(0, remaining_nodes.size(), InitGrainSize),
-                                  [this, &remaining_nodes](const tbb::blocked_range<int> &range)
-                                  {
-                                      for (int x = range.begin(), end = range.end(); x != end; ++x)
-                                      {
-                                          const auto orig_id = remaining_nodes[x].id;
-                                          is_core_node[orig_id] = true;
-                                      }
-                                  });
-            }
+              if (orig_node_id_from_new_node_id_map.size() > 0)
+              {
+                  tbb::parallel_for(
+                      tbb::blocked_range<int>(0, remaining_nodes.size(), InitGrainSize),
+                      [this, &remaining_nodes](const tbb::blocked_range<int> &range)
+                      {
+                          for (int x = range.begin(), end = range.end(); x != end; ++x)
+                          {
+                              const auto orig_id = remaining_nodes[x].id;
+                              is_core_node[orig_node_id_from_new_node_id_map[orig_id]] = true;
+                          }
+                      });
+              }
+              else
+              {
+                  tbb::parallel_for(
+                      tbb::blocked_range<int>(0, remaining_nodes.size(), InitGrainSize),
+                      [this, &remaining_nodes](const tbb::blocked_range<int> &range)
+                      {
+                          for (int x = range.begin(), end = range.end(); x != end; ++x)
+                          {
+                              const auto orig_id = remaining_nodes[x].id;
+                              is_core_node[orig_id] = true;
+                          }
+                      });
+              }
        }
        else
        {
@@ -600,9 +650,8 @@ class GraphContractor
            is_core_node.clear();
        }

-        util::SimpleLogger().Write() << "[core] " << remaining_nodes.size() << " nodes "
-                                     << contractor_graph->GetNumberOfEdges() << " edges."
-                                     << std::endl;
+        SimpleLogger().Write() << "[core] " << remaining_nodes.size() << " nodes "
+                               << contractor_graph->GetNumberOfEdges() << " edges." << std::endl;

        thread_data_list.data.clear();
    }
@@ -617,15 +666,15 @@ class GraphContractor
        out_node_levels.swap(node_levels);
    }

-    template <class Edge> inline void GetEdges(util::DeallocatingVector<Edge> &edges)
+    template <class Edge> inline void GetEdges(DeallocatingVector<Edge> &edges)
    {
-        util::Percent p(contractor_graph->GetNumberOfNodes());
-        util::SimpleLogger().Write() << "Getting edges of minimized graph";
+        Percent p(contractor_graph->GetNumberOfNodes());
+        SimpleLogger().Write() << "Getting edges of minimized graph";
        const NodeID number_of_nodes = contractor_graph->GetNumberOfNodes();
        if (contractor_graph->GetNumberOfNodes())
        {
            Edge new_edge;
-            for (const auto node : util::irange(0u, number_of_nodes))
+            for (const auto node : osrm::irange(0u, number_of_nodes))
            {
                p.printStatus(node);
                for (auto edge : contractor_graph->GetAdjacentEdgeRange(node))
@@ -642,8 +691,8 @@ class GraphContractor
                        new_edge.source = node;
                        new_edge.target = target;
                    }
-                    BOOST_ASSERT_MSG(SPECIAL_NODEID != new_edge.source, "Source id invalid");
-                    BOOST_ASSERT_MSG(SPECIAL_NODEID != new_edge.target, "Target id invalid");
+                    BOOST_ASSERT_MSG(UINT_MAX != new_edge.source, "Source id invalid");
+                    BOOST_ASSERT_MSG(UINT_MAX != new_edge.target, "Target id invalid");
                    new_edge.data.distance = data.distance;
                    new_edge.data.shortcut = data.shortcut;
                    if (!data.is_original_via_node_ID && !orig_node_id_from_new_node_id_map.empty())
@@ -674,55 +723,23 @@ class GraphContractor
    }

  private:
-    inline void RelaxNode(const NodeID node,
-                          const NodeID forbidden_node,
-                          const int distance,
-                          ContractorHeap &heap)
-    {
-        const short current_hop = heap.GetData(node).hop + 1;
-        for (auto edge : contractor_graph->GetAdjacentEdgeRange(node))
-        {
-            const ContractorEdgeData &data = contractor_graph->GetEdgeData(edge);
-            if (!data.forward)
-            {
-                continue;
-            }
-            const NodeID to = contractor_graph->GetTarget(edge);
-            if (forbidden_node == to)
-            {
-                continue;
-            }
-            const int to_distance = distance + data.distance;
-
-            // New Node discovered -> Add to Heap + Node Info Storage
-            if (!heap.WasInserted(to))
-            {
-                heap.Insert(to, to_distance, ContractorHeapData{current_hop, false});
-            }
-            // Found a shorter Path -> Update distance
-            else if (to_distance < heap.GetKey(to))
-            {
-                heap.DecreaseKey(to, to_distance);
-                heap.GetData(to).hop = current_hop;
-            }
-        }
-    }
-
    inline void Dijkstra(const int max_distance,
                         const unsigned number_of_targets,
                         const int maxNodes,
-                         ContractorThreadData &data,
+                         ContractorThreadData *const data,
                         const NodeID middleNode)
    {

-        ContractorHeap &heap = data.heap;
+        ContractorHeap &heap = data->heap;

        int nodes = 0;
        unsigned number_of_targets_found = 0;
        while (!heap.Empty())
        {
            const NodeID node = heap.DeleteMin();
-            const auto distance = heap.GetKey(node);
+            const int distance = heap.GetKey(node);
+            const short current_hop = heap.GetData(node).hop + 1;
+
            if (++nodes > maxNodes)
            {
                return;
@@ -742,12 +759,38 @@ class GraphContractor
                }
            }

-            RelaxNode(node, middleNode, distance, heap);
+            // iterate over all edges of node
+            for (auto edge : contractor_graph->GetAdjacentEdgeRange(node))
+            {
+                const ContractorEdgeData &data = contractor_graph->GetEdgeData(edge);
+                if (!data.forward)
+                {
+                    continue;
+                }
+                const NodeID to = contractor_graph->GetTarget(edge);
+                if (middleNode == to)
+                {
+                    continue;
+                }
+                const int to_distance = distance + data.distance;
+
+                // New Node discovered -> Add to Heap + Node Info Storage
+                if (!heap.WasInserted(to))
+                {
+                    heap.Insert(to, to_distance, ContractorHeapData(current_hop, false));
+                }
+                // Found a shorter Path -> Update distance
+                else if (to_distance < heap.GetKey(to))
+                {
+                    heap.DecreaseKey(to, to_distance);
+                    heap.GetData(to).hop = current_hop;
+                }
+            }
        }
    }

    inline float EvaluateNodePriority(ContractorThreadData *const data,
-                                      const NodeDepth node_depth,
+                                      NodePriorityData *const node_data,
                                      const NodeID node)
    {
        ContractionStats stats;
@@ -759,14 +802,14 @@ class GraphContractor
        float result;
        if (0 == (stats.edges_deleted_count * stats.original_edges_deleted_count))
        {
-            result = 1.f * node_depth;
+            result = 1.f * node_data->depth;
        }
        else
        {
            result = 2.f * (((float)stats.edges_added_count) / stats.edges_deleted_count) +
                     4.f * (((float)stats.original_edges_added_count) /
                            stats.original_edges_deleted_count) +
-                     1.f * node_depth;
+                     1.f * node_data->depth;
        }
        BOOST_ASSERT(result >= 0);
        return result;
@@ -777,21 +820,13 @@ class GraphContractor
    ContractNode(ContractorThreadData *data, const NodeID node, ContractionStats *stats = nullptr)
    {
        ContractorHeap &heap = data->heap;
-        std::size_t inserted_edges_size = data->inserted_edges.size();
+        int inserted_edges_size = data->inserted_edges.size();
        std::vector<ContractorEdge> &inserted_edges = data->inserted_edges;
-        const constexpr bool SHORTCUT_ARC = true;
-        const constexpr bool FORWARD_DIRECTION_ENABLED = true;
-        const constexpr bool FORWARD_DIRECTION_DISABLED = false;
-        const constexpr bool REVERSE_DIRECTION_ENABLED = true;
-        const constexpr bool REVERSE_DIRECTION_DISABLED = false;

        for (auto in_edge : contractor_graph->GetAdjacentEdgeRange(node))
        {
            const ContractorEdgeData &in_data = contractor_graph->GetEdgeData(in_edge);
            const NodeID source = contractor_graph->GetTarget(in_edge);
-            if (source == node)
-                continue;
-
            if (RUNSIMULATION)
            {
                BOOST_ASSERT(stats != nullptr);
@@ -804,7 +839,7 @@ class GraphContractor
            }

            heap.Clear();
-            heap.Insert(source, 0, ContractorHeapData{});
+            heap.Insert(source, 0, ContractorHeapData());
            int max_distance = 0;
            unsigned number_of_targets = 0;

@@ -816,64 +851,22 @@ class GraphContractor
                    continue;
                }
                const NodeID target = contractor_graph->GetTarget(out_edge);
-                if (node == target)
-                    continue;
-
-                const EdgeWeight path_distance = in_data.distance + out_data.distance;
-                if (target == source)
-                {
-                    if (path_distance < node_weights[node])
-                    {
-                        if (RUNSIMULATION)
-                        {
-                            // make sure to prune better, but keep inserting this loop if it should
-                            // still be the best
-                            // CAREFUL: This only works due to the independent node-setting. This
-                            // guarantees that source is not connected to another node that is
-                            // contracted
-                            node_weights[source] = path_distance + 1;
-                            BOOST_ASSERT(stats != nullptr);
-                            stats->edges_added_count += 2;
-                            stats->original_edges_added_count +=
-                                2 * (out_data.originalEdges + in_data.originalEdges);
-                        }
-                        else
-                        {
-                            // CAREFUL: This only works due to the independent node-setting. This
-                            // guarantees that source is not connected to another node that is
-                            // contracted
-                            node_weights[source] = path_distance; // make sure to prune better
-                            inserted_edges.emplace_back(
-                                source, target, path_distance,
-                                out_data.originalEdges + in_data.originalEdges, node, SHORTCUT_ARC,
-                                FORWARD_DIRECTION_ENABLED, REVERSE_DIRECTION_DISABLED);
-
-                            inserted_edges.emplace_back(
-                                target, source, path_distance,
-                                out_data.originalEdges + in_data.originalEdges, node, SHORTCUT_ARC,
-                                FORWARD_DIRECTION_DISABLED, REVERSE_DIRECTION_ENABLED);
-                        }
-                    }
-                    continue;
-                }
+                const int path_distance = in_data.distance + out_data.distance;
                max_distance = std::max(max_distance, path_distance);
                if (!heap.WasInserted(target))
                {
-                    heap.Insert(target, INVALID_EDGE_WEIGHT, ContractorHeapData{0, true});
+                    heap.Insert(target, INT_MAX, ContractorHeapData(0, true));
                    ++number_of_targets;
                }
            }

            if (RUNSIMULATION)
            {
-                const int constexpr SIMULATION_SEARCH_SPACE_SIZE = 1000;
-                Dijkstra(max_distance, number_of_targets, SIMULATION_SEARCH_SPACE_SIZE, *data,
-                         node);
+                Dijkstra(max_distance, number_of_targets, 1000, data, node);
            }
            else
            {
-                const int constexpr FULL_SEARCH_SPACE_SIZE = 2000;
-                Dijkstra(max_distance, number_of_targets, FULL_SEARCH_SPACE_SIZE, *data, node);
+                Dijkstra(max_distance, number_of_targets, 2000, data, node);
            }
            for (auto out_edge : contractor_graph->GetAdjacentEdgeRange(node))
            {
@@ -883,8 +876,6 @@ class GraphContractor
                    continue;
                }
                const NodeID target = contractor_graph->GetTarget(out_edge);
-                if (target == node)
-                    continue;
                const int path_distance = in_data.distance + out_data.distance;
                const int distance = heap.GetKey(target);
                if (path_distance < distance)
@@ -900,26 +891,22 @@ class GraphContractor
                    {
                        inserted_edges.emplace_back(source, target, path_distance,
                                                    out_data.originalEdges + in_data.originalEdges,
-                                                    node, SHORTCUT_ARC, FORWARD_DIRECTION_ENABLED,
-                                                    REVERSE_DIRECTION_DISABLED);
+                                                    node, true, true, false);

                        inserted_edges.emplace_back(target, source, path_distance,
                                                    out_data.originalEdges + in_data.originalEdges,
-                                                    node, SHORTCUT_ARC, FORWARD_DIRECTION_DISABLED,
-                                                    REVERSE_DIRECTION_ENABLED);
+                                                    node, true, false, true);
                    }
                }
            }
        }
-        // Check For One-Way Streets to decide on the creation of self-loops
-
        if (!RUNSIMULATION)
        {
-            std::size_t iend = inserted_edges.size();
-            for (std::size_t i = inserted_edges_size; i < iend; ++i)
+            int iend = inserted_edges.size();
+            for (int i = inserted_edges_size; i < iend; ++i)
            {
                bool found = false;
-                for (std::size_t other = i + 1; other < iend; ++other)
+                for (int other = i + 1; other < iend; ++other)
                {
                    if (inserted_edges[other].source != inserted_edges[i].source)
                    {
@@ -970,14 +957,14 @@ class GraphContractor
        std::sort(neighbours.begin(), neighbours.end());
        neighbours.resize(std::unique(neighbours.begin(), neighbours.end()) - neighbours.begin());

-        for (const auto i : util::irange<std::size_t>(0, neighbours.size()))
+        for (const auto i : osrm::irange<std::size_t>(0, neighbours.size()))
        {
            contractor_graph->DeleteEdgesTo(neighbours[i], node);
        }
    }

    inline bool UpdateNodeNeighbours(std::vector<float> &priorities,
-                                     std::vector<NodeDepth> &node_depth,
+                                     std::vector<NodePriorityData> &node_data,
                                     ContractorThreadData *const data,
                                     const NodeID node)
    {
@@ -993,7 +980,7 @@ class GraphContractor
                continue;
            }
            neighbours.push_back(u);
-            node_depth[u] = std::max(node_depth[node] + 1, node_depth[u]);
+            node_data[u].depth = (std::max)(node_data[node].depth + 1, node_data[u].depth);
        }
        // eliminate duplicate entries ( forward + backward edges )
        std::sort(neighbours.begin(), neighbours.end());
@@ -1002,7 +989,7 @@ class GraphContractor
        // re-evaluate priorities of neighboring nodes
        for (const NodeID u : neighbours)
        {
-            priorities[u] = EvaluateNodePriority(data, node_depth[u], u);
+            priorities[u] = EvaluateNodePriority(data, &(node_data)[u], u);
        }
        return true;
    }
@@ -1089,17 +1076,8 @@ class GraphContractor
    stxxl::vector<QueryEdge> external_edge_list;
    std::vector<NodeID> orig_node_id_from_new_node_id_map;
    std::vector<float> node_levels;
-
-    // A list of weights for every node in the graph.
-    // The weight represents the cost for a u-turn on the segment in the base-graph in addition to
-    // its traversal.
-    // During contraction, self-loops are checked against this node weight to ensure that necessary
-    // self-loops are added.
-    std::vector<EdgeWeight> node_weights;
    std::vector<bool> is_core_node;
-    util::XORFastHash<> fast_hash;
+    XORFastHash fast_hash;
 };
-}
-}

 #endif // CONTRACTOR_HPP
@@ -0,0 +1,142 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#include "contractor_options.hpp"
+
+#include "util/version.hpp"
+#include "../util/simple_logger.hpp"
+
+#include <boost/filesystem.hpp>
+#include <boost/program_options.hpp>
+
+#include <tbb/task_scheduler_init.h>
+
+return_code
+ContractorOptions::ParseArguments(int argc, char *argv[], ContractorConfig &contractor_config)
+{
+    // declare a group of options that will be allowed only on command line
+    boost::program_options::options_description generic_options("Options");
+    generic_options.add_options()("version,v", "Show version")("help,h", "Show this help message")(
+        "config,c", boost::program_options::value<boost::filesystem::path>(&contractor_config.config_file_path)
+                        ->default_value("contractor.ini"),
+        "Path to a configuration file.");
+
+    // declare a group of options that will be allowed both on command line and in config file
+    boost::program_options::options_description config_options("Configuration");
+    config_options.add_options()(
+        "profile,p",
+        boost::program_options::value<boost::filesystem::path>(&contractor_config.profile_path)
+            ->default_value("profile.lua"),
+        "Path to LUA routing profile")(
+        "threads,t",
+        boost::program_options::value<unsigned int>(&contractor_config.requested_num_threads)
+            ->default_value(tbb::task_scheduler_init::default_num_threads()),
+        "Number of threads to use")(
+		"core,k", boost::program_options::value<double>(&contractor_config.core_factor)
+						 ->default_value(1.0),"Percentage of the graph (in vertices) to contract [0..1]")(
+		"segment-speed-file", boost::program_options::value<std::string>(&contractor_config.segment_speed_lookup_path),
+						 "Lookup file containing nodeA,nodeB,speed data to adjust edge weights")(
+        "level-cache,o",
+        boost::program_options::value<bool>(&contractor_config.use_cached_priority)->default_value(false),
+        "Use .level file to retain the contaction level for each node from the last run.");
+
+#ifdef DEBUG_GEOMETRY
+    config_options.add_options()(
+		"debug-geometry", boost::program_options::value<std::string>(&contractor_config.debug_geometry_path)
+						 ,"Write out edge-weight debugging geometry data in GeoJSON format to this file");
+#endif
+
+    // hidden options, will be allowed both on command line and in config file, but will not be
+    // shown to the user
+    boost::program_options::options_description hidden_options("Hidden options");
+    hidden_options.add_options()(
+        "input,i", boost::program_options::value<boost::filesystem::path>(&contractor_config.osrm_input_path),
+        "Input file in .osm, .osm.bz2 or .osm.pbf format");
+
+    // positional option
+    boost::program_options::positional_options_description positional_options;
+    positional_options.add("input", 1);
+
+    // combine above options for parsing
+    boost::program_options::options_description cmdline_options;
+    cmdline_options.add(generic_options).add(config_options).add(hidden_options);
+
+    boost::program_options::options_description config_file_options;
+    config_file_options.add(config_options).add(hidden_options);
+
+    boost::program_options::options_description visible_options(
+        "Usage: " + boost::filesystem::basename(argv[0]) + " <input.osrm> [options]");
+    visible_options.add(generic_options).add(config_options);
+
+    // parse command line options
+    boost::program_options::variables_map option_variables;
+    boost::program_options::store(boost::program_options::command_line_parser(argc, argv)
+                                      .options(cmdline_options)
+                                      .positional(positional_options)
+                                      .run(),
+                                  option_variables);
+
+    const auto &temp_config_path = option_variables["config"].as<boost::filesystem::path>();
+    if (boost::filesystem::is_regular_file(temp_config_path))
+    {
+        boost::program_options::store(boost::program_options::parse_config_file<char>(
+                                          temp_config_path.string().c_str(), cmdline_options, true),
+                                      option_variables);
+    }
+
+    if (option_variables.count("version"))
+    {
+        SimpleLogger().Write() << OSRM_VERSION;
+        return return_code::exit;
+    }
+
+    if (option_variables.count("help"))
+    {
+        SimpleLogger().Write() << "\n" << visible_options;
+        return return_code::exit;
+    }
+
+    boost::program_options::notify(option_variables);
+
+    if (!option_variables.count("input"))
+    {
+        SimpleLogger().Write() << "\n" << visible_options;
+        return return_code::fail;
+    }
+
+    return return_code::ok;
+}
+
+void ContractorOptions::GenerateOutputFilesNames(ContractorConfig &contractor_config)
+{
+    contractor_config.level_output_path = contractor_config.osrm_input_path.string() + ".level";
+    contractor_config.core_output_path = contractor_config.osrm_input_path.string() + ".core";
+    contractor_config.graph_output_path = contractor_config.osrm_input_path.string() + ".hsgr";
+    contractor_config.edge_based_graph_path = contractor_config.osrm_input_path.string() + ".ebg";
+    contractor_config.edge_segment_lookup_path = contractor_config.osrm_input_path.string() + ".edge_segment_lookup";
+    contractor_config.edge_penalty_path = contractor_config.osrm_input_path.string() + ".edge_penalties";
+}
@@ -1,6 +1,6 @@
 /*

-Copyright (c) 2016, Project OSRM contributors
+Copyright (c) 2015, Project OSRM contributors
 All rights reserved.

 Redistribution and use in source and binary forms, with or without modification,
@@ -32,33 +32,20 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 #include <string>

-namespace osrm
-{
-namespace contractor
+enum class return_code : unsigned
 {
+    ok,
+    fail,
+    exit
+};

 struct ContractorConfig
 {
-    ContractorConfig() : requested_num_threads(0) {}
-
-    // Infer the output names from the path of the .osrm file
-    void UseDefaultOutputNames()
-    {
-        level_output_path = osrm_input_path.string() + ".level";
-        core_output_path = osrm_input_path.string() + ".core";
-        graph_output_path = osrm_input_path.string() + ".hsgr";
-        edge_based_graph_path = osrm_input_path.string() + ".ebg";
-        edge_segment_lookup_path = osrm_input_path.string() + ".edge_segment_lookup";
-        edge_penalty_path = osrm_input_path.string() + ".edge_penalties";
-        node_based_graph_path = osrm_input_path.string() + ".nodes";
-        geometry_path = osrm_input_path.string() + ".geometry";
-        rtree_leaf_path = osrm_input_path.string() + ".fileIndex";
-        datasource_names_path = osrm_input_path.string() + ".datasource_names";
-        datasource_indexes_path = osrm_input_path.string() + ".datasource_indexes";
-    }
+    ContractorConfig() noexcept : requested_num_threads(0) {}

    boost::filesystem::path config_file_path;
    boost::filesystem::path osrm_input_path;
+    boost::filesystem::path profile_path;

    std::string level_output_path;
    std::string core_output_path;
@@ -67,24 +54,28 @@ struct ContractorConfig

    std::string edge_segment_lookup_path;
    std::string edge_penalty_path;
-    std::string node_based_graph_path;
-    std::string geometry_path;
-    std::string rtree_leaf_path;
    bool use_cached_priority;

    unsigned requested_num_threads;

-    // A percentage of vertices that will be contracted for the hierarchy.
-    // Offers a trade-off between preprocessing and query time.
-    // The remaining vertices form the core of the hierarchy
+    //A percentage of vertices that will be contracted for the hierarchy.
+    //Offers a trade-off between preprocessing and query time.
+    //The remaining vertices form the core of the hierarchy 
    //(e.g. 0.8 contracts 80 percent of the hierarchy, leaving a core of 20%)
    double core_factor;

-    std::vector<std::string> segment_speed_lookup_paths;
-    std::string datasource_indexes_path;
-    std::string datasource_names_path;
+    std::string segment_speed_lookup_path;
+
+#ifdef DEBUG_GEOMETRY
+    std::string debug_geometry_path;
+#endif
+};
+
+struct ContractorOptions
+{
+    static return_code ParseArguments(int argc, char *argv[], ContractorConfig &extractor_config);
+
+    static void GenerateOutputFilesNames(ContractorConfig &extractor_config);
 };
-}
-}

 #endif // EXTRACTOR_OPTIONS_HPP
@@ -0,0 +1,441 @@
+/*
+
+Copyright (c) 2015, Project OSRM, Dennis Luxen, others
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#include "processing_chain.hpp"
+#include "contractor.hpp"
+
+#include "contractor.hpp"
+
+#include "../data_structures/deallocating_vector.hpp"
+
+#include "../algorithms/crc32_processor.hpp"
+#include "../util/graph_loader.hpp"
+#include "../util/integer_range.hpp"
+#include "../util/lua_util.hpp"
+#include "../util/osrm_exception.hpp"
+#include "../util/simple_logger.hpp"
+#include "../util/string_util.hpp"
+#include "../util/timing_util.hpp"
+#include "../typedefs.h"
+
+#include <fast-cpp-csv-parser/csv.h>
+
+#include <boost/filesystem/fstream.hpp>
+#include <boost/program_options.hpp>
+
+#include <tbb/parallel_sort.h>
+
+#include <chrono>
+#include <memory>
+#include <string>
+#include <thread>
+#include <vector>
+
+#include "../util/debug_geometry.hpp"
+
+Prepare::~Prepare() {}
+
+int Prepare::Run()
+{
+#ifdef WIN32
+#pragma message("Memory consumption on Windows can be higher due to different bit packing")
+#else
+    static_assert(sizeof(NodeBasedEdge) == 20,
+                  "changing NodeBasedEdge type has influence on memory consumption!");
+    static_assert(sizeof(EdgeBasedEdge) == 16,
+                  "changing EdgeBasedEdge type has influence on memory consumption!");
+#endif
+
+    if (config.core_factor > 1.0 || config.core_factor < 0) 
+    {
+       throw osrm::exception("Core factor must be between 0.0 to 1.0 (inclusive)");
+    }
+
+    TIMER_START(preparing);
+
+    // Create a new lua state
+
+    SimpleLogger().Write() << "Loading edge-expanded graph representation";
+
+    DeallocatingVector<EdgeBasedEdge> edge_based_edge_list;
+
+    size_t max_edge_id = LoadEdgeExpandedGraph(
+        config.edge_based_graph_path, edge_based_edge_list, config.edge_segment_lookup_path,
+        config.edge_penalty_path, config.segment_speed_lookup_path);
+
+    // Contracting the edge-expanded graph
+
+    TIMER_START(contraction);
+    std::vector<bool> is_core_node;
+    std::vector<float> node_levels;
+    if (config.use_cached_priority)
+    {
+        ReadNodeLevels(node_levels);
+    }
+    DeallocatingVector<QueryEdge> contracted_edge_list;
+    ContractGraph(max_edge_id, edge_based_edge_list, contracted_edge_list, is_core_node,
+                  node_levels);
+    TIMER_STOP(contraction);
+
+    SimpleLogger().Write() << "Contraction took " << TIMER_SEC(contraction) << " sec";
+
+    std::size_t number_of_used_edges = WriteContractedGraph(max_edge_id, contracted_edge_list);
+    WriteCoreNodeMarker(std::move(is_core_node));
+    if (!config.use_cached_priority)
+    {
+        WriteNodeLevels(std::move(node_levels));
+    }
+
+    TIMER_STOP(preparing);
+
+    SimpleLogger().Write() << "Preprocessing : " << TIMER_SEC(preparing) << " seconds";
+    SimpleLogger().Write() << "Contraction: " << ((max_edge_id + 1) / TIMER_SEC(contraction))
+                           << " nodes/sec and " << number_of_used_edges / TIMER_SEC(contraction)
+                           << " edges/sec";
+
+    SimpleLogger().Write() << "finished preprocessing";
+
+    return 0;
+}
+
+namespace std
+{
+
+template <> struct hash<std::pair<OSMNodeID, OSMNodeID>>
+{
+    std::size_t operator()(const std::pair<OSMNodeID, OSMNodeID> &k) const
+    {
+        return OSMNodeID_to_uint64_t(k.first) ^ (OSMNodeID_to_uint64_t(k.second) << 12);
+    }
+};
+}
+
+std::size_t Prepare::LoadEdgeExpandedGraph(std::string const &edge_based_graph_filename,
+                                           DeallocatingVector<EdgeBasedEdge> &edge_based_edge_list,
+                                           const std::string &edge_segment_lookup_filename,
+                                           const std::string &edge_penalty_filename,
+                                           const std::string &segment_speed_filename)
+{
+    SimpleLogger().Write() << "Opening " << edge_based_graph_filename;
+    boost::filesystem::ifstream input_stream(edge_based_graph_filename, std::ios::binary);
+
+    const bool update_edge_weights = segment_speed_filename != "";
+
+    boost::filesystem::ifstream edge_segment_input_stream;
+    boost::filesystem::ifstream edge_fixed_penalties_input_stream;
+
+    if (update_edge_weights)
+    {
+        edge_segment_input_stream.open(edge_segment_lookup_filename, std::ios::binary);
+        edge_fixed_penalties_input_stream.open(edge_penalty_filename, std::ios::binary);
+        if (!edge_segment_input_stream || !edge_fixed_penalties_input_stream)
+        {
+            throw osrm::exception("Could not load .edge_segment_lookup or .edge_penalties, did you "
+                                  "run osrm-extract with '--generate-edge-lookup'?");
+        }
+    }
+
+    const FingerPrint fingerprint_valid = FingerPrint::GetValid();
+    FingerPrint fingerprint_loaded;
+    input_stream.read((char *)&fingerprint_loaded, sizeof(FingerPrint));
+    fingerprint_loaded.TestPrepare(fingerprint_valid);
+
+    size_t number_of_edges = 0;
+    size_t max_edge_id = SPECIAL_EDGEID;
+    input_stream.read((char *)&number_of_edges, sizeof(size_t));
+    input_stream.read((char *)&max_edge_id, sizeof(size_t));
+
+    edge_based_edge_list.resize(number_of_edges);
+    SimpleLogger().Write() << "Reading " << number_of_edges << " edges from the edge based graph";
+
+    std::unordered_map<std::pair<OSMNodeID, OSMNodeID>, unsigned> segment_speed_lookup;
+
+    if (update_edge_weights)
+    {
+        SimpleLogger().Write() << "Segment speed data supplied, will update edge weights from "
+                               << segment_speed_filename;
+        io::CSVReader<3> csv_in(segment_speed_filename);
+        csv_in.set_header("from_node", "to_node", "speed");
+        uint64_t from_node_id;
+        uint64_t to_node_id;
+        unsigned speed;
+        while (csv_in.read_row(from_node_id, to_node_id, speed))
+        {
+            segment_speed_lookup[std::make_pair(OSMNodeID(from_node_id), OSMNodeID(to_node_id))] = speed;
+        }
+    }
+
+    DEBUG_GEOMETRY_START(config);
+
+    // TODO: can we read this in bulk?  DeallocatingVector isn't necessarily
+    // all stored contiguously
+    for (; number_of_edges > 0; --number_of_edges)
+    {
+        EdgeBasedEdge inbuffer;
+        input_stream.read((char *) &inbuffer, sizeof(EdgeBasedEdge));
+
+        if (update_edge_weights)
+        {
+            // Processing-time edge updates
+            unsigned fixed_penalty;
+            edge_fixed_penalties_input_stream.read(reinterpret_cast<char *>(&fixed_penalty),
+                                                   sizeof(fixed_penalty));
+
+            int new_weight = 0;
+
+            unsigned num_osm_nodes = 0;
+            edge_segment_input_stream.read(reinterpret_cast<char *>(&num_osm_nodes),
+                                           sizeof(num_osm_nodes));
+            OSMNodeID previous_osm_node_id;
+            edge_segment_input_stream.read(reinterpret_cast<char *>(&previous_osm_node_id),
+                                           sizeof(previous_osm_node_id));
+            OSMNodeID this_osm_node_id;
+            double segment_length;
+            int segment_weight;
+            --num_osm_nodes;
+            for (; num_osm_nodes != 0; --num_osm_nodes)
+            {
+                edge_segment_input_stream.read(reinterpret_cast<char *>(&this_osm_node_id),
+                                               sizeof(this_osm_node_id));
+                edge_segment_input_stream.read(reinterpret_cast<char *>(&segment_length),
+                                               sizeof(segment_length));
+                edge_segment_input_stream.read(reinterpret_cast<char *>(&segment_weight),
+                                               sizeof(segment_weight));
+
+                auto speed_iter = segment_speed_lookup.find(
+                    std::make_pair(previous_osm_node_id, this_osm_node_id));
+                if (speed_iter != segment_speed_lookup.end())
+                {
+                    // This sets the segment weight using the same formula as the
+                    // EdgeBasedGraphFactory for consistency.  The *why* of this formula
+                    // is lost in the annals of time.
+                    int new_segment_weight =
+                        std::max(1, static_cast<int>(std::floor(
+                                        (segment_length * 10.) / (speed_iter->second / 3.6) + .5)));
+                    new_weight += new_segment_weight;
+
+                    DEBUG_GEOMETRY_EDGE( 
+                            new_segment_weight, 
+                            segment_length,
+                            previous_osm_node_id,
+                            this_osm_node_id);
+                }
+                else
+                {
+                    // If no lookup found, use the original weight value for this segment
+                    new_weight += segment_weight;
+
+                    DEBUG_GEOMETRY_EDGE(
+                            segment_weight,
+                            segment_length,
+                            previous_osm_node_id,
+                            this_osm_node_id);
+                }
+
+                previous_osm_node_id = this_osm_node_id;
+            }
+
+            inbuffer.weight = fixed_penalty + new_weight;
+        }
+
+        edge_based_edge_list.emplace_back(std::move(inbuffer));
+    }
+
+    DEBUG_GEOMETRY_STOP();
+    SimpleLogger().Write() << "Done reading edges";
+    return max_edge_id;
+}
+
+void Prepare::ReadNodeLevels(std::vector<float> &node_levels) const
+{
+    boost::filesystem::ifstream order_input_stream(config.level_output_path, std::ios::binary);
+
+    unsigned level_size;
+    order_input_stream.read((char *)&level_size, sizeof(unsigned));
+    node_levels.resize(level_size);
+    order_input_stream.read((char *)node_levels.data(), sizeof(float) * node_levels.size());
+}
+
+void Prepare::WriteNodeLevels(std::vector<float> &&in_node_levels) const
+{
+    std::vector<float> node_levels(std::move(in_node_levels));
+
+    boost::filesystem::ofstream order_output_stream(config.level_output_path, std::ios::binary);
+
+    unsigned level_size = node_levels.size();
+    order_output_stream.write((char *)&level_size, sizeof(unsigned));
+    order_output_stream.write((char *)node_levels.data(), sizeof(float) * node_levels.size());
+}
+
+void Prepare::WriteCoreNodeMarker(std::vector<bool> &&in_is_core_node) const
+{
+    std::vector<bool> is_core_node(std::move(in_is_core_node));
+    std::vector<char> unpacked_bool_flags(std::move(is_core_node.size()));
+    for (auto i = 0u; i < is_core_node.size(); ++i)
+    {
+        unpacked_bool_flags[i] = is_core_node[i] ? 1 : 0;
+    }
+
+    boost::filesystem::ofstream core_marker_output_stream(config.core_output_path,
+                                                          std::ios::binary);
+    unsigned size = unpacked_bool_flags.size();
+    core_marker_output_stream.write((char *)&size, sizeof(unsigned));
+    core_marker_output_stream.write((char *)unpacked_bool_flags.data(),
+                                    sizeof(char) * unpacked_bool_flags.size());
+}
+
+std::size_t Prepare::WriteContractedGraph(unsigned max_node_id,
+                                          const DeallocatingVector<QueryEdge> &contracted_edge_list)
+{
+    // Sorting contracted edges in a way that the static query graph can read some in in-place.
+    tbb::parallel_sort(contracted_edge_list.begin(), contracted_edge_list.end());
+    const unsigned contracted_edge_count = contracted_edge_list.size();
+    SimpleLogger().Write() << "Serializing compacted graph of " << contracted_edge_count
+                           << " edges";
+
+    const FingerPrint fingerprint = FingerPrint::GetValid();
+    boost::filesystem::ofstream hsgr_output_stream(config.graph_output_path, std::ios::binary);
+    hsgr_output_stream.write((char *)&fingerprint, sizeof(FingerPrint));
+    const unsigned max_used_node_id = [&contracted_edge_list]
+    {
+        unsigned tmp_max = 0;
+        for (const QueryEdge &edge : contracted_edge_list)
+        {
+            BOOST_ASSERT(SPECIAL_NODEID != edge.source);
+            BOOST_ASSERT(SPECIAL_NODEID != edge.target);
+            tmp_max = std::max(tmp_max, edge.source);
+            tmp_max = std::max(tmp_max, edge.target);
+        }
+        return tmp_max;
+    }();
+
+    SimpleLogger().Write(logDEBUG) << "input graph has " << (max_node_id + 1) << " nodes";
+    SimpleLogger().Write(logDEBUG) << "contracted graph has " << (max_used_node_id + 1) << " nodes";
+
+    std::vector<StaticGraph<EdgeData>::NodeArrayEntry> node_array;
+    // make sure we have at least one sentinel
+    node_array.resize(max_node_id + 2);
+
+    SimpleLogger().Write() << "Building node array";
+    StaticGraph<EdgeData>::EdgeIterator edge = 0;
+    StaticGraph<EdgeData>::EdgeIterator position = 0;
+    StaticGraph<EdgeData>::EdgeIterator last_edge;
+
+    // initializing 'first_edge'-field of nodes:
+    for (const auto node : osrm::irange(0u, max_used_node_id + 1))
+    {
+        last_edge = edge;
+        while ((edge < contracted_edge_count) && (contracted_edge_list[edge].source == node))
+        {
+            ++edge;
+        }
+        node_array[node].first_edge = position; //=edge
+        position += edge - last_edge;           // remove
+    }
+
+    for (const auto sentinel_counter :
+         osrm::irange<unsigned>(max_used_node_id + 1, node_array.size()))
+    {
+        // sentinel element, guarded against underflow
+        node_array[sentinel_counter].first_edge = contracted_edge_count;
+    }
+
+    SimpleLogger().Write() << "Serializing node array";
+
+    RangebasedCRC32 crc32_calculator;
+    const unsigned edges_crc32 = crc32_calculator(contracted_edge_list);
+    SimpleLogger().Write() << "Writing CRC32: " << edges_crc32;
+
+    const unsigned node_array_size = node_array.size();
+    // serialize crc32, aka checksum
+    hsgr_output_stream.write((char *)&edges_crc32, sizeof(unsigned));
+    // serialize number of nodes
+    hsgr_output_stream.write((char *)&node_array_size, sizeof(unsigned));
+    // serialize number of edges
+    hsgr_output_stream.write((char *)&contracted_edge_count, sizeof(unsigned));
+    // serialize all nodes
+    if (node_array_size > 0)
+    {
+        hsgr_output_stream.write((char *)&node_array[0],
+                                 sizeof(StaticGraph<EdgeData>::NodeArrayEntry) * node_array_size);
+    }
+
+    // serialize all edges
+    SimpleLogger().Write() << "Building edge array";
+    int number_of_used_edges = 0;
+
+    StaticGraph<EdgeData>::EdgeArrayEntry current_edge;
+    for (const auto edge : osrm::irange<std::size_t>(0, contracted_edge_list.size()))
+    {
+        // no eigen loops
+        BOOST_ASSERT(contracted_edge_list[edge].source != contracted_edge_list[edge].target);
+        current_edge.target = contracted_edge_list[edge].target;
+        current_edge.data = contracted_edge_list[edge].data;
+
+        // every target needs to be valid
+        BOOST_ASSERT(current_edge.target <= max_used_node_id);
+#ifndef NDEBUG
+        if (current_edge.data.distance <= 0)
+        {
+            SimpleLogger().Write(logWARNING) << "Edge: " << edge
+                                             << ",source: " << contracted_edge_list[edge].source
+                                             << ", target: " << contracted_edge_list[edge].target
+                                             << ", dist: " << current_edge.data.distance;
+
+            SimpleLogger().Write(logWARNING) << "Failed at adjacency list of node "
+                                             << contracted_edge_list[edge].source << "/"
+                                             << node_array.size() - 1;
+            return 1;
+        }
+#endif
+        hsgr_output_stream.write((char *)&current_edge,
+                                 sizeof(StaticGraph<EdgeData>::EdgeArrayEntry));
+
+        ++number_of_used_edges;
+    }
+
+    return number_of_used_edges;
+}
+
+/**
+ \brief Build contracted graph.
+ */
+void Prepare::ContractGraph(const unsigned max_edge_id,
+                            DeallocatingVector<EdgeBasedEdge> &edge_based_edge_list,
+                            DeallocatingVector<QueryEdge> &contracted_edge_list,
+                            std::vector<bool> &is_core_node,
+                            std::vector<float> &inout_node_levels) const
+{
+    std::vector<float> node_levels;
+    node_levels.swap(inout_node_levels);
+
+    Contractor contractor(max_edge_id + 1, edge_based_edge_list, std::move(node_levels));
+    contractor.Run(config.core_factor);
+    contractor.GetEdges(contracted_edge_list);
+    contractor.GetCoreMarker(is_core_node);
+    contractor.GetNodeLevels(inout_node_levels);
+}
@@ -0,0 +1,84 @@
+/*
+
+Copyright (c) 2014, Project OSRM, Dennis Luxen, others
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef PROCESSING_CHAIN_HPP
+#define PROCESSING_CHAIN_HPP
+
+#include "contractor.hpp"
+#include "contractor_options.hpp"
+#include "../data_structures/query_edge.hpp"
+#include "../data_structures/static_graph.hpp"
+#include "../data_structures/deallocating_vector.hpp"
+#include "../data_structures/node_based_graph.hpp"
+
+struct SpeedProfileProperties;
+struct EdgeBasedNode;
+struct lua_State;
+
+#include <boost/filesystem.hpp>
+
+#include <vector>
+
+/**
+    \brief class of 'prepare' utility.
+ */
+class Prepare
+{
+  public:
+    using EdgeData = QueryEdge::EdgeData;
+
+    explicit Prepare(ContractorConfig contractor_config) : config(std::move(contractor_config)) {}
+    Prepare(const Prepare &) = delete;
+    ~Prepare();
+
+    int Run();
+
+  protected:
+    void ContractGraph(const unsigned max_edge_id,
+                       DeallocatingVector<EdgeBasedEdge> &edge_based_edge_list,
+                       DeallocatingVector<QueryEdge> &contracted_edge_list,
+                       std::vector<bool> &is_core_node,
+                       std::vector<float> &node_levels) const;
+    void WriteCoreNodeMarker(std::vector<bool> &&is_core_node) const;
+    void WriteNodeLevels(std::vector<float> &&node_levels) const;
+    void ReadNodeLevels(std::vector<float> &contraction_order) const;
+    std::size_t WriteContractedGraph(unsigned number_of_edge_based_nodes,
+                                     const DeallocatingVector<QueryEdge> &contracted_edge_list);
+    void FindComponents(unsigned max_edge_id,
+                        const DeallocatingVector<EdgeBasedEdge> &edges,
+                        std::vector<EdgeBasedNode> &nodes) const;
+
+  private:
+    ContractorConfig config;
+    std::size_t LoadEdgeExpandedGraph(const std::string &edge_based_graph_path,
+                                      DeallocatingVector<EdgeBasedEdge> &edge_based_edge_list,
+                                      const std::string &edge_segment_lookup_path,
+                                      const std::string &edge_penalty_path,
+                                      const std::string &segment_speed_path);
+};
+
+#endif // PROCESSING_CHAIN_HPP
@@ -1,3 +1,30 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
 #ifndef BINARY_HEAP_H
 #define BINARY_HEAP_H

@@ -10,11 +37,6 @@
 #include <unordered_map>
 #include <vector>

-namespace osrm
-{
-namespace util
-{
-
 template <typename NodeID, typename Key> class ArrayStorage
 {
  public:
@@ -167,10 +189,9 @@ class BinaryHeap
        return inserted_nodes[heap[1].index].node;
    }

-    Weight MinKey() const
-    {
-        BOOST_ASSERT(heap.size() > 1);
-        return heap[1].weight;
+    Weight MinKey() const {
+      BOOST_ASSERT(heap.size() > 1);
+      return heap[1].weight;
    }

    NodeID DeleteMin()
@@ -290,7 +311,5 @@ class BinaryHeap
 #endif
    }
 };
-}
-}

 #endif // BINARY_HEAP_H
@@ -1,5 +1,32 @@
-#include "extractor/compressed_edge_container.hpp"
-#include "util/simple_logger.hpp"
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#include "compressed_edge_container.hpp"
+#include "../util/simple_logger.hpp"

 #include <boost/assert.hpp>
 #include <boost/filesystem.hpp>
@@ -10,11 +37,6 @@

 #include <iostream>

-namespace osrm
-{
-namespace extractor
-{
-
 CompressedEdgeContainer::CompressedEdgeContainer()
 {
    m_free_list.reserve(100);
@@ -59,7 +81,7 @@ void CompressedEdgeContainer::SerializeInternalVector(const std::string &path) c
    {
        geometry_out_stream.write((char *)&prefix_sum_of_list_indices, sizeof(unsigned));

-        const std::vector<CompressedEdge> &current_vector = elem;
+        const std::vector<CompressedNode> &current_vector = elem;
        const unsigned unpacked_size = current_vector.size();
        BOOST_ASSERT(std::numeric_limits<unsigned>::max() != unpacked_size);
        prefix_sum_of_list_indices += unpacked_size;
@@ -74,32 +96,26 @@ void CompressedEdgeContainer::SerializeInternalVector(const std::string &path) c
    // write compressed geometries
    for (auto &elem : m_compressed_geometries)
    {
-        const std::vector<CompressedEdge> &current_vector = elem;
+        const std::vector<CompressedNode> &current_vector = elem;
        const unsigned unpacked_size = current_vector.size();
        control_sum += unpacked_size;
        BOOST_ASSERT(std::numeric_limits<unsigned>::max() != unpacked_size);
-        for (const auto &current_node : current_vector)
+        for (const CompressedNode current_node : current_vector)
        {
-            geometry_out_stream.write((char *)&(current_node), sizeof(CompressedEdge));
+            geometry_out_stream.write((char *)&(current_node.first), sizeof(NodeID));
        }
    }
    BOOST_ASSERT(control_sum == prefix_sum_of_list_indices);
+    // all done, let's close the resource
+    geometry_out_stream.close();
 }

-// Adds info for a compressed edge to the container.   edge_id_2
-// has been removed from the graph, so we have to save These edges/nodes
-// have already been trimmed from the graph, this function just stores
-// the original data for unpacking later.
-//
-//     edge_id_1               edge_id_2
-//   ----------> via_node_id -----------> target_node_id
-//     weight_1                weight_2
 void CompressedEdgeContainer::CompressEdge(const EdgeID edge_id_1,
-                                           const EdgeID edge_id_2,
-                                           const NodeID via_node_id,
-                                           const NodeID target_node_id,
-                                           const EdgeWeight weight1,
-                                           const EdgeWeight weight2)
+                                      const EdgeID edge_id_2,
+                                      const NodeID via_node_id,
+                                      const NodeID target_node_id,
+                                      const EdgeWeight weight1,
+                                      const EdgeWeight weight2)
 {
    // remove super-trivial geometries
    BOOST_ASSERT(SPECIAL_EDGEID != edge_id_1);
@@ -137,13 +153,13 @@ void CompressedEdgeContainer::CompressEdge(const EdgeID edge_id_1,
    BOOST_ASSERT(edge_bucket_id1 == GetPositionForID(edge_id_1));
    BOOST_ASSERT(edge_bucket_id1 < m_compressed_geometries.size());

-    std::vector<CompressedEdge> &edge_bucket_list1 = m_compressed_geometries[edge_bucket_id1];
+    std::vector<CompressedNode> &edge_bucket_list1 = m_compressed_geometries[edge_bucket_id1];

    // note we don't save the start coordinate: it is implicitly given by edge 1
    // weight1 is the distance to the (currently) last coordinate in the bucket
    if (edge_bucket_list1.empty())
    {
-        edge_bucket_list1.emplace_back(CompressedEdge{via_node_id, weight1});
+        edge_bucket_list1.emplace_back(via_node_id, weight1);
    }

    BOOST_ASSERT(0 < edge_bucket_list1.size());
@@ -155,7 +171,7 @@ void CompressedEdgeContainer::CompressEdge(const EdgeID edge_id_1,
        const unsigned list_to_remove_index = GetPositionForID(edge_id_2);
        BOOST_ASSERT(list_to_remove_index < m_compressed_geometries.size());

-        std::vector<CompressedEdge> &edge_bucket_list2 =
+        std::vector<CompressedNode> &edge_bucket_list2 =
            m_compressed_geometries[list_to_remove_index];

        // found an existing list, append it to the list of edge_id_1
@@ -174,48 +190,7 @@ void CompressedEdgeContainer::CompressEdge(const EdgeID edge_id_1,
    else
    {
        // we are certain that the second edge is atomic.
-        edge_bucket_list1.emplace_back(CompressedEdge{target_node_id, weight2});
-    }
-}
-
-void CompressedEdgeContainer::AddUncompressedEdge(const EdgeID edge_id,
-                                                  const NodeID target_node_id,
-                                                  const EdgeWeight weight)
-{
-    // remove super-trivial geometries
-    BOOST_ASSERT(SPECIAL_EDGEID != edge_id);
-    BOOST_ASSERT(SPECIAL_NODEID != target_node_id);
-    BOOST_ASSERT(INVALID_EDGE_WEIGHT != weight);
-
-    // Add via node id. List is created if it does not exist
-    if (!HasEntryForID(edge_id))
-    {
-        // create a new entry in the map
-        if (0 == m_free_list.size())
-        {
-            // make sure there is a place to put the entries
-            IncreaseFreeList();
-        }
-        BOOST_ASSERT(!m_free_list.empty());
-        m_edge_id_to_list_index_map[edge_id] = m_free_list.back();
-        m_free_list.pop_back();
-    }
-
-    // find bucket index
-    const auto iter = m_edge_id_to_list_index_map.find(edge_id);
-    BOOST_ASSERT(iter != m_edge_id_to_list_index_map.end());
-    const unsigned edge_bucket_id = iter->second;
-    BOOST_ASSERT(edge_bucket_id == GetPositionForID(edge_id));
-    BOOST_ASSERT(edge_bucket_id < m_compressed_geometries.size());
-
-    std::vector<CompressedEdge> &edge_bucket_list = m_compressed_geometries[edge_bucket_id];
-
-    // note we don't save the start coordinate: it is implicitly given by edge_id
-    // weight is the distance to the (currently) last coordinate in the bucket
-    // Don't re-add this if it's already in there.
-    if (edge_bucket_list.empty())
-    {
-        edge_bucket_list.emplace_back(CompressedEdge{target_node_id, weight});
+        edge_bucket_list1.emplace_back(target_node_id, weight2);
    }
 }

@@ -227,23 +202,24 @@ void CompressedEdgeContainer::PrintStatistics() const

    uint64_t compressed_geometries = 0;
    uint64_t longest_chain_length = 0;
-    for (const std::vector<CompressedEdge> &current_vector : m_compressed_geometries)
+    for (const std::vector<CompressedNode> &current_vector : m_compressed_geometries)
    {
        compressed_geometries += current_vector.size();
        longest_chain_length = std::max(longest_chain_length, (uint64_t)current_vector.size());
    }

-    util::SimpleLogger().Write()
-        << "Geometry successfully removed:"
-           "\n  compressed edges: "
-        << compressed_edges << "\n  compressed geometries: " << compressed_geometries
-        << "\n  longest chain length: " << longest_chain_length << "\n  cmpr ratio: "
-        << ((float)compressed_edges / std::max(compressed_geometries, (uint64_t)1))
-        << "\n  avg chain length: "
-        << (float)compressed_geometries / std::max((uint64_t)1, compressed_edges);
+    SimpleLogger().Write() << "Geometry successfully removed:"
+                              "\n  compressed edges: " << compressed_edges
+                           << "\n  compressed geometries: " << compressed_geometries
+                           << "\n  longest chain length: " << longest_chain_length
+                           << "\n  cmpr ratio: " << ((float)compressed_edges /
+                                                     std::max(compressed_geometries, (uint64_t)1))
+                           << "\n  avg chain length: "
+                           << (float)compressed_geometries /
+                                  std::max((uint64_t)1, compressed_edges);
 }

-const CompressedEdgeContainer::EdgeBucket &
+const CompressedEdgeContainer::EdgeBucket&
 CompressedEdgeContainer::GetBucketReference(const EdgeID edge_id) const
 {
    const unsigned index = m_edge_id_to_list_index_map.at(edge_id);
@@ -254,13 +230,11 @@ NodeID CompressedEdgeContainer::GetFirstEdgeTargetID(const EdgeID edge_id) const
 {
    const auto &bucket = GetBucketReference(edge_id);
    BOOST_ASSERT(bucket.size() >= 2);
-    return bucket.front().node_id;
+    return bucket.front().first;
 }
 NodeID CompressedEdgeContainer::GetLastEdgeSourceID(const EdgeID edge_id) const
 {
    const auto &bucket = GetBucketReference(edge_id);
    BOOST_ASSERT(bucket.size() >= 2);
-    return bucket[bucket.size() - 2].node_id;
-}
-}
+    return bucket[bucket.size() - 2].first;
 }
@@ -1,6 +1,6 @@
 /*

-Copyright (c) 2016, Project OSRM contributors
+Copyright (c) 2014, Project OSRM, Dennis Luxen, others
 All rights reserved.

 Redistribution and use in source and binary forms, with or without modification,
@@ -25,78 +25,45 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

-// based on
-// https://svn.apache.org/repos/asf/mesos/tags/release-0.9.0-incubating-RC0/src/common/json.hpp
+#ifndef GEOMETRY_COMPRESSOR_HPP_
+#define GEOMETRY_COMPRESSOR_HPP_

-#ifndef JSON_CONTAINER_HPP
-#define JSON_CONTAINER_HPP
+#include "../typedefs.h"

-#include <variant/variant.hpp>
-
-#include <vector>
-#include <string>
-#include <utility>
 #include <unordered_map>

-namespace osrm
-{
+#include <string>
+#include <vector>

-namespace util
+class CompressedEdgeContainer
 {
+  public:
+    using CompressedNode = std::pair<NodeID, EdgeWeight>;
+    using EdgeBucket = std::vector<CompressedNode>;

-namespace json
-{
+    CompressedEdgeContainer();
+    void CompressEdge(const EdgeID surviving_edge_id,
+                      const EdgeID removed_edge_id,
+                      const NodeID via_node_id,
+                      const NodeID target_node,
+                      const EdgeWeight weight1,
+                      const EdgeWeight weight2);

-struct Object;
-struct Array;
+    bool HasEntryForID(const EdgeID edge_id) const;
+    void PrintStatistics() const;
+    void SerializeInternalVector(const std::string &path) const;
+    unsigned GetPositionForID(const EdgeID edge_id) const;
+    const EdgeBucket& GetBucketReference(const EdgeID edge_id) const;
+    NodeID GetFirstEdgeTargetID(const EdgeID edge_id) const;
+    NodeID GetLastEdgeSourceID(const EdgeID edge_id) const;

-struct String
-{
-    String() = default;
-    String(const char *value_) : value{value_} {}
-    String(std::string value_) : value{std::move(value_)} {}
-    std::string value;
+  private:
+    int free_list_maximum = 0;
+
+    void IncreaseFreeList();
+    std::vector<EdgeBucket> m_compressed_geometries;
+    std::vector<unsigned> m_free_list;
+    std::unordered_map<EdgeID, unsigned> m_edge_id_to_list_index_map;
 };

-struct Number
-{
-    Number() = default;
-    Number(double value_) : value{value_} {}
-    double value;
-};
-
-struct True
-{
-};
-
-struct False
-{
-};
-
-struct Null
-{
-};
-
-using Value = mapbox::util::variant<String,
-                                    Number,
-                                    mapbox::util::recursive_wrapper<Object>,
-                                    mapbox::util::recursive_wrapper<Array>,
-                                    True,
-                                    False,
-                                    Null>;
-
-struct Object
-{
-    std::unordered_map<std::string, Value> values;
-};
-
-struct Array
-{
-    std::vector<Value> values;
-};
-
-} // namespace JSON
-} // namespace util
-} // namespace osrm
-
-#endif // JSON_CONTAINER_HPP
+#endif // GEOMETRY_COMPRESSOR_HPP_
@@ -0,0 +1,87 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#include "../algorithms/coordinate_calculation.hpp"
+
+#ifndef NDEBUG
+#include "../util/simple_logger.hpp"
+#endif
+#include <osrm/coordinate.hpp>
+
+#ifndef NDEBUG
+#include <bitset>
+#endif
+#include <iostream>
+#include <limits>
+
+FixedPointCoordinate::FixedPointCoordinate()
+    : lat(std::numeric_limits<int>::min()), lon(std::numeric_limits<int>::min())
+{
+}
+
+FixedPointCoordinate::FixedPointCoordinate(int lat, int lon) : lat(lat), lon(lon)
+{
+#ifndef NDEBUG
+    if (0 != (std::abs(lat) >> 30))
+    {
+        std::bitset<32> y_coordinate_vector(lat);
+        SimpleLogger().Write(logDEBUG) << "broken lat: " << lat
+                                       << ", bits: " << y_coordinate_vector;
+    }
+    if (0 != (std::abs(lon) >> 30))
+    {
+        std::bitset<32> x_coordinate_vector(lon);
+        SimpleLogger().Write(logDEBUG) << "broken lon: " << lon
+                                       << ", bits: " << x_coordinate_vector;
+    }
+#endif
+}
+
+bool FixedPointCoordinate::is_valid() const
+{
+    if (lat > 90 * COORDINATE_PRECISION || lat < -90 * COORDINATE_PRECISION ||
+        lon > 180 * COORDINATE_PRECISION || lon < -180 * COORDINATE_PRECISION)
+    {
+        return false;
+    }
+    return true;
+}
+
+bool FixedPointCoordinate::operator==(const FixedPointCoordinate &other) const
+{
+    return lat == other.lat && lon == other.lon;
+}
+
+void FixedPointCoordinate::output(std::ostream &out) const
+{
+    out << "(" << lat / COORDINATE_PRECISION << "," << lon / COORDINATE_PRECISION << ")";
+}
+
+float FixedPointCoordinate::bearing(const FixedPointCoordinate &other) const
+{
+    return coordinate_calculation::bearing(other, *this);
+}
@@ -1,7 +1,34 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
 #ifndef DEALLOCATING_VECTOR_HPP
 #define DEALLOCATING_VECTOR_HPP

-#include "util/integer_range.hpp"
+#include "../util/integer_range.hpp"

 #include <boost/iterator/iterator_facade.hpp>

@@ -9,11 +36,6 @@
 #include <utility>
 #include <vector>

-namespace osrm
-{
-namespace util
-{
-
 template <typename ElementT> struct ConstDeallocatingVectorIteratorState
 {
    ConstDeallocatingVectorIteratorState()
@@ -25,15 +47,14 @@ template <typename ElementT> struct ConstDeallocatingVectorIteratorState
    {
    }
    explicit ConstDeallocatingVectorIteratorState(const std::size_t idx,
-                                                  const std::vector<ElementT *> *input_list)
+                                             const std::vector<ElementT *> *input_list)
        : index(idx), bucket_list(input_list)
    {
    }
    std::size_t index;
    const std::vector<ElementT *> *bucket_list;

-    ConstDeallocatingVectorIteratorState &
-    operator=(const ConstDeallocatingVectorIteratorState &other)
+    ConstDeallocatingVectorIteratorState &operator=(const ConstDeallocatingVectorIteratorState &other)
    {
        index = other.index;
        bucket_list = other.bucket_list;
@@ -216,10 +237,11 @@ class DeallocatingVectorRemoveIterator
    }
 };

-template <typename ElementT, std::size_t ELEMENTS_PER_BLOCK> class DeallocatingVector;
+template <typename ElementT, std::size_t ELEMENTS_PER_BLOCK>
+class DeallocatingVector;

-template <typename T, std::size_t S>
-void swap(DeallocatingVector<T, S> &lhs, DeallocatingVector<T, S> &rhs);
+template<typename T, std::size_t S>
+void swap(DeallocatingVector<T, S>& lhs, DeallocatingVector<T, S>& rhs);

 template <typename ElementT, std::size_t ELEMENTS_PER_BLOCK = 8388608 / sizeof(ElementT)>
 class DeallocatingVector
@@ -241,8 +263,7 @@ class DeallocatingVector

    ~DeallocatingVector() { clear(); }

-    friend void swap<>(DeallocatingVector<ElementT, ELEMENTS_PER_BLOCK> &lhs,
-                       DeallocatingVector<ElementT, ELEMENTS_PER_BLOCK> &rhs);
+    friend void swap<>(DeallocatingVector<ElementT, ELEMENTS_PER_BLOCK>& lhs, DeallocatingVector<ElementT, ELEMENTS_PER_BLOCK>& rhs);

    void swap(DeallocatingVector<ElementT, ELEMENTS_PER_BLOCK> &other)
    {
@@ -306,7 +327,8 @@ class DeallocatingVector
        else
        { // down-size
            const std::size_t number_of_necessary_buckets = 1 + (new_size / ELEMENTS_PER_BLOCK);
-            for (const auto bucket_index : irange(number_of_necessary_buckets, bucket_list.size()))
+            for (const auto bucket_index :
+                 osrm::irange(number_of_necessary_buckets, bucket_list.size()))
            {
                if (nullptr != bucket_list[bucket_index])
                {
@@ -372,12 +394,10 @@ class DeallocatingVector
    }
 };

-template <typename T, std::size_t S>
-void swap(DeallocatingVector<T, S> &lhs, DeallocatingVector<T, S> &rhs)
+template<typename T, std::size_t S>
+void swap(DeallocatingVector<T, S>& lhs, DeallocatingVector<T, S>& rhs)
 {
    lhs.swap(rhs);
 }
-}
-}

 #endif /* DEALLOCATING_VECTOR_HPP */
@@ -1,9 +1,36 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
 #ifndef DYNAMICGRAPH_HPP
 #define DYNAMICGRAPH_HPP

-#include "util/deallocating_vector.hpp"
-#include "util/integer_range.hpp"
-#include "util/typedefs.hpp"
+#include "deallocating_vector.hpp"
+#include "../util/integer_range.hpp"
+#include "../typedefs.h"

 #include <boost/assert.hpp>

@@ -15,18 +42,13 @@
 #include <tuple>
 #include <vector>

-namespace osrm
-{
-namespace util
-{
-
 template <typename EdgeDataT> class DynamicGraph
 {
  public:
    using EdgeData = EdgeDataT;
    using NodeIterator = unsigned;
    using EdgeIterator = unsigned;
-    using EdgeRange = range<EdgeIterator>;
+    using EdgeRange = osrm::range<EdgeIterator>;

    class InputEdge
    {
@@ -69,15 +91,14 @@ template <typename EdgeDataT> class DynamicGraph
    template <class ContainerT> DynamicGraph(const NodeIterator nodes, const ContainerT &graph)
    {
        // we need to cast here because DeallocatingVector does not have a valid const iterator
-        BOOST_ASSERT(std::is_sorted(const_cast<ContainerT &>(graph).begin(),
-                                    const_cast<ContainerT &>(graph).end()));
+        BOOST_ASSERT(std::is_sorted(const_cast<ContainerT&>(graph).begin(), const_cast<ContainerT&>(graph).end()));

        number_of_nodes = nodes;
        number_of_edges = static_cast<EdgeIterator>(graph.size());
        node_array.resize(number_of_nodes + 1);
        EdgeIterator edge = 0;
        EdgeIterator position = 0;
-        for (const auto node : irange(0u, number_of_nodes))
+        for (const auto node : osrm::irange(0u, number_of_nodes))
        {
            EdgeIterator last_edge = edge;
            while (edge < number_of_edges && graph[edge].source == node)
@@ -92,10 +113,10 @@ template <typename EdgeDataT> class DynamicGraph
        edge_list.reserve(static_cast<std::size_t>(edge_list.size() * 1.1));
        edge_list.resize(position);
        edge = 0;
-        for (const auto node : irange(0u, number_of_nodes))
+        for (const auto node : osrm::irange(0u, number_of_nodes))
        {
-            for (const auto i : irange(node_array[node].first_edge,
-                                       node_array[node].first_edge + node_array[node].edges))
+            for (const auto i : osrm::irange(node_array[node].first_edge,
+                                             node_array[node].first_edge + node_array[node].edges))
            {
                edge_list[i].target = graph[edge].target;
                BOOST_ASSERT(edge_list[i].target < number_of_nodes);
@@ -116,7 +137,7 @@ template <typename EdgeDataT> class DynamicGraph
    unsigned GetDirectedOutDegree(const NodeIterator n) const
    {
        unsigned degree = 0;
-        for (const auto edge : irange(BeginEdges(n), EndEdges(n)))
+        for (const auto edge : osrm::irange(BeginEdges(n), EndEdges(n)))
        {
            if (!GetEdgeData(edge).reversed)
            {
@@ -146,7 +167,7 @@ template <typename EdgeDataT> class DynamicGraph

    EdgeRange GetAdjacentEdgeRange(const NodeIterator node) const
    {
-        return irange(BeginEdges(node), EndEdges(node));
+        return osrm::irange(BeginEdges(node), EndEdges(node));
    }

    NodeIterator InsertNode()
@@ -180,12 +201,12 @@ template <typename EdgeDataT> class DynamicGraph
                    edge_list.reserve(requiredCapacity * 1.1);
                }
                edge_list.resize(edge_list.size() + newSize);
-                for (const auto i : irange(0u, node.edges))
+                for (const auto i : osrm::irange(0u, node.edges))
                {
                    edge_list[newFirstEdge + i] = edge_list[node.first_edge + i];
                    makeDummy(node.first_edge + i);
                }
-                for (const auto i : irange(node.edges + 1, newSize))
+                for (const auto i : osrm::irange(node.edges + 1, newSize))
                {
                    makeDummy(newFirstEdge + i);
                }
@@ -240,7 +261,7 @@ template <typename EdgeDataT> class DynamicGraph
    // searches for a specific edge
    EdgeIterator FindEdge(const NodeIterator from, const NodeIterator to) const
    {
-        for (const auto i : irange(BeginEdges(from), EndEdges(from)))
+        for (const auto i : osrm::irange(BeginEdges(from), EndEdges(from)))
        {
            if (to == edge_list[i].target)
            {
@@ -320,7 +341,5 @@ template <typename EdgeDataT> class DynamicGraph
    std::vector<Node> node_array;
    DeallocatingVector<Edge> edge_list;
 };
-}
-}

 #endif // DYNAMICGRAPH_HPP
@@ -0,0 +1,113 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef EDGE_BASED_NODE_HPP
+#define EDGE_BASED_NODE_HPP
+
+#include "../data_structures/travel_mode.hpp"
+#include "../typedefs.h"
+
+#include <boost/assert.hpp>
+
+#include <osrm/coordinate.hpp>
+
+#include <limits>
+
+/// This is what StaticRTree serialized and stores on disk
+/// It is generated in EdgeBasedGraphFactory.
+struct EdgeBasedNode
+{
+    EdgeBasedNode()
+        : forward_edge_based_node_id(SPECIAL_NODEID), reverse_edge_based_node_id(SPECIAL_NODEID),
+          u(SPECIAL_NODEID), v(SPECIAL_NODEID), name_id(0),
+          forward_weight(INVALID_EDGE_WEIGHT >> 1), reverse_weight(INVALID_EDGE_WEIGHT >> 1),
+          forward_offset(0), reverse_offset(0), packed_geometry_id(SPECIAL_EDGEID),
+          component{INVALID_COMPONENTID, false}, fwd_segment_position(std::numeric_limits<unsigned short>::max()),
+          forward_travel_mode(TRAVEL_MODE_INACCESSIBLE),
+          backward_travel_mode(TRAVEL_MODE_INACCESSIBLE)
+    {
+    }
+
+    explicit EdgeBasedNode(NodeID forward_edge_based_node_id,
+                           NodeID reverse_edge_based_node_id,
+                           NodeID u,
+                           NodeID v,
+                           unsigned name_id,
+                           int forward_weight,
+                           int reverse_weight,
+                           int forward_offset,
+                           int reverse_offset,
+                           unsigned packed_geometry_id,
+                           bool is_tiny_component,
+                           unsigned component_id,
+                           unsigned short fwd_segment_position,
+                           TravelMode forward_travel_mode,
+                           TravelMode backward_travel_mode)
+        : forward_edge_based_node_id(forward_edge_based_node_id),
+          reverse_edge_based_node_id(reverse_edge_based_node_id), u(u), v(v), name_id(name_id),
+          forward_weight(forward_weight), reverse_weight(reverse_weight),
+          forward_offset(forward_offset), reverse_offset(reverse_offset),
+          packed_geometry_id(packed_geometry_id), component{component_id, is_tiny_component},
+          fwd_segment_position(fwd_segment_position), forward_travel_mode(forward_travel_mode),
+          backward_travel_mode(backward_travel_mode)
+    {
+        BOOST_ASSERT((forward_edge_based_node_id != SPECIAL_NODEID) ||
+                     (reverse_edge_based_node_id != SPECIAL_NODEID));
+    }
+
+    static inline FixedPointCoordinate Centroid(const FixedPointCoordinate &a,
+                                                const FixedPointCoordinate &b)
+    {
+        FixedPointCoordinate centroid;
+        // The coordinates of the midpoint are given by:
+        centroid.lat = (a.lat + b.lat) / 2;
+        centroid.lon = (a.lon + b.lon) / 2;
+        return centroid;
+    }
+
+    bool IsCompressed() const { return packed_geometry_id != SPECIAL_EDGEID; }
+
+    NodeID forward_edge_based_node_id; // needed for edge-expanded graph
+    NodeID reverse_edge_based_node_id; // needed for edge-expanded graph
+    NodeID u;                          // indices into the coordinates array
+    NodeID v;                          // indices into the coordinates array
+    unsigned name_id;                  // id of the edge name
+    int forward_weight;                // weight of the edge
+    int reverse_weight;                // weight in the other direction (may be different)
+    int forward_offset;          // prefix sum of the weight up the edge TODO: short must suffice
+    int reverse_offset;          // prefix sum of the weight from the edge TODO: short must suffice
+    unsigned packed_geometry_id; // if set, then the edge represents a packed geometry
+    struct {
+        unsigned id : 31;
+        bool is_tiny : 1;
+    } component;
+    unsigned short fwd_segment_position; // segment id in a compressed geometry
+    TravelMode forward_travel_mode : 4;
+    TravelMode backward_travel_mode : 4;
+};
+
+#endif // EDGE_BASED_NODE_HPP
@@ -0,0 +1,66 @@
+/*
+
+Copyright (c) 2014, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#include "external_memory_node.hpp"
+#include "query_node.hpp"
+
+#include <limits>
+
+ExternalMemoryNode::ExternalMemoryNode(
+    int lat, int lon, OSMNodeID node_id, bool barrier, bool traffic_lights)
+    : QueryNode(lat, lon, node_id), barrier(barrier), traffic_lights(traffic_lights)
+{
+}
+
+ExternalMemoryNode::ExternalMemoryNode() : barrier(false), traffic_lights(false) {}
+
+ExternalMemoryNode ExternalMemoryNode::min_value()
+{
+    return ExternalMemoryNode(0, 0, MIN_OSM_NODEID, false, false);
+}
+
+ExternalMemoryNode ExternalMemoryNode::max_value()
+{
+    return ExternalMemoryNode(std::numeric_limits<int>::max(), std::numeric_limits<int>::max(),
+                              MAX_OSM_NODEID, false, false);
+}
+
+bool ExternalMemoryNodeSTXXLCompare::operator()(const ExternalMemoryNode &left,
+                                                const ExternalMemoryNode &right) const
+{
+    return left.node_id < right.node_id;
+}
+
+ExternalMemoryNodeSTXXLCompare::value_type ExternalMemoryNodeSTXXLCompare::max_value()
+{
+    return ExternalMemoryNode::max_value();
+}
+
+ExternalMemoryNodeSTXXLCompare::value_type ExternalMemoryNodeSTXXLCompare::min_value()
+{
+    return ExternalMemoryNode::min_value();
+}
@@ -0,0 +1,57 @@
+/*
+
+Copyright (c) 2014, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef EXTERNAL_MEMORY_NODE_HPP_
+#define EXTERNAL_MEMORY_NODE_HPP_
+
+#include "query_node.hpp"
+
+#include "../typedefs.h"
+
+struct ExternalMemoryNode : QueryNode
+{
+    ExternalMemoryNode(int lat, int lon, OSMNodeID id, bool barrier, bool traffic_light);
+
+    ExternalMemoryNode();
+
+    static ExternalMemoryNode min_value();
+
+    static ExternalMemoryNode max_value();
+
+    bool barrier;
+    bool traffic_lights;
+};
+
+struct ExternalMemoryNodeSTXXLCompare
+{
+    using value_type = ExternalMemoryNode;
+    bool operator()(const ExternalMemoryNode &left, const ExternalMemoryNode &right) const;
+    value_type max_value();
+    value_type min_value();
+};
+
+#endif /* EXTERNAL_MEMORY_NODE_HPP_ */
@@ -0,0 +1,216 @@
+/*
+
+Copyright (c) 2014, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef FIXED_POINT_NUMBER_HPP
+#define FIXED_POINT_NUMBER_HPP
+
+#include <cmath>
+#include <cstdint>
+
+#include <iostream>
+#include <limits>
+#include <type_traits>
+#include <utility>
+
+namespace osrm
+{
+
+// implements an binary based fixed point number type
+template <unsigned FractionalBitSize,
+          bool use_64_bits = false,
+          bool is_unsigned = false,
+          bool truncate_results = false>
+class FixedPointNumber
+{
+    static_assert(FractionalBitSize > 0, "FractionalBitSize must be greater than 0");
+    static_assert(FractionalBitSize <= 32, "FractionalBitSize must at most 32");
+
+    typename std::conditional<use_64_bits, int64_t, int32_t>::type m_fixed_point_state;
+    constexpr static const decltype(m_fixed_point_state) PRECISION = 1 << FractionalBitSize;
+
+    // state signage encapsulates whether the state should either represent a
+    // signed or an unsigned floating point number
+    using state_signage =
+        typename std::conditional<is_unsigned,
+                                  typename std::make_unsigned<decltype(m_fixed_point_state)>::type,
+                                  decltype(m_fixed_point_state)>::type;
+
+  public:
+    FixedPointNumber() : m_fixed_point_state(0) {}
+
+    // the type is either initialized with a floating point value or an
+    // integral state. Anything else will throw at compile-time.
+    template <class T>
+    constexpr FixedPointNumber(const T &&input) noexcept
+        : m_fixed_point_state(static_cast<decltype(m_fixed_point_state)>(
+              std::round(std::forward<const T>(input) * PRECISION)))
+    {
+        static_assert(
+            std::is_floating_point<T>::value || std::is_integral<T>::value,
+            "FixedPointNumber needs to be initialized with floating point or integral value");
+    }
+
+    // get max value
+    template <typename T,
+              typename std::enable_if<std::is_floating_point<T>::value>::type * = nullptr>
+    constexpr static auto max() noexcept -> T
+    {
+        return static_cast<T>(std::numeric_limits<state_signage>::max()) / PRECISION;
+    }
+
+    // get min value
+    template <typename T,
+              typename std::enable_if<std::is_floating_point<T>::value>::type * = nullptr>
+    constexpr static auto min() noexcept -> T
+    {
+        return static_cast<T>(1) / PRECISION;
+    }
+
+    // get lowest value
+    template <typename T,
+              typename std::enable_if<std::is_floating_point<T>::value>::type * = nullptr>
+    constexpr static auto lowest() noexcept -> T
+    {
+        return static_cast<T>(std::numeric_limits<state_signage>::min()) / PRECISION;
+    }
+
+    // cast to floating point type T, return value
+    template <typename T,
+              typename std::enable_if<std::is_floating_point<T>::value>::type * = nullptr>
+    explicit operator const T() const noexcept
+    {
+        // casts to external type (signed or unsigned) and then to float
+        return static_cast<T>(static_cast<state_signage>(m_fixed_point_state)) / PRECISION;
+    }
+
+    // warn about cast to integral type T, its disabled for good reason
+    template <typename T, typename std::enable_if<std::is_integral<T>::value>::type * = nullptr>
+    explicit operator T() const
+    {
+        static_assert(std::is_integral<T>::value,
+                      "casts to integral types have been disabled on purpose");
+    }
+
+    // compare, ie. sort fixed-point numbers
+    bool operator<(const FixedPointNumber &other) const noexcept
+    {
+        return m_fixed_point_state < other.m_fixed_point_state;
+    }
+
+    // equality, ie. sort fixed-point numbers
+    bool operator==(const FixedPointNumber &other) const noexcept
+    {
+        return m_fixed_point_state == other.m_fixed_point_state;
+    }
+
+    bool operator!=(const FixedPointNumber &other) const { return !(*this == other); }
+    bool operator>(const FixedPointNumber &other) const { return other < *this; }
+    bool operator<=(const FixedPointNumber &other) const { return !(other < *this); }
+    bool operator>=(const FixedPointNumber &other) const { return !(*this < other); }
+
+    // arithmetic operators
+    FixedPointNumber operator+(const FixedPointNumber &other) const noexcept
+    {
+        FixedPointNumber tmp = *this;
+        tmp.m_fixed_point_state += other.m_fixed_point_state;
+        return tmp;
+    }
+
+    FixedPointNumber &operator+=(const FixedPointNumber &other) noexcept
+    {
+        this->m_fixed_point_state += other.m_fixed_point_state;
+        return *this;
+    }
+
+    FixedPointNumber operator-(const FixedPointNumber &other) const noexcept
+    {
+        FixedPointNumber tmp = *this;
+        tmp.m_fixed_point_state -= other.m_fixed_point_state;
+        return tmp;
+    }
+
+    FixedPointNumber &operator-=(const FixedPointNumber &other) noexcept
+    {
+        this->m_fixed_point_state -= other.m_fixed_point_state;
+        return *this;
+    }
+
+    FixedPointNumber operator*(const FixedPointNumber &other) const noexcept
+    {
+        int64_t temp = this->m_fixed_point_state;
+        temp *= other.m_fixed_point_state;
+
+        // rounding!
+        if (!truncate_results)
+        {
+            temp = temp + ((temp & 1 << (FractionalBitSize - 1)) << 1);
+        }
+        temp >>= FractionalBitSize;
+        FixedPointNumber tmp;
+        tmp.m_fixed_point_state = static_cast<decltype(m_fixed_point_state)>(temp);
+        return tmp;
+    }
+
+    FixedPointNumber &operator*=(const FixedPointNumber &other) noexcept
+    {
+        int64_t temp = this->m_fixed_point_state;
+        temp *= other.m_fixed_point_state;
+
+        // rounding!
+        if (!truncate_results)
+        {
+            temp = temp + ((temp & 1 << (FractionalBitSize - 1)) << 1);
+        }
+        temp >>= FractionalBitSize;
+        this->m_fixed_point_state = static_cast<decltype(m_fixed_point_state)>(temp);
+        return *this;
+    }
+
+    FixedPointNumber operator/(const FixedPointNumber &other) const noexcept
+    {
+        int64_t temp = this->m_fixed_point_state;
+        temp <<= FractionalBitSize;
+        temp /= static_cast<int64_t>(other.m_fixed_point_state);
+        FixedPointNumber tmp;
+        tmp.m_fixed_point_state = static_cast<decltype(m_fixed_point_state)>(temp);
+        return tmp;
+    }
+
+    FixedPointNumber &operator/=(const FixedPointNumber &other) noexcept
+    {
+        int64_t temp = this->m_fixed_point_state;
+        temp <<= FractionalBitSize;
+        temp /= static_cast<int64_t>(other.m_fixed_point_state);
+        FixedPointNumber tmp;
+        this->m_fixed_point_state = static_cast<decltype(m_fixed_point_state)>(temp);
+        return *this;
+    }
+};
+
+static_assert(4 == sizeof(FixedPointNumber<1>), "FP19 has wrong size != 4");
+}
+#endif // FIXED_POINT_NUMBER_HPP
@@ -1,10 +1,36 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
 #ifndef HIDDEN_MARKOV_MODEL
 #define HIDDEN_MARKOV_MODEL

-#include "util/integer_range.hpp"
+#include "../util/integer_range.hpp"

 #include <boost/assert.hpp>
-#include <boost/math/constants/constants.hpp>

 #include <cmath>

@@ -13,15 +39,14 @@

 namespace osrm
 {
-namespace engine
+namespace matching
 {
-namespace map_matching
-{
-
-static const double log_2_pi = std::log(2. * boost::math::constants::pi<double>());
+static const double log_2_pi = std::log(2. * M_PI);
 static const double IMPOSSIBLE_LOG_PROB = -std::numeric_limits<double>::infinity();
 static const double MINIMAL_LOG_PROB = std::numeric_limits<double>::lowest();
 static const std::size_t INVALID_STATE = std::numeric_limits<std::size_t>::max();
+} // namespace matching
+} // namespace osrm

 // closures to precompute log -> only simple floating point operations
 struct EmissionLogProbability
@@ -35,7 +60,8 @@ struct EmissionLogProbability

    double operator()(const double distance) const
    {
-        return -0.5 * (log_2_pi + (distance / sigma_z) * (distance / sigma_z)) - log_sigma_z;
+        return -0.5 * (osrm::matching::log_2_pi + (distance / sigma_z) * (distance / sigma_z)) -
+               log_sigma_z;
    }
 };

@@ -52,32 +78,35 @@ template <class CandidateLists> struct HiddenMarkovModel
 {
    std::vector<std::vector<double>> viterbi;
    std::vector<std::vector<std::pair<unsigned, unsigned>>> parents;
-    std::vector<std::vector<float>> path_distances;
+    std::vector<std::vector<float>> path_lengths;
    std::vector<std::vector<bool>> pruned;
+    std::vector<std::vector<bool>> suspicious;
    std::vector<bool> breakage;

    const CandidateLists &candidates_list;
-    const std::vector<std::vector<double>> &emission_log_probabilities;
+    const EmissionLogProbability &emission_log_probability;

    HiddenMarkovModel(const CandidateLists &candidates_list,
-                      const std::vector<std::vector<double>> &emission_log_probabilities)
+                      const EmissionLogProbability &emission_log_probability)
        : breakage(candidates_list.size()), candidates_list(candidates_list),
-          emission_log_probabilities(emission_log_probabilities)
+          emission_log_probability(emission_log_probability)
    {
        viterbi.resize(candidates_list.size());
        parents.resize(candidates_list.size());
-        path_distances.resize(candidates_list.size());
+        path_lengths.resize(candidates_list.size());
+        suspicious.resize(candidates_list.size());
        pruned.resize(candidates_list.size());
        breakage.resize(candidates_list.size());
-        for (const auto i : util::irange<std::size_t>(0u, candidates_list.size()))
+        for (const auto i : osrm::irange<std::size_t>(0u, candidates_list.size()))
        {
-            const auto &num_candidates = candidates_list[i].size();
+            const auto& num_candidates = candidates_list[i].size();
            // add empty vectors
            if (num_candidates > 0)
            {
                viterbi[i].resize(num_candidates);
                parents[i].resize(num_candidates);
-                path_distances[i].resize(num_candidates);
+                path_lengths[i].resize(num_candidates);
+                suspicious[i].resize(num_candidates);
                pruned[i].resize(num_candidates);
            }
        }
@@ -87,14 +116,15 @@ template <class CandidateLists> struct HiddenMarkovModel

    void clear(std::size_t initial_timestamp)
    {
-        BOOST_ASSERT(viterbi.size() == parents.size() && parents.size() == path_distances.size() &&
-                     path_distances.size() == pruned.size() && pruned.size() == breakage.size());
+        BOOST_ASSERT(viterbi.size() == parents.size() && parents.size() == path_lengths.size() &&
+                     path_lengths.size() == pruned.size() && pruned.size() == breakage.size());

-        for (const auto t : util::irange(initial_timestamp, viterbi.size()))
+        for (const auto t : osrm::irange(initial_timestamp, viterbi.size()))
        {
-            std::fill(viterbi[t].begin(), viterbi[t].end(), IMPOSSIBLE_LOG_PROB);
+            std::fill(viterbi[t].begin(), viterbi[t].end(), osrm::matching::IMPOSSIBLE_LOG_PROB);
            std::fill(parents[t].begin(), parents[t].end(), std::make_pair(0u, 0u));
-            std::fill(path_distances[t].begin(), path_distances[t].end(), 0);
+            std::fill(path_lengths[t].begin(), path_lengths[t].end(), 0);
+            std::fill(suspicious[t].begin(), suspicious[t].end(), true);
            std::fill(pruned[t].begin(), pruned[t].end(), true);
        }
        std::fill(breakage.begin() + initial_timestamp, breakage.end(), true);
@@ -107,11 +137,14 @@ template <class CandidateLists> struct HiddenMarkovModel
        {
            BOOST_ASSERT(initial_timestamp < num_points);

-            for (const auto s : util::irange<std::size_t>(0u, viterbi[initial_timestamp].size()))
+            for (const auto s : osrm::irange<std::size_t>(0u, viterbi[initial_timestamp].size()))
            {
-                viterbi[initial_timestamp][s] = emission_log_probabilities[initial_timestamp][s];
+                viterbi[initial_timestamp][s] =
+                    emission_log_probability(candidates_list[initial_timestamp][s].distance);
                parents[initial_timestamp][s] = std::make_pair(initial_timestamp, s);
-                pruned[initial_timestamp][s] = viterbi[initial_timestamp][s] < MINIMAL_LOG_PROB;
+                pruned[initial_timestamp][s] =
+                    viterbi[initial_timestamp][s] < osrm::matching::MINIMAL_LOG_PROB;
+                suspicious[initial_timestamp][s] = false;

                breakage[initial_timestamp] =
                    breakage[initial_timestamp] && pruned[initial_timestamp][s];
@@ -122,7 +155,7 @@ template <class CandidateLists> struct HiddenMarkovModel

        if (initial_timestamp >= num_points)
        {
-            return INVALID_STATE;
+            return osrm::matching::INVALID_STATE;
        }

        BOOST_ASSERT(initial_timestamp > 0);
@@ -133,8 +166,5 @@ template <class CandidateLists> struct HiddenMarkovModel
        return initial_timestamp;
    }
 };
-}
-}
-}

 #endif // HIDDEN_MARKOV_MODEL
@@ -0,0 +1,100 @@
+/*
+
+Copyright (c) 2014, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#include "hilbert_value.hpp"
+
+#include <osrm/coordinate.hpp>
+
+uint64_t HilbertCode::operator()(const FixedPointCoordinate &current_coordinate) const
+{
+    unsigned location[2];
+    location[0] = current_coordinate.lat + static_cast<int>(90 * COORDINATE_PRECISION);
+    location[1] = current_coordinate.lon + static_cast<int>(180 * COORDINATE_PRECISION);
+
+    TransposeCoordinate(location);
+    return BitInterleaving(location[0], location[1]);
+}
+
+uint64_t HilbertCode::BitInterleaving(const uint32_t latitude, const uint32_t longitude) const
+{
+    uint64_t result = 0;
+    for (int8_t index = 31; index >= 0; --index)
+    {
+        result |= (latitude >> index) & 1;
+        result <<= 1;
+        result |= (longitude >> index) & 1;
+        if (0 != index)
+        {
+            result <<= 1;
+        }
+    }
+    return result;
+}
+
+void HilbertCode::TransposeCoordinate(uint32_t *X) const
+{
+    uint32_t M = 1u << (32 - 1), P, Q, t;
+    int i;
+    // Inverse undo
+    for (Q = M; Q > 1; Q >>= 1)
+    {
+        P = Q - 1;
+        for (i = 0; i < 2; ++i)
+        {
+
+            const bool condition = (X[i] & Q);
+            if (condition)
+            {
+                X[0] ^= P; // invert
+            }
+            else
+            {
+                t = (X[0] ^ X[i]) & P;
+                X[0] ^= t;
+                X[i] ^= t;
+            }
+        } // exchange
+    }
+    // Gray encode
+    for (i = 1; i < 2; ++i)
+    {
+        X[i] ^= X[i - 1];
+    }
+    t = 0;
+    for (Q = M; Q > 1; Q >>= 1)
+    {
+        const bool condition = (X[2 - 1] & Q);
+        if (condition)
+        {
+            t ^= Q - 1;
+        }
+    } // check if this for loop is wrong
+    for (i = 0; i < 2; ++i)
+    {
+        X[i] ^= t;
+    }
+}
@@ -1,6 +1,6 @@
 /*

-Copyright (c) 2016, Project OSRM contributors
+Copyright (c) 2014, Project OSRM contributors
 All rights reserved.

 Redistribution and use in source and binary forms, with or without modification,
@@ -25,28 +25,25 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

-#ifndef OSRM_ENGINE_BEARING_HPP
-#define OSRM_ENGINE_BEARING_HPP
+#ifndef HILBERT_VALUE_HPP
+#define HILBERT_VALUE_HPP

-namespace osrm
-{
-namespace engine
-{
+#include <cstdint>

-struct Bearing
-{
-    short bearing;
-    short range;
+// computes a 64 bit value that corresponds to the hilbert space filling curve

-    bool IsValid() const { return bearing >= 0 && bearing <= 360 && range >= 0 && range <= 180; }
+struct FixedPointCoordinate;
+
+class HilbertCode
+{
+  public:
+    uint64_t operator()(const FixedPointCoordinate &current_coordinate) const;
+    HilbertCode() {}
+    HilbertCode(const HilbertCode &) = delete;
+
+  private:
+    inline uint64_t BitInterleaving(const uint32_t a, const uint32_t b) const;
+    inline void TransposeCoordinate(uint32_t *X) const;
 };

-inline bool operator==(const Bearing lhs, const Bearing rhs)
-{
-    return lhs.bearing == rhs.bearing && lhs.range == rhs.range;
-}
-inline bool operator!=(const Bearing lhs, const Bearing rhs) { return !(lhs == rhs); }
-}
-}
-
-#endif
+#endif /* HILBERT_VALUE_HPP */
@@ -0,0 +1,113 @@
+/*
+
+Copyright (c) 2014, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#include "import_edge.hpp"
+
+#include "travel_mode.hpp"
+#include "../typedefs.h"
+
+bool NodeBasedEdge::operator<(const NodeBasedEdge &other) const
+{
+    if (source == other.source)
+    {
+        if (target == other.target)
+        {
+            if (weight == other.weight)
+            {
+                return forward && backward && ((!other.forward) || (!other.backward));
+            }
+            return weight < other.weight;
+        }
+        return target < other.target;
+    }
+    return source < other.source;
+}
+
+NodeBasedEdge::NodeBasedEdge()
+    : source(SPECIAL_NODEID), target(SPECIAL_NODEID), name_id(0), weight(0), forward(false),
+      backward(false), roundabout(false),
+      access_restricted(false), startpoint(true), is_split(false), travel_mode(false)
+{
+}
+
+NodeBasedEdge::NodeBasedEdge(NodeID source,
+                             NodeID target,
+                             NodeID name_id,
+                             EdgeWeight weight,
+                             bool forward,
+                             bool backward,
+                             bool roundabout,
+                             bool access_restricted,
+                             bool startpoint,
+                             TravelMode travel_mode,
+                             bool is_split)
+    : source(source), target(target), name_id(name_id), weight(weight), forward(forward),
+      backward(backward), roundabout(roundabout),
+      access_restricted(access_restricted), startpoint(startpoint), is_split(is_split), travel_mode(travel_mode)
+{
+}
+
+bool EdgeBasedEdge::operator<(const EdgeBasedEdge &other) const
+{
+    if (source == other.source)
+    {
+        if (target == other.target)
+        {
+            if (weight == other.weight)
+            {
+                return forward && backward && ((!other.forward) || (!other.backward));
+            }
+            return weight < other.weight;
+        }
+        return target < other.target;
+    }
+    return source < other.source;
+}
+
+template <class EdgeT>
+EdgeBasedEdge::EdgeBasedEdge(const EdgeT &other)
+    : source(other.source), target(other.target), edge_id(other.data.via),
+      weight(other.data.distance), forward(other.data.forward), backward(other.data.backward)
+{
+}
+
+/** Default constructor. target and weight are set to 0.*/
+EdgeBasedEdge::EdgeBasedEdge()
+    : source(0), target(0), edge_id(0), weight(0), forward(false), backward(false)
+{
+}
+
+EdgeBasedEdge::EdgeBasedEdge(const NodeID source,
+                             const NodeID target,
+                             const NodeID edge_id,
+                             const EdgeWeight weight,
+                             const bool forward,
+                             const bool backward)
+    : source(source), target(target), edge_id(edge_id), weight(weight), forward(forward),
+      backward(backward)
+{
+}
@@ -0,0 +1,108 @@
+/*
+
+Copyright (c) 2013, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef IMPORT_EDGE_HPP
+#define IMPORT_EDGE_HPP
+
+#include "../data_structures/travel_mode.hpp"
+#include "../typedefs.h"
+
+struct NodeBasedEdge
+{
+    bool operator<(const NodeBasedEdge &e) const;
+
+    NodeBasedEdge();
+    explicit NodeBasedEdge(NodeID source,
+                           NodeID target,
+                           NodeID name_id,
+                           EdgeWeight weight,
+                           bool forward,
+                           bool backward,
+                           bool roundabout,
+                           bool access_restricted,
+                           bool startpoint,
+                           TravelMode travel_mode,
+                           bool is_split);
+
+    NodeID source;
+    NodeID target;
+    NodeID name_id;
+    EdgeWeight weight;
+    bool forward : 1;
+    bool backward : 1;
+    bool roundabout : 1;
+    bool access_restricted : 1;
+    bool startpoint : 1;
+    bool is_split : 1;
+    TravelMode travel_mode : 4;
+};
+
+struct NodeBasedEdgeWithOSM : NodeBasedEdge
+{
+    explicit NodeBasedEdgeWithOSM(OSMNodeID source,
+                           OSMNodeID target,
+                           NodeID name_id,
+                           EdgeWeight weight,
+                           bool forward,
+                           bool backward,
+                           bool roundabout,
+                           bool access_restricted,
+                           bool startpoint,
+                           TravelMode travel_mode,
+                           bool is_split)
+        : NodeBasedEdge(SPECIAL_NODEID, SPECIAL_NODEID, name_id, weight, forward, backward, roundabout, access_restricted, startpoint, travel_mode, is_split),
+        osm_source_id(source), osm_target_id(target) {}
+
+    OSMNodeID osm_source_id;
+    OSMNodeID osm_target_id;
+};
+
+struct EdgeBasedEdge
+{
+
+  public:
+    bool operator<(const EdgeBasedEdge &e) const;
+
+    template <class EdgeT> explicit EdgeBasedEdge(const EdgeT &myEdge);
+
+    EdgeBasedEdge();
+
+    explicit EdgeBasedEdge(const NodeID source,
+                           const NodeID target,
+                           const NodeID edge_id,
+                           const EdgeWeight weight,
+                           const bool forward,
+                           const bool backward);
+    NodeID source;
+    NodeID target;
+    NodeID edge_id;
+    EdgeWeight weight : 30;
+    bool forward : 1;
+    bool backward : 1;
+};
+
+#endif /* IMPORT_EDGE_HPP */
@@ -0,0 +1,87 @@
+/*
+
+Copyright (c) 2013, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef RAW_ROUTE_DATA_H
+#define RAW_ROUTE_DATA_H
+
+#include "../data_structures/phantom_node.hpp"
+#include "../data_structures/travel_mode.hpp"
+#include "../data_structures/turn_instructions.hpp"
+#include "../typedefs.h"
+
+#include <osrm/coordinate.hpp>
+
+#include <vector>
+
+struct PathData
+{
+    PathData()
+        : node(SPECIAL_NODEID), name_id(INVALID_EDGE_WEIGHT), segment_duration(INVALID_EDGE_WEIGHT),
+          turn_instruction(TurnInstruction::NoTurn), travel_mode(TRAVEL_MODE_INACCESSIBLE)
+    {
+    }
+
+    PathData(NodeID node,
+             unsigned name_id,
+             TurnInstruction turn_instruction,
+             EdgeWeight segment_duration,
+             TravelMode travel_mode)
+        : node(node), name_id(name_id), segment_duration(segment_duration),
+          turn_instruction(turn_instruction), travel_mode(travel_mode)
+    {
+    }
+    NodeID node;
+    unsigned name_id;
+    EdgeWeight segment_duration;
+    TurnInstruction turn_instruction;
+    TravelMode travel_mode : 4;
+};
+
+struct InternalRouteResult
+{
+    std::vector<std::vector<PathData>> unpacked_path_segments;
+    std::vector<PathData> unpacked_alternative;
+    std::vector<PhantomNodes> segment_end_coordinates;
+    std::vector<bool> source_traversed_in_reverse;
+    std::vector<bool> target_traversed_in_reverse;
+    std::vector<bool> alt_source_traversed_in_reverse;
+    std::vector<bool> alt_target_traversed_in_reverse;
+    int shortest_path_length;
+    int alternative_path_length;
+
+    bool is_via_leg(const std::size_t leg) const
+    {
+        return (leg != unpacked_path_segments.size() - 1);
+    }
+
+    InternalRouteResult()
+        : shortest_path_length(INVALID_EDGE_WEIGHT), alternative_path_length(INVALID_EDGE_WEIGHT)
+    {
+    }
+};
+
+#endif // RAW_ROUTE_DATA_H
@@ -0,0 +1,97 @@
+/*
+
+Copyright (c) 2014, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef LRUCACHE_HPP
+#define LRUCACHE_HPP
+
+#include <list>
+#include <unordered_map>
+
+template <typename KeyT, typename ValueT> class LRUCache
+{
+  private:
+    struct CacheEntry
+    {
+        CacheEntry(KeyT k, ValueT v) : key(k), value(v) {}
+        KeyT key;
+        ValueT value;
+    };
+    unsigned capacity;
+    std::list<CacheEntry> itemsInCache;
+    std::unordered_map<KeyT, typename std::list<CacheEntry>::iterator> positionMap;
+
+  public:
+    explicit LRUCache(unsigned c) : capacity(c) {}
+
+    bool Holds(KeyT key)
+    {
+        if (positionMap.find(key) != positionMap.end())
+        {
+            return true;
+        }
+        return false;
+    }
+
+    void Insert(const KeyT key, ValueT &value)
+    {
+        itemsInCache.push_front(CacheEntry(key, value));
+        positionMap.insert(std::make_pair(key, itemsInCache.begin()));
+        if (itemsInCache.size() > capacity)
+        {
+            positionMap.erase(itemsInCache.back().key);
+            itemsInCache.pop_back();
+        }
+    }
+
+    void Insert(const KeyT key, ValueT value)
+    {
+        itemsInCache.push_front(CacheEntry(key, value));
+        positionMap.insert(std::make_pair(key, itemsInCache.begin()));
+        if (itemsInCache.size() > capacity)
+        {
+            positionMap.erase(itemsInCache.back().key);
+            itemsInCache.pop_back();
+        }
+    }
+
+    bool Fetch(const KeyT key, ValueT &result)
+    {
+        if (Holds(key))
+        {
+            CacheEntry e = *(positionMap.find(key)->second);
+            result = e.value;
+
+            // move to front
+            itemsInCache.splice(itemsInCache.begin(), itemsInCache, positionMap.find(key)->second);
+            positionMap.find(key)->second = itemsInCache.begin();
+            return true;
+        }
+        return false;
+    }
+    unsigned Size() const { return itemsInCache.size(); }
+};
+#endif // LRUCACHE_HPP
@@ -0,0 +1,70 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef MATRIX_GRAPH_WRAPPER_H
+#define MATRIX_GRAPH_WRAPPER_H
+
+#include <vector>
+#include <cstddef>
+#include <iterator>
+
+#include "../typedefs.h"
+
+// This Wrapper provides all methods that are needed for TarjanSCC, when the graph is given in a
+// matrix representation (e.g. as output from a distance table call)
+
+template <typename T> class MatrixGraphWrapper
+{
+  public:
+    MatrixGraphWrapper(std::vector<T> table, const std::size_t number_of_nodes)
+        : table_(std::move(table)), number_of_nodes_(number_of_nodes){};
+
+    std::size_t GetNumberOfNodes() const { return number_of_nodes_; }
+
+    std::vector<T> GetAdjacentEdgeRange(const NodeID node) const
+    {
+
+        std::vector<T> edges;
+        // find all valid adjacent edges and move to vector `edges`
+        for (std::size_t i = 0; i < number_of_nodes_; ++i)
+        {
+            if (*(std::begin(table_) + node * number_of_nodes_ + i) != INVALID_EDGE_WEIGHT)
+            {
+                edges.push_back(i);
+            }
+        }
+        return edges;
+    }
+
+    EdgeWeight GetTarget(const EdgeWeight edge) const { return edge; }
+
+  private:
+    const std::vector<T> table_;
+    const std::size_t number_of_nodes_;
+};
+
+#endif // MATRIX_GRAPH_WRAPPER_H
@@ -0,0 +1,103 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef NODE_BASED_GRAPH_HPP
+#define NODE_BASED_GRAPH_HPP
+
+#include "dynamic_graph.hpp"
+#include "import_edge.hpp"
+#include "../util/graph_utils.hpp"
+
+#include <tbb/parallel_sort.h>
+
+#include <memory>
+
+struct NodeBasedEdgeData
+{
+    NodeBasedEdgeData()
+        : distance(INVALID_EDGE_WEIGHT), edge_id(SPECIAL_NODEID),
+          name_id(std::numeric_limits<unsigned>::max()), access_restricted(false),
+          reversed(false), roundabout(false), travel_mode(TRAVEL_MODE_INACCESSIBLE)
+    {
+    }
+
+    NodeBasedEdgeData(int distance, unsigned edge_id, unsigned name_id,
+            bool access_restricted, bool reversed,
+            bool roundabout, bool startpoint, TravelMode travel_mode)
+        : distance(distance), edge_id(edge_id), name_id(name_id),
+          access_restricted(access_restricted), reversed(reversed),
+          roundabout(roundabout), startpoint(startpoint), travel_mode(travel_mode)
+    {
+    }
+
+    int distance;
+    unsigned edge_id;
+    unsigned name_id;
+    bool access_restricted : 1;
+    bool reversed : 1;
+    bool roundabout : 1;
+    bool startpoint : 1;
+    TravelMode travel_mode : 4;
+
+    bool IsCompatibleTo(const NodeBasedEdgeData &other) const
+    {
+        return (reversed == other.reversed) && (name_id == other.name_id) &&
+               (travel_mode == other.travel_mode);
+    }
+};
+
+using NodeBasedDynamicGraph = DynamicGraph<NodeBasedEdgeData>;
+
+/// Factory method to create NodeBasedDynamicGraph from NodeBasedEdges
+/// Since DynamicGraph expects directed edges, we need to insert
+/// two edges for undirected edges.
+inline std::shared_ptr<NodeBasedDynamicGraph>
+NodeBasedDynamicGraphFromEdges(std::size_t number_of_nodes, const std::vector<NodeBasedEdge> &input_edge_list)
+{
+    auto edges_list = directedEdgesFromCompressed<NodeBasedDynamicGraph::InputEdge>(input_edge_list,
+        [](NodeBasedDynamicGraph::InputEdge& output_edge, const NodeBasedEdge& input_edge)
+        {
+            output_edge.data.distance = static_cast<int>(input_edge.weight);
+            BOOST_ASSERT(output_edge.data.distance > 0);
+
+            output_edge.data.roundabout = input_edge.roundabout;
+            output_edge.data.name_id = input_edge.name_id;
+            output_edge.data.access_restricted = input_edge.access_restricted;
+            output_edge.data.travel_mode = input_edge.travel_mode;
+            output_edge.data.startpoint = input_edge.startpoint;
+        }
+    );
+
+    tbb::parallel_sort(edges_list.begin(), edges_list.end());
+
+    auto graph = std::make_shared<NodeBasedDynamicGraph>(
+        static_cast<NodeBasedDynamicGraph::NodeIterator>(number_of_nodes), edges_list);
+
+    return graph;
+}
+
+#endif // NODE_BASED_GRAPH_HPP
@@ -1,6 +1,6 @@
 /*

-Copyright (c) 2016, Project OSRM contributors
+Copyright (c) 2014, Project OSRM contributors
 All rights reserved.

 Redistribution and use in source and binary forms, with or without modification,
@@ -25,26 +25,17 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

-#ifndef ENGINE_API_TRIP_PARAMETERS_HPP
-#define ENGINE_API_TRIP_PARAMETERS_HPP
+#ifndef NODE_ID_HPP
+#define NODE_ID_HPP

-#include "engine/api/route_parameters.hpp"
+#include "../typedefs.h"

-#include <vector>
-
-namespace osrm
+struct Cmp
 {
-namespace engine
-{
-namespace api
-{
-
-struct TripParameters : public RouteParameters
-{
-    // bool IsValid() const; Falls back to base class
+    using value_type = OSMNodeID;
+    bool operator()(const value_type left, const value_type right) const { return left < right; }
+    value_type max_value() { return MAX_OSM_NODEID; }
+    value_type min_value() { return MIN_OSM_NODEID; }
 };
-}
-}
-}

-#endif
+#endif // NODE_ID_HPP
@@ -0,0 +1,63 @@
+/*
+
+Copyright (c) 2014, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef ORIGINAL_EDGE_DATA_HPP
+#define ORIGINAL_EDGE_DATA_HPP
+
+#include "travel_mode.hpp"
+#include "turn_instructions.hpp"
+#include "../typedefs.h"
+
+#include <limits>
+
+struct OriginalEdgeData
+{
+    explicit OriginalEdgeData(NodeID via_node,
+                              unsigned name_id,
+                              TurnInstruction turn_instruction,
+                              bool compressed_geometry,
+                              TravelMode travel_mode)
+        : via_node(via_node), name_id(name_id), turn_instruction(turn_instruction),
+          compressed_geometry(compressed_geometry), travel_mode(travel_mode)
+    {
+    }
+
+    OriginalEdgeData()
+        : via_node(std::numeric_limits<unsigned>::max()),
+          name_id(std::numeric_limits<unsigned>::max()), turn_instruction(TurnInstruction::NoTurn),
+          compressed_geometry(false), travel_mode(TRAVEL_MODE_INACCESSIBLE)
+    {
+    }
+
+    NodeID via_node;
+    unsigned name_id;
+    TurnInstruction turn_instruction;
+    bool compressed_geometry;
+    TravelMode travel_mode;
+};
+
+#endif // ORIGINAL_EDGE_DATA_HPP
@@ -1,14 +1,36 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
 #ifndef PERCENT_HPP
 #define PERCENT_HPP

 #include <iostream>
 #include <atomic>

-namespace osrm
-{
-namespace util
-{
-
 class Percent
 {
  public:
@@ -75,7 +97,5 @@ class Percent
        }
    }
 };
-}
-}

 #endif // PERCENT_HPP
@@ -0,0 +1,105 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#include "phantom_node.hpp"
+
+#include "../typedefs.h"
+#include "travel_mode.hpp"
+
+#include <osrm/coordinate.hpp>
+
+#include <limits>
+
+PhantomNode::PhantomNode(NodeID forward_node_id,
+                         NodeID reverse_node_id,
+                         unsigned name_id,
+                         int forward_weight,
+                         int reverse_weight,
+                         int forward_offset,
+                         int reverse_offset,
+                         unsigned packed_geometry_id,
+                         bool is_tiny_component,
+                         unsigned component_id,
+                         FixedPointCoordinate &location,
+                         unsigned short fwd_segment_position,
+                         TravelMode forward_travel_mode,
+                         TravelMode backward_travel_mode)
+    : forward_node_id(forward_node_id), reverse_node_id(reverse_node_id), name_id(name_id),
+      forward_weight(forward_weight), reverse_weight(reverse_weight),
+      forward_offset(forward_offset), reverse_offset(reverse_offset),
+      packed_geometry_id(packed_geometry_id), component{component_id, is_tiny_component}, location(location),
+      fwd_segment_position(fwd_segment_position), forward_travel_mode(forward_travel_mode),
+      backward_travel_mode(backward_travel_mode)
+{
+}
+
+PhantomNode::PhantomNode()
+    : forward_node_id(SPECIAL_NODEID), reverse_node_id(SPECIAL_NODEID),
+      name_id(std::numeric_limits<unsigned>::max()), forward_weight(INVALID_EDGE_WEIGHT),
+      reverse_weight(INVALID_EDGE_WEIGHT), forward_offset(0), reverse_offset(0),
+      packed_geometry_id(SPECIAL_EDGEID), component{INVALID_COMPONENTID, false},
+      fwd_segment_position(0), forward_travel_mode(TRAVEL_MODE_INACCESSIBLE),
+      backward_travel_mode(TRAVEL_MODE_INACCESSIBLE)
+{
+}
+
+int PhantomNode::GetForwardWeightPlusOffset() const
+{
+    if (SPECIAL_NODEID == forward_node_id)
+    {
+        return 0;
+    }
+    return forward_offset + forward_weight;
+}
+
+int PhantomNode::GetReverseWeightPlusOffset() const
+{
+    if (SPECIAL_NODEID == reverse_node_id)
+    {
+        return 0;
+    }
+    return reverse_offset + reverse_weight;
+}
+
+bool PhantomNode::is_bidirected() const
+{
+    return (forward_node_id != SPECIAL_NODEID) && (reverse_node_id != SPECIAL_NODEID);
+}
+
+bool PhantomNode::is_compressed() const { return (forward_offset != 0) || (reverse_offset != 0); }
+
+bool PhantomNode::is_valid(const unsigned number_of_nodes) const
+{
+    return location.is_valid() &&
+           ((forward_node_id < number_of_nodes) || (reverse_node_id < number_of_nodes)) &&
+           ((forward_weight != INVALID_EDGE_WEIGHT) || (reverse_weight != INVALID_EDGE_WEIGHT)) &&
+           (component.id != INVALID_COMPONENTID) && (name_id != INVALID_NAMEID);
+}
+
+bool PhantomNode::is_valid() const { return location.is_valid() && (name_id != INVALID_NAMEID); }
+
+bool PhantomNode::operator==(const PhantomNode &other) const { return location == other.location; }
@@ -1,6 +1,6 @@
 /*

-Copyright (c) 2016, Project OSRM contributors
+Copyright (c) 2015, Project OSRM contributors
 All rights reserved.

 Redistribution and use in source and binary forms, with or without modification,
@@ -28,20 +28,15 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef PHANTOM_NODES_H
 #define PHANTOM_NODES_H

-#include "extractor/travel_mode.hpp"
-#include "util/typedefs.hpp"
+#include "travel_mode.hpp"
+#include "../typedefs.h"

-#include "osrm/coordinate.hpp"
+#include <osrm/coordinate.hpp>

 #include <iostream>
 #include <utility>
 #include <vector>

-namespace osrm
-{
-namespace engine
-{
-
 struct PhantomNode
 {
    PhantomNode(NodeID forward_node_id,
@@ -51,94 +46,29 @@ struct PhantomNode
                int reverse_weight,
                int forward_offset,
                int reverse_offset,
-                unsigned forward_packed_geometry_id_,
-                unsigned reverse_packed_geometry_id_,
+                unsigned packed_geometry_id,
                bool is_tiny_component,
                unsigned component_id,
-                util::Coordinate location,
+                FixedPointCoordinate &location,
                unsigned short fwd_segment_position,
-                extractor::TravelMode forward_travel_mode,
-                extractor::TravelMode backward_travel_mode)
-        : forward_node_id(forward_node_id), reverse_node_id(reverse_node_id), name_id(name_id),
-          forward_weight(forward_weight), reverse_weight(reverse_weight),
-          forward_offset(forward_offset), reverse_offset(reverse_offset),
-          forward_packed_geometry_id(forward_packed_geometry_id_),
-          reverse_packed_geometry_id(reverse_packed_geometry_id_),
-          component{component_id, is_tiny_component}, location(std::move(location)),
-          fwd_segment_position(fwd_segment_position), forward_travel_mode(forward_travel_mode),
-          backward_travel_mode(backward_travel_mode)
-    {
-    }
+                TravelMode forward_travel_mode,
+                TravelMode backward_travel_mode);

-    PhantomNode()
-        : forward_node_id(SPECIAL_NODEID), reverse_node_id(SPECIAL_NODEID),
-          name_id(std::numeric_limits<unsigned>::max()), forward_weight(INVALID_EDGE_WEIGHT),
-          reverse_weight(INVALID_EDGE_WEIGHT), forward_offset(0), reverse_offset(0),
-          forward_packed_geometry_id(SPECIAL_EDGEID), reverse_packed_geometry_id(SPECIAL_EDGEID),
-          component{INVALID_COMPONENTID, false}, fwd_segment_position(0),
-          forward_travel_mode(TRAVEL_MODE_INACCESSIBLE),
-          backward_travel_mode(TRAVEL_MODE_INACCESSIBLE)
-    {
-    }
+    PhantomNode();

-    int GetForwardWeightPlusOffset() const
-    {
-        if (SPECIAL_NODEID == forward_node_id)
-        {
-            return 0;
-        }
-        return forward_offset + forward_weight;
-    }
-
-    int GetReverseWeightPlusOffset() const
-    {
-        if (SPECIAL_NODEID == reverse_node_id)
-        {
-            return 0;
-        }
-        return reverse_offset + reverse_weight;
-    }
-
-    bool IsBidirected() const
-    {
-        return (forward_node_id != SPECIAL_NODEID) && (reverse_node_id != SPECIAL_NODEID);
-    }
-
-    bool IsCompressed() const { return (forward_offset != 0) || (reverse_offset != 0); }
-
-    bool IsValid(const unsigned number_of_nodes) const
-    {
-        return location.IsValid() &&
-               ((forward_node_id < number_of_nodes) || (reverse_node_id < number_of_nodes)) &&
-               ((forward_weight != INVALID_EDGE_WEIGHT) ||
-                (reverse_weight != INVALID_EDGE_WEIGHT)) &&
-               (component.id != INVALID_COMPONENTID) && (name_id != INVALID_NAMEID);
-    }
-
-    bool IsValid() const { return location.IsValid() && (name_id != INVALID_NAMEID); }
-
-    bool operator==(const PhantomNode &other) const { return location == other.location; }
-
-    template <class OtherT>
-    explicit PhantomNode(const OtherT &other,
-                         int forward_weight_,
-                         int forward_offset_,
-                         int reverse_weight_,
-                         int reverse_offset_,
-                         const util::Coordinate foot_point)
+    template <class OtherT> PhantomNode(const OtherT &other, const FixedPointCoordinate &foot_point)
    {
        forward_node_id = other.forward_edge_based_node_id;
        reverse_node_id = other.reverse_edge_based_node_id;
        name_id = other.name_id;

-        forward_weight = forward_weight_;
-        reverse_weight = reverse_weight_;
+        forward_weight = other.forward_weight;
+        reverse_weight = other.reverse_weight;

-        forward_offset = forward_offset_;
-        reverse_offset = reverse_offset_;
+        forward_offset = other.forward_offset;
+        reverse_offset = other.reverse_offset;

-        forward_packed_geometry_id = other.forward_packed_geometry_id;
-        reverse_packed_geometry_id = other.reverse_packed_geometry_id;
+        packed_geometry_id = other.packed_geometry_id;

        component.id = other.component.id;
        component.is_tiny = other.component.is_tiny;
@@ -157,10 +87,8 @@ struct PhantomNode
    int reverse_weight;
    int forward_offset;
    int reverse_offset;
-    unsigned forward_packed_geometry_id;
-    unsigned reverse_packed_geometry_id;
-    struct ComponentType
-    {
+    unsigned packed_geometry_id;
+    struct ComponentType {
        uint32_t id : 31;
        bool is_tiny : 1;
    } component;
@@ -168,16 +96,30 @@ struct PhantomNode
 #ifndef _MSC_VER
    static_assert(sizeof(ComponentType) == 4, "ComponentType needs to 4 bytes big");
 #endif
-    util::Coordinate location;
+    FixedPointCoordinate location;
    unsigned short fwd_segment_position;
    // note 4 bits would suffice for each,
    // but the saved byte would be padding anyway
-    extractor::TravelMode forward_travel_mode;
-    extractor::TravelMode backward_travel_mode;
+    TravelMode forward_travel_mode;
+    TravelMode backward_travel_mode;
+
+    int GetForwardWeightPlusOffset() const;
+
+    int GetReverseWeightPlusOffset() const;
+
+    bool is_bidirected() const;
+
+    bool is_compressed() const;
+
+    bool is_valid(const unsigned numberOfNodes) const;
+
+    bool is_valid() const;
+
+    bool operator==(const PhantomNode &other) const;
 };

 #ifndef _MSC_VER
-static_assert(sizeof(PhantomNode) == 52, "PhantomNode has more padding then expected");
+static_assert(sizeof(PhantomNode) == 48, "PhantomNode has more padding then expected");
 #endif

 using PhantomNodePair = std::pair<PhantomNode, PhantomNode>;
@@ -210,14 +152,11 @@ inline std::ostream &operator<<(std::ostream &out, const PhantomNode &pn)
        << "rev-w: " << pn.reverse_weight << ", "
        << "fwd-o: " << pn.forward_offset << ", "
        << "rev-o: " << pn.reverse_offset << ", "
-        << "fwd_geom: " << pn.forward_packed_geometry_id << ", "
-        << "rev_geom: " << pn.reverse_packed_geometry_id << ", "
+        << "geom: " << pn.packed_geometry_id << ", "
        << "comp: " << pn.component.is_tiny << " / " << pn.component.id << ", "
        << "pos: " << pn.fwd_segment_position << ", "
        << "loc: " << pn.location;
    return out;
 }
-}
-}

 #endif // PHANTOM_NODES_H
@@ -1,15 +1,37 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
 #ifndef QUERYEDGE_HPP
 #define QUERYEDGE_HPP

-#include "util/typedefs.hpp"
+#include "../typedefs.h"

 #include <tuple>

-namespace osrm
-{
-namespace contractor
-{
-
 struct QueryEdge
 {
    NodeID source;
@@ -53,7 +75,5 @@ struct QueryEdge
                data.id == right.data.id);
    }
 };
-}
-}

 #endif // QUERYEDGE_HPP
@@ -0,0 +1,85 @@
+/*
+
+Copyright (c) 2014, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef QUERY_NODE_HPP
+#define QUERY_NODE_HPP
+
+#include "../typedefs.h"
+
+#include <boost/assert.hpp>
+
+#include <osrm/coordinate.hpp>
+
+#include <limits>
+
+struct QueryNode
+{
+    using key_type = OSMNodeID; // type of NodeID
+    using value_type = int;  // type of lat,lons
+
+    explicit QueryNode(int lat, int lon, OSMNodeID node_id) : lat(lat), lon(lon), node_id(node_id) {}
+    QueryNode()
+        : lat(std::numeric_limits<int>::max()), lon(std::numeric_limits<int>::max()),
+          node_id(SPECIAL_OSM_NODEID)
+    {
+    }
+
+    int lat;
+    int lon;
+    OSMNodeID node_id;
+
+    static QueryNode min_value()
+    {
+        return QueryNode(static_cast<int>(-90 * COORDINATE_PRECISION),
+                         static_cast<int>(-180 * COORDINATE_PRECISION),
+                         MIN_OSM_NODEID);
+    }
+
+    static QueryNode max_value()
+    {
+        return QueryNode(static_cast<int>(90 * COORDINATE_PRECISION),
+                         static_cast<int>(180 * COORDINATE_PRECISION),
+                         MAX_OSM_NODEID);
+    }
+
+    value_type operator[](const std::size_t n) const
+    {
+        switch (n)
+        {
+        case 1:
+            return lat;
+        case 0:
+            return lon;
+        default:
+            break;
+        }
+        BOOST_ASSERT_MSG(false, "should not happen");
+        return std::numeric_limits<int>::lowest();
+    }
+};
+
+#endif // QUERY_NODE_HPP
@@ -1,17 +1,39 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
 #ifndef RANGE_TABLE_HPP
 #define RANGE_TABLE_HPP

-#include "util/integer_range.hpp"
-#include "util/shared_memory_vector_wrapper.hpp"
+#include "../util/integer_range.hpp"
+#include "shared_memory_factory.hpp"
+#include "shared_memory_vector_wrapper.hpp"

 #include <fstream>
 #include <array>
-#include <utility>
-
-namespace osrm
-{
-namespace util
-{
 /*
 * These pre-declarations are needed because parsing C++ is hard
 * and otherwise the compiler gets confused.
@@ -40,7 +62,7 @@ template <unsigned BLOCK_SIZE, bool USE_SHARED_MEMORY> class RangeTable
    using BlockT = std::array<unsigned char, BLOCK_SIZE>;
    using BlockContainerT = typename ShM<BlockT, USE_SHARED_MEMORY>::vector;
    using OffsetContainerT = typename ShM<unsigned, USE_SHARED_MEMORY>::vector;
-    using RangeT = range<unsigned>;
+    using RangeT = osrm::range<unsigned>;

    friend std::ostream &operator<<<>(std::ostream &out, const RangeTable &table);
    friend std::istream &operator>><>(std::istream &in, RangeTable &table);
@@ -53,13 +75,13 @@ template <unsigned BLOCK_SIZE, bool USE_SHARED_MEMORY> class RangeTable
                        const unsigned sum_lengths)
        : sum_lengths(sum_lengths)
    {
-        using std::swap;
-        swap(block_offsets, external_offsets);
-        swap(diff_blocks, external_blocks);
+        block_offsets.swap(external_offsets);
+        diff_blocks.swap(external_blocks);
    }

    // construct table from length vector
-    template <typename VectorT> explicit RangeTable(const VectorT &lengths)
+    template<typename VectorT>
+    explicit RangeTable(const VectorT &lengths)
    {
        const unsigned number_of_blocks = [&lengths]()
        {
@@ -172,7 +194,7 @@ template <unsigned BLOCK_SIZE, bool USE_SHARED_MEMORY> class RangeTable
        BOOST_ASSERT(begin_idx < sum_lengths && end_idx <= sum_lengths);
        BOOST_ASSERT(begin_idx <= end_idx);

-        return irange(begin_idx, end_idx);
+        return osrm::irange(begin_idx, end_idx);
    }

  private:
@@ -234,7 +256,5 @@ std::istream &operator>>(std::istream &in, RangeTable<BLOCK_SIZE, USE_SHARED_MEM
    in.read((char *)table.diff_blocks.data(), BLOCK_SIZE * number_of_blocks);
    return in;
 }
-}
-}

 #endif // RANGE_TABLE_HPP
@@ -1,17 +1,39 @@
-#include "extractor/raster_source.hpp"
+/*

-#include "util/simple_logger.hpp"
-#include "util/timing_util.hpp"
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.

-#include "osrm/coordinate.hpp"
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#include "raster_source.hpp"
+
+#include "../util/simple_logger.hpp"
+#include "../util/timing_util.hpp"
+
+#include <osrm/coordinate.hpp>

 #include <cmath>

-namespace osrm
-{
-namespace extractor
-{
-
 RasterSource::RasterSource(RasterGrid _raster_data,
                           std::size_t _width,
                           std::size_t _height,
@@ -92,20 +114,20 @@ int SourceContainer::loadRasterSource(const std::string &path_string,
    const auto itr = LoadedSourcePaths.find(path_string);
    if (itr != LoadedSourcePaths.end())
    {
-        util::SimpleLogger().Write() << "[source loader] Already loaded source '" << path_string
-                                     << "' at source_id " << itr->second;
+        SimpleLogger().Write() << "[source loader] Already loaded source '" << path_string
+                               << "' at source_id " << itr->second;
        return itr->second;
    }

    int source_id = static_cast<int>(LoadedSources.size());

-    util::SimpleLogger().Write() << "[source loader] Loading from " << path_string << "  ... ";
+    SimpleLogger().Write() << "[source loader] Loading from " << path_string << "  ... ";
    TIMER_START(loading_source);

    boost::filesystem::path filepath(path_string);
    if (!boost::filesystem::exists(filepath))
    {
-        throw util::exception("error reading: no such path");
+        throw osrm::exception("error reading: no such path");
    }

    RasterGrid rasterData{filepath, ncols, nrows};
@@ -115,8 +137,7 @@ int SourceContainer::loadRasterSource(const std::string &path_string,
    LoadedSourcePaths.emplace(path_string, source_id);
    LoadedSources.push_back(std::move(source));

-    util::SimpleLogger().Write() << "[source loader] ok, after " << TIMER_SEC(loading_source)
-                                 << "s";
+    SimpleLogger().Write() << "[source loader] ok, after " << TIMER_SEC(loading_source) << "s";

    return source_id;
 }
@@ -126,7 +147,7 @@ RasterDatum SourceContainer::getRasterDataFromSource(unsigned int source_id, int
 {
    if (LoadedSources.size() < source_id + 1)
    {
-        throw util::exception("error reading: no such loaded source");
+        throw osrm::exception("error reading: no such loaded source");
    }

    BOOST_ASSERT(lat < (90 * COORDINATE_PRECISION));
@@ -144,7 +165,7 @@ SourceContainer::getRasterInterpolateFromSource(unsigned int source_id, int lon,
 {
    if (LoadedSources.size() < source_id + 1)
    {
-        throw util::exception("error reading: no such loaded source");
+        throw osrm::exception("error reading: no such loaded source");
    }

    BOOST_ASSERT(lat < (90 * COORDINATE_PRECISION));
@@ -155,5 +176,3 @@ SourceContainer::getRasterInterpolateFromSource(unsigned int source_id, int lon,
    const auto &found = LoadedSources[source_id];
    return found.getRasterInterpolate(lon, lat);
 }
-}
-}
@@ -1,7 +1,34 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
 #ifndef RASTER_SOURCE_HPP
 #define RASTER_SOURCE_HPP

-#include "util/exception.hpp"
+#include "../util/osrm_exception.hpp"

 #include <boost/filesystem.hpp>
 #include <boost/filesystem/fstream.hpp>
@@ -13,11 +40,6 @@
 #include <unordered_map>
 #include <iterator>

-namespace osrm
-{
-namespace extractor
-{
-
 /**
    \brief Small wrapper around raster source queries to optionally provide results
    gracefully, depending on source bounds
@@ -45,7 +67,7 @@ class RasterGrid
        boost::filesystem::ifstream stream(filepath);
        if (!stream)
        {
-            throw util::exception("Unable to open raster file.");
+            throw osrm::exception("Unable to open raster file.");
        }

        stream.seekg(0, std::ios_base::end);
@@ -70,13 +92,13 @@ class RasterGrid
        }
        catch (std::exception const &ex)
        {
-            throw util::exception(
+            throw osrm::exception(
                std::string("Failed to read from raster source with exception: ") + ex.what());
        }

        if (!r || itr != end)
        {
-            throw util::exception("Failed to parse raster source correctly.");
+            throw osrm::exception("Failed to parse raster source correctly.");
        }
    }

@@ -149,7 +171,5 @@ class SourceContainer
    std::vector<RasterSource> LoadedSources;
    std::unordered_map<std::string, int> LoadedSourcePaths;
 };
-}
-}

 #endif /* RASTER_SOURCE_HPP */
@@ -0,0 +1,203 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef RECTANGLE_HPP
+#define RECTANGLE_HPP
+
+#include "../algorithms/coordinate_calculation.hpp"
+
+#include <boost/assert.hpp>
+
+#include <osrm/coordinate.hpp>
+
+#include <algorithm>
+#include <cstdint>
+#include <limits>
+
+// TODO: Make template type, add tests
+struct RectangleInt2D
+{
+    RectangleInt2D()
+        : min_lon(std::numeric_limits<int32_t>::max()),
+          max_lon(std::numeric_limits<int32_t>::min()),
+          min_lat(std::numeric_limits<int32_t>::max()), max_lat(std::numeric_limits<int32_t>::min())
+    {
+    }
+
+    int32_t min_lon, max_lon;
+    int32_t min_lat, max_lat;
+
+    void MergeBoundingBoxes(const RectangleInt2D &other)
+    {
+        min_lon = std::min(min_lon, other.min_lon);
+        max_lon = std::max(max_lon, other.max_lon);
+        min_lat = std::min(min_lat, other.min_lat);
+        max_lat = std::max(max_lat, other.max_lat);
+        BOOST_ASSERT(min_lat != std::numeric_limits<int32_t>::min());
+        BOOST_ASSERT(min_lon != std::numeric_limits<int32_t>::min());
+        BOOST_ASSERT(max_lat != std::numeric_limits<int32_t>::min());
+        BOOST_ASSERT(max_lon != std::numeric_limits<int32_t>::min());
+    }
+
+    FixedPointCoordinate Centroid() const
+    {
+        FixedPointCoordinate centroid;
+        // The coordinates of the midpoints are given by:
+        // x = (x1 + x2) /2 and y = (y1 + y2) /2.
+        centroid.lon = (min_lon + max_lon) / 2;
+        centroid.lat = (min_lat + max_lat) / 2;
+        return centroid;
+    }
+
+    bool Intersects(const RectangleInt2D &other) const
+    {
+        FixedPointCoordinate upper_left(other.max_lat, other.min_lon);
+        FixedPointCoordinate upper_right(other.max_lat, other.max_lon);
+        FixedPointCoordinate lower_right(other.min_lat, other.max_lon);
+        FixedPointCoordinate lower_left(other.min_lat, other.min_lon);
+
+        return (Contains(upper_left) || Contains(upper_right) || Contains(lower_right) ||
+                Contains(lower_left));
+    }
+
+    float GetMinDist(const FixedPointCoordinate &location) const
+    {
+        const bool is_contained = Contains(location);
+        if (is_contained)
+        {
+            return 0.0f;
+        }
+
+        enum Direction
+        {
+            INVALID = 0,
+            NORTH = 1,
+            SOUTH = 2,
+            EAST = 4,
+            NORTH_EAST = 5,
+            SOUTH_EAST = 6,
+            WEST = 8,
+            NORTH_WEST = 9,
+            SOUTH_WEST = 10
+        };
+
+        Direction d = INVALID;
+        if (location.lat > max_lat)
+            d = (Direction)(d | NORTH);
+        else if (location.lat < min_lat)
+            d = (Direction)(d | SOUTH);
+        if (location.lon > max_lon)
+            d = (Direction)(d | EAST);
+        else if (location.lon < min_lon)
+            d = (Direction)(d | WEST);
+
+        BOOST_ASSERT(d != INVALID);
+
+        float min_dist = std::numeric_limits<float>::max();
+        switch (d)
+        {
+        case NORTH:
+            min_dist = coordinate_calculation::great_circle_distance(
+                location, FixedPointCoordinate(max_lat, location.lon));
+            break;
+        case SOUTH:
+            min_dist = coordinate_calculation::great_circle_distance(
+                location, FixedPointCoordinate(min_lat, location.lon));
+            break;
+        case WEST:
+            min_dist = coordinate_calculation::great_circle_distance(
+                location, FixedPointCoordinate(location.lat, min_lon));
+            break;
+        case EAST:
+            min_dist = coordinate_calculation::great_circle_distance(
+                location, FixedPointCoordinate(location.lat, max_lon));
+            break;
+        case NORTH_EAST:
+            min_dist = coordinate_calculation::great_circle_distance(
+                location, FixedPointCoordinate(max_lat, max_lon));
+            break;
+        case NORTH_WEST:
+            min_dist = coordinate_calculation::great_circle_distance(
+                location, FixedPointCoordinate(max_lat, min_lon));
+            break;
+        case SOUTH_EAST:
+            min_dist = coordinate_calculation::great_circle_distance(
+                location, FixedPointCoordinate(min_lat, max_lon));
+            break;
+        case SOUTH_WEST:
+            min_dist = coordinate_calculation::great_circle_distance(
+                location, FixedPointCoordinate(min_lat, min_lon));
+            break;
+        default:
+            break;
+        }
+
+        BOOST_ASSERT(min_dist < std::numeric_limits<float>::max());
+
+        return min_dist;
+    }
+
+    float GetMinMaxDist(const FixedPointCoordinate &location) const
+    {
+        float min_max_dist = std::numeric_limits<float>::max();
+        // Get minmax distance to each of the four sides
+        const FixedPointCoordinate upper_left(max_lat, min_lon);
+        const FixedPointCoordinate upper_right(max_lat, max_lon);
+        const FixedPointCoordinate lower_right(min_lat, max_lon);
+        const FixedPointCoordinate lower_left(min_lat, min_lon);
+
+        min_max_dist = std::min(
+            min_max_dist,
+            std::max(coordinate_calculation::great_circle_distance(location, upper_left),
+                     coordinate_calculation::great_circle_distance(location, upper_right)));
+
+        min_max_dist = std::min(
+            min_max_dist,
+            std::max(coordinate_calculation::great_circle_distance(location, upper_right),
+                     coordinate_calculation::great_circle_distance(location, lower_right)));
+
+        min_max_dist =
+            std::min(min_max_dist,
+                     std::max(coordinate_calculation::great_circle_distance(location, lower_right),
+                              coordinate_calculation::great_circle_distance(location, lower_left)));
+
+        min_max_dist =
+            std::min(min_max_dist,
+                     std::max(coordinate_calculation::great_circle_distance(location, lower_left),
+                              coordinate_calculation::great_circle_distance(location, upper_left)));
+        return min_max_dist;
+    }
+
+    bool Contains(const FixedPointCoordinate &location) const
+    {
+        const bool lats_contained = (location.lat >= min_lat) && (location.lat <= max_lat);
+        const bool lons_contained = (location.lon >= min_lon) && (location.lon <= max_lon);
+        return lats_contained && lons_contained;
+    }
+};
+
+#endif
@@ -1,15 +1,37 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
 #ifndef RESTRICTION_HPP
 #define RESTRICTION_HPP

-#include "util/typedefs.hpp"
+#include "../typedefs.h"

 #include <limits>

-namespace osrm
-{
-namespace extractor
-{
-
 struct TurnRestriction
 {
    union WayOrNode
@@ -57,7 +79,7 @@ struct TurnRestriction

 /**
 * 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)
@@ -108,7 +130,5 @@ struct CmpRestrictionContainerByTo
    value_type max_value() const { return InputRestrictionContainer::max_value(); }
    value_type min_value() const { return InputRestrictionContainer::min_value(); }
 };
-}
-}

 #endif // RESTRICTION_HPP
@@ -1,9 +1,31 @@
-#include "extractor/restriction_map.hpp"
+/*

-namespace osrm
-{
-namespace extractor
-{
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#include "restriction_map.hpp"

 RestrictionMap::RestrictionMap(const std::vector<TurnRestriction> &restriction_list) : m_count(0)
 {
@@ -20,8 +42,7 @@ RestrictionMap::RestrictionMap(const std::vector<TurnRestriction> &restriction_l
        m_no_turn_via_node_set.insert(restriction.via.node);

        // This explicit downcasting is also OK for the same reason.
-        RestrictionSource restriction_source = {static_cast<NodeID>(restriction.from.node),
-                                                static_cast<NodeID>(restriction.via.node)};
+        RestrictionSource restriction_source = {static_cast<NodeID>(restriction.from.node), static_cast<NodeID>(restriction.via.node)};

        std::size_t index;
        auto restriction_iter = m_restriction_map.find(restriction_source);
@@ -155,7 +176,9 @@ bool RestrictionMap::CheckIfTurnIsRestricted(const NodeID node_u,
 // check of node is the start of any restriction
 bool RestrictionMap::IsSourceNode(const NodeID node) const
 {
-    return m_restriction_start_nodes.find(node) != m_restriction_start_nodes.end();
-}
-}
+    if (m_restriction_start_nodes.find(node) == m_restriction_start_nodes.end())
+    {
+        return false;
+    }
+    return true;
 }
@@ -1,10 +1,36 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
 #ifndef RESTRICTION_MAP_HPP
 #define RESTRICTION_MAP_HPP

-#include "extractor/edge_based_edge.hpp"
-#include "extractor/restriction.hpp"
-#include "util/std_hash.hpp"
-#include "util/typedefs.hpp"
+#include "restriction.hpp"
+#include "../util/std_hash.hpp"
+#include "../typedefs.h"

 #include <boost/assert.hpp>

@@ -13,11 +39,6 @@
 #include <unordered_set>
 #include <vector>

-namespace osrm
-{
-namespace extractor
-{
-
 struct RestrictionSource
 {
    NodeID start_node;
@@ -43,32 +64,26 @@ struct RestrictionTarget
        return (lhs.target_node == rhs.target_node && lhs.is_only == rhs.is_only);
    }
 };
-}
-}

 namespace std
 {
-template <> struct hash<osrm::extractor::RestrictionSource>
+template <> struct hash<RestrictionSource>
 {
-    size_t operator()(const osrm::extractor::RestrictionSource &r_source) const
+    size_t operator()(const RestrictionSource &r_source) const
    {
        return hash_val(r_source.start_node, r_source.via_node);
    }
 };

-template <> struct hash<osrm::extractor::RestrictionTarget>
+template <> struct hash<RestrictionTarget>
 {
-    size_t operator()(const osrm::extractor::RestrictionTarget &r_target) const
+    size_t operator()(const RestrictionTarget &r_target) const
    {
        return hash_val(r_target.target_node, r_target.is_only);
    }
 };
 }

-namespace osrm
-{
-namespace extractor
-{
 /**
    \brief Efficent look up if an edge is the start + via node of a TurnRestriction
    EdgeBasedEdgeFactory decides by it if edges are inserted or geometry is compressed
@@ -76,7 +91,7 @@ namespace extractor
 class RestrictionMap
 {
  public:
-    RestrictionMap() : m_count(0){}
+    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
@@ -157,7 +172,5 @@ class RestrictionMap
    std::unordered_set<NodeID> m_restriction_start_nodes;
    std::unordered_set<NodeID> m_no_turn_via_node_set;
 };
-}
-}

 #endif // RESTRICTION_MAP_HPP
@@ -0,0 +1,179 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#include <boost/fusion/container/vector.hpp>
+#include <boost/fusion/sequence/intrinsic.hpp>
+#include <boost/fusion/include/at_c.hpp>
+#include <boost/spirit/include/qi.hpp>
+
+#include <osrm/route_parameters.hpp>
+
+#include "../algorithms/polyline_compressor.hpp"
+
+RouteParameters::RouteParameters()
+    : zoom_level(18), print_instructions(false), alternate_route(true), geometry(true),
+      compression(true), deprecatedAPI(false), uturn_default(false), classify(false),
+      matching_beta(5), gps_precision(5), check_sum(-1), num_results(1)
+{
+}
+
+void RouteParameters::setZoomLevel(const short level)
+{
+    if (18 >= level && 0 <= level)
+    {
+        zoom_level = level;
+    }
+}
+
+void RouteParameters::setNumberOfResults(const short number)
+{
+    if (number > 0 && number <= 100)
+    {
+        num_results = number;
+    }
+}
+
+void RouteParameters::setAlternateRouteFlag(const bool flag) { alternate_route = flag; }
+
+void RouteParameters::setUTurn(const bool flag)
+{
+    // the API grammar should make sure this never happens
+    BOOST_ASSERT(!uturns.empty());
+    uturns.back() = flag;
+}
+
+void RouteParameters::setAllUTurns(const bool flag)
+{
+    // if the flag flips the default, then we erase everything.
+    if (flag)
+    {
+        uturn_default = flag;
+        uturns.clear();
+        uturns.resize(coordinates.size(), uturn_default);
+    }
+}
+
+void RouteParameters::setDeprecatedAPIFlag(const std::string &) { deprecatedAPI = true; }
+
+void RouteParameters::setChecksum(const unsigned sum) { check_sum = sum; }
+
+void RouteParameters::setInstructionFlag(const bool flag) { print_instructions = flag; }
+
+void RouteParameters::setService(const std::string &service_string) { service = service_string; }
+
+void RouteParameters::setClassify(const bool flag) { classify = flag; }
+
+void RouteParameters::setMatchingBeta(const double beta) { matching_beta = beta; }
+
+void RouteParameters::setGPSPrecision(const double precision) { gps_precision = precision; }
+
+void RouteParameters::setOutputFormat(const std::string &format) { output_format = format; }
+
+void RouteParameters::setJSONpParameter(const std::string &parameter)
+{
+    jsonp_parameter = parameter;
+}
+
+void RouteParameters::addHint(const std::string &hint)
+{
+    hints.resize(coordinates.size());
+    if (!hints.empty())
+    {
+        hints.back() = hint;
+    }
+}
+
+void RouteParameters::addTimestamp(const unsigned timestamp)
+{
+    timestamps.resize(coordinates.size());
+    if (!timestamps.empty())
+    {
+        timestamps.back() = timestamp;
+    }
+}
+
+void RouteParameters::addBearing(
+    const boost::fusion::vector<int, boost::optional<int>> &received_bearing,
+        boost::spirit::qi::unused_type /* unused */, bool& pass)
+{
+    pass = false;
+    const int bearing = boost::fusion::at_c<0>(received_bearing);
+    const boost::optional<int> range = boost::fusion::at_c<1>(received_bearing);
+    if (bearing < 0 || bearing > 359) return;
+    if (range && (*range < 0 || *range > 180)) return;
+    bearings.emplace_back(std::make_pair(bearing,range));
+    pass = true;
+}
+
+void RouteParameters::setLanguage(const std::string &language_string)
+{
+    language = language_string;
+}
+
+void RouteParameters::setGeometryFlag(const bool flag) { geometry = flag; }
+
+void RouteParameters::setCompressionFlag(const bool flag) { compression = flag; }
+
+void RouteParameters::addCoordinate(
+    const boost::fusion::vector<double, double> &received_coordinates)
+{
+    coordinates.emplace_back(
+        static_cast<int>(COORDINATE_PRECISION * boost::fusion::at_c<0>(received_coordinates)),
+        static_cast<int>(COORDINATE_PRECISION * boost::fusion::at_c<1>(received_coordinates)));
+    is_source.push_back(true);
+    is_destination.push_back(true);
+    uturns.push_back(uturn_default);
+}
+
+void RouteParameters::addDestination(
+    const boost::fusion::vector<double, double> &received_coordinates)
+{
+    coordinates.emplace_back(
+        static_cast<int>(COORDINATE_PRECISION * boost::fusion::at_c<0>(received_coordinates)),
+        static_cast<int>(COORDINATE_PRECISION * boost::fusion::at_c<1>(received_coordinates)));
+    is_source.push_back(false);
+    is_destination.push_back(true);
+    uturns.push_back(uturn_default);
+}
+
+void RouteParameters::addSource(
+    const boost::fusion::vector<double, double> &received_coordinates)
+{
+    coordinates.emplace_back(
+        static_cast<int>(COORDINATE_PRECISION * boost::fusion::at_c<0>(received_coordinates)),
+        static_cast<int>(COORDINATE_PRECISION * boost::fusion::at_c<1>(received_coordinates)));
+    is_source.push_back(true);
+    is_destination.push_back(false);
+    uturns.push_back(uturn_default);
+}
+
+void RouteParameters::getCoordinatesFromGeometry(const std::string &geometry_string)
+{
+    PolylineCompressor pc;
+    coordinates = pc.decode_string(geometry_string);
+}
+
@@ -0,0 +1,69 @@
+/*
+
+Copyright (c) 2014, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef SEARCH_ENGINE_HPP
+#define SEARCH_ENGINE_HPP
+
+#include "search_engine_data.hpp"
+#include "../routing_algorithms/alternative_path.hpp"
+#include "../routing_algorithms/many_to_many.hpp"
+#include "../routing_algorithms/map_matching.hpp"
+#include "../routing_algorithms/shortest_path.hpp"
+#include "../routing_algorithms/direct_shortest_path.hpp"
+
+#include <type_traits>
+
+template <class DataFacadeT> class SearchEngine
+{
+  private:
+    DataFacadeT *facade;
+    SearchEngineData engine_working_data;
+
+  public:
+    ShortestPathRouting<DataFacadeT> shortest_path;
+    DirectShortestPathRouting<DataFacadeT> direct_shortest_path;
+    AlternativeRouting<DataFacadeT> alternative_path;
+    ManyToManyRouting<DataFacadeT> distance_table;
+    MapMatching<DataFacadeT> map_matching;
+
+    explicit SearchEngine(DataFacadeT *facade)
+        : facade(facade),
+          shortest_path(facade, engine_working_data),
+          direct_shortest_path(facade, engine_working_data),
+          alternative_path(facade, engine_working_data),
+          distance_table(facade, engine_working_data),
+          map_matching(facade, engine_working_data)
+    {
+        static_assert(!std::is_pointer<DataFacadeT>::value, "don't instantiate with ptr type");
+        static_assert(std::is_object<DataFacadeT>::value,
+                      "don't instantiate with void, function, or reference");
+    }
+
+    ~SearchEngine() {}
+};
+
+#endif // SEARCH_ENGINE_HPP
@@ -0,0 +1,93 @@
+/*
+
+Copyright (c) 2013, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#include "search_engine_data.hpp"
+
+#include "binary_heap.hpp"
+
+void SearchEngineData::InitializeOrClearFirstThreadLocalStorage(const unsigned number_of_nodes)
+{
+    if (forward_heap_1.get())
+    {
+        forward_heap_1->Clear();
+    }
+    else
+    {
+        forward_heap_1.reset(new QueryHeap(number_of_nodes));
+    }
+
+    if (reverse_heap_1.get())
+    {
+        reverse_heap_1->Clear();
+    }
+    else
+    {
+        reverse_heap_1.reset(new QueryHeap(number_of_nodes));
+    }
+}
+
+void SearchEngineData::InitializeOrClearSecondThreadLocalStorage(const unsigned number_of_nodes)
+{
+    if (forward_heap_2.get())
+    {
+        forward_heap_2->Clear();
+    }
+    else
+    {
+        forward_heap_2.reset(new QueryHeap(number_of_nodes));
+    }
+
+    if (reverse_heap_2.get())
+    {
+        reverse_heap_2->Clear();
+    }
+    else
+    {
+        reverse_heap_2.reset(new QueryHeap(number_of_nodes));
+    }
+}
+
+void SearchEngineData::InitializeOrClearThirdThreadLocalStorage(const unsigned number_of_nodes)
+{
+    if (forward_heap_3.get())
+    {
+        forward_heap_3->Clear();
+    }
+    else
+    {
+        forward_heap_3.reset(new QueryHeap(number_of_nodes));
+    }
+
+    if (reverse_heap_3.get())
+    {
+        reverse_heap_3->Clear();
+    }
+    else
+    {
+        reverse_heap_3.reset(new QueryHeap(number_of_nodes));
+    }
+}
@@ -0,0 +1,61 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef SEARCH_ENGINE_DATA_HPP
+#define SEARCH_ENGINE_DATA_HPP
+
+#include <boost/thread/tss.hpp>
+
+#include "../typedefs.h"
+#include "binary_heap.hpp"
+
+struct HeapData
+{
+    NodeID parent;
+    /* explicit */ HeapData(NodeID p) : parent(p) {}
+};
+
+struct SearchEngineData
+{
+    using QueryHeap = BinaryHeap<NodeID, NodeID, int, HeapData, UnorderedMapStorage<NodeID, int>>;
+    using SearchEngineHeapPtr = boost::thread_specific_ptr<QueryHeap>;
+
+    static SearchEngineHeapPtr forward_heap_1;
+    static SearchEngineHeapPtr reverse_heap_1;
+    static SearchEngineHeapPtr forward_heap_2;
+    static SearchEngineHeapPtr reverse_heap_2;
+    static SearchEngineHeapPtr forward_heap_3;
+    static SearchEngineHeapPtr reverse_heap_3;
+
+    void InitializeOrClearFirstThreadLocalStorage(const unsigned number_of_nodes);
+
+    void InitializeOrClearSecondThreadLocalStorage(const unsigned number_of_nodes);
+
+    void InitializeOrClearThirdThreadLocalStorage(const unsigned number_of_nodes);
+};
+
+#endif // SEARCH_ENGINE_DATA_HPP
@@ -0,0 +1,80 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef SEGMENT_INFORMATION_HPP
+#define SEGMENT_INFORMATION_HPP
+
+#include "turn_instructions.hpp"
+
+#include "../data_structures/travel_mode.hpp"
+#include "../typedefs.h"
+
+#include <osrm/coordinate.hpp>
+#include <utility>
+
+// Struct fits everything in one cache line
+struct SegmentInformation
+{
+    FixedPointCoordinate location;
+    NodeID name_id;
+    EdgeWeight duration;
+    float length;
+    short pre_turn_bearing; // more than enough [0..3600] fits into 12 bits
+    short post_turn_bearing;
+    TurnInstruction turn_instruction;
+    TravelMode travel_mode;
+    bool necessary;
+    bool is_via_location;
+
+    explicit SegmentInformation(FixedPointCoordinate location,
+                                const NodeID name_id,
+                                const EdgeWeight duration,
+                                const float length,
+                                const TurnInstruction turn_instruction,
+                                const bool necessary,
+                                const bool is_via_location,
+                                const TravelMode travel_mode)
+        : location(std::move(location)), name_id(name_id), duration(duration), length(length),
+          pre_turn_bearing(0), post_turn_bearing(0), turn_instruction(turn_instruction), travel_mode(travel_mode),
+          necessary(necessary), is_via_location(is_via_location)
+    {
+    }
+
+    explicit SegmentInformation(FixedPointCoordinate location,
+                                const NodeID name_id,
+                                const EdgeWeight duration,
+                                const float length,
+                                const TurnInstruction turn_instruction,
+                                const TravelMode travel_mode)
+        : location(std::move(location)), name_id(name_id), duration(duration), length(length),
+          pre_turn_bearing(0), post_turn_bearing(0), turn_instruction(turn_instruction), travel_mode(travel_mode),
+          necessary(turn_instruction != TurnInstruction::NoTurn), is_via_location(false)
+    {
+    }
+};
+
+#endif /* SEGMENT_INFORMATION_HPP */
@@ -1,8 +1,35 @@
-#ifndef SHARED_MEMORY_HPP
-#define SHARED_MEMORY_HPP
+/*

-#include "util/exception.hpp"
-#include "util/simple_logger.hpp"
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef SHARED_MEMORY_FACTORY_HPP
+#define SHARED_MEMORY_FACTORY_HPP
+
+#include "../util/osrm_exception.hpp"
+#include "../util/simple_logger.hpp"

 #include <boost/filesystem.hpp>
 #include <boost/filesystem/fstream.hpp>
@@ -24,11 +51,6 @@
 #include <algorithm>
 #include <exception>

-namespace osrm
-{
-namespace storage
-{
-
 struct OSRMLockFile
 {
    boost::filesystem::path operator()()
@@ -58,18 +80,15 @@ class SharedMemory
        }

        shm_remove() : m_shmid(INT_MIN), m_initialized(false) {}
-
        shm_remove(const shm_remove &) = delete;
-        shm_remove &operator=(const shm_remove &) = delete;
-
        ~shm_remove()
        {
            if (m_initialized)
            {
-                util::SimpleLogger().Write(logDEBUG) << "automatic memory deallocation";
+                SimpleLogger().Write(logDEBUG) << "automatic memory deallocation";
                if (!boost::interprocess::xsi_shared_memory::remove(m_shmid))
                {
-                    util::SimpleLogger().Write(logDEBUG) << "could not deallocate id " << m_shmid;
+                    SimpleLogger().Write(logDEBUG) << "could not deallocate id " << m_shmid;
                }
            }
        }
@@ -78,6 +97,7 @@ class SharedMemory
  public:
    void *Ptr() const { return region.get_address(); }

+    SharedMemory() = delete;
    SharedMemory(const SharedMemory &) = delete;
    SharedMemory &operator=(const SharedMemory &) = delete;

@@ -111,15 +131,14 @@ class SharedMemory
            {
                if (ENOMEM == errno)
                {
-                    util::SimpleLogger().Write(logWARNING) << "could not lock shared memory to RAM";
+                    SimpleLogger().Write(logWARNING) << "could not lock shared memory to RAM";
                }
            }
 #endif
            region = boost::interprocess::mapped_region(shm, boost::interprocess::read_write);

            remover.SetID(shm.get_shmid());
-            util::SimpleLogger().Write(logDEBUG) << "writeable memory allocated " << size
-                                                 << " bytes";
+            SimpleLogger().Write(logDEBUG) << "writeable memory allocated " << size << " bytes";
        }
    }

@@ -166,7 +185,7 @@ class SharedMemory
        bool ret = false;
        try
        {
-            util::SimpleLogger().Write(logDEBUG) << "deallocating prev memory";
+            SimpleLogger().Write(logDEBUG) << "deallocating prev memory";
            boost::interprocess::xsi_shared_memory xsi(boost::interprocess::open_only, key);
            ret = boost::interprocess::xsi_shared_memory::remove(xsi.get_shmid());
        }
@@ -195,6 +214,8 @@ class SharedMemory
    class shm_remove
    {
      private:
+        shm_remove(const shm_remove &) = delete;
+        shm_remove &operator=(const shm_remove &) = delete;
        char *m_shmid;
        bool m_initialized;

@@ -207,17 +228,14 @@ class SharedMemory

        shm_remove() : m_shmid("undefined"), m_initialized(false) {}

-        shm_remove(const shm_remove &) = delete;
-        shm_remove &operator=(const shm_remove &) = delete;
-
        ~shm_remove()
        {
            if (m_initialized)
            {
-                util::SimpleLogger().Write(logDEBUG) << "automatic memory deallocation";
+                SimpleLogger().Write(logDEBUG) << "automatic memory deallocation";
                if (!boost::interprocess::shared_memory_object::remove(m_shmid))
                {
-                    util::SimpleLogger().Write(logDEBUG) << "could not deallocate id " << m_shmid;
+                    SimpleLogger().Write(logDEBUG) << "could not deallocate id " << m_shmid;
                }
            }
        }
@@ -254,8 +272,7 @@ class SharedMemory
            region = boost::interprocess::mapped_region(shm, boost::interprocess::read_write);

            remover.SetID(key);
-            util::SimpleLogger().Write(logDEBUG) << "writeable memory allocated " << size
-                                                 << " bytes";
+            SimpleLogger().Write(logDEBUG) << "writeable memory allocated " << size << " bytes";
        }
    }

@@ -305,7 +322,7 @@ class SharedMemory
        bool ret = false;
        try
        {
-            util::SimpleLogger().Write(logDEBUG) << "deallocating prev memory";
+            SimpleLogger().Write(logDEBUG) << "deallocating prev memory";
            ret = boost::interprocess::shared_memory_object::remove(key);
        }
        catch (const boost::interprocess::interprocess_exception &e)
@@ -325,36 +342,45 @@ class SharedMemory
 };
 #endif

-template <typename IdentifierT, typename LockFileT = OSRMLockFile>
-SharedMemory *makeSharedMemory(const IdentifierT &id,
-                               const uint64_t size = 0,
-                               bool read_write = false,
-                               bool remove_prev = true)
+template <class LockFileT = OSRMLockFile> class SharedMemoryFactory_tmpl
 {
-    try
+  public:
+    template <typename IdentifierT>
+    static SharedMemory *Get(const IdentifierT &id,
+                             const uint64_t size = 0,
+                             bool read_write = false,
+                             bool remove_prev = true)
    {
-        LockFileT lock_file;
-        if (!boost::filesystem::exists(lock_file()))
+        try
        {
-            if (0 == size)
+            LockFileT lock_file;
+            if (!boost::filesystem::exists(lock_file()))
            {
-                throw util::exception("lock file does not exist, exiting");
-            }
-            else
-            {
-                boost::filesystem::ofstream ofs(lock_file());
+                if (0 == size)
+                {
+                    throw osrm::exception("lock file does not exist, exiting");
+                }
+                else
+                {
+                    boost::filesystem::ofstream ofs(lock_file());
+                    ofs.close();
+                }
            }
+            return new SharedMemory(lock_file(), id, size, read_write, remove_prev);
+        }
+        catch (const boost::interprocess::interprocess_exception &e)
+        {
+            SimpleLogger().Write(logWARNING) << "caught exception: " << e.what() << ", code "
+                                             << e.get_error_code();
+            throw osrm::exception(e.what());
        }
-        return new SharedMemory(lock_file(), id, size, read_write, remove_prev);
    }
-    catch (const boost::interprocess::interprocess_exception &e)
-    {
-        util::SimpleLogger().Write(logWARNING) << "caught exception: " << e.what() << ", code "
-                                               << e.get_error_code();
-        throw util::exception(e.what());
-    }
-}
-}
-}

-#endif // SHARED_MEMORY_HPP
+    SharedMemoryFactory_tmpl() = delete;
+    SharedMemoryFactory_tmpl(const SharedMemoryFactory_tmpl &) = delete;
+    SharedMemoryFactory_tmpl &operator=(const SharedMemoryFactory_tmpl &) = delete;
+};
+
+using SharedMemoryFactory = SharedMemoryFactory_tmpl<>;
+
+#endif // SHARED_MEMORY_FACTORY_HPP
@@ -1,20 +1,39 @@
+/*
+
+Copyright (c) 2014, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
 #ifndef SHARED_MEMORY_VECTOR_WRAPPER_HPP
 #define SHARED_MEMORY_VECTOR_WRAPPER_HPP

 #include <boost/assert.hpp>

-#include <cstddef>
-
 #include <algorithm>
 #include <iterator>
 #include <type_traits>
 #include <vector>
-#include <utility>
-
-namespace osrm
-{
-namespace util
-{

 template <typename DataT> class ShMemIterator : public std::iterator<std::input_iterator_tag, DataT>
 {
@@ -55,6 +74,13 @@ template <typename DataT> class SharedMemoryWrapper

    SharedMemoryWrapper(DataT *ptr, std::size_t size) : m_ptr(ptr), m_size(size) {}

+    void swap(SharedMemoryWrapper<DataT> &other)
+    {
+        // BOOST_ASSERT_MSG(m_size != 0 || other.size() != 0, "size invalid");
+        std::swap(m_size, other.m_size);
+        std::swap(m_ptr, other.m_ptr);
+    }
+
    DataT &at(const std::size_t index) { return m_ptr[index]; }

    const DataT &at(const std::size_t index) const { return m_ptr[index]; }
@@ -78,9 +104,6 @@ template <typename DataT> class SharedMemoryWrapper
        BOOST_ASSERT_MSG(index < m_size, "invalid size");
        return m_ptr[index];
    }
-
-    template <typename T>
-    friend void swap(SharedMemoryWrapper<T> &, SharedMemoryWrapper<T> &) noexcept;
 };

 template <> class SharedMemoryWrapper<bool>
@@ -94,11 +117,18 @@ template <> class SharedMemoryWrapper<bool>

    SharedMemoryWrapper(unsigned *ptr, std::size_t size) : m_ptr(ptr), m_size(size) {}

+    void swap(SharedMemoryWrapper<bool> &other)
+    {
+        // BOOST_ASSERT_MSG(m_size != 0 || other.size() != 0, "size invalid");
+        std::swap(m_size, other.m_size);
+        std::swap(m_ptr, other.m_ptr);
+    }
+
    bool at(const std::size_t index) const
    {
        const std::size_t bucket = index / 32;
        const unsigned offset = static_cast<unsigned>(index % 32);
-        return m_ptr[bucket] & (1u << offset);
+        return m_ptr[bucket] & (1 << offset);
    }

    std::size_t size() const { return m_size; }
@@ -110,28 +140,15 @@ template <> class SharedMemoryWrapper<bool>
        BOOST_ASSERT_MSG(index < m_size, "invalid size");
        const unsigned bucket = index / 32;
        const unsigned offset = index % 32;
-        return m_ptr[bucket] & (1u << offset);
+        return m_ptr[bucket] & (1 << offset);
    }
-
-    template <typename T>
-    friend void swap(SharedMemoryWrapper<T> &, SharedMemoryWrapper<T> &) noexcept;
 };

-// Both SharedMemoryWrapper<T> and the SharedMemoryWrapper<bool> specializations share this impl.
-template <typename DataT>
-void swap(SharedMemoryWrapper<DataT> &lhs, SharedMemoryWrapper<DataT> &rhs) noexcept
-{
-    std::swap(lhs.m_ptr, rhs.m_ptr);
-    std::swap(lhs.m_size, rhs.m_size);
-}
-
 template <typename DataT, bool UseSharedMemory> struct ShM
 {
    using vector = typename std::conditional<UseSharedMemory,
                                             SharedMemoryWrapper<DataT>,
                                             std::vector<DataT>>::type;
 };
-}
-}

 #endif // SHARED_MEMORY_VECTOR_WRAPPER_HPP
@@ -1,10 +1,37 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
 #ifndef STATIC_GRAPH_HPP
 #define STATIC_GRAPH_HPP

-#include "util/percent.hpp"
-#include "util/shared_memory_vector_wrapper.hpp"
-#include "util/integer_range.hpp"
-#include "util/typedefs.hpp"
+#include "percent.hpp"
+#include "shared_memory_vector_wrapper.hpp"
+#include "../util/integer_range.hpp"
+#include "../typedefs.h"

 #include <boost/assert.hpp>

@@ -13,18 +40,13 @@
 #include <utility>
 #include <vector>

-namespace osrm
-{
-namespace util
-{
-
 template <typename EdgeDataT, bool UseSharedMemory = false> class StaticGraph
 {
  public:
    using NodeIterator = NodeID;
    using EdgeIterator = NodeID;
    using EdgeData = EdgeDataT;
-    using EdgeRange = range<EdgeIterator>;
+    using EdgeRange = osrm::range<EdgeIterator>;

    class InputEdge
    {
@@ -62,20 +84,20 @@ template <typename EdgeDataT, bool UseSharedMemory = false> class StaticGraph

    EdgeRange GetAdjacentEdgeRange(const NodeID node) const
    {
-        return irange(BeginEdges(node), EndEdges(node));
+        return osrm::irange(BeginEdges(node), EndEdges(node));
    }

-    template <typename ContainerT> StaticGraph(const int nodes, const ContainerT &graph)
+    template<typename ContainerT>
+    StaticGraph(const int nodes, const ContainerT &graph)
    {
-        BOOST_ASSERT(std::is_sorted(const_cast<ContainerT &>(graph).begin(),
-                                    const_cast<ContainerT &>(graph).end()));
+        BOOST_ASSERT(std::is_sorted(const_cast<ContainerT&>(graph).begin(), const_cast<ContainerT&>(graph).end()));

        number_of_nodes = nodes;
        number_of_edges = static_cast<EdgeIterator>(graph.size());
        node_array.resize(number_of_nodes + 1);
        EdgeIterator edge = 0;
        EdgeIterator position = 0;
-        for (const auto node : irange(0u, number_of_nodes + 1))
+        for (const auto node : osrm::irange(0u, number_of_nodes + 1))
        {
            EdgeIterator last_edge = edge;
            while (edge < number_of_edges && graph[edge].source == node)
@@ -87,10 +109,10 @@ template <typename EdgeDataT, bool UseSharedMemory = false> class StaticGraph
        }
        edge_array.resize(position); //(edge)
        edge = 0;
-        for (const auto node : irange(0u, number_of_nodes))
+        for (const auto node : osrm::irange(0u, number_of_nodes))
        {
            EdgeIterator e = node_array[node + 1].first_edge;
-            for (const auto i : irange(node_array[node].first_edge, e))
+            for (const auto i : osrm::irange(node_array[node].first_edge, e))
            {
                edge_array[i].target = graph[edge].target;
                edge_array[i].data = graph[edge].data;
@@ -105,9 +127,8 @@ template <typename EdgeDataT, bool UseSharedMemory = false> class StaticGraph
        number_of_nodes = static_cast<decltype(number_of_nodes)>(nodes.size() - 1);
        number_of_edges = static_cast<decltype(number_of_edges)>(edges.size());

-        using std::swap;
-        swap(node_array, nodes);
-        swap(edge_array, edges);
+        node_array.swap(nodes);
+        edge_array.swap(edges);
    }

    unsigned GetNumberOfNodes() const { return number_of_nodes; }
@@ -138,7 +159,7 @@ template <typename EdgeDataT, bool UseSharedMemory = false> class StaticGraph
    // searches for a specific edge
    EdgeIterator FindEdge(const NodeIterator from, const NodeIterator to) const
    {
-        for (const auto i : irange(BeginEdges(from), EndEdges(from)))
+        for (const auto i : osrm::irange(BeginEdges(from), EndEdges(from)))
        {
            if (to == edge_array[i].target)
            {
@@ -194,7 +215,5 @@ template <typename EdgeDataT, bool UseSharedMemory = false> class StaticGraph
    typename ShM<NodeArrayEntry, UseSharedMemory>::vector node_array;
    typename ShM<EdgeArrayEntry, UseSharedMemory>::vector edge_array;
 };
-}
-}

 #endif // STATIC_GRAPH_HPP
@@ -0,0 +1,260 @@
+/*
+
+Copyright (c) 2013, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+// KD Tree coded by Christian Vetter, Monav Project
+
+#ifndef STATICKDTREE_HPP
+#define STATICKDTREE_HPP
+
+#include <boost/assert.hpp>
+#include <vector>
+#include <algorithm>
+#include <stack>
+#include <limits>
+
+namespace KDTree
+{
+
+#define KDTREE_BASESIZE (8)
+
+template <unsigned k, typename T> class BoundingBox
+{
+  public:
+    BoundingBox()
+    {
+        for (unsigned dim = 0; dim < k; ++dim)
+        {
+            min[dim] = std::numeric_limits<T>::min();
+            max[dim] = std::numeric_limits<T>::max();
+        }
+    }
+
+    T min[k];
+    T max[k];
+};
+
+struct NoData
+{
+};
+
+template <unsigned k, typename T> class EuclidianMetric
+{
+  public:
+    double operator()(const T left[k], const T right[k])
+    {
+        double result = 0;
+        for (unsigned i = 0; i < k; ++i)
+        {
+            double temp = (double)left[i] - (double)right[i];
+            result += temp * temp;
+        }
+        return result;
+    }
+
+    double operator()(const BoundingBox<k, T> &box, const T point[k])
+    {
+        T nearest[k];
+        for (unsigned dim = 0; dim < k; ++dim)
+        {
+            if (point[dim] < box.min[dim])
+                nearest[dim] = box.min[dim];
+            else if (point[dim] > box.max[dim])
+                nearest[dim] = box.max[dim];
+            else
+                nearest[dim] = point[dim];
+        }
+        return operator()(point, nearest);
+    }
+};
+
+template <unsigned k, typename T, typename Data = NoData, typename Metric = EuclidianMetric<k, T>>
+class StaticKDTree
+{
+  public:
+    struct InputPoint
+    {
+        T coordinates[k];
+        Data data;
+        bool operator==(const InputPoint &right)
+        {
+            for (int i = 0; i < k; i++)
+            {
+                if (coordinates[i] != right.coordinates[i])
+                    return false;
+            }
+            return true;
+        }
+    };
+
+    explicit StaticKDTree(std::vector<InputPoint> *points)
+    {
+        BOOST_ASSERT(k > 0);
+        BOOST_ASSERT(points->size() > 0);
+        size = points->size();
+        kdtree = new InputPoint[size];
+        for (Iterator i = 0; i != size; ++i)
+        {
+            kdtree[i] = points->at(i);
+            for (unsigned dim = 0; dim < k; ++dim)
+            {
+                if (kdtree[i].coordinates[dim] < boundingBox.min[dim])
+                    boundingBox.min[dim] = kdtree[i].coordinates[dim];
+                if (kdtree[i].coordinates[dim] > boundingBox.max[dim])
+                    boundingBox.max[dim] = kdtree[i].coordinates[dim];
+            }
+        }
+        std::stack<Tree> s;
+        s.push(Tree(0, size, 0));
+        while (!s.empty())
+        {
+            Tree tree = s.top();
+            s.pop();
+
+            if (tree.right - tree.left < KDTREE_BASESIZE)
+                continue;
+
+            Iterator middle = tree.left + (tree.right - tree.left) / 2;
+            std::nth_element(kdtree + tree.left, kdtree + middle, kdtree + tree.right,
+                             Less(tree.dimension));
+            s.push(Tree(tree.left, middle, (tree.dimension + 1) % k));
+            s.push(Tree(middle + 1, tree.right, (tree.dimension + 1) % k));
+        }
+    }
+
+    ~StaticKDTree() { delete[] kdtree; }
+
+    bool NearestNeighbor(InputPoint *result, const InputPoint &point)
+    {
+        Metric distance;
+        bool found = false;
+        double nearestDistance = std::numeric_limits<T>::max();
+        std::stack<NNTree> s;
+        s.push(NNTree(0, size, 0, boundingBox));
+        while (!s.empty())
+        {
+            NNTree tree = s.top();
+            s.pop();
+
+            if (distance(tree.box, point.coordinates) >= nearestDistance)
+                continue;
+
+            if (tree.right - tree.left < KDTREE_BASESIZE)
+            {
+                for (unsigned i = tree.left; i < tree.right; i++)
+                {
+                    double newDistance = distance(kdtree[i].coordinates, point.coordinates);
+                    if (newDistance < nearestDistance)
+                    {
+                        nearestDistance = newDistance;
+                        *result = kdtree[i];
+                        found = true;
+                    }
+                }
+                continue;
+            }
+
+            Iterator middle = tree.left + (tree.right - tree.left) / 2;
+
+            double newDistance = distance(kdtree[middle].coordinates, point.coordinates);
+            if (newDistance < nearestDistance)
+            {
+                nearestDistance = newDistance;
+                *result = kdtree[middle];
+                found = true;
+            }
+
+            Less comperator(tree.dimension);
+            if (!comperator(point, kdtree[middle]))
+            {
+                NNTree first(middle + 1, tree.right, (tree.dimension + 1) % k, tree.box);
+                NNTree second(tree.left, middle, (tree.dimension + 1) % k, tree.box);
+                first.box.min[tree.dimension] = kdtree[middle].coordinates[tree.dimension];
+                second.box.max[tree.dimension] = kdtree[middle].coordinates[tree.dimension];
+                s.push(second);
+                s.push(first);
+            }
+            else
+            {
+                NNTree first(middle + 1, tree.right, (tree.dimension + 1) % k, tree.box);
+                NNTree second(tree.left, middle, (tree.dimension + 1) % k, tree.box);
+                first.box.min[tree.dimension] = kdtree[middle].coordinates[tree.dimension];
+                second.box.max[tree.dimension] = kdtree[middle].coordinates[tree.dimension];
+                s.push(first);
+                s.push(second);
+            }
+        }
+        return found;
+    }
+
+  private:
+    using Iterator = unsigned;
+    struct Tree
+    {
+        Iterator left;
+        Iterator right;
+        unsigned dimension;
+        Tree() {}
+        Tree(Iterator l, Iterator r, unsigned d) : left(l), right(r), dimension(d) {}
+    };
+    struct NNTree
+    {
+        Iterator left;
+        Iterator right;
+        unsigned dimension;
+        BoundingBox<k, T> box;
+        NNTree() {}
+        NNTree(Iterator l, Iterator r, unsigned d, const BoundingBox<k, T> &b)
+            : left(l), right(r), dimension(d), box(b)
+        {
+        }
+    };
+    class Less
+    {
+      public:
+        explicit Less(unsigned d)
+        {
+            dimension = d;
+            BOOST_ASSERT(dimension < k);
+        }
+
+        bool operator()(const InputPoint &left, const InputPoint &right)
+        {
+            BOOST_ASSERT(dimension < k);
+            return left.coordinates[dimension] < right.coordinates[dimension];
+        }
+
+      private:
+        unsigned dimension;
+    };
+
+    BoundingBox<k, T> boundingBox;
+    InputPoint *kdtree;
+    Iterator size;
+};
+}
+
+#endif // STATICKDTREE_HPP
@@ -1,17 +1,46 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
 #ifndef STATIC_RTREE_HPP
 #define STATIC_RTREE_HPP

-#include "util/deallocating_vector.hpp"
-#include "util/hilbert_value.hpp"
-#include "util/rectangle.hpp"
-#include "util/shared_memory_vector_wrapper.hpp"
+#include "deallocating_vector.hpp"
+#include "hilbert_value.hpp"
+#include "rectangle.hpp"
+#include "shared_memory_factory.hpp"
+#include "shared_memory_vector_wrapper.hpp"

-#include "util/bearing.hpp"
-#include "util/integer_range.hpp"
-#include "util/exception.hpp"
-#include "util/typedefs.hpp"
+#include "../util/bearing.hpp"
+#include "../util/integer_range.hpp"
+#include "../util/mercator.hpp"
+#include "../util/osrm_exception.hpp"
+#include "../typedefs.h"

-#include "osrm/coordinate.hpp"
+#include <osrm/coordinate.hpp>

 #include <boost/assert.hpp>
 #include <boost/filesystem.hpp>
@@ -30,17 +59,12 @@
 #include <string>
 #include <vector>

-namespace osrm
-{
-namespace util
-{
-
 // Static RTree for serving nearest neighbour queries
 template <class EdgeDataT,
-          class CoordinateListT = std::vector<Coordinate>,
+          class CoordinateListT = std::vector<FixedPointCoordinate>,
          bool UseSharedMemory = false,
-          std::uint32_t BRANCHING_FACTOR = 64,
-          std::uint32_t LEAF_NODE_SIZE = 1024>
+          uint32_t BRANCHING_FACTOR = 64,
+          uint32_t LEAF_NODE_SIZE = 1024>
 class StaticRTree
 {
  public:
@@ -54,23 +78,15 @@ class StaticRTree
    {
        TreeNode() : child_count(0), child_is_on_disk(false) {}
        Rectangle minimum_bounding_rectangle;
-        std::uint32_t child_count : 31;
+        uint32_t child_count : 31;
        bool child_is_on_disk : 1;
-        std::uint32_t children[BRANCHING_FACTOR];
-    };
-
-    struct LeafNode
-    {
-        LeafNode() : object_count(0), objects() {}
-        uint32_t object_count;
-        std::array<EdgeDataT, LEAF_NODE_SIZE> objects;
+        uint32_t children[BRANCHING_FACTOR];
    };

  private:
    struct WrappedInputElement
    {
-        explicit WrappedInputElement(const uint64_t _hilbert_value,
-                                     const std::uint32_t _array_index)
+        explicit WrappedInputElement(const uint64_t _hilbert_value, const uint32_t _array_index)
            : m_hilbert_value(_hilbert_value), m_array_index(_array_index)
        {
        }
@@ -78,7 +94,7 @@ class StaticRTree
        WrappedInputElement() : m_hilbert_value(0), m_array_index(UINT_MAX) {}

        uint64_t m_hilbert_value;
-        std::uint32_t m_array_index;
+        uint32_t m_array_index;

        inline bool operator<(const WrappedInputElement &other) const
        {
@@ -86,6 +102,13 @@ class StaticRTree
        }
    };

+    struct LeafNode
+    {
+        LeafNode() : object_count(0), objects() {}
+        uint32_t object_count;
+        std::array<EdgeDataT, LEAF_NODE_SIZE> objects;
+    };
+
    using QueryNodeType = mapbox::util::variant<TreeNode, EdgeDataT>;
    struct QueryCandidate
    {
@@ -106,8 +129,8 @@ class StaticRTree
    boost::filesystem::ifstream leaves_stream;

  public:
+    StaticRTree() = delete;
    StaticRTree(const StaticRTree &) = delete;
-    StaticRTree &operator=(const StaticRTree &) = delete;

    template <typename CoordinateT>
    // Construct a packed Hilbert-R-Tree with Kamel-Faloutsos algorithm [1]
@@ -119,10 +142,12 @@ class StaticRTree
    {
        std::vector<WrappedInputElement> input_wrapper_vector(m_element_count);

+        HilbertCode get_hilbert_number;
+
        // generate auxiliary vector of hilbert-values
        tbb::parallel_for(
            tbb::blocked_range<uint64_t>(0, m_element_count),
-            [&input_data_vector, &input_wrapper_vector,
+            [&input_data_vector, &input_wrapper_vector, &get_hilbert_number,
             &coordinate_list](const tbb::blocked_range<uint64_t> &range)
            {
                for (uint64_t element_counter = range.begin(), end = range.end();
@@ -134,19 +159,16 @@ class StaticRTree
                    EdgeDataT const &current_element = input_data_vector[element_counter];

                    // Get Hilbert-Value for centroid in mercartor projection
-                    BOOST_ASSERT(current_element.u < coordinate_list.size());
-                    BOOST_ASSERT(current_element.v < coordinate_list.size());
-
-                    Coordinate current_centroid =
-                        EdgeDataT::Centroid(Coordinate(coordinate_list[current_element.u].lon,
-                                                       coordinate_list[current_element.u].lat),
-                                            Coordinate(coordinate_list[current_element.v].lon,
-                                                       coordinate_list[current_element.v].lat));
-                    current_centroid.lat = FixedLatitude(
+                    FixedPointCoordinate current_centroid = EdgeDataT::Centroid(
+                        FixedPointCoordinate(coordinate_list.at(current_element.u).lat,
+                                             coordinate_list.at(current_element.u).lon),
+                        FixedPointCoordinate(coordinate_list.at(current_element.v).lat,
+                                             coordinate_list.at(current_element.v).lon));
+                    current_centroid.lat =
                        COORDINATE_PRECISION *
-                        coordinate_calculation::mercator::latToY(toFloating(current_centroid.lat)));
+                        mercator::lat2y(current_centroid.lat / COORDINATE_PRECISION);

-                    current_wrapper.m_hilbert_value = hilbertCode(current_centroid);
+                    current_wrapper.m_hilbert_value = get_hilbert_number(current_centroid);
                }
            });

@@ -165,12 +187,12 @@ class StaticRTree

            LeafNode current_leaf;
            TreeNode current_node;
-            for (std::uint32_t current_element_index = 0; LEAF_NODE_SIZE > current_element_index;
+            for (uint32_t current_element_index = 0; LEAF_NODE_SIZE > current_element_index;
                 ++current_element_index)
            {
                if (m_element_count > (processed_objects_count + current_element_index))
                {
-                    std::uint32_t index_of_next_object =
+                    uint32_t index_of_next_object =
                        input_wrapper_vector[processed_objects_count + current_element_index]
                            .m_array_index;
                    current_leaf.objects[current_element_index] =
@@ -191,16 +213,19 @@ class StaticRTree
            processed_objects_count += current_leaf.object_count;
        }

-        std::uint32_t processing_level = 0;
+        // close leaf file
+        leaf_node_file.close();
+
+        uint32_t processing_level = 0;
        while (1 < tree_nodes_in_level.size())
        {
            std::vector<TreeNode> tree_nodes_in_next_level;
-            std::uint32_t processed_tree_nodes_in_level = 0;
+            uint32_t processed_tree_nodes_in_level = 0;
            while (processed_tree_nodes_in_level < tree_nodes_in_level.size())
            {
                TreeNode parent_node;
                // pack BRANCHING_FACTOR elements into tree_nodes each
-                for (std::uint32_t current_child_node_index = 0;
+                for (uint32_t current_child_node_index = 0;
                     BRANCHING_FACTOR > current_child_node_index; ++current_child_node_index)
                {
                    if (processed_tree_nodes_in_level < tree_nodes_in_level.size())
@@ -230,18 +255,17 @@ class StaticRTree
        // reverse and renumber tree to have root at index 0
        std::reverse(m_search_tree.begin(), m_search_tree.end());

-        std::uint32_t search_tree_size = m_search_tree.size();
-        tbb::parallel_for(tbb::blocked_range<std::uint32_t>(0, search_tree_size),
-                          [this, &search_tree_size](const tbb::blocked_range<std::uint32_t> &range)
+        uint32_t search_tree_size = m_search_tree.size();
+        tbb::parallel_for(tbb::blocked_range<uint32_t>(0, search_tree_size),
+                          [this, &search_tree_size](const tbb::blocked_range<uint32_t> &range)
                          {
-                              for (std::uint32_t i = range.begin(), end = range.end(); i != end;
-                                   ++i)
+                              for (uint32_t i = range.begin(), end = range.end(); i != end; ++i)
                              {
                                  TreeNode &current_tree_node = this->m_search_tree[i];
-                                  for (std::uint32_t j = 0; j < current_tree_node.child_count; ++j)
+                                  for (uint32_t j = 0; j < current_tree_node.child_count; ++j)
                                  {
-                                      const std::uint32_t old_id = current_tree_node.children[j];
-                                      const std::uint32_t new_id = search_tree_size - old_id - 1;
+                                      const uint32_t old_id = current_tree_node.children[j];
+                                      const uint32_t new_id = search_tree_size - old_id - 1;
                                      current_tree_node.children[j] = new_id;
                                  }
                              }
@@ -250,10 +274,12 @@ class StaticRTree
        // open tree file
        boost::filesystem::ofstream tree_node_file(tree_node_filename, std::ios::binary);

-        std::uint32_t size_of_tree = m_search_tree.size();
+        uint32_t size_of_tree = m_search_tree.size();
        BOOST_ASSERT_MSG(0 < size_of_tree, "tree empty");
-        tree_node_file.write((char *)&size_of_tree, sizeof(std::uint32_t));
+        tree_node_file.write((char *)&size_of_tree, sizeof(uint32_t));
        tree_node_file.write((char *)&m_search_tree[0], sizeof(TreeNode) * size_of_tree);
+        // close tree node file.
+        tree_node_file.close();
    }

    explicit StaticRTree(const boost::filesystem::path &node_file,
@@ -266,31 +292,31 @@ class StaticRTree

        if (!boost::filesystem::exists(node_file))
        {
-            throw exception("ram index file does not exist");
+            throw osrm::exception("ram index file does not exist");
        }
        if (0 == boost::filesystem::file_size(node_file))
        {
-            throw exception("ram index file is empty");
+            throw osrm::exception("ram index file is empty");
        }
        boost::filesystem::ifstream tree_node_file(node_file, std::ios::binary);

-        std::uint32_t tree_size = 0;
-        tree_node_file.read((char *)&tree_size, sizeof(std::uint32_t));
+        uint32_t tree_size = 0;
+        tree_node_file.read((char *)&tree_size, sizeof(uint32_t));

        m_search_tree.resize(tree_size);
        if (tree_size > 0)
        {
            tree_node_file.read((char *)&m_search_tree[0], sizeof(TreeNode) * tree_size);
        }
-
+        tree_node_file.close();
        // open leaf node file and store thread specific pointer
        if (!boost::filesystem::exists(leaf_file))
        {
-            throw exception("mem index file does not exist");
+            throw osrm::exception("mem index file does not exist");
        }
        if (0 == boost::filesystem::file_size(leaf_file))
        {
-            throw exception("mem index file is empty");
+            throw osrm::exception("mem index file is empty");
        }

        leaves_stream.open(leaf_file, std::ios::binary);
@@ -307,77 +333,20 @@ class StaticRTree
        // open leaf node file and store thread specific pointer
        if (!boost::filesystem::exists(leaf_file))
        {
-            throw exception("mem index file does not exist");
+            throw osrm::exception("mem index file does not exist");
        }
        if (0 == boost::filesystem::file_size(leaf_file))
        {
-            throw exception("mem index file is empty");
+            throw osrm::exception("mem index file is empty");
        }

        leaves_stream.open(leaf_file, std::ios::binary);
        leaves_stream.read((char *)&m_element_count, sizeof(uint64_t));
    }

-    /* Returns all features inside the bounding box */
-    std::vector<EdgeDataT> SearchInBox(const Rectangle &search_rectangle)
-    {
-        std::vector<EdgeDataT> results;
-
-        std::queue<TreeNode> traversal_queue;
-
-        traversal_queue.push(m_search_tree[0]);
-
-        while (!traversal_queue.empty())
-        {
-            auto const current_tree_node = traversal_queue.front();
-            traversal_queue.pop();
-
-            if (current_tree_node.child_is_on_disk)
-            {
-                LeafNode current_leaf_node;
-                LoadLeafFromDisk(current_tree_node.children[0], current_leaf_node);
-
-                for (const auto i : irange(0u, current_leaf_node.object_count))
-                {
-                    const auto &current_edge = current_leaf_node.objects[i];
-
-                    const Rectangle bbox{std::min((*m_coordinate_list)[current_edge.u].lon,
-                                                  (*m_coordinate_list)[current_edge.v].lon),
-                                         std::max((*m_coordinate_list)[current_edge.u].lon,
-                                                  (*m_coordinate_list)[current_edge.v].lon),
-                                         std::min((*m_coordinate_list)[current_edge.u].lat,
-                                                  (*m_coordinate_list)[current_edge.v].lat),
-                                         std::max((*m_coordinate_list)[current_edge.u].lat,
-                                                  (*m_coordinate_list)[current_edge.v].lat)};
-
-                    if (bbox.Intersects(search_rectangle))
-                    {
-                        results.push_back(current_edge);
-                    }
-                }
-            }
-            else
-            {
-                // If it's a tree node, look at all children and add them
-                // to the search queue if their bounding boxes intersect
-                for (std::uint32_t i = 0; i < current_tree_node.child_count; ++i)
-                {
-                    const std::int32_t child_id = current_tree_node.children[i];
-                    const auto &child_tree_node = m_search_tree[child_id];
-                    const auto &child_rectangle = child_tree_node.minimum_bounding_rectangle;
-
-                    if (child_rectangle.Intersects(search_rectangle))
-                    {
-                        traversal_queue.push(m_search_tree[child_id]);
-                    }
-                }
-            }
-        }
-        return results;
-    }
-
    // Override filter and terminator for the desired behaviour.
-    std::vector<EdgeDataT> Nearest(const Coordinate input_coordinate, const std::size_t max_results)
+    std::vector<EdgeDataT> Nearest(const FixedPointCoordinate &input_coordinate,
+                                const std::size_t max_results)
    {
        return Nearest(input_coordinate,
                       [](const EdgeDataT &)
@@ -392,17 +361,18 @@ class StaticRTree

    // Override filter and terminator for the desired behaviour.
    template <typename FilterT, typename TerminationT>
-    std::vector<EdgeDataT>
-    Nearest(const Coordinate input_coordinate, const FilterT filter, const TerminationT terminate)
+    std::vector<EdgeDataT> Nearest(const FixedPointCoordinate &input_coordinate,
+                                const FilterT filter,
+                                const TerminationT terminate)
    {
        std::vector<EdgeDataT> results;
        std::pair<double, double> projected_coordinate = {
-            static_cast<double>(toFloating(input_coordinate.lon)),
-            coordinate_calculation::mercator::latToY(toFloating(input_coordinate.lat))};
+            mercator::lat2y(input_coordinate.lat / COORDINATE_PRECISION),
+            input_coordinate.lon / COORDINATE_PRECISION};

        // initialize queue with root element
        std::priority_queue<QueryCandidate> traversal_queue;
-        traversal_queue.push(QueryCandidate{0.f, m_search_tree[0]});
+        traversal_queue.push(QueryCandidate {0.f, m_search_tree[0]});

        while (!traversal_queue.empty())
        {
@@ -434,6 +404,7 @@ class StaticRTree
                // inspecting an actual road segment
                const auto &current_segment = current_query_node.node.template get<EdgeDataT>();

+
                auto use_segment = filter(current_segment);
                if (!use_segment.first && !use_segment.second)
                {
@@ -460,7 +431,7 @@ class StaticRTree
  private:
    template <typename QueueT>
    void ExploreLeafNode(const std::uint32_t leaf_id,
-                         const Coordinate input_coordinate,
+                         const FixedPointCoordinate &input_coordinate,
                         const std::pair<double, double> &projected_coordinate,
                         QueueT &traversal_queue)
    {
@@ -468,37 +439,36 @@ class StaticRTree
        LoadLeafFromDisk(leaf_id, current_leaf_node);

        // current object represents a block on disk
-        for (const auto i : irange(0u, current_leaf_node.object_count))
+        for (const auto i : osrm::irange(0u, current_leaf_node.object_count))
        {
            auto &current_edge = current_leaf_node.objects[i];
            const float current_perpendicular_distance =
-                coordinate_calculation::perpendicularDistanceFromProjectedCoordinate(
+                coordinate_calculation::perpendicular_distance_from_projected_coordinate(
                    m_coordinate_list->at(current_edge.u), m_coordinate_list->at(current_edge.v),
                    input_coordinate, projected_coordinate);
            // distance must be non-negative
            BOOST_ASSERT(0.f <= current_perpendicular_distance);

-            traversal_queue.push(
-                QueryCandidate{current_perpendicular_distance, std::move(current_edge)});
+            traversal_queue.push(QueryCandidate {current_perpendicular_distance, std::move(current_edge)});
        }
    }

    template <class QueueT>
    void ExploreTreeNode(const TreeNode &parent,
-                         const Coordinate input_coordinate,
+                         const FixedPointCoordinate &input_coordinate,
                         QueueT &traversal_queue)
    {
-        for (std::uint32_t i = 0; i < parent.child_count; ++i)
+        for (uint32_t i = 0; i < parent.child_count; ++i)
        {
-            const std::int32_t child_id = parent.children[i];
+            const int32_t child_id = parent.children[i];
            const auto &child_tree_node = m_search_tree[child_id];
            const auto &child_rectangle = child_tree_node.minimum_bounding_rectangle;
            const float lower_bound_to_element = child_rectangle.GetMinDist(input_coordinate);
-            traversal_queue.push(QueryCandidate{lower_bound_to_element, m_search_tree[child_id]});
+            traversal_queue.push(QueryCandidate {lower_bound_to_element, m_search_tree[child_id]});
        }
    }

-    inline void LoadLeafFromDisk(const std::uint32_t leaf_id, LeafNode &result_node)
+    inline void LoadLeafFromDisk(const uint32_t leaf_id, LeafNode &result_node)
    {
        if (!leaves_stream.is_open())
        {
@@ -506,7 +476,7 @@ class StaticRTree
        }
        if (!leaves_stream.good())
        {
-            throw exception("Could not read from leaf file.");
+          throw osrm::exception("Could not read from leaf file.");
        }
        const uint64_t seek_pos = sizeof(uint64_t) + leaf_id * sizeof(LeafNode);
        leaves_stream.seekg(seek_pos);
@@ -518,32 +488,29 @@ class StaticRTree
    template <typename CoordinateT>
    void InitializeMBRectangle(Rectangle &rectangle,
                               const std::array<EdgeDataT, LEAF_NODE_SIZE> &objects,
-                               const std::uint32_t element_count,
+                               const uint32_t element_count,
                               const std::vector<CoordinateT> &coordinate_list)
    {
-        for (std::uint32_t i = 0; i < element_count; ++i)
+        for (uint32_t i = 0; i < element_count; ++i)
        {
-            BOOST_ASSERT(objects[i].u < coordinate_list.size());
-            BOOST_ASSERT(objects[i].v < coordinate_list.size());
-
            rectangle.min_lon =
-                std::min(rectangle.min_lon, std::min(coordinate_list[objects[i].u].lon,
-                                                     coordinate_list[objects[i].v].lon));
+                std::min(rectangle.min_lon, std::min(coordinate_list.at(objects[i].u).lon,
+                                                     coordinate_list.at(objects[i].v).lon));
            rectangle.max_lon =
-                std::max(rectangle.max_lon, std::max(coordinate_list[objects[i].u].lon,
-                                                     coordinate_list[objects[i].v].lon));
+                std::max(rectangle.max_lon, std::max(coordinate_list.at(objects[i].u).lon,
+                                                     coordinate_list.at(objects[i].v).lon));

            rectangle.min_lat =
-                std::min(rectangle.min_lat, std::min(coordinate_list[objects[i].u].lat,
-                                                     coordinate_list[objects[i].v].lat));
+                std::min(rectangle.min_lat, std::min(coordinate_list.at(objects[i].u).lat,
+                                                     coordinate_list.at(objects[i].v).lat));
            rectangle.max_lat =
-                std::max(rectangle.max_lat, std::max(coordinate_list[objects[i].u].lat,
-                                                     coordinate_list[objects[i].v].lat));
+                std::max(rectangle.max_lat, std::max(coordinate_list.at(objects[i].u).lat,
+                                                     coordinate_list.at(objects[i].v).lat));
        }
-        BOOST_ASSERT(rectangle.min_lon != FixedLongitude(std::numeric_limits<int>::min()));
-        BOOST_ASSERT(rectangle.min_lat != FixedLatitude(std::numeric_limits<int>::min()));
-        BOOST_ASSERT(rectangle.max_lon != FixedLongitude(std::numeric_limits<int>::min()));
-        BOOST_ASSERT(rectangle.max_lat != FixedLatitude(std::numeric_limits<int>::min()));
+        BOOST_ASSERT(rectangle.min_lat != std::numeric_limits<int>::min());
+        BOOST_ASSERT(rectangle.min_lon != std::numeric_limits<int>::min());
+        BOOST_ASSERT(rectangle.max_lat != std::numeric_limits<int>::min());
+        BOOST_ASSERT(rectangle.max_lon != std::numeric_limits<int>::min());
    }
 };

@@ -551,7 +518,4 @@ class StaticRTree
 //[2] "Nearest Neighbor Queries", N. Roussopulos et al; 1995; DOI: 10.1145/223784.223794
 //[3] "Distance Browsing in Spatial Databases"; G. Hjaltason, H. Samet; 1999; ACM Trans. DB Sys
 // Vol.24 No.2, pp.265-318
-}
-}
-
 #endif // STATIC_RTREE_HPP
@@ -0,0 +1,37 @@
+/*
+
+Copyright (c) 2014, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef TRAVEL_MODE_HPP
+#define TRAVEL_MODE_HPP
+
+namespace
+{
+using TravelMode = unsigned char;
+static const TravelMode TRAVEL_MODE_INACCESSIBLE = 0;
+static const TravelMode TRAVEL_MODE_DEFAULT = 1;
+}
+#endif /* TRAVEL_MODE_HPP */
@@ -1,6 +1,6 @@
 /*

-Copyright (c) 2016, Project OSRM contributors
+Copyright (c) 2015, Project OSRM contributors
 All rights reserved.

 Redistribution and use in source and binary forms, with or without modification,
@@ -25,20 +25,16 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

-#ifndef ENGINE_STATUS_HPP
-#define ENGINE_STATUS_HPP
+#ifndef TRIBOOL_HPP
+#define TRIBOOL_HPP

 namespace osrm
 {
-namespace engine
+enum class tribool : char
 {
-
-enum class Status
-{
-    Ok,
-    Error
+    yes,
+    no,
+    indeterminate
 };
 }
-}
-
-#endif
+#endif // TRIBOOL_HPP
@@ -0,0 +1,105 @@
+/*
+
+Copyright (c) 2014, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef TURN_INSTRUCTIONS_HPP
+#define TURN_INSTRUCTIONS_HPP
+
+enum class TurnInstruction : unsigned char
+{
+    NoTurn = 0,
+    GoStraight,
+    TurnSlightRight,
+    TurnRight,
+    TurnSharpRight,
+    UTurn,
+    TurnSharpLeft,
+    TurnLeft,
+    TurnSlightLeft,
+    ReachViaLocation,
+    HeadOn,
+    EnterRoundAbout,
+    LeaveRoundAbout,
+    StayOnRoundAbout,
+    StartAtEndOfStreet,
+    ReachedYourDestination,
+    EnterAgainstAllowedDirection,
+    LeaveAgainstAllowedDirection,
+    InverseAccessRestrictionFlag = 127,
+    AccessRestrictionFlag = 128,
+    AccessRestrictionPenalty = 129
+};
+
+struct TurnInstructionsClass
+{
+    TurnInstructionsClass() = delete;
+    TurnInstructionsClass(const TurnInstructionsClass &) = delete;
+
+    static inline TurnInstruction GetTurnDirectionOfInstruction(const double angle)
+    {
+        if (angle >= 23 && angle < 67)
+        {
+            return TurnInstruction::TurnSharpRight;
+        }
+        if (angle >= 67 && angle < 113)
+        {
+            return TurnInstruction::TurnRight;
+        }
+        if (angle >= 113 && angle < 158)
+        {
+            return TurnInstruction::TurnSlightRight;
+        }
+        if (angle >= 158 && angle < 202)
+        {
+            return TurnInstruction::GoStraight;
+        }
+        if (angle >= 202 && angle < 248)
+        {
+            return TurnInstruction::TurnSlightLeft;
+        }
+        if (angle >= 248 && angle < 292)
+        {
+            return TurnInstruction::TurnLeft;
+        }
+        if (angle >= 292 && angle < 336)
+        {
+            return TurnInstruction::TurnSharpLeft;
+        }
+        return TurnInstruction::UTurn;
+    }
+
+    static inline bool TurnIsNecessary(const TurnInstruction turn_instruction)
+    {
+        if (TurnInstruction::NoTurn == turn_instruction ||
+            TurnInstruction::StayOnRoundAbout == turn_instruction)
+        {
+            return false;
+        }
+        return true;
+    }
+};
+
+#endif /* TURN_INSTRUCTIONS_HPP */
@@ -0,0 +1,77 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef LOWER_BOUND_HPP
+#define LOWER_BOUND_HPP
+
+#include <functional>
+#include <limits>
+#include <queue>
+#include <type_traits>
+
+// max pq holds k elements
+// insert if key is smaller than max
+// if size > k then remove element
+// get() always yields a bound to the k smallest element in the stream
+
+template <typename key_type> class upper_bound
+{
+  private:
+    using parameter_type =
+        typename std::conditional<std::is_fundamental<key_type>::value, key_type, key_type &>::type;
+
+  public:
+    upper_bound() = delete;
+    upper_bound(std::size_t size) : size(size) {}
+
+    key_type get() const
+    {
+        if (queue.size() < size)
+        {
+            return std::numeric_limits<key_type>::max();
+        }
+        return queue.top();
+    }
+
+    void insert(const parameter_type key)
+    {
+        if (key < get())
+        {
+            queue.emplace(key);
+            while (queue.size() > size)
+            {
+                queue.pop();
+            }
+        }
+    }
+
+  private:
+    std::priority_queue<key_type, std::vector<key_type>, std::less<key_type>> queue;
+    const std::size_t size;
+};
+
+#endif // LOWER_BOUND_HPP
@@ -0,0 +1,115 @@
+/*
+
+Copyright (c) 2013, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef XOR_FAST_HASH_HPP
+#define XOR_FAST_HASH_HPP
+
+#include <algorithm>
+#include <vector>
+
+/*
+    This is an implementation of Tabulation hashing, which has suprising properties like
+   universality.
+    The space requirement is 2*2^16 = 256 kb of memory, which fits into L2 cache.
+    Evaluation boils down to 10 or less assembly instruction on any recent X86 CPU:
+
+    1: movq    table2(%rip), %rdx
+    2: movl    %edi, %eax
+    3: movzwl  %di, %edi
+    4: shrl    $16, %eax
+    5: movzwl  %ax, %eax
+    6: movzbl  (%rdx,%rax), %eax
+    7: movq    table1(%rip), %rdx
+    8: xorb    (%rdx,%rdi), %al
+    9: movzbl  %al, %eax
+    10: ret
+
+*/
+class XORFastHash
+{ // 65k entries
+    std::vector<unsigned short> table1;
+    std::vector<unsigned short> table2;
+
+  public:
+    XORFastHash()
+    {
+        table1.resize(2 << 16);
+        table2.resize(2 << 16);
+        for (unsigned i = 0; i < (2 << 16); ++i)
+        {
+            table1[i] = static_cast<unsigned short>(i);
+            table2[i] = static_cast<unsigned short>(i);
+        }
+        std::random_shuffle(table1.begin(), table1.end());
+        std::random_shuffle(table2.begin(), table2.end());
+    }
+
+    inline unsigned short operator()(const unsigned originalValue) const
+    {
+        unsigned short lsb = ((originalValue)&0xffff);
+        unsigned short msb = (((originalValue) >> 16) & 0xffff);
+        return table1[lsb] ^ table2[msb];
+    }
+};
+
+class XORMiniHash
+{ // 256 entries
+    std::vector<unsigned char> table1;
+    std::vector<unsigned char> table2;
+    std::vector<unsigned char> table3;
+    std::vector<unsigned char> table4;
+
+  public:
+    XORMiniHash()
+    {
+        table1.resize(1 << 8);
+        table2.resize(1 << 8);
+        table3.resize(1 << 8);
+        table4.resize(1 << 8);
+        for (unsigned i = 0; i < (1 << 8); ++i)
+        {
+            table1[i] = static_cast<unsigned char>(i);
+            table2[i] = static_cast<unsigned char>(i);
+            table3[i] = static_cast<unsigned char>(i);
+            table4[i] = static_cast<unsigned char>(i);
+        }
+        std::random_shuffle(table1.begin(), table1.end());
+        std::random_shuffle(table2.begin(), table2.end());
+        std::random_shuffle(table3.begin(), table3.end());
+        std::random_shuffle(table4.begin(), table4.end());
+    }
+    unsigned char operator()(const unsigned originalValue) const
+    {
+        unsigned char byte1 = ((originalValue)&0xff);
+        unsigned char byte2 = ((originalValue >> 8) & 0xff);
+        unsigned char byte3 = ((originalValue >> 16) & 0xff);
+        unsigned char byte4 = ((originalValue >> 24) & 0xff);
+        return table1[byte1] ^ table2[byte2] ^ table3[byte3] ^ table4[byte4];
+    }
+};
+
+#endif // XOR_FAST_HASH_HPP
@@ -0,0 +1,101 @@
+/*
+
+Copyright (c) 2013, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef XOR_FAST_HASH_STORAGE_HPP
+#define XOR_FAST_HASH_STORAGE_HPP
+
+#include "xor_fast_hash.hpp"
+
+#include <limits>
+#include <vector>
+
+template <typename NodeID, typename Key> class XORFastHashStorage
+{
+  public:
+    struct HashCell
+    {
+        unsigned time;
+        NodeID id;
+        Key key;
+        HashCell()
+            : time(std::numeric_limits<unsigned>::max()), id(std::numeric_limits<unsigned>::max()),
+              key(std::numeric_limits<unsigned>::max())
+        {
+        }
+
+        HashCell(const HashCell &other) : time(other.key), id(other.id), key(other.time) {}
+
+        operator Key() const { return key; }
+
+        void operator=(const Key key_to_insert) { key = key_to_insert; }
+    };
+
+    XORFastHashStorage() = delete;
+
+    explicit XORFastHashStorage(size_t) : positions(2 << 16), current_timestamp(0) {}
+
+    HashCell &operator[](const NodeID node)
+    {
+        unsigned short position = fast_hasher(node);
+        while ((positions[position].time == current_timestamp) && (positions[position].id != node))
+        {
+            ++position %= (2 << 16);
+        }
+
+        positions[position].time = current_timestamp;
+        positions[position].id = node;
+        return positions[position];
+    }
+
+    // peek into table, get key for node, think of it as a read-only operator[]
+    Key peek_index(const NodeID node) const
+    {
+        unsigned short position = fast_hasher(node);
+        while ((positions[position].time == current_timestamp) && (positions[position].id != node))
+        {
+            ++position %= (2 << 16);
+        }
+        return positions[position].key;
+    }
+
+    void Clear()
+    {
+        ++current_timestamp;
+        if (std::numeric_limits<unsigned>::max() == current_timestamp)
+        {
+            positions.clear();
+            positions.resize(2 << 16);
+        }
+    }
+
+  private:
+    std::vector<HashCell> positions;
+    XORFastHash fast_hasher;
+    unsigned current_timestamp;
+};
+
+#endif // XOR_FAST_HASH_STORAGE_HPP
@@ -1,23 +1,54 @@
-#include "extractor/original_edge_data.hpp"
-#include "util/range_table.hpp"
-#include "contractor/query_edge.hpp"
-#include "extractor/query_node.hpp"
-#include "extractor/compressed_edge_container.hpp"
-#include "util/shared_memory_vector_wrapper.hpp"
-#include "util/static_graph.hpp"
-#include "util/static_rtree.hpp"
-#include "engine/datafacade/datafacade_base.hpp"
-#include "extractor/travel_mode.hpp"
-#include "extractor/guidance/turn_instruction.hpp"
-#include "storage/storage.hpp"
-#include "storage/shared_datatype.hpp"
-#include "storage/shared_barriers.hpp"
-#include "storage/shared_memory.hpp"
-#include "util/fingerprint.hpp"
-#include "util/exception.hpp"
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#include "data_structures/original_edge_data.hpp"
+#include "data_structures/range_table.hpp"
+#include "data_structures/query_edge.hpp"
+#include "data_structures/query_node.hpp"
+#include "data_structures/shared_memory_factory.hpp"
+#include "data_structures/shared_memory_vector_wrapper.hpp"
+#include "data_structures/static_graph.hpp"
+#include "data_structures/static_rtree.hpp"
+#include "data_structures/travel_mode.hpp"
+#include "data_structures/turn_instructions.hpp"
+#include "server/data_structures/datafacade_base.hpp"
+#include "server/data_structures/shared_datatype.hpp"
+#include "server/data_structures/shared_barriers.hpp"
+#include "util/datastore_options.hpp"
 #include "util/simple_logger.hpp"
-#include "util/typedefs.hpp"
-#include "util/coordinate.hpp"
+#include "util/osrm_exception.hpp"
+#include "util/fingerprint.hpp"
+#include "typedefs.h"
+
+#include <osrm/coordinate.hpp>
+
+using RTreeLeaf = BaseDataFacade<QueryEdge::EdgeData>::RTreeLeaf;
+using RTreeNode = StaticRTree<RTreeLeaf, ShM<FixedPointCoordinate, true>::vector, true>::TreeNode;
+using QueryGraph = StaticGraph<QueryEdge::EdgeData>;

 #ifdef __linux__
 #include <sys/mman.h>
@@ -29,21 +60,11 @@
 #include <cstdint>

 #include <fstream>
-#include <new>
 #include <string>
-
-namespace osrm
-{
-namespace storage
-{
-
-using RTreeLeaf = typename engine::datafacade::BaseDataFacade::RTreeLeaf;
-using RTreeNode =
-    util::StaticRTree<RTreeLeaf, util::ShM<util::Coordinate, true>::vector, true>::TreeNode;
-using QueryGraph = util::StaticGraph<contractor::QueryEdge::EdgeData>;
+#include <new>

 // delete a shared memory region. report warning if it could not be deleted
-void deleteRegion(const SharedDataType region)
+void delete_region(const SharedDataType region)
 {
    if (SharedMemory::RegionExists(region) && !SharedMemory::Remove(region))
    {
@@ -68,15 +89,13 @@ void deleteRegion(const SharedDataType region)
            }
        }();

-        util::SimpleLogger().Write(logWARNING) << "could not delete shared memory region " << name;
+        SimpleLogger().Write(logWARNING) << "could not delete shared memory region " << name;
    }
 }

-Storage::Storage(const DataPaths &paths_) : paths(paths_) {}
-
-int Storage::Run()
+int main(const int argc, const char *argv[]) try
 {
-    util::LogPolicy::GetInstance().Unmute();
+    LogPolicy::GetInstance().Unmute();
    SharedBarriers barrier;

 #ifdef __linux__
@@ -84,7 +103,7 @@ int Storage::Run()
    const bool lock_flags = MCL_CURRENT | MCL_FUTURE;
    if (-1 == mlockall(lock_flags))
    {
-        util::SimpleLogger().Write(logWARNING) << "Could not request RAM lock";
+        SimpleLogger().Write(logWARNING) << "Process " << argv[0] << " could not request RAM lock";
    }
 #endif

@@ -99,130 +118,122 @@ int Storage::Run()
        barrier.pending_update_mutex.unlock();
    }

-    if (paths.find("hsgrdata") == paths.end())
+    SimpleLogger().Write(logDEBUG) << "Checking input parameters";
+
+    std::unordered_map<std::string, boost::filesystem::path> server_paths;
+    if (!GenerateDataStoreOptions(argc, argv, server_paths))
    {
-        throw util::exception("no hsgr file found");
-    }
-    if (paths.find("ramindex") == paths.end())
-    {
-        throw util::exception("no ram index file found");
-    }
-    if (paths.find("fileindex") == paths.end())
-    {
-        throw util::exception("no leaf index file found");
-    }
-    if (paths.find("nodesdata") == paths.end())
-    {
-        throw util::exception("no nodes file found");
-    }
-    if (paths.find("edgesdata") == paths.end())
-    {
-        throw util::exception("no edges file found");
-    }
-    if (paths.find("namesdata") == paths.end())
-    {
-        throw util::exception("no names file found");
-    }
-    if (paths.find("geometry") == paths.end())
-    {
-        throw util::exception("no geometry file found");
-    }
-    if (paths.find("core") == paths.end())
-    {
-        throw util::exception("no core file found");
-    }
-    if (paths.find("datasource_indexes") == paths.end())
-    {
-        throw util::exception("no datasource_indexes file found");
-    }
-    if (paths.find("datasource_names") == paths.end())
-    {
-        throw util::exception("no datasource_names file found");
+        return EXIT_SUCCESS;
    }

-    auto paths_iterator = paths.find("hsgrdata");
-    BOOST_ASSERT(paths.end() != paths_iterator);
+    if (server_paths.find("hsgrdata") == server_paths.end())
+    {
+        throw osrm::exception("no hsgr file found");
+    }
+    if (server_paths.find("ramindex") == server_paths.end())
+    {
+        throw osrm::exception("no ram index file found");
+    }
+    if (server_paths.find("fileindex") == server_paths.end())
+    {
+        throw osrm::exception("no leaf index file found");
+    }
+    if (server_paths.find("nodesdata") == server_paths.end())
+    {
+        throw osrm::exception("no nodes file found");
+    }
+    if (server_paths.find("edgesdata") == server_paths.end())
+    {
+        throw osrm::exception("no edges file found");
+    }
+    if (server_paths.find("namesdata") == server_paths.end())
+    {
+        throw osrm::exception("no names file found");
+    }
+    if (server_paths.find("geometry") == server_paths.end())
+    {
+        throw osrm::exception("no geometry file found");
+    }
+    if (server_paths.find("core") == server_paths.end())
+    {
+        throw osrm::exception("no core file found");
+    }
+
+    auto paths_iterator = server_paths.find("hsgrdata");
+    BOOST_ASSERT(server_paths.end() != paths_iterator);
    BOOST_ASSERT(!paths_iterator->second.empty());
    const boost::filesystem::path &hsgr_path = paths_iterator->second;
-    paths_iterator = paths.find("timestamp");
-    BOOST_ASSERT(paths.end() != paths_iterator);
+    paths_iterator = server_paths.find("timestamp");
+    BOOST_ASSERT(server_paths.end() != paths_iterator);
    BOOST_ASSERT(!paths_iterator->second.empty());
    const boost::filesystem::path &timestamp_path = paths_iterator->second;
-    paths_iterator = paths.find("ramindex");
-    BOOST_ASSERT(paths.end() != paths_iterator);
+    paths_iterator = server_paths.find("ramindex");
+    BOOST_ASSERT(server_paths.end() != paths_iterator);
    BOOST_ASSERT(!paths_iterator->second.empty());
    const boost::filesystem::path &ram_index_path = paths_iterator->second;
-    paths_iterator = paths.find("fileindex");
-    BOOST_ASSERT(paths.end() != paths_iterator);
+    paths_iterator = server_paths.find("fileindex");
+    BOOST_ASSERT(server_paths.end() != paths_iterator);
    BOOST_ASSERT(!paths_iterator->second.empty());
    const boost::filesystem::path index_file_path_absolute =
        boost::filesystem::canonical(paths_iterator->second);
    const std::string &file_index_path = index_file_path_absolute.string();
-    paths_iterator = paths.find("nodesdata");
-    BOOST_ASSERT(paths.end() != paths_iterator);
+    paths_iterator = server_paths.find("nodesdata");
+    BOOST_ASSERT(server_paths.end() != paths_iterator);
    BOOST_ASSERT(!paths_iterator->second.empty());
    const boost::filesystem::path &nodes_data_path = paths_iterator->second;
-    paths_iterator = paths.find("edgesdata");
-    BOOST_ASSERT(paths.end() != paths_iterator);
+    paths_iterator = server_paths.find("edgesdata");
+    BOOST_ASSERT(server_paths.end() != paths_iterator);
    BOOST_ASSERT(!paths_iterator->second.empty());
    const boost::filesystem::path &edges_data_path = paths_iterator->second;
-    paths_iterator = paths.find("namesdata");
-    BOOST_ASSERT(paths.end() != paths_iterator);
+    paths_iterator = server_paths.find("namesdata");
+    BOOST_ASSERT(server_paths.end() != paths_iterator);
    BOOST_ASSERT(!paths_iterator->second.empty());
    const boost::filesystem::path &names_data_path = paths_iterator->second;
-    paths_iterator = paths.find("geometry");
-    BOOST_ASSERT(paths.end() != paths_iterator);
+    paths_iterator = server_paths.find("geometry");
+    BOOST_ASSERT(server_paths.end() != paths_iterator);
    BOOST_ASSERT(!paths_iterator->second.empty());
    const boost::filesystem::path &geometries_data_path = paths_iterator->second;
-    paths_iterator = paths.find("core");
-    BOOST_ASSERT(paths.end() != paths_iterator);
+    paths_iterator = server_paths.find("core");
+    BOOST_ASSERT(server_paths.end() != paths_iterator);
    BOOST_ASSERT(!paths_iterator->second.empty());
    const boost::filesystem::path &core_marker_path = paths_iterator->second;
-    paths_iterator = paths.find("datasource_indexes");
-    BOOST_ASSERT(paths.end() != paths_iterator);
-    BOOST_ASSERT(!paths_iterator->second.empty());
-    const boost::filesystem::path &datasource_indexes_path = paths_iterator->second;
-    paths_iterator = paths.find("datasource_names");
-    BOOST_ASSERT(paths.end() != paths_iterator);
-    BOOST_ASSERT(!paths_iterator->second.empty());
-    const boost::filesystem::path &datasource_names_path = paths_iterator->second;

    // determine segment to use
    bool segment2_in_use = SharedMemory::RegionExists(LAYOUT_2);
-    const storage::SharedDataType layout_region = [&]
+    const SharedDataType layout_region = [&]
    {
        return segment2_in_use ? LAYOUT_1 : LAYOUT_2;
    }();
-    const storage::SharedDataType data_region = [&]
+    const SharedDataType data_region = [&]
    {
        return segment2_in_use ? DATA_1 : DATA_2;
    }();
-    const storage::SharedDataType previous_layout_region = [&]
+    const SharedDataType previous_layout_region = [&]
    {
        return segment2_in_use ? LAYOUT_2 : LAYOUT_1;
    }();
-    const storage::SharedDataType previous_data_region = [&]
+    const SharedDataType previous_data_region = [&]
    {
        return segment2_in_use ? DATA_2 : DATA_1;
    }();

    // Allocate a memory layout in shared memory, deallocate previous
-    auto *layout_memory = makeSharedMemory(layout_region, sizeof(SharedDataLayout));
-    auto shared_layout_ptr = new (layout_memory->Ptr()) SharedDataLayout();
+    auto *layout_memory = SharedMemoryFactory::Get(layout_region, sizeof(SharedDataLayout));
+    auto *shared_layout_ptr = new (layout_memory->Ptr()) SharedDataLayout();

    shared_layout_ptr->SetBlockSize<char>(SharedDataLayout::FILE_INDEX_PATH,
                                          file_index_path.length() + 1);

    // collect number of elements to store in shared memory object
-    util::SimpleLogger().Write() << "load names from: " << names_data_path;
+    SimpleLogger().Write() << "load names from: " << names_data_path;
    // number of entries in name index
    boost::filesystem::ifstream name_stream(names_data_path, std::ios::binary);
    unsigned name_blocks = 0;
    name_stream.read((char *)&name_blocks, sizeof(unsigned));
    shared_layout_ptr->SetBlockSize<unsigned>(SharedDataLayout::NAME_OFFSETS, name_blocks);
-    shared_layout_ptr->SetBlockSize<typename util::RangeTable<16, true>::BlockT>(
+    shared_layout_ptr->SetBlockSize<typename RangeTable<16, true>::BlockT>(
        SharedDataLayout::NAME_BLOCKS, name_blocks);
-    util::SimpleLogger().Write() << "name offsets size: " << name_blocks;
+    SimpleLogger().Write() << "name offsets size: " << name_blocks;
    BOOST_ASSERT_MSG(0 != name_blocks, "name file broken");

    unsigned number_of_chars = 0;
@@ -239,24 +250,27 @@ int Storage::Run()
                                            number_of_original_edges);
    shared_layout_ptr->SetBlockSize<unsigned>(SharedDataLayout::NAME_ID_LIST,
                                              number_of_original_edges);
-    shared_layout_ptr->SetBlockSize<extractor::TravelMode>(SharedDataLayout::TRAVEL_MODE,
-                                                           number_of_original_edges);
-    shared_layout_ptr->SetBlockSize<extractor::guidance::TurnInstruction>(
-        SharedDataLayout::TURN_INSTRUCTION, number_of_original_edges);
+    shared_layout_ptr->SetBlockSize<TravelMode>(SharedDataLayout::TRAVEL_MODE,
+                                                number_of_original_edges);
+    shared_layout_ptr->SetBlockSize<TurnInstruction>(SharedDataLayout::TURN_INSTRUCTION,
+                                                     number_of_original_edges);
+    // note: there are 32 geometry indicators in one unsigned block
+    shared_layout_ptr->SetBlockSize<unsigned>(SharedDataLayout::GEOMETRIES_INDICATORS,
+                                              number_of_original_edges);

    boost::filesystem::ifstream hsgr_input_stream(hsgr_path, std::ios::binary);

-    util::FingerPrint fingerprint_valid = util::FingerPrint::GetValid();
-    util::FingerPrint fingerprint_loaded;
-    hsgr_input_stream.read((char *)&fingerprint_loaded, sizeof(util::FingerPrint));
+    FingerPrint fingerprint_valid = FingerPrint::GetValid();
+    FingerPrint fingerprint_loaded;
+    hsgr_input_stream.read((char *)&fingerprint_loaded, sizeof(FingerPrint));
    if (fingerprint_loaded.TestGraphUtil(fingerprint_valid))
    {
-        util::SimpleLogger().Write(logDEBUG) << "Fingerprint checked out ok";
+        SimpleLogger().Write(logDEBUG) << "Fingerprint checked out ok";
    }
    else
    {
-        util::SimpleLogger().Write(logWARNING) << ".hsgr was prepared with different build. "
-                                                  "Reprocess to get rid of this warning.";
+        SimpleLogger().Write(logWARNING) << ".hsgr was prepared with different build. "
+                                            "Reprocess to get rid of this warning.";
    }

    // load checksum
@@ -292,12 +306,12 @@ int Storage::Run()
        boost::filesystem::ifstream timestamp_stream(timestamp_path);
        if (!timestamp_stream)
        {
-            util::SimpleLogger().Write(logWARNING) << timestamp_path
-                                                   << " not found. setting to default";
+            SimpleLogger().Write(logWARNING) << timestamp_path << " not found. setting to default";
        }
        else
        {
            getline(timestamp_stream, m_timestamp);
+            timestamp_stream.close();
        }
    }
    if (m_timestamp.empty())
@@ -322,8 +336,8 @@ int Storage::Run()
    boost::filesystem::ifstream nodes_input_stream(nodes_data_path, std::ios::binary);
    unsigned coordinate_list_size = 0;
    nodes_input_stream.read((char *)&coordinate_list_size, sizeof(unsigned));
-    shared_layout_ptr->SetBlockSize<util::Coordinate>(SharedDataLayout::COORDINATE_LIST,
-                                                      coordinate_list_size);
+    shared_layout_ptr->SetBlockSize<FixedPointCoordinate>(SharedDataLayout::COORDINATE_LIST,
+                                                          coordinate_list_size);

    // load geometries sizes
    std::ifstream geometry_input_stream(geometries_data_path.string().c_str(), std::ios::binary);
@@ -336,50 +350,13 @@ int Storage::Run()
    boost::iostreams::seek(geometry_input_stream, number_of_geometries_indices * sizeof(unsigned),
                           BOOST_IOS::cur);
    geometry_input_stream.read((char *)&number_of_compressed_geometries, sizeof(unsigned));
-    shared_layout_ptr->SetBlockSize<extractor::CompressedEdgeContainer::CompressedEdge>(
-        SharedDataLayout::GEOMETRIES_LIST, number_of_compressed_geometries);
-
-    // load datasource sizes.  This file is optional, and it's non-fatal if it doesn't
-    // exist.
-    std::ifstream geometry_datasource_input_stream(datasource_indexes_path.c_str(),
-                                                   std::ios::binary);
-    std::size_t number_of_compressed_datasources = 0;
-    if (geometry_datasource_input_stream)
-    {
-        geometry_datasource_input_stream.read(
-            reinterpret_cast<char *>(&number_of_compressed_datasources), sizeof(std::size_t));
-    }
-    shared_layout_ptr->SetBlockSize<uint8_t>(SharedDataLayout::DATASOURCES_LIST,
-                                             number_of_compressed_datasources);
-
-    // Load datasource name sizes.  This file is optional, and it's non-fatal if it doesn't
-    // exist
-    std::ifstream datasource_names_input_stream(datasource_names_path.c_str(), std::ios::binary);
-    std::vector<char> m_datasource_name_data;
-    std::vector<std::size_t> m_datasource_name_offsets;
-    std::vector<std::size_t> m_datasource_name_lengths;
-    if (datasource_names_input_stream)
-    {
-        std::string name;
-        while (std::getline(datasource_names_input_stream, name))
-        {
-            m_datasource_name_offsets.push_back(m_datasource_name_data.size());
-            std::copy(name.c_str(), name.c_str() + name.size(),
-                      std::back_inserter(m_datasource_name_data));
-            m_datasource_name_lengths.push_back(name.size());
-        }
-    }
-    shared_layout_ptr->SetBlockSize<char>(SharedDataLayout::DATASOURCE_NAME_DATA,
-            m_datasource_name_data.size());
-    shared_layout_ptr->SetBlockSize<std::size_t>(SharedDataLayout::DATASOURCE_NAME_OFFSETS,
-            m_datasource_name_offsets.size());
-    shared_layout_ptr->SetBlockSize<std::size_t>(SharedDataLayout::DATASOURCE_NAME_LENGTHS,
-            m_datasource_name_lengths.size());
-
+    shared_layout_ptr->SetBlockSize<unsigned>(SharedDataLayout::GEOMETRIES_LIST,
+                                              number_of_compressed_geometries);
    // allocate shared memory block
-    util::SimpleLogger().Write() << "allocating shared memory of "
-                                 << shared_layout_ptr->GetSizeOfLayout() << " bytes";
-    auto *shared_memory = makeSharedMemory(data_region, shared_layout_ptr->GetSizeOfLayout());
+    SimpleLogger().Write() << "allocating shared memory of " << shared_layout_ptr->GetSizeOfLayout()
+                           << " bytes";
+    SharedMemory *shared_memory =
+        SharedMemoryFactory::Get(data_region, shared_layout_ptr->GetSizeOfLayout());
    char *shared_memory_ptr = static_cast<char *>(shared_memory->Ptr());

    // read actual data into shared memory object //
@@ -440,22 +417,39 @@ int Storage::Run()
    unsigned *name_id_ptr = shared_layout_ptr->GetBlockPtr<unsigned, true>(
        shared_memory_ptr, SharedDataLayout::NAME_ID_LIST);

-    extractor::TravelMode *travel_mode_ptr =
-        shared_layout_ptr->GetBlockPtr<extractor::TravelMode, true>(shared_memory_ptr,
-                                                                    SharedDataLayout::TRAVEL_MODE);
+    TravelMode *travel_mode_ptr = shared_layout_ptr->GetBlockPtr<TravelMode, true>(
+        shared_memory_ptr, SharedDataLayout::TRAVEL_MODE);

-    extractor::guidance::TurnInstruction *turn_instructions_ptr =
-        shared_layout_ptr->GetBlockPtr<extractor::guidance::TurnInstruction, true>(
-            shared_memory_ptr, SharedDataLayout::TURN_INSTRUCTION);
+    TurnInstruction *turn_instructions_ptr = shared_layout_ptr->GetBlockPtr<TurnInstruction, true>(
+        shared_memory_ptr, SharedDataLayout::TURN_INSTRUCTION);

-    extractor::OriginalEdgeData current_edge_data;
+    unsigned *geometries_indicator_ptr = shared_layout_ptr->GetBlockPtr<unsigned, true>(
+        shared_memory_ptr, SharedDataLayout::GEOMETRIES_INDICATORS);
+
+    OriginalEdgeData current_edge_data;
    for (unsigned i = 0; i < number_of_original_edges; ++i)
    {
-        edges_input_stream.read((char *)&(current_edge_data), sizeof(extractor::OriginalEdgeData));
+        edges_input_stream.read((char *)&(current_edge_data), sizeof(OriginalEdgeData));
        via_node_ptr[i] = current_edge_data.via_node;
        name_id_ptr[i] = current_edge_data.name_id;
        travel_mode_ptr[i] = current_edge_data.travel_mode;
        turn_instructions_ptr[i] = current_edge_data.turn_instruction;
+
+        const unsigned bucket = i / 32;
+        const unsigned offset = i % 32;
+        const unsigned value = [&]
+        {
+            unsigned return_value = 0;
+            if (0 != offset)
+            {
+                return_value = geometries_indicator_ptr[bucket];
+            }
+            return return_value;
+        }();
+        if (current_edge_data.compressed_geometry)
+        {
+            geometries_indicator_ptr[bucket] = (value | (1 << offset));
+        }
    }
    edges_input_stream.close();

@@ -474,9 +468,8 @@ int Storage::Run()
            (char *)geometries_index_ptr,
            shared_layout_ptr->GetBlockSize(SharedDataLayout::GEOMETRIES_INDEX));
    }
-    extractor::CompressedEdgeContainer::CompressedEdge *geometries_list_ptr =
-        shared_layout_ptr->GetBlockPtr<extractor::CompressedEdgeContainer::CompressedEdge, true>(
-            shared_memory_ptr, SharedDataLayout::GEOMETRIES_LIST);
+    unsigned *geometries_list_ptr = shared_layout_ptr->GetBlockPtr<unsigned, true>(
+        shared_memory_ptr, SharedDataLayout::GEOMETRIES_LIST);

    geometry_input_stream.read((char *)&temporary_value, sizeof(unsigned));
    BOOST_ASSERT(temporary_value ==
@@ -489,53 +482,16 @@ int Storage::Run()
            shared_layout_ptr->GetBlockSize(SharedDataLayout::GEOMETRIES_LIST));
    }

-    // load datasource information (if it exists)
-    uint8_t *datasources_list_ptr = shared_layout_ptr->GetBlockPtr<uint8_t, true>(
-        shared_memory_ptr, SharedDataLayout::DATASOURCES_LIST);
-    if (shared_layout_ptr->GetBlockSize(SharedDataLayout::DATASOURCES_LIST) > 0)
-    {
-        geometry_datasource_input_stream.read(
-            reinterpret_cast<char *>(datasources_list_ptr),
-            shared_layout_ptr->GetBlockSize(SharedDataLayout::DATASOURCES_LIST));
-    }
-
-    // load datasource name information (if it exists)
-    char *datasource_name_data_ptr = shared_layout_ptr->GetBlockPtr<char, true>(
-        shared_memory_ptr, SharedDataLayout::DATASOURCE_NAME_DATA);
-    if (shared_layout_ptr->GetBlockSize(SharedDataLayout::DATASOURCE_NAME_DATA) > 0)
-    {
-        std::cout << "Copying "
-                  << (m_datasource_name_data.end() - m_datasource_name_data.begin())
-                  << " chars into name data ptr\n";
-        std::copy(m_datasource_name_data.begin(), m_datasource_name_data.end(),
-                  datasource_name_data_ptr);
-    }
-
-    auto datasource_name_offsets_ptr = shared_layout_ptr->GetBlockPtr<std::size_t, true>(
-        shared_memory_ptr, SharedDataLayout::DATASOURCE_NAME_OFFSETS);
-    if (shared_layout_ptr->GetBlockSize(SharedDataLayout::DATASOURCE_NAME_OFFSETS) > 0)
-    {
-        std::copy(m_datasource_name_offsets.begin(), m_datasource_name_offsets.end(),
-                  datasource_name_offsets_ptr);
-    }
-
-    auto datasource_name_lengths_ptr = shared_layout_ptr->GetBlockPtr<std::size_t, true>(
-        shared_memory_ptr, SharedDataLayout::DATASOURCE_NAME_LENGTHS);
-    if (shared_layout_ptr->GetBlockSize(SharedDataLayout::DATASOURCE_NAME_LENGTHS) > 0)
-    {
-        std::copy(m_datasource_name_lengths.begin(), m_datasource_name_lengths.end(),
-                  datasource_name_lengths_ptr);
-    }
-
    // Loading list of coordinates
-    util::Coordinate *coordinates_ptr = shared_layout_ptr->GetBlockPtr<util::Coordinate, true>(
-        shared_memory_ptr, SharedDataLayout::COORDINATE_LIST);
+    FixedPointCoordinate *coordinates_ptr =
+        shared_layout_ptr->GetBlockPtr<FixedPointCoordinate, true>(
+            shared_memory_ptr, SharedDataLayout::COORDINATE_LIST);

-    extractor::QueryNode current_node;
+    QueryNode current_node;
    for (unsigned i = 0; i < coordinate_list_size; ++i)
    {
-        nodes_input_stream.read((char *)&current_node, sizeof(extractor::QueryNode));
-        coordinates_ptr[i] = util::Coordinate(current_node.lon, current_node.lat);
+        nodes_input_stream.read((char *)&current_node, sizeof(QueryNode));
+        coordinates_ptr[i] = FixedPointCoordinate(current_node.lat, current_node.lon);
    }
    nodes_input_stream.close();

@@ -580,7 +536,7 @@ int Storage::Run()
                return return_value;
            }();

-            core_marker_ptr[bucket] = (value | (1u << offset));
+            core_marker_ptr[bucket] = (value | (1 << offset));
        }
    }

@@ -607,7 +563,7 @@ int Storage::Run()

    // acquire lock
    SharedMemory *data_type_memory =
-        makeSharedMemory(CURRENT_REGIONS, sizeof(SharedDataTimestamp), true, false);
+        SharedMemoryFactory::Get(CURRENT_REGIONS, sizeof(SharedDataTimestamp), true, false);
    SharedDataTimestamp *data_timestamp_ptr =
        static_cast<SharedDataTimestamp *>(data_type_memory->Ptr());

@@ -623,11 +579,20 @@ int Storage::Run()
    data_timestamp_ptr->layout = layout_region;
    data_timestamp_ptr->data = data_region;
    data_timestamp_ptr->timestamp += 1;
-    deleteRegion(previous_data_region);
-    deleteRegion(previous_layout_region);
-    util::SimpleLogger().Write() << "all data loaded";
+    delete_region(previous_data_region);
+    delete_region(previous_layout_region);
+    SimpleLogger().Write() << "all data loaded";

-    return EXIT_SUCCESS;
+    shared_layout_ptr->PrintInformation();
 }
+catch (const std::bad_alloc &e)
+{
+    SimpleLogger().Write(logWARNING) << "[exception] " << e.what();
+    SimpleLogger().Write(logWARNING) << "Please provide more memory or disable locking the virtual "
+                                        "address space (note: this makes OSRM swap, i.e. slow)";
+    return EXIT_FAILURE;
 }
+catch (const std::exception &e)
+{
+    SimpleLogger().Write(logWARNING) << "caught exception: " << e.what();
 }
@@ -0,0 +1,249 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#include "description_factory.hpp"
+
+#include "../algorithms/polyline_formatter.hpp"
+#include "../algorithms/coordinate_calculation.hpp"
+#include "../data_structures/internal_route_result.hpp"
+#include "../data_structures/turn_instructions.hpp"
+#include "../util/container.hpp"
+#include "../util/integer_range.hpp"
+#include "../typedefs.h"
+
+DescriptionFactory::DescriptionFactory() : entire_length(0) { via_indices.push_back(0); }
+
+std::vector<unsigned> const &DescriptionFactory::GetViaIndices() const { return via_indices; }
+
+void DescriptionFactory::SetStartSegment(const PhantomNode &source, const bool traversed_in_reverse)
+{
+    start_phantom = source;
+    const EdgeWeight segment_duration =
+        (traversed_in_reverse ? source.reverse_weight : source.forward_weight);
+    const TravelMode travel_mode =
+        (traversed_in_reverse ? source.backward_travel_mode : source.forward_travel_mode);
+    AppendSegment(source.location, PathData(0, source.name_id, TurnInstruction::HeadOn,
+                                            segment_duration, travel_mode));
+    BOOST_ASSERT(path_description.back().duration == segment_duration);
+}
+
+void DescriptionFactory::SetEndSegment(const PhantomNode &target,
+                                       const bool traversed_in_reverse,
+                                       const bool is_via_location)
+{
+    target_phantom = target;
+    const EdgeWeight segment_duration =
+        (traversed_in_reverse ? target.reverse_weight : target.forward_weight);
+    const TravelMode travel_mode =
+        (traversed_in_reverse ? target.backward_travel_mode : target.forward_travel_mode);
+    path_description.emplace_back(target.location, target.name_id, segment_duration, 0.f,
+                                  is_via_location ? TurnInstruction::ReachViaLocation
+                                                  : TurnInstruction::NoTurn,
+                                  true, true, travel_mode);
+    BOOST_ASSERT(path_description.back().duration == segment_duration);
+}
+
+void DescriptionFactory::AppendSegment(const FixedPointCoordinate &coordinate,
+                                       const PathData &path_point)
+{
+    // if the start location is on top of a node, the first movement might be zero-length,
+    // in which case we dont' add a new description, but instead update the existing one
+    if ((1 == path_description.size()) && (path_description.front().location == coordinate))
+    {
+        if (path_point.segment_duration > 0)
+        {
+            path_description.front().name_id = path_point.name_id;
+            path_description.front().travel_mode = path_point.travel_mode;
+        }
+        return;
+    }
+
+    // make sure mode changes are announced, even when there otherwise is no turn
+    const TurnInstruction turn = [&]() -> TurnInstruction
+    {
+        if (TurnInstruction::NoTurn == path_point.turn_instruction &&
+            path_description.front().travel_mode != path_point.travel_mode &&
+            path_point.segment_duration > 0)
+        {
+            return TurnInstruction::GoStraight;
+        }
+        return path_point.turn_instruction;
+    }();
+
+    path_description.emplace_back(coordinate, path_point.name_id, path_point.segment_duration, 0.f,
+                                  turn, path_point.travel_mode);
+}
+
+osrm::json::Value DescriptionFactory::AppendGeometryString(const bool return_encoded)
+{
+    if (return_encoded)
+    {
+        return PolylineFormatter().printEncodedString(path_description);
+    }
+    return PolylineFormatter().printUnencodedString(path_description);
+}
+
+void DescriptionFactory::BuildRouteSummary(const double distance, const unsigned time)
+{
+    summary.source_name_id = start_phantom.name_id;
+    summary.target_name_id = target_phantom.name_id;
+    summary.BuildDurationAndLengthStrings(distance, time);
+}
+
+void DescriptionFactory::Run(const unsigned zoom_level)
+{
+    if (path_description.empty())
+    {
+        return;
+    }
+
+    /** starts at index 1 */
+    path_description[0].length = 0.f;
+    for (const auto i : osrm::irange<std::size_t>(1, path_description.size()))
+    {
+        // move down names by one, q&d hack
+        path_description[i - 1].name_id = path_description[i].name_id;
+        path_description[i].length = coordinate_calculation::great_circle_distance(
+            path_description[i - 1].location, path_description[i].location);
+    }
+
+    /*Simplify turn instructions
+    Input :
+    10. Turn left on B 36 for 20 km
+    11. Continue on B 35; B 36 for 2 km
+    12. Continue on B 36 for 13 km
+
+    becomes:
+    10. Turn left on B 36 for 35 km
+    */
+    // TODO: rework to check only end and start of string.
+    //      stl string is way to expensive
+
+    //    unsigned lastTurn = 0;
+    //    for(unsigned i = 1; i < path_description.size(); ++i) {
+    //        string1 = sEngine.GetEscapedNameForNameID(path_description[i].name_id);
+    //        if(TurnInstruction::GoStraight == path_description[i].turn_instruction) {
+    //            if(std::string::npos != string0.find(string1+";")
+    //                  || std::string::npos != string0.find(";"+string1)
+    //                  || std::string::npos != string0.find(string1+" ;")
+    //                    || std::string::npos != string0.find("; "+string1)
+    //                    ){
+    //                SimpleLogger().Write() << "->next correct: " << string0 << " contains " <<
+    //                string1;
+    //                for(; lastTurn != i; ++lastTurn)
+    //                    path_description[lastTurn].name_id = path_description[i].name_id;
+    //                path_description[i].turn_instruction = TurnInstruction::NoTurn;
+    //            } else if(std::string::npos != string1.find(string0+";")
+    //                  || std::string::npos != string1.find(";"+string0)
+    //                    || std::string::npos != string1.find(string0+" ;")
+    //                    || std::string::npos != string1.find("; "+string0)
+    //                    ){
+    //                SimpleLogger().Write() << "->prev correct: " << string1 << " contains " <<
+    //                string0;
+    //                path_description[i].name_id = path_description[i-1].name_id;
+    //                path_description[i].turn_instruction = TurnInstruction::NoTurn;
+    //            }
+    //        }
+    //        if (TurnInstruction::NoTurn != path_description[i].turn_instruction) {
+    //            lastTurn = i;
+    //        }
+    //        string0 = string1;
+    //    }
+    //
+
+    float segment_length = 0.;
+    EdgeWeight segment_duration = 0;
+    std::size_t segment_start_index = 0;
+
+    for (const auto i : osrm::irange<std::size_t>(1, path_description.size()))
+    {
+        entire_length += path_description[i].length;
+        segment_length += path_description[i].length;
+        segment_duration += path_description[i].duration;
+        path_description[segment_start_index].length = segment_length;
+        path_description[segment_start_index].duration = segment_duration;
+
+        if (TurnInstruction::NoTurn != path_description[i].turn_instruction)
+        {
+            BOOST_ASSERT(path_description[i].necessary);
+            segment_length = 0;
+            segment_duration = 0;
+            segment_start_index = i;
+        }
+    }
+
+    // Post-processing to remove empty or nearly empty path segments
+    if (path_description.size() > 2 &&
+        std::numeric_limits<float>::epsilon() > path_description.back().length &&
+        !(path_description.end() - 2)->is_via_location)
+    {
+        path_description.pop_back();
+        path_description.back().necessary = true;
+        path_description.back().turn_instruction = TurnInstruction::NoTurn;
+        target_phantom.name_id = (path_description.end() - 2)->name_id;
+    }
+
+    if (path_description.size() > 2 &&
+        std::numeric_limits<float>::epsilon() > path_description.front().length &&
+        !(path_description.begin() + 1)->is_via_location)
+    {
+        path_description.erase(path_description.begin());
+        path_description.front().turn_instruction = TurnInstruction::HeadOn;
+        path_description.front().necessary = true;
+        start_phantom.name_id = path_description.front().name_id;
+    }
+
+    // Generalize poly line
+    polyline_generalizer.Run(path_description.begin(), path_description.end(), zoom_level);
+
+    // fix what needs to be fixed else
+    unsigned necessary_segments = 0; // a running index that counts the necessary pieces
+    osrm::for_each_pair(
+        path_description, [&](SegmentInformation &first, const SegmentInformation &second)
+        {
+            if (!first.necessary)
+            {
+                return;
+            }
+
+            if (first.is_via_location)
+            { // mark the end of a leg (of several segments)
+                via_indices.push_back(necessary_segments);
+            }
+
+            const double post_turn_bearing = coordinate_calculation::bearing(first.location, second.location);
+            const double pre_turn_bearing = coordinate_calculation::bearing(second.location, first.location);
+            first.post_turn_bearing = static_cast<short>(post_turn_bearing * 10);
+            first.pre_turn_bearing = static_cast<short>(pre_turn_bearing * 10);
+
+            ++necessary_segments;
+        });
+
+    via_indices.push_back(necessary_segments);
+    BOOST_ASSERT(via_indices.size() >= 2);
+    return;
+}
@@ -0,0 +1,96 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef DESCRIPTION_FACTORY_HPP
+#define DESCRIPTION_FACTORY_HPP
+
+#include "../algorithms/douglas_peucker.hpp"
+#include "../data_structures/phantom_node.hpp"
+#include "../data_structures/segment_information.hpp"
+#include "../data_structures/turn_instructions.hpp"
+
+#include <boost/assert.hpp>
+
+#include <osrm/coordinate.hpp>
+#include <osrm/json_container.hpp>
+
+#include <cmath>
+
+#include <limits>
+#include <vector>
+
+struct PathData;
+/* This class is fed with all way segments in consecutive order
+ *  and produces the description plus the encoded polyline */
+
+class DescriptionFactory
+{
+    DouglasPeucker polyline_generalizer;
+    PhantomNode start_phantom, target_phantom;
+
+    double DegreeToRadian(const double degree) const;
+    double RadianToDegree(const double degree) const;
+
+    std::vector<unsigned> via_indices;
+
+    double entire_length;
+
+  public:
+    struct RouteSummary
+    {
+        unsigned distance;
+        EdgeWeight duration;
+        unsigned source_name_id;
+        unsigned target_name_id;
+        RouteSummary() : distance(0), duration(0), source_name_id(0), target_name_id(0) {}
+
+        void BuildDurationAndLengthStrings(const double raw_distance, const unsigned raw_duration)
+        {
+            // compute distance/duration for route summary
+            distance = static_cast<unsigned>(std::round(raw_distance));
+            duration = static_cast<EdgeWeight>(std::round(raw_duration / 10.));
+        }
+    } summary;
+
+    // I know, declaring this public is considered bad. I'm lazy
+    std::vector<SegmentInformation> path_description;
+    DescriptionFactory();
+    void AppendSegment(const FixedPointCoordinate &coordinate, const PathData &data);
+    void BuildRouteSummary(const double distance, const unsigned time);
+    void SetStartSegment(const PhantomNode &start_phantom, const bool traversed_in_reverse);
+    void SetEndSegment(const PhantomNode &start_phantom,
+                       const bool traversed_in_reverse,
+                       const bool is_via_location = false);
+    osrm::json::Value AppendGeometryString(const bool return_encoded);
+    std::vector<unsigned> const &GetViaIndices() const;
+
+    double get_entire_length() const { return entire_length; }
+
+    void Run(const unsigned zoom_level);
+};
+
+#endif /* DESCRIPTION_FACTORY_HPP */
@@ -0,0 +1,87 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef DESCRIPTOR_BASE_HPP
+#define DESCRIPTOR_BASE_HPP
+
+#include "../algorithms/coordinate_calculation.hpp"
+#include "../data_structures/internal_route_result.hpp"
+#include "../data_structures/phantom_node.hpp"
+#include "../typedefs.h"
+
+#include <boost/assert.hpp>
+
+#include <osrm/json_container.hpp>
+
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+struct DescriptorTable : public std::unordered_map<std::string, unsigned>
+{
+    unsigned get_id(const std::string &key)
+    {
+        auto iter = find(key);
+        if (iter != end())
+        {
+            return iter->second;
+        }
+        return 0;
+    }
+};
+
+struct DescriptorConfig
+{
+    DescriptorConfig() : instructions(true), geometry(true), encode_geometry(true), zoom_level(18)
+    {
+    }
+
+    template <class OtherT>
+    DescriptorConfig(const OtherT &other)
+        : instructions(other.print_instructions), geometry(other.geometry),
+          encode_geometry(other.compression), zoom_level(other.zoom_level)
+    {
+        BOOST_ASSERT(zoom_level >= 0);
+    }
+
+    bool instructions;
+    bool geometry;
+    bool encode_geometry;
+    short zoom_level;
+};
+
+template <class DataFacadeT> class BaseDescriptor
+{
+  public:
+    BaseDescriptor() {}
+    // Maybe someone can explain the pure virtual destructor thing to me (dennis)
+    virtual ~BaseDescriptor() {}
+    virtual void Run(const InternalRouteResult &raw_route, osrm::json::Object &json_result) = 0;
+    virtual void SetConfig(const DescriptorConfig &c) = 0;
+};
+
+#endif // DESCRIPTOR_BASE_HPP
@@ -0,0 +1,94 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef GPX_DESCRIPTOR_HPP
+#define GPX_DESCRIPTOR_HPP
+
+#include "descriptor_base.hpp"
+#include "../util/xml_renderer.hpp"
+
+#include <osrm/json_container.hpp>
+
+#include <iostream>
+
+template <class DataFacadeT> class GPXDescriptor final : public BaseDescriptor<DataFacadeT>
+{
+  private:
+    DescriptorConfig config;
+    DataFacadeT *facade;
+
+    void AddRoutePoint(const FixedPointCoordinate &coordinate, osrm::json::Array &json_route)
+    {
+        osrm::json::Object json_lat;
+        osrm::json::Object json_lon;
+        osrm::json::Array json_row;
+
+        std::string tmp;
+
+        coordinate_calculation::lat_or_lon_to_string(coordinate.lat, tmp);
+        json_lat.values["_lat"] = tmp;
+
+        coordinate_calculation::lat_or_lon_to_string(coordinate.lon, tmp);
+        json_lon.values["_lon"] = tmp;
+
+        json_row.values.push_back(json_lat);
+        json_row.values.push_back(json_lon);
+        osrm::json::Object entry;
+        entry.values["rtept"] = json_row;
+        json_route.values.push_back(entry);
+    }
+
+  public:
+    explicit GPXDescriptor(DataFacadeT *facade) : facade(facade) {}
+
+    virtual void SetConfig(const DescriptorConfig &c) final { config = c; }
+
+    virtual void Run(const InternalRouteResult &raw_route, osrm::json::Object &json_result) final
+    {
+        osrm::json::Array json_route;
+        if (raw_route.shortest_path_length != INVALID_EDGE_WEIGHT)
+        {
+            AddRoutePoint(raw_route.segment_end_coordinates.front().source_phantom.location,
+                          json_route);
+
+            for (const std::vector<PathData> &path_data_vector : raw_route.unpacked_path_segments)
+            {
+                for (const PathData &path_data : path_data_vector)
+                {
+                    const FixedPointCoordinate current_coordinate =
+                        facade->GetCoordinateOfNode(path_data.node);
+                    AddRoutePoint(current_coordinate, json_route);
+                }
+            }
+            AddRoutePoint(raw_route.segment_end_coordinates.back().target_phantom.location,
+                          json_route);
+        }
+        // osrm::json::gpx_render(reply.content, json_route);
+        json_result.values["route"] = json_route;
+    }
+};
+#endif // GPX_DESCRIPTOR_HPP
@@ -0,0 +1,403 @@
+/*
+
+Copyright (c) 2015, Project OSRM contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef JSON_DESCRIPTOR_HPP
+#define JSON_DESCRIPTOR_HPP
+
+#include "descriptor_base.hpp"
+#include "description_factory.hpp"
+#include "../algorithms/object_encoder.hpp"
+#include "../algorithms/route_name_extraction.hpp"
+#include "../data_structures/segment_information.hpp"
+#include "../data_structures/turn_instructions.hpp"
+#include "../util/bearing.hpp"
+#include "../util/cast.hpp"
+#include "../util/integer_range.hpp"
+#include "../util/json_renderer.hpp"
+#include "../util/simple_logger.hpp"
+#include "../util/string_util.hpp"
+#include "../util/timing_util.hpp"
+
+#include <osrm/json_container.hpp>
+
+#include <limits>
+#include <algorithm>
+#include <string>
+
+template <class DataFacadeT> class JSONDescriptor final : public BaseDescriptor<DataFacadeT>
+{
+  private:
+    DataFacadeT *facade;
+    DescriptorConfig config;
+    DescriptionFactory description_factory, alternate_description_factory;
+    FixedPointCoordinate current;
+
+  public:
+    struct Segment
+    {
+        Segment() : name_id(INVALID_NAMEID), length(-1), position(0) {}
+        Segment(unsigned n, int l, unsigned p) : name_id(n), length(l), position(p) {}
+        unsigned name_id;
+        int length;
+        unsigned position;
+    };
+  private:
+    std::vector<Segment> shortest_path_segments, alternative_path_segments;
+    ExtractRouteNames<DataFacadeT, Segment> GenerateRouteNames;
+
+  public:
+    explicit JSONDescriptor(DataFacadeT *facade) : facade(facade)
+    {
+    }
+
+    virtual void SetConfig(const DescriptorConfig &c) override final { config = c; }
+
+    unsigned DescribeLeg(const std::vector<PathData> &route_leg,
+                         const PhantomNodes &leg_phantoms,
+                         const bool target_traversed_in_reverse,
+                         const bool is_via_leg)
+    {
+        unsigned added_element_count = 0;
+        // Get all the coordinates for the computed route
+        FixedPointCoordinate current_coordinate;
+        for (const PathData &path_data : route_leg)
+        {
+            current_coordinate = facade->GetCoordinateOfNode(path_data.node);
+            description_factory.AppendSegment(current_coordinate, path_data);
+            ++added_element_count;
+        }
+        description_factory.SetEndSegment(leg_phantoms.target_phantom, target_traversed_in_reverse,
+                                          is_via_leg);
+        ++added_element_count;
+        BOOST_ASSERT((route_leg.size() + 1) == added_element_count);
+        return added_element_count;
+    }
+
+    virtual void Run(const InternalRouteResult &raw_route,
+                     osrm::json::Object &json_result) override final
+    {
+        if (INVALID_EDGE_WEIGHT == raw_route.shortest_path_length)
+        {
+            // We do not need to do much, if there is no route ;-)
+            return;
+        }
+
+        // check if first segment is non-zero
+        BOOST_ASSERT(raw_route.unpacked_path_segments.size() ==
+                     raw_route.segment_end_coordinates.size());
+
+        description_factory.SetStartSegment(
+            raw_route.segment_end_coordinates.front().source_phantom,
+            raw_route.source_traversed_in_reverse.front());
+
+        // for each unpacked segment add the leg to the description
+        for (const auto i : osrm::irange<std::size_t>(0, raw_route.unpacked_path_segments.size()))
+        {
+#ifndef NDEBUG
+            const int added_segments =
+#endif
+                DescribeLeg(raw_route.unpacked_path_segments[i],
+                            raw_route.segment_end_coordinates[i],
+                            raw_route.target_traversed_in_reverse[i], raw_route.is_via_leg(i));
+            BOOST_ASSERT(0 < added_segments);
+        }
+        description_factory.Run(config.zoom_level);
+
+        if (config.geometry)
+        {
+            osrm::json::Value route_geometry =
+                description_factory.AppendGeometryString(config.encode_geometry);
+            json_result.values["route_geometry"] = route_geometry;
+        }
+        if (config.instructions)
+        {
+            osrm::json::Array json_route_instructions = BuildTextualDescription(description_factory, shortest_path_segments);
+            json_result.values["route_instructions"] = json_route_instructions;
+        }
+        description_factory.BuildRouteSummary(description_factory.get_entire_length(),
+                                              raw_route.shortest_path_length);
+        osrm::json::Object json_route_summary;
+        json_route_summary.values["total_distance"] = description_factory.summary.distance;
+        json_route_summary.values["total_time"] = description_factory.summary.duration;
+        json_route_summary.values["start_point"] =
+            facade->get_name_for_id(description_factory.summary.source_name_id);
+        json_route_summary.values["end_point"] =
+            facade->get_name_for_id(description_factory.summary.target_name_id);
+        json_result.values["route_summary"] = json_route_summary;
+
+        BOOST_ASSERT(!raw_route.segment_end_coordinates.empty());
+
+        osrm::json::Array json_via_points_array;
+        osrm::json::Array json_first_coordinate;
+        json_first_coordinate.values.push_back(
+            raw_route.segment_end_coordinates.front().source_phantom.location.lat /
+            COORDINATE_PRECISION);
+        json_first_coordinate.values.push_back(
+            raw_route.segment_end_coordinates.front().source_phantom.location.lon /
+            COORDINATE_PRECISION);
+        json_via_points_array.values.push_back(json_first_coordinate);
+        for (const PhantomNodes &nodes : raw_route.segment_end_coordinates)
+        {
+            std::string tmp;
+            osrm::json::Array json_coordinate;
+            json_coordinate.values.push_back(nodes.target_phantom.location.lat /
+                                             COORDINATE_PRECISION);
+            json_coordinate.values.push_back(nodes.target_phantom.location.lon /
+                                             COORDINATE_PRECISION);
+            json_via_points_array.values.push_back(json_coordinate);
+        }
+        json_result.values["via_points"] = json_via_points_array;
+
+        osrm::json::Array json_via_indices_array;
+
+        std::vector<unsigned> const &shortest_leg_end_indices = description_factory.GetViaIndices();
+        json_via_indices_array.values.insert(json_via_indices_array.values.end(),
+                                             shortest_leg_end_indices.begin(),
+                                             shortest_leg_end_indices.end());
+        json_result.values["via_indices"] = json_via_indices_array;
+
+        // only one alternative route is computed at this time, so this is hardcoded
+        if (INVALID_EDGE_WEIGHT != raw_route.alternative_path_length)
+        {
+            json_result.values["found_alternative"] = osrm::json::True();
+            BOOST_ASSERT(!raw_route.alt_source_traversed_in_reverse.empty());
+            alternate_description_factory.SetStartSegment(
+                raw_route.segment_end_coordinates.front().source_phantom,
+                raw_route.alt_source_traversed_in_reverse.front());
+            // Get all the coordinates for the computed route
+            for (const PathData &path_data : raw_route.unpacked_alternative)
+            {
+                current = facade->GetCoordinateOfNode(path_data.node);
+                alternate_description_factory.AppendSegment(current, path_data);
+            }
+            alternate_description_factory.SetEndSegment(
+                raw_route.segment_end_coordinates.back().target_phantom,
+                raw_route.alt_source_traversed_in_reverse.back());
+            alternate_description_factory.Run(config.zoom_level);
+
+            if (config.geometry)
+            {
+                osrm::json::Value alternate_geometry_string =
+                    alternate_description_factory.AppendGeometryString(config.encode_geometry);
+                osrm::json::Array json_alternate_geometries_array;
+                json_alternate_geometries_array.values.push_back(alternate_geometry_string);
+                json_result.values["alternative_geometries"] = json_alternate_geometries_array;
+            }
+            // Generate instructions for each alternative (simulated here)
+            osrm::json::Array json_alt_instructions;
+            osrm::json::Array json_current_alt_instructions;
+            if (config.instructions)
+            {
+                json_current_alt_instructions = BuildTextualDescription(alternate_description_factory, alternative_path_segments);
+                json_alt_instructions.values.push_back(json_current_alt_instructions);
+                json_result.values["alternative_instructions"] = json_alt_instructions;
+            }
+            alternate_description_factory.BuildRouteSummary(
+                alternate_description_factory.get_entire_length(),
+                raw_route.alternative_path_length);
+
+            osrm::json::Object json_alternate_route_summary;
+            osrm::json::Array json_alternate_route_summary_array;
+            json_alternate_route_summary.values["total_distance"] =
+                alternate_description_factory.summary.distance;
+            json_alternate_route_summary.values["total_time"] =
+                alternate_description_factory.summary.duration;
+            json_alternate_route_summary.values["start_point"] =
+                facade->get_name_for_id(alternate_description_factory.summary.source_name_id);
+            json_alternate_route_summary.values["end_point"] =
+                facade->get_name_for_id(alternate_description_factory.summary.target_name_id);
+            json_alternate_route_summary_array.values.push_back(json_alternate_route_summary);
+            json_result.values["alternative_summaries"] = json_alternate_route_summary_array;
+
+            std::vector<unsigned> const &alternate_leg_end_indices =
+                alternate_description_factory.GetViaIndices();
+            osrm::json::Array json_altenative_indices_array;
+            json_altenative_indices_array.values.insert(json_altenative_indices_array.values.end(),
+                                                        alternate_leg_end_indices.begin(),
+                                                        alternate_leg_end_indices.end());
+            json_result.values["alternative_indices"] = json_altenative_indices_array;
+        }
+        else
+        {
+            json_result.values["found_alternative"] = osrm::json::False();
+        }
+
+        // Get Names for both routes
+        RouteNames route_names =
+            GenerateRouteNames(shortest_path_segments, alternative_path_segments, facade);
+        osrm::json::Array json_route_names;
+        json_route_names.values.push_back(route_names.shortest_path_name_1);
+        json_route_names.values.push_back(route_names.shortest_path_name_2);
+        json_result.values["route_name"] = json_route_names;
+
+        if (INVALID_EDGE_WEIGHT != raw_route.alternative_path_length)
+        {
+            osrm::json::Array json_alternate_names_array;
+            osrm::json::Array json_alternate_names;
+            json_alternate_names.values.push_back(route_names.alternative_path_name_1);
+            json_alternate_names.values.push_back(route_names.alternative_path_name_2);
+            json_alternate_names_array.values.push_back(json_alternate_names);
+            json_result.values["alternative_names"] = json_alternate_names_array;
+        }
+
+        json_result.values["hint_data"] = BuildHintData(raw_route);
+    }
+
+    inline osrm::json::Object BuildHintData(const InternalRouteResult& raw_route) const
+    {
+        osrm::json::Object json_hint_object;
+        json_hint_object.values["checksum"] = facade->GetCheckSum();
+        osrm::json::Array json_location_hint_array;
+        std::string hint;
+        for (const auto i : osrm::irange<std::size_t>(0, raw_route.segment_end_coordinates.size()))
+        {
+            ObjectEncoder::EncodeToBase64(raw_route.segment_end_coordinates[i].source_phantom,
+                                          hint);
+            json_location_hint_array.values.push_back(hint);
+        }
+        ObjectEncoder::EncodeToBase64(raw_route.segment_end_coordinates.back().target_phantom,
+                                      hint);
+        json_location_hint_array.values.push_back(hint);
+        json_hint_object.values["locations"] = json_location_hint_array;
+
+        return json_hint_object;
+    }
+
+    inline osrm::json::Array BuildTextualDescription(const DescriptionFactory &description_factory,
+                                                     std::vector<Segment> &route_segments_list) const
+    {
+        osrm::json::Array json_instruction_array;
+        // Segment information has following format:
+        //["instruction id","streetname",length,position,time,"length","earth_direction",azimuth]
+        unsigned necessary_segments_running_index = 0;
+
+        struct RoundAbout
+        {
+            RoundAbout() : start_index(std::numeric_limits<int>::max()), name_id(INVALID_NAMEID), leave_at_exit(std::numeric_limits<int>::max()) {}
+            int start_index;
+            unsigned name_id;
+            int leave_at_exit;
+        } round_about;
+
+        round_about.leave_at_exit = 0;
+        round_about.name_id = 0;
+        std::string temp_dist, temp_length, temp_duration, temp_bearing, temp_instruction;
+        TravelMode last_travel_mode = TRAVEL_MODE_DEFAULT;
+
+        // Fetch data from Factory and generate a string from it.
+        for (const SegmentInformation &segment : description_factory.path_description)
+        {
+            osrm::json::Array json_instruction_row;
+            TurnInstruction current_instruction = segment.turn_instruction;
+            if (TurnInstructionsClass::TurnIsNecessary(current_instruction))
+            {
+                if (TurnInstruction::EnterRoundAbout == current_instruction)
+                {
+                    round_about.name_id = segment.name_id;
+                    round_about.start_index = necessary_segments_running_index;
+                }
+                else
+                {
+                    std::string current_turn_instruction;
+                    if (TurnInstruction::LeaveRoundAbout == current_instruction)
+                    {
+                        temp_instruction = std::to_string(
+                            cast::enum_to_underlying(TurnInstruction::EnterRoundAbout));
+                        current_turn_instruction += temp_instruction;
+                        current_turn_instruction += "-";
+                        temp_instruction = std::to_string(round_about.leave_at_exit + 1);
+                        current_turn_instruction += temp_instruction;
+                        round_about.leave_at_exit = 0;
+                    }
+                    else
+                    {
+                        temp_instruction =
+                            std::to_string(cast::enum_to_underlying(current_instruction));
+                        current_turn_instruction += temp_instruction;
+                    }
+                    json_instruction_row.values.push_back(current_turn_instruction);
+
+                    json_instruction_row.values.push_back(facade->get_name_for_id(segment.name_id));
+                    json_instruction_row.values.push_back(std::round(segment.length));
+                    json_instruction_row.values.push_back(necessary_segments_running_index);
+                    json_instruction_row.values.push_back(std::round(segment.duration / 10.));
+                    json_instruction_row.values.push_back(
+                        std::to_string(static_cast<unsigned>(segment.length)) + "m");
+
+                    // post turn bearing
+                    const double post_turn_bearing_value = (segment.post_turn_bearing / 10.);
+                    json_instruction_row.values.push_back(bearing::get(post_turn_bearing_value));
+                    json_instruction_row.values.push_back(
+                        static_cast<unsigned>(round(post_turn_bearing_value)));
+
+                    json_instruction_row.values.push_back(segment.travel_mode);
+                    last_travel_mode = segment.travel_mode;
+
+                    // pre turn bearing
+                    const double pre_turn_bearing_value = (segment.pre_turn_bearing / 10.);
+                    json_instruction_row.values.push_back(bearing::get(pre_turn_bearing_value));
+                    json_instruction_row.values.push_back(
+                        static_cast<unsigned>(round(pre_turn_bearing_value)));
+
+                    json_instruction_array.values.push_back(json_instruction_row);
+
+                    route_segments_list.emplace_back(
+                        segment.name_id, static_cast<int>(segment.length),
+                        static_cast<unsigned>(route_segments_list.size()));
+                }
+            }
+            else if (TurnInstruction::StayOnRoundAbout == current_instruction)
+            {
+                ++round_about.leave_at_exit;
+            }
+            if (segment.necessary)
+            {
+                ++necessary_segments_running_index;
+            }
+        }
+
+        osrm::json::Array json_last_instruction_row;
+        temp_instruction =
+            std::to_string(cast::enum_to_underlying(TurnInstruction::ReachedYourDestination));
+        json_last_instruction_row.values.push_back(temp_instruction);
+        json_last_instruction_row.values.push_back("");
+        json_last_instruction_row.values.push_back(0);
+        json_last_instruction_row.values.push_back(necessary_segments_running_index - 1);
+        json_last_instruction_row.values.push_back(0);
+        json_last_instruction_row.values.push_back("0m");
+        json_last_instruction_row.values.push_back(bearing::get(0.0));
+        json_last_instruction_row.values.push_back(0.);
+        json_last_instruction_row.values.push_back(last_travel_mode);
+        json_last_instruction_row.values.push_back(bearing::get(0.0));
+        json_last_instruction_row.values.push_back(0.);
+        json_instruction_array.values.push_back(json_last_instruction_row);
+
+        return json_instruction_array;
+    }
+};
+
+#endif /* JSON_DESCRIPTOR_H_ */
@@ -12,6 +12,8 @@ RUN pip install awscli

 # luabind
 RUN curl https://gist.githubusercontent.com/DennisOSRM/f2eb7b948e6fe1ae319e/raw/install-luabind.sh | sudo bash
+# osmosis
+RUN curl -s https://gist.githubusercontent.com/DennisOSRM/803a64a9178ec375069f/raw/ | sudo bash

 RUN useradd -ms /bin/bash mapbox
 USER mapbox
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Patrick Niklaus	f6116db957	Merge pull request #1902 from Project-OSRM/4.9.1 Bug fix release 4.9.1	2016-01-19 19:00:11 -05:00
Patrick Niklaus	c824429458	Include the travel mode in the last instruction by copying it from the previous instruction.	2016-01-19 23:23:32 +01:00
Daniel Patterson	23b2154d98	Adds a shared/exclusive lock around queries and CheckAndReloadFacade. Without this, it's possible for CheckAndReloadFacade to start working while a query is still in progress, leading to undefined behaviour.	2016-01-19 21:26:30 +01:00
Daniel J. Hofmann	25c8711aad	Fix shared memory non-copyable properties	2016-01-19 20:31:14 +01:00
Daniel Patterson	cf30628d4e	DataFacade should only remove shared segments if they're actually different from the last time they were checked.	2016-01-19 20:31:03 +01:00
Patrick Niklaus	7675c730b6	Fix wrong assertion and emplace_back bug in trip plugin	2016-01-19 17:38:02 +01:00
Patrick Niklaus	2ce74c05e1	Use a sane gps_precision multipler	2016-01-15 22:15:05 +01:00
Patrick Niklaus	88e6558da3	Fix handling unexpected errors.	2016-01-15 22:08:04 +01:00
Patrick Niklaus	f1140ec903	Fix uturns at dead-end streets	2016-01-15 21:48:14 +01:00
Patrick Niklaus	a2e114e852	Merge branch 'develop'	2015-12-24 11:22:16 +01:00
Patrick Niklaus	8f6fc0146b	Merge branch 'develop'	2015-09-20 13:30:19 +02:00
Patrick Niklaus	6ad1cd3fb5	Merge branch 'develop'	2015-09-16 18:18:54 +02:00
Wilhelm Berg	40443d1e25	appveyor.yml update url to binary deps	2015-08-24 21:23:12 +02:00
Patrick Niklaus	4ec323c5cc	Merge commit '9958937fd1c1f9dd60126a56e1c4f25ceefaf70e'	2015-08-15 00:11:31 +02:00
Patrick Niklaus	300d901618	Merge branch 'develop'	2015-06-22 13:06:50 +02:00
Patrick Niklaus	fd6daa580a	Merge branch 'develop'	2015-04-22 10:34:56 +02:00
Patrick Niklaus	c2fc47df34	Merge branch 'develop'	2015-04-17 22:51:40 +02:00