From 51c79f9784abb0eba8c4e800a9d825711b860591 Mon Sep 17 00:00:00 2001 From: Dennis Luxen Date: Fri, 29 Aug 2014 12:22:44 +0200 Subject: [PATCH] rename ExtractorStructs into a more telling name --- Extractor/ExtractionContainers.cpp | 11 +++- Extractor/ExtractionContainers.h | 4 +- Extractor/ExtractorStructs.h | 40 ++++++------- Extractor/FirstAndLastSegmentOfWay.h | 84 ++++++++++++++++++++++++++++ 4 files changed, 110 insertions(+), 29 deletions(-) create mode 100644 Extractor/FirstAndLastSegmentOfWay.h diff --git a/Extractor/ExtractionContainers.cpp b/Extractor/ExtractionContainers.cpp index 92cfcd1d6..55e971cb0 100644 --- a/Extractor/ExtractionContainers.cpp +++ b/Extractor/ExtractionContainers.cpp @@ -27,10 +27,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "ExtractionContainers.h" #include "ExtractionWay.h" + +#include "../DataStructures/NodeID.h" +#include "../DataStructures/RangeTable.h" + #include "../Util/OSRMException.h" #include "../Util/simple_logger.hpp" #include "../Util/TimingUtil.h" -#include "../DataStructures/RangeTable.h" #include #include @@ -92,8 +95,10 @@ void ExtractionContainers::PrepareData(const std::string &output_file_name, std::cout << "[extractor] Sorting used ways ... " << std::flush; TIMER_START(sort_ways); - stxxl::sort( - way_start_end_id_list.begin(), way_start_end_id_list.end(), CmpWayByID(), stxxl_memory); + stxxl::sort(way_start_end_id_list.begin(), + way_start_end_id_list.end(), + FirstAndLastSegmentOfWayStxxlCompare(), + stxxl_memory); TIMER_STOP(sort_ways); std::cout << "ok, after " << TIMER_SEC(sort_ways) << "s" << std::endl; diff --git a/Extractor/ExtractionContainers.h b/Extractor/ExtractionContainers.h index 377f2d2cf..f09fcc522 100644 --- a/Extractor/ExtractionContainers.h +++ b/Extractor/ExtractionContainers.h @@ -29,7 +29,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #define EXTRACTIONCONTAINERS_H_ #include "InternalExtractorEdge.h" -#include "ExtractorStructs.h" +#include "FirstAndLastSegmentOfWay.h" #include "../DataStructures/ExternalMemoryNode.h" #include "../DataStructures/Restriction.h" #include "../Util/FingerPrint.h" @@ -49,7 +49,7 @@ class ExtractionContainers using STXXLEdgeVector = stxxl::vector; using STXXLStringVector = stxxl::vector; using STXXLRestrictionsVector = stxxl::vector; - using STXXLWayIDStartEndVector = stxxl::vector; + using STXXLWayIDStartEndVector = stxxl::vector; STXXLNodeIDVector used_node_id_list; STXXLNodeVector all_nodes_list; diff --git a/Extractor/ExtractorStructs.h b/Extractor/ExtractorStructs.h index 2f68b6e31..d1c620669 100644 --- a/Extractor/ExtractorStructs.h +++ b/Extractor/ExtractorStructs.h @@ -25,8 +25,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef EXTRACTORSTRUCTS_H_ -#define EXTRACTORSTRUCTS_H_ +#ifndef FIRST_AND_LAST_SEGMENT_OF_WAY_H__ +#define FIRST_AND_LAST_SEGMENT_OF_WAY_H__ #include "../DataStructures/ExternalMemoryNode.h" #include "../typedefs.h" @@ -34,35 +34,35 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -struct WayIDStartAndEndEdge +struct FirstAndLastSegmentOfWay { - unsigned wayID; + EdgeID wayID; NodeID firstStart; NodeID firstTarget; NodeID lastStart; NodeID lastTarget; - WayIDStartAndEndEdge() + FirstAndLastSegmentOfWay() : wayID(std::numeric_limits::max()), firstStart(std::numeric_limits::max()), firstTarget(std::numeric_limits::max()), lastStart(std::numeric_limits::max()), lastTarget(std::numeric_limits::max()) { } - WayIDStartAndEndEdge(unsigned w, NodeID fs, NodeID ft, NodeID ls, NodeID lt) + FirstAndLastSegmentOfWay(unsigned w, NodeID fs, NodeID ft, NodeID ls, NodeID lt) : wayID(w), firstStart(fs), firstTarget(ft), lastStart(ls), lastTarget(lt) { } - static WayIDStartAndEndEdge min_value() + static FirstAndLastSegmentOfWay min_value() { - return WayIDStartAndEndEdge((std::numeric_limits::min)(), + return FirstAndLastSegmentOfWay((std::numeric_limits::min)(), (std::numeric_limits::min)(), (std::numeric_limits::min)(), (std::numeric_limits::min)(), (std::numeric_limits::min)()); } - static WayIDStartAndEndEdge max_value() + static FirstAndLastSegmentOfWay max_value() { - return WayIDStartAndEndEdge((std::numeric_limits::max)(), + return FirstAndLastSegmentOfWay((std::numeric_limits::max)(), (std::numeric_limits::max)(), (std::numeric_limits::max)(), (std::numeric_limits::max)(), @@ -70,23 +70,15 @@ struct WayIDStartAndEndEdge } }; -struct CmpWayByID +struct FirstAndLastSegmentOfWayStxxlCompare { - using value_type = WayIDStartAndEndEdge; - bool operator()(const WayIDStartAndEndEdge &a, const WayIDStartAndEndEdge &b) const + using value_type = FirstAndLastSegmentOfWay; + bool operator()(const FirstAndLastSegmentOfWay &a, const FirstAndLastSegmentOfWay &b) const { return a.wayID < b.wayID; } - value_type max_value() { return WayIDStartAndEndEdge::max_value(); } - value_type min_value() { return WayIDStartAndEndEdge::min_value(); } + value_type max_value() { return FirstAndLastSegmentOfWay::max_value(); } + value_type min_value() { return FirstAndLastSegmentOfWay::min_value(); } }; -struct Cmp -{ - using value_type = NodeID; - bool operator()(const NodeID left, const NodeID right) const { return left < right; } - value_type max_value() { return 0xffffffff; } - value_type min_value() { return 0x0; } -}; - -#endif /* EXTRACTORSTRUCTS_H_ */ +#endif /* FIRST_AND_LAST_SEGMENT_OF_WAY_H__ */ diff --git a/Extractor/FirstAndLastSegmentOfWay.h b/Extractor/FirstAndLastSegmentOfWay.h new file mode 100644 index 000000000..fb23e48fc --- /dev/null +++ b/Extractor/FirstAndLastSegmentOfWay.h @@ -0,0 +1,84 @@ +/* + +Copyright (c) 2013, Project OSRM, Dennis Luxen, others +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + +Redistributions of source code must retain the above copyright notice, this list +of conditions and the following disclaimer. +Redistributions in binary form must reproduce the above copyright notice, this +list of conditions and the following disclaimer in the documentation and/or +other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +*/ + +#ifndef EXTRACTORSTRUCTS_H_ +#define EXTRACTORSTRUCTS_H_ + +#include "../DataStructures/ExternalMemoryNode.h" +#include "../typedefs.h" + +#include +#include + +struct FirstAndLastSegmentOfWay +{ + EdgeID wayID; + NodeID firstStart; + NodeID firstTarget; + NodeID lastStart; + NodeID lastTarget; + FirstAndLastSegmentOfWay() + : wayID(std::numeric_limits::max()), firstStart(std::numeric_limits::max()), firstTarget(std::numeric_limits::max()), lastStart(std::numeric_limits::max()), + lastTarget(std::numeric_limits::max()) + { + } + + FirstAndLastSegmentOfWay(unsigned w, NodeID fs, NodeID ft, NodeID ls, NodeID lt) + : wayID(w), firstStart(fs), firstTarget(ft), lastStart(ls), lastTarget(lt) + { + } + + static FirstAndLastSegmentOfWay min_value() + { + return FirstAndLastSegmentOfWay((std::numeric_limits::min)(), + (std::numeric_limits::min)(), + (std::numeric_limits::min)(), + (std::numeric_limits::min)(), + (std::numeric_limits::min)()); + } + static FirstAndLastSegmentOfWay max_value() + { + return FirstAndLastSegmentOfWay((std::numeric_limits::max)(), + (std::numeric_limits::max)(), + (std::numeric_limits::max)(), + (std::numeric_limits::max)(), + (std::numeric_limits::max)()); + } +}; + +struct FirstAndLastSegmentOfWayStxxlCompare +{ + using value_type = FirstAndLastSegmentOfWay; + bool operator()(const FirstAndLastSegmentOfWay &a, const FirstAndLastSegmentOfWay &b) const + { + return a.wayID < b.wayID; + } + value_type max_value() { return FirstAndLastSegmentOfWay::max_value(); } + value_type min_value() { return FirstAndLastSegmentOfWay::min_value(); } +}; + +#endif /* EXTRACTORSTRUCTS_H_ */