rename ExtractorStructs into a more telling name

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 <boost/assert.hpp>
 #include <boost/filesystem.hpp>
@@ -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(
+        stxxl::sort(way_start_end_id_list.begin(),
-            way_start_end_id_list.begin(), way_start_end_id_list.end(), CmpWayByID(), stxxl_memory);
+                    way_start_end_id_list.end(),
+                    FirstAndLastSegmentOfWayStxxlCompare(),
+                    stxxl_memory);
         TIMER_STOP(sort_ways);
         std::cout << "ok, after " << TIMER_SEC(sort_ways) << "s" << std::endl;
 

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<InternalExtractorEdge>;
     using  STXXLStringVector = stxxl::vector<std::string>;
     using  STXXLRestrictionsVector = stxxl::vector<InputRestrictionContainer>;
-    using  STXXLWayIDStartEndVector = stxxl::vector<WayIDStartAndEndEdge>;
+    using  STXXLWayIDStartEndVector = stxxl::vector<FirstAndLastSegmentOfWay>;
 
     STXXLNodeIDVector used_node_id_list;
     STXXLNodeVector all_nodes_list;

Extractor/ExtractorStructs.h

@@ -25,8 +25,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 */
 
-#ifndef EXTRACTORSTRUCTS_H_
+#ifndef FIRST_AND_LAST_SEGMENT_OF_WAY_H__
-#define EXTRACTORSTRUCTS_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 <limits>
 #include <string>
 
-struct WayIDStartAndEndEdge
+struct FirstAndLastSegmentOfWay
 {
-    unsigned wayID;
+    EdgeID wayID;
     NodeID firstStart;
     NodeID firstTarget;
     NodeID lastStart;
     NodeID lastTarget;
-    WayIDStartAndEndEdge()
+    FirstAndLastSegmentOfWay()
         : wayID(std::numeric_limits<unsigned>::max()), firstStart(std::numeric_limits<unsigned>::max()), firstTarget(std::numeric_limits<unsigned>::max()), lastStart(std::numeric_limits<unsigned>::max()),
           lastTarget(std::numeric_limits<unsigned>::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<unsigned>::min)(),
+        return FirstAndLastSegmentOfWay((std::numeric_limits<unsigned>::min)(),
                                     (std::numeric_limits<unsigned>::min)(),
                                     (std::numeric_limits<unsigned>::min)(),
                                     (std::numeric_limits<unsigned>::min)(),
                                     (std::numeric_limits<unsigned>::min)());
     }
-    static WayIDStartAndEndEdge max_value()
+    static FirstAndLastSegmentOfWay max_value()
     {
-        return WayIDStartAndEndEdge((std::numeric_limits<unsigned>::max)(),
+        return FirstAndLastSegmentOfWay((std::numeric_limits<unsigned>::max)(),
                                     (std::numeric_limits<unsigned>::max)(),
                                     (std::numeric_limits<unsigned>::max)(),
                                     (std::numeric_limits<unsigned>::max)(),
@@ -70,23 +70,15 @@ struct WayIDStartAndEndEdge
     }
 };
 
-struct CmpWayByID
+struct FirstAndLastSegmentOfWayStxxlCompare
 {
-    using value_type = WayIDStartAndEndEdge;
+    using value_type = FirstAndLastSegmentOfWay;
-    bool operator()(const WayIDStartAndEndEdge &a, const WayIDStartAndEndEdge &b) const
+    bool operator()(const FirstAndLastSegmentOfWay &a, const FirstAndLastSegmentOfWay &b) const
     {
         return a.wayID < b.wayID;
     }
-    value_type max_value() { return WayIDStartAndEndEdge::max_value(); }
+    value_type max_value() { return FirstAndLastSegmentOfWay::max_value(); }
-    value_type min_value() { return WayIDStartAndEndEdge::min_value(); }
+    value_type min_value() { return FirstAndLastSegmentOfWay::min_value(); }
 };
 
-struct Cmp
+#endif /* FIRST_AND_LAST_SEGMENT_OF_WAY_H__ */
-{
-    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_ */

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 <limits>
+#include <string>
+
+struct FirstAndLastSegmentOfWay
+{
+    EdgeID wayID;
+    NodeID firstStart;
+    NodeID firstTarget;
+    NodeID lastStart;
+    NodeID lastTarget;
+    FirstAndLastSegmentOfWay()
+        : wayID(std::numeric_limits<unsigned>::max()), firstStart(std::numeric_limits<unsigned>::max()), firstTarget(std::numeric_limits<unsigned>::max()), lastStart(std::numeric_limits<unsigned>::max()),
+          lastTarget(std::numeric_limits<unsigned>::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<unsigned>::min)(),
+                                    (std::numeric_limits<unsigned>::min)(),
+                                    (std::numeric_limits<unsigned>::min)(),
+                                    (std::numeric_limits<unsigned>::min)(),
+                                    (std::numeric_limits<unsigned>::min)());
+    }
+    static FirstAndLastSegmentOfWay max_value()
+    {
+        return FirstAndLastSegmentOfWay((std::numeric_limits<unsigned>::max)(),
+                                    (std::numeric_limits<unsigned>::max)(),
+                                    (std::numeric_limits<unsigned>::max)(),
+                                    (std::numeric_limits<unsigned>::max)(),
+                                    (std::numeric_limits<unsigned>::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_ */