Fix platform-independent data in data files

src/extractor/edge_based_graph_factory.cpp

@@ -83,7 +83,7 @@ void EdgeBasedGraphFactory::GetEdgeBasedNodeWeights(std::vector<EdgeWeight> &out
     swap(m_edge_based_node_weights, output_node_weights);
 }
 
-unsigned EdgeBasedGraphFactory::GetHighestEdgeID() { return m_max_edge_id; }
+EdgeID EdgeBasedGraphFactory::GetHighestEdgeID() { return m_max_edge_id; }
 
 void EdgeBasedGraphFactory::InsertEdgeBasedNode(const NodeID node_u, const NodeID node_v)
 {

src/extractor/extraction_containers.cpp

@@ -167,7 +167,7 @@ void ExtractionContainers::PrepareNodes()
     // handle > uint32_t actual usable nodes.  This should be OK for a while
     // because we usually route on a *lot* less than 2^32 of the OSM
     // graph nodes.
-    std::size_t internal_id = 0;
+    std::uint64_t internal_id = 0;
 
     // compute the intersection of nodes that were referenced and nodes we actually have
     while (node_iter != all_nodes_list_end && ref_iter != used_node_id_list_end)
@@ -479,11 +479,11 @@ void ExtractionContainers::WriteEdges(std::ofstream &file_out_stream) const
     std::cout << "[extractor] Writing used edges       ... " << std::flush;
     TIMER_START(write_edges);
     // Traverse list of edges and nodes in parallel and set target coord
-    std::size_t used_edges_counter = 0;
-    unsigned used_edges_counter_buffer = 0;
+    std::uint64_t used_edges_counter = 0;
+    std::uint32_t used_edges_counter_buffer = 0;
 
     auto start_position = file_out_stream.tellp();
-    file_out_stream.write((char *)&used_edges_counter_buffer, sizeof(unsigned));
+    file_out_stream.write((char *)&used_edges_counter_buffer, sizeof(used_edges_counter_buffer));
 
     for (const auto &edge : all_edges_list)
     {
@@ -508,10 +508,10 @@ void ExtractionContainers::WriteEdges(std::ofstream &file_out_stream) const
 
     std::cout << "[extractor] setting number of edges   ... " << std::flush;
 
-    used_edges_counter_buffer = boost::numeric_cast<unsigned>(used_edges_counter);
+    used_edges_counter_buffer = boost::numeric_cast<std::uint32_t>(used_edges_counter);
 
     file_out_stream.seekp(start_position);
-    file_out_stream.write((char *)&used_edges_counter_buffer, sizeof(unsigned));
+    file_out_stream.write((char *)&used_edges_counter_buffer, sizeof(used_edges_counter_buffer));
     std::cout << "ok" << std::endl;
 
     util::SimpleLogger().Write() << "Processed " << used_edges_counter << " edges";

src/extractor/extractor.cpp

@@ -475,7 +475,7 @@ Extractor::LoadNodeBasedGraph(std::unordered_set<NodeID> &barrier_nodes,
 /**
  \brief Building an edge-expanded graph from node-based input and turn restrictions
 */
-std::pair<std::size_t, std::size_t>
+std::pair<std::size_t, EdgeID>
 Extractor::BuildEdgeExpandedGraph(lua_State *lua_state,
                                   const ProfileProperties &profile_properties,
                                   std::vector<QueryNode> &internal_to_external_node_map,
@@ -600,7 +600,7 @@ void Extractor::BuildRTree(std::vector<EdgeBasedNode> node_based_edge_list,
 
 void Extractor::WriteEdgeBasedGraph(
     std::string const &output_file_filename,
-    size_t const max_edge_id,
+    EdgeID const max_edge_id,
     util::DeallocatingVector<EdgeBasedEdge> const &edge_based_edge_list)
 {
 
@@ -613,9 +613,9 @@ void Extractor::WriteEdgeBasedGraph(
                                  << std::flush;
     TIMER_START(write_edges);
 
-    size_t number_of_used_edges = edge_based_edge_list.size();
-    file_out_stream.write((char *)&number_of_used_edges, sizeof(size_t));
-    file_out_stream.write((char *)&max_edge_id, sizeof(size_t));
+    std::uint64_t number_of_used_edges = edge_based_edge_list.size();
+    file_out_stream.write((char *)&number_of_used_edges, sizeof(number_of_used_edges));
+    file_out_stream.write((char *)&max_edge_id, sizeof(max_edge_id));
 
     for (const auto &edge : edge_based_edge_list)
     {