From 44077cb00785c8940270e470b59b9a51e5a0f83a Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Wed, 26 Mar 2014 15:14:39 +0100 Subject: [PATCH] refactor and streamline use of TurnInstructionsClass members --- Contractor/EdgeBasedGraphFactory.cpp | 22 +++---- DataStructures/TurnInstructions.h | 2 - Descriptors/DescriptionFactory.h | 4 +- Descriptors/JSONDescriptor.h | 82 ++++++++++++++------------ Server/DataStructures/SharedDataType.h | 60 +++++++++---------- 5 files changed, 87 insertions(+), 83 deletions(-) diff --git a/Contractor/EdgeBasedGraphFactory.cpp b/Contractor/EdgeBasedGraphFactory.cpp index 680f8ce2a..89cf6d63b 100644 --- a/Contractor/EdgeBasedGraphFactory.cpp +++ b/Contractor/EdgeBasedGraphFactory.cpp @@ -826,7 +826,7 @@ void EdgeBasedGraphFactory::Run( } const int turn_penalty = GetTurnPenalty(u, v, w, lua_state); TurnInstruction turn_instruction = AnalyzeTurn(u, v, w); - if(turn_instruction == TurnInstructions.UTurn){ + if(turn_instruction == TurnInstructionsClass::UTurn){ distance += speed_profile.uTurnPenalty; } distance += turn_penalty; @@ -934,7 +934,7 @@ TurnInstruction EdgeBasedGraphFactory::AnalyzeTurn( const NodeID w ) const { if(u == w) { - return TurnInstructions.UTurn; + return TurnInstructionsClass::UTurn; } const EdgeIterator edge1 = m_node_based_graph->FindEdge(u, v); @@ -944,10 +944,10 @@ TurnInstruction EdgeBasedGraphFactory::AnalyzeTurn( const EdgeData & data2 = m_node_based_graph->GetEdgeData(edge2); if(!data1.contraFlow && data2.contraFlow) { - return TurnInstructions.EnterAgainstAllowedDirection; + return TurnInstructionsClass::EnterAgainstAllowedDirection; } if(data1.contraFlow && !data2.contraFlow) { - return TurnInstructions.LeaveAgainstAllowedDirection; + return TurnInstructionsClass::LeaveAgainstAllowedDirection; } //roundabouts need to be handled explicitely @@ -955,19 +955,19 @@ TurnInstruction EdgeBasedGraphFactory::AnalyzeTurn( //Is a turn possible? If yes, we stay on the roundabout! if( 1 == m_node_based_graph->GetOutDegree(v) ) { //No turn possible. - return TurnInstructions.NoTurn; + return TurnInstructionsClass::NoTurn; } - return TurnInstructions.StayOnRoundAbout; + return TurnInstructionsClass::StayOnRoundAbout; } //Does turn start or end on roundabout? if(data1.roundabout || data2.roundabout) { //We are entering the roundabout if( (!data1.roundabout) && data2.roundabout) { - return TurnInstructions.EnterRoundAbout; + return TurnInstructionsClass::EnterRoundAbout; } //We are leaving the roundabout if(data1.roundabout && (!data2.roundabout) ) { - return TurnInstructions.LeaveRoundAbout; + return TurnInstructionsClass::LeaveRoundAbout; } } @@ -977,9 +977,9 @@ TurnInstruction EdgeBasedGraphFactory::AnalyzeTurn( //TODO: Here we should also do a small graph exploration to check for // more complex situations if( 0 != data1.nameID ) { - return TurnInstructions.NoTurn; + return TurnInstructionsClass::NoTurn; } else if (m_node_based_graph->GetOutDegree(v) <= 2) { - return TurnInstructions.NoTurn; + return TurnInstructionsClass::NoTurn; } } @@ -988,7 +988,7 @@ TurnInstruction EdgeBasedGraphFactory::AnalyzeTurn( m_node_info_list[v], m_node_info_list[w] ); - return TurnInstructions.GetTurnDirectionOfInstruction(angle); + return TurnInstructionsClass::GetTurnDirectionOfInstruction(angle); } unsigned EdgeBasedGraphFactory::GetNumberOfEdgeBasedNodes() const { diff --git a/DataStructures/TurnInstructions.h b/DataStructures/TurnInstructions.h index 4a80ccfc2..cb60a32f5 100644 --- a/DataStructures/TurnInstructions.h +++ b/DataStructures/TurnInstructions.h @@ -92,6 +92,4 @@ struct TurnInstructionsClass : boost::noncopyable { }; -static TurnInstructionsClass TurnInstructions; - #endif /* TURNINSTRUCTIONS_H_ */ diff --git a/Descriptors/DescriptionFactory.h b/Descriptors/DescriptionFactory.h index 12d0213b2..3b3a8432e 100644 --- a/Descriptors/DescriptionFactory.h +++ b/Descriptors/DescriptionFactory.h @@ -179,7 +179,7 @@ public: if(pathDescription.size() > 2){ pathDescription.pop_back(); pathDescription.back().necessary = true; - pathDescription.back().turn_instruction = TurnInstructions.NoTurn; + pathDescription.back().turn_instruction = TurnInstructionsClass::NoTurn; target_phantom.name_id = (pathDescription.end()-2)->name_id; } } else { @@ -188,7 +188,7 @@ public: if(std::numeric_limits::epsilon() > pathDescription[0].length) { if(pathDescription.size() > 2) { pathDescription.erase(pathDescription.begin()); - pathDescription[0].turn_instruction = TurnInstructions.HeadOn; + pathDescription[0].turn_instruction = TurnInstructionsClass::HeadOn; pathDescription[0].necessary = true; start_phantom.name_id = pathDescription[0].name_id; } diff --git a/Descriptors/JSONDescriptor.h b/Descriptors/JSONDescriptor.h index 5415cc5ed..cd5cebc99 100644 --- a/Descriptors/JSONDescriptor.h +++ b/Descriptors/JSONDescriptor.h @@ -44,6 +44,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. template class JSONDescriptor : public BaseDescriptor { private: + // TODO: initalize in c'tor DataFacadeT * facade; DescriptorConfig config; DescriptionFactory description_factory; @@ -59,7 +60,7 @@ private: int start_index; int name_id; int leave_at_exit; - } roundAbout; + } round_about; struct Segment { Segment() : name_id(-1), length(-1), position(-1) {} @@ -419,56 +420,61 @@ public: //Segment information has following format: //["instruction","streetname",length,position,time,"length","earth_direction",azimuth] //Example: ["Turn left","High Street",200,4,10,"200m","NE",22.5] - //See also: http://developers.cloudmade.com/wiki/navengine/JSON_format - unsigned prefixSumOfNecessarySegments = 0; - roundAbout.leave_at_exit = 0; - roundAbout.name_id = 0; - std::string tmpDist, tmpLength, tmpDuration, tmpBearing, tmpInstruction; + unsigned necessary_segments_running_index = 0; + round_about.leave_at_exit = 0; + round_about.name_id = 0; + std::string temp_dist, temp_length, temp_duration, temp_bearing, temp_instruction; + //Fetch data from Factory and generate a string from it. BOOST_FOREACH(const SegmentInformation & segment, description_factory.pathDescription) { - TurnInstruction current_instruction = segment.turn_instruction & TurnInstructions.InverseAccessRestrictionFlag; + TurnInstruction current_instruction = segment.turn_instruction & TurnInstructionsClass::InverseAccessRestrictionFlag; entered_restricted_area_count += (current_instruction != segment.turn_instruction); - if(TurnInstructions.TurnIsNecessary( current_instruction) ) { - if(TurnInstructions.EnterRoundAbout == current_instruction) { - roundAbout.name_id = segment.name_id; - roundAbout.start_index = prefixSumOfNecessarySegments; - } else { - if(0 != prefixSumOfNecessarySegments){ + if (TurnInstructionsClass::TurnIsNecessary( current_instruction) ) + { + if (TurnInstructionsClass::EnterRoundAbout == current_instruction) + { + round_about.name_id = segment.name_id; + round_about.start_index = necessary_segments_running_index; + } + else + { + if (0 != necessary_segments_running_index) + { reply.content.push_back(","); } reply.content.push_back("[\""); - if(TurnInstructions.LeaveRoundAbout == current_instruction) { - intToString(TurnInstructions.EnterRoundAbout, tmpInstruction); - reply.content.push_back(tmpInstruction); + if(TurnInstructionsClass::LeaveRoundAbout == current_instruction) { + intToString(TurnInstructionsClass::EnterRoundAbout, temp_instruction); + reply.content.push_back(temp_instruction); reply.content.push_back("-"); - intToString(roundAbout.leave_at_exit+1, tmpInstruction); - reply.content.push_back(tmpInstruction); - roundAbout.leave_at_exit = 0; + intToString(round_about.leave_at_exit+1, temp_instruction); + reply.content.push_back(temp_instruction); + round_about.leave_at_exit = 0; } else { - intToString(current_instruction, tmpInstruction); - reply.content.push_back(tmpInstruction); + intToString(current_instruction, temp_instruction); + reply.content.push_back(temp_instruction); } reply.content.push_back("\",\""); reply.content.push_back(facade->GetEscapedNameForNameID(segment.name_id)); reply.content.push_back("\","); - intToString(segment.length, tmpDist); - reply.content.push_back(tmpDist); + intToString(segment.length, temp_dist); + reply.content.push_back(temp_dist); reply.content.push_back(","); - intToString(prefixSumOfNecessarySegments, tmpLength); - reply.content.push_back(tmpLength); + intToString(necessary_segments_running_index, temp_length); + reply.content.push_back(temp_length); reply.content.push_back(","); - intToString(segment.duration/10, tmpDuration); - reply.content.push_back(tmpDuration); + intToString(segment.duration/10, temp_duration); + reply.content.push_back(temp_duration); reply.content.push_back(",\""); - intToString(segment.length, tmpLength); - reply.content.push_back(tmpLength); + intToString(segment.length, temp_length); + reply.content.push_back(temp_length); reply.content.push_back("m\",\""); double bearing_value = round(segment.bearing/10.); reply.content.push_back(Azimuth::Get(bearing_value)); reply.content.push_back("\","); - intToString(bearing_value, tmpBearing); - reply.content.push_back(tmpBearing); + intToString(bearing_value, temp_bearing); + reply.content.push_back(temp_bearing); reply.content.push_back("]"); route_segments_list.push_back( @@ -479,22 +485,22 @@ public: ) ); } - } else if(TurnInstructions.StayOnRoundAbout == current_instruction) { - ++roundAbout.leave_at_exit; + } else if(TurnInstructionsClass::StayOnRoundAbout == current_instruction) { + ++round_about.leave_at_exit; } if(segment.necessary) - ++prefixSumOfNecessarySegments; + ++necessary_segments_running_index; } if(INT_MAX != route_length) { reply.content.push_back(",[\""); - intToString(TurnInstructions.ReachedYourDestination, tmpInstruction); - reply.content.push_back(tmpInstruction); + intToString(TurnInstructionsClass::ReachedYourDestination, temp_instruction); + reply.content.push_back(temp_instruction); reply.content.push_back("\",\""); reply.content.push_back("\","); reply.content.push_back("0"); reply.content.push_back(","); - intToString(prefixSumOfNecessarySegments-1, tmpLength); - reply.content.push_back(tmpLength); + intToString(necessary_segments_running_index-1, temp_length); + reply.content.push_back(temp_length); reply.content.push_back(","); reply.content.push_back("0"); reply.content.push_back(",\""); diff --git a/Server/DataStructures/SharedDataType.h b/Server/DataStructures/SharedDataType.h index b7154094f..49cfac0a4 100644 --- a/Server/DataStructures/SharedDataType.h +++ b/Server/DataStructures/SharedDataType.h @@ -96,17 +96,17 @@ struct SharedDataLayout { uint64_t GetSizeOfLayout() const { uint64_t result = - (name_index_list_size * sizeof(unsigned) ) + - (name_char_list_size * sizeof(char) ) + - (name_id_list_size * sizeof(unsigned) ) + - (via_node_list_size * sizeof(NodeID) ) + - (graph_node_list_size * sizeof(QueryGraph::_StrNode)) + - (graph_edge_list_size * sizeof(QueryGraph::_StrEdge)) + - (timestamp_length * sizeof(char) ) + - (coordinate_list_size * sizeof(FixedPointCoordinate)) + - (turn_instruction_list_size * sizeof(TurnInstructions) ) + - (r_search_tree_size * sizeof(RTreeNode) ) + - sizeof(checksum) + + (name_index_list_size * sizeof(unsigned) ) + + (name_char_list_size * sizeof(char) ) + + (name_id_list_size * sizeof(unsigned) ) + + (via_node_list_size * sizeof(NodeID) ) + + (graph_node_list_size * sizeof(QueryGraph::_StrNode) ) + + (graph_edge_list_size * sizeof(QueryGraph::_StrEdge) ) + + (timestamp_length * sizeof(char) ) + + (coordinate_list_size * sizeof(FixedPointCoordinate) ) + + (turn_instruction_list_size * sizeof(TurnInstructionsClass)) + + (r_search_tree_size * sizeof(RTreeNode) ) + + sizeof(checksum) + 1024*sizeof(char); return result; } @@ -184,29 +184,29 @@ struct SharedDataLayout { } uint64_t GetRSearchTreeOffset() const { uint64_t result = - (name_index_list_size * sizeof(unsigned) ) + - (name_char_list_size * sizeof(char) ) + - (name_id_list_size * sizeof(unsigned) ) + - (via_node_list_size * sizeof(NodeID) ) + - (graph_node_list_size * sizeof(QueryGraph::_StrNode)) + - (graph_edge_list_size * sizeof(QueryGraph::_StrEdge)) + - (timestamp_length * sizeof(char) ) + - (coordinate_list_size * sizeof(FixedPointCoordinate)) + - (turn_instruction_list_size * sizeof(TurnInstructions) ); + (name_index_list_size * sizeof(unsigned) ) + + (name_char_list_size * sizeof(char) ) + + (name_id_list_size * sizeof(unsigned) ) + + (via_node_list_size * sizeof(NodeID) ) + + (graph_node_list_size * sizeof(QueryGraph::_StrNode) ) + + (graph_edge_list_size * sizeof(QueryGraph::_StrEdge) ) + + (timestamp_length * sizeof(char) ) + + (coordinate_list_size * sizeof(FixedPointCoordinate) ) + + (turn_instruction_list_size * sizeof(TurnInstructionsClass)); return result; } uint64_t GetChecksumOffset() const { uint64_t result = - (name_index_list_size * sizeof(unsigned) ) + - (name_char_list_size * sizeof(char) ) + - (name_id_list_size * sizeof(unsigned) ) + - (via_node_list_size * sizeof(NodeID) ) + - (graph_node_list_size * sizeof(QueryGraph::_StrNode)) + - (graph_edge_list_size * sizeof(QueryGraph::_StrEdge)) + - (timestamp_length * sizeof(char) ) + - (coordinate_list_size * sizeof(FixedPointCoordinate)) + - (turn_instruction_list_size * sizeof(TurnInstructions) ) + - (r_search_tree_size * sizeof(RTreeNode) ); + (name_index_list_size * sizeof(unsigned) ) + + (name_char_list_size * sizeof(char) ) + + (name_id_list_size * sizeof(unsigned) ) + + (via_node_list_size * sizeof(NodeID) ) + + (graph_node_list_size * sizeof(QueryGraph::_StrNode) ) + + (graph_edge_list_size * sizeof(QueryGraph::_StrEdge) ) + + (timestamp_length * sizeof(char) ) + + (coordinate_list_size * sizeof(FixedPointCoordinate) ) + + (turn_instruction_list_size * sizeof(TurnInstructionsClass)) + + (r_search_tree_size * sizeof(RTreeNode) ); return result; } };