[skip ci] Bump package version to latest.3

Remove osrm namespace indication where possible, wrap out shared_memory_ownership
clang-format
2017-04-04 23:03:04 +00:00 · 2017-04-04 17:00:36 +00:00 · 2017-04-04 17:00:36 +00:00 · 2017-04-04 17:00:36 +00:00 · 2017-04-04 17:00:36 +00:00 · 2017-04-04 17:00:36 +00:00
51 changed files with 706 additions and 531 deletions
@@ -223,6 +223,10 @@ script:
  - ./unit_tests/util-tests
  - ./unit_tests/server-tests
  - ./unit_tests/partition-tests
+  - |
+    if [ -n "${ENABLE_NODE_BINDINGS}" ] && [ -z "${ENABLE_SANITIZER}" ]; then
+      npm run nodejs-tests
+    fi
  - popd
  - yarn test

@@ -10,6 +10,8 @@
      - .osrm.datasource_index file was removed. Data is now part of .osrm.geometries.
      - .osrm.edge_lookup was removed. The option `--generate-edge-lookup` does nothing now.
      - `osrm-contract` does not depend on the `.osrm.fileIndex` file anymore
+    - Profiles
+      - Added `force_split_edges` flag to global properties. True value guarantees that segment_function will be called for all segments, but also could double memory consumption

 # 5.6.3
  - Changes from 5.6.0
@@ -303,6 +303,8 @@ endif()
 if (ENABLE_SANITIZER)
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address")
  set(OSRM_CXXFLAGS "${OSRM_CXXFLAGS} -fsanitize=address")
+  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=address")
+  set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -fsanitize=address")
 endif()

 # Configuring compilers
@@ -36,6 +36,7 @@ use_turn_restrictions         | Boolean  | Are turn instructions followed?
 continue_straight_at_waypoint | Boolean  | Must the route continue straight on at a via point, or are U-turns allowed?
 max_speed_for_map_matching    | Float    | Maximum vehicle speed to be assumed in matching (in m/s)
 max_turn_weight               | Float    | Maximum turn penalty weight
+force_split_edges             | Boolean  | True value forces a split of forward and backward edges of extracted ways and guarantees that segment_function will be called for all segments

 ## way_function

@@ -32,21 +32,25 @@ We may introduce forward-compatible changes: query parameters and response prope

 - The `master` branch is for the bleeding edge development
 - We create and maintain release branches `x.y` to control the release flow
- We create the release branch once we tagged the final version `x.y.0` version, RCs go on master
+- We create the release branch once we create release branches once we want to release the first RC
+- RCs go in the release branch, commits needs to be cherry-picked from master
 - No minor or major version will be released without a code-equal release candidates
- For quality assurance, release candidates will be run on the demo server for 24 hours before releaseing the version proper
+- For quality assurance, release candidates need to be staged beforing tagging a final release
 - Patch versions may be released without a release candidate
 - We may backport fixes to older versions and release them as patch versions

 ## Releasing a version

 1. Check out the appropriate release branch `x.y`
-2. Make sure all tests are passing (e.g. Travis CI gives you a :thumbs_up:)
-3. Make sure `CHANGELOG.md` is up to date.
-4. Make sure the OSRM version in `CMakeLists.txt` is up to date
-5. Use an annotated tag to mark the release: `git tag vx.y.z -a` Body of the tag description should be the changelog entries.
-6. Use `npm run build-api-docs` to generate the API documentation.  Copy `build/docs/*` to `https://github.com/Project-OSRM/project-osrm.github.com` in the `docs/vN.N.N/api` directory
-6. Push tags and commits: `git push; git push --tags`
-8. Proceede with the `node-osrm` release as [outlined in the repository](https://github.com/Project-OSRM/node-osrm/blob/master/docs/releasing.md).
+2. Make sure `CHANGELOG.md` is up to date.
+3. Make sure the OSRM version in `CMakeLists.txt` is up to date
+4. Make sure the `package.json` is up to date.
+5. Make sure all tests are passing (e.g. Travis CI gives you a :thumbs_up:)
+6. Use an annotated tag to mark the release: `git tag vx.y.z -a` Body of the tag description should be the changelog entries.
+7. Use `npm run build-api-docs` to generate the API documentation.  Copy `build/docs/*` to `https://github.com/Project-OSRM/project-osrm.github.com` in the `docs/vN.N.N/api` directory
+8. Push tags and commits: `git push; git push --tags`
 9. If not a release-candidate: Write a mailing-list post to osrm-talk@openstreetmap.org to announce the release
+10. Wait until the travis build has been completed and check if the node binaries were published by doing:
+    `rm -rf node_modules && npm install` locally.
+11. For final releases run `npm publish` or `npm publish --tag next` for release candidates.

@@ -2,10 +2,10 @@
 Feature: osrm-extract with a profile containing raster source
    Scenario: osrm-extract on a valid profile
        Given the profile "rasterbot"
-        And the node map
-            """
-            a b
-            """
+        And the node locations
+            | node | lat        | lon      |
+            | a    | 0.1        | 0.1      |
+            | b    | 0.05       | 0.1      |
        And the ways
            | nodes |
            | ab    |
@@ -20,4 +20,6 @@ Feature: osrm-extract with a profile containing raster source
        And the data has been saved to disk
        When I run "osrm-extract {osm_file} -p {profile_file}"
        Then stdout should contain "source loader"
+        Then stdout should contain "slope: 0.0899"
+        Then stdout should contain "slope: -0.0899"
        And it should exit successfully
@@ -50,8 +50,9 @@ Feature: Raster - weights
        And I route I should get
            | from | to | route    | speed   |
            | a    | b  | ab,ab    | 8 km/h  |
-            | a    | c  | ad,dc,dc | 15 km/h |
-            | b    | c  | bc,bc    | 8 km/h  |
+            | b    | a  | ab,ab    | 22 km/h |
+            | a    | c  | ab,bc,bc | 12 km/h |
+            | b    | c  | bc,bc    | 22 km/h |
            | a    | d  | ad,ad    | 15 km/h |
            | d    | c  | dc,dc    | 15 km/h |
            | d    | e  | de,de    | 10 km/h |
@@ -7,6 +7,8 @@
 #include "util/static_graph.hpp"
 #include "util/typedefs.hpp"

+#include "storage/shared_memory_ownership.hpp"
+
 #include <boost/filesystem/path.hpp>

 namespace osrm
@@ -16,16 +18,17 @@ namespace customizer

 using EdgeBasedGraphEdgeData = partition::EdgeBasedGraphEdgeData;

-struct MultiLevelEdgeBasedGraph : public partition::MultiLevelGraph<EdgeBasedGraphEdgeData, false>
+struct MultiLevelEdgeBasedGraph
+    : public partition::MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::Container>
 {
-    using Base = partition::MultiLevelGraph<EdgeBasedGraphEdgeData, false>;
+    using Base = partition::MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::Container>;
    using Base::Base;
 };

 struct MultiLevelEdgeBasedGraphView
-    : public partition::MultiLevelGraph<EdgeBasedGraphEdgeData, true>
+    : public partition::MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::View>
 {
-    using Base = partition::MultiLevelGraph<EdgeBasedGraphEdgeData, true>;
+    using Base = partition::MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::View>;
    using Base::Base;
 };

@@ -20,6 +20,7 @@
 #include "partition/multi_level_partition.hpp"

 #include "storage/shared_datatype.hpp"
+#include "storage/shared_memory_ownership.hpp"

 #include "util/exception.hpp"
 #include "util/exception_utils.hpp"
@@ -61,7 +62,7 @@ class ContiguousInternalMemoryAlgorithmDataFacade<algorithm::CH>
    : public datafacade::AlgorithmDataFacade<algorithm::CH>
 {
  private:
-    using QueryGraph = util::StaticGraph<EdgeData, true>;
+    using QueryGraph = util::StaticGraph<EdgeData, storage::Ownership::View>;
    using GraphNode = QueryGraph::NodeArrayEntry;
    using GraphEdge = QueryGraph::EdgeArrayEntry;

@@ -78,9 +79,9 @@ class ContiguousInternalMemoryAlgorithmDataFacade<algorithm::CH>
        auto graph_edges_ptr = data_layout.GetBlockPtr<GraphEdge>(
            memory_block, storage::DataLayout::CH_GRAPH_EDGE_LIST);

-        util::ShM<GraphNode, true>::vector node_list(
+        util::vector_view<GraphNode> node_list(
            graph_nodes_ptr, data_layout.num_entries[storage::DataLayout::CH_GRAPH_NODE_LIST]);
-        util::ShM<GraphEdge, true>::vector edge_list(
+        util::vector_view<GraphEdge> edge_list(
            graph_edges_ptr, data_layout.num_entries[storage::DataLayout::CH_GRAPH_EDGE_LIST]);
        m_query_graph.reset(new QueryGraph(node_list, edge_list));
    }
@@ -154,7 +155,7 @@ class ContiguousInternalMemoryAlgorithmDataFacade<algorithm::CoreCH>
    : public datafacade::AlgorithmDataFacade<algorithm::CoreCH>
 {
  private:
-    util::ShM<bool, true>::vector m_is_core_node;
+    util::vector_view<bool> m_is_core_node;

    // allocator that keeps the allocation data
    std::shared_ptr<ContiguousBlockAllocator> allocator;
@@ -163,7 +164,7 @@ class ContiguousInternalMemoryAlgorithmDataFacade<algorithm::CoreCH>
    {
        auto core_marker_ptr =
            data_layout.GetBlockPtr<unsigned>(memory_block, storage::DataLayout::CH_CORE_MARKER);
-        util::ShM<bool, true>::vector is_core_node(
+        util::vector_view<bool> is_core_node(
            core_marker_ptr, data_layout.num_entries[storage::DataLayout::CH_CORE_MARKER]);
        m_is_core_node = std::move(is_core_node);
    }
@@ -199,10 +200,10 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
 {
  private:
    using super = BaseDataFacade;
-    using IndexBlock = util::RangeTable<16, true>::BlockT;
+    using IndexBlock = util::RangeTable<16, storage::Ownership::View>::BlockT;
    using RTreeLeaf = super::RTreeLeaf;
    using SharedRTree =
-        util::StaticRTree<RTreeLeaf, util::ShM<util::Coordinate, true>::vector, true>;
+        util::StaticRTree<RTreeLeaf, util::vector_view<util::Coordinate>, storage::Ownership::View>;
    using SharedGeospatialQuery = GeospatialQuery<SharedRTree, BaseDataFacade>;
    using RTreeNode = SharedRTree::TreeNode;

@@ -211,28 +212,28 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
    extractor::Datasources *m_datasources;

    unsigned m_check_sum;
-    util::ShM<util::Coordinate, true>::vector m_coordinate_list;
-    util::PackedVector<OSMNodeID, true> m_osmnodeid_list;
-    util::ShM<GeometryID, true>::vector m_via_geometry_list;
-    util::ShM<NameID, true>::vector m_name_ID_list;
-    util::ShM<LaneDataID, true>::vector m_lane_data_id;
-    util::ShM<extractor::guidance::TurnInstruction, true>::vector m_turn_instruction_list;
-    util::ShM<extractor::TravelMode, true>::vector m_travel_mode_list;
-    util::ShM<util::guidance::TurnBearing, true>::vector m_pre_turn_bearing;
-    util::ShM<util::guidance::TurnBearing, true>::vector m_post_turn_bearing;
+    util::vector_view<util::Coordinate> m_coordinate_list;
+    util::PackedVector<OSMNodeID, storage::Ownership::View> m_osmnodeid_list;
+    util::vector_view<GeometryID> m_via_geometry_list;
+    util::vector_view<NameID> m_name_ID_list;
+    util::vector_view<LaneDataID> m_lane_data_id;
+    util::vector_view<extractor::guidance::TurnInstruction> m_turn_instruction_list;
+    util::vector_view<extractor::TravelMode> m_travel_mode_list;
+    util::vector_view<util::guidance::TurnBearing> m_pre_turn_bearing;
+    util::vector_view<util::guidance::TurnBearing> m_post_turn_bearing;
    util::NameTable m_names_table;
-    util::ShM<unsigned, true>::vector m_name_begin_indices;
-    util::ShM<bool, true>::vector m_is_core_node;
-    util::ShM<std::uint32_t, true>::vector m_lane_description_offsets;
-    util::ShM<extractor::guidance::TurnLaneType::Mask, true>::vector m_lane_description_masks;
-    util::ShM<TurnPenalty, true>::vector m_turn_weight_penalties;
-    util::ShM<TurnPenalty, true>::vector m_turn_duration_penalties;
+    util::vector_view<unsigned> m_name_begin_indices;
+    util::vector_view<bool> m_is_core_node;
+    util::vector_view<std::uint32_t> m_lane_description_offsets;
+    util::vector_view<extractor::guidance::TurnLaneType::Mask> m_lane_description_masks;
+    util::vector_view<TurnPenalty> m_turn_weight_penalties;
+    util::vector_view<TurnPenalty> m_turn_duration_penalties;
    extractor::SegmentDataView segment_data;

-    util::ShM<char, true>::vector m_datasource_name_data;
-    util::ShM<std::size_t, true>::vector m_datasource_name_offsets;
-    util::ShM<std::size_t, true>::vector m_datasource_name_lengths;
-    util::ShM<util::guidance::LaneTupleIdPair, true>::vector m_lane_tupel_id_pairs;
+    util::vector_view<char> m_datasource_name_data;
+    util::vector_view<std::size_t> m_datasource_name_offsets;
+    util::vector_view<std::size_t> m_datasource_name_lengths;
+    util::vector_view<util::guidance::LaneTupleIdPair> m_lane_tupel_id_pairs;

    std::unique_ptr<SharedRTree> m_static_rtree;
    std::unique_ptr<SharedGeospatialQuery> m_geospatial_query;
@@ -240,17 +241,17 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade

    util::NameTable m_name_table;
    // bearing classes by node based node
-    util::ShM<BearingClassID, true>::vector m_bearing_class_id_table;
+    util::vector_view<BearingClassID> m_bearing_class_id_table;
    // entry class IDs
-    util::ShM<EntryClassID, true>::vector m_entry_class_id_list;
+    util::vector_view<EntryClassID> m_entry_class_id_list;

    // the look-up table for entry classes. An entry class lists the possibility of entry for all
    // available turns. Such a class id is stored with every edge.
-    util::ShM<util::guidance::EntryClass, true>::vector m_entry_class_table;
+    util::vector_view<util::guidance::EntryClass> m_entry_class_table;
    // the look-up table for distinct bearing classes. A bearing class lists the available bearings
    // at an intersection
-    std::shared_ptr<util::RangeTable<16, true>> m_bearing_ranges_table;
-    util::ShM<DiscreteBearing, true>::vector m_bearing_values_table;
+    std::shared_ptr<util::RangeTable<16, storage::Ownership::View>> m_bearing_ranges_table;
+    util::vector_view<DiscreteBearing> m_bearing_values_table;

    // allocator that keeps the allocation data
    std::shared_ptr<ContiguousBlockAllocator> allocator;
@@ -326,52 +327,52 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade

        const auto travel_mode_list_ptr = data_layout.GetBlockPtr<extractor::TravelMode>(
            memory_block, storage::DataLayout::TRAVEL_MODE);
-        util::ShM<extractor::TravelMode, true>::vector travel_mode_list(
+        util::vector_view<extractor::TravelMode> travel_mode_list(
            travel_mode_list_ptr, data_layout.num_entries[storage::DataLayout::TRAVEL_MODE]);
        m_travel_mode_list = std::move(travel_mode_list);

        const auto lane_data_id_ptr =
            data_layout.GetBlockPtr<LaneDataID>(memory_block, storage::DataLayout::LANE_DATA_ID);
-        util::ShM<LaneDataID, true>::vector lane_data_id(
+        util::vector_view<LaneDataID> lane_data_id(
            lane_data_id_ptr, data_layout.num_entries[storage::DataLayout::LANE_DATA_ID]);
        m_lane_data_id = std::move(lane_data_id);

        const auto lane_tupel_id_pair_ptr =
            data_layout.GetBlockPtr<util::guidance::LaneTupleIdPair>(
                memory_block, storage::DataLayout::TURN_LANE_DATA);
-        util::ShM<util::guidance::LaneTupleIdPair, true>::vector lane_tupel_id_pair(
+        util::vector_view<util::guidance::LaneTupleIdPair> lane_tupel_id_pair(
            lane_tupel_id_pair_ptr, data_layout.num_entries[storage::DataLayout::TURN_LANE_DATA]);
        m_lane_tupel_id_pairs = std::move(lane_tupel_id_pair);

        const auto turn_instruction_list_ptr =
            data_layout.GetBlockPtr<extractor::guidance::TurnInstruction>(
                memory_block, storage::DataLayout::TURN_INSTRUCTION);
-        util::ShM<extractor::guidance::TurnInstruction, true>::vector turn_instruction_list(
+        util::vector_view<extractor::guidance::TurnInstruction> turn_instruction_list(
            turn_instruction_list_ptr,
            data_layout.num_entries[storage::DataLayout::TURN_INSTRUCTION]);
        m_turn_instruction_list = std::move(turn_instruction_list);

        const auto name_id_list_ptr =
            data_layout.GetBlockPtr<NameID>(memory_block, storage::DataLayout::NAME_ID_LIST);
-        util::ShM<NameID, true>::vector name_id_list(
+        util::vector_view<NameID> name_id_list(
            name_id_list_ptr, data_layout.num_entries[storage::DataLayout::NAME_ID_LIST]);
        m_name_ID_list = std::move(name_id_list);

        const auto entry_class_id_list_ptr =
            data_layout.GetBlockPtr<EntryClassID>(memory_block, storage::DataLayout::ENTRY_CLASSID);
-        typename util::ShM<EntryClassID, true>::vector entry_class_id_list(
+        typename util::vector_view<EntryClassID> entry_class_id_list(
            entry_class_id_list_ptr, data_layout.num_entries[storage::DataLayout::ENTRY_CLASSID]);
        m_entry_class_id_list = std::move(entry_class_id_list);

        const auto pre_turn_bearing_ptr = data_layout.GetBlockPtr<util::guidance::TurnBearing>(
            memory_block, storage::DataLayout::PRE_TURN_BEARING);
-        typename util::ShM<util::guidance::TurnBearing, true>::vector pre_turn_bearing(
+        typename util::vector_view<util::guidance::TurnBearing> pre_turn_bearing(
            pre_turn_bearing_ptr, data_layout.num_entries[storage::DataLayout::PRE_TURN_BEARING]);
        m_pre_turn_bearing = std::move(pre_turn_bearing);

        const auto post_turn_bearing_ptr = data_layout.GetBlockPtr<util::guidance::TurnBearing>(
            memory_block, storage::DataLayout::POST_TURN_BEARING);
-        typename util::ShM<util::guidance::TurnBearing, true>::vector post_turn_bearing(
+        typename util::vector_view<util::guidance::TurnBearing> post_turn_bearing(
            post_turn_bearing_ptr, data_layout.num_entries[storage::DataLayout::POST_TURN_BEARING]);
        m_post_turn_bearing = std::move(post_turn_bearing);
    }
@@ -380,7 +381,7 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
    {
        auto via_geometry_list_ptr =
            data_layout.GetBlockPtr<GeometryID>(memory_block, storage::DataLayout::VIA_NODE_LIST);
-        util::ShM<GeometryID, true>::vector via_geometry_list(
+        util::vector_view<GeometryID> via_geometry_list(
            via_geometry_list_ptr, data_layout.num_entries[storage::DataLayout::VIA_NODE_LIST]);
        m_via_geometry_list = std::move(via_geometry_list);
    }
@@ -398,14 +399,14 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
    {
        auto offsets_ptr = data_layout.GetBlockPtr<std::uint32_t>(
            memory_block, storage::DataLayout::LANE_DESCRIPTION_OFFSETS);
-        util::ShM<std::uint32_t, true>::vector offsets(
+        util::vector_view<std::uint32_t> offsets(
            offsets_ptr, data_layout.num_entries[storage::DataLayout::LANE_DESCRIPTION_OFFSETS]);
        m_lane_description_offsets = std::move(offsets);

        auto masks_ptr = data_layout.GetBlockPtr<extractor::guidance::TurnLaneType::Mask>(
            memory_block, storage::DataLayout::LANE_DESCRIPTION_MASKS);

-        util::ShM<extractor::guidance::TurnLaneType::Mask, true>::vector masks(
+        util::vector_view<extractor::guidance::TurnLaneType::Mask> masks(
            masks_ptr, data_layout.num_entries[storage::DataLayout::LANE_DESCRIPTION_MASKS]);
        m_lane_description_masks = std::move(masks);
    }
@@ -414,12 +415,12 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
    {
        auto turn_weight_penalties_ptr = data_layout.GetBlockPtr<TurnPenalty>(
            memory_block, storage::DataLayout::TURN_WEIGHT_PENALTIES);
-        m_turn_weight_penalties = util::ShM<TurnPenalty, true>::vector(
+        m_turn_weight_penalties = util::vector_view<TurnPenalty>(
            turn_weight_penalties_ptr,
            data_layout.num_entries[storage::DataLayout::TURN_WEIGHT_PENALTIES]);
        auto turn_duration_penalties_ptr = data_layout.GetBlockPtr<TurnPenalty>(
            memory_block, storage::DataLayout::TURN_DURATION_PENALTIES);
-        m_turn_duration_penalties = util::ShM<TurnPenalty, true>::vector(
+        m_turn_duration_penalties = util::vector_view<TurnPenalty>(
            turn_duration_penalties_ptr,
            data_layout.num_entries[storage::DataLayout::TURN_DURATION_PENALTIES]);
    }
@@ -428,42 +429,42 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
    {
        auto geometries_index_ptr =
            data_layout.GetBlockPtr<unsigned>(memory_block, storage::DataLayout::GEOMETRIES_INDEX);
-        util::ShM<unsigned, true>::vector geometry_begin_indices(
+        util::vector_view<unsigned> geometry_begin_indices(
            geometries_index_ptr, data_layout.num_entries[storage::DataLayout::GEOMETRIES_INDEX]);

        auto geometries_node_list_ptr = data_layout.GetBlockPtr<NodeID>(
            memory_block, storage::DataLayout::GEOMETRIES_NODE_LIST);
-        util::ShM<NodeID, true>::vector geometry_node_list(
+        util::vector_view<NodeID> geometry_node_list(
            geometries_node_list_ptr,
            data_layout.num_entries[storage::DataLayout::GEOMETRIES_NODE_LIST]);

        auto geometries_fwd_weight_list_ptr = data_layout.GetBlockPtr<EdgeWeight>(
            memory_block, storage::DataLayout::GEOMETRIES_FWD_WEIGHT_LIST);
-        util::ShM<EdgeWeight, true>::vector geometry_fwd_weight_list(
+        util::vector_view<EdgeWeight> geometry_fwd_weight_list(
            geometries_fwd_weight_list_ptr,
            data_layout.num_entries[storage::DataLayout::GEOMETRIES_FWD_WEIGHT_LIST]);

        auto geometries_rev_weight_list_ptr = data_layout.GetBlockPtr<EdgeWeight>(
            memory_block, storage::DataLayout::GEOMETRIES_REV_WEIGHT_LIST);
-        util::ShM<EdgeWeight, true>::vector geometry_rev_weight_list(
+        util::vector_view<EdgeWeight> geometry_rev_weight_list(
            geometries_rev_weight_list_ptr,
            data_layout.num_entries[storage::DataLayout::GEOMETRIES_REV_WEIGHT_LIST]);

        auto geometries_fwd_duration_list_ptr = data_layout.GetBlockPtr<EdgeWeight>(
            memory_block, storage::DataLayout::GEOMETRIES_FWD_DURATION_LIST);
-        util::ShM<EdgeWeight, true>::vector geometry_fwd_duration_list(
+        util::vector_view<EdgeWeight> geometry_fwd_duration_list(
            geometries_fwd_duration_list_ptr,
            data_layout.num_entries[storage::DataLayout::GEOMETRIES_FWD_DURATION_LIST]);

        auto geometries_rev_duration_list_ptr = data_layout.GetBlockPtr<EdgeWeight>(
            memory_block, storage::DataLayout::GEOMETRIES_REV_DURATION_LIST);
-        util::ShM<EdgeWeight, true>::vector geometry_rev_duration_list(
+        util::vector_view<EdgeWeight> geometry_rev_duration_list(
            geometries_rev_duration_list_ptr,
            data_layout.num_entries[storage::DataLayout::GEOMETRIES_REV_DURATION_LIST]);

        auto datasources_list_ptr = data_layout.GetBlockPtr<DatasourceID>(
            memory_block, storage::DataLayout::DATASOURCES_LIST);
-        util::ShM<DatasourceID, true>::vector datasources_list(
+        util::vector_view<DatasourceID> datasources_list(
            datasources_list_ptr, data_layout.num_entries[storage::DataLayout::DATASOURCES_LIST]);

        segment_data = extractor::SegmentDataView{std::move(geometry_begin_indices),
@@ -482,13 +483,13 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
    {
        auto bearing_class_id_ptr = data_layout.GetBlockPtr<BearingClassID>(
            memory_block, storage::DataLayout::BEARING_CLASSID);
-        typename util::ShM<BearingClassID, true>::vector bearing_class_id_table(
+        typename util::vector_view<BearingClassID> bearing_class_id_table(
            bearing_class_id_ptr, data_layout.num_entries[storage::DataLayout::BEARING_CLASSID]);
        m_bearing_class_id_table = std::move(bearing_class_id_table);

        auto bearing_class_ptr = data_layout.GetBlockPtr<DiscreteBearing>(
            memory_block, storage::DataLayout::BEARING_VALUES);
-        typename util::ShM<DiscreteBearing, true>::vector bearing_class_table(
+        typename util::vector_view<DiscreteBearing> bearing_class_table(
            bearing_class_ptr, data_layout.num_entries[storage::DataLayout::BEARING_VALUES]);
        m_bearing_values_table = std::move(bearing_class_table);

@@ -496,17 +497,17 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
            data_layout.GetBlockPtr<unsigned>(memory_block, storage::DataLayout::BEARING_OFFSETS);
        auto blocks_ptr =
            data_layout.GetBlockPtr<IndexBlock>(memory_block, storage::DataLayout::BEARING_BLOCKS);
-        util::ShM<unsigned, true>::vector bearing_offsets(
+        util::vector_view<unsigned> bearing_offsets(
            offsets_ptr, data_layout.num_entries[storage::DataLayout::BEARING_OFFSETS]);
-        util::ShM<IndexBlock, true>::vector bearing_blocks(
+        util::vector_view<IndexBlock> bearing_blocks(
            blocks_ptr, data_layout.num_entries[storage::DataLayout::BEARING_BLOCKS]);

-        m_bearing_ranges_table = std::make_unique<util::RangeTable<16, true>>(
+        m_bearing_ranges_table = std::make_unique<util::RangeTable<16, storage::Ownership::View>>(
            bearing_offsets, bearing_blocks, static_cast<unsigned>(m_bearing_values_table.size()));

        auto entry_class_ptr = data_layout.GetBlockPtr<util::guidance::EntryClass>(
            memory_block, storage::DataLayout::ENTRY_CLASS);
-        typename util::ShM<util::guidance::EntryClass, true>::vector entry_class_table(
+        typename util::vector_view<util::guidance::EntryClass> entry_class_table(
            entry_class_ptr, data_layout.num_entries[storage::DataLayout::ENTRY_CLASS]);
        m_entry_class_table = std::move(entry_class_table);
    }
@@ -929,15 +930,13 @@ class ContiguousInternalMemoryAlgorithmDataFacade<algorithm::MLD>
                memory_block, storage::DataLayout::MLD_PARTITION);
            auto partition_entries_count =
                data_layout.GetBlockEntries(storage::DataLayout::MLD_PARTITION);
-            util::ShM<PartitionID, true>::vector partition(mld_partition_ptr,
-                                                           partition_entries_count);
+            util::vector_view<PartitionID> partition(mld_partition_ptr, partition_entries_count);

            auto mld_chilren_ptr = data_layout.GetBlockPtr<CellID>(
                memory_block, storage::DataLayout::MLD_CELL_TO_CHILDREN);
            auto children_entries_count =
                data_layout.GetBlockEntries(storage::DataLayout::MLD_CELL_TO_CHILDREN);
-            util::ShM<CellID, true>::vector cell_to_children(mld_chilren_ptr,
-                                                             children_entries_count);
+            util::vector_view<CellID> cell_to_children(mld_chilren_ptr, children_entries_count);

            mld_partition =
                partition::MultiLevelPartitionView{level_data, partition, cell_to_children};
@@ -969,15 +968,15 @@ class ContiguousInternalMemoryAlgorithmDataFacade<algorithm::MLD>
            auto cell_level_offsets_entries_count =
                data_layout.GetBlockEntries(storage::DataLayout::MLD_CELL_LEVEL_OFFSETS);

-            util::ShM<EdgeWeight, true>::vector weights(mld_cell_weights_ptr, weight_entries_count);
-            util::ShM<NodeID, true>::vector source_boundary(mld_source_boundary_ptr,
-                                                            source_boundary_entries_count);
-            util::ShM<NodeID, true>::vector destination_boundary(
-                mld_destination_boundary_ptr, destination_boundary_entries_count);
-            util::ShM<partition::CellStorageView::CellData, true>::vector cells(
-                mld_cells_ptr, cells_entries_counts);
-            util::ShM<std::uint64_t, true>::vector level_offsets(mld_cell_level_offsets_ptr,
-                                                                 cell_level_offsets_entries_count);
+            util::vector_view<EdgeWeight> weights(mld_cell_weights_ptr, weight_entries_count);
+            util::vector_view<NodeID> source_boundary(mld_source_boundary_ptr,
+                                                      source_boundary_entries_count);
+            util::vector_view<NodeID> destination_boundary(mld_destination_boundary_ptr,
+                                                           destination_boundary_entries_count);
+            util::vector_view<partition::CellStorageView::CellData> cells(mld_cells_ptr,
+                                                                          cells_entries_counts);
+            util::vector_view<std::uint64_t> level_offsets(mld_cell_level_offsets_ptr,
+                                                           cell_level_offsets_entries_count);

            mld_cell_storage = partition::CellStorageView{std::move(weights),
                                                          std::move(source_boundary),
@@ -997,11 +996,11 @@ class ContiguousInternalMemoryAlgorithmDataFacade<algorithm::MLD>
        auto graph_node_to_offset_ptr = data_layout.GetBlockPtr<QueryGraph::EdgeOffset>(
            memory_block, storage::DataLayout::MLD_GRAPH_NODE_TO_OFFSET);

-        util::ShM<GraphNode, true>::vector node_list(
+        util::vector_view<GraphNode> node_list(
            graph_nodes_ptr, data_layout.num_entries[storage::DataLayout::MLD_GRAPH_NODE_LIST]);
-        util::ShM<GraphEdge, true>::vector edge_list(
+        util::vector_view<GraphEdge> edge_list(
            graph_edges_ptr, data_layout.num_entries[storage::DataLayout::MLD_GRAPH_EDGE_LIST]);
-        util::ShM<QueryGraph::EdgeOffset, true>::vector node_to_offset(
+        util::vector_view<QueryGraph::EdgeOffset> node_to_offset(
            graph_node_to_offset_ptr,
            data_layout.num_entries[storage::DataLayout::MLD_GRAPH_NODE_TO_OFFSET]);

@@ -62,13 +62,6 @@ struct ExtractionWay
        forward_restricted = false;
    }

-    // These accessors exists because it's not possible to take the address of a bitfield,
-    // and LUA therefore cannot read/write the mode attributes directly.
-    void set_forward_mode(const TravelMode m) { forward_travel_mode = m; }
-    TravelMode get_forward_mode() const { return forward_travel_mode; }
-    void set_backward_mode(const TravelMode m) { backward_travel_mode = m; }
-    TravelMode get_backward_mode() const { return backward_travel_mode; }
-
    // wrappers to allow assigning nil (nullptr) to string values
    void SetName(const char *value) { detail::maybeSetString(name, value); }
    const char *GetName() const { return name.c_str(); }
@@ -105,14 +98,14 @@ struct ExtractionWay
    std::string destinations;
    std::string turn_lanes_forward;
    std::string turn_lanes_backward;
-    bool roundabout;
-    bool circular;
-    bool is_startpoint;
-    bool backward_restricted;
-    bool forward_restricted;
+    guidance::RoadClassification road_classification;
    TravelMode forward_travel_mode : 4;
    TravelMode backward_travel_mode : 4;
-    guidance::RoadClassification road_classification;
+    bool roundabout : 1;
+    bool circular : 1;
+    bool is_startpoint : 1;
+    bool forward_restricted : 1;
+    bool backward_restricted : 1;
 };
 }
 }
@@ -63,6 +63,7 @@ class ExtractorCallbacks
    guidance::LaneDescriptionMap lane_description_map;
    ExtractionContainers &external_memory;
    bool fallback_to_duration;
+    bool force_split_edges;

  public:
    explicit ExtractorCallbacks(ExtractionContainers &extraction_containers,
@@ -87,6 +87,7 @@ struct ProfileProperties
    //! stores the name of the weight (e.g. 'duration', 'distance', 'safety')
    char weight_name[MAX_WEIGHT_NAME_LENGTH + 1];
    unsigned weight_precision = 1;
+    bool force_split_edges = false;
 };
 }
 }
@@ -4,6 +4,8 @@
 #include "util/shared_memory_vector_wrapper.hpp"
 #include "util/typedefs.hpp"

+#include "storage/shared_memory_ownership.hpp"
+
 #include <boost/filesystem/path.hpp>
 #include <boost/range/adaptor/reversed.hpp>
 #include <boost/range/iterator_range.hpp>
@@ -22,24 +24,24 @@ class CompressedEdgeContainer;

 namespace detail
 {
-template <bool UseShareMemory> class SegmentDataContainerImpl;
+template <storage::Ownership Ownership> class SegmentDataContainerImpl;
 }

 namespace io
 {
-template <bool UseShareMemory>
+template <storage::Ownership Ownership>
 inline void read(const boost::filesystem::path &path,
-                 detail::SegmentDataContainerImpl<UseShareMemory> &segment_data);
-template <bool UseShareMemory>
+                 detail::SegmentDataContainerImpl<Ownership> &segment_data);
+template <storage::Ownership Ownership>
 inline void write(const boost::filesystem::path &path,
-                  const detail::SegmentDataContainerImpl<UseShareMemory> &segment_data);
+                  const detail::SegmentDataContainerImpl<Ownership> &segment_data);
 }

 namespace detail
 {
-template <bool UseShareMemory> class SegmentDataContainerImpl
+template <storage::Ownership Ownership> class SegmentDataContainerImpl
 {
-    template <typename T> using Vector = typename util::ShM<T, UseShareMemory>::vector;
+    template <typename T> using Vector = typename util::ShM<T, Ownership>::vector;

    friend CompressedEdgeContainer;

@@ -188,12 +190,11 @@ template <bool UseShareMemory> class SegmentDataContainerImpl
    auto GetNumberOfGeometries() const { return index.size() - 1; }
    auto GetNumberOfSegments() const { return fwd_weights.size(); }

+    friend void io::read<Ownership>(const boost::filesystem::path &path,
+                                    detail::SegmentDataContainerImpl<Ownership> &segment_data);
    friend void
-    io::read<UseShareMemory>(const boost::filesystem::path &path,
-                             detail::SegmentDataContainerImpl<UseShareMemory> &segment_data);
-    friend void
-    io::write<UseShareMemory>(const boost::filesystem::path &path,
-                              const detail::SegmentDataContainerImpl<UseShareMemory> &segment_data);
+    io::write<Ownership>(const boost::filesystem::path &path,
+                         const detail::SegmentDataContainerImpl<Ownership> &segment_data);

  private:
    Vector<std::uint32_t> index;
@@ -206,8 +207,8 @@ template <bool UseShareMemory> class SegmentDataContainerImpl
 };
 }

-using SegmentDataView = detail::SegmentDataContainerImpl<true>;
-using SegmentDataContainer = detail::SegmentDataContainerImpl<false>;
+using SegmentDataView = detail::SegmentDataContainerImpl<storage::Ownership::View>;
+using SegmentDataContainer = detail::SegmentDataContainerImpl<storage::Ownership::Container>;
 }
 }

@@ -112,7 +112,13 @@ inline engine_config_ptr argumentsToEngineConfig(const Nan::FunctionCallbackInfo
    auto params = Nan::To<v8::Object>(args[0]).ToLocalChecked();

    auto path = params->Get(Nan::New("path").ToLocalChecked());
+    if (path.IsEmpty())
+        return engine_config_ptr();
+
    auto shared_memory = params->Get(Nan::New("shared_memory").ToLocalChecked());
+    if (shared_memory.IsEmpty())
+        return engine_config_ptr();
+
    if (!path->IsUndefined())
    {
        engine_config->storage_config =
@@ -140,6 +146,9 @@ inline engine_config_ptr argumentsToEngineConfig(const Nan::FunctionCallbackInfo
    }

    auto algorithm = params->Get(Nan::New("algorithm").ToLocalChecked());
+    if (algorithm.IsEmpty())
+        return engine_config_ptr();
+
    if (algorithm->IsString())
    {
        auto algorithm_str = Nan::To<v8::String>(algorithm).ToLocalChecked();
@@ -180,6 +189,8 @@ parseCoordinateArray(const v8::Local<v8::Array> &coordinates_array)
    for (uint32_t i = 0; i < coordinates_array->Length(); ++i)
    {
        v8::Local<v8::Value> coordinate = coordinates_array->Get(i);
+        if (coordinate.IsEmpty())
+            return resulting_coordinates;

        if (!coordinate->IsArray())
        {
@@ -247,6 +258,9 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo<v8::Value> &arg
    v8::Local<v8::Object> obj = Nan::To<v8::Object>(args[0]).ToLocalChecked();

    v8::Local<v8::Value> coordinates = obj->Get(Nan::New("coordinates").ToLocalChecked());
+    if (coordinates.IsEmpty())
+        return false;
+
    if (coordinates->IsUndefined())
    {
        Nan::ThrowError("Must provide a coordinates property");
@@ -287,6 +301,8 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo<v8::Value> &arg
    if (obj->Has(Nan::New("bearings").ToLocalChecked()))
    {
        v8::Local<v8::Value> bearings = obj->Get(Nan::New("bearings").ToLocalChecked());
+        if (bearings.IsEmpty())
+            return false;

        if (!bearings->IsArray())
        {
@@ -305,6 +321,8 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo<v8::Value> &arg
        for (uint32_t i = 0; i < bearings_array->Length(); ++i)
        {
            v8::Local<v8::Value> bearing_raw = bearings_array->Get(i);
+            if (bearing_raw.IsEmpty())
+                return false;

            if (bearing_raw->IsNull())
            {
@@ -349,6 +367,8 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo<v8::Value> &arg
    if (obj->Has(Nan::New("hints").ToLocalChecked()))
    {
        v8::Local<v8::Value> hints = obj->Get(Nan::New("hints").ToLocalChecked());
+        if (hints.IsEmpty())
+            return false;

        if (!hints->IsArray())
        {
@@ -367,6 +387,9 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo<v8::Value> &arg
        for (uint32_t i = 0; i < hints_array->Length(); ++i)
        {
            v8::Local<v8::Value> hint = hints_array->Get(i);
+            if (hint.IsEmpty())
+                return false;
+
            if (hint->IsString())
            {
                if (hint->ToString()->Length() == 0)
@@ -393,6 +416,8 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo<v8::Value> &arg
    if (obj->Has(Nan::New("radiuses").ToLocalChecked()))
    {
        v8::Local<v8::Value> radiuses = obj->Get(Nan::New("radiuses").ToLocalChecked());
+        if (radiuses.IsEmpty())
+            return false;

        if (!radiuses->IsArray())
        {
@@ -411,6 +436,9 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo<v8::Value> &arg
        for (uint32_t i = 0; i < radiuses_array->Length(); ++i)
        {
            v8::Local<v8::Value> radius = radiuses_array->Get(i);
+            if (radius.IsEmpty())
+                return false;
+
            if (radius->IsNull())
            {
                params->radiuses.emplace_back();
@@ -430,6 +458,8 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo<v8::Value> &arg
    if (obj->Has(Nan::New("generate_hints").ToLocalChecked()))
    {
        v8::Local<v8::Value> generate_hints = obj->Get(Nan::New("generate_hints").ToLocalChecked());
+        if (generate_hints.IsEmpty())
+            return false;

        if (!generate_hints->IsBoolean())
        {
@@ -449,6 +479,9 @@ inline bool parseCommonParameters(const v8::Local<v8::Object> &obj, ParamType &p
    if (obj->Has(Nan::New("steps").ToLocalChecked()))
    {
        auto steps = obj->Get(Nan::New("steps").ToLocalChecked());
+        if (steps.IsEmpty())
+            return false;
+
        if (steps->IsBoolean())
        {
            params->steps = steps->BooleanValue();
@@ -463,6 +496,9 @@ inline bool parseCommonParameters(const v8::Local<v8::Object> &obj, ParamType &p
    if (obj->Has(Nan::New("annotations").ToLocalChecked()))
    {
        auto annotations = obj->Get(Nan::New("annotations").ToLocalChecked());
+        if (annotations.IsEmpty())
+            return false;
+
        if (annotations->IsBoolean())
        {
            params->annotations = annotations->BooleanValue();
@@ -523,6 +559,8 @@ inline bool parseCommonParameters(const v8::Local<v8::Object> &obj, ParamType &p
    if (obj->Has(Nan::New("geometries").ToLocalChecked()))
    {
        v8::Local<v8::Value> geometries = obj->Get(Nan::New("geometries").ToLocalChecked());
+        if (geometries.IsEmpty())
+            return false;

        if (!geometries->IsString())
        {
@@ -555,6 +593,8 @@ inline bool parseCommonParameters(const v8::Local<v8::Object> &obj, ParamType &p
    if (obj->Has(Nan::New("overview").ToLocalChecked()))
    {
        v8::Local<v8::Value> overview = obj->Get(Nan::New("overview").ToLocalChecked());
+        if (overview.IsEmpty())
+            return false;

        if (!overview->IsString())
        {
@@ -601,9 +641,13 @@ argumentsToRouteParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
    if (obj->Has(Nan::New("continue_straight").ToLocalChecked()))
    {
        auto value = obj->Get(Nan::New("continue_straight").ToLocalChecked());
+        if (value.IsEmpty())
+            return route_parameters_ptr();
+
        if (!value->IsBoolean() && !value->IsNull())
        {
            Nan::ThrowError("'continue_straight' parama must be boolean or null");
+            return route_parameters_ptr();
        }
        if (value->IsBoolean())
        {
@@ -614,9 +658,13 @@ argumentsToRouteParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
    if (obj->Has(Nan::New("alternatives").ToLocalChecked()))
    {
        auto value = obj->Get(Nan::New("alternatives").ToLocalChecked());
+        if (value.IsEmpty())
+            return route_parameters_ptr();
+
        if (!value->IsBoolean())
        {
            Nan::ThrowError("'alternatives' parama must be boolean");
+            return route_parameters_ptr();
        }
        params->alternatives = value->BooleanValue();
    }
@@ -658,6 +706,8 @@ argumentsToTileParameters(const Nan::FunctionCallbackInfo<v8::Value> &args, bool
    v8::Local<v8::Value> x = array->Get(0);
    v8::Local<v8::Value> y = array->Get(1);
    v8::Local<v8::Value> z = array->Get(2);
+    if (x.IsEmpty() || y.IsEmpty() || z.IsEmpty())
+        return tile_parameters_ptr();

    if (!x->IsUint32() && !x->IsUndefined())
    {
@@ -698,6 +748,8 @@ argumentsToNearestParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
        return nearest_parameters_ptr();

    v8::Local<v8::Object> obj = Nan::To<v8::Object>(args[0]).ToLocalChecked();
+    if (obj.IsEmpty())
+        return nearest_parameters_ptr();

    if (obj->Has(Nan::New("number").ToLocalChecked()))
    {
@@ -735,10 +787,14 @@ argumentsToTableParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
        return table_parameters_ptr();

    v8::Local<v8::Object> obj = Nan::To<v8::Object>(args[0]).ToLocalChecked();
+    if (obj.IsEmpty())
+        return table_parameters_ptr();

    if (obj->Has(Nan::New("sources").ToLocalChecked()))
    {
        v8::Local<v8::Value> sources = obj->Get(Nan::New("sources").ToLocalChecked());
+        if (sources.IsEmpty())
+            return table_parameters_ptr();

        if (!sources->IsArray())
        {
@@ -750,6 +806,9 @@ argumentsToTableParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
        for (uint32_t i = 0; i < sources_array->Length(); ++i)
        {
            v8::Local<v8::Value> source = sources_array->Get(i);
+            if (source.IsEmpty())
+                return table_parameters_ptr();
+
            if (source->IsUint32())
            {
                size_t source_value = static_cast<size_t>(source->NumberValue());
@@ -773,6 +832,8 @@ argumentsToTableParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
    if (obj->Has(Nan::New("destinations").ToLocalChecked()))
    {
        v8::Local<v8::Value> destinations = obj->Get(Nan::New("destinations").ToLocalChecked());
+        if (destinations.IsEmpty())
+            return table_parameters_ptr();

        if (!destinations->IsArray())
        {
@@ -784,6 +845,9 @@ argumentsToTableParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
        for (uint32_t i = 0; i < destinations_array->Length(); ++i)
        {
            v8::Local<v8::Value> destination = destinations_array->Get(i);
+            if (destination.IsEmpty())
+                return table_parameters_ptr();
+
            if (destination->IsUint32())
            {
                size_t destination_value = static_cast<size_t>(destination->NumberValue());
@@ -827,6 +891,9 @@ argumentsToTripParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
    if (obj->Has(Nan::New("roundtrip").ToLocalChecked()))
    {
        auto roundtrip = obj->Get(Nan::New("roundtrip").ToLocalChecked());
+        if (roundtrip.IsEmpty())
+            return trip_parameters_ptr();
+
        if (roundtrip->IsBoolean())
        {
            params->roundtrip = roundtrip->BooleanValue();
@@ -841,6 +908,8 @@ argumentsToTripParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
    if (obj->Has(Nan::New("source").ToLocalChecked()))
    {
        v8::Local<v8::Value> source = obj->Get(Nan::New("source").ToLocalChecked());
+        if (source.IsEmpty())
+            return trip_parameters_ptr();

        if (!source->IsString())
        {
@@ -868,6 +937,8 @@ argumentsToTripParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
    if (obj->Has(Nan::New("destination").ToLocalChecked()))
    {
        v8::Local<v8::Value> destination = obj->Get(Nan::New("destination").ToLocalChecked());
+        if (destination.IsEmpty())
+            return trip_parameters_ptr();

        if (!destination->IsString())
        {
@@ -909,6 +980,8 @@ argumentsToMatchParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
    if (obj->Has(Nan::New("timestamps").ToLocalChecked()))
    {
        v8::Local<v8::Value> timestamps = obj->Get(Nan::New("timestamps").ToLocalChecked());
+        if (timestamps.IsEmpty())
+            return match_parameters_ptr();

        if (!timestamps->IsArray())
        {
@@ -928,6 +1001,9 @@ argumentsToMatchParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
        for (uint32_t i = 0; i < timestamps_array->Length(); ++i)
        {
            v8::Local<v8::Value> timestamp = timestamps_array->Get(i);
+            if (timestamp.IsEmpty())
+                return match_parameters_ptr();
+
            if (!timestamp->IsNumber())
            {
                Nan::ThrowError("Timestamps array items must be numbers");
@@ -10,6 +10,7 @@
 #include "util/typedefs.hpp"

 #include "storage/io.hpp"
+#include "storage/shared_memory_ownership.hpp"

 #include <boost/iterator/iterator_facade.hpp>
 #include <boost/range/iterator_range.hpp>
@@ -26,24 +27,23 @@ namespace partition
 {
 namespace detail
 {
-template <bool UseShareMemory> class CellStorageImpl;
+template <storage::Ownership Ownership> class CellStorageImpl;
 }
-using CellStorage = detail::CellStorageImpl<false>;
-using CellStorageView = detail::CellStorageImpl<true>;
+using CellStorage = detail::CellStorageImpl<storage::Ownership::Container>;
+using CellStorageView = detail::CellStorageImpl<storage::Ownership::View>;

 namespace io
 {
-template <bool UseShareMemory>
-inline void read(const boost::filesystem::path &path,
-                 detail::CellStorageImpl<UseShareMemory> &storage);
-template <bool UseShareMemory>
+template <storage::Ownership Ownership>
+inline void read(const boost::filesystem::path &path, detail::CellStorageImpl<Ownership> &storage);
+template <storage::Ownership Ownership>
 inline void write(const boost::filesystem::path &path,
-                  const detail::CellStorageImpl<UseShareMemory> &storage);
+                  const detail::CellStorageImpl<Ownership> &storage);
 }

 namespace detail
 {
-template <bool UseShareMemory> class CellStorageImpl
+template <storage::Ownership Ownership> class CellStorageImpl
 {
  public:
    using WeightOffset = std::uint32_t;
@@ -65,7 +65,7 @@ template <bool UseShareMemory> class CellStorageImpl
    };

  private:
-    template <typename T> using Vector = typename util::ShM<T, UseShareMemory>::vector;
+    template <typename T> using Vector = typename util::ShM<T, Ownership>::vector;

    // Implementation of the cell view. We need a template parameter here
    // because we need to derive a read-only and read-write view from this.
@@ -185,7 +185,8 @@ template <bool UseShareMemory> class CellStorageImpl

    CellStorageImpl() {}

-    template <typename GraphT, typename = std::enable_if<!UseShareMemory>>
+    template <typename GraphT,
+              typename = std::enable_if<Ownership == storage::Ownership::Container>>
    CellStorageImpl(const partition::MultiLevelPartition &partition, const GraphT &base_graph)
    {
        // pre-allocate storge for CellData so we can have random access to it by cell id
@@ -314,7 +315,7 @@ template <bool UseShareMemory> class CellStorageImpl
        weights.resize(weight_offset + 1, INVALID_EDGE_WEIGHT);
    }

-    template <typename = std::enable_if<UseShareMemory>>
+    template <typename = std::enable_if<Ownership == storage::Ownership::View>>
    CellStorageImpl(Vector<EdgeWeight> weights_,
                    Vector<NodeID> source_boundary_,
                    Vector<NodeID> destination_boundary_,
@@ -339,7 +340,8 @@ template <bool UseShareMemory> class CellStorageImpl
                         destination_boundary.empty() ? nullptr : destination_boundary.data()};
    }

-    template <typename = std::enable_if<!UseShareMemory>> Cell GetCell(LevelID level, CellID id)
+    template <typename = std::enable_if<Ownership == storage::Ownership::Container>>
+    Cell GetCell(LevelID level, CellID id)
    {
        const auto level_index = LevelIDToIndex(level);
        BOOST_ASSERT(level_index < level_to_cell_offset.size());
@@ -350,10 +352,10 @@ template <bool UseShareMemory> class CellStorageImpl
            cells[cell_index], weights.data(), source_boundary.data(), destination_boundary.data()};
    }

-    friend void io::read<UseShareMemory>(const boost::filesystem::path &path,
-                                         detail::CellStorageImpl<UseShareMemory> &storage);
-    friend void io::write<UseShareMemory>(const boost::filesystem::path &path,
-                                          const detail::CellStorageImpl<UseShareMemory> &storage);
+    friend void io::read<Ownership>(const boost::filesystem::path &path,
+                                    detail::CellStorageImpl<Ownership> &storage);
+    friend void io::write<Ownership>(const boost::filesystem::path &path,
+                                     const detail::CellStorageImpl<Ownership> &storage);

  private:
    Vector<EdgeWeight> weights;
@@ -7,6 +7,7 @@
 #include "partition/multi_level_partition.hpp"

 #include "storage/io.hpp"
+#include "storage/shared_memory_ownership.hpp"

 namespace osrm
 {
@@ -15,9 +16,8 @@ namespace partition
 namespace io
 {

-template <typename EdgeDataT, bool UseSharedMemory>
-inline void read(const boost::filesystem::path &path,
-                 MultiLevelGraph<EdgeDataT, UseSharedMemory> &graph)
+template <typename EdgeDataT, storage::Ownership Ownership>
+inline void read(const boost::filesystem::path &path, MultiLevelGraph<EdgeDataT, Ownership> &graph)
 {
    const auto fingerprint = storage::io::FileReader::VerifyFingerprint;
    storage::io::FileReader reader{path, fingerprint};
@@ -27,9 +27,9 @@ inline void read(const boost::filesystem::path &path,
    reader.DeserializeVector(graph.edge_to_level);
 }

-template <typename EdgeDataT, bool UseSharedMemory>
+template <typename EdgeDataT, storage::Ownership Ownership>
 inline void write(const boost::filesystem::path &path,
-                  const MultiLevelGraph<EdgeDataT, UseSharedMemory> &graph)
+                  const MultiLevelGraph<EdgeDataT, Ownership> &graph)
 {
    const auto fingerprint = storage::io::FileWriter::GenerateFingerprint;
    storage::io::FileWriter writer{path, fingerprint};
@@ -3,6 +3,8 @@

 #include "partition/multi_level_partition.hpp"

+#include "storage/shared_memory_ownership.hpp"
+
 #include "util/static_graph.hpp"

 #include <tbb/parallel_sort.h>
@@ -14,24 +16,23 @@ namespace osrm
 {
 namespace partition
 {
-template <typename EdgeDataT, bool UseSharedMemory> class MultiLevelGraph;
+template <typename EdgeDataT, storage::Ownership Ownership> class MultiLevelGraph;

 namespace io
 {
-template <typename EdgeDataT, bool UseSharedMemory>
-void read(const boost::filesystem::path &path, MultiLevelGraph<EdgeDataT, UseSharedMemory> &graph);
+template <typename EdgeDataT, storage::Ownership Ownership>
+void read(const boost::filesystem::path &path, MultiLevelGraph<EdgeDataT, Ownership> &graph);

-template <typename EdgeDataT, bool UseSharedMemory>
-void write(const boost::filesystem::path &path,
-           const MultiLevelGraph<EdgeDataT, UseSharedMemory> &graph);
+template <typename EdgeDataT, storage::Ownership Ownership>
+void write(const boost::filesystem::path &path, const MultiLevelGraph<EdgeDataT, Ownership> &graph);
 }

-template <typename EdgeDataT, bool UseSharedMemory>
-class MultiLevelGraph : public util::StaticGraph<EdgeDataT, UseSharedMemory>
+template <typename EdgeDataT, storage::Ownership Ownership>
+class MultiLevelGraph : public util::StaticGraph<EdgeDataT, Ownership>
 {
  private:
-    using SuperT = util::StaticGraph<EdgeDataT, UseSharedMemory>;
-    template <typename T> using Vector = typename util::ShM<T, UseSharedMemory>::vector;
+    using SuperT = util::StaticGraph<EdgeDataT, Ownership>;
+    template <typename T> using Vector = typename util::ShM<T, Ownership>::vector;

  public:
    // We limit each node to have 255 edges
@@ -189,12 +190,10 @@ class MultiLevelGraph : public util::StaticGraph<EdgeDataT, UseSharedMemory>
        node_to_edge_offset.push_back(mlp.GetNumberOfLevels());
    }

-    friend void
-    io::read<EdgeDataT, UseSharedMemory>(const boost::filesystem::path &path,
-                                         MultiLevelGraph<EdgeDataT, UseSharedMemory> &graph);
-    friend void
-    io::write<EdgeDataT, UseSharedMemory>(const boost::filesystem::path &path,
-                                          const MultiLevelGraph<EdgeDataT, UseSharedMemory> &graph);
+    friend void io::read<EdgeDataT, Ownership>(const boost::filesystem::path &path,
+                                               MultiLevelGraph<EdgeDataT, Ownership> &graph);
+    friend void io::write<EdgeDataT, Ownership>(const boost::filesystem::path &path,
+                                                const MultiLevelGraph<EdgeDataT, Ownership> &graph);

    Vector<EdgeOffset> node_to_edge_offset;
 };
@@ -8,6 +8,7 @@
 #include "util/typedefs.hpp"

 #include "storage/io.hpp"
+#include "storage/shared_memory_ownership.hpp"

 #include <algorithm>
 #include <array>
@@ -25,31 +26,30 @@ namespace partition
 {
 namespace detail
 {
-template <bool UseShareMemory> class MultiLevelPartitionImpl;
+template <storage::Ownership Ownership> class MultiLevelPartitionImpl;
 }
-using MultiLevelPartition = detail::MultiLevelPartitionImpl<false>;
-using MultiLevelPartitionView = detail::MultiLevelPartitionImpl<true>;
+using MultiLevelPartition = detail::MultiLevelPartitionImpl<storage::Ownership::Container>;
+using MultiLevelPartitionView = detail::MultiLevelPartitionImpl<storage::Ownership::View>;

 namespace io
 {
-template <bool UseShareMemory>
-void read(const boost::filesystem::path &file,
-          detail::MultiLevelPartitionImpl<UseShareMemory> &mlp);
-template <bool UseShareMemory>
+template <storage::Ownership Ownership>
+void read(const boost::filesystem::path &file, detail::MultiLevelPartitionImpl<Ownership> &mlp);
+template <storage::Ownership Ownership>
 void write(const boost::filesystem::path &file,
-           const detail::MultiLevelPartitionImpl<UseShareMemory> &mlp);
+           const detail::MultiLevelPartitionImpl<Ownership> &mlp);
 }

 namespace detail
 {

-template <bool UseShareMemory> class MultiLevelPartitionImpl final
+template <storage::Ownership Ownership> class MultiLevelPartitionImpl final
 {
    // we will support at most 16 levels
    static const constexpr std::uint8_t MAX_NUM_LEVEL = 16;
    static const constexpr std::uint8_t NUM_PARTITION_BITS = sizeof(PartitionID) * CHAR_BIT;

-    template <typename T> using Vector = typename util::ShM<T, UseShareMemory>::vector;
+    template <typename T> using Vector = typename util::ShM<T, Ownership>::vector;

  public:
    // Contains all data necessary to describe the level hierarchy
@@ -68,7 +68,7 @@ template <bool UseShareMemory> class MultiLevelPartitionImpl final
    // cell_sizes is index by level (starting at 0, the base graph).
    // However level 0 always needs to have cell size 1, since it is the
    // basegraph.
-    template <typename = typename std::enable_if<!UseShareMemory>>
+    template <typename = typename std::enable_if<Ownership == storage::Ownership::Container>>
    MultiLevelPartitionImpl(const std::vector<std::vector<CellID>> &partitions,
                            const std::vector<std::uint32_t> &lidx_to_num_cells)
        : level_data(MakeLevelData(lidx_to_num_cells))
@@ -76,7 +76,7 @@ template <bool UseShareMemory> class MultiLevelPartitionImpl final
        InitializePartitionIDs(partitions);
    }

-    template <typename = typename std::enable_if<UseShareMemory>>
+    template <typename = typename std::enable_if<Ownership == storage::Ownership::View>>
    MultiLevelPartitionImpl(LevelData level_data,
                            Vector<PartitionID> partition_,
                            Vector<CellID> cell_to_children_)
@@ -134,10 +134,10 @@ template <bool UseShareMemory> class MultiLevelPartitionImpl final
        return cell_to_children[offset + cell + 1];
    }

-    friend void io::read<UseShareMemory>(const boost::filesystem::path &file,
-                                         MultiLevelPartitionImpl &mlp);
-    friend void io::write<UseShareMemory>(const boost::filesystem::path &file,
-                                          const MultiLevelPartitionImpl &mlp);
+    friend void io::read<Ownership>(const boost::filesystem::path &file,
+                                    MultiLevelPartitionImpl &mlp);
+    friend void io::write<Ownership>(const boost::filesystem::path &file,
+                                     const MultiLevelPartitionImpl &mlp);

  private:
    auto MakeLevelData(const std::vector<std::uint32_t> &lidx_to_num_cells)
@@ -25,6 +25,8 @@
 #include <exception>
 #include <thread>

+#include "storage/shared_memory_ownership.hpp"
+
 namespace osrm
 {
 namespace storage
@@ -0,0 +1,17 @@
+#ifndef SHARED_MEMORY_OWNERSHIP_HPP
+#define SHARED_MEMORY_OWNERSHIP_HPP
+
+namespace osrm
+{
+namespace storage
+{
+
+enum class Ownership
+{
+    Container,
+    View
+};
+}
+}
+
+#endif // SHARED_MEMORY_OWNERSHIP_HPP
@@ -4,6 +4,8 @@
 #include "util/shared_memory_vector_wrapper.hpp"
 #include "util/typedefs.hpp"

+#include "storage/shared_memory_ownership.hpp"
+
 #include <cmath>
 #include <vector>

@@ -20,7 +22,8 @@ namespace util
 * NOTE: this type is templated for future use, but will require a slight refactor to
 * configure BITSIZE and ELEMSIZE
 */
-template <typename T, bool UseSharedMemory = false> class PackedVector
+template <typename T, storage::Ownership Ownership = storage::Ownership::Container>
+class PackedVector
 {
    static const constexpr std::size_t BITSIZE = 33;
    static const constexpr std::size_t ELEMSIZE = 64;
@@ -120,20 +123,20 @@ template <typename T, bool UseSharedMemory = false> class PackedVector

    std::size_t size() const { return num_elements; }

-    template <bool enabled = UseSharedMemory>
+    template <bool enabled = (Ownership == storage::Ownership::View)>
    void reserve(typename std::enable_if<!enabled, std::size_t>::type capacity)
    {
        vec.reserve(elements_to_blocks(capacity));
    }

-    template <bool enabled = UseSharedMemory>
+    template <bool enabled = (Ownership == storage::Ownership::View)>
    void reset(typename std::enable_if<enabled, std::uint64_t>::type *ptr,
               typename std::enable_if<enabled, std::size_t>::type size)
    {
        vec.reset(ptr, size);
    }

-    template <bool enabled = UseSharedMemory>
+    template <bool enabled = (Ownership == storage::Ownership::View)>
    void set_number_of_entries(typename std::enable_if<enabled, std::size_t>::type count)
    {
        num_elements = count;
@@ -145,44 +148,44 @@ template <typename T, bool UseSharedMemory = false> class PackedVector
    }

  private:
-    typename util::ShM<std::uint64_t, UseSharedMemory>::vector vec;
+    typename util::ShM<std::uint64_t, Ownership>::vector vec;

    std::size_t num_elements = 0;

    signed cursor = -1;

-    template <bool enabled = UseSharedMemory>
+    template <bool enabled = (Ownership == storage::Ownership::View)>
    void replace_last_elem(typename std::enable_if<enabled, std::uint64_t>::type last_elem)
    {
        vec[cursor] = last_elem;
    }

-    template <bool enabled = UseSharedMemory>
+    template <bool enabled = (Ownership == storage::Ownership::View)>
    void replace_last_elem(typename std::enable_if<!enabled, std::uint64_t>::type last_elem)
    {
        vec.back() = last_elem;
    }

-    template <bool enabled = UseSharedMemory>
+    template <bool enabled = (Ownership == storage::Ownership::View)>
    void add_last_elem(typename std::enable_if<enabled, std::uint64_t>::type last_elem)
    {
        vec[cursor + 1] = last_elem;
        cursor++;
    }

-    template <bool enabled = UseSharedMemory>
+    template <bool enabled = (Ownership == storage::Ownership::View)>
    void add_last_elem(typename std::enable_if<!enabled, std::uint64_t>::type last_elem)
    {
        vec.push_back(last_elem);
    }

-    template <bool enabled = UseSharedMemory>
+    template <bool enabled = (Ownership == storage::Ownership::View)>
    std::uint64_t vec_back(typename std::enable_if<enabled>::type * = nullptr)
    {
        return vec[cursor];
    }

-    template <bool enabled = UseSharedMemory>
+    template <bool enabled = (Ownership == storage::Ownership::View)>
    std::uint64_t vec_back(typename std::enable_if<!enabled>::type * = nullptr)
    {
        return vec.back();
@@ -2,6 +2,7 @@
 #define RANGE_TABLE_HPP

 #include "storage/io.hpp"
+#include "storage/shared_memory_ownership.hpp"
 #include "util/integer_range.hpp"
 #include "util/shared_memory_vector_wrapper.hpp"

@@ -18,13 +19,14 @@ namespace util
 * and otherwise the compiler gets confused.
 */

-template <unsigned BLOCK_SIZE = 16, bool USE_SHARED_MEMORY = false> class RangeTable;
+template <unsigned BLOCK_SIZE = 16, storage::Ownership Ownership = storage::Ownership::Container>
+class RangeTable;

-template <unsigned BLOCK_SIZE, bool USE_SHARED_MEMORY>
-std::ostream &operator<<(std::ostream &out, const RangeTable<BLOCK_SIZE, USE_SHARED_MEMORY> &table);
+template <unsigned BLOCK_SIZE, storage::Ownership Ownership>
+std::ostream &operator<<(std::ostream &out, const RangeTable<BLOCK_SIZE, Ownership> &table);

-template <unsigned BLOCK_SIZE, bool USE_SHARED_MEMORY>
-std::istream &operator>>(std::istream &in, RangeTable<BLOCK_SIZE, USE_SHARED_MEMORY> &table);
+template <unsigned BLOCK_SIZE, storage::Ownership Ownership>
+std::istream &operator>>(std::istream &in, RangeTable<BLOCK_SIZE, Ownership> &table);

 /**
 * Stores adjacent ranges in a compressed format.
@@ -35,12 +37,12 @@ std::istream &operator>>(std::istream &in, RangeTable<BLOCK_SIZE, USE_SHARED_MEM
 * But each block consists of an absolute value and BLOCK_SIZE differential values.
 * So the effective block size is sizeof(unsigned) + BLOCK_SIZE.
 */
-template <unsigned BLOCK_SIZE, bool USE_SHARED_MEMORY> class RangeTable
+template <unsigned BLOCK_SIZE, storage::Ownership Ownership> class RangeTable
 {
  public:
    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 BlockContainerT = typename ShM<BlockT, Ownership>::vector;
+    using OffsetContainerT = typename ShM<unsigned, Ownership>::vector;
    using RangeT = range<unsigned>;

    friend std::ostream &operator<<<>(std::ostream &out, const RangeTable &table);
@@ -139,7 +141,7 @@ template <unsigned BLOCK_SIZE, bool USE_SHARED_MEMORY> class RangeTable
        sum_lengths = lengths_prefix_sum;
    }

-    void Write(osrm::storage::io::FileWriter &filewriter)
+    void Write(storage::io::FileWriter &filewriter)
    {
        unsigned number_of_blocks = diff_blocks.size();

@@ -151,7 +153,7 @@ template <unsigned BLOCK_SIZE, bool USE_SHARED_MEMORY> class RangeTable
        filewriter.WriteFrom(diff_blocks.data(), number_of_blocks);
    }

-    void Read(osrm::storage::io::FileReader &filereader)
+    void Read(storage::io::FileReader &filereader)
    {
        unsigned number_of_blocks = filereader.ReadElementCount32();
        // read total length
@@ -212,9 +214,8 @@ template <unsigned BLOCK_SIZE, bool USE_SHARED_MEMORY> class RangeTable
    unsigned sum_lengths;
 };

-template <unsigned BLOCK_SIZE, bool USE_SHARED_MEMORY>
-unsigned RangeTable<BLOCK_SIZE, USE_SHARED_MEMORY>::PrefixSumAtIndex(int index,
-                                                                     const BlockT &block) const
+template <unsigned BLOCK_SIZE, storage::Ownership Ownership>
+unsigned RangeTable<BLOCK_SIZE, Ownership>::PrefixSumAtIndex(int index, const BlockT &block) const
 {
    // this loop looks inefficent, but a modern compiler
    // will emit nice SIMD here, at least for sensible block sizes. (I checked.)
@@ -227,8 +228,8 @@ unsigned RangeTable<BLOCK_SIZE, USE_SHARED_MEMORY>::PrefixSumAtIndex(int index,
    return sum;
 }

-template <unsigned BLOCK_SIZE, bool USE_SHARED_MEMORY>
-std::ostream &operator<<(std::ostream &out, const RangeTable<BLOCK_SIZE, USE_SHARED_MEMORY> &table)
+template <unsigned BLOCK_SIZE, storage::Ownership Ownership>
+std::ostream &operator<<(std::ostream &out, const RangeTable<BLOCK_SIZE, Ownership> &table)
 {
    // write number of block
    const unsigned number_of_blocks = table.diff_blocks.size();
@@ -243,8 +244,8 @@ std::ostream &operator<<(std::ostream &out, const RangeTable<BLOCK_SIZE, USE_SHA
    return out;
 }

-template <unsigned BLOCK_SIZE, bool USE_SHARED_MEMORY>
-std::istream &operator>>(std::istream &in, RangeTable<BLOCK_SIZE, USE_SHARED_MEMORY> &table)
+template <unsigned BLOCK_SIZE, storage::Ownership Ownership>
+std::istream &operator>>(std::istream &in, RangeTable<BLOCK_SIZE, Ownership> &table)
 {
    // read number of block
    unsigned number_of_blocks;
@@ -3,6 +3,8 @@

 #include "util/log.hpp"

+#include "storage/shared_memory_ownership.hpp"
+
 #include <boost/assert.hpp>
 #include <boost/iterator/iterator_facade.hpp>
 #include <boost/iterator/reverse_iterator.hpp>
@@ -52,7 +54,7 @@ class ShMemIterator
    DataT *m_value;
 };

-template <typename DataT> class SharedMemoryWrapper
+template <typename DataT> class vector_view
 {
  private:
    DataT *m_ptr;
@@ -64,9 +66,9 @@ template <typename DataT> class SharedMemoryWrapper
    using const_iterator = ShMemIterator<const DataT>;
    using reverse_iterator = boost::reverse_iterator<iterator>;

-    SharedMemoryWrapper() : m_ptr(nullptr), m_size(0) {}
+    vector_view() : m_ptr(nullptr), m_size(0) {}

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

    void reset(DataT *ptr, std::size_t size)
    {
@@ -126,20 +128,19 @@ template <typename DataT> class SharedMemoryWrapper

    auto data() const { return m_ptr; }

-    template <typename T>
-    friend void swap(SharedMemoryWrapper<T> &, SharedMemoryWrapper<T> &) noexcept;
+    template <typename T> friend void swap(vector_view<T> &, vector_view<T> &) noexcept;
 };

-template <> class SharedMemoryWrapper<bool>
+template <> class vector_view<bool>
 {
  private:
    unsigned *m_ptr;
    std::size_t m_size;

  public:
-    SharedMemoryWrapper() : m_ptr(nullptr), m_size(0) {}
+    vector_view() : m_ptr(nullptr), m_size(0) {}

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

    bool at(const std::size_t index) const
    {
@@ -161,22 +162,20 @@ template <> class SharedMemoryWrapper<bool>

    bool operator[](const unsigned index) const { return at(index); }

-    template <typename T>
-    friend void swap(SharedMemoryWrapper<T> &, SharedMemoryWrapper<T> &) noexcept;
+    template <typename T> friend void swap(vector_view<T> &, vector_view<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
+// Both vector_view<T> and the vector_view<bool> specializations share this impl.
+template <typename DataT> void swap(vector_view<DataT> &lhs, vector_view<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
+template <typename DataT, storage::Ownership Ownership> struct ShM
 {
-    using vector = typename std::conditional<UseSharedMemory,
-                                             SharedMemoryWrapper<DataT>,
+    using vector = typename std::conditional<Ownership == storage::Ownership::View,
+                                             vector_view<DataT>,
                                             std::vector<DataT>>::type;
 };
 }
@@ -7,6 +7,8 @@
 #include "util/shared_memory_vector_wrapper.hpp"
 #include "util/typedefs.hpp"

+#include "storage/shared_memory_ownership.hpp"
+
 #include <boost/assert.hpp>

 #include <algorithm>
@@ -97,7 +99,8 @@ EntryT edgeToEntry(const OtherEdge &from, std::false_type)

 } // namespace static_graph_details

-template <typename EdgeDataT, bool UseSharedMemory = false> class StaticGraph
+template <typename EdgeDataT, storage::Ownership Ownership = storage::Ownership::Container>
+class StaticGraph
 {
  public:
    using InputEdge = static_graph_details::SortableEdgeWithData<EdgeDataT>;
@@ -122,8 +125,8 @@ template <typename EdgeDataT, bool UseSharedMemory = false> class StaticGraph
        InitializeFromSortedEdgeRange(nodes, edges.begin(), edges.end());
    }

-    StaticGraph(typename ShM<NodeArrayEntry, UseSharedMemory>::vector node_array_,
-                typename ShM<EdgeArrayEntry, UseSharedMemory>::vector edge_array_)
+    StaticGraph(typename util::ShM<NodeArrayEntry, Ownership>::vector node_array_,
+                typename util::ShM<EdgeArrayEntry, Ownership>::vector edge_array_)
        : node_array(std::move(node_array_)), edge_array(std::move(edge_array_))
    {
        BOOST_ASSERT(!node_array.empty());
@@ -258,8 +261,8 @@ template <typename EdgeDataT, bool UseSharedMemory = false> class StaticGraph
    NodeIterator number_of_nodes;
    EdgeIterator number_of_edges;

-    typename ShM<NodeArrayEntry, UseSharedMemory>::vector node_array;
-    typename ShM<EdgeArrayEntry, UseSharedMemory>::vector edge_array;
+    typename ShM<NodeArrayEntry, Ownership>::vector node_array;
+    typename ShM<EdgeArrayEntry, Ownership>::vector edge_array;
 };

 } // namespace util
@@ -15,6 +15,8 @@

 #include "osrm/coordinate.hpp"

+#include "storage/shared_memory_ownership.hpp"
+
 #include <boost/assert.hpp>
 #include <boost/filesystem.hpp>
 #include <boost/filesystem/fstream.hpp>
@@ -52,7 +54,7 @@ namespace util
 // are computed, this means the internal distance metric doesn not represent meters!
 template <class EdgeDataT,
          class CoordinateListT = std::vector<Coordinate>,
-          bool UseSharedMemory = false,
+          storage::Ownership Ownership = storage::Ownership::Container,
          std::uint32_t BRANCHING_FACTOR = 128,
          std::uint32_t LEAF_PAGE_SIZE = 4096>
 class StaticRTree
@@ -152,12 +154,12 @@ class StaticRTree
        Coordinate fixed_projected_coordinate;
    };

-    typename ShM<TreeNode, UseSharedMemory>::vector m_search_tree;
+    typename ShM<TreeNode, Ownership>::vector m_search_tree;
    const CoordinateListT &m_coordinate_list;

    boost::iostreams::mapped_file_source m_leaves_region;
    // read-only view of leaves
-    typename ShM<const LeafNode, true>::vector m_leaves;
+    typename ShM<const LeafNode, storage::Ownership::View>::vector m_leaves;

  public:
    StaticRTree(const StaticRTree &) = delete;
@@ -1,6 +1,6 @@
 {
  "name": "osrm",
-  "version": "5.7.0-latest.1",
+  "version": "5.7.0-latest.3",
  "private": false,
  "description": "The Open Source Routing Machine is a high performance routing engine written in C++14 designed to run on OpenStreetMap data.",
  "dependencies": {
@@ -19,7 +19,8 @@
    "test": "npm run lint && node ./node_modules/cucumber/bin/cucumber.js features/ -p verify && node ./node_modules/cucumber/bin/cucumber.js features/ -p mld",
    "clean": "rm -rf test/cache",
    "docs": "./scripts/build_api_docs.sh",
-    "install": "node-pre-gyp install --fallback-to-build=false"
+    "install": "node-pre-gyp install --fallback-to-build=false",
+    "nodejs-tests": "make -C test/data && ./lib/binding/osrm-datastore test/data/ch/monaco.osrm && node test/nodejs/index.js | faucet"
  },
  "repository": {
    "type": "git",
@@ -44,6 +45,7 @@
    "mkdirp": "^0.5.1",
    "aws-sdk": "~2.0.31",
    "tape": "^4.2.2",
+    "faucet": "^0.0.1",
    "node-timeout": "0.0.4",
    "polyline": "^0.2.0",
    "request": "^2.69.0",
@@ -1,6 +1,8 @@
 api_version = 1
 -- Rasterbot profile

+properties.force_split_edges = true
+
 -- Minimalist node_ and way_functions in order to test source_ and segment_functions

 function node_function (node, result)
@@ -46,7 +48,7 @@ function segment_function (segment)
  local scaled_duration = segment.duration

  if sourceData.datum ~= invalid and targetData.datum ~= invalid then
-    local slope = math.abs(sourceData.datum - targetData.datum) / segment.distance
+    local slope = (targetData.datum - sourceData.datum) / segment.distance
    scaled_weight = scaled_weight / (1.0 - (slope * 5.0))
    scaled_duration = scaled_duration / (1.0 - (slope * 5.0))
    io.write("   slope: " .. slope .. "\n")
@@ -28,12 +28,14 @@ constexpr int32_t WORLD_MAX_LON = 180 * COORDINATE_PRECISION;

 using RTreeLeaf = extractor::EdgeBasedNode;
 using BenchStaticRTree =
-    util::StaticRTree<RTreeLeaf, util::ShM<util::Coordinate, false>::vector, false>;
+    util::StaticRTree<RTreeLeaf,
+                      util::ShM<util::Coordinate, storage::Ownership::Container>::vector,
+                      storage::Ownership::Container>;

 std::vector<util::Coordinate> loadCoordinates(const boost::filesystem::path &nodes_file)
 {
-    osrm::storage::io::FileReader nodes_path_file_reader(
-        nodes_file, osrm::storage::io::FileReader::HasNoFingerprint);
+    storage::io::FileReader nodes_path_file_reader(nodes_file,
+                                                   storage::io::FileReader::HasNoFingerprint);

    extractor::QueryNode current_node;
    unsigned coordinate_count = nodes_path_file_reader.ReadElementCount32();
@@ -8,6 +8,8 @@
 #include "partition/io.hpp"
 #include "partition/multi_level_partition.hpp"

+#include "storage/shared_memory_ownership.hpp"
+
 #include "updater/updater.hpp"

 #include "util/log.hpp"
@@ -82,9 +84,9 @@ auto LoadAndUpdateEdgeExpandedGraph(const CustomizationConfig &config,
    auto directed = partition::splitBidirectionalEdges(edge_based_edge_list);
    auto tidied =
        partition::prepareEdgesForUsageInGraph<StaticEdgeBasedGraphEdge>(std::move(directed));
-    auto edge_based_graph =
-        std::make_unique<partition::MultiLevelGraph<EdgeBasedGraphEdgeData, false>>(
-            mlp, num_nodes, std::move(tidied));
+    auto edge_based_graph = std::make_unique<
+        partition::MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::Container>>(
+        mlp, num_nodes, std::move(tidied));

    util::Log() << "Loaded edge based graph for mapping partition ids: "
                << edge_based_graph->GetNumberOfEdges() << " edges, "
@@ -388,21 +388,24 @@ void ExtractionContainers::PrepareEdges(ScriptingEnvironment &scripting_environm
            BOOST_ASSERT(edge_iterator->source_coordinate.lon !=
                         util::FixedLongitude{std::numeric_limits<std::int32_t>::min()});

-            const util::Coordinate target_coord{node_iterator->lon, node_iterator->lat};
-            const double distance = util::coordinate_calculation::greatCircleDistance(
-                edge_iterator->source_coordinate, target_coord);
+            util::Coordinate source_coord(edge_iterator->source_coordinate);
+            util::Coordinate target_coord{node_iterator->lon, node_iterator->lat};

-            auto weight = edge_iterator->weight_data(distance);
-            auto duration = edge_iterator->duration_data(distance);
+            // flip source and target coordinates if segment is in backward direction only
+            if (!edge_iterator->result.forward && edge_iterator->result.backward)
+                std::swap(source_coord, target_coord);

-            ExtractionSegment extracted_segment(
-                edge_iterator->source_coordinate, target_coord, distance, weight, duration);
-            scripting_environment.ProcessSegment(extracted_segment);
+            const auto distance =
+                util::coordinate_calculation::greatCircleDistance(source_coord, target_coord);
+            const auto weight = edge_iterator->weight_data(distance);
+            const auto duration = edge_iterator->duration_data(distance);
+
+            ExtractionSegment segment(source_coord, target_coord, distance, weight, duration);
+            scripting_environment.ProcessSegment(segment);

            auto &edge = edge_iterator->result;
-            edge.weight =
-                std::max<EdgeWeight>(1, std::round(extracted_segment.weight * weight_multiplier));
-            edge.duration = std::max<EdgeWeight>(1, std::round(extracted_segment.duration * 10.));
+            edge.weight = std::max<EdgeWeight>(1, std::round(segment.weight * weight_multiplier));
+            edge.duration = std::max<EdgeWeight>(1, std::round(segment.duration * 10.));

            // assign new node id
            auto id_iter = external_to_internal_node_id_map.find(node_iterator->node_id);
@@ -35,7 +35,9 @@ namespace TurnLaneType = guidance::TurnLaneType;

 ExtractorCallbacks::ExtractorCallbacks(ExtractionContainers &extraction_containers_,
                                       const ProfileProperties &properties)
-    : external_memory(extraction_containers_), fallback_to_duration(properties.fallback_to_duration)
+    : external_memory(extraction_containers_),
+      fallback_to_duration(properties.fallback_to_duration),
+      force_split_edges(properties.force_split_edges)
 {
    // we reserved 0, 1, 2, 3 for the empty case
    string_map[MapKey("", "", "", "")] = 0;
@@ -323,14 +325,15 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, const Extracti
        (parsed_way.backward_travel_mode != TRAVEL_MODE_INACCESSIBLE);

    // split an edge into two edges if forwards/backwards behavior differ
-    const bool split_edge = in_forward_direction && in_backward_direction &&
-                            ((parsed_way.forward_rate != parsed_way.backward_rate) ||
-                             (parsed_way.forward_speed != parsed_way.backward_speed) ||
-                             (parsed_way.forward_travel_mode != parsed_way.backward_travel_mode) ||
-                             (turn_lane_id_forward != turn_lane_id_backward));
+    const bool split_edge =
+        in_forward_direction && in_backward_direction &&
+        (force_split_edges || (parsed_way.forward_rate != parsed_way.backward_rate) ||
+         (parsed_way.forward_speed != parsed_way.backward_speed) ||
+         (parsed_way.forward_travel_mode != parsed_way.backward_travel_mode) ||
+         (turn_lane_id_forward != turn_lane_id_backward));

    if (in_forward_direction)
-    {
+    { // add (forward) segments or (forward,backward) for non-split edges in backward direction
        util::for_each_pair(
            nodes.cbegin(),
            nodes.cend(),
@@ -355,8 +358,8 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, const Extracti
            });
    }

-    if (in_backward_direction || split_edge)
-    {
+    if (in_backward_direction && (!in_forward_direction || split_edge))
+    { // add (backward) segments for split edges or not in forward direction
        util::for_each_pair(
            nodes.cbegin(),
            nodes.cend(),
@@ -247,7 +247,9 @@ void Sol2ScriptingEnvironment::InitContext(LuaScriptingContext &context)
        "weight_name",
        sol::property(&ProfileProperties::SetWeightName, &ProfileProperties::GetWeightName),
        "max_turn_weight",
-        sol::property(&ProfileProperties::GetMaxTurnWeight));
+        sol::property(&ProfileProperties::GetMaxTurnWeight),
+        "force_split_edges",
+        &ProfileProperties::force_split_edges);

    context.state.new_usertype<std::vector<std::string>>(
        "vector",
@@ -330,12 +332,6 @@ void Sol2ScriptingEnvironment::InitContext(LuaScriptingContext &context)
        sol::property(&ExtractionWay::GetTurnLanesForward, &ExtractionWay::SetTurnLanesForward),
        "turn_lanes_backward",
        sol::property(&ExtractionWay::GetTurnLanesBackward, &ExtractionWay::SetTurnLanesBackward),
-        "roundabout",
-        &ExtractionWay::roundabout,
-        "circular",
-        &ExtractionWay::circular,
-        "is_startpoint",
-        &ExtractionWay::is_startpoint,
        "duration",
        &ExtractionWay::duration,
        "weight",
@@ -343,13 +339,26 @@ void Sol2ScriptingEnvironment::InitContext(LuaScriptingContext &context)
        "road_classification",
        &ExtractionWay::road_classification,
        "forward_mode",
-        sol::property(&ExtractionWay::get_forward_mode, &ExtractionWay::set_forward_mode),
+        sol::property([](const ExtractionWay &way) { return way.forward_travel_mode; },
+                      [](ExtractionWay &way, TravelMode mode) { way.forward_travel_mode = mode; }),
        "backward_mode",
-        sol::property(&ExtractionWay::get_backward_mode, &ExtractionWay::set_backward_mode),
+        sol::property([](const ExtractionWay &way) { return way.backward_travel_mode; },
+                      [](ExtractionWay &way, TravelMode mode) { way.backward_travel_mode = mode; }),
+        "roundabout",
+        sol::property([](const ExtractionWay &way) { return way.roundabout; },
+                      [](ExtractionWay &way, bool flag) { way.roundabout = flag; }),
+        "circular",
+        sol::property([](const ExtractionWay &way) { return way.circular; },
+                      [](ExtractionWay &way, bool flag) { way.circular = flag; }),
+        "is_startpoint",
+        sol::property([](const ExtractionWay &way) { return way.is_startpoint; },
+                      [](ExtractionWay &way, bool flag) { way.is_startpoint = flag; }),
        "forward_restricted",
-        &ExtractionWay::forward_restricted,
+        sol::property([](const ExtractionWay &way) { return way.forward_restricted; },
+                      [](ExtractionWay &way, bool flag) { way.forward_restricted = flag; }),
        "backward_restricted",
-        &ExtractionWay::backward_restricted);
+        sol::property([](const ExtractionWay &way) { return way.backward_restricted; },
+                      [](ExtractionWay &way, bool flag) { way.backward_restricted = flag; }));

    context.state.new_usertype<ExtractionSegment>("ExtractionSegment",
                                                  "source",
@@ -7,12 +7,14 @@ message(STATUS "Building node-osrm")
 set(BINDING_DIR "${PROJECT_SOURCE_DIR}/lib/binding")

 list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/nodejs")
-include(FindNodeJS)

 set(NodeJS_CXX_STANDARD 14 CACHE INTERNAL "Use C++14" FORCE)
 set(NodeJS_DOWNLOAD ON CACHE INTERNAL "Download node.js sources" FORCE)
 set(NodeJS_USE_CLANG_STDLIB OFF CACHE BOOL "Don't use libc++ by default" FORCE)

+# ^ Make sure to set NodeJs options before including and requiring the NodeJs module.
+# Otherwise the module will use defaults (which - among many bad choices - means libc++).
+include(FindNodeJS)
 find_package(NodeJS REQUIRED)
 add_nodejs_module(node-osrm node_osrm.cpp)
 target_link_libraries(node-osrm osrm)
@@ -16,6 +16,7 @@
 #include "storage/serialization.hpp"
 #include "storage/shared_datatype.hpp"
 #include "storage/shared_memory.hpp"
+#include "storage/shared_memory_ownership.hpp"
 #include "storage/shared_monitor.hpp"
 #include "engine/datafacade/datafacade_base.hpp"
 #include "util/coordinate.hpp"
@@ -55,8 +56,9 @@ namespace storage
 {

 using RTreeLeaf = engine::datafacade::BaseDataFacade::RTreeLeaf;
-using RTreeNode =
-    util::StaticRTree<RTreeLeaf, util::ShM<util::Coordinate, true>::vector, true>::TreeNode;
+using RTreeNode = util::StaticRTree<RTreeLeaf,
+                                    util::vector_view<util::Coordinate>,
+                                    storage::Ownership::View>::TreeNode;
 using QueryGraph = util::StaticGraph<contractor::QueryEdge::EdgeData>;
 using EdgeBasedGraph = util::StaticGraph<extractor::EdgeBasedEdge::EdgeData>;

@@ -364,12 +366,13 @@ void Storage::PopulateLayout(DataLayout &layout)
        intersection_file.Skip<std::uint32_t>(1); // sum_lengths

        layout.SetBlockSize<unsigned>(DataLayout::BEARING_OFFSETS, bearing_blocks);
-        layout.SetBlockSize<typename util::RangeTable<16, true>::BlockT>(DataLayout::BEARING_BLOCKS,
-                                                                         bearing_blocks);
+        layout.SetBlockSize<typename util::RangeTable<16, storage::Ownership::View>::BlockT>(
+            DataLayout::BEARING_BLOCKS, bearing_blocks);

        // No need to read the data
        intersection_file.Skip<unsigned>(bearing_blocks);
-        intersection_file.Skip<typename util::RangeTable<16, true>::BlockT>(bearing_blocks);
+        intersection_file.Skip<typename util::RangeTable<16, storage::Ownership::View>::BlockT>(
+            bearing_blocks);

        const auto num_bearings = intersection_file.ReadElementCount64();

@@ -694,7 +697,7 @@ void Storage::PopulateData(const DataLayout &layout, char *memory_ptr)
            layout.GetBlockPtr<util::Coordinate, true>(memory_ptr, DataLayout::COORDINATE_LIST);
        const auto osmnodeid_ptr =
            layout.GetBlockPtr<std::uint64_t, true>(memory_ptr, DataLayout::OSM_NODE_ID_LIST);
-        util::PackedVector<OSMNodeID, true> osmnodeid_list;
+        util::PackedVector<OSMNodeID, storage::Ownership::View> osmnodeid_list;

        osmnodeid_list.reset(osmnodeid_ptr, layout.num_entries[DataLayout::OSM_NODE_ID_LIST]);

@@ -803,8 +806,8 @@ void Storage::PopulateData(const DataLayout &layout, char *memory_ptr)
        intersection_file.Skip<std::uint32_t>(1); // sum_lengths

        std::vector<unsigned> bearing_offsets_data(bearing_blocks);
-        std::vector<typename util::RangeTable<16, true>::BlockT> bearing_blocks_data(
-            bearing_blocks);
+        std::vector<typename util::RangeTable<16, storage::Ownership::View>::BlockT>
+            bearing_blocks_data(bearing_blocks);

        intersection_file.ReadInto(bearing_offsets_data.data(), bearing_blocks);
        intersection_file.ReadInto(bearing_blocks_data.data(), bearing_blocks);
@@ -844,8 +847,8 @@ void Storage::PopulateData(const DataLayout &layout, char *memory_ptr)
        if (layout.GetBlockSize(DataLayout::BEARING_BLOCKS) > 0)
        {
            const auto bearing_blocks_ptr =
-                layout.GetBlockPtr<typename util::RangeTable<16, true>::BlockT, true>(
-                    memory_ptr, DataLayout::BEARING_BLOCKS);
+                layout.GetBlockPtr<typename util::RangeTable<16, storage::Ownership::View>::BlockT,
+                                   true>(memory_ptr, DataLayout::BEARING_BLOCKS);
            BOOST_ASSERT(
                static_cast<std::size_t>(layout.GetBlockSize(DataLayout::BEARING_BLOCKS)) >=
                std::distance(bearing_blocks_data.begin(), bearing_blocks_data.end()) *
@@ -14,7 +14,7 @@

 using namespace osrm;

-void removeLocks() { osrm::storage::SharedMonitor<osrm::storage::SharedDataTimestamp>::remove(); }
+void removeLocks() { storage::SharedMonitor<storage::SharedDataTimestamp>::remove(); }

 void deleteRegion(const storage::SharedDataType region)
 {
@@ -81,7 +81,7 @@ void checkWeightsConsistency(
    const UpdaterConfig &config,
    const std::vector<osrm::extractor::EdgeBasedEdge> &edge_based_edge_list)
 {
-    using Reader = osrm::storage::io::FileReader;
+    using Reader = storage::io::FileReader;
    using OriginalEdgeData = osrm::extractor::OriginalEdgeData;

    extractor::SegmentDataContainer segment_data;
@@ -0,0 +1,26 @@
+var path = require('path');
+
+// Constants and fixtures for nodejs tests on our Monaco dataset.
+
+// Somewhere in Monaco
+// http://www.openstreetmap.org/#map=18/43.73185/7.41772
+exports.three_test_coordinates = [[7.41337, 43.72956],
+                                  [7.41546, 43.73077],
+                                  [7.41862, 43.73216]];
+
+exports.two_test_coordinates = exports.three_test_coordinates.slice(0, 2)
+
+exports.test_tile = {'at': [17059, 11948, 15], 'size': 114000};
+
+
+// Test files generated by the routing engine; check test/data
+if (process.env.OSRM_DATA_PATH !== undefined) {
+    exports.data_path = path.join(path.resolve(process.env.OSRM_DATA_PATH), "ch/monaco.osrm");
+    exports.mld_data_path = path.join(path.resolve(process.env.OSRM_DATA_PATH), "mld/monaco.osrm");
+    exports.corech_data_path = path.join(path.resolve(process.env.OSRM_DATA_PATH), "corech/monaco.osrm");
+    console.log('Setting custom data path to ' + exports.data_path);
+} else {
+    exports.data_path = path.resolve(path.join(__dirname, "../data/ch/monaco.osrm"));
+    exports.mld_data_path = path.resolve(path.join(__dirname, "../data/mld/monaco.osrm"));
+    exports.corech_data_path = path.resolve(path.join(__dirname, "../data/corech/monaco.osrm"));
+}
@@ -1,8 +1,8 @@
 var OSRM = require('../../');
 var test = require('tape');
-var berlin_path = require('./osrm-data-path').data_path;
-var berlin_mld_path = require('./osrm-data-path').mld_data_path;
-var berlin_corech_path = require('./osrm-data-path').corech_data_path;
+var monaco_path = require('./constants').data_path;
+var monaco_mld_path = require('./constants').mld_data_path;
+var monaco_corech_path = require('./constants').corech_data_path;

 test('constructor: throws if new keyword is not used', function(assert) {
    assert.plan(1);
@@ -30,7 +30,7 @@ test('constructor: throws if necessary files do not exist', function(assert) {

 test('constructor: takes a shared memory argument', function(assert) {
    assert.plan(1);
-    var osrm = new OSRM({path: berlin_path, shared_memory: false});
+    var osrm = new OSRM({path: monaco_path, shared_memory: false});
    assert.ok(osrm);
 });

@@ -42,7 +42,7 @@ test('constructor: throws if shared_memory==false with no path defined', functio

 test('constructor: throws if given a non-bool shared_memory option', function(assert) {
    assert.plan(1);
-    assert.throws(function() { new OSRM({path: berlin_path, shared_memory: 'a'}); },
+    assert.throws(function() { new OSRM({path: monaco_path, shared_memory: 'a'}); },
        /Shared_memory option must be a boolean/);
 });

@@ -66,19 +66,19 @@ test('constructor: throws if given an invalid algorithm', function(assert) {

 test('constructor: loads MLD if given as algorithm', function(assert) {
    assert.plan(1);
-    var osrm = new OSRM({algorithm: 'MLD', path: berlin_mld_path});
+    var osrm = new OSRM({algorithm: 'MLD', path: monaco_mld_path});
    assert.ok(osrm);
 });

 test('constructor: loads CH if given as algorithm', function(assert) {
    assert.plan(1);
-    var osrm = new OSRM({algorithm: 'CH', path: berlin_path});
+    var osrm = new OSRM({algorithm: 'CH', path: monaco_path});
    assert.ok(osrm);
 });

 test('constructor: loads CoreCH if given as algorithm', function(assert) {
    assert.plan(1);
-    var osrm = new OSRM({algorithm: 'CoreCH', path: berlin_corech_path});
+    var osrm = new OSRM({algorithm: 'CoreCH', path: monaco_corech_path});
    assert.ok(osrm);
 });

@@ -1,12 +1,14 @@
 var OSRM = require('../../');
 var test = require('tape');
-var berlin_path = require('./osrm-data-path').data_path;
+var data_path = require('./constants').data_path;
+var three_test_coordinates = require('./constants').three_test_coordinates;
+var two_test_coordinates = require('./constants').two_test_coordinates;

-test('match: match in Berlin', function(assert) {
+test('match: match in Monaco', function(assert) {
    assert.plan(5);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
    var options = {
-        coordinates: [[13.393252,52.542648],[13.39478,52.543079],[13.397389,52.542107]],
+        coordinates: three_test_coordinates,
        timestamps: [1424684612, 1424684616, 1424684620]
    };
    osrm.match(options, function(err, response) {
@@ -22,11 +24,11 @@ test('match: match in Berlin', function(assert) {
    });
 });

-test('match: match in Berlin without timestamps', function(assert) {
+test('match: match in Monaco without timestamps', function(assert) {
    assert.plan(3);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
    var options = {
-        coordinates: [[13.393252,52.542648],[13.39478,52.543079],[13.397389,52.542107]]
+        coordinates: three_test_coordinates
    };
    osrm.match(options, function(err, response) {
        assert.ifError(err);
@@ -35,11 +37,11 @@ test('match: match in Berlin without timestamps', function(assert) {
    });
 });

-test('match: match in Berlin without geometry compression', function(assert) {
+test('match: match in Monaco without geometry compression', function(assert) {
    assert.plan(4);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
    var options = {
-        coordinates: [[13.393252,52.542648],[13.39478,52.543079],[13.397389,52.542107]],
+        coordinates: three_test_coordinates,
        geometries: 'geojson'
    };
    osrm.match(options, function(err, response) {
@@ -50,11 +52,11 @@ test('match: match in Berlin without geometry compression', function(assert) {
    });
 });

-test('match: match in Berlin with geometry compression', function(assert) {
+test('match: match in Monaco with geometry compression', function(assert) {
    assert.plan(3);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
    var options = {
-        coordinates: [[13.393252,52.542648],[13.39478,52.543079],[13.397389,52.542107]]
+        coordinates: three_test_coordinates,
    };
    osrm.match(options, function(err, response) {
        assert.ifError(err);
@@ -63,11 +65,11 @@ test('match: match in Berlin with geometry compression', function(assert) {
    });
 });

-test('match: match in Berlin with speed annotations options', function(assert) {
+test('match: match in Monaco with speed annotations options', function(assert) {
    assert.plan(12);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
    var options = {
-        coordinates: [[13.393252,52.542648],[13.39478,52.543079],[13.397389,52.542107]],
+        coordinates: three_test_coordinates,
        timestamps: [1424684612, 1424684616, 1424684620],
        radiuses: [4.07, 4.07, 4.07],
        steps: true,
@@ -92,11 +94,12 @@ test('match: match in Berlin with speed annotations options', function(assert) {
 });


-test('match: match in Berlin with several (duration, distance, nodes) annotations options', function(assert) {
+test('match: match in Monaco with several (duration, distance, nodes) annotations options', function(assert) {
    assert.plan(12);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
    var options = {
-        coordinates: [[13.393252,52.542648],[13.39478,52.543079],[13.397389,52.542107]],
+        timestamps: [1424684612, 1424684616, 1424684620],
+        coordinates: three_test_coordinates,
        timestamps: [1424684612, 1424684616, 1424684620],
        radiuses: [4.07, 4.07, 4.07],
        steps: true,
@@ -120,11 +123,11 @@ test('match: match in Berlin with several (duration, distance, nodes) annotation
    });
 });

-test('match: match in Berlin with all options', function(assert) {
+test('match: match in Monaco with all options', function(assert) {
    assert.plan(8);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
    var options = {
-        coordinates: [[13.393252,52.542648],[13.39478,52.543079],[13.397389,52.542107]],
+        coordinates: three_test_coordinates,
        timestamps: [1424684612, 1424684616, 1424684620],
        radiuses: [4.07, 4.07, 4.07],
        steps: true,
@@ -146,42 +149,42 @@ test('match: match in Berlin with all options', function(assert) {

 test('match: throws on missing arguments', function(assert) {
    assert.plan(1);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
    assert.throws(function() { osrm.match({}) },
        /Two arguments required/);
 });

 test('match: throws on non-object arg', function(assert) {
    assert.plan(1);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
    assert.throws(function() { osrm.match(null, function(err, response) {}) },
        /First arg must be an object/);
 });

 test('match: throws on invalid coordinates param', function(assert) {
    assert.plan(4);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
    var options = {
        coordinates: ''
    };
    assert.throws(function() { osrm.match(options, function(err, response) {}) },
        /Coordinates must be an array of \(lon\/lat\) pairs/);
-    options.coordinates = [[13.393252,52.542648]];
+    options.coordinates = [three_test_coordinates[0]];
    assert.throws(function() { osrm.match(options, function(err, response) {}) },
        /At least two coordinates must be provided/);
-    options.coordinates = [13.393252,52.542648];
+    options.coordinates = three_test_coordinates[0]
    assert.throws(function() { osrm.match(options, function(err, response) {}) },
        /Coordinates must be an array of \(lon\/lat\) pairs/);
-    options.coordinates = [[13.393252],[52.542648]];
+    options.coordinates = [three_test_coordinates[0][0], three_test_coordinates[0][1]];
    assert.throws(function() { osrm.match(options, function(err, response) {}) },
        /Coordinates must be an array of \(lon\/lat\) pairs/);
 });

 test('match: throws on invalid timestamps param', function(assert) {
    assert.plan(3);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
    var options = {
-        coordinates: [[13.393252,52.542648],[13.39478,52.543079],[13.397389,52.542107]],
+        coordinates: three_test_coordinates,
        timestamps: 'timestamps'
    };
    assert.throws(function() { osrm.match(options, function(err, response) {}) },
@@ -1,12 +1,15 @@
 var OSRM = require('../../');
 var test = require('tape');
-var berlin_path = require('./osrm-data-path').data_path;
+var data_path = require('./constants').data_path;
+var three_test_coordinates = require('./constants').three_test_coordinates;
+var two_test_coordinates = require('./constants').two_test_coordinates;
+

 test('nearest', function(assert) {
    assert.plan(4);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
    osrm.nearest({
-        coordinates: [[13.333086, 52.4224]]
+        coordinates: [three_test_coordinates[0]]
    }, function(err, result) {
        assert.ifError(err);
        assert.equal(result.waypoints.length, 1);
@@ -17,9 +20,9 @@ test('nearest', function(assert) {

 test('nearest: can ask for multiple nearest pts', function(assert) {
    assert.plan(2);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
    osrm.nearest({
-        coordinates: [[13.333086, 52.4224]],
+        coordinates: [three_test_coordinates[0]],
        number: 3
    }, function(err, result) {
        assert.ifError(err);
@@ -29,19 +32,19 @@ test('nearest: can ask for multiple nearest pts', function(assert) {

 test('nearest: throws on invalid args', function(assert) {
    assert.plan(6);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
    var options = {};
    assert.throws(function() { osrm.nearest(options); },
        /Two arguments required/);
    assert.throws(function() { osrm.nearest(null, function(err, res) {}); },
        /First arg must be an object/);
-    options.coordinates = [52.4224];
+    options.coordinates = [43.73072];
    assert.throws(function() { osrm.nearest(options, function(err, res) {}); },
        /Coordinates must be an array of /);
-    options.coordinates = [[13.333086, 52.4224],[13.333086, 52.5224]];
+    options.coordinates = [three_test_coordinates[0], three_test_coordinates[1]];
    assert.throws(function() { osrm.nearest(options, function(err, res) {}); },
        /Exactly one coordinate pair must be provided/);
-    options.coordinates = [[13.333086, 52.4224]];
+    options.coordinates = [three_test_coordinates[0]];
    options.number = 3.14159;
    assert.throws(function() { osrm.nearest(options, function(err, res) {}); },
        /Number must be an integer greater than or equal to 1/);
@@ -1,12 +0,0 @@
-var path = require('path');
-
-if (process.env.OSRM_DATA_PATH !== undefined) {
-    exports.data_path = path.join(path.resolve(process.env.OSRM_DATA_PATH), "ch/berlin.osrm");
-    exports.mld_data_path = path.join(path.resolve(process.env.OSRM_DATA_PATH), "mld/berlin.osrm");
-    exports.corech_data_path = path.join(path.resolve(process.env.OSRM_DATA_PATH), "corech/berlin.osrm");
-    console.log('Setting custom data path to ' + exports.data_path);
-} else {
-    exports.data_path = path.resolve(path.join(__dirname, "../data/ch/berlin.osrm"));
-    exports.mld_data_path = path.resolve(path.join(__dirname, "../data/mld/berlin.osrm"));
-    exports.corech_data_path = path.resolve(path.join(__dirname, "../data/corech/berlin.osrm"));
-}
@@ -1,12 +1,27 @@
 var OSRM = require('../../');
 var test = require('tape');
-var berlin_path = require('./osrm-data-path').data_path;
-var berlin_mld_path = require('./osrm-data-path').mld_data_path;
-var berlin_corech_path = require('./osrm-data-path').corech_data_path;
+var monaco_path = require('./constants').data_path;
+var monaco_mld_path = require('./constants').mld_data_path;
+var monaco_corech_path = require('./constants').corech_data_path;
+var three_test_coordinates = require('./constants').three_test_coordinates;
+var two_test_coordinates = require('./constants').two_test_coordinates;

-test('route: routes Berlin', function(assert) {
+
+test('route: routes Monaco', function(assert) {
    assert.plan(5);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(monaco_path);
+    osrm.route({coordinates: two_test_coordinates}, function(err, route) {
+        assert.ifError(err);
+        assert.ok(route.waypoints);
+        assert.ok(route.routes);
+        assert.ok(route.routes.length);
+        assert.ok(route.routes[0].geometry);
+    });
+});
+
+test('route: routes Monaco on MLD', function(assert) {
+    assert.plan(5);
+    var osrm = new OSRM({path: monaco_mld_path, algorithm: 'MLD'});
    osrm.route({coordinates: [[13.43864,52.51993],[13.415852,52.513191]]}, function(err, route) {
        assert.ifError(err);
        assert.ok(route.waypoints);
@@ -16,21 +31,9 @@ test('route: routes Berlin', function(assert) {
    });
 });

-test('route: routes Berlin on MLD', function(assert) {
+test('route: routes Monaco on CoreCH', function(assert) {
    assert.plan(5);
-    var osrm = new OSRM({path: berlin_mld_path, algorithm: 'MLD'});
-    osrm.route({coordinates: [[13.43864,52.51993],[13.415852,52.513191]]}, function(err, route) {
-        assert.ifError(err);
-        assert.ok(route.waypoints);
-        assert.ok(route.routes);
-        assert.ok(route.routes.length);
-        assert.ok(route.routes[0].geometry);
-    });
-});
-
-test('route: routes Berlin on CoreCH', function(assert) {
-    assert.plan(5);
-    var osrm = new OSRM({path: berlin_corech_path, algorithm: 'CoreCH'});
+    var osrm = new OSRM({path: monaco_corech_path, algorithm: 'CoreCH'});
    osrm.route({coordinates: [[13.43864,52.51993],[13.415852,52.513191]]}, function(err, route) {
        assert.ifError(err);
        assert.ok(route.waypoints);
@@ -42,19 +45,19 @@ test('route: routes Berlin on CoreCH', function(assert) {

 test('route: throws with too few or invalid args', function(assert) {
    assert.plan(3);
-    var osrm = new OSRM(berlin_path);
-    assert.throws(function() { osrm.route({coordinates: [[13.43864,52.51993],[13.415852,52.513191]]}) },
+    var osrm = new OSRM(monaco_path);
+    assert.throws(function() { osrm.route({coordinates: two_test_coordinates}) },
        /Two arguments required/);
    assert.throws(function() { osrm.route(null, function(err, route) {}) },
        /First arg must be an object/);
-    assert.throws(function() { osrm.route({coordinates: [[13.43864,52.51993],[13.415852,52.513191]]}, true)},
+    assert.throws(function() { osrm.route({coordinates: two_test_coordinates}, true)},
        /last argument must be a callback function/);
 });

-test('route: provides no alternatives by default, but when requested', function(assert) {
+test('route: provides no alternatives by default, but when requested it may (not guaranteed)', function(assert) {
    assert.plan(6);
-    var osrm = new OSRM(berlin_path);
-    var options = {coordinates: [[13.302383,52.490516], [13.418427,52.522070]]};
+    var osrm = new OSRM(monaco_path);
+    var options = {coordinates: two_test_coordinates};

    osrm.route(options, function(err, route) {
        assert.ifError(err);
@@ -65,53 +68,53 @@ test('route: provides no alternatives by default, but when requested', function(
    osrm.route(options, function(err, route) {
        assert.ifError(err);
        assert.ok(route.routes);
-        assert.equal(route.routes.length, 2);
+        assert.ok(route.routes.length >= 1);
    });
 });

 test('route: throws with bad params', function(assert) {
    assert.plan(11);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(monaco_path);
    assert.throws(function () { osrm.route({coordinates: []}, function(err) {}) });
    assert.throws(function() { osrm.route({}, function(err, route) {}) },
        /Must provide a coordinates property/);
    assert.throws(function() { osrm.route({coordinates: null}, function(err, route) {}) },
        /Coordinates must be an array of \(lon\/lat\) pairs/);
-    assert.throws(function() { osrm.route({coordinates: [13.438640, 52.519930]}, function(err, route) {}) },
+    assert.throws(function() { osrm.route({coordinates: [[three_test_coordinates[0]], [three_test_coordinates[1]]]}, function(err, route) {}) },
        /Coordinates must be an array of \(lon\/lat\) pairs/);
-    assert.throws(function() { osrm.route({coordinates: [[true, '52.519930'], [13.438640, 52.519930]]}, function(err, route) {}) },
+    assert.throws(function() { osrm.route({coordinates: [[true, 'stringish'], three_test_coordinates[1]]}, function(err, route) {}) },
        /Each member of a coordinate pair must be a number/);
    assert.throws(function() { osrm.route({coordinates: [[213.43864,252.51993],[413.415852,552.513191]]}, function(err, route) {}) },
        /Lng\/Lat coordinates must be within world bounds \(-180 < lng < 180, -90 < lat < 90\)/);
    assert.throws(function() { osrm.route({coordinates: [[13.438640], [52.519930]]}, function(err, route) {}) },
        /Coordinates must be an array of \(lon\/lat\) pairs/);
-    assert.throws(function() { osrm.route({coordinates: [[13.43864,52.51993],[13.415852,52.513191]], hints: null}, function(err, route) {}) },
+    assert.throws(function() { osrm.route({coordinates: two_test_coordinates, hints: null}, function(err, route) {}) },
        /Hints must be an array of strings\/null/);
-    assert.throws(function() { osrm.route({coordinates: [[13.43864,52.51993],[13.415852,52.513191]], steps: null}, function(err, route) {}) });
-    assert.throws(function() { osrm.route({coordinates: [[13.43864,52.51993],[13.415852,52.513191]], annotations: null}, function(err, route) {}) });
+    assert.throws(function() { osrm.route({coordinates: two_test_coordinates, steps: null}, function(err, route) {}) });
+    assert.throws(function() { osrm.route({coordinates: two_test_coordinates, annotations: null}, function(err, route) {}) });
    var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
        alternateRoute: false,
-        hints: [13.438640, 52.519930]
+        hints: three_test_coordinates[0]
    };
    assert.throws(function() { osrm.route(options, function(err, route) {}) },
        /Hint must be null or string/);
 });

-test('route: routes Berlin using shared memory', function(assert) {
+test('route: routes Monaco using shared memory', function(assert) {
    assert.plan(2);
    var osrm = new OSRM();
-    osrm.route({coordinates: [[13.43864,52.51993],[13.415852,52.513191]]}, function(err, route) {
+    osrm.route({coordinates: two_test_coordinates}, function(err, route) {
        assert.ifError(err);
        assert.ok(Array.isArray(route.routes));
    });
 });

-test('route: routes Berlin with geometry compression', function(assert) {
+test('route: routes Monaco with geometry compression', function(assert) {
    assert.plan(2);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(monaco_path);
    var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
    };
    osrm.route(options, function(err, route) {
        assert.ifError(err);
@@ -119,11 +122,11 @@ test('route: routes Berlin with geometry compression', function(assert) {
    });
 });

-test('route: routes Berlin without geometry compression', function(assert) {
+test('route: routes Monaco without geometry compression', function(assert) {
    assert.plan(4);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(monaco_path);
    var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
        geometries: 'geojson'
    };
    osrm.route(options, function(err, route) {
@@ -136,9 +139,9 @@ test('route: routes Berlin without geometry compression', function(assert) {

 test('Test polyline6 geometries option', function(assert) {
    assert.plan(6);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(monaco_path);
    var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
        continue_straight: false,
        overview: 'false',
        geometries: 'polyline6',
@@ -154,11 +157,11 @@ test('Test polyline6 geometries option', function(assert) {
    });
 });

-test('route: routes Berlin with speed annotations options', function(assert) {
+test('route: routes Monaco with speed annotations options', function(assert) {
    assert.plan(17);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(monaco_path);
    var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
        continue_straight: false,
        overview: 'false',
        geometries: 'polyline',
@@ -193,16 +196,16 @@ test('route: routes Berlin with speed annotations options', function(assert) {
    });
 });

-test('route: routes Berlin with several (duration, distance, nodes) annotations options', function(assert) {
+test('route: routes Monaco with several (duration, distance, nodes) annotations options', function(assert) {
    assert.plan(17);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(monaco_path);
    var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
        continue_straight: false,
        overview: 'false',
        geometries: 'polyline',
        steps: true,
-        annotations: ['duration','distance','nodes']
+        annotations: ['duration', 'distance', 'nodes']
    };
    osrm.route(options, function(err, first) {
        assert.ifError(err);
@@ -232,11 +235,11 @@ test('route: routes Berlin with several (duration, distance, nodes) annotations
    });
 });

-test('route: routes Berlin with options', function(assert) {
+test('route: routes Monaco with options', function(assert) {
    assert.plan(11);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(monaco_path);
    var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
        continue_straight: false,
        overview: 'false',
        geometries: 'polyline',
@@ -265,11 +268,11 @@ test('route: routes Berlin with options', function(assert) {
    });
 });

-test('route: routes Berlin with options', function(assert) {
+test('route: routes Monaco with options', function(assert) {
    assert.plan(11);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(monaco_path);
    var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
        continue_straight: false,
        overview: 'false',
        geometries: 'polyline',
@@ -300,39 +303,39 @@ test('route: routes Berlin with options', function(assert) {

 test('route: invalid route options', function(assert) {
    assert.plan(8);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(monaco_path);
    assert.throws(function() { osrm.route({
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
        continue_straight: []
    }, function(err, route) {}); },
        /must be boolean/);
    assert.throws(function() { osrm.route({
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
        alternatives: []
    }, function(err, route) {}); },
        /must be boolean/);
    assert.throws(function() { osrm.route({
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
        geometries: true
    }, function(err, route) {}); },
        /Geometries must be a string: \[polyline, polyline6, geojson\]/);
    assert.throws(function() { osrm.route({
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
        overview: false
    }, function(err, route) {}); },
        /Overview must be a string: \[simplified, full, false\]/);
    assert.throws(function() { osrm.route({
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
        overview: false
    }, function(err, route) {}); },
        /Overview must be a string: \[simplified, full, false\]/);
    assert.throws(function() { osrm.route({
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
        overview: 'maybe'
    }, function(err, route) {}); },
        /'overview' param must be one of \[simplified, full, false\]/);
    assert.throws(function() { osrm.route({
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
        geometries: 'maybe'
    }, function(err, route) {}); },
        /'geometries' param must be one of \[polyline, polyline6, geojson\]/);
@@ -344,9 +347,9 @@ test('route: invalid route options', function(assert) {

 test('route: integer bearing values no longer supported', function(assert) {
    assert.plan(1);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(monaco_path);
    var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
        bearings: [200, 250],
    };
    assert.throws(function() { osrm.route(options, function(err, route) {}); },
@@ -355,9 +358,9 @@ test('route: integer bearing values no longer supported', function(assert) {

 test('route: valid bearing values', function(assert) {
    assert.plan(4);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(monaco_path);
    var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
        bearings: [[200, 180], [250, 180]],
    };
    osrm.route(options, function(err, route) {
@@ -373,44 +376,44 @@ test('route: valid bearing values', function(assert) {

 test('route: invalid bearing values', function(assert) {
    assert.plan(6);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(monaco_path);
    assert.throws(function() { osrm.route({
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
        bearings: [[400, 180], [-250, 180]],
    }, function(err, route) {}) },
        /Bearing values need to be in range 0..360, 0..180/);
    assert.throws(function() { osrm.route({
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
        bearings: [[200], [250, 180]],
    }, function(err, route) {}) },
        /Bearing must be an array of/);
    assert.throws(function() { osrm.route({
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
        bearings: [[400, 109], [100, 720]],
    }, function(err, route) {}) },
        /Bearing values need to be in range 0..360, 0..180/);
    assert.throws(function() { osrm.route({
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
        bearings: 400,
    }, function(err, route) {}) },
        /Bearings must be an array of arrays of numbers/);
    assert.throws(function() { osrm.route({
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
        bearings: [[100, 100]],
    }, function(err, route) {}) },
        /Bearings array must have the same length as coordinates array/);
    assert.throws(function() { osrm.route({
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
        bearings: [Infinity, Infinity],
    }, function(err, route) {}) },
        /Bearing must be an array of \[bearing, range\] or null/);
 });

-test('route: routes Berlin with hints', function(assert) {
+test('route: routes Monaco with hints', function(assert) {
    assert.plan(5);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(monaco_path);
    var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]]
+        coordinates: two_test_coordinates,
    };
    osrm.route(options, function(err, first) {
        assert.ifError(err);
@@ -427,11 +430,11 @@ test('route: routes Berlin with hints', function(assert) {
    });
 });

-test('route: routes Berlin with null hints', function(assert) {
+test('route: routes Monaco with null hints', function(assert) {
    assert.plan(1);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(monaco_path);
    var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
        hints: [null, null]
    };
    osrm.route(options, function(err, route) {
@@ -441,22 +444,22 @@ test('route: routes Berlin with null hints', function(assert) {

 test('route: throws on bad hints', function(assert) {
    assert.plan(2);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(monaco_path);
    assert.throws(function() { osrm.route({
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
        hints: ['', '']
    }, function(err, route) {})}, /Hint cannot be an empty string/);
    assert.throws(function() { osrm.route({
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
        hints: [null]
    }, function(err, route) {})}, /Hints array must have the same length as coordinates array/);
 });

-test('route: routes Berlin with valid radius values', function(assert) {
+test('route: routes Monaco with valid radius values', function(assert) {
    assert.plan(3);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(monaco_path);
    var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
        radiuses: [100, 100]
    };
    osrm.route(options, function(err, route) {
@@ -474,23 +477,23 @@ test('route: routes Berlin with valid radius values', function(assert) {

 test('route: throws on bad radiuses', function(assert) {
    assert.plan(3);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(monaco_path);
    var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
        radiuses: [10, 10]
    };
    assert.throws(function() { osrm.route({
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
        radiuses: 10
    }, function(err, route) {}) },
        /Radiuses must be an array of non-negative doubles or null/);
    assert.throws(function() { osrm.route({
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
        radiuses: ['magic', 'numbers']
    }, function(err, route) {}) },
        /Radius must be non-negative double or null/);
    assert.throws(function() { osrm.route({
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
        radiuses: [10]
    }, function(err, route) {}) },
        /Radiuses array must have the same length as coordinates array/);
@@ -1,12 +1,15 @@
 var OSRM = require('../../');
 var test = require('tape');
-var berlin_path = require('./osrm-data-path').data_path;
+var data_path = require('./constants').data_path;
+var three_test_coordinates = require('./constants').three_test_coordinates;
+var two_test_coordinates = require('./constants').two_test_coordinates;

-test('table: distance table in Berlin', function(assert) {
-    assert.plan(9);
-    var osrm = new OSRM(berlin_path);
+
+test('table: distance table in Monaco', function(assert) {
+    assert.plan(11);
+    var osrm = new OSRM(data_path);
    var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]]
+        coordinates: [three_test_coordinates[0], three_test_coordinates[1]]
    };
    osrm.table(options, function(err, table) {
        assert.ifError(err);
@@ -23,6 +26,8 @@ test('table: distance table in Berlin', function(assert) {
                } else {
                    // everything else is non-zero
                    assert.notEqual(0, column[j], 'other entries must be non-zero');
+                    // and finite (not nan, inf etc.)
+                    assert.ok(Number.isFinite(column[j]), 'distance is finite number');
                }
            }
        }
@@ -30,11 +35,11 @@ test('table: distance table in Berlin', function(assert) {
    });
 });

-test('table: distance table in Berlin with sources/destinations', function(assert) {
-    assert.plan(6);
-    var osrm = new OSRM(berlin_path);
+test('table: distance table in Monaco with sources/destinations', function(assert) {
+    assert.plan(7);
+    var osrm = new OSRM(data_path);
    var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: [three_test_coordinates[0], three_test_coordinates[1]],
        sources: [0],
        destinations: [0,1]
    };
@@ -53,6 +58,8 @@ test('table: distance table in Berlin with sources/destinations', function(asser
                } else {
                    // everything else is non-zero
                    assert.notEqual(0, column[j], 'other entries must be non-zero');
+                    // and finite (not nan, inf etc.)
+                    assert.ok(Number.isFinite(column[j]), 'distance is finite number');
                }
            }
        }
@@ -62,24 +69,24 @@ test('table: distance table in Berlin with sources/destinations', function(asser

 test('table: throws on invalid arguments', function(assert) {
    assert.plan(14);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
    var options = {};
    assert.throws(function() { osrm.table(options); },
        /Two arguments required/);
    options.coordinates = null;
    assert.throws(function() { osrm.table(options, function() {}); },
        /Coordinates must be an array of \(lon\/lat\) pairs/);
-    options.coordinates = [[13.393252,52.542648]];
+    options.coordinates = [three_test_coordinates[0]];
    assert.throws(function() { osrm.table(options, function(err, response) {}) },
        /At least two coordinates must be provided/);
-    options.coordinates = [13.393252,52.542648];
+    options.coordinates = three_test_coordinates[0];
    assert.throws(function() { osrm.table(options, function(err, response) {}) },
        /Coordinates must be an array of \(lon\/lat\) pairs/);
-    options.coordinates = [[13.393252],[52.542648]];
+    options.coordinates = [three_test_coordinates[0][0], three_test_coordinates[0][1]];
    assert.throws(function() { osrm.table(options, function(err, response) {}) },
        /Coordinates must be an array of \(lon\/lat\) pairs/);

-    options.coordinates = [[13.393252,52.542648],[13.393252,52.542648]];
+    options.coordinates = two_test_coordinates;
    options.sources = true;
    assert.throws(function() { osrm.table(options, function(err, response) {}) },
        /Sources must be an array of indices \(or undefined\)/);
@@ -110,22 +117,22 @@ test('table: throws on invalid arguments', function(assert) {
    assert.doesNotThrow(function() { osrm.table(options, function(err, response) {}) },
        /You can either specify sources and destinations, or coordinates/);

-    assert.throws(function() { osrm.route({coordinates: [[13.43864,52.51993],[13.415852,52.513191]], generate_hints: null}, function(err, route) {}) },
+    assert.throws(function() { osrm.route({coordinates: two_test_coordinates, generate_hints: null}, function(err, route) {}) },
        /generate_hints must be of type Boolean/);
 });

 test('table: throws on invalid arguments', function(assert) {
    assert.plan(1);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
    assert.throws(function() { osrm.table(null, function() {}); },
        /First arg must be an object/);
 });

-test('table: distance table in Berlin with hints', function(assert) {
+test('table: distance table in Monaco with hints', function(assert) {
    assert.plan(5);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
    var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
        generate_hints: true  // true is default but be explicit here
    };
    osrm.table(options, function(err, table) {
@@ -141,11 +148,11 @@ test('table: distance table in Berlin with hints', function(assert) {
    });
 });

-test('table: distance table in Berlin without hints', function(assert) {
+test('table: distance table in Monaco without hints', function(assert) {
    assert.plan(5);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
    var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
        generate_hints: false  // true is default
    };
    osrm.table(options, function(err, table) {
@@ -1,23 +1,25 @@
 var OSRM = require('../../');
 var test = require('tape');
-var berlin_path = "test/data/berlin-latest.osrm";
+var data_path = require('./constants').data_path;
+var tile = require('./constants').test_tile;

 test.test('tile check size coarse', function(assert) {
    assert.plan(2);
-    var osrm = new OSRM(berlin_path);
-    osrm.tile([17603, 10747, 15], function(err, result) {
+    var osrm = new OSRM(data_path);
+    osrm.tile(tile.at, function(err, result) {
        assert.ifError(err);
-        assert.ok(result.length > 35000);
+        assert.ok(result.length > tile.size);
    });
 });

-// FIXME the size of the tile that is returned depends on the architecture
-// See issue #3343 in osrm-backend
-test.skip('tile', function(assert) {
-    assert.plan(2);
-    var osrm = new OSRM(berlin_path);
-    osrm.tile([17603, 10747, 15], function(err, result) {
-        assert.ifError(err);
-        assert.equal(result.length, 35970);
-    });
+test.test('tile interface pre-conditions', function(assert) {
+    assert.plan(6);
+    var osrm = new OSRM(data_path);
+
+    assert.throws(function() { osrm.tile(null, function(err, result) {}) }, /must be an array \[x, y, z\]/);
+    assert.throws(function() { osrm.tile([], function(err, result) {}) }, /must be an array \[x, y, z\]/);
+    assert.throws(function() { osrm.tile([[]], function(err, result) {}) }, /must be an array \[x, y, z\]/);
+    assert.throws(function() { osrm.tile(undefined, function(err, result) {}) }, /must be an array \[x, y, z\]/);
+    assert.throws(function() { osrm.tile(17059, 11948, 15, function(err, result) {}) }, /must be an array \[x, y, z\]/);
+    assert.throws(function() { osrm.tile([17059, 11948, -15], function(err, result) {}) }, /must be unsigned/);
 });
@@ -1,11 +1,14 @@
 var OSRM = require('../../');
 var test = require('tape');
-var berlin_path = require('./osrm-data-path').data_path;
+var data_path = require('./constants').data_path;
+var three_test_coordinates = require('./constants').three_test_coordinates;
+var two_test_coordinates = require('./constants').two_test_coordinates;

-test('trip: trip in Berlin', function(assert) {
+
+test('trip: trip in Monaco', function(assert) {
    assert.plan(2);
-    var osrm = new OSRM(berlin_path);
-    osrm.trip({coordinates: [[13.36761474609375,52.51663871100423],[13.374481201171875,52.506191342034576]]}, function(err, trip) {
+    var osrm = new OSRM(data_path);
+    osrm.trip({coordinates: two_test_coordinates}, function(err, trip) {
        assert.ifError(err);
        for (t = 0; t < trip.trips.length; t++) {
            assert.ok(trip.trips[t].geometry);
@@ -13,28 +16,25 @@ test('trip: trip in Berlin', function(assert) {
    });
 });

-test('trip: trip with many locations in Berlin', function(assert) {
-    assert.plan(4);
-    var osrm = new OSRM(berlin_path);
-    var opts = {coordinates: [[13.36761474609375,52.51663871100423],[13.374481201171875,52.506191342034576],[13.404693603515625,52.50535544522142],[13.388900756835938,52.50159371284434],[13.386840820312498,52.518727886767266],[13.4088134765625,52.528754547664185],[13.41156005859375,52.51705655410405],[13.420486450195312,52.512042174642346],[13.413619995117188,52.50368360390624],[13.36212158203125,52.504101570196205],[13.35113525390625,52.52248815280757],[13.36761474609375,52.53460237630516],[13.383407592773438,52.53710835019913],[13.392333984375,52.536690697815736],[13.42529296875,52.532931647583325],[13.399200439453125,52.52415927884915],[13.390960693359375,52.51956352925745],[13.375167846679688,52.533349335723294],[13.37860107421875,52.520399155853454],[13.355255126953125,52.52081696319122],[13.385467529296875,52.5143405029259],[13.398857116699219,52.513086884218325],[13.399200439453125,52.50744515744915],[13.409500122070312,52.49783165855699],[13.424949645996094,52.500339730516934],[13.440055847167969,52.50786308797268],[13.428382873535156,52.511624283857785],[13.437652587890625,52.50451953251202],[13.443145751953125,52.5199813445422],[13.431129455566406,52.52520370034151],[13.418426513671875,52.52896341209634],[13.429069519042969,52.517474393230245],[13.418083190917969,52.528127948407935],[13.405036926269531,52.52833681581998],[13.384437561035156,52.53084314728766],[13.374481201171875,52.53084314728766],[13.3978271484375,52.532305107923925],[13.418769836425781,52.526039219655445],[13.441085815429688,52.51642978796417],[13.448638916015625,52.51601193890388],[13.44623565673828,52.50535544522142],[13.430442810058594,52.502638670794546],[13.358688354492188,52.520190250694526],[13.358001708984375,52.531887409851336],[13.367271423339842,52.528545682238736],[13.387870788574219,52.52958999943304],[13.406410217285156,52.53961418106945],[13.399543762207031,52.50556442091497],[13.374824523925781,52.50389258754797],[13.386154174804688,52.51099744023003],[13.40229034423828,52.49657756892365]]
-};
+test('trip: trip with many locations in Monaco', function(assert) {
+    assert.plan(2);
+
+    var many = 5;
+
+    var osrm = new OSRM(data_path);
+    var opts = {coordinates: three_test_coordinates.slice(0, many)};
    osrm.trip(opts, function(err, trip) {
        assert.ifError(err);
        for (t = 0; t < trip.trips.length; t++) {
            assert.ok(trip.trips[t].geometry);
        }
-        assert.equal(opts.coordinates.length, trip.waypoints.length);
-        var indexMap = trip.waypoints.map(function(wp, i) {
-            return [i, wp.waypoint_index];
-        });
-        assert.ok(!indexMap.every(function(tuple) { return tuple[0] === tuple[1]; }));
    });
 });

 test('trip: throws with too few or invalid args', function(assert) {
    assert.plan(2);
-    var osrm = new OSRM(berlin_path);
-    assert.throws(function() { osrm.trip({coordinates: [[13.43864,52.51993],[13.415852,52.513191]]}) },
+    var osrm = new OSRM(data_path);
+    assert.throws(function() { osrm.trip({coordinates: two_test_coordinates}) },
        /Two arguments required/);
    assert.throws(function() { osrm.trip(null, function(err, trip) {}) },
        /First arg must be an object/);
@@ -42,7 +42,7 @@ test('trip: throws with too few or invalid args', function(assert) {

 test('trip: throws with bad params', function(assert) {
    assert.plan(14);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
    assert.throws(function () { osrm.trip({coordinates: []}, function(err) {}) });
    assert.throws(function() { osrm.trip({}, function(err, trip) {}) },
        /Must provide a coordinates property/);
@@ -51,22 +51,21 @@ test('trip: throws with bad params', function(assert) {
    }, function(err, trip) {}) },
        /Coordinates must be an array of \(lon\/lat\) pairs/);
    assert.throws(function() { osrm.trip({
-        coordinates: [13.438640, 52.519930]
+        coordinates: three_test_coordinates[0]
    }, function(err, trip) {}) },
        /Coordinates must be an array of \(lon\/lat\) pairs/);
    assert.throws(function() { osrm.trip({
-        coordinates: [[13.438640], [52.519930]]
+        coordinates: [three_test_coordinates[0][0], three_test_coordinates[0][1]]
    }, function(err, trip) {}) },
        /Coordinates must be an array of \(lon\/lat\) pairs/);
    assert.throws(function() { osrm.trip({
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
        hints: null
    }, function(err, trip) {}) },
        /Hints must be an array of strings\/null/);
    var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
-        printInstructions: false,
-        hints: [13.438640, 52.519930]
+        coordinates: [three_test_coordinates[0], three_test_coordinates[1]],
+        hints: three_test_coordinates[0]
    };
    assert.throws(function() { osrm.trip(options, function(err, trip) {}); },
        /Hint must be null or string/);
@@ -96,10 +95,10 @@ test('trip: throws with bad params', function(assert) {
        /'roundtrip' param must be a boolean/);
 });

-test('trip: routes Berlin using shared memory', function(assert) {
+test('trip: routes Monaco using shared memory', function(assert) {
    assert.plan(2);
    var osrm = new OSRM();
-    osrm.trip({coordinates: [[13.43864,52.51993],[13.415852,52.513191]]}, function(err, trip) {
+    osrm.trip({coordinates: two_test_coordinates}, function(err, trip) {
        assert.ifError(err);
            for (t = 0; t < trip.trips.length; t++) {
                assert.ok(trip.trips[t].geometry);
@@ -107,11 +106,11 @@ test('trip: routes Berlin using shared memory', function(assert) {
    });
 });

-test('trip: routes Berlin with hints', function(assert) {
+test('trip: routes Monaco with hints', function(assert) {
    assert.plan(5);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
    var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
        steps: false
    };
    osrm.trip(options, function(err, first) {
@@ -130,11 +129,11 @@ test('trip: routes Berlin with hints', function(assert) {
    });
 });

-test('trip: trip through Berlin with geometry compression', function(assert) {
+test('trip: trip through Monaco with geometry compression', function(assert) {
    assert.plan(2);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
    var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]]
+        coordinates: [three_test_coordinates[0], three_test_coordinates[1]]
    };
    osrm.trip(options, function(err, trip) {
        assert.ifError(err);
@@ -144,11 +143,11 @@ test('trip: trip through Berlin with geometry compression', function(assert) {
    });
 });

-test('trip: trip through Berlin without geometry compression', function(assert) {
+test('trip: trip through Monaco without geometry compression', function(assert) {
    assert.plan(2);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
    var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
        geometries: 'geojson'
    };
    osrm.trip(options, function(err, trip) {
@@ -159,11 +158,11 @@ test('trip: trip through Berlin without geometry compression', function(assert)
    });
 });

-test('trip: trip through Berlin with speed annotations options', function(assert) {
+test('trip: trip through Monaco with speed annotations options', function(assert) {
    assert.plan(12);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
    var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
        steps: true,
        annotations: ['speed'],
        overview: 'false'
@@ -186,11 +185,11 @@ test('trip: trip through Berlin with speed annotations options', function(assert
    });
 });

-test('trip: trip through Berlin with several (duration, distance, nodes) annotations options', function(assert) {
+test('trip: trip through Monaco with several (duration, distance, nodes) annotations options', function(assert) {
    assert.plan(12);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
    var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
        steps: true,
        annotations: ['duration', 'distance', 'nodes'],
        overview: 'false'
@@ -213,11 +212,11 @@ test('trip: trip through Berlin with several (duration, distance, nodes) annotat
    });
 });

-test('trip: trip through Berlin with options', function(assert) {
+test('trip: trip through Monaco with options', function(assert) {
    assert.plan(6);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
    var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
        steps: true,
        annotations: true,
        overview: 'false'
@@ -234,12 +233,11 @@ test('trip: trip through Berlin with options', function(assert) {
    });
 });

-test('trip: routes Berlin with null hints', function(assert) {
+test('trip: routes Monaco with null hints', function(assert) {
    assert.plan(1);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);
    var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
-        printInstructions: false,
+        coordinates: [three_test_coordinates[0], three_test_coordinates[1]],
        hints: [null, null]
    };
    osrm.trip(options, function(err, second) {
@@ -249,11 +247,11 @@ test('trip: routes Berlin with null hints', function(assert) {

 test('trip: service combinations that are not implemented', function(assert) {
    assert.plan(3);
-    var osrm = new OSRM(berlin_path);
+    var osrm = new OSRM(data_path);

    // fixed start, non-roundtrip
    var options = {
-        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
+        coordinates: two_test_coordinates,
        source: 'first',
        roundtrip: false
    };
@@ -278,10 +276,10 @@ test('trip: service combinations that are not implemented', function(assert) {
 });

 test('trip: fixed start and end combinations', function(assert) {
-    var osrm = new OSRM(berlin_path);
-    
+    var osrm = new OSRM(data_path);
+
    var options = {
-        coordinates: [[13.36761474609375,52.51663871100423],[13.374481201171875,52.506191342034576]],
+        coordinates: two_test_coordinates,
        source: 'first',
        destination: 'last',
        roundtrip: false,
@@ -291,10 +289,8 @@ test('trip: fixed start and end combinations', function(assert) {
    // fixed start and end, non-roundtrip
    osrm.trip(options, function(err, fseTrip) {
        assert.ifError(err);
-        assert.equal(206.8, fseTrip.trips[0].duration);
        assert.equal(1, fseTrip.trips.length);
        var coordinates = fseTrip.trips[0].geometry.coordinates;
-        assert.equal(15, coordinates.length);
        assert.notEqual(JSON.stringify(coordinates[0]), JSON.stringify(coordinates[coordinates.length - 1]));
    });

@@ -304,9 +300,7 @@ test('trip: fixed start and end combinations', function(assert) {
        osrm.trip(options, function(err, trip) {
            assert.ifError(err);
            assert.equal(1, trip.trips.length);
-            assert.equal(422, Math.round(trip.trips[0].duration));
            var coordinates = trip.trips[0].geometry.coordinates;
-            assert.equal(29, coordinates.length);
            assert.equal(JSON.stringify(coordinates[0]), JSON.stringify(coordinates[coordinates.length - 1]));
        });
    }
@@ -38,7 +38,8 @@ auto makeGraph(const MultiLevelPartition &mlp, const std::vector<MockEdge> &mock
        edges.push_back(Edge{m.target, m.start, m.weight, false, true});
    }
    std::sort(edges.begin(), edges.end());
-    return partition::MultiLevelGraph<EdgeData, false>(mlp, max_id + 1, edges);
+    return partition::MultiLevelGraph<EdgeData, osrm::storage::Ownership::Container>(
+        mlp, max_id + 1, edges);
 }
 }

@@ -38,7 +38,7 @@ auto makeGraph(const MultiLevelPartition &mlp, const std::vector<MockEdge> &mock
        edges.push_back(Edge{m.target, m.source, false, true});
    }
    std::sort(edges.begin(), edges.end());
-    return MultiLevelGraph<EdgeData, false>(mlp, max_id + 1, edges);
+    return MultiLevelGraph<EdgeData, osrm::storage::Ownership::Container>(mlp, max_id + 1, edges);
 }
 }

@@ -12,7 +12,7 @@ using namespace osrm::util;
 // Verify that the packed vector behaves as expected
 BOOST_AUTO_TEST_CASE(insert_and_retrieve_packed_test)
 {
-    PackedVector<OSMNodeID, false> packed_ids;
+    PackedVector<OSMNodeID, osrm::storage::Ownership::Container> packed_ids;
    std::vector<OSMNodeID> original_ids;

    const constexpr std::size_t num_test_cases = 399;
@@ -33,7 +33,7 @@ BOOST_AUTO_TEST_CASE(insert_and_retrieve_packed_test)

 BOOST_AUTO_TEST_CASE(packed_vector_capacity_test)
 {
-    PackedVector<OSMNodeID, false> packed_vec;
+    PackedVector<OSMNodeID, osrm::storage::Ownership::Container> packed_vec;
    const std::size_t original_size = packed_vec.capacity();
    std::vector<OSMNodeID> dummy_vec;

@@ -13,7 +13,7 @@ using namespace osrm;
 using namespace osrm::util;

 constexpr unsigned BLOCK_SIZE = 16;
-typedef RangeTable<BLOCK_SIZE, false> TestRangeTable;
+typedef RangeTable<BLOCK_SIZE, osrm::storage::Ownership::Container> TestRangeTable;

 void ConstructionTest(stxxl::vector<unsigned> lengths, std::vector<unsigned> offsets)
 {
@@ -70,8 +70,8 @@ template <unsigned NUM_NODES, unsigned NUM_EDGES> struct RandomArrayEntryFixture
        std::shuffle(order.begin(), order.end(), g);
    }

-    typename ShM<TestNodeArrayEntry, false>::vector nodes;
-    typename ShM<TestEdgeArrayEntry, false>::vector edges;
+    std::vector<TestNodeArrayEntry> nodes;
+    std::vector<TestEdgeArrayEntry> edges;
    std::vector<unsigned> lengths;
    std::vector<unsigned> order;
 };
@@ -42,10 +42,11 @@ constexpr uint32_t TEST_LEAF_NODE_SIZE = 64;
 using TestData = extractor::EdgeBasedNode;
 using TestStaticRTree = StaticRTree<TestData,
                                    std::vector<Coordinate>,
-                                    false,
+                                    osrm::storage::Ownership::Container,
                                    TEST_BRANCHING_FACTOR,
                                    TEST_LEAF_NODE_SIZE>;
-using MiniStaticRTree = StaticRTree<TestData, std::vector<Coordinate>, false, 2, 128>;
+using MiniStaticRTree =
+    StaticRTree<TestData, std::vector<Coordinate>, osrm::storage::Ownership::Container, 2, 128>;

 // Choosen by a fair W20 dice roll (this value is completely arbitrary)
 constexpr unsigned RANDOM_SEED = 42;
@@ -273,7 +274,8 @@ void construction_test(const std::string &prefix, FixtureT *fixture)

 BOOST_FIXTURE_TEST_CASE(construct_tiny, TestRandomGraphFixture_10_30)
 {
-    using TinyTestTree = StaticRTree<TestData, std::vector<Coordinate>, false, 2, 64>;
+    using TinyTestTree =
+        StaticRTree<TestData, std::vector<Coordinate>, osrm::storage::Ownership::Container, 2, 64>;
    construction_test<TinyTestTree>("test_tiny", this);
 }
Author	SHA1	Message	Date
Patrick Niklaus	a3621f3655	[skip ci] Bump package version to latest.3	2017-04-04 23:03:04 +00:00
Pepijn Schoen	789311abd6	Remove osrm namespace indication where possible, wrap out shared_memory_ownership	2017-04-04 17:00:36 +00:00
Pepijn Schoen	091a495632	clang-format	2017-04-04 17:00:36 +00:00
Pepijn Schoen	16665aeb00	Renaming of MemorySetting > Ownership	2017-04-04 17:00:36 +00:00
Pepijn Schoen	d6e56c38d5	Rename SharedMemoryWrapper to vector_view	2017-04-04 17:00:36 +00:00
Pepijn Schoen	87874006c7	rename to vector_view, replace some missing ShM occurences	2017-04-04 17:00:36 +00:00
Pepijn Schoen	703588b684	clang-format	2017-04-04 17:00:36 +00:00
Pepijn Schoen	b21ee1b63b	Fixed regression	2017-04-04 17:00:36 +00:00
Pepijn Schoen	427437d49b	Use a one-time defined generic signature for SharedMemoryVectors	2017-04-04 17:00:36 +00:00
Pepijn Schoen	01deefc3bc	First pass at adjustment for comments	2017-04-04 17:00:36 +00:00
Pepijn Schoen	157ca9161f	clang-format	2017-04-04 17:00:36 +00:00
Pepijn Schoen	266e65e6d2	Replace bool for using shared memory with MemorySetting enum	2017-04-04 17:00:36 +00:00
Daniel J. Hofmann	70b3962c35	NodeJS Binding Tests Does not run the nodejs tests in sanitized builds. We'd have to export LD_PRELOAD='/usr/lib/x86_64-linux-gnu/libasan.so.2' the asan lib. But it seems like our Clang from mason does not like the system's libasan. Also we'd need a suppression file for v8 and node.	2017-04-04 16:57:44 +00:00
Patrick Niklaus	e568b600f0	Tag a new latest version for publishing	2017-04-03 12:50:45 +00:00
Patrick Niklaus	273fd689ce	Always check local variables	2017-03-30 20:12:07 +00:00
Patrick Niklaus	0363d64722	Update releasing docs	2017-03-30 20:12:07 +00:00
Patrick Niklaus	d200507424	Fix travis.yml	2017-03-30 20:12:07 +00:00
Patrick Niklaus	fc84f605af	Switch from commit message publishing to tag-based publishing	2017-03-30 20:12:07 +00:00
Patrick Niklaus	927dea37bb	Fix publishing node binaries	2017-03-30 20:12:07 +00:00
Patrick Niklaus	de98ae57b7	Switch to yarn	2017-03-30 20:12:07 +00:00
Patrick Niklaus	614398ed6c	Integrate MLD in node bindings	2017-03-30 20:12:07 +00:00
Michael Krasnyk	2cd4ba9a0a	move split_edges to global properties	2017-03-30 11:20:13 +02:00
Michael Krasnyk	57d3f71bf9	added change log entry and documentation	2017-03-30 11:20:13 +02:00
Michael Krasnyk	8f8df969a2	use signed slope to distinguish uphills and downhills	2017-03-30 11:20:13 +02:00
Michael Krasnyk	e39dc3c464	adjust rasterbot test to check split_edges flag	2017-03-30 11:20:13 +02:00
Michael Krasnyk	dbc6535221	add split_edge flag in extracted ways	2017-03-30 11:20:13 +02:00
Michael Krasnyk	e262cac3e8	Flip source and target coordinates for segments in only backward direction	2017-03-29 22:05:37 +00:00
Michael Krasnyk	4ab3165ae3	Fix unnecessary duplication of backward segments for non-split edges for edges with the split flag false and in_backward_direction true if in_forward_direction is also true backward segments can be incorrectly duplicated	2017-03-29 22:05:37 +00:00