Don't use bool flags on ExternalMemoryNode because they blow up the struct

include/engine/datafacade/datafacade_base.hpp

@@ -10,10 +10,10 @@
 
 #include "extractor/class_data.hpp"
 #include "extractor/edge_based_node_segment.hpp"
-#include "extractor/external_memory_node.hpp"
 #include "extractor/guidance/turn_instruction.hpp"
 #include "extractor/guidance/turn_lane_types.hpp"
 #include "extractor/original_edge_data.hpp"
+#include "extractor/query_node.hpp"
 #include "extractor/travel_mode.hpp"
 
 #include "util/exception.hpp"

include/engine/engine.hpp

@@ -11,7 +11,6 @@
 #include "engine/datafacade/contiguous_block_allocator.hpp"
 #include "engine/datafacade_provider.hpp"
 #include "engine/engine_config.hpp"
-#include "engine/engine_config.hpp"
 #include "engine/plugins/match.hpp"
 #include "engine/plugins/nearest.hpp"
 #include "engine/plugins/table.hpp"

include/extractor/external_memory_node.hpp

@@ -1,60 +0,0 @@
-#ifndef EXTERNAL_MEMORY_NODE_HPP_
-#define EXTERNAL_MEMORY_NODE_HPP_
-
-#include "extractor/query_node.hpp"
-
-#include "util/typedefs.hpp"
-
-#include <cstdint>
-
-namespace osrm
-{
-namespace extractor
-{
-
-struct ExternalMemoryNode : QueryNode
-{
-    ExternalMemoryNode(const util::FixedLongitude lon_,
-                       const util::FixedLatitude lat_,
-                       OSMNodeID node_id_,
-                       bool barrier_,
-                       bool traffic_lights_)
-        : QueryNode(lon_, lat_, node_id_), barrier(barrier_), traffic_lights(traffic_lights_)
-    {
-    }
-
-    ExternalMemoryNode() : barrier(false), traffic_lights(false) {}
-
-    static ExternalMemoryNode min_value()
-    {
-        return ExternalMemoryNode(
-            util::FixedLongitude{0}, util::FixedLatitude{0}, MIN_OSM_NODEID, false, false);
-    }
-
-    static ExternalMemoryNode max_value()
-    {
-        return ExternalMemoryNode(util::FixedLongitude{std::numeric_limits<std::int32_t>::max()},
-                                  util::FixedLatitude{std::numeric_limits<std::int32_t>::max()},
-                                  MAX_OSM_NODEID,
-                                  false,
-                                  false);
-    }
-
-    bool barrier;
-    bool traffic_lights;
-};
-
-struct ExternalMemoryNodeSTXXLCompare
-{
-    using value_type = ExternalMemoryNode;
-    value_type max_value() { return value_type::max_value(); }
-    value_type min_value() { return value_type::min_value(); }
-    bool operator()(const value_type &left, const value_type &right) const
-    {
-        return left.node_id < right.node_id;
-    }
-};
-}
-}
-
-#endif /* EXTERNAL_MEMORY_NODE_HPP_ */

include/extractor/extraction_containers.hpp

@@ -1,10 +1,10 @@
 #ifndef EXTRACTION_CONTAINERS_HPP
 #define EXTRACTION_CONTAINERS_HPP
 
-#include "extractor/external_memory_node.hpp"
 #include "extractor/first_and_last_segment_of_way.hpp"
 #include "extractor/guidance/turn_lane_types.hpp"
 #include "extractor/internal_extractor_edge.hpp"
+#include "extractor/query_node.hpp"
 #include "extractor/restriction.hpp"
 #include "extractor/scripting_environment.hpp"
 
@@ -46,13 +46,15 @@ class ExtractionContainers
 
   public:
     using STXXLNodeIDVector = stxxl::vector<OSMNodeID>;
-    using STXXLNodeVector = stxxl::vector<ExternalMemoryNode>;
+    using STXXLNodeVector = stxxl::vector<QueryNode>;
     using STXXLEdgeVector = stxxl::vector<InternalExtractorEdge>;
     using RestrictionsVector = std::vector<InputRestrictionContainer>;
     using STXXLWayIDStartEndVector = stxxl::vector<FirstAndLastSegmentOfWay>;
     using STXXLNameCharData = stxxl::vector<unsigned char>;
     using STXXLNameOffsets = stxxl::vector<unsigned>;
 
+    std::vector<OSMNodeID> barrier_nodes;
+    std::vector<OSMNodeID> traffic_lights;
     STXXLNodeIDVector used_node_id_list;
     STXXLNodeVector all_nodes_list;
     STXXLEdgeVector all_edges_list;

include/extractor/first_and_last_segment_of_way.hpp

@@ -1,7 +1,6 @@
 #ifndef FIRST_AND_LAST_SEGMENT_OF_WAY_HPP
 #define FIRST_AND_LAST_SEGMENT_OF_WAY_HPP
 
-#include "extractor/external_memory_node.hpp"
 #include "util/typedefs.hpp"
 
 #include <limits>

include/storage/io.hpp

@@ -14,7 +14,6 @@
 
 #include <cerrno>
 #include <cstring>
-#include <cstring>
 #include <tuple>
 #include <type_traits>
 

include/util/geojson_debug_policy_toolkit.hpp

@@ -1,7 +1,7 @@
 #ifndef OSRM_GEOJSON_DEBUG_POLICY_TOOLKIT_HPP
 #define OSRM_GEOJSON_DEBUG_POLICY_TOOLKIT_HPP
 
-#include "extractor/external_memory_node.hpp"
+#include "extractor/query_node.hpp"
 #include "util/coordinate.hpp"
 #include "util/json_container.hpp"
 

include/util/graph_loader.hpp

@@ -1,7 +1,6 @@
 #ifndef GRAPH_LOADER_HPP
 #define GRAPH_LOADER_HPP
 
-#include "extractor/external_memory_node.hpp"
 #include "extractor/node_based_edge.hpp"
 #include "extractor/packed_osm_ids.hpp"
 #include "extractor/query_node.hpp"
@@ -50,7 +49,7 @@ NodeID loadNodesFromFile(storage::io::FileReader &file_reader,
     coordinates.resize(number_of_nodes);
     osm_node_ids.reserve(number_of_nodes);
 
-    extractor::ExternalMemoryNode current_node;
+    extractor::QueryNode current_node;
     for (NodeID i = 0; i < number_of_nodes; ++i)
     {
         file_reader.ReadInto(&current_node, 1);
@@ -58,18 +57,18 @@ NodeID loadNodesFromFile(storage::io::FileReader &file_reader,
         coordinates[i].lon = current_node.lon;
         coordinates[i].lat = current_node.lat;
         osm_node_ids.push_back(current_node.node_id);
+    }
 
-        if (current_node.barrier)
-        {
-            *barriers = i;
-            ++barriers;
-        }
+    auto num_barriers = file_reader.ReadElementCount64();
+    for (auto index = 0UL; index < num_barriers; ++index)
+    {
+        *barriers++ = file_reader.ReadOne<NodeID>();
+    }
 
-        if (current_node.traffic_lights)
-        {
-            *traffic_signals = i;
-            ++traffic_signals;
-        }
+    auto num_lights = file_reader.ReadElementCount64();
+    for (auto index = 0UL; index < num_lights; ++index)
+    {
+        *traffic_signals++ = file_reader.ReadOne<NodeID>();
     }
 
     return number_of_nodes;