Fix travis.yml

Switch from commit message publishing to tag-based publishing
Fix publishing node binaries
2017-03-29 15:45:18 +00:00 · 2017-03-29 15:28:47 +00:00 · 2017-03-29 14:45:56 +00:00 · 2017-03-29 14:45:56 +00:00 · 2017-03-29 14:45:56 +00:00
53 changed files with 572 additions and 809 deletions
@@ -223,10 +223,6 @@ 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,8 +10,6 @@
      - .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,8 +303,6 @@ 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,7 +36,6 @@ 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,25 +32,21 @@ 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 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
+- We create the release branch once we tagged the final version `x.y.0` version, RCs go on master
 - No minor or major version will be released without a code-equal release candidates
- For quality assurance, release candidates need to be staged beforing tagging a final release
+- For quality assurance, release candidates will be run on the demo server for 24 hours before releaseing the version proper
 - 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 `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`
+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).
 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 locations
-            | node | lat        | lon      |
-            | a    | 0.1        | 0.1      |
-            | b    | 0.05       | 0.1      |
+        And the node map
+            """
+            a b
+            """
        And the ways
            | nodes |
            | ab    |
@@ -20,6 +20,4 @@ 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,9 +50,8 @@ Feature: Raster - weights
        And I route I should get
            | from | to | route    | speed   |
            | a    | b  | ab,ab    | 8 km/h  |
-            | b    | a  | ab,ab    | 22 km/h |
-            | a    | c  | ab,bc,bc | 12 km/h |
-            | b    | c  | bc,bc    | 22 km/h |
+            | a    | c  | ad,dc,dc | 15 km/h |
+            | b    | c  | bc,bc    | 8 km/h  |
            | a    | d  | ad,ad    | 15 km/h |
            | d    | c  | dc,dc    | 15 km/h |
            | d    | e  | de,de    | 10 km/h |
@@ -5,8 +5,7 @@
 #include "partition/multi_level_partition.hpp"
 #include "util/binary_heap.hpp"

-#include <tbb/enumerable_thread_specific.h>
-
+#include <boost/thread/tss.hpp>
 #include <unordered_set>

 namespace osrm
@@ -16,22 +15,12 @@ namespace customizer

 class CellCustomizer
 {
-  private:
-    struct HeapData
-    {
-        bool from_clique;
-    };

  public:
-    using Heap =
-        util::BinaryHeap<NodeID, NodeID, EdgeWeight, HeapData, util::ArrayStorage<NodeID, int>>;
-    using HeapPtr = tbb::enumerable_thread_specific<Heap>;
-
    CellCustomizer(const partition::MultiLevelPartition &partition) : partition(partition) {}

    template <typename GraphT>
-    void Customize(
-        const GraphT &graph, Heap &heap, partition::CellStorage &cells, LevelID level, CellID id)
+    void Customize(const GraphT &graph, partition::CellStorage &cells, LevelID level, CellID id)
    {
        auto cell = cells.GetCell(level, id);
        auto destinations = cell.GetDestinationNodes();
@@ -40,8 +29,8 @@ class CellCustomizer
        for (auto source : cell.GetSourceNodes())
        {
            std::unordered_set<NodeID> destinations_set(destinations.begin(), destinations.end());
-            heap.Clear();
-            heap.Insert(source, 0, {false});
+            Heap heap(graph.GetNumberOfNodes());
+            heap.Insert(source, 0, {});

            // explore search space
            while (!heap.Empty() && !destinations_set.empty())
@@ -71,23 +60,26 @@ class CellCustomizer

    template <typename GraphT> void Customize(const GraphT &graph, partition::CellStorage &cells)
    {
-        Heap heap_exemplar(graph.GetNumberOfNodes());
-        HeapPtr heaps(heap_exemplar);
-
        for (std::size_t level = 1; level < partition.GetNumberOfLevels(); ++level)
        {
            tbb::parallel_for(tbb::blocked_range<std::size_t>(0, partition.GetNumberOfCells(level)),
                              [&](const tbb::blocked_range<std::size_t> &range) {
-                                  auto &heap = heaps.local();
                                  for (auto id = range.begin(), end = range.end(); id != end; ++id)
                                  {
-                                      Customize(graph, heap, cells, level, id);
+                                      Customize(graph, cells, level, id);
                                  }
                              });
        }
    }

  private:
+    struct HeapData
+    {
+    };
+    using Heap = util::
+        BinaryHeap<NodeID, NodeID, EdgeWeight, HeapData, util::UnorderedMapStorage<NodeID, int>>;
+    using HeapPtr = boost::thread_specific_ptr<Heap>;
+
    template <bool first_level, typename GraphT>
    void RelaxNode(const GraphT &graph,
                   const partition::CellStorage &cells,
@@ -96,42 +88,29 @@ class CellCustomizer
                   NodeID node,
                   EdgeWeight weight) const
    {
-        BOOST_ASSERT(heap.WasInserted(node));
-
        if (!first_level)
        {
-            // if we reaches this node from a clique arc we don't need to scan
-            // the clique arcs again because of the triangle inequality
-            //
-            // d(parent, node) + d(node, v) >= d(parent, v)
-            //
-            // And if there is a path (parent, node, v) there must also be a
-            // clique arc (parent, v) with d(parent, v).
-            if (!heap.GetData(node).from_clique)
+            // Relax sub-cell nodes
+            auto subcell_id = partition.GetCell(level - 1, node);
+            auto subcell = cells.GetCell(level - 1, subcell_id);
+            auto subcell_destination = subcell.GetDestinationNodes().begin();
+            for (auto subcell_weight : subcell.GetOutWeight(node))
            {
-                // Relax sub-cell nodes
-                auto subcell_id = partition.GetCell(level - 1, node);
-                auto subcell = cells.GetCell(level - 1, subcell_id);
-                auto subcell_destination = subcell.GetDestinationNodes().begin();
-                for (auto subcell_weight : subcell.GetOutWeight(node))
+                if (subcell_weight != INVALID_EDGE_WEIGHT)
                {
-                    if (subcell_weight != INVALID_EDGE_WEIGHT)
+                    const NodeID to = *subcell_destination;
+                    const EdgeWeight to_weight = subcell_weight + weight;
+                    if (!heap.WasInserted(to))
                    {
-                        const NodeID to = *subcell_destination;
-                        const EdgeWeight to_weight = subcell_weight + weight;
-                        if (!heap.WasInserted(to))
-                        {
-                            heap.Insert(to, to_weight, {true});
-                        }
-                        else if (to_weight < heap.GetKey(to))
-                        {
-                            heap.DecreaseKey(to, to_weight);
-                            heap.GetData(to).from_clique = true;
-                        }
+                        heap.Insert(to, to_weight, {});
+                    }
+                    else if (to_weight < heap.GetKey(to))
+                    {
+                        heap.DecreaseKey(to, to_weight);
                    }
-
-                    ++subcell_destination;
                }
+
+                ++subcell_destination;
            }
        }

@@ -147,12 +126,11 @@ class CellCustomizer
                const EdgeWeight to_weight = data.weight + weight;
                if (!heap.WasInserted(to))
                {
-                    heap.Insert(to, to_weight, {false});
+                    heap.Insert(to, to_weight, {});
                }
                else if (to_weight < heap.GetKey(to))
                {
                    heap.DecreaseKey(to, to_weight);
-                    heap.GetData(to).from_clique = false;
                }
            }
        }
@@ -7,8 +7,6 @@
 #include "util/static_graph.hpp"
 #include "util/typedefs.hpp"

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

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

 using EdgeBasedGraphEdgeData = partition::EdgeBasedGraphEdgeData;

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

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

@@ -20,7 +20,6 @@
 #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"
@@ -62,7 +61,7 @@ class ContiguousInternalMemoryAlgorithmDataFacade<algorithm::CH>
    : public datafacade::AlgorithmDataFacade<algorithm::CH>
 {
  private:
-    using QueryGraph = util::StaticGraph<EdgeData, storage::Ownership::View>;
+    using QueryGraph = util::StaticGraph<EdgeData, true>;
    using GraphNode = QueryGraph::NodeArrayEntry;
    using GraphEdge = QueryGraph::EdgeArrayEntry;

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

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

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

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

    unsigned m_check_sum;
-    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::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::NameTable m_names_table;
-    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;
+    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;
    extractor::SegmentDataView segment_data;

-    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;
+    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;

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

    util::NameTable m_name_table;
    // bearing classes by node based node
-    util::vector_view<BearingClassID> m_bearing_class_id_table;
+    util::ShM<BearingClassID, true>::vector m_bearing_class_id_table;
    // entry class IDs
-    util::vector_view<EntryClassID> m_entry_class_id_list;
+    util::ShM<EntryClassID, true>::vector 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::vector_view<util::guidance::EntryClass> m_entry_class_table;
+    util::ShM<util::guidance::EntryClass, true>::vector 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, storage::Ownership::View>> m_bearing_ranges_table;
-    util::vector_view<DiscreteBearing> m_bearing_values_table;
+    std::shared_ptr<util::RangeTable<16, true>> m_bearing_ranges_table;
+    util::ShM<DiscreteBearing, true>::vector m_bearing_values_table;

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

        const auto travel_mode_list_ptr = data_layout.GetBlockPtr<extractor::TravelMode>(
            memory_block, storage::DataLayout::TRAVEL_MODE);
-        util::vector_view<extractor::TravelMode> travel_mode_list(
+        util::ShM<extractor::TravelMode, true>::vector 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::vector_view<LaneDataID> lane_data_id(
+        util::ShM<LaneDataID, true>::vector 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::vector_view<util::guidance::LaneTupleIdPair> lane_tupel_id_pair(
+        util::ShM<util::guidance::LaneTupleIdPair, true>::vector 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::vector_view<extractor::guidance::TurnInstruction> turn_instruction_list(
+        util::ShM<extractor::guidance::TurnInstruction, true>::vector 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::vector_view<NameID> name_id_list(
+        util::ShM<NameID, true>::vector 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::vector_view<EntryClassID> entry_class_id_list(
+        typename util::ShM<EntryClassID, true>::vector 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::vector_view<util::guidance::TurnBearing> pre_turn_bearing(
+        typename util::ShM<util::guidance::TurnBearing, true>::vector 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::vector_view<util::guidance::TurnBearing> post_turn_bearing(
+        typename util::ShM<util::guidance::TurnBearing, true>::vector 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);
    }
@@ -381,7 +380,7 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
    {
        auto via_geometry_list_ptr =
            data_layout.GetBlockPtr<GeometryID>(memory_block, storage::DataLayout::VIA_NODE_LIST);
-        util::vector_view<GeometryID> via_geometry_list(
+        util::ShM<GeometryID, true>::vector 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);
    }
@@ -399,14 +398,14 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
    {
        auto offsets_ptr = data_layout.GetBlockPtr<std::uint32_t>(
            memory_block, storage::DataLayout::LANE_DESCRIPTION_OFFSETS);
-        util::vector_view<std::uint32_t> offsets(
+        util::ShM<std::uint32_t, true>::vector 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::vector_view<extractor::guidance::TurnLaneType::Mask> masks(
+        util::ShM<extractor::guidance::TurnLaneType::Mask, true>::vector masks(
            masks_ptr, data_layout.num_entries[storage::DataLayout::LANE_DESCRIPTION_MASKS]);
        m_lane_description_masks = std::move(masks);
    }
@@ -415,12 +414,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::vector_view<TurnPenalty>(
+        m_turn_weight_penalties = util::ShM<TurnPenalty, true>::vector(
            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::vector_view<TurnPenalty>(
+        m_turn_duration_penalties = util::ShM<TurnPenalty, true>::vector(
            turn_duration_penalties_ptr,
            data_layout.num_entries[storage::DataLayout::TURN_DURATION_PENALTIES]);
    }
@@ -429,42 +428,42 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
    {
        auto geometries_index_ptr =
            data_layout.GetBlockPtr<unsigned>(memory_block, storage::DataLayout::GEOMETRIES_INDEX);
-        util::vector_view<unsigned> geometry_begin_indices(
+        util::ShM<unsigned, true>::vector 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::vector_view<NodeID> geometry_node_list(
+        util::ShM<NodeID, true>::vector 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::vector_view<EdgeWeight> geometry_fwd_weight_list(
+        util::ShM<EdgeWeight, true>::vector 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::vector_view<EdgeWeight> geometry_rev_weight_list(
+        util::ShM<EdgeWeight, true>::vector 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::vector_view<EdgeWeight> geometry_fwd_duration_list(
+        util::ShM<EdgeWeight, true>::vector 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::vector_view<EdgeWeight> geometry_rev_duration_list(
+        util::ShM<EdgeWeight, true>::vector 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::vector_view<DatasourceID> datasources_list(
+        util::ShM<DatasourceID, true>::vector datasources_list(
            datasources_list_ptr, data_layout.num_entries[storage::DataLayout::DATASOURCES_LIST]);

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

@@ -497,17 +496,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::vector_view<unsigned> bearing_offsets(
+        util::ShM<unsigned, true>::vector bearing_offsets(
            offsets_ptr, data_layout.num_entries[storage::DataLayout::BEARING_OFFSETS]);
-        util::vector_view<IndexBlock> bearing_blocks(
+        util::ShM<IndexBlock, true>::vector bearing_blocks(
            blocks_ptr, data_layout.num_entries[storage::DataLayout::BEARING_BLOCKS]);

-        m_bearing_ranges_table = std::make_unique<util::RangeTable<16, storage::Ownership::View>>(
+        m_bearing_ranges_table = std::make_unique<util::RangeTable<16, true>>(
            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::vector_view<util::guidance::EntryClass> entry_class_table(
+        typename util::ShM<util::guidance::EntryClass, true>::vector entry_class_table(
            entry_class_ptr, data_layout.num_entries[storage::DataLayout::ENTRY_CLASS]);
        m_entry_class_table = std::move(entry_class_table);
    }
@@ -930,13 +929,15 @@ class ContiguousInternalMemoryAlgorithmDataFacade<algorithm::MLD>
                memory_block, storage::DataLayout::MLD_PARTITION);
            auto partition_entries_count =
                data_layout.GetBlockEntries(storage::DataLayout::MLD_PARTITION);
-            util::vector_view<PartitionID> partition(mld_partition_ptr, partition_entries_count);
+            util::ShM<PartitionID, true>::vector 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::vector_view<CellID> cell_to_children(mld_chilren_ptr, children_entries_count);
+            util::ShM<CellID, true>::vector cell_to_children(mld_chilren_ptr,
+                                                             children_entries_count);

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

-            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);
+            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);

            mld_cell_storage = partition::CellStorageView{std::move(weights),
                                                          std::move(source_boundary),
@@ -996,11 +997,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::vector_view<GraphNode> node_list(
+        util::ShM<GraphNode, true>::vector node_list(
            graph_nodes_ptr, data_layout.num_entries[storage::DataLayout::MLD_GRAPH_NODE_LIST]);
-        util::vector_view<GraphEdge> edge_list(
+        util::ShM<GraphEdge, true>::vector edge_list(
            graph_edges_ptr, data_layout.num_entries[storage::DataLayout::MLD_GRAPH_EDGE_LIST]);
-        util::vector_view<QueryGraph::EdgeOffset> node_to_offset(
+        util::ShM<QueryGraph::EdgeOffset, true>::vector node_to_offset(
            graph_node_to_offset_ptr,
            data_layout.num_entries[storage::DataLayout::MLD_GRAPH_NODE_TO_OFFSET]);

@@ -62,6 +62,13 @@ 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(); }
@@ -98,14 +105,14 @@ struct ExtractionWay
    std::string destinations;
    std::string turn_lanes_forward;
    std::string turn_lanes_backward;
-    guidance::RoadClassification road_classification;
+    bool roundabout;
+    bool circular;
+    bool is_startpoint;
+    bool backward_restricted;
+    bool forward_restricted;
    TravelMode forward_travel_mode : 4;
    TravelMode backward_travel_mode : 4;
-    bool roundabout : 1;
-    bool circular : 1;
-    bool is_startpoint : 1;
-    bool forward_restricted : 1;
-    bool backward_restricted : 1;
+    guidance::RoadClassification road_classification;
 };
 }
 }
@@ -63,7 +63,6 @@ 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,7 +87,6 @@ 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,8 +4,6 @@
 #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>
@@ -24,24 +22,24 @@ class CompressedEdgeContainer;

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

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

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

    friend CompressedEdgeContainer;

@@ -190,11 +188,12 @@ template <storage::Ownership Ownership> 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::write<Ownership>(const boost::filesystem::path &path,
-                         const detail::SegmentDataContainerImpl<Ownership> &segment_data);
+    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);

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

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

@@ -112,13 +112,7 @@ 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 =
@@ -146,9 +140,6 @@ 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();
@@ -189,8 +180,6 @@ 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())
        {
@@ -258,9 +247,6 @@ 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");
@@ -301,8 +287,6 @@ 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())
        {
@@ -321,8 +305,6 @@ 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())
            {
@@ -367,8 +349,6 @@ 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())
        {
@@ -387,9 +367,6 @@ 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)
@@ -416,8 +393,6 @@ 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())
        {
@@ -436,9 +411,6 @@ 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();
@@ -458,8 +430,6 @@ 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())
        {
@@ -479,9 +449,6 @@ 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();
@@ -496,9 +463,6 @@ 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();
@@ -559,8 +523,6 @@ 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())
        {
@@ -593,8 +555,6 @@ 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())
        {
@@ -641,13 +601,9 @@ 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())
        {
@@ -658,13 +614,9 @@ 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();
    }
@@ -706,8 +658,6 @@ 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())
    {
@@ -748,8 +698,6 @@ 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()))
    {
@@ -787,14 +735,10 @@ 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())
        {
@@ -806,9 +750,6 @@ 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());
@@ -832,8 +773,6 @@ 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())
        {
@@ -845,9 +784,6 @@ 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());
@@ -891,9 +827,6 @@ 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();
@@ -908,8 +841,6 @@ 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())
        {
@@ -937,8 +868,6 @@ 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())
        {
@@ -980,8 +909,6 @@ 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())
        {
@@ -1001,9 +928,6 @@ 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,7 +10,6 @@
 #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>
@@ -27,23 +26,24 @@ namespace partition
 {
 namespace detail
 {
-template <storage::Ownership Ownership> class CellStorageImpl;
+template <bool UseShareMemory> class CellStorageImpl;
 }
-using CellStorage = detail::CellStorageImpl<storage::Ownership::Container>;
-using CellStorageView = detail::CellStorageImpl<storage::Ownership::View>;
+using CellStorage = detail::CellStorageImpl<false>;
+using CellStorageView = detail::CellStorageImpl<true>;

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

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

  private:
-    template <typename T> using Vector = typename util::ShM<T, Ownership>::vector;
+    template <typename T> using Vector = typename util::ShM<T, UseShareMemory>::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,8 +185,7 @@ template <storage::Ownership Ownership> class CellStorageImpl

    CellStorageImpl() {}

-    template <typename GraphT,
-              typename = std::enable_if<Ownership == storage::Ownership::Container>>
+    template <typename GraphT, typename = std::enable_if<!UseShareMemory>>
    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
@@ -315,7 +314,7 @@ template <storage::Ownership Ownership> class CellStorageImpl
        weights.resize(weight_offset + 1, INVALID_EDGE_WEIGHT);
    }

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

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

-    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);
+    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);

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

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

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

-template <typename EdgeDataT, storage::Ownership Ownership>
-inline void read(const boost::filesystem::path &path, MultiLevelGraph<EdgeDataT, Ownership> &graph)
+template <typename EdgeDataT, bool UseSharedMemory>
+inline void read(const boost::filesystem::path &path,
+                 MultiLevelGraph<EdgeDataT, UseSharedMemory> &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, MultiLevelGraph<EdgeDataT,
    reader.DeserializeVector(graph.edge_to_level);
 }

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

 #include "partition/multi_level_partition.hpp"

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

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

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

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

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

-    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);
+    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);

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

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

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

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

 namespace detail
 {

-template <storage::Ownership Ownership> class MultiLevelPartitionImpl final
+template <bool UseShareMemory> 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, Ownership>::vector;
+    template <typename T> using Vector = typename util::ShM<T, UseShareMemory>::vector;

  public:
    // Contains all data necessary to describe the level hierarchy
@@ -68,7 +68,7 @@ template <storage::Ownership Ownership> 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<Ownership == storage::Ownership::Container>>
+    template <typename = typename std::enable_if<!UseShareMemory>>
    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 <storage::Ownership Ownership> class MultiLevelPartitionImpl final
        InitializePartitionIDs(partitions);
    }

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

-    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);
+    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);

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

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

-template <typename NodeID, typename Key> class GenerationArrayStorage
-{
-    using GenerationCounter = std::uint16_t;
-
-  public:
-    explicit GenerationArrayStorage(std::size_t size)
-        : positions(size, 0), generation(1), generations(size, 0)
-    {
-    }
-
-    Key &operator[](NodeID node)
-    {
-        generation[node] = generation;
-        return positions[node];
-    }
-
-    Key peek_index(const NodeID node) const
-    {
-        if (generations[node] < generation)
-        {
-            return std::numeric_limits<Key>::max();
-        }
-        return positions[node];
-    }
-
-    void Clear()
-    {
-        generation++;
-        // if generation overflows we end up at 0 again and need to clear the vector
-        if (generation == 0)
-        {
-            generation = 1;
-            std::fill(generations.begin(), generations.end(), 0);
-        }
-    }
-
-  private:
-    GenerationCounter generation;
-    std::vector<GenerationCounter> generations;
-    std::vector<Key> positions;
-};
-
 template <typename NodeID, typename Key> class ArrayStorage
 {
  public:
@@ -134,6 +92,10 @@ template <typename NodeID,
          typename IndexStorage = ArrayStorage<NodeID, NodeID>>
 class BinaryHeap
 {
+  private:
+    BinaryHeap(const BinaryHeap &right);
+    void operator=(const BinaryHeap &right);
+
  public:
    using WeightType = Weight;
    using DataType = Data;
@@ -4,8 +4,6 @@
 #include "util/shared_memory_vector_wrapper.hpp"
 #include "util/typedefs.hpp"

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

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

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

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

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

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

    std::size_t num_elements = 0;

    signed cursor = -1;

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

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

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

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

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

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

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

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

-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::ostream &operator<<(std::ostream &out, const 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);
+template <unsigned BLOCK_SIZE, bool USE_SHARED_MEMORY>
+std::istream &operator>>(std::istream &in, RangeTable<BLOCK_SIZE, USE_SHARED_MEMORY> &table);

 /**
 * Stores adjacent ranges in a compressed format.
@@ -37,12 +35,12 @@ std::istream &operator>>(std::istream &in, RangeTable<BLOCK_SIZE, Ownership> &ta
 * 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, storage::Ownership Ownership> class RangeTable
+template <unsigned BLOCK_SIZE, bool USE_SHARED_MEMORY> class RangeTable
 {
  public:
    using BlockT = std::array<unsigned char, BLOCK_SIZE>;
-    using BlockContainerT = typename ShM<BlockT, Ownership>::vector;
-    using OffsetContainerT = typename ShM<unsigned, Ownership>::vector;
+    using BlockContainerT = typename ShM<BlockT, USE_SHARED_MEMORY>::vector;
+    using OffsetContainerT = typename ShM<unsigned, USE_SHARED_MEMORY>::vector;
    using RangeT = range<unsigned>;

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

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

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

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

-template <unsigned BLOCK_SIZE, storage::Ownership Ownership>
-unsigned RangeTable<BLOCK_SIZE, Ownership>::PrefixSumAtIndex(int index, const BlockT &block) const
+template <unsigned BLOCK_SIZE, bool USE_SHARED_MEMORY>
+unsigned RangeTable<BLOCK_SIZE, USE_SHARED_MEMORY>::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.)
@@ -228,8 +227,8 @@ unsigned RangeTable<BLOCK_SIZE, Ownership>::PrefixSumAtIndex(int index, const Bl
    return sum;
 }

-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::ostream &operator<<(std::ostream &out, const RangeTable<BLOCK_SIZE, USE_SHARED_MEMORY> &table)
 {
    // write number of block
    const unsigned number_of_blocks = table.diff_blocks.size();
@@ -244,8 +243,8 @@ std::ostream &operator<<(std::ostream &out, const RangeTable<BLOCK_SIZE, Ownersh
    return out;
 }

-template <unsigned BLOCK_SIZE, storage::Ownership Ownership>
-std::istream &operator>>(std::istream &in, 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)
 {
    // read number of block
    unsigned number_of_blocks;
@@ -3,8 +3,6 @@

 #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>
@@ -54,7 +52,7 @@ class ShMemIterator
    DataT *m_value;
 };

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

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

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

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

    auto data() const { return m_ptr; }

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

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

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

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

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

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

-    template <typename T> friend void swap(vector_view<T> &, vector_view<T> &) noexcept;
+    template <typename T>
+    friend void swap(SharedMemoryWrapper<T> &, SharedMemoryWrapper<T> &) 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
+// Both SharedMemoryWrapper<T> and the SharedMemoryWrapper<bool> specializations share this impl.
+template <typename DataT>
+void swap(SharedMemoryWrapper<DataT> &lhs, SharedMemoryWrapper<DataT> &rhs) noexcept
 {
    std::swap(lhs.m_ptr, rhs.m_ptr);
    std::swap(lhs.m_size, rhs.m_size);
 }

-template <typename DataT, storage::Ownership Ownership> struct ShM
+template <typename DataT, bool UseSharedMemory> struct ShM
 {
-    using vector = typename std::conditional<Ownership == storage::Ownership::View,
-                                             vector_view<DataT>,
+    using vector = typename std::conditional<UseSharedMemory,
+                                             SharedMemoryWrapper<DataT>,
                                             std::vector<DataT>>::type;
 };
 }
@@ -7,8 +7,6 @@
 #include "util/shared_memory_vector_wrapper.hpp"
 #include "util/typedefs.hpp"

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

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

 } // namespace static_graph_details

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

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

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

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

 #include "osrm/coordinate.hpp"

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

-    typename ShM<TreeNode, Ownership>::vector m_search_tree;
+    typename ShM<TreeNode, UseSharedMemory>::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, storage::Ownership::View>::vector m_leaves;
+    typename ShM<const LeafNode, true>::vector m_leaves;

  public:
    StaticRTree(const StaticRTree &) = delete;
@@ -1,6 +1,6 @@
 {
  "name": "osrm",
-  "version": "5.7.0-latest.4",
+  "version": "5.7.0-latest.1",
  "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,8 +19,7 @@
    "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",
-    "nodejs-tests": "make -C test/data && ./lib/binding/osrm-datastore test/data/ch/monaco.osrm && node test/nodejs/index.js | faucet"
+    "install": "node-pre-gyp install --fallback-to-build=false"
  },
  "repository": {
    "type": "git",
@@ -45,7 +44,6 @@
    "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,8 +1,6 @@
 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)
@@ -48,7 +46,7 @@ function segment_function (segment)
  local scaled_duration = segment.duration

  if sourceData.datum ~= invalid and targetData.datum ~= invalid then
-    local slope = (targetData.datum - sourceData.datum) / segment.distance
+    local slope = math.abs(sourceData.datum - targetData.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,14 +28,12 @@ constexpr int32_t WORLD_MAX_LON = 180 * COORDINATE_PRECISION;

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

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

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

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

 #include "util/log.hpp"
@@ -84,9 +82,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, storage::Ownership::Container>>(
-        mlp, num_nodes, std::move(tidied));
+    auto edge_based_graph =
+        std::make_unique<partition::MultiLevelGraph<EdgeBasedGraphEdgeData, false>>(
+            mlp, num_nodes, std::move(tidied));

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

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

-            // 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);
+            auto weight = edge_iterator->weight_data(distance);
+            auto duration = edge_iterator->duration_data(distance);

-            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);
+            ExtractionSegment extracted_segment(
+                edge_iterator->source_coordinate, target_coord, distance, weight, duration);
+            scripting_environment.ProcessSegment(extracted_segment);

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

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

 ExtractorCallbacks::ExtractorCallbacks(ExtractionContainers &extraction_containers_,
                                       const ProfileProperties &properties)
-    : external_memory(extraction_containers_),
-      fallback_to_duration(properties.fallback_to_duration),
-      force_split_edges(properties.force_split_edges)
+    : external_memory(extraction_containers_), fallback_to_duration(properties.fallback_to_duration)
 {
    // we reserved 0, 1, 2, 3 for the empty case
    string_map[MapKey("", "", "", "")] = 0;
@@ -325,15 +323,14 @@ 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 &&
-        (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));
+    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));

    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(),
@@ -358,8 +355,8 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, const Extracti
            });
    }

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

    context.state.new_usertype<std::vector<std::string>>(
        "vector",
@@ -332,6 +330,12 @@ 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",
@@ -339,26 +343,13 @@ void Sol2ScriptingEnvironment::InitContext(LuaScriptingContext &context)
        "road_classification",
        &ExtractionWay::road_classification,
        "forward_mode",
-        sol::property([](const ExtractionWay &way) { return way.forward_travel_mode; },
-                      [](ExtractionWay &way, TravelMode mode) { way.forward_travel_mode = mode; }),
+        sol::property(&ExtractionWay::get_forward_mode, &ExtractionWay::set_forward_mode),
        "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; }),
+        sol::property(&ExtractionWay::get_backward_mode, &ExtractionWay::set_backward_mode),
        "forward_restricted",
-        sol::property([](const ExtractionWay &way) { return way.forward_restricted; },
-                      [](ExtractionWay &way, bool flag) { way.forward_restricted = flag; }),
+        &ExtractionWay::forward_restricted,
        "backward_restricted",
-        sol::property([](const ExtractionWay &way) { return way.backward_restricted; },
-                      [](ExtractionWay &way, bool flag) { way.backward_restricted = flag; }));
+        &ExtractionWay::backward_restricted);

    context.state.new_usertype<ExtractionSegment>("ExtractionSegment",
                                                  "source",
@@ -7,14 +7,12 @@ 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,7 +16,6 @@
 #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"
@@ -56,9 +55,8 @@ namespace storage
 {

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

@@ -366,13 +364,12 @@ 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, storage::Ownership::View>::BlockT>(
-            DataLayout::BEARING_BLOCKS, bearing_blocks);
+        layout.SetBlockSize<typename util::RangeTable<16, true>::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, storage::Ownership::View>::BlockT>(
-            bearing_blocks);
+        intersection_file.Skip<typename util::RangeTable<16, true>::BlockT>(bearing_blocks);

        const auto num_bearings = intersection_file.ReadElementCount64();

@@ -697,7 +694,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, storage::Ownership::View> osmnodeid_list;
+        util::PackedVector<OSMNodeID, true> osmnodeid_list;

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

@@ -806,8 +803,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, storage::Ownership::View>::BlockT>
-            bearing_blocks_data(bearing_blocks);
+        std::vector<typename util::RangeTable<16, true>::BlockT> bearing_blocks_data(
+            bearing_blocks);

        intersection_file.ReadInto(bearing_offsets_data.data(), bearing_blocks);
        intersection_file.ReadInto(bearing_blocks_data.data(), bearing_blocks);
@@ -847,8 +844,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, storage::Ownership::View>::BlockT,
-                                   true>(memory_ptr, DataLayout::BEARING_BLOCKS);
+                layout.GetBlockPtr<typename util::RangeTable<16, true>::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() { storage::SharedMonitor<storage::SharedDataTimestamp>::remove(); }
+void removeLocks() { osrm::storage::SharedMonitor<osrm::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 = storage::io::FileReader;
+    using Reader = osrm::storage::io::FileReader;
    using OriginalEdgeData = osrm::extractor::OriginalEdgeData;

    extractor::SegmentDataContainer segment_data;
@@ -1,26 +0,0 @@
-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 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 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;

 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: monaco_path, shared_memory: false});
+    var osrm = new OSRM({path: berlin_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: monaco_path, shared_memory: 'a'}); },
+    assert.throws(function() { new OSRM({path: berlin_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: monaco_mld_path});
+    var osrm = new OSRM({algorithm: 'MLD', path: berlin_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: monaco_path});
+    var osrm = new OSRM({algorithm: 'CH', path: berlin_path});
    assert.ok(osrm);
 });

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

@@ -1,14 +1,12 @@
 var OSRM = require('../../');
 var test = require('tape');
-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;
+var berlin_path = require('./osrm-data-path').data_path;

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

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

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

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

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


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

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

 test('match: throws on missing arguments', function(assert) {
    assert.plan(1);
-    var osrm = new OSRM(data_path);
+    var osrm = new OSRM(berlin_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(data_path);
+    var osrm = new OSRM(berlin_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(data_path);
+    var osrm = new OSRM(berlin_path);
    var options = {
        coordinates: ''
    };
    assert.throws(function() { osrm.match(options, function(err, response) {}) },
        /Coordinates must be an array of \(lon\/lat\) pairs/);
-    options.coordinates = [three_test_coordinates[0]];
+    options.coordinates = [[13.393252,52.542648]];
    assert.throws(function() { osrm.match(options, function(err, response) {}) },
        /At least two coordinates must be provided/);
-    options.coordinates = three_test_coordinates[0]
+    options.coordinates = [13.393252,52.542648];
    assert.throws(function() { osrm.match(options, function(err, response) {}) },
        /Coordinates must be an array of \(lon\/lat\) pairs/);
-    options.coordinates = [three_test_coordinates[0][0], three_test_coordinates[0][1]];
+    options.coordinates = [[13.393252],[52.542648]];
    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(data_path);
+    var osrm = new OSRM(berlin_path);
    var options = {
-        coordinates: three_test_coordinates,
+        coordinates: [[13.393252,52.542648],[13.39478,52.543079],[13.397389,52.542107]],
        timestamps: 'timestamps'
    };
    assert.throws(function() { osrm.match(options, function(err, response) {}) },
@@ -1,15 +1,12 @@
 var OSRM = require('../../');
 var test = require('tape');
-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;
-
+var berlin_path = require('./osrm-data-path').data_path;

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

 test('nearest: can ask for multiple nearest pts', function(assert) {
    assert.plan(2);
-    var osrm = new OSRM(data_path);
+    var osrm = new OSRM(berlin_path);
    osrm.nearest({
-        coordinates: [three_test_coordinates[0]],
+        coordinates: [[13.333086, 52.4224]],
        number: 3
    }, function(err, result) {
        assert.ifError(err);
@@ -32,19 +29,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(data_path);
+    var osrm = new OSRM(berlin_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 = [43.73072];
+    options.coordinates = [52.4224];
    assert.throws(function() { osrm.nearest(options, function(err, res) {}); },
        /Coordinates must be an array of /);
-    options.coordinates = [three_test_coordinates[0], three_test_coordinates[1]];
+    options.coordinates = [[13.333086, 52.4224],[13.333086, 52.5224]];
    assert.throws(function() { osrm.nearest(options, function(err, res) {}); },
        /Exactly one coordinate pair must be provided/);
-    options.coordinates = [three_test_coordinates[0]];
+    options.coordinates = [[13.333086, 52.4224]];
    options.number = 3.14159;
    assert.throws(function() { osrm.nearest(options, function(err, res) {}); },
        /Number must be an integer greater than or equal to 1/);
@@ -0,0 +1,12 @@
+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,27 +1,12 @@
 var OSRM = require('../../');
 var test = require('tape');
-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;
+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;

-
-test('route: routes Monaco', function(assert) {
+test('route: routes Berlin', function(assert) {
    assert.plan(5);
-    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'});
+    var osrm = new OSRM(berlin_path);
    osrm.route({coordinates: [[13.43864,52.51993],[13.415852,52.513191]]}, function(err, route) {
        assert.ifError(err);
        assert.ok(route.waypoints);
@@ -31,9 +16,21 @@ test('route: routes Monaco on MLD', function(assert) {
    });
 });

-test('route: routes Monaco on CoreCH', function(assert) {
+test('route: routes Berlin on MLD', function(assert) {
    assert.plan(5);
-    var osrm = new OSRM({path: monaco_corech_path, algorithm: 'CoreCH'});
+    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'});
    osrm.route({coordinates: [[13.43864,52.51993],[13.415852,52.513191]]}, function(err, route) {
        assert.ifError(err);
        assert.ok(route.waypoints);
@@ -45,19 +42,19 @@ test('route: routes Monaco on CoreCH', function(assert) {

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

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

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

 test('route: throws with bad params', function(assert) {
    assert.plan(11);
-    var osrm = new OSRM(monaco_path);
+    var osrm = new OSRM(berlin_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: [[three_test_coordinates[0]], [three_test_coordinates[1]]]}, function(err, route) {}) },
+    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: [[true, 'stringish'], three_test_coordinates[1]]}, function(err, route) {}) },
+    assert.throws(function() { osrm.route({coordinates: [[true, '52.519930'], [13.438640, 52.519930]]}, 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: two_test_coordinates, hints: null}, function(err, route) {}) },
+    assert.throws(function() { osrm.route({coordinates: [[13.43864,52.51993],[13.415852,52.513191]], hints: null}, function(err, route) {}) },
        /Hints must be an array of strings\/null/);
-    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) {}) });
+    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) {}) });
    var options = {
-        coordinates: two_test_coordinates,
+        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
        alternateRoute: false,
-        hints: three_test_coordinates[0]
+        hints: [13.438640, 52.519930]
    };
    assert.throws(function() { osrm.route(options, function(err, route) {}) },
        /Hint must be null or string/);
 });

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

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

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

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

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

-test('route: routes Monaco with several (duration, distance, nodes) annotations options', function(assert) {
+test('route: routes Berlin with several (duration, distance, nodes) annotations options', function(assert) {
    assert.plan(17);
-    var osrm = new OSRM(monaco_path);
+    var osrm = new OSRM(berlin_path);
    var options = {
-        coordinates: two_test_coordinates,
+        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
        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);
@@ -235,11 +232,11 @@ test('route: routes Monaco with several (duration, distance, nodes) annotations
    });
 });

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

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

 test('route: invalid route options', function(assert) {
    assert.plan(8);
-    var osrm = new OSRM(monaco_path);
+    var osrm = new OSRM(berlin_path);
    assert.throws(function() { osrm.route({
-        coordinates: two_test_coordinates,
+        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
        continue_straight: []
    }, function(err, route) {}); },
        /must be boolean/);
    assert.throws(function() { osrm.route({
-        coordinates: two_test_coordinates,
+        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
        alternatives: []
    }, function(err, route) {}); },
        /must be boolean/);
    assert.throws(function() { osrm.route({
-        coordinates: two_test_coordinates,
+        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
        geometries: true
    }, function(err, route) {}); },
        /Geometries must be a string: \[polyline, polyline6, geojson\]/);
    assert.throws(function() { osrm.route({
-        coordinates: two_test_coordinates,
+        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
        overview: false
    }, function(err, route) {}); },
        /Overview must be a string: \[simplified, full, false\]/);
    assert.throws(function() { osrm.route({
-        coordinates: two_test_coordinates,
+        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
        overview: false
    }, function(err, route) {}); },
        /Overview must be a string: \[simplified, full, false\]/);
    assert.throws(function() { osrm.route({
-        coordinates: two_test_coordinates,
+        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
        overview: 'maybe'
    }, function(err, route) {}); },
        /'overview' param must be one of \[simplified, full, false\]/);
    assert.throws(function() { osrm.route({
-        coordinates: two_test_coordinates,
+        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
        geometries: 'maybe'
    }, function(err, route) {}); },
        /'geometries' param must be one of \[polyline, polyline6, geojson\]/);
@@ -347,9 +344,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(monaco_path);
+    var osrm = new OSRM(berlin_path);
    var options = {
-        coordinates: two_test_coordinates,
+        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
        bearings: [200, 250],
    };
    assert.throws(function() { osrm.route(options, function(err, route) {}); },
@@ -358,9 +355,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(monaco_path);
+    var osrm = new OSRM(berlin_path);
    var options = {
-        coordinates: two_test_coordinates,
+        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
        bearings: [[200, 180], [250, 180]],
    };
    osrm.route(options, function(err, route) {
@@ -376,44 +373,44 @@ test('route: valid bearing values', function(assert) {

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

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

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

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

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

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

-
-test('table: distance table in Monaco', function(assert) {
-    assert.plan(11);
-    var osrm = new OSRM(data_path);
+test('table: distance table in Berlin', function(assert) {
+    assert.plan(9);
+    var osrm = new OSRM(berlin_path);
    var options = {
-        coordinates: [three_test_coordinates[0], three_test_coordinates[1]]
+        coordinates: [[13.43864,52.51993],[13.415852,52.513191]]
    };
    osrm.table(options, function(err, table) {
        assert.ifError(err);
@@ -26,8 +23,6 @@ test('table: distance table in Monaco', 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');
                }
            }
        }
@@ -35,11 +30,11 @@ test('table: distance table in Monaco', function(assert) {
    });
 });

-test('table: distance table in Monaco with sources/destinations', function(assert) {
-    assert.plan(7);
-    var osrm = new OSRM(data_path);
+test('table: distance table in Berlin with sources/destinations', function(assert) {
+    assert.plan(6);
+    var osrm = new OSRM(berlin_path);
    var options = {
-        coordinates: [three_test_coordinates[0], three_test_coordinates[1]],
+        coordinates: [[13.43864,52.51993],[13.415852,52.513191]],
        sources: [0],
        destinations: [0,1]
    };
@@ -58,8 +53,6 @@ test('table: distance table in Monaco 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');
                }
            }
        }
@@ -69,24 +62,24 @@ test('table: distance table in Monaco with sources/destinations', function(asser

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

-    options.coordinates = two_test_coordinates;
+    options.coordinates = [[13.393252,52.542648],[13.393252,52.542648]];
    options.sources = true;
    assert.throws(function() { osrm.table(options, function(err, response) {}) },
        /Sources must be an array of indices \(or undefined\)/);
@@ -117,22 +110,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: two_test_coordinates, generate_hints: null}, function(err, route) {}) },
+    assert.throws(function() { osrm.route({coordinates: [[13.43864,52.51993],[13.415852,52.513191]], 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(data_path);
+    var osrm = new OSRM(berlin_path);
    assert.throws(function() { osrm.table(null, function() {}); },
        /First arg must be an object/);
 });

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

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

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

-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/);
+// 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);
+    });
 });
@@ -1,14 +1,11 @@
 var OSRM = require('../../');
 var test = require('tape');
-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;
+var berlin_path = require('./osrm-data-path').data_path;

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

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

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

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

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

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

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

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

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

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

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

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

 test('trip: fixed start and end combinations', function(assert) {
-    var osrm = new OSRM(data_path);
-
+    var osrm = new OSRM(berlin_path);
+    
    var options = {
-        coordinates: two_test_coordinates,
+        coordinates: [[13.36761474609375,52.51663871100423],[13.374481201171875,52.506191342034576]],
        source: 'first',
        destination: 'last',
        roundtrip: false,
@@ -289,8 +291,10 @@ 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]));
    });

@@ -300,7 +304,9 @@ 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,8 +38,7 @@ 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, osrm::storage::Ownership::Container>(
-        mlp, max_id + 1, edges);
+    return partition::MultiLevelGraph<EdgeData, false>(mlp, max_id + 1, edges);
 }
 }

@@ -59,7 +58,6 @@ BOOST_AUTO_TEST_CASE(two_level_test)

    CellStorage storage(mlp, graph);
    CellCustomizer customizer(mlp);
-    CellCustomizer::Heap heap(graph.GetNumberOfNodes());

    auto cell_1_0 = storage.GetCell(1, 0);
    auto cell_1_1 = storage.GetCell(1, 1);
@@ -81,8 +79,8 @@ BOOST_AUTO_TEST_CASE(two_level_test)
    REQUIRE_SIZE_RANGE(cell_1_1.GetOutWeight(2), 2);
    REQUIRE_SIZE_RANGE(cell_1_1.GetInWeight(3), 2);

-    customizer.Customize(graph, heap, storage, 1, 0);
-    customizer.Customize(graph, heap, storage, 1, 1);
+    customizer.Customize(graph, storage, 1, 0);
+    customizer.Customize(graph, storage, 1, 1);

    // cell 0
    // check row source -> destination
@@ -204,15 +202,14 @@ BOOST_AUTO_TEST_CASE(four_levels_test)
    REQUIRE_SIZE_RANGE(cell_3_0.GetDestinationNodes(), 0);

    CellCustomizer customizer(mlp);
-    CellCustomizer::Heap heap(graph.GetNumberOfNodes());

-    customizer.Customize(graph, heap, storage, 1, 0);
-    customizer.Customize(graph, heap, storage, 1, 1);
-    customizer.Customize(graph, heap, storage, 1, 2);
-    customizer.Customize(graph, heap, storage, 1, 3);
+    customizer.Customize(graph, storage, 1, 0);
+    customizer.Customize(graph, storage, 1, 1);
+    customizer.Customize(graph, storage, 1, 2);
+    customizer.Customize(graph, storage, 1, 3);

-    customizer.Customize(graph, heap, storage, 2, 0);
-    customizer.Customize(graph, heap, storage, 2, 1);
+    customizer.Customize(graph, storage, 2, 0);
+    customizer.Customize(graph, storage, 2, 1);

    // level 1
    // cell 0
@@ -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, osrm::storage::Ownership::Container>(mlp, max_id + 1, edges);
+    return MultiLevelGraph<EdgeData, false>(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, osrm::storage::Ownership::Container> packed_ids;
+    PackedVector<OSMNodeID, false> 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, osrm::storage::Ownership::Container> packed_vec;
+    PackedVector<OSMNodeID, false> 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, osrm::storage::Ownership::Container> TestRangeTable;
+typedef RangeTable<BLOCK_SIZE, false> 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);
    }

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

 // Choosen by a fair W20 dice roll (this value is completely arbitrary)
 constexpr unsigned RANDOM_SEED = 42;
@@ -274,8 +273,7 @@ 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>, osrm::storage::Ownership::Container, 2, 64>;
+    using TinyTestTree = StaticRTree<TestData, std::vector<Coordinate>, false, 2, 64>;
    construction_test<TinyTestTree>("test_tiny", this);
 }
Author	SHA1	Message	Date
Patrick Niklaus	ae01a1ad6a	Fix travis.yml	2017-03-29 15:45:18 +00:00
Patrick Niklaus	abaa47458b	Switch from commit message publishing to tag-based publishing	2017-03-29 15:28:47 +00:00
Patrick Niklaus	ce5afb7334	Fix publishing node binaries	2017-03-29 14:45:56 +00:00
Patrick Niklaus	82dc092ca0	Switch to yarn	2017-03-29 14:45:56 +00:00
Patrick Niklaus	31b6e4b2c3	Integrate MLD in node bindings	2017-03-29 14:45:56 +00:00