From 30b2c1ad611176d048e78b4572b7ef5b83a16d57 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Wed, 13 Nov 2013 15:23:44 -0500 Subject: [PATCH] refactor input restrictions class --- DataStructures/Restriction.h | 52 ++-- Extractor/ExtractionContainers.cpp | 378 +++++++++++++++++------------ Extractor/ExtractionContainers.h | 36 +-- Extractor/ExtractorCallbacks.cpp | 18 +- Extractor/ExtractorCallbacks.h | 2 +- Extractor/PBFParser.cpp | 2 +- Extractor/XMLParser.cpp | 6 +- Extractor/XMLParser.h | 2 +- 8 files changed, 281 insertions(+), 215 deletions(-) diff --git a/DataStructures/Restriction.h b/DataStructures/Restriction.h index d75204a5e..7a942612f 100644 --- a/DataStructures/Restriction.h +++ b/DataStructures/Restriction.h @@ -73,13 +73,13 @@ struct TurnRestriction { } }; -struct _RawRestrictionContainer { - TurnRestriction restriction; +struct InputRestrictionContainer { EdgeID fromWay; EdgeID toWay; unsigned viaNode; + TurnRestriction restriction; - _RawRestrictionContainer( + InputRestrictionContainer( EdgeID fromWay, EdgeID toWay, NodeID vn, @@ -91,7 +91,7 @@ struct _RawRestrictionContainer { { restriction.viaNode = vn; } - _RawRestrictionContainer( + InputRestrictionContainer( bool isOnly = false ) : fromWay(UINT_MAX), @@ -101,37 +101,45 @@ struct _RawRestrictionContainer { restriction.flags.isOnly = isOnly; } - static _RawRestrictionContainer min_value() { - return _RawRestrictionContainer(0, 0, 0, 0); + static InputRestrictionContainer min_value() { + return InputRestrictionContainer(0, 0, 0, 0); } - static _RawRestrictionContainer max_value() { - return _RawRestrictionContainer(UINT_MAX, UINT_MAX, UINT_MAX, UINT_MAX); + static InputRestrictionContainer max_value() { + return InputRestrictionContainer(UINT_MAX, UINT_MAX, UINT_MAX, UINT_MAX); } }; -struct CmpRestrictionContainerByFrom : public std::binary_function<_RawRestrictionContainer, _RawRestrictionContainer, bool> { - typedef _RawRestrictionContainer value_type; - bool operator () (const _RawRestrictionContainer & a, const _RawRestrictionContainer & b) const { +struct CmpRestrictionContainerByFrom : + public std::binary_function +{ + typedef InputRestrictionContainer value_type; + inline bool operator()( + const InputRestrictionContainer & a, + const InputRestrictionContainer & b + ) const { return a.fromWay < b.fromWay; } - value_type max_value() { - return _RawRestrictionContainer::max_value(); + inline value_type max_value() const { + return InputRestrictionContainer::max_value(); } - value_type min_value() { - return _RawRestrictionContainer::min_value(); + inline value_type min_value() const { + return InputRestrictionContainer::min_value(); } }; -struct CmpRestrictionContainerByTo: public std::binary_function<_RawRestrictionContainer, _RawRestrictionContainer, bool> { - typedef _RawRestrictionContainer value_type; - bool operator () (const _RawRestrictionContainer & a, const _RawRestrictionContainer & b) const { +struct CmpRestrictionContainerByTo: public std::binary_function { + typedef InputRestrictionContainer value_type; + inline bool operator ()( + const InputRestrictionContainer & a, + const InputRestrictionContainer & b + ) const { return a.toWay < b.toWay; } - value_type max_value() { - return _RawRestrictionContainer::max_value(); + value_type max_value() const { + return InputRestrictionContainer::max_value(); } - value_type min_value() { - return _RawRestrictionContainer::min_value(); + value_type min_value() const { + return InputRestrictionContainer::min_value(); } }; diff --git a/Extractor/ExtractionContainers.cpp b/Extractor/ExtractionContainers.cpp index 063fd0abf..11b2345c6 100644 --- a/Extractor/ExtractionContainers.cpp +++ b/Extractor/ExtractionContainers.cpp @@ -29,17 +29,17 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. void ExtractionContainers::PrepareData( const std::string & output_file_name, - const std::string restrictionsFileName + const std::string & restrictions_file_name ) { try { - unsigned usedNodeCounter = 0; - unsigned usedEdgeCounter = 0; + unsigned number_of_used_nodes = 0; + unsigned number_of_used_edges = 0; double time = get_timestamp(); std::cout << "[extractor] Sorting used nodes ... " << std::flush; stxxl::sort( - usedNodeIDs.begin(), - usedNodeIDs.end(), + used_node_id_list.begin(), + used_node_id_list.end(), Cmp(), 4294967296 ); @@ -47,15 +47,15 @@ void ExtractionContainers::PrepareData( time = get_timestamp(); std::cout << "[extractor] Erasing duplicate nodes ... " << std::flush; - stxxl::vector::iterator NewEnd = std::unique ( usedNodeIDs.begin(),usedNodeIDs.end() ) ; - usedNodeIDs.resize ( NewEnd - usedNodeIDs.begin() ); + stxxl::vector::iterator NewEnd = std::unique ( used_node_id_list.begin(),used_node_id_list.end() ) ; + used_node_id_list.resize ( NewEnd - used_node_id_list.begin() ); std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl; time = get_timestamp(); std::cout << "[extractor] Sorting all nodes ... " << std::flush; stxxl::sort( - allNodes.begin(), - allNodes.end(), + all_nodes_list.begin(), + all_nodes_list.end(), CmpNodeByID(), 4294967296 ); @@ -63,41 +63,55 @@ void ExtractionContainers::PrepareData( time = get_timestamp(); std::cout << "[extractor] Sorting used ways ... " << std::flush; - stxxl::sort(wayStartEndVector.begin(), wayStartEndVector.end(), CmpWayByID(), - 4294967296); + stxxl::sort( + way_start_end_id_list.begin(), + way_start_end_id_list.end(), + CmpWayByID(), + 4294967296 + ); std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl; std::cout << "[extractor] Sorting restrctns. by from... " << std::flush; - stxxl::sort(restrictionsVector.begin(), restrictionsVector.end(), CmpRestrictionContainerByFrom(), - 4294967296); + stxxl::sort( + restrictions_list.begin(), + restrictions_list.end(), + CmpRestrictionContainerByFrom(), + 4294967296 + ); std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl; std::cout << "[extractor] Fixing restriction starts ... " << std::flush; - STXXLRestrictionsVector::iterator restrictionsIT = restrictionsVector.begin(); - STXXLWayIDStartEndVector::iterator wayStartAndEndEdgeIT = wayStartEndVector.begin(); + STXXLRestrictionsVector::iterator restrictions_iterator = restrictions_list.begin(); + STXXLWayIDStartEndVector::iterator way_start_and_end_iterator = way_start_end_id_list.begin(); - while(wayStartAndEndEdgeIT != wayStartEndVector.end() && restrictionsIT != restrictionsVector.end()) { - if(wayStartAndEndEdgeIT->wayID < restrictionsIT->fromWay){ - ++wayStartAndEndEdgeIT; + while( + way_start_and_end_iterator != way_start_end_id_list.end() && + restrictions_iterator != restrictions_list.end() + ) { + + if(way_start_and_end_iterator->wayID < restrictions_iterator->fromWay){ + ++way_start_and_end_iterator; continue; } - if(wayStartAndEndEdgeIT->wayID > restrictionsIT->fromWay) { - ++restrictionsIT; + + if(way_start_and_end_iterator->wayID > restrictions_iterator->fromWay) { + ++restrictions_iterator; continue; } - assert(wayStartAndEndEdgeIT->wayID == restrictionsIT->fromWay); - NodeID viaNode = restrictionsIT->restriction.viaNode; - if(wayStartAndEndEdgeIT->firstStart == viaNode) { - restrictionsIT->restriction.fromNode = wayStartAndEndEdgeIT->firstTarget; - } else if(wayStartAndEndEdgeIT->firstTarget == viaNode) { - restrictionsIT->restriction.fromNode = wayStartAndEndEdgeIT->firstStart; - } else if(wayStartAndEndEdgeIT->lastStart == viaNode) { - restrictionsIT->restriction.fromNode = wayStartAndEndEdgeIT->lastTarget; - } else if(wayStartAndEndEdgeIT->lastTarget == viaNode) { - restrictionsIT->restriction.fromNode = wayStartAndEndEdgeIT->lastStart; + BOOST_ASSERT(way_start_and_end_iterator->wayID == restrictions_iterator->fromWay); + NodeID via_node_id = restrictions_iterator->restriction.viaNode; + + if(way_start_and_end_iterator->firstStart == via_node_id) { + restrictions_iterator->restriction.fromNode = way_start_and_end_iterator->firstTarget; + } else if(way_start_and_end_iterator->firstTarget == via_node_id) { + restrictions_iterator->restriction.fromNode = way_start_and_end_iterator->firstStart; + } else if(way_start_and_end_iterator->lastStart == via_node_id) { + restrictions_iterator->restriction.fromNode = way_start_and_end_iterator->lastTarget; + } else if(way_start_and_end_iterator->lastTarget == via_node_id) { + restrictions_iterator->restriction.fromNode = way_start_and_end_iterator->lastStart; } - ++restrictionsIT; + ++restrictions_iterator; } std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl; @@ -105,8 +119,8 @@ void ExtractionContainers::PrepareData( std::cout << "[extractor] Sorting restrctns. by to ... " << std::flush; stxxl::sort( - restrictionsVector.begin(), - restrictionsVector.end(), + restrictions_list.begin(), + restrictions_list.end(), CmpRestrictionContainerByTo(), 4294967296 ); @@ -115,93 +129,107 @@ void ExtractionContainers::PrepareData( time = get_timestamp(); unsigned usableRestrictionsCounter(0); std::cout << "[extractor] Fixing restriction ends ... " << std::flush; - restrictionsIT = restrictionsVector.begin(); - wayStartAndEndEdgeIT = wayStartEndVector.begin(); - while(wayStartAndEndEdgeIT != wayStartEndVector.end() && restrictionsIT != restrictionsVector.end()) { - if(wayStartAndEndEdgeIT->wayID < restrictionsIT->toWay){ - ++wayStartAndEndEdgeIT; + restrictions_iterator = restrictions_list.begin(); + way_start_and_end_iterator = way_start_end_id_list.begin(); + while( + way_start_and_end_iterator != way_start_end_id_list.end() && + restrictions_iterator != restrictions_list.end() + ) { + if(way_start_and_end_iterator->wayID < restrictions_iterator->toWay){ + ++way_start_and_end_iterator; continue; } - if(wayStartAndEndEdgeIT->wayID > restrictionsIT->toWay) { - ++restrictionsIT; + if(way_start_and_end_iterator->wayID > restrictions_iterator->toWay) { + ++restrictions_iterator; continue; } - NodeID viaNode = restrictionsIT->restriction.viaNode; - if(wayStartAndEndEdgeIT->lastStart == viaNode) { - restrictionsIT->restriction.toNode = wayStartAndEndEdgeIT->lastTarget; - } else if(wayStartAndEndEdgeIT->lastTarget == viaNode) { - restrictionsIT->restriction.toNode = wayStartAndEndEdgeIT->lastStart; - } else if(wayStartAndEndEdgeIT->firstStart == viaNode) { - restrictionsIT->restriction.toNode = wayStartAndEndEdgeIT->firstTarget; - } else if(wayStartAndEndEdgeIT->firstTarget == viaNode) { - restrictionsIT->restriction.toNode = wayStartAndEndEdgeIT->firstStart; + NodeID via_node_id = restrictions_iterator->restriction.viaNode; + if(way_start_and_end_iterator->lastStart == via_node_id) { + restrictions_iterator->restriction.toNode = way_start_and_end_iterator->lastTarget; + } else if(way_start_and_end_iterator->lastTarget == via_node_id) { + restrictions_iterator->restriction.toNode = way_start_and_end_iterator->lastStart; + } else if(way_start_and_end_iterator->firstStart == via_node_id) { + restrictions_iterator->restriction.toNode = way_start_and_end_iterator->firstTarget; + } else if(way_start_and_end_iterator->firstTarget == via_node_id) { + restrictions_iterator->restriction.toNode = way_start_and_end_iterator->firstStart; } if( - UINT_MAX != restrictionsIT->restriction.fromNode && - UINT_MAX != restrictionsIT->restriction.toNode + UINT_MAX != restrictions_iterator->restriction.fromNode && + UINT_MAX != restrictions_iterator->restriction.toNode ) { ++usableRestrictionsCounter; } - ++restrictionsIT; + ++restrictions_iterator; } std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl; SimpleLogger().Write() << "usable restrictions: " << usableRestrictionsCounter; //serialize restrictions std::ofstream restrictions_out_stream; - restrictions_out_stream.open(restrictionsFileName.c_str(), std::ios::binary); + restrictions_out_stream.open(restrictions_file_name.c_str(), std::ios::binary); restrictions_out_stream.write((char*)&uuid, sizeof(UUID)); - restrictions_out_stream.write((char*)&usableRestrictionsCounter, sizeof(unsigned)); + restrictions_out_stream.write( + (char*)&usableRestrictionsCounter, + sizeof(unsigned) + ); for( - restrictionsIT = restrictionsVector.begin(); - restrictionsIT != restrictionsVector.end(); - ++restrictionsIT + restrictions_iterator = restrictions_list.begin(); + restrictions_iterator != restrictions_list.end(); + ++restrictions_iterator ) { if( - UINT_MAX != restrictionsIT->restriction.fromNode && - UINT_MAX != restrictionsIT->restriction.toNode + UINT_MAX != restrictions_iterator->restriction.fromNode && + UINT_MAX != restrictions_iterator->restriction.toNode ) { restrictions_out_stream.write( - (char *)&(restrictionsIT->restriction), + (char *)&(restrictions_iterator->restriction), sizeof(TurnRestriction) ); } } restrictions_out_stream.close(); - std::ofstream fout; - fout.open(output_file_name.c_str(), std::ios::binary); - fout.write((char*)&uuid, sizeof(UUID)); - fout.write((char*)&usedNodeCounter, sizeof(unsigned)); + std::ofstream file_out_stream; + file_out_stream.open(output_file_name.c_str(), std::ios::binary); + file_out_stream.write((char*)&uuid, sizeof(UUID)); + file_out_stream.write((char*)&number_of_used_nodes, sizeof(unsigned)); time = get_timestamp(); std::cout << "[extractor] Confirming/Writing used nodes ... " << std::flush; - STXXLNodeVector::iterator nodesIT = allNodes.begin(); - STXXLNodeIDVector::iterator usedNodeIDsIT = usedNodeIDs.begin(); - while(usedNodeIDsIT != usedNodeIDs.end() && nodesIT != allNodes.end()) { - if(*usedNodeIDsIT < nodesIT->id){ - ++usedNodeIDsIT; + //identify all used nodes by a merging step of two sorted lists + STXXLNodeVector::iterator node_iterator = all_nodes_list.begin(); + STXXLNodeIDVector::iterator node_id_iterator = used_node_id_list.begin(); + while( + node_id_iterator != used_node_id_list.end() && + node_iterator != all_nodes_list.end() + ) { + if(*node_id_iterator < node_iterator->id){ + ++node_id_iterator; continue; } - if(*usedNodeIDsIT > nodesIT->id) { - ++nodesIT; + if(*node_id_iterator > node_iterator->id) { + ++node_iterator; continue; } - if(*usedNodeIDsIT == nodesIT->id) { - fout.write((char*)&(*nodesIT), sizeof(ExternalMemoryNode)); - ++usedNodeCounter; - ++usedNodeIDsIT; - ++nodesIT; - } + BOOST_ASSERT( *node_id_iterator == node_iterator->id); + + file_out_stream.write( + (char*)&(*node_iterator), + sizeof(ExternalMemoryNode) + ); + + ++number_of_used_nodes; + ++node_id_iterator; + ++node_iterator; } std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl; std::cout << "[extractor] setting number of nodes ... " << std::flush; - std::ios::pos_type positionInFile = fout.tellp(); - fout.seekp(std::ios::beg+sizeof(UUID)); - fout.write((char*)&usedNodeCounter, sizeof(unsigned)); - fout.seekp(positionInFile); + std::ios::pos_type previous_file_position = file_out_stream.tellp(); + file_out_stream.seekp(std::ios::beg+sizeof(UUID)); + file_out_stream.write((char*)&number_of_used_nodes, sizeof(unsigned)); + file_out_stream.seekp(previous_file_position); std::cout << "ok" << std::endl; time = get_timestamp(); @@ -209,8 +237,8 @@ void ExtractionContainers::PrepareData( // Sort edges by start. std::cout << "[extractor] Sorting edges by start ... " << std::flush; stxxl::sort( - allEdges.begin(), - allEdges.end(), + all_edges_list.begin(), + all_edges_list.end(), CmpEdgeByStartID(), 4294967296 ); @@ -218,24 +246,27 @@ void ExtractionContainers::PrepareData( time = get_timestamp(); std::cout << "[extractor] Setting start coords ... " << std::flush; - fout.write((char*)&usedEdgeCounter, sizeof(unsigned)); + file_out_stream.write((char*)&number_of_used_edges, sizeof(unsigned)); // Traverse list of edges and nodes in parallel and set start coord - nodesIT = allNodes.begin(); - STXXLEdgeVector::iterator edgeIT = allEdges.begin(); - while(edgeIT != allEdges.end() && nodesIT != allNodes.end()) { - if(edgeIT->start < nodesIT->id){ - ++edgeIT; + node_iterator = all_nodes_list.begin(); + STXXLEdgeVector::iterator edge_iterator = all_edges_list.begin(); + while( + edge_iterator != all_edges_list.end() && + node_iterator != all_nodes_list.end() + ) { + if(edge_iterator->start < node_iterator->id){ + ++edge_iterator; continue; } - if(edgeIT->start > nodesIT->id) { - nodesIT++; + if(edge_iterator->start > node_iterator->id) { + node_iterator++; continue; } - if(edgeIT->start == nodesIT->id) { - edgeIT->startCoord.lat = nodesIT->lat; - edgeIT->startCoord.lon = nodesIT->lon; - ++edgeIT; - } + + BOOST_ASSERT(edge_iterator->start == node_iterator->id); + edge_iterator->startCoord.lat = node_iterator->lat; + edge_iterator->startCoord.lon = node_iterator->lon; + ++edge_iterator; } std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl; time = get_timestamp(); @@ -243,8 +274,8 @@ void ExtractionContainers::PrepareData( // Sort Edges by target std::cout << "[extractor] Sorting edges by target ... " << std::flush; stxxl::sort( - allEdges.begin(), - allEdges.end(), + all_edges_list.begin(), + all_edges_list.end(), CmpEdgeByTargetID(), 4294967296 ); @@ -253,72 +284,99 @@ void ExtractionContainers::PrepareData( std::cout << "[extractor] Setting target coords ... " << std::flush; // Traverse list of edges and nodes in parallel and set target coord - nodesIT = allNodes.begin(); - edgeIT = allEdges.begin(); + node_iterator = all_nodes_list.begin(); + edge_iterator = all_edges_list.begin(); - while(edgeIT != allEdges.end() && nodesIT != allNodes.end()) { - if(edgeIT->target < nodesIT->id){ - ++edgeIT; + while( + edge_iterator != all_edges_list.end() && + node_iterator != all_nodes_list.end() + ) { + if(edge_iterator->target < node_iterator->id){ + ++edge_iterator; continue; } - if(edgeIT->target > nodesIT->id) { - ++nodesIT; + if(edge_iterator->target > node_iterator->id) { + ++node_iterator; continue; } - if(edgeIT->target == nodesIT->id) { - if(edgeIT->startCoord.lat != INT_MIN && edgeIT->startCoord.lon != INT_MIN) { - edgeIT->targetCoord.lat = nodesIT->lat; - edgeIT->targetCoord.lon = nodesIT->lon; + BOOST_ASSERT(edge_iterator->target == node_iterator->id); + if(edge_iterator->startCoord.lat != INT_MIN && edge_iterator->startCoord.lon != INT_MIN) { + edge_iterator->targetCoord.lat = node_iterator->lat; + edge_iterator->targetCoord.lon = node_iterator->lon; - double distance = ApproximateDistance(edgeIT->startCoord.lat, edgeIT->startCoord.lon, nodesIT->lat, nodesIT->lon); - assert(edgeIT->speed != -1); - double weight = ( distance * 10. ) / (edgeIT->speed / 3.6); - int intWeight = std::max(1, (int)std::floor((edgeIT->isDurationSet ? edgeIT->speed : weight)+.5) ); - int intDist = std::max(1, (int)distance); - short zero = 0; - short one = 1; + const double distance = ApproximateDistance( + edge_iterator->startCoord.lat, + edge_iterator->startCoord.lon, + node_iterator->lat, + node_iterator->lon + ); - fout.write((char*)&edgeIT->start, sizeof(unsigned)); - fout.write((char*)&edgeIT->target, sizeof(unsigned)); - fout.write((char*)&intDist, sizeof(int)); - switch(edgeIT->direction) { - case ExtractionWay::notSure: - fout.write((char*)&zero, sizeof(short)); - break; - case ExtractionWay::oneway: - fout.write((char*)&one, sizeof(short)); - break; - case ExtractionWay::bidirectional: - fout.write((char*)&zero, sizeof(short)); + BOOST_ASSERT(edge_iterator->speed != -1); + const double weight = ( distance * 10. ) / (edge_iterator->speed / 3.6); + int integer_weight = std::max( 1, (int)std::floor((edge_iterator->isDurationSet ? edge_iterator->speed : weight)+.5) ); + int integer_distance = std::max( 1, (int)distance ); + short zero = 0; + short one = 1; - break; - case ExtractionWay::opposite: - fout.write((char*)&one, sizeof(short)); - break; - default: - std::cerr << "[error] edge with no direction: " << edgeIT->direction << std::endl; - assert(false); - break; - } - fout.write((char*)&intWeight, sizeof(int)); - assert(edgeIT->type >= 0); - fout.write((char*)&edgeIT->type, sizeof(short)); - fout.write((char*)&edgeIT->nameID, sizeof(unsigned)); - fout.write((char*)&edgeIT->isRoundabout, sizeof(bool)); - fout.write((char*)&edgeIT->ignoreInGrid, sizeof(bool)); - fout.write((char*)&edgeIT->isAccessRestricted, sizeof(bool)); - fout.write((char*)&edgeIT->isContraFlow, sizeof(bool)); - ++usedEdgeCounter; + file_out_stream.write((char*)&edge_iterator->start, sizeof(unsigned)); + file_out_stream.write((char*)&edge_iterator->target, sizeof(unsigned)); + file_out_stream.write((char*)&integer_distance, sizeof(int)); + switch(edge_iterator->direction) { + case ExtractionWay::notSure: + file_out_stream.write((char*)&zero, sizeof(short)); + break; + case ExtractionWay::oneway: + file_out_stream.write((char*)&one, sizeof(short)); + break; + case ExtractionWay::bidirectional: + file_out_stream.write((char*)&zero, sizeof(short)); + + break; + case ExtractionWay::opposite: + file_out_stream.write((char*)&one, sizeof(short)); + break; + default: + throw OSRMException("edge has broken direction"); + break; } - ++edgeIT; + file_out_stream.write( + (char*)&integer_weight, sizeof(int) + ); + BOOST_ASSERT(edge_iterator->type >= 0); + file_out_stream.write( + (char*)&edge_iterator->type, + sizeof(short) + ); + file_out_stream.write( + (char*)&edge_iterator->nameID, + sizeof(unsigned) + ); + file_out_stream.write( + (char*)&edge_iterator->isRoundabout, + sizeof(bool) + ); + file_out_stream.write( + (char*)&edge_iterator->ignoreInGrid, + sizeof(bool) + ); + file_out_stream.write( + (char*)&edge_iterator->isAccessRestricted, + sizeof(bool) + ); + file_out_stream.write( + (char*)&edge_iterator->isContraFlow, + sizeof(bool) + ); + ++number_of_used_edges; } + ++edge_iterator; } std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl; std::cout << "[extractor] setting number of edges ... " << std::flush; - fout.seekp(positionInFile); - fout.write((char*)&usedEdgeCounter, sizeof(unsigned)); - fout.close(); + file_out_stream.seekp(previous_file_position); + file_out_stream.write((char*)&number_of_used_edges, sizeof(unsigned)); + file_out_stream.close(); std::cout << "ok" << std::endl; time = get_timestamp(); @@ -335,8 +393,8 @@ void ExtractionContainers::PrepareData( //compute total number of chars unsigned total_number_of_chars = 0; - BOOST_FOREACH(const std::string & str, name_list) { - total_number_of_chars += strlen(str.c_str()); + BOOST_FOREACH(const std::string & temp_string, name_list) { + total_number_of_chars += temp_string.length(); } //write total number of chars name_file_stream.write( @@ -345,12 +403,12 @@ void ExtractionContainers::PrepareData( ); //write prefixe sums unsigned name_lengths_prefix_sum = 0; - BOOST_FOREACH(const std::string & str, name_list) { + BOOST_FOREACH(const std::string & temp_string, name_list) { name_file_stream.write( (char *)&(name_lengths_prefix_sum), sizeof(unsigned) ); - name_lengths_prefix_sum += strlen(str.c_str()); + name_lengths_prefix_sum += temp_string.length(); } //duplicate on purpose! name_file_stream.write( @@ -359,16 +417,16 @@ void ExtractionContainers::PrepareData( ); //write all chars consecutively - BOOST_FOREACH(const std::string & str, name_list) { - const unsigned lengthOfRawString = strlen(str.c_str()); - name_file_stream.write(str.c_str(), lengthOfRawString); + BOOST_FOREACH(const std::string & temp_string, name_list) { + const unsigned string_length = temp_string.length(); + name_file_stream.write(temp_string.c_str(), string_length); } name_file_stream.close(); std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl; - SimpleLogger().Write() << - "Processed " << usedNodeCounter << " nodes and " << usedEdgeCounter << " edges"; - + SimpleLogger().Write() << "Processed " << + number_of_used_nodes << " nodes and " << + number_of_used_edges << " edges"; } catch ( const std::exception& e ) { std::cerr << "Caught Execption:" << e.what() << std::endl; diff --git a/Extractor/ExtractionContainers.h b/Extractor/ExtractionContainers.h index 389de0d76..254c358da 100644 --- a/Extractor/ExtractionContainers.h +++ b/Extractor/ExtractionContainers.h @@ -33,6 +33,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "../Util/TimingUtil.h" #include "../Util/UUID.h" +#include #include #include #include @@ -42,20 +43,19 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. class ExtractionContainers { public: - typedef stxxl::vector STXXLNodeIDVector; - typedef stxxl::vector STXXLNodeVector; - typedef stxxl::vector STXXLEdgeVector; - typedef stxxl::vector STXXLStringVector; - typedef stxxl::vector<_RawRestrictionContainer> STXXLRestrictionsVector; - typedef stxxl::vector<_WayIDStartAndEndEdge> STXXLWayIDStartEndVector; + typedef stxxl::vector STXXLNodeIDVector; + typedef stxxl::vector STXXLNodeVector; + typedef stxxl::vector STXXLEdgeVector; + typedef stxxl::vector STXXLStringVector; + typedef stxxl::vector STXXLRestrictionsVector; + typedef stxxl::vector<_WayIDStartAndEndEdge> STXXLWayIDStartEndVector; - - STXXLNodeIDVector usedNodeIDs; - STXXLNodeVector allNodes; - STXXLEdgeVector allEdges; + STXXLNodeIDVector used_node_id_list; + STXXLNodeVector all_nodes_list; + STXXLEdgeVector all_edges_list; STXXLStringVector name_list; - STXXLRestrictionsVector restrictionsVector; - STXXLWayIDStartEndVector wayStartEndVector; + STXXLRestrictionsVector restrictions_list; + STXXLWayIDStartEndVector way_start_end_id_list; const UUID uuid; ExtractionContainers() { @@ -65,17 +65,17 @@ public: } virtual ~ExtractionContainers() { - usedNodeIDs.clear(); - allNodes.clear(); - allEdges.clear(); + used_node_id_list.clear(); + all_nodes_list.clear(); + all_edges_list.clear(); name_list.clear(); - restrictionsVector.clear(); - wayStartEndVector.clear(); + restrictions_list.clear(); + way_start_end_id_list.clear(); } void PrepareData( const std::string & output_file_name, - const std::string restrictionsFileName + const std::string & restrictions_file_name ); }; diff --git a/Extractor/ExtractorCallbacks.cpp b/Extractor/ExtractorCallbacks.cpp index d9750092e..8ac71f7da 100644 --- a/Extractor/ExtractorCallbacks.cpp +++ b/Extractor/ExtractorCallbacks.cpp @@ -38,12 +38,12 @@ ExtractorCallbacks::~ExtractorCallbacks() { } /** warning: caller needs to take care of synchronization! */ void ExtractorCallbacks::nodeFunction(const ExternalMemoryNode &n) { if(n.lat <= 85*COORDINATE_PRECISION && n.lat >= -85*COORDINATE_PRECISION) { - externalMemory->allNodes.push_back(n); + externalMemory->all_nodes_list.push_back(n); } } -bool ExtractorCallbacks::restrictionFunction(const _RawRestrictionContainer &r) { - externalMemory->restrictionsVector.push_back(r); +bool ExtractorCallbacks::restrictionFunction(const InputRestrictionContainer &r) { + externalMemory->restrictions_list.push_back(r); return true; } @@ -86,7 +86,7 @@ void ExtractorCallbacks::wayFunction(ExtractionWay &parsed_way) { const bool split_bidirectional_edge = (parsed_way.backward_speed > 0) && (parsed_way.speed != parsed_way.backward_speed); for(std::vector< NodeID >::size_type n = 0; n < parsed_way.path.size()-1; ++n) { - externalMemory->allEdges.push_back( + externalMemory->all_edges_list.push_back( InternalExtractorEdge(parsed_way.path[n], parsed_way.path[n+1], parsed_way.type, @@ -99,17 +99,17 @@ void ExtractorCallbacks::wayFunction(ExtractionWay &parsed_way) { parsed_way.isAccessRestricted ) ); - externalMemory->usedNodeIDs.push_back(parsed_way.path[n]); + externalMemory->used_node_id_list.push_back(parsed_way.path[n]); } - externalMemory->usedNodeIDs.push_back(parsed_way.path.back()); + externalMemory->used_node_id_list.push_back(parsed_way.path.back()); //The following information is needed to identify start and end segments of restrictions - externalMemory->wayStartEndVector.push_back(_WayIDStartAndEndEdge(parsed_way.id, parsed_way.path[0], parsed_way.path[1], parsed_way.path[parsed_way.path.size()-2], parsed_way.path.back())); + externalMemory->way_start_end_id_list.push_back(_WayIDStartAndEndEdge(parsed_way.id, parsed_way.path[0], parsed_way.path[1], parsed_way.path[parsed_way.path.size()-2], parsed_way.path.back())); if(split_bidirectional_edge) { //Only true if the way should be split std::reverse( parsed_way.path.begin(), parsed_way.path.end() ); for(std::vector< NodeID >::size_type n = 0; n < parsed_way.path.size()-1; ++n) { - externalMemory->allEdges.push_back( + externalMemory->all_edges_list.push_back( InternalExtractorEdge(parsed_way.path[n], parsed_way.path[n+1], parsed_way.type, @@ -124,7 +124,7 @@ void ExtractorCallbacks::wayFunction(ExtractionWay &parsed_way) { ) ); } - externalMemory->wayStartEndVector.push_back(_WayIDStartAndEndEdge(parsed_way.id, parsed_way.path[0], parsed_way.path[1], parsed_way.path[parsed_way.path.size()-2], parsed_way.path.back())); + externalMemory->way_start_end_id_list.push_back(_WayIDStartAndEndEdge(parsed_way.id, parsed_way.path[0], parsed_way.path[1], parsed_way.path[parsed_way.path.size()-2], parsed_way.path.back())); } } } diff --git a/Extractor/ExtractorCallbacks.h b/Extractor/ExtractorCallbacks.h index 91b22d4ff..e95505762 100644 --- a/Extractor/ExtractorCallbacks.h +++ b/Extractor/ExtractorCallbacks.h @@ -57,7 +57,7 @@ public: /** warning: caller needs to take care of synchronization! */ void nodeFunction(const ExternalMemoryNode &n); - bool restrictionFunction(const _RawRestrictionContainer &r); + bool restrictionFunction(const InputRestrictionContainer &r); /** warning: caller needs to take care of synchronization! */ void wayFunction(ExtractionWay &w); diff --git a/Extractor/PBFParser.cpp b/Extractor/PBFParser.cpp index ab5e17413..96c71603f 100644 --- a/Extractor/PBFParser.cpp +++ b/Extractor/PBFParser.cpp @@ -248,7 +248,7 @@ inline void PBFParser::parseRelation(_ThreadData * threadData) { if(isRestriction) { int64_t lastRef = 0; - _RawRestrictionContainer currentRestrictionContainer(isOnlyRestriction); + InputRestrictionContainer currentRestrictionContainer(isOnlyRestriction); for( int rolesIndex = 0, last_role = inputRelation.roles_sid_size(); rolesIndex < last_role; diff --git a/Extractor/XMLParser.cpp b/Extractor/XMLParser.cpp index 551bf7f34..c67e5c177 100644 --- a/Extractor/XMLParser.cpp +++ b/Extractor/XMLParser.cpp @@ -74,7 +74,7 @@ bool XMLParser::Parse() { } if( use_turn_restrictions ) { if ( xmlStrEqual( currentName, ( const xmlChar* ) "relation" ) == 1 ) { - _RawRestrictionContainer r = _ReadXMLRestriction(); + InputRestrictionContainer r = _ReadXMLRestriction(); if(r.fromWay != UINT_MAX) { if(!extractor_callbacks->restrictionFunction(r)) { std::cerr << "[XMLParser] restriction not parsed" << std::endl; @@ -87,8 +87,8 @@ bool XMLParser::Parse() { return true; } -_RawRestrictionContainer XMLParser::_ReadXMLRestriction() { - _RawRestrictionContainer restriction; +InputRestrictionContainer XMLParser::_ReadXMLRestriction() { + InputRestrictionContainer restriction; std::string except_tag_string; if ( xmlTextReaderIsEmptyElement( inputReader ) != 1 ) { diff --git a/Extractor/XMLParser.h b/Extractor/XMLParser.h index b6d8613f9..99e72b69e 100644 --- a/Extractor/XMLParser.h +++ b/Extractor/XMLParser.h @@ -44,7 +44,7 @@ public: bool Parse(); private: - _RawRestrictionContainer _ReadXMLRestriction(); + InputRestrictionContainer _ReadXMLRestriction(); ExtractionWay _ReadXMLWay(); ImportNode _ReadXMLNode(); xmlTextReaderPtr inputReader;