From b343a17b294f5a8f077eccfed13107bee51fe488 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Fri, 20 Sep 2013 18:30:47 +0200 Subject: [PATCH] Implementation of internal data storage --- DataStructures/NodeInformationHelpDesk.h | 2 +- DataStructures/SearchEngine.h | 1 - DataStructures/StaticGraph.h | 18 +- DataStructures/StaticRTree.h | 8 +- Library/OSRM.cpp | 80 ++---- Library/OSRM.h | 1 - Plugins/LocatePlugin.h | 2 - Plugins/NearestPlugin.h | 3 +- Plugins/ViaRoutePlugin.h | 2 +- RoutingAlgorithms/AlternativePathRouting.h | 40 +-- RoutingAlgorithms/BasicRoutingInterface.h | 4 +- RoutingAlgorithms/ShortestPathRouting.h | 20 +- Server/DataStructures/BaseDataFacade.h | 4 +- Server/DataStructures/InternalDataFacade.h | 267 +++++++++++++++++++-- Server/DataStructures/SharedDataFacade.h | 11 +- Util/GraphLoader.h | 3 +- Util/IniFile.h | 4 + 17 files changed, 340 insertions(+), 130 deletions(-) diff --git a/DataStructures/NodeInformationHelpDesk.h b/DataStructures/NodeInformationHelpDesk.h index ff539024f..bdaa21b35 100644 --- a/DataStructures/NodeInformationHelpDesk.h +++ b/DataStructures/NodeInformationHelpDesk.h @@ -203,7 +203,7 @@ private: std::vector m_name_ID_list; std::vector m_turn_instruction_list; - StaticRTree * m_ro_rtree_ptr; + StaticRTree * m_ro_rtree_ptr; const unsigned m_number_of_nodes; const unsigned m_check_sum; }; diff --git a/DataStructures/SearchEngine.h b/DataStructures/SearchEngine.h index 894ea8715..34bbeb556 100644 --- a/DataStructures/SearchEngine.h +++ b/DataStructures/SearchEngine.h @@ -22,7 +22,6 @@ or see http://www.gnu.org/licenses/agpl.txt. #define SEARCHENGINE_H #include "Coordinate.h" -#include "NodeInformationHelpDesk.h" #include "SearchEngineData.h" #include "PhantomNodes.h" #include "QueryEdge.h" diff --git a/DataStructures/StaticGraph.h b/DataStructures/StaticGraph.h index b193b3ef4..3558fad9a 100644 --- a/DataStructures/StaticGraph.h +++ b/DataStructures/StaticGraph.h @@ -137,32 +137,32 @@ public: return _numEdges; } - unsigned GetOutDegree( const NodeIterator &n ) const { + unsigned GetOutDegree( const NodeIterator n ) const { return BeginEdges(n)-EndEdges(n) - 1; } - inline NodeIterator GetTarget( const EdgeIterator &e ) const { + inline NodeIterator GetTarget( const EdgeIterator e ) const { return NodeIterator( _edges[e].target ); } - inline EdgeDataT &GetEdgeData( const EdgeIterator &e ) { + inline EdgeDataT &GetEdgeData( const EdgeIterator e ) { return _edges[e].data; } - const EdgeDataT &GetEdgeData( const EdgeIterator &e ) const { + const EdgeDataT &GetEdgeData( const EdgeIterator e ) const { return _edges[e].data; } - EdgeIterator BeginEdges( const NodeIterator &n ) const { + EdgeIterator BeginEdges( const NodeIterator n ) const { return EdgeIterator( _nodes[n].firstEdge ); } - EdgeIterator EndEdges( const NodeIterator &n ) const { + EdgeIterator EndEdges( const NodeIterator n ) const { return EdgeIterator( _nodes[n+1].firstEdge ); } //searches for a specific edge - EdgeIterator FindEdge( const NodeIterator &from, const NodeIterator &to ) const { + EdgeIterator FindEdge( const NodeIterator from, const NodeIterator to ) const { EdgeIterator smallestEdge = SPECIAL_EDGEID; EdgeWeight smallestWeight = UINT_MAX; for ( EdgeIterator edge = BeginEdges( from ); edge < EndEdges(from); edge++ ) { @@ -175,12 +175,12 @@ public: return smallestEdge; } - EdgeIterator FindEdgeInEitherDirection( const NodeIterator &from, const NodeIterator &to ) const { + EdgeIterator FindEdgeInEitherDirection( const NodeIterator from, const NodeIterator to ) const { EdgeIterator tmp = FindEdge( from, to ); return (UINT_MAX != tmp ? tmp : FindEdge( to, from )); } - EdgeIterator FindEdgeIndicateIfReverse( const NodeIterator &from, const NodeIterator &to, bool & result ) const { + EdgeIterator FindEdgeIndicateIfReverse( const NodeIterator from, const NodeIterator to, bool & result ) const { EdgeIterator tmp = FindEdge( from, to ); if(UINT_MAX == tmp) { tmp = FindEdge( to, from ); diff --git a/DataStructures/StaticRTree.h b/DataStructures/StaticRTree.h index 5bf27b434..82e4f726a 100644 --- a/DataStructures/StaticRTree.h +++ b/DataStructures/StaticRTree.h @@ -410,11 +410,10 @@ public: //Read-only operation for queries explicit StaticRTree( - const std::string & node_filename, - const std::string & leaf_filename - ) : m_leaf_node_filename(leaf_filename) { + const boost::filesystem::path & node_file, + const boost::filesystem::path & leaf_file + ) : m_leaf_node_filename(leaf_file.string()) { //open tree node file and load into RAM. - boost::filesystem::path node_file(node_filename); if ( !boost::filesystem::exists( node_file ) ) { throw OSRMException("ram index file does not exist"); @@ -432,7 +431,6 @@ public: tree_node_file.close(); //open leaf node file and store thread specific pointer - boost::filesystem::path leaf_file(leaf_filename); if ( !boost::filesystem::exists( leaf_file ) ) { throw OSRMException("mem index file does not exist"); } diff --git a/Library/OSRM.cpp b/Library/OSRM.cpp index 9ece830f9..3e4509362 100644 --- a/Library/OSRM.cpp +++ b/Library/OSRM.cpp @@ -20,74 +20,26 @@ or see http://www.gnu.org/licenses/agpl.txt. #include "OSRM.h" -OSRM::OSRM(const char * server_ini_path, const bool use_shared_memory) - : use_shared_memory(use_shared_memory) +OSRM::OSRM(const char * server_ini_path, const bool use_shared_memory) : + use_shared_memory(use_shared_memory) { + + if( !testDataFile(server_ini_path) ){ + std::string error_message(server_ini_path); + error_message += " not found"; + throw OSRMException(error_message); + } + boost::filesystem::path base_path = boost::filesystem::absolute(server_ini_path).parent_path(); + IniFile server_config(server_ini_path); + if( !use_shared_memory ) { - if( !testDataFile(server_ini_path) ){ - std::string error_message(server_ini_path); - error_message += " not found"; - throw OSRMException(error_message); - } - - IniFile serverConfig(server_ini_path); - - boost::filesystem::path base_path = - boost::filesystem::absolute(server_ini_path).parent_path(); - - if ( !serverConfig.Holds("hsgrData")) { - throw OSRMException("no ram index file name in server ini"); - } - if ( !serverConfig.Holds("ramIndex") ) { - throw OSRMException("no mem index file name in server ini"); - } - if ( !serverConfig.Holds("fileIndex") ) { - throw OSRMException("no nodes file name in server ini"); - } - if ( !serverConfig.Holds("nodesData") ) { - throw OSRMException("no nodes file name in server ini"); - } - if ( !serverConfig.Holds("edgesData") ) { - throw OSRMException("no edges file name in server ini"); - } - - boost::filesystem::path hsgr_path = boost::filesystem::absolute( - serverConfig.GetParameter("hsgrData"), - base_path + query_data_facade = new InternalDataFacade( + server_config, base_path ); - - boost::filesystem::path ram_index_path = boost::filesystem::absolute( - serverConfig.GetParameter("ramIndex"), - base_path - ); - - boost::filesystem::path file_index_path = boost::filesystem::absolute( - serverConfig.GetParameter("fileIndex"), - base_path - ); - - boost::filesystem::path node_data_path = boost::filesystem::absolute( - serverConfig.GetParameter("nodesData"), - base_path - ); - boost::filesystem::path edge_data_path = boost::filesystem::absolute( - serverConfig.GetParameter("edgesData"), - base_path - ); - boost::filesystem::path name_data_path = boost::filesystem::absolute( - serverConfig.GetParameter("namesData"), - base_path - ); - boost::filesystem::path timestamp_path = boost::filesystem::absolute( - serverConfig.GetParameter("timestamp"), - base_path - ); - - query_data_facade = new InternalDataFacade(); - } else { - //TODO: fetch pointers from shared memory - query_data_facade = new SharedDataFacade(); + query_data_facade = new SharedDataFacade( + server_config, base_path + ); } //The following plugins handle all requests. diff --git a/Library/OSRM.h b/Library/OSRM.h index c58958934..df2c8ad93 100644 --- a/Library/OSRM.h +++ b/Library/OSRM.h @@ -63,7 +63,6 @@ private: PluginMap plugin_map; const bool use_shared_memory; - }; #endif //OSRM_H diff --git a/Plugins/LocatePlugin.h b/Plugins/LocatePlugin.h index 35261a9d5..ed2a89a4e 100644 --- a/Plugins/LocatePlugin.h +++ b/Plugins/LocatePlugin.h @@ -22,8 +22,6 @@ or see http://www.gnu.org/licenses/agpl.txt. #define LOCATEPLUGIN_H_ #include "BasePlugin.h" -#include "../DataStructures/NodeInformationHelpDesk.h" -#include "../Server/DataStructures/QueryObjectsStorage.h" #include "../Util/StringUtil.h" //locates the nearest node in the road network for a given coordinate. diff --git a/Plugins/NearestPlugin.h b/Plugins/NearestPlugin.h index 45c1c90d0..903d0e745 100644 --- a/Plugins/NearestPlugin.h +++ b/Plugins/NearestPlugin.h @@ -22,8 +22,7 @@ or see http://www.gnu.org/licenses/agpl.txt. #define NearestPlugin_H_ #include "BasePlugin.h" - -#include "../DataStructures/NodeInformationHelpDesk.h" +#include "../DataStructures/PhantomNodes.h" #include "../Util/StringUtil.h" /* diff --git a/Plugins/ViaRoutePlugin.h b/Plugins/ViaRoutePlugin.h index 598d67c1d..dc9dd7918 100644 --- a/Plugins/ViaRoutePlugin.h +++ b/Plugins/ViaRoutePlugin.h @@ -115,7 +115,7 @@ public: ( routeParameters.alternateRoute ) && (1 == rawRoute.segmentEndCoordinates.size()) ) { - search_engine_ptr->alternative_paths( + search_engine_ptr->alternative_path( rawRoute.segmentEndCoordinates[0], rawRoute ); diff --git a/RoutingAlgorithms/AlternativePathRouting.h b/RoutingAlgorithms/AlternativePathRouting.h index 96c0a3737..167954739 100644 --- a/RoutingAlgorithms/AlternativePathRouting.h +++ b/RoutingAlgorithms/AlternativePathRouting.h @@ -74,14 +74,20 @@ public: std::vector reverse_search_space; //Initialize Queues, semi-expensive because access to TSS invokes a system call - super::_queryData.InitializeOrClearFirstThreadLocalStorage(); - super::_queryData.InitializeOrClearSecondThreadLocalStorage(); - super::_queryData.InitializeOrClearThirdThreadLocalStorage(); + engine_working_data.InitializeOrClearFirstThreadLocalStorage( + super::facade->GetNumberOfNodes() + ); + engine_working_data.InitializeOrClearSecondThreadLocalStorage( + super::facade->GetNumberOfNodes() + ); + engine_working_data.InitializeOrClearThirdThreadLocalStorage( + super::facade->GetNumberOfNodes() + ); - QueryHeap & forward_heap1 = *(super::_queryData.forwardHeap); - QueryHeap & reverse_heap1 = *(super::_queryData.backwardHeap); - QueryHeap & forward_heap2 = *(super::_queryData.forwardHeap2); - QueryHeap & reverse_heap2 = *(super::_queryData.backwardHeap2); + QueryHeap & forward_heap1 = *(engine_working_data.forwardHeap); + QueryHeap & reverse_heap1 = *(engine_working_data.backwardHeap); + QueryHeap & forward_heap2 = *(engine_working_data.forwardHeap2); + QueryHeap & reverse_heap2 = *(engine_working_data.backwardHeap2); int upper_bound_to_shortest_path_distance = INT_MAX; NodeID middle_node = UINT_MAX; @@ -219,12 +225,14 @@ private: const int offset, const std::vector & packed_shortest_path) { //compute and unpack and by exploring search spaces from v and intersecting against queues //only half-searches have to be done at this stage - super::_queryData.InitializeOrClearSecondThreadLocalStorage(); + engine_working_data.InitializeOrClearSecondThreadLocalStorage( + super::facade->GetNumberOfNodes() + ); - QueryHeap & existingForwardHeap = *super::_queryData.forwardHeap; - QueryHeap & existingBackwardHeap = *super::_queryData.backwardHeap; - QueryHeap & newForwardHeap = *super::_queryData.forwardHeap2; - QueryHeap & newBackwardHeap = *super::_queryData.backwardHeap2; + QueryHeap & existingForwardHeap = *engine_working_data.forwardHeap; + QueryHeap & existingBackwardHeap = *engine_working_data.backwardHeap; + QueryHeap & newForwardHeap = *engine_working_data.forwardHeap2; + QueryHeap & newBackwardHeap = *engine_working_data.backwardHeap2; std::vector < NodeID > packed_s_v_path; std::vector < NodeID > packed_v_t_path; @@ -517,10 +525,12 @@ private: lengthOfPathT_Test_Path += unpackedUntilDistance; //Run actual T-Test query and compare if distances equal. - super::_queryData.InitializeOrClearThirdThreadLocalStorage(); + engine_working_data.InitializeOrClearThirdThreadLocalStorage( + super::facade->GetNumberOfNodes() + ); - QueryHeap& forward_heap3 = *super::_queryData.forwardHeap3; - QueryHeap& backward_heap3 = *super::_queryData.backwardHeap3; + QueryHeap& forward_heap3 = *engine_working_data.forwardHeap3; + QueryHeap& backward_heap3 = *engine_working_data.backwardHeap3; int _upperBound = INT_MAX; NodeID middle = UINT_MAX; forward_heap3.Insert(s_P, 0, s_P); diff --git a/RoutingAlgorithms/BasicRoutingInterface.h b/RoutingAlgorithms/BasicRoutingInterface.h index 6dcdcdd1b..8661e9747 100644 --- a/RoutingAlgorithms/BasicRoutingInterface.h +++ b/RoutingAlgorithms/BasicRoutingInterface.h @@ -125,7 +125,9 @@ public: //We have to push the path in reverse order onto the stack because it's LIFO. for(unsigned i = packed_path_size-1; i > 0; --i){ - recursion_stack.push(std::make_pair(packed_path[i-1], packed_path[i])); + recursion_stack.push( + std::make_pair(packed_path[i-1], packed_path[i]) + ); } std::pair edge; diff --git a/RoutingAlgorithms/ShortestPathRouting.h b/RoutingAlgorithms/ShortestPathRouting.h index 3426772d9..2678a38fb 100644 --- a/RoutingAlgorithms/ShortestPathRouting.h +++ b/RoutingAlgorithms/ShortestPathRouting.h @@ -54,14 +54,20 @@ public: std::vector packedPath1; std::vector packedPath2; - super::_queryData.InitializeOrClearFirstThreadLocalStorage(); - super::_queryData.InitializeOrClearSecondThreadLocalStorage(); - super::_queryData.InitializeOrClearThirdThreadLocalStorage(); + engine_working_data.InitializeOrClearFirstThreadLocalStorage( + super::facade->GetNumberOfNodes() + ); + engine_working_data.InitializeOrClearSecondThreadLocalStorage( + super::facade->GetNumberOfNodes() + ); + engine_working_data.InitializeOrClearThirdThreadLocalStorage( + super::facade->GetNumberOfNodes() + ); - QueryHeap & forward_heap1 = *(super::_queryData.forwardHeap); - QueryHeap & reverse_heap1 = *(super::_queryData.backwardHeap); - QueryHeap & forward_heap2 = *(super::_queryData.forwardHeap2); - QueryHeap & reverse_heap2 = *(super::_queryData.backwardHeap2); + QueryHeap & forward_heap1 = *(engine_working_data.forwardHeap); + QueryHeap & reverse_heap1 = *(engine_working_data.backwardHeap); + QueryHeap & forward_heap2 = *(engine_working_data.forwardHeap2); + QueryHeap & reverse_heap2 = *(engine_working_data.backwardHeap2); //Get distance to next pair of target nodes. BOOST_FOREACH(const PhantomNodes & phantomNodePair, phantomNodesVector) { diff --git a/Server/DataStructures/BaseDataFacade.h b/Server/DataStructures/BaseDataFacade.h index b3f1aee97..d04a17b66 100644 --- a/Server/DataStructures/BaseDataFacade.h +++ b/Server/DataStructures/BaseDataFacade.h @@ -23,6 +23,7 @@ or see http://www.gnu.org/licenses/agpl.txt. //Exposes all data access interfaces to the algorithms via base class ptr +#include "../../Contractor/EdgeBasedGraphFactory.h" #include "../../DataStructures/Coordinate.h" #include "../../DataStructures/PhantomNodes.h" #include "../../DataStructures/TurnInstructions.h" @@ -35,8 +36,9 @@ or see http://www.gnu.org/licenses/agpl.txt. template class BaseDataFacade { public: + typedef EdgeBasedGraphFactory::EdgeBasedNode RTreeLeaf; typedef EdgeDataT EdgeData; - BaseDataFacade() { } + BaseDataFacade( ) { } virtual ~BaseDataFacade() { } //search graph access diff --git a/Server/DataStructures/InternalDataFacade.h b/Server/DataStructures/InternalDataFacade.h index e4fc77525..86500ae8e 100644 --- a/Server/DataStructures/InternalDataFacade.h +++ b/Server/DataStructures/InternalDataFacade.h @@ -25,67 +25,300 @@ or see http://www.gnu.org/licenses/agpl.txt. #include "BaseDataFacade.h" +#include "../../DataStructures/Coordinate.h" +#include "../../DataStructures/QueryNode.h" +#include "../../DataStructures/QueryEdge.h" #include "../../DataStructures/StaticGraph.h" +#include "../../DataStructures/StaticRTree.h" +#include "../../Util/BoostFilesystemFix.h" +#include "../../Util/GraphLoader.h" +#include "../../Util/IniFile.h" +#include "../../Util/SimpleLogger.h" template class InternalDataFacade : public BaseDataFacade { private: + typedef BaseDataFacade super; + typedef StaticGraph QueryGraph; + typedef typename QueryGraph::InputEdge InputEdge; + typedef typename super::RTreeLeaf RTreeLeaf; + + InternalDataFacade() { } + + unsigned m_check_sum; + unsigned m_number_of_nodes; + QueryGraph * m_query_graph; + std::string m_timestamp; + + std::vector m_coordinate_list; + std::vector m_via_node_list; + std::vector m_name_ID_list; + std::vector m_turn_instruction_list; + StaticRTree * m_static_rtree; + + + void LoadTimestamp(const boost::filesystem::path & timestamp_path) { + if( boost::filesystem::exists(timestamp_path) ) { + SimpleLogger().Write() << "Loading Timestamp"; + boost::filesystem::ifstream timestampInStream( timestamp_path ); + if(!timestampInStream) { + SimpleLogger().Write(logWARNING) << timestamp_path << " not found"; + } + getline(timestampInStream, m_timestamp); + timestampInStream.close(); + } + if(m_timestamp.empty()) { + m_timestamp = "n/a"; + } + if(25 < m_timestamp.length()) { + m_timestamp.resize(25); + } + } + + void LoadGraph(const boost::filesystem::path & hsgr_path) { + ShMemVector node_list; + ShMemVector< typename QueryGraph::_StrEdge> edge_list; + + m_number_of_nodes = readHSGRFromStream( + hsgr_path, + node_list, + edge_list, + &m_check_sum + ); + BOOST_ASSERT_MSG(0 == node_list.size(), "node list not flushed"); + BOOST_ASSERT_MSG(0 == edge_list.size(), "edge list not flushed"); + + m_query_graph = new QueryGraph(node_list, edge_list); + SimpleLogger().Write() << "Data checksum is " << m_check_sum; + } + + void LoadNodeAndEdgeInformation( + const boost::filesystem::path nodes_file, + const boost::filesystem::path edges_file + ) { + boost::filesystem::ifstream nodes_input_stream( + nodes_file, + std::ios::binary + ); + boost::filesystem::ifstream edges_input_stream( + edges_file, + std::ios::binary + ); + + SimpleLogger().Write(logDEBUG) << "Loading node data"; + NodeInfo current_node; + while(!nodes_input_stream.eof()) { + nodes_input_stream.read((char *)¤t_node, sizeof(NodeInfo)); + m_coordinate_list.push_back( + FixedPointCoordinate( + current_node.lat, + current_node.lon + ) + ); + } + std::vector(m_coordinate_list).swap(m_coordinate_list); + nodes_input_stream.close(); + + SimpleLogger().Write(logDEBUG) + << "Loading edge data"; + unsigned number_of_edges = 0; + edges_input_stream.read((char*)&number_of_edges, sizeof(unsigned)); + m_via_node_list.resize(number_of_edges); + m_name_ID_list.resize(number_of_edges); + m_turn_instruction_list.resize(number_of_edges); + + OriginalEdgeData current_edge_data; + for(unsigned i = 0; i < number_of_edges; ++i) { + edges_input_stream.read( + (char*)&(current_edge_data), + sizeof(OriginalEdgeData) + ); + m_via_node_list[i] = current_edge_data.viaNode; + m_name_ID_list[i] = current_edge_data.nameID; + m_turn_instruction_list[i] = current_edge_data.turnInstruction; + } + edges_input_stream.close(); + SimpleLogger().Write(logDEBUG) + << "Loaded " << number_of_edges << " orig edges"; + SimpleLogger().Write(logDEBUG) << "Opening NN indices"; + } + + void LoadRTree( + const boost::filesystem::path & ram_index_path, + const boost::filesystem::path & file_index_path + ) { + m_static_rtree = new StaticRTree( + ram_index_path, + file_index_path + ); + } public: + ~InternalDataFacade() { + delete m_query_graph; + delete m_static_rtree; + } + + InternalDataFacade( + const IniFile & server_config, + const boost::filesystem::path & base_path + ) { + //check contents of config file + if ( !server_config.Holds("hsgrData")) { + throw OSRMException("no ram index file name in server ini"); + } + if ( !server_config.Holds("ramIndex") ) { + throw OSRMException("no mem index file name in server ini"); + } + if ( !server_config.Holds("fileIndex") ) { + throw OSRMException("no nodes file name in server ini"); + } + if ( !server_config.Holds("nodesData") ) { + throw OSRMException("no nodes file name in server ini"); + } + if ( !server_config.Holds("edgesData") ) { + throw OSRMException("no edges file name in server ini"); + } + + //generate paths of data files + boost::filesystem::path hsgr_path = boost::filesystem::absolute( + server_config.GetParameter("hsgrData"), + base_path + ); + boost::filesystem::path ram_index_path = boost::filesystem::absolute( + server_config.GetParameter("ramIndex"), + base_path + ); + boost::filesystem::path file_index_path = boost::filesystem::absolute( + server_config.GetParameter("fileIndex"), + base_path + ); + boost::filesystem::path node_data_path = boost::filesystem::absolute( + server_config.GetParameter("nodesData"), + base_path + ); + boost::filesystem::path edge_data_path = boost::filesystem::absolute( + server_config.GetParameter("edgesData"), + base_path + ); + boost::filesystem::path name_data_path = boost::filesystem::absolute( + server_config.GetParameter("namesData"), + base_path + ); + boost::filesystem::path timestamp_path = boost::filesystem::absolute( + server_config.GetParameter("timestamp"), + base_path + ); + + // check if data files empty + if ( 0 == boost::filesystem::file_size( node_data_path ) ) { + throw OSRMException("nodes file is empty"); + } + if ( 0 == boost::filesystem::file_size( edge_data_path ) ) { + throw OSRMException("edges file is empty"); + } + + + //load data + SimpleLogger().Write() << "loading graph data"; + LoadGraph(hsgr_path); + LoadNodeAndEdgeInformation(node_data_path, edge_data_path); + LoadRTree(ram_index_path, file_index_path); + LoadTimestamp(hsgr_path); + } + //search graph access - unsigned GetNumberOfNodes() const { return 0; } + unsigned GetNumberOfNodes() const { + return m_query_graph->GetNumberOfNodes(); + } - unsigned GetNumberOfEdges() const { return 0; } + unsigned GetNumberOfEdges() const { + return m_query_graph->GetNumberOfEdges(); + } - unsigned GetOutDegree( const NodeID n ) const { return 0; } + unsigned GetOutDegree( const NodeID n ) const { + return m_query_graph->GetOutDegree(n); + } - NodeID GetTarget( const EdgeID e ) const { return 0; } + NodeID GetTarget( const EdgeID e ) const { + return m_query_graph->GetTarget(e); } - EdgeDataT &GetEdgeData( const EdgeID e ) { return EdgeDataT(); } + EdgeDataT &GetEdgeData( const EdgeID e ) { + return m_query_graph->GetEdgeData(e); + } - const EdgeDataT &GetEdgeData( const EdgeID e ) const { return EdgeDataT(); } + const EdgeDataT &GetEdgeData( const EdgeID e ) const { + return m_query_graph->GetEdgeData(e); + } - EdgeID BeginEdges( const NodeID n ) const { return 0; } + EdgeID BeginEdges( const NodeID n ) const { + return m_query_graph->BeginEdges(n); + } - EdgeID EndEdges( const NodeID n ) const { return 0; } + EdgeID EndEdges( const NodeID n ) const { + return m_query_graph->EndEdges(n); + } //searches for a specific edge - EdgeID FindEdge( const NodeID from, const NodeID to ) const { return 0; } + EdgeID FindEdge( const NodeID from, const NodeID to ) const { + return m_query_graph->FindEdge(from, to); + } EdgeID FindEdgeInEitherDirection( const NodeID from, const NodeID to - ) const { return 0; } + ) const { + return m_query_graph->FindEdgeInEitherDirection(from, to); + } EdgeID FindEdgeIndicateIfReverse( const NodeID from, const NodeID to, bool & result - ) const { return 0; } + ) const { + return m_query_graph->FindEdgeIndicateIfReverse(from, to, result); + } //node and edge information access FixedPointCoordinate GetCoordinateOfNode( const unsigned id - ) const { return FixedPointCoordinate(); }; + ) const { + const NodeID node = m_via_node_list.at(id); + return m_coordinate_list.at(node); + }; TurnInstruction GetTurnInstructionForEdgeID( const unsigned id - ) const { return 0; } + ) const { + return m_turn_instruction_list.at(id); + } bool LocateClosestEndPointForCoordinate( const FixedPointCoordinate& input_coordinate, FixedPointCoordinate& result, const unsigned zoom_level = 18 - ) const { return false; } + ) const { + return m_static_rtree->LocateClosestEndPointForCoordinate( + input_coordinate, + result, + zoom_level + ); + } bool FindPhantomNodeForCoordinate( const FixedPointCoordinate & input_coordinate, PhantomNode & resulting_phantom_node, const unsigned zoom_level - ) const { return false; } + ) const { + return m_static_rtree->FindPhantomNodeForCoordinate( + input_coordinate, + resulting_phantom_node, + zoom_level + ); + } - unsigned GetCheckSum() const { return 0; } + unsigned GetCheckSum() const { return m_check_sum; } unsigned GetNameIndexFromEdgeID(const unsigned id) const { return 0; }; @@ -95,7 +328,7 @@ public: ) const { return; }; std::string GetTimestamp() const { - return ""; + return m_timestamp; }; }; diff --git a/Server/DataStructures/SharedDataFacade.h b/Server/DataStructures/SharedDataFacade.h index 34700bca5..66f870f10 100644 --- a/Server/DataStructures/SharedDataFacade.h +++ b/Server/DataStructures/SharedDataFacade.h @@ -26,13 +26,22 @@ or see http://www.gnu.org/licenses/agpl.txt. #include "BaseDataFacade.h" #include "../../DataStructures/StaticGraph.h" +#include "../../Util/BoostFilesystemFix.h" +#include "../../Util/IniFile.h" +#include "../../Util/SimpleLogger.h" template class SharedDataFacade : public BaseDataFacade { private: - + SharedDataFacade() { } public: + SharedDataFacade( + const IniFile & configuration, + const boost::filesystem::path base_path + ) { + //TODO: load data + } //search graph access unsigned GetNumberOfNodes() const { return 0; } diff --git a/Util/GraphLoader.h b/Util/GraphLoader.h index 4c9621302..23fd40236 100644 --- a/Util/GraphLoader.h +++ b/Util/GraphLoader.h @@ -403,12 +403,11 @@ NodeID readDDSGGraphFromStream(std::istream &in, std::vector& edgeList, s template unsigned readHSGRFromStream( - const std::string & hsgr_filename, + const boost::filesystem::path & hsgr_file, std::vector & node_list, std::vector & edge_list, unsigned * check_sum ) { - boost::filesystem::path hsgr_file(hsgr_filename); if ( !boost::filesystem::exists( hsgr_file ) ) { throw OSRMException("hsgr file does not exist"); } diff --git a/Util/IniFile.h b/Util/IniFile.h index 582cc273c..a4923cea4 100644 --- a/Util/IniFile.h +++ b/Util/IniFile.h @@ -64,6 +64,10 @@ public: return parameters.Find(key); } + std::string GetParameter(const std::string & key) const { + return parameters.Find(key); + } + bool Holds(const std::string & key) const { return parameters.Holds(key); }