Move geometry ids, name_ids and travel_modes to EdgeBasedNodeData

include/engine/datafacade/contiguous_internalmem_datafacade.hpp

@@ -13,6 +13,7 @@
 #include "extractor/datasources.hpp"
 #include "extractor/guidance/turn_instruction.hpp"
 #include "extractor/guidance/turn_lane_types.hpp"
+#include "extractor/node_data_container.hpp"
 #include "extractor/packed_osm_ids.hpp"
 #include "extractor/profile_properties.hpp"
 #include "extractor/segment_data_container.hpp"
@@ -223,6 +224,7 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
     util::vector_view<TurnPenalty> m_turn_duration_penalties;
     extractor::SegmentDataView segment_data;
     extractor::TurnDataView turn_data;
+    extractor::EdgeBasedNodeDataView edge_based_node_data;
 
     util::vector_view<char> m_datasource_name_data;
     util::vector_view<std::size_t> m_datasource_name_offsets;
@@ -319,17 +321,34 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
             data_layout.num_entries[storage::DataLayout::COORDINATE_LIST]);
     }
 
-    void InitializeEdgeInformationPointers(storage::DataLayout &layout, char *memory_ptr)
+    void InitializeEdgeBasedNodeDataInformationPointers(storage::DataLayout &layout,
+                                                        char *memory_ptr)
     {
         auto via_geometry_list_ptr =
-            layout.GetBlockPtr<GeometryID>(memory_ptr, storage::DataLayout::VIA_NODE_LIST);
+            layout.GetBlockPtr<GeometryID>(memory_ptr, storage::DataLayout::GEOMETRY_ID_LIST);
         util::vector_view<GeometryID> geometry_ids(
-            via_geometry_list_ptr, layout.num_entries[storage::DataLayout::VIA_NODE_LIST]);
+            via_geometry_list_ptr, layout.num_entries[storage::DataLayout::GEOMETRY_ID_LIST]);
 
-        const auto travel_mode_list_ptr =
+        const auto name_id_list_ptr =
-            layout.GetBlockPtr<extractor::TravelMode>(memory_ptr, storage::DataLayout::TRAVEL_MODE);
+            layout.GetBlockPtr<NameID>(memory_ptr, storage::DataLayout::NAME_ID_LIST);
+        util::vector_view<NameID> name_ids(name_id_list_ptr,
+                                           layout.num_entries[storage::DataLayout::NAME_ID_LIST]);
+
+        const auto travel_mode_list_ptr = layout.GetBlockPtr<extractor::TravelMode>(
+            memory_ptr, storage::DataLayout::TRAVEL_MODE_LIST);
         util::vector_view<extractor::TravelMode> travel_modes(
-            travel_mode_list_ptr, layout.num_entries[storage::DataLayout::TRAVEL_MODE]);
+            travel_mode_list_ptr, layout.num_entries[storage::DataLayout::TRAVEL_MODE_LIST]);
+
+        edge_based_node_data = extractor::EdgeBasedNodeDataView(
+            std::move(geometry_ids), std::move(name_ids), std::move(travel_modes));
+    }
+
+    void InitializeEdgeInformationPointers(storage::DataLayout &layout, char *memory_ptr)
+    {
+        auto node_ids_list_ptr =
+            layout.GetBlockPtr<NodeID>(memory_ptr, storage::DataLayout::EDGE_BASED_NODE_ID_LIST);
+        util::vector_view<NodeID> node_ids(
+            node_ids_list_ptr, layout.num_entries[storage::DataLayout::EDGE_BASED_NODE_ID_LIST]);
 
         const auto lane_data_id_ptr =
             layout.GetBlockPtr<LaneDataID>(memory_ptr, storage::DataLayout::LANE_DATA_ID);
@@ -342,11 +361,6 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
         util::vector_view<extractor::guidance::TurnInstruction> turn_instructions(
             turn_instruction_list_ptr, layout.num_entries[storage::DataLayout::TURN_INSTRUCTION]);
 
-        const auto name_id_list_ptr =
-            layout.GetBlockPtr<NameID>(memory_ptr, storage::DataLayout::NAME_ID_LIST);
-        util::vector_view<NameID> name_ids(name_id_list_ptr,
-                                           layout.num_entries[storage::DataLayout::NAME_ID_LIST]);
-
         const auto entry_class_id_list_ptr =
             layout.GetBlockPtr<EntryClassID>(memory_ptr, storage::DataLayout::ENTRY_CLASSID);
         util::vector_view<EntryClassID> entry_class_ids(
@@ -362,11 +376,9 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
         util::vector_view<util::guidance::TurnBearing> post_turn_bearings(
             post_turn_bearing_ptr, layout.num_entries[storage::DataLayout::POST_TURN_BEARING]);
 
-        turn_data = extractor::TurnDataView(std::move(geometry_ids),
+        turn_data = extractor::TurnDataView(std::move(node_ids),
-                                            std::move(name_ids),
                                             std::move(turn_instructions),
                                             std::move(lane_data_ids),
-                                            std::move(travel_modes),
                                             std::move(entry_class_ids),
                                             std::move(pre_turn_bearings),
                                             std::move(post_turn_bearings));
@@ -509,6 +521,7 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
     {
         InitializeChecksumPointer(data_layout, memory_block);
         InitializeNodeInformationPointers(data_layout, memory_block);
+        InitializeEdgeBasedNodeDataInformationPointers(data_layout, memory_block);
         InitializeEdgeInformationPointers(data_layout, memory_block);
         InitializeTurnPenalties(data_layout, memory_block);
         InitializeGeometryPointers(data_layout, memory_block);
@@ -540,7 +553,7 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
         return m_osmnodeid_list.at(id);
     }
 
-    virtual std::vector<NodeID> GetUncompressedForwardGeometry(const EdgeID id) const override final
+    std::vector<NodeID> GetUncompressedForwardGeometry(const EdgeID id) const override final
     {
 
         auto range = segment_data.GetForwardGeometry(id);
@@ -599,11 +612,6 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
         return std::vector<DatasourceID>{range.begin(), range.end()};
     }
 
-    virtual GeometryID GetGeometryIndexForEdgeID(const EdgeID id) const override final
-    {
-        return turn_data.GetGeometryID(id);
-    }
-
     virtual TurnPenalty GetWeightPenaltyForEdgeID(const unsigned id) const override final
     {
         BOOST_ASSERT(m_turn_weight_penalties.size() > id);
@@ -616,17 +624,17 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
         return m_turn_duration_penalties[id];
     }
 
+    NodeID GetEdgeBasedNodeID(const EdgeID id) const override final
+    {
+        return turn_data.GetNodeID(id);
+    }
+
     extractor::guidance::TurnInstruction
     GetTurnInstructionForEdgeID(const EdgeID id) const override final
     {
         return turn_data.GetTurnInstruction(id);
     }
 
-    extractor::TravelMode GetTravelModeForEdgeID(const EdgeID id) const override final
-    {
-        return turn_data.GetTravelMode(id);
-    }
-
     std::vector<RTreeLeaf> GetEdgesInBox(const util::Coordinate south_west,
                                          const util::Coordinate north_east) const override final
     {
@@ -744,9 +752,19 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
 
     unsigned GetCheckSum() const override final { return m_check_sum; }
 
-    NameID GetNameIndexFromEdgeID(const EdgeID id) const override final
+    GeometryID GetGeometryIndex(const NodeID id) const override final
     {
-        return turn_data.GetNameID(id);
+        return edge_based_node_data.GetGeometryID(id);
+    }
+
+    extractor::TravelMode GetTravelMode(const NodeID id) const override final
+    {
+        return edge_based_node_data.GetTravelMode(id);
+    }
+
+    NameID GetNameIndex(const NodeID id) const override final
+    {
+        return edge_based_node_data.GetNameID(id);
     }
 
     StringView GetNameForID(const NameID id) const override final

include/engine/datafacade/datafacade_base.hpp

@@ -51,7 +51,7 @@ class BaseDataFacade
 
     virtual OSMNodeID GetOSMNodeIDOfNode(const NodeID id) const = 0;
 
-    virtual GeometryID GetGeometryIndexForEdgeID(const EdgeID id) const = 0;
+    virtual GeometryID GetGeometryIndex(const NodeID id) const = 0;
 
     virtual std::vector<NodeID> GetUncompressedForwardGeometry(const EdgeID id) const = 0;
 
@@ -79,10 +79,12 @@ class BaseDataFacade
     // Gets the name of a datasource
     virtual StringView GetDatasourceName(const DatasourceID id) const = 0;
 
+    virtual NodeID GetEdgeBasedNodeID(const NodeID id) const = 0;
+
     virtual extractor::guidance::TurnInstruction
     GetTurnInstructionForEdgeID(const EdgeID id) const = 0;
 
-    virtual extractor::TravelMode GetTravelModeForEdgeID(const EdgeID id) const = 0;
+    virtual extractor::TravelMode GetTravelMode(const NodeID id) const = 0;
 
     virtual std::vector<RTreeLeaf> GetEdgesInBox(const util::Coordinate south_west,
                                                  const util::Coordinate north_east) const = 0;
@@ -135,7 +137,7 @@ class BaseDataFacade
     virtual extractor::guidance::TurnLaneDescription
     GetTurnDescription(const LaneDescriptionID lane_description_id) const = 0;
 
-    virtual NameID GetNameIndexFromEdgeID(const EdgeID id) const = 0;
+    virtual NameID GetNameIndex(const NodeID id) const = 0;
 
     virtual StringView GetNameForID(const NameID id) const = 0;
 

include/engine/routing_algorithms/routing_base.hpp

@@ -115,15 +115,16 @@ void annotatePath(const FacadeT &facade,
     for (auto edge_id : unpacked_edges)
     {
         const auto &edge_data = facade.GetEdgeData(edge_id);
-        const auto turn_id = edge_data.turn_id; // edge-based node ID
+        const auto turn_id = edge_data.turn_id;                      // edge-based edge ID
-        const auto name_index = facade.GetNameIndexFromEdgeID(turn_id);
+        const auto ebg_node_id = facade.GetEdgeBasedNodeID(turn_id); // edge-based source node ID
+        const auto name_index = facade.GetNameIndex(ebg_node_id);
         const auto turn_instruction = facade.GetTurnInstructionForEdgeID(turn_id);
         const extractor::TravelMode travel_mode =
             (unpacked_path.empty() && start_traversed_in_reverse)
                 ? phantom_node_pair.source_phantom.backward_travel_mode
-                : facade.GetTravelModeForEdgeID(turn_id);
+                : facade.GetTravelMode(ebg_node_id);
 
-        const auto geometry_index = facade.GetGeometryIndexForEdgeID(turn_id);
+        const auto geometry_index = facade.GetGeometryIndex(ebg_node_id);
         std::vector<NodeID> id_vector;
 
         std::vector<EdgeWeight> weight_vector;

include/extractor/edge_based_graph_factory.hpp

@@ -83,7 +83,8 @@ class EdgeBasedGraphFactory
                                    guidance::LaneDescriptionMap &lane_description_map);
 
     void Run(ScriptingEnvironment &scripting_environment,
-             const std::string &original_edge_data_filename,
+             const std::string &nodes_data_filename,
+             const std::string &turn_data_filename,
              const std::string &turn_lane_data_filename,
              const std::string &turn_weight_penalties_filename,
              const std::string &turn_duration_penalties_filename,
@@ -151,12 +152,17 @@ class EdgeBasedGraphFactory
 
     std::vector<NBGToEBG> GenerateEdgeExpandedNodes();
 
-    void GenerateEdgeExpandedEdges(ScriptingEnvironment &scripting_environment,
+    std::unordered_map<EdgeID, NodeID>
-                                   const std::string &original_edge_data_filename,
+    GenerateEdgeExpandedNodesData(const std::string &node_data_filename) const;
-                                   const std::string &turn_lane_data_filename,
+
-                                   const std::string &turn_weight_penalties_filename,
+    void
-                                   const std::string &turn_duration_penalties_filename,
+    GenerateEdgeExpandedEdges(ScriptingEnvironment &scripting_environment,
-                                   const std::string &turn_penalties_index_filename);
+                              const std::unordered_map<EdgeID, NodeID> &index_nbg_edgeid_ebg_nodeid,
+                              const std::string &original_edge_data_filename,
+                              const std::string &turn_lane_data_filename,
+                              const std::string &turn_weight_penalties_filename,
+                              const std::string &turn_duration_penalties_filename,
+                              const std::string &turn_penalties_index_filename);
 
     NBGToEBG InsertEdgeBasedNode(const NodeID u, const NodeID v);
 

include/extractor/edge_based_node.hpp

@@ -52,7 +52,7 @@ struct EdgeBasedNode
     SegmentID reverse_segment_id; // needed for edge-expanded graph
     NodeID u;                     // indices into the coordinates array
     NodeID v;                     // indices into the coordinates array
-    unsigned name_id;             // id of the edge name
+    NameID name_id;               // id of the edge name
 
     unsigned packed_geometry_id;
     struct

include/extractor/extractor_config.hpp

@@ -74,6 +74,7 @@ struct ExtractorConfig
         turn_weight_penalties_path = basepath + ".osrm.turn_weight_penalties";
         turn_penalties_index_path = basepath + ".osrm.turn_penalties_index";
         edge_based_node_weights_output_path = basepath + ".osrm.enw";
+        edge_based_nodes_data_path = basepath + ".osrm.nodes_data";
         profile_properties_output_path = basepath + ".osrm.properties";
         intersection_class_data_output_path = basepath + ".osrm.icd";
         compressed_node_based_graph_output_path = basepath + ".osrm.cnbg";
@@ -92,6 +93,7 @@ struct ExtractorConfig
     std::string geometry_output_path;
     std::string edge_output_path;
     std::string edge_graph_output_path;
+    std::string edge_based_nodes_data_path;
     std::string edge_based_node_weights_output_path;
     std::string node_output_path;
     std::string rtree_nodes_output_path;

include/extractor/files.hpp

@@ -2,7 +2,9 @@
 #define OSRM_EXTRACTOR_FILES_HPP
 
 #include "extractor/guidance/turn_lane_types.hpp"
+#include "extractor/node_data_container.hpp"
 #include "extractor/serialization.hpp"
+#include "extractor/turn_data_container.hpp"
 
 #include "util/coordinate.hpp"
 #include "util/packed_vector.hpp"
@@ -140,6 +142,34 @@ inline void writeTurnData(const boost::filesystem::path &path, const TurnDataT &
     serialization::write(writer, turn_data);
 }
 
+// reads .osrm.nodes_data
+template <typename NodeDataT>
+inline void readNodeData(const boost::filesystem::path &path, NodeDataT &node_data)
+{
+    static_assert(std::is_same<EdgeBasedNodeDataContainer, NodeDataT>::value ||
+                      std::is_same<EdgeBasedNodeDataView, NodeDataT>::value ||
+                      std::is_same<EdgeBasedNodeDataExternalContainer, NodeDataT>::value,
+                  "");
+    const auto fingerprint = storage::io::FileReader::VerifyFingerprint;
+    storage::io::FileReader reader{path, fingerprint};
+
+    serialization::read(reader, node_data);
+}
+
+// writes .osrm.nodes_data
+template <typename NodeDataT>
+inline void writeNodeData(const boost::filesystem::path &path, const NodeDataT &node_data)
+{
+    static_assert(std::is_same<EdgeBasedNodeDataContainer, NodeDataT>::value ||
+                      std::is_same<EdgeBasedNodeDataView, NodeDataT>::value ||
+                      std::is_same<EdgeBasedNodeDataExternalContainer, NodeDataT>::value,
+                  "");
+    const auto fingerprint = storage::io::FileWriter::GenerateFingerprint;
+    storage::io::FileWriter writer{path, fingerprint};
+
+    serialization::write(writer, node_data);
+}
+
 // reads .osrm.tls
 template <typename OffsetsT, typename MaskT>
 inline void readTurnLaneDescriptions(const boost::filesystem::path &path,

include/extractor/node_data_container.hpp

@@ -0,0 +1,83 @@
+#ifndef OSRM_EXTRACTOR_NODE_DATA_CONTAINER_HPP
+#define OSRM_EXTRACTOR_NODE_DATA_CONTAINER_HPP
+
+#include "storage/io_fwd.hpp"
+#include "storage/shared_memory_ownership.hpp"
+
+#include "util/typedefs.hpp"
+#include "util/vector_view.hpp"
+
+namespace osrm
+{
+namespace extractor
+{
+namespace detail
+{
+template <storage::Ownership Ownership> class EdgeBasedNodeDataContainerImpl;
+}
+
+namespace serialization
+{
+template <storage::Ownership Ownership>
+void read(storage::io::FileReader &reader,
+          detail::EdgeBasedNodeDataContainerImpl<Ownership> &ebn_data);
+
+template <storage::Ownership Ownership>
+void write(storage::io::FileWriter &writer,
+           const detail::EdgeBasedNodeDataContainerImpl<Ownership> &ebn_data);
+}
+
+namespace detail
+{
+template <storage::Ownership Ownership> class EdgeBasedNodeDataContainerImpl
+{
+    template <typename T> using Vector = util::ViewOrVector<T, Ownership>;
+
+  public:
+    EdgeBasedNodeDataContainerImpl() = default;
+
+    EdgeBasedNodeDataContainerImpl(Vector<GeometryID> geometry_ids,
+                                   Vector<NameID> name_ids,
+                                   Vector<extractor::TravelMode> travel_modes)
+        : geometry_ids(std::move(geometry_ids)), name_ids(std::move(name_ids)),
+          travel_modes(std::move(travel_modes))
+    {
+    }
+
+    GeometryID GetGeometryID(const NodeID id) const { return geometry_ids[id]; }
+
+    extractor::TravelMode GetTravelMode(const NodeID id) const { return travel_modes[id]; }
+
+    NameID GetNameID(const NodeID id) const { return name_ids[id]; }
+
+    // Used by EdgeBasedGraphFactory to fill data structure
+    template <typename = std::enable_if<Ownership == storage::Ownership::Container>>
+    void push_back(GeometryID geometry_id, NameID name_id, extractor::TravelMode travel_mode)
+    {
+        geometry_ids.push_back(geometry_id);
+        name_ids.push_back(name_id);
+        travel_modes.push_back(travel_mode);
+    }
+
+    friend void serialization::read<Ownership>(storage::io::FileReader &reader,
+                                               EdgeBasedNodeDataContainerImpl &ebn_data_container);
+    friend void
+    serialization::write<Ownership>(storage::io::FileWriter &writer,
+                                    const EdgeBasedNodeDataContainerImpl &ebn_data_container);
+
+  private:
+    Vector<GeometryID> geometry_ids;
+    Vector<NameID> name_ids;
+    Vector<extractor::TravelMode> travel_modes;
+};
+}
+
+using EdgeBasedNodeDataExternalContainer =
+    detail::EdgeBasedNodeDataContainerImpl<storage::Ownership::External>;
+using EdgeBasedNodeDataContainer =
+    detail::EdgeBasedNodeDataContainerImpl<storage::Ownership::Container>;
+using EdgeBasedNodeDataView = detail::EdgeBasedNodeDataContainerImpl<storage::Ownership::View>;
+}
+}
+
+#endif

include/extractor/serialization.hpp

@@ -3,6 +3,7 @@
 
 #include "extractor/datasources.hpp"
 #include "extractor/nbg_to_ebg.hpp"
+#include "extractor/node_data_container.hpp"
 #include "extractor/segment_data_container.hpp"
 #include "extractor/turn_data_container.hpp"
 
@@ -58,11 +59,9 @@ template <storage::Ownership Ownership>
 inline void read(storage::io::FileReader &reader,
                  detail::TurnDataContainerImpl<Ownership> &turn_data_container)
 {
-    storage::serialization::read(reader, turn_data_container.geometry_ids);
+    storage::serialization::read(reader, turn_data_container.node_data_ids);
-    storage::serialization::read(reader, turn_data_container.name_ids);
     storage::serialization::read(reader, turn_data_container.turn_instructions);
     storage::serialization::read(reader, turn_data_container.lane_data_ids);
-    storage::serialization::read(reader, turn_data_container.travel_modes);
     storage::serialization::read(reader, turn_data_container.entry_class_ids);
     storage::serialization::read(reader, turn_data_container.pre_turn_bearings);
     storage::serialization::read(reader, turn_data_container.post_turn_bearings);
@@ -72,15 +71,31 @@ template <storage::Ownership Ownership>
 inline void write(storage::io::FileWriter &writer,
                   const detail::TurnDataContainerImpl<Ownership> &turn_data_container)
 {
-    storage::serialization::write(writer, turn_data_container.geometry_ids);
+    storage::serialization::write(writer, turn_data_container.node_data_ids);
-    storage::serialization::write(writer, turn_data_container.name_ids);
     storage::serialization::write(writer, turn_data_container.turn_instructions);
     storage::serialization::write(writer, turn_data_container.lane_data_ids);
-    storage::serialization::write(writer, turn_data_container.travel_modes);
     storage::serialization::write(writer, turn_data_container.entry_class_ids);
     storage::serialization::write(writer, turn_data_container.pre_turn_bearings);
     storage::serialization::write(writer, turn_data_container.post_turn_bearings);
 }
+
+template <storage::Ownership Ownership>
+inline void read(storage::io::FileReader &reader,
+                 detail::EdgeBasedNodeDataContainerImpl<Ownership> &node_data_container)
+{
+    storage::serialization::read(reader, node_data_container.geometry_ids);
+    storage::serialization::read(reader, node_data_container.name_ids);
+    storage::serialization::read(reader, node_data_container.travel_modes);
+}
+
+template <storage::Ownership Ownership>
+inline void write(storage::io::FileWriter &writer,
+                  const detail::EdgeBasedNodeDataContainerImpl<Ownership> &node_data_container)
+{
+    storage::serialization::write(writer, node_data_container.geometry_ids);
+    storage::serialization::write(writer, node_data_container.name_ids);
+    storage::serialization::write(writer, node_data_container.travel_modes);
+}
 }
 }
 }

include/extractor/turn_data_container.hpp

@@ -40,29 +40,23 @@ template <storage::Ownership Ownership> class TurnDataContainerImpl
   public:
     TurnDataContainerImpl() = default;
 
-    TurnDataContainerImpl(Vector<GeometryID> geometry_ids_,
+    TurnDataContainerImpl(Vector<NodeID> node_data_ids,
-                          Vector<NameID> name_ids_,
+                          Vector<extractor::guidance::TurnInstruction> turn_instructions,
-                          Vector<extractor::guidance::TurnInstruction> turn_instructions_,
+                          Vector<LaneDataID> lane_data_ids,
-                          Vector<LaneDataID> lane_data_ids_,
+                          Vector<EntryClassID> entry_class_ids,
-                          Vector<extractor::TravelMode> travel_modes_,
+                          Vector<util::guidance::TurnBearing> pre_turn_bearings,
-                          Vector<EntryClassID> entry_class_ids_,
+                          Vector<util::guidance::TurnBearing> post_turn_bearings)
-                          Vector<util::guidance::TurnBearing> pre_turn_bearings_,
+        : node_data_ids(std::move(node_data_ids)), turn_instructions(std::move(turn_instructions)),
-                          Vector<util::guidance::TurnBearing> post_turn_bearings_)
+          lane_data_ids(std::move(lane_data_ids)), entry_class_ids(std::move(entry_class_ids)),
-        : geometry_ids(std::move(geometry_ids_)), name_ids(std::move(name_ids_)),
+          pre_turn_bearings(std::move(pre_turn_bearings)),
-          turn_instructions(std::move(turn_instructions_)),
+          post_turn_bearings(std::move(post_turn_bearings))
-          lane_data_ids(std::move(lane_data_ids_)), travel_modes(std::move(travel_modes_)),
-          entry_class_ids(std::move(entry_class_ids_)),
-          pre_turn_bearings(std::move(pre_turn_bearings_)),
-          post_turn_bearings(std::move(post_turn_bearings_))
     {
     }
 
-    GeometryID GetGeometryID(const EdgeID id) const { return geometry_ids[id]; }
+    NodeID GetNodeID(const EdgeID id) const { return node_data_ids[id]; }
 
     EntryClassID GetEntryClassID(const EdgeID id) const { return entry_class_ids[id]; }
 
-    extractor::TravelMode GetTravelMode(const EdgeID id) const { return travel_modes[id]; }
-
     util::guidance::TurnBearing GetPreTurnBearing(const EdgeID id) const
     {
         return pre_turn_bearings[id];
@@ -77,8 +71,6 @@ template <storage::Ownership Ownership> class TurnDataContainerImpl
 
     bool HasLaneData(const EdgeID id) const { return INVALID_LANE_DATAID != lane_data_ids[id]; }
 
-    NameID GetNameID(const EdgeID id) const { return name_ids[id]; }
-
     extractor::guidance::TurnInstruction GetTurnInstruction(const EdgeID id) const
     {
         return turn_instructions[id];
@@ -86,20 +78,16 @@ template <storage::Ownership Ownership> class TurnDataContainerImpl
 
     // Used by EdgeBasedGraphFactory to fill data structure
     template <typename = std::enable_if<Ownership == storage::Ownership::Container>>
-    void push_back(GeometryID geometry_id,
+    void push_back(NodeID node_data_id,
-                   NameID name_id,
                    extractor::guidance::TurnInstruction turn_instruction,
                    LaneDataID lane_data_id,
                    EntryClassID entry_class_id,
-                   extractor::TravelMode travel_mode,
                    util::guidance::TurnBearing pre_turn_bearing,
                    util::guidance::TurnBearing post_turn_bearing)
     {
-        geometry_ids.push_back(geometry_id);
+        node_data_ids.push_back(node_data_id);
-        name_ids.push_back(name_id);
         turn_instructions.push_back(turn_instruction);
         lane_data_ids.push_back(lane_data_id);
-        travel_modes.push_back(travel_mode);
         entry_class_ids.push_back(entry_class_id);
         pre_turn_bearings.push_back(pre_turn_bearing);
         post_turn_bearings.push_back(post_turn_bearing);
@@ -111,11 +99,9 @@ template <storage::Ownership Ownership> class TurnDataContainerImpl
                                                 const TurnDataContainerImpl &turn_data_container);
 
   private:
-    Vector<GeometryID> geometry_ids;
+    Vector<NodeID> node_data_ids;
-    Vector<NameID> name_ids;
     Vector<extractor::guidance::TurnInstruction> turn_instructions;
     Vector<LaneDataID> lane_data_ids;
-    Vector<extractor::TravelMode> travel_modes;
     Vector<EntryClassID> entry_class_ids;
     Vector<util::guidance::TurnBearing> pre_turn_bearings;
     Vector<util::guidance::TurnBearing> post_turn_bearings;

include/storage/shared_datatype.hpp

@@ -19,14 +19,15 @@ namespace storage
 const constexpr char CANARY[4] = {'O', 'S', 'R', 'M'};
 
 const constexpr char *block_id_to_name[] = {"NAME_CHAR_DATA",
+                                            "GEOMETRY_ID_LIST",
                                             "NAME_ID_LIST",
-                                            "VIA_NODE_LIST",
+                                            "TRAVEL_MODE_LIST",
                                             "CH_GRAPH_NODE_LIST",
                                             "CH_GRAPH_EDGE_LIST",
                                             "COORDINATE_LIST",
                                             "OSM_NODE_ID_LIST",
+                                            "EDGE_BASED_NODE_ID_LIST",
                                             "TURN_INSTRUCTION",
-                                            "TRAVEL_MODE",
                                             "ENTRY_CLASSID",
                                             "R_SEARCH_TREE",
                                             "GEOMETRIES_INDEX",
@@ -72,14 +73,15 @@ struct DataLayout
     enum BlockID
     {
         NAME_CHAR_DATA = 0,
+        GEOMETRY_ID_LIST,
         NAME_ID_LIST,
-        VIA_NODE_LIST,
+        TRAVEL_MODE_LIST,
         CH_GRAPH_NODE_LIST,
         CH_GRAPH_EDGE_LIST,
         COORDINATE_LIST,
         OSM_NODE_ID_LIST,
+        EDGE_BASED_NODE_ID_LIST,
         TURN_INSTRUCTION,
-        TRAVEL_MODE,
         ENTRY_CLASSID,
         R_SEARCH_TREE,
         GEOMETRIES_INDEX,

include/storage/storage_config.hpp

@@ -57,6 +57,7 @@ struct StorageConfig final
     boost::filesystem::path hsgr_data_path;
     boost::filesystem::path nodes_data_path;
     boost::filesystem::path edges_data_path;
+    boost::filesystem::path edge_based_nodes_data_path;
     boost::filesystem::path core_data_path;
     boost::filesystem::path geometries_path;
     boost::filesystem::path timestamp_path;

include/updater/updater_config.hpp

@@ -48,6 +48,7 @@ struct UpdaterConfig final
         turn_penalties_index_path = osrm_input_path.string() + ".turn_penalties_index";
         node_based_graph_path = osrm_input_path.string() + ".nodes";
         edge_data_path = osrm_input_path.string() + ".edges";
+        edge_based_nodes_data_path = osrm_input_path.string() + ".nodes_data";
         geometry_path = osrm_input_path.string() + ".geometry";
         rtree_leaf_path = osrm_input_path.string() + ".fileIndex";
         datasource_names_path = osrm_input_path.string() + ".datasource_names";
@@ -63,6 +64,7 @@ struct UpdaterConfig final
     std::string turn_penalties_index_path;
     std::string node_based_graph_path;
     std::string edge_data_path;
+    std::string edge_based_nodes_data_path;
     std::string geometry_path;
     std::string rtree_leaf_path;
 

src/extractor/edge_based_graph_factory.cpp

@@ -168,6 +168,7 @@ NBGToEBG EdgeBasedGraphFactory::InsertEdgeBasedNode(const NodeID node_u, const N
 }
 
 void EdgeBasedGraphFactory::Run(ScriptingEnvironment &scripting_environment,
+                                const std::string &nodes_data_filename,
                                 const std::string &turn_data_filename,
                                 const std::string &turn_lane_data_filename,
                                 const std::string &turn_weight_penalties_filename,
@@ -186,8 +187,13 @@ void EdgeBasedGraphFactory::Run(ScriptingEnvironment &scripting_environment,
     }
     TIMER_STOP(generate_nodes);
 
+    TIMER_START(generate_nodes_data);
+    auto index_nbg_edgeid_to_ebg_nodeid = GenerateEdgeExpandedNodesData(nodes_data_filename);
+    TIMER_STOP(generate_nodes_data);
+
     TIMER_START(generate_edges);
     GenerateEdgeExpandedEdges(scripting_environment,
+                              index_nbg_edgeid_to_ebg_nodeid,
                               turn_data_filename,
                               turn_lane_data_filename,
                               turn_weight_penalties_filename,
@@ -292,9 +298,48 @@ std::vector<NBGToEBG> EdgeBasedGraphFactory::GenerateEdgeExpandedNodes()
     return mapping;
 }
 
+/// Actually it also generates turn data and serializes them...
+std::unordered_map<EdgeID, NodeID>
+EdgeBasedGraphFactory::GenerateEdgeExpandedNodesData(const std::string &node_data_filename) const
+{
+    // parallel_for( blocked_range<int>( 0, n ), avg, auto_partitioner( ) );
+
+    NodeID ebg_node_id = 0;
+    std::unordered_map<EdgeID, NodeID> index;
+    EdgeBasedNodeDataExternalContainer node_data_container;
+    for (auto node_id : util::irange(0u, m_node_based_graph->GetNumberOfNodes()))
+    {
+        for (auto edge_id : m_node_based_graph->GetAdjacentEdgeRange(node_id))
+        {
+            const EdgeData &edge_data = m_node_based_graph->GetEdgeData(edge_id);
+            const bool is_encoded_forwards =
+                m_compressed_edge_container.HasZippedEntryForForwardID(edge_id);
+            const bool is_encoded_backwards =
+                m_compressed_edge_container.HasZippedEntryForReverseID(edge_id);
+            if (is_encoded_forwards || is_encoded_backwards)
+            {
+                auto geometry_id =
+                    is_encoded_forwards
+                        ? m_compressed_edge_container.GetZippedPositionForForwardID(edge_id)
+                        : m_compressed_edge_container.GetZippedPositionForReverseID(edge_id);
+
+                BOOST_ASSERT(index.find(edge_id) == index.end());
+                index.insert({edge_id, ebg_node_id++});
+                node_data_container.push_back(GeometryID{geometry_id, is_encoded_forwards},
+                                              edge_data.name_id,
+                                              edge_data.travel_mode);
+            }
+        }
+    }
+
+    files::writeNodeData(node_data_filename, node_data_container);
+    return index;
+}
+
 /// Actually it also generates turn data and serializes them...
 void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
     ScriptingEnvironment &scripting_environment,
+    const std::unordered_map<EdgeID, NodeID> &nbg_edgeid_to_ebg_nodeid,
     const std::string &turn_data_filename,
     const std::string &turn_lane_data_filename,
     const std::string &turn_weight_penalties_filename,
@@ -454,39 +499,15 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
                     BOOST_ASSERT(!edge_data2.reversed);
 
                     // the following is the core of the loop.
-                    const bool is_encoded_forwards =
+                    BOOST_ASSERT(nbg_edgeid_to_ebg_nodeid.find(incoming_edge) !=
-                        m_compressed_edge_container.HasZippedEntryForForwardID(incoming_edge);
+                                 nbg_edgeid_to_ebg_nodeid.end());
-                    const bool is_encoded_backwards =
+                    turn_data_container.push_back(
-                        m_compressed_edge_container.HasZippedEntryForReverseID(incoming_edge);
+                        nbg_edgeid_to_ebg_nodeid.find(incoming_edge)->second,
-                    BOOST_ASSERT(is_encoded_forwards || is_encoded_backwards);
+                        turn.instruction,
-                    if (is_encoded_forwards)
+                        turn.lane_data_id,
-                    {
+                        entry_class_id,
-                        turn_data_container.push_back(
+                        util::guidance::TurnBearing(intersection[0].bearing),
-                            GeometryID{m_compressed_edge_container.GetZippedPositionForForwardID(
+                        util::guidance::TurnBearing(turn.bearing));
-                                           incoming_edge),
-                                       true},
-                            edge_data1.name_id,
-                            turn.instruction,
-                            turn.lane_data_id,
-                            entry_class_id,
-                            edge_data1.travel_mode,
-                            util::guidance::TurnBearing(intersection[0].bearing),
-                            util::guidance::TurnBearing(turn.bearing));
-                    }
-                    else if (is_encoded_backwards)
-                    {
-                        turn_data_container.push_back(
-                            GeometryID{m_compressed_edge_container.GetZippedPositionForReverseID(
-                                           incoming_edge),
-                                       false},
-                            edge_data1.name_id,
-                            turn.instruction,
-                            turn.lane_data_id,
-                            entry_class_id,
-                            edge_data1.travel_mode,
-                            util::guidance::TurnBearing(intersection[0].bearing),
-                            util::guidance::TurnBearing(turn.bearing));
-                    }
 
                     // compute weight and duration penalties
                     auto is_traffic_light = m_traffic_lights.count(node_at_center_of_intersection);

src/extractor/extractor.cpp

@@ -484,6 +484,7 @@ Extractor::BuildEdgeExpandedGraph(ScriptingEnvironment &scripting_environment,
         turn_lane_map);
 
     edge_based_graph_factory.Run(scripting_environment,
+                                 config.edge_based_nodes_data_path,
                                  config.edge_output_path,
                                  config.turn_lane_data_file_name,
                                  config.turn_weight_penalties_path,

src/storage/storage.cpp

@@ -234,10 +234,7 @@ void Storage::PopulateLayout(DataLayout &layout)
         const auto number_of_original_edges = edges_file.ReadElementCount64();
 
         // note: settings this all to the same size is correct, we extract them from the same struct
-        layout.SetBlockSize<NodeID>(DataLayout::VIA_NODE_LIST, number_of_original_edges);
+        layout.SetBlockSize<NodeID>(DataLayout::EDGE_BASED_NODE_ID_LIST, number_of_original_edges);
-        layout.SetBlockSize<unsigned>(DataLayout::NAME_ID_LIST, number_of_original_edges);
-        layout.SetBlockSize<extractor::TravelMode>(DataLayout::TRAVEL_MODE,
-                                                   number_of_original_edges);
         layout.SetBlockSize<util::guidance::TurnBearing>(DataLayout::PRE_TURN_BEARING,
                                                          number_of_original_edges);
         layout.SetBlockSize<util::guidance::TurnBearing>(DataLayout::POST_TURN_BEARING,
@@ -248,6 +245,16 @@ void Storage::PopulateLayout(DataLayout &layout)
         layout.SetBlockSize<EntryClassID>(DataLayout::ENTRY_CLASSID, number_of_original_edges);
     }
 
+    {
+        io::FileReader nodes_data_file(config.edge_based_nodes_data_path,
+                                       io::FileReader::VerifyFingerprint);
+        const auto nodes_number = nodes_data_file.ReadElementCount64();
+
+        layout.SetBlockSize<NodeID>(DataLayout::GEOMETRY_ID_LIST, nodes_number);
+        layout.SetBlockSize<unsigned>(DataLayout::NAME_ID_LIST, nodes_number);
+        layout.SetBlockSize<extractor::TravelMode>(DataLayout::TRAVEL_MODE_LIST, nodes_number);
+    }
+
     if (boost::filesystem::exists(config.hsgr_data_path))
     {
         io::FileReader reader(config.hsgr_data_path, io::FileReader::VerifyFingerprint);
@@ -573,17 +580,35 @@ void Storage::PopulateData(const DataLayout &layout, char *memory_ptr)
             config.turn_lane_description_path, offsets, masks);
     }
 
+    // Load edge-based nodes data
+    {
+        auto geometry_id_list_ptr =
+            layout.GetBlockPtr<GeometryID, true>(memory_ptr, storage::DataLayout::GEOMETRY_ID_LIST);
+        util::vector_view<GeometryID> geometry_ids(
+            geometry_id_list_ptr, layout.num_entries[storage::DataLayout::GEOMETRY_ID_LIST]);
+
+        auto name_id_list_ptr =
+            layout.GetBlockPtr<NameID, true>(memory_ptr, storage::DataLayout::NAME_ID_LIST);
+        util::vector_view<NameID> name_ids(name_id_list_ptr,
+                                           layout.num_entries[storage::DataLayout::NAME_ID_LIST]);
+
+        auto travel_mode_list_ptr = layout.GetBlockPtr<extractor::TravelMode, true>(
+            memory_ptr, storage::DataLayout::TRAVEL_MODE_LIST);
+        util::vector_view<extractor::TravelMode> travel_modes(
+            travel_mode_list_ptr, layout.num_entries[storage::DataLayout::TRAVEL_MODE_LIST]);
+
+        extractor::EdgeBasedNodeDataView node_data(
+            std::move(geometry_ids), std::move(name_ids), std::move(travel_modes));
+
+        extractor::files::readNodeData(config.edge_based_nodes_data_path, node_data);
+    }
+
     // Load original edge data
     {
-        auto via_geometry_list_ptr =
+        auto node_id_list_ptr = layout.GetBlockPtr<NodeID, true>(
-            layout.GetBlockPtr<GeometryID, true>(memory_ptr, storage::DataLayout::VIA_NODE_LIST);
+            memory_ptr, storage::DataLayout::EDGE_BASED_NODE_ID_LIST);
-        util::vector_view<GeometryID> geometry_ids(
+        util::vector_view<NodeID> node_ids(
-            via_geometry_list_ptr, layout.num_entries[storage::DataLayout::VIA_NODE_LIST]);
+            node_id_list_ptr, layout.num_entries[storage::DataLayout::EDGE_BASED_NODE_ID_LIST]);
-
-        const auto travel_mode_list_ptr = layout.GetBlockPtr<extractor::TravelMode, true>(
-            memory_ptr, storage::DataLayout::TRAVEL_MODE);
-        util::vector_view<extractor::TravelMode> travel_modes(
-            travel_mode_list_ptr, layout.num_entries[storage::DataLayout::TRAVEL_MODE]);
 
         const auto lane_data_id_ptr =
             layout.GetBlockPtr<LaneDataID, true>(memory_ptr, storage::DataLayout::LANE_DATA_ID);
@@ -596,11 +621,6 @@ void Storage::PopulateData(const DataLayout &layout, char *memory_ptr)
         util::vector_view<extractor::guidance::TurnInstruction> turn_instructions(
             turn_instruction_list_ptr, layout.num_entries[storage::DataLayout::TURN_INSTRUCTION]);
 
-        const auto name_id_list_ptr =
-            layout.GetBlockPtr<NameID, true>(memory_ptr, storage::DataLayout::NAME_ID_LIST);
-        util::vector_view<NameID> name_ids(name_id_list_ptr,
-                                           layout.num_entries[storage::DataLayout::NAME_ID_LIST]);
-
         const auto entry_class_id_list_ptr =
             layout.GetBlockPtr<EntryClassID, true>(memory_ptr, storage::DataLayout::ENTRY_CLASSID);
         util::vector_view<EntryClassID> entry_class_ids(
@@ -616,11 +636,9 @@ void Storage::PopulateData(const DataLayout &layout, char *memory_ptr)
         util::vector_view<util::guidance::TurnBearing> post_turn_bearings(
             post_turn_bearing_ptr, layout.num_entries[storage::DataLayout::POST_TURN_BEARING]);
 
-        extractor::TurnDataView turn_data(std::move(geometry_ids),
+        extractor::TurnDataView turn_data(std::move(node_ids),
-                                          std::move(name_ids),
                                           std::move(turn_instructions),
                                           std::move(lane_data_ids),
-                                          std::move(travel_modes),
                                           std::move(entry_class_ids),
                                           std::move(pre_turn_bearings),
                                           std::move(post_turn_bearings));

src/storage/storage_config.cpp

@@ -27,8 +27,10 @@ bool CheckFileList(const std::vector<boost::filesystem::path> &files)
 StorageConfig::StorageConfig(const boost::filesystem::path &base)
     : ram_index_path{base.string() + ".ramIndex"}, file_index_path{base.string() + ".fileIndex"},
       hsgr_data_path{base.string() + ".hsgr"}, nodes_data_path{base.string() + ".nodes"},
-      edges_data_path{base.string() + ".edges"}, core_data_path{base.string() + ".core"},
+      edges_data_path{base.string() + ".edges"},
-      geometries_path{base.string() + ".geometry"}, timestamp_path{base.string() + ".timestamp"},
+      edge_based_nodes_data_path{base.string() + ".nodes_data"},
+      core_data_path{base.string() + ".core"}, geometries_path{base.string() + ".geometry"},
+      timestamp_path{base.string() + ".timestamp"},
       turn_weight_penalties_path{base.string() + ".turn_weight_penalties"},
       turn_duration_penalties_path{base.string() + ".turn_duration_penalties"},
       datasource_names_path{base.string() + ".datasource_names"},

src/updater/updater.cpp

@@ -76,12 +76,16 @@ void checkWeightsConsistency(
     extractor::SegmentDataContainer segment_data;
     extractor::files::readSegmentData(config.geometry_path, segment_data);
 
+    extractor::EdgeBasedNodeDataContainer node_data;
+    extractor::files::readNodeData(config.osrm_input_path.string() + ".nodes_data", node_data);
+
     extractor::TurnDataContainer turn_data;
     extractor::files::readTurnData(config.osrm_input_path.string() + ".edges", turn_data);
 
     for (auto &edge : edge_based_edge_list)
     {
-        auto geometry_id = turn_data.GetGeometryID(edge.data.turn_id);
+        const auto node_id = turn_data.GetNodeID(edge.data.turn_id);
+        const auto geometry_id = node_data.GetGeometryID(node_id);
 
         if (geometry_id.forward)
         {
@@ -457,6 +461,7 @@ Updater::LoadAndUpdateEdgeExpandedGraph(std::vector<extractor::EdgeBasedEdge> &e
         throw util::exception("Limit of 255 segment speed and turn penalty files each reached" +
                               SOURCE_REF);
 
+    extractor::EdgeBasedNodeDataContainer node_data;
     extractor::TurnDataContainer turn_data;
     extractor::SegmentDataContainer segment_data;
     extractor::ProfileProperties profile_properties;
@@ -468,6 +473,10 @@ Updater::LoadAndUpdateEdgeExpandedGraph(std::vector<extractor::EdgeBasedEdge> &e
             extractor::files::readSegmentData(config.geometry_path, segment_data);
         };
 
+        const auto load_node_data = [&] {
+            extractor::files::readNodeData(config.edge_based_nodes_data_path, node_data);
+        };
+
         const auto load_edge_data = [&] {
             extractor::files::readTurnData(config.edge_data_path, turn_data);
         };
@@ -491,7 +500,8 @@ Updater::LoadAndUpdateEdgeExpandedGraph(std::vector<extractor::EdgeBasedEdge> &e
             profile_properties = profile_properties_file.ReadOne<extractor::ProfileProperties>();
         };
 
-        tbb::parallel_invoke(load_edge_data,
+        tbb::parallel_invoke(load_node_data,
+                             load_edge_data,
                              load_segment_data,
                              load_turn_weight_penalties,
                              load_turn_duration_penalties,
@@ -524,11 +534,13 @@ Updater::LoadAndUpdateEdgeExpandedGraph(std::vector<extractor::EdgeBasedEdge> &e
         updated_segments.resize(offset + updated_turn_penalties.size());
         // we need to re-compute all edges that have updated turn penalties.
         // this marks it for re-computation
-        std::transform(
+        std::transform(updated_turn_penalties.begin(),
-            updated_turn_penalties.begin(),
+                       updated_turn_penalties.end(),
-            updated_turn_penalties.end(),
+                       updated_segments.begin() + offset,
-            updated_segments.begin() + offset,
+                       [&node_data, &turn_data](const std::uint64_t turn_id) {
-            [&turn_data](const std::uint64_t turn_id) { return turn_data.GetGeometryID(turn_id); });
+                           const auto node_id = turn_data.GetNodeID(turn_id);
+                           return node_data.GetGeometryID(node_id);
+                       });
     }
 
     tbb::parallel_sort(updated_segments.begin(),
@@ -586,7 +598,8 @@ Updater::LoadAndUpdateEdgeExpandedGraph(std::vector<extractor::EdgeBasedEdge> &e
                       });
 
     const auto update_edge = [&](extractor::EdgeBasedEdge &edge) {
-        const auto geometry_id = turn_data.GetGeometryID(edge.data.turn_id);
+        const auto node_id = turn_data.GetNodeID(edge.data.turn_id);
+        const auto geometry_id = node_data.GetGeometryID(node_id);
         auto updated_iter = std::lower_bound(updated_segments.begin(),
                                              updated_segments.end(),
                                              geometry_id,

src/util/assert.cpp

@@ -15,6 +15,7 @@ namespace
     std::cerr << "[assert][" << tid << "] " << file << ":" << line << "\nin: " << function << ": "
               << expr << "\n"
               << msg;
+
     std::terminate();
 }
 }

unit_tests/mocks/mock_datafacade.hpp

@@ -30,7 +30,7 @@ class MockBaseDataFacade : public engine::datafacade::BaseDataFacade
     }
     OSMNodeID GetOSMNodeIDOfNode(const NodeID /* id */) const override { return OSMNodeID{0}; }
     bool EdgeIsCompressed(const EdgeID /* id */) const { return false; }
-    GeometryID GetGeometryIndexForEdgeID(const EdgeID /* id */) const override
+    GeometryID GetGeometryIndex(const NodeID /* id */) const override
     {
         return GeometryID{SPECIAL_GEOMETRYID, false};
     }
@@ -85,10 +85,6 @@ class MockBaseDataFacade : public engine::datafacade::BaseDataFacade
     {
         return extractor::guidance::TurnInstruction::NO_TURN();
     }
-    extractor::TravelMode GetTravelModeForEdgeID(const EdgeID /* id */) const override
-    {
-        return TRAVEL_MODE_INACCESSIBLE;
-    }
     std::vector<RTreeLeaf> GetEdgesInBox(const util::Coordinate /* south_west */,
                                          const util::Coordinate /*north_east */) const override
     {
@@ -178,7 +174,12 @@ class MockBaseDataFacade : public engine::datafacade::BaseDataFacade
 
     unsigned GetCheckSum() const override { return 0; }
 
-    NameID GetNameIndexFromEdgeID(const EdgeID /* id */) const override { return 0; }
+    NodeID GetEdgeBasedNodeID(const NodeID /*id*/) const override { return 0; }
+    extractor::TravelMode GetTravelMode(const NodeID /* id */) const override
+    {
+        return TRAVEL_MODE_INACCESSIBLE;
+    }
+    NameID GetNameIndex(const NodeID /* id */) const override { return 0; }
 
     StringView GetNameForID(const NameID) const override final { return {}; }
     StringView GetRefForID(const NameID) const override final { return {}; }