diff --git a/Contractor/EdgeBasedGraphFactory.h b/Contractor/EdgeBasedGraphFactory.h index 2a83fc445..4621d752c 100644 --- a/Contractor/EdgeBasedGraphFactory.h +++ b/Contractor/EdgeBasedGraphFactory.h @@ -39,8 +39,9 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "../DataStructures/OriginalEdgeData.h" #include "../DataStructures/Percent.h" #include "../DataStructures/QueryEdge.h" +#include "../DataStructures/QueryNode.h" #include "../DataStructures/TurnInstructions.h" -#include "../Extractor/ExtractorStructs.h" +#include "../DataStructures/Restriction.h" #include "../Util/LuaUtil.h" #include "../Util/SimpleLogger.h" diff --git a/DataStructures/Restriction.h b/DataStructures/Restriction.h index 7a942612f..9f53ce3bf 100644 --- a/DataStructures/Restriction.h +++ b/DataStructures/Restriction.h @@ -105,13 +105,16 @@ struct InputRestrictionContainer { return InputRestrictionContainer(0, 0, 0, 0); } static InputRestrictionContainer max_value() { - return InputRestrictionContainer(UINT_MAX, UINT_MAX, UINT_MAX, UINT_MAX); + return InputRestrictionContainer( + UINT_MAX, + UINT_MAX, + UINT_MAX, + UINT_MAX + ); } }; -struct CmpRestrictionContainerByFrom : - public std::binary_function -{ +struct CmpRestrictionContainerByFrom { typedef InputRestrictionContainer value_type; inline bool operator()( const InputRestrictionContainer & a, @@ -127,9 +130,9 @@ struct CmpRestrictionContainerByFrom : } }; -struct CmpRestrictionContainerByTo: public std::binary_function { +struct CmpRestrictionContainerByTo { typedef InputRestrictionContainer value_type; - inline bool operator ()( + inline bool operator()( const InputRestrictionContainer & a, const InputRestrictionContainer & b ) const { diff --git a/Extractor/BaseParser.cpp b/Extractor/BaseParser.cpp index 65f3b78bf..23464e413 100644 --- a/Extractor/BaseParser.cpp +++ b/Extractor/BaseParser.cpp @@ -26,14 +26,18 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "BaseParser.h" -#include "ExtractorStructs.h" +#include "ExtractionWay.h" #include "ScriptingEnvironment.h" +#include "../DataStructures/ImportNode.h" #include "../Util/LuaUtil.h" #include "../Util/OSRMException.h" #include "../Util/SimpleLogger.h" +#include +#include #include +#include BaseParser::BaseParser( ExtractorCallbacks * extractor_callbacks, diff --git a/Extractor/ExtractionContainers.cpp b/Extractor/ExtractionContainers.cpp index 4bb3d7485..dc1a7ff60 100644 --- a/Extractor/ExtractionContainers.cpp +++ b/Extractor/ExtractionContainers.cpp @@ -26,6 +26,31 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "ExtractionContainers.h" +#include "ExtractionWay.h" +#include "../Util/SimpleLogger.h" +#include "../Util/TimingUtil.h" + +#include +#include +#include +#include + +#include + +ExtractionContainers::ExtractionContainers() { + //Check if stxxl can be instantiated + stxxl::vector dummy_vector; + name_list.push_back(""); +} + +ExtractionContainers::~ExtractionContainers() { + used_node_id_list.clear(); + all_nodes_list.clear(); + all_edges_list.clear(); + name_list.clear(); + restrictions_list.clear(); + way_start_end_id_list.clear(); +} void ExtractionContainers::PrepareData( const std::string & output_file_name, diff --git a/Extractor/ExtractionContainers.h b/Extractor/ExtractionContainers.h index 254c358da..8fe4d8e10 100644 --- a/Extractor/ExtractionContainers.h +++ b/Extractor/ExtractionContainers.h @@ -28,17 +28,11 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #ifndef EXTRACTIONCONTAINERS_H_ #define EXTRACTIONCONTAINERS_H_ +#include "InternalExtractorEdge.h" #include "ExtractorStructs.h" -#include "../Util/SimpleLogger.h" -#include "../Util/TimingUtil.h" +#include "../DataStructures/Restriction.h" #include "../Util/UUID.h" -#include -#include -#include -#include - -#include #include class ExtractionContainers { @@ -58,20 +52,9 @@ public: STXXLWayIDStartEndVector way_start_end_id_list; const UUID uuid; - ExtractionContainers() { - //Check if stxxl can be instantiated - stxxl::vector dummy_vector; - name_list.push_back(""); - } + ExtractionContainers(); - virtual ~ExtractionContainers() { - used_node_id_list.clear(); - all_nodes_list.clear(); - all_edges_list.clear(); - name_list.clear(); - restrictions_list.clear(); - way_start_end_id_list.clear(); - } + virtual ~ExtractionContainers(); void PrepareData( const std::string & output_file_name, diff --git a/Extractor/ExtractionWay.h b/Extractor/ExtractionWay.h new file mode 100644 index 000000000..addd8ce80 --- /dev/null +++ b/Extractor/ExtractionWay.h @@ -0,0 +1,78 @@ +/* + +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 EXTRACTION_WAY_H +#define EXTRACTION_WAY_H + +#include "../DataStructures/HashTable.h" +#include "../typedefs.h" + +#include +#include + +struct ExtractionWay { + ExtractionWay() { + Clear(); + } + + inline void Clear(){ + id = UINT_MAX; + nameID = UINT_MAX; + path.clear(); + keyVals.clear(); + direction = ExtractionWay::notSure; + speed = -1; + backward_speed = -1; + duration = -1; + type = -1; + access = true; + roundabout = false; + isAccessRestricted = false; + ignoreInGrid = false; + } + + enum Directions { + notSure = 0, oneway, bidirectional, opposite + }; + unsigned id; + unsigned nameID; + double speed; + double backward_speed; + double duration; + Directions direction; + std::string name; + short type; + bool access; + bool roundabout; + bool isAccessRestricted; + bool ignoreInGrid; + std::vector< NodeID > path; + HashTable keyVals; +}; + + +#endif //EXTRACTION_WAY_H diff --git a/Extractor/ExtractorCallbacks.cpp b/Extractor/ExtractorCallbacks.cpp index 423b7b22d..cf3114ad1 100644 --- a/Extractor/ExtractorCallbacks.cpp +++ b/Extractor/ExtractorCallbacks.cpp @@ -27,8 +27,12 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "ExtractionContainers.h" #include "ExtractionHelperFunctions.h" +#include "ExtractionWay.h" #include "ExtractorCallbacks.h" +#include "../DataStructures/Restriction.h" +#include "../Util/SimpleLogger.h" + #include #include @@ -40,11 +44,19 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include -ExtractorCallbacks::ExtractorCallbacks() {externalMemory = NULL; stringMap = NULL; } -ExtractorCallbacks::ExtractorCallbacks(ExtractionContainers * ext, StringMap * strMap) { - externalMemory = ext; - stringMap = strMap; -} +ExtractorCallbacks::ExtractorCallbacks() + : + stringMap(NULL), + externalMemory(NULL) +{ } + +ExtractorCallbacks::ExtractorCallbacks( + ExtractionContainers * ext, + StringMap * strMap +) : + stringMap(strMap), + externalMemory(ext) +{ } ExtractorCallbacks::~ExtractorCallbacks() { } @@ -82,7 +94,7 @@ void ExtractorCallbacks::wayFunction(ExtractionWay &parsed_way) { } //Get the unique identifier for the street name - const StringMap::const_iterator string_map_iterator = stringMap->find(parsed_way.name); + const StringMap::const_iterator & string_map_iterator = stringMap->find(parsed_way.name); if(stringMap->end() == string_map_iterator) { parsed_way.nameID = externalMemory->name_list.size(); externalMemory->name_list.push_back(parsed_way.name); diff --git a/Extractor/ExtractorCallbacks.h b/Extractor/ExtractorCallbacks.h index 68ec213ff..555d19a12 100644 --- a/Extractor/ExtractorCallbacks.h +++ b/Extractor/ExtractorCallbacks.h @@ -29,18 +29,29 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #define EXTRACTORCALLBACKS_H_ #include "ExtractorStructs.h" +#include "../typedefs.h" +#include +#include class ExtractionContainers; +struct ExtractionWay; +struct InputRestrictionContainer; + +typedef boost::unordered_map StringMap; class ExtractorCallbacks{ private: + StringMap * stringMap; ExtractionContainers * externalMemory; ExtractorCallbacks(); public: - explicit ExtractorCallbacks(ExtractionContainers * ext, StringMap * strMap); + explicit ExtractorCallbacks( + ExtractionContainers * ext, + StringMap * strMap + ); ~ExtractorCallbacks(); diff --git a/Extractor/ExtractorStructs.h b/Extractor/ExtractorStructs.h index 1e04ed68e..3803436dd 100644 --- a/Extractor/ExtractorStructs.h +++ b/Extractor/ExtractorStructs.h @@ -30,63 +30,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "../DataStructures/HashTable.h" #include "../DataStructures/ImportNode.h" -#include "../DataStructures/QueryNode.h" -#include "../DataStructures/Restriction.h" #include "../typedefs.h" -#include - -#include -#include -#include -#include - -#include #include -typedef boost::unordered_map StringMap; -typedef boost::unordered_map > StringToIntPairMap; - -struct ExtractionWay { - ExtractionWay() { - Clear(); - } - - inline void Clear(){ - id = UINT_MAX; - nameID = UINT_MAX; - path.clear(); - keyVals.clear(); - direction = ExtractionWay::notSure; - speed = -1; - backward_speed = -1; - duration = -1; - type = -1; - access = true; - roundabout = false; - isAccessRestricted = false; - ignoreInGrid = false; - } - - enum Directions { - notSure = 0, oneway, bidirectional, opposite - }; - unsigned id; - unsigned nameID; - double speed; - double backward_speed; - double duration; - Directions direction; - std::string name; - short type; - bool access; - bool roundabout; - bool isAccessRestricted; - bool ignoreInGrid; - std::vector< NodeID > path; - HashTable keyVals; -}; - struct ExtractorRelation { ExtractorRelation() : type(unknown){} enum { @@ -95,49 +42,34 @@ struct ExtractorRelation { HashTable keyVals; }; -struct InternalExtractorEdge { - InternalExtractorEdge() : start(0), target(0), type(0), direction(0), speed(0), nameID(0), isRoundabout(false), ignoreInGrid(false), isDurationSet(false), isAccessRestricted(false), isContraFlow(false) {}; - InternalExtractorEdge(NodeID s, NodeID t) : start(s), target(t), type(0), direction(0), speed(0), nameID(0), isRoundabout(false), ignoreInGrid(false), isDurationSet(false), isAccessRestricted(false), isContraFlow(false) { } - InternalExtractorEdge(NodeID s, NodeID t, short tp, short d, double sp): start(s), target(t), type(tp), direction(d), speed(sp), nameID(0), isRoundabout(false), ignoreInGrid(false), isDurationSet(false), isAccessRestricted(false), isContraFlow(false) { } - InternalExtractorEdge(NodeID s, NodeID t, short tp, short d, double sp, unsigned nid, bool isra, bool iing, bool ids, bool iar): start(s), target(t), type(tp), direction(d), speed(sp), nameID(nid), isRoundabout(isra), ignoreInGrid(iing), isDurationSet(ids), isAccessRestricted(iar), isContraFlow(false) { - assert(0 <= type); - } - InternalExtractorEdge(NodeID s, NodeID t, short tp, short d, double sp, unsigned nid, bool isra, bool iing, bool ids, bool iar, bool icf): start(s), target(t), type(tp), direction(d), speed(sp), nameID(nid), isRoundabout(isra), ignoreInGrid(iing), isDurationSet(ids), isAccessRestricted(iar), isContraFlow(icf) { - assert(0 <= type); - } - NodeID start; - NodeID target; - short type; - short direction; - double speed; - unsigned nameID; - bool isRoundabout; - bool ignoreInGrid; - bool isDurationSet; - bool isAccessRestricted; - bool isContraFlow; - - FixedPointCoordinate startCoord; - FixedPointCoordinate targetCoord; - - static InternalExtractorEdge min_value() { - return InternalExtractorEdge(0,0); - } - static InternalExtractorEdge max_value() { - return InternalExtractorEdge((std::numeric_limits::max)(), (std::numeric_limits::max)()); - } -}; - - - struct _WayIDStartAndEndEdge { unsigned wayID; NodeID firstStart; NodeID firstTarget; NodeID lastStart; NodeID lastTarget; - _WayIDStartAndEndEdge() : wayID(UINT_MAX), firstStart(UINT_MAX), firstTarget(UINT_MAX), lastStart(UINT_MAX), lastTarget(UINT_MAX) {} - _WayIDStartAndEndEdge(unsigned w, NodeID fs, NodeID ft, NodeID ls, NodeID lt) : wayID(w), firstStart(fs), firstTarget(ft), lastStart(ls), lastTarget(lt) {} + _WayIDStartAndEndEdge() + : + wayID(UINT_MAX), + firstStart(UINT_MAX), + firstTarget(UINT_MAX), + lastStart(UINT_MAX), + lastTarget(UINT_MAX) + { } + + explicit _WayIDStartAndEndEdge( + unsigned w, + NodeID fs, + NodeID ft, + NodeID ls, + NodeID lt + ) : + wayID(w), + firstStart(fs), + firstTarget(ft), + lastStart(ls), + lastTarget(lt) + { } static _WayIDStartAndEndEdge min_value() { return _WayIDStartAndEndEdge((std::numeric_limits::min)(), (std::numeric_limits::min)(), (std::numeric_limits::min)(), (std::numeric_limits::min)(), (std::numeric_limits::min)()); @@ -147,9 +79,12 @@ struct _WayIDStartAndEndEdge { } }; -struct CmpWayByID : public std::binary_function<_WayIDStartAndEndEdge, _WayIDStartAndEndEdge, bool> { +struct CmpWayByID { typedef _WayIDStartAndEndEdge value_type; - bool operator () (const _WayIDStartAndEndEdge & a, const _WayIDStartAndEndEdge & b) const { + bool operator ()( + const _WayIDStartAndEndEdge & a, + const _WayIDStartAndEndEdge & b + ) const { return a.wayID < b.wayID; } value_type max_value() { @@ -160,9 +95,12 @@ struct CmpWayByID : public std::binary_function<_WayIDStartAndEndEdge, _WayIDSta } }; -struct Cmp : public std::binary_function { +struct Cmp { typedef NodeID value_type; - bool operator () (const NodeID a, const NodeID b) const { + bool operator ()( + const NodeID a, + const NodeID b + ) const { return a < b; } value_type max_value() { @@ -173,7 +111,7 @@ struct Cmp : public std::binary_function { } }; -struct CmpNodeByID : public std::binary_function { +struct CmpNodeByID { typedef ExternalMemoryNode value_type; bool operator () ( const ExternalMemoryNode & a, @@ -189,44 +127,4 @@ struct CmpNodeByID : public std::binary_function { - typedef InternalExtractorEdge value_type; - bool operator () (const InternalExtractorEdge & a, const InternalExtractorEdge & b) const { - return a.start < b.start; - } - value_type max_value() { - return InternalExtractorEdge::max_value(); - } - value_type min_value() { - return InternalExtractorEdge::min_value(); - } -}; - -struct CmpEdgeByTargetID : public std::binary_function { - typedef InternalExtractorEdge value_type; - bool operator () (const InternalExtractorEdge & a, const InternalExtractorEdge & b) const { - return a.target < b.target; - } - value_type max_value() { - return InternalExtractorEdge::max_value(); - } - value_type min_value() { - return InternalExtractorEdge::min_value(); - } -}; - -inline std::string GetRandomString() { - char s[128]; - static const char alphanum[] = - "0123456789" - "ABCDEFGHIJKLMNOPQRSTUVWXYZ" - "abcdefghijklmnopqrstuvwxyz"; - - for (int i = 0; i < 127; ++i) { - s[i] = alphanum[rand() % (sizeof(alphanum) - 1)]; - } - s[127] = 0; - return std::string(s); -} - #endif /* EXTRACTORSTRUCTS_H_ */ diff --git a/Extractor/InternalExtractorEdge.h b/Extractor/InternalExtractorEdge.h new file mode 100644 index 000000000..3dca1fa1d --- /dev/null +++ b/Extractor/InternalExtractorEdge.h @@ -0,0 +1,207 @@ +/* + +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 INTERNAL_EXTRACTOR_EDGE_H +#define INTERNAL_EXTRACTOR_EDGE_H + +#include + +#include "../typedefs.h" + +#include + +struct InternalExtractorEdge { + InternalExtractorEdge() + : + start(0), + target(0), + type(0), + direction(0), + speed(0), + nameID(0), + isRoundabout(false), + ignoreInGrid(false), + isDurationSet(false), + isAccessRestricted(false), + isContraFlow(false) + { } + + explicit InternalExtractorEdge(NodeID start, NodeID target) + : + start(start), + target(target), + type(0), + direction(0), + speed(0), + nameID(0), + isRoundabout(false), + ignoreInGrid(false), + isDurationSet(false), + isAccessRestricted(false), + isContraFlow(false) + { } + + explicit InternalExtractorEdge( + NodeID start, + NodeID target, + short type, + short d, + double speed + ) : + start(start), + target(target), + type(type), + direction(d), + speed(speed), + nameID(0), + isRoundabout(false), + ignoreInGrid(false), + isDurationSet(false), + isAccessRestricted(false), + isContraFlow(false) + { } + + explicit InternalExtractorEdge( + NodeID start, + NodeID target, + short type, + short direction, + double speed, + unsigned nameID, + bool isRoundabout, + bool ignoreInGrid, + bool isDurationSet, + bool isAccressRestricted + ) : + start(start), + target(target), + type(type), + direction(direction), + speed(speed), + nameID(nameID), + isRoundabout(isRoundabout), + ignoreInGrid(ignoreInGrid), + isDurationSet(isDurationSet), + isAccessRestricted(isAccressRestricted), + isContraFlow(false) + { + BOOST_ASSERT(0 <= type); + } + + explicit InternalExtractorEdge( + NodeID start, + NodeID target, + short type, + short direction, + double speed, + unsigned nameID, + bool isRoundabout, + bool ignoreInGrid, + bool isDurationSet, + bool isAccressRestricted, + bool isContraFlow + ) : + start(start), + target(target), + type(type), + direction(direction), + speed(speed), + nameID(nameID), + isRoundabout(isRoundabout), + ignoreInGrid(ignoreInGrid), + isDurationSet(isDurationSet), + isAccessRestricted(isAccressRestricted), + isContraFlow(isContraFlow) + { + BOOST_ASSERT(0 <= type); + } + + // necessary static util functions for stxxl's sorting + static InternalExtractorEdge min_value() { + return InternalExtractorEdge(0,0); + } + static InternalExtractorEdge max_value() { + return InternalExtractorEdge( + std::numeric_limits::max(), + std::numeric_limits::max() + ); + } + + NodeID start; + NodeID target; + short type; + short direction; + double speed; + unsigned nameID; + bool isRoundabout; + bool ignoreInGrid; + bool isDurationSet; + bool isAccessRestricted; + bool isContraFlow; + + FixedPointCoordinate startCoord; + FixedPointCoordinate targetCoord; +}; + +struct CmpEdgeByStartID { + typedef InternalExtractorEdge value_type; + bool operator ()( + const InternalExtractorEdge & a, + const InternalExtractorEdge & b + ) const { + return a.start < b.start; + } + + value_type max_value() { + return InternalExtractorEdge::max_value(); + } + + value_type min_value() { + return InternalExtractorEdge::min_value(); + } +}; + +struct CmpEdgeByTargetID { + typedef InternalExtractorEdge value_type; + + bool operator ()( + const InternalExtractorEdge & a, + const InternalExtractorEdge & b + ) const { + return a.target < b.target; + } + + value_type max_value() { + return InternalExtractorEdge::max_value(); + } + + value_type min_value() { + return InternalExtractorEdge::min_value(); + } +}; + +#endif //INTERNAL_EXTRACTOR_EDGE_H diff --git a/Extractor/PBFParser.cpp b/Extractor/PBFParser.cpp index b8e998e7d..106d9c40f 100644 --- a/Extractor/PBFParser.cpp +++ b/Extractor/PBFParser.cpp @@ -25,12 +25,14 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#include "ExtractorCallbacks.h" -#include "ExtractorStructs.h" #include "PBFParser.h" + +#include "ExtractionWay.h" +#include "ExtractorCallbacks.h" #include "ScriptingEnvironment.h" #include "../DataStructures/HashTable.h" +#include "../DataStructures/Restriction.h" #include "../Util/MachineInfo.h" #include "../Util/OpenMPWrapper.h" #include "../Util/OSRMException.h" diff --git a/Extractor/ScriptingEnvironment.cpp b/Extractor/ScriptingEnvironment.cpp index baafdb10d..d904b649a 100644 --- a/Extractor/ScriptingEnvironment.cpp +++ b/Extractor/ScriptingEnvironment.cpp @@ -25,9 +25,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#include "ExtractionHelperFunctions.h" -#include "ExtractorStructs.h" #include "ScriptingEnvironment.h" + +#include "ExtractionHelperFunctions.h" +#include "ExtractionWay.h" #include "../DataStructures/ImportNode.h" #include "../Util/LuaUtil.h" #include "../Util/OpenMPWrapper.h" diff --git a/Extractor/XMLParser.cpp b/Extractor/XMLParser.cpp index 5da7e52d7..e0deb29f5 100644 --- a/Extractor/XMLParser.cpp +++ b/Extractor/XMLParser.cpp @@ -27,9 +27,11 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "XMLParser.h" -#include "ExtractorStructs.h" +#include "ExtractionWay.h" #include "../DataStructures/HashTable.h" +#include "../DataStructures/ImportNode.h" #include "../DataStructures/InputReaderFactory.h" +#include "../DataStructures/Restriction.h" #include "../Util/SimpleLogger.h" #include "../Util/StringUtil.h" #include "../typedefs.h" diff --git a/Util/StringUtil.h b/Util/StringUtil.h index d4b46cce2..8a86df109 100644 --- a/Util/StringUtil.h +++ b/Util/StringUtil.h @@ -184,4 +184,18 @@ inline bool StringStartsWith( return boost::starts_with(input, prefix); } +inline std::string GetRandomString() { + char s[128]; + static const char alphanum[] = + "0123456789" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + "abcdefghijklmnopqrstuvwxyz"; + + for (int i = 0; i < 127; ++i) { + s[i] = alphanum[rand() % (sizeof(alphanum) - 1)]; + } + s[127] = 0; + return std::string(s); +} + #endif /* STRINGUTIL_H_ */ diff --git a/extractor.cpp b/extractor.cpp index 35c590cb7..1eda249fa 100644 --- a/extractor.cpp +++ b/extractor.cpp @@ -37,6 +37,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "Util/ProgramOptions.h" #include "Util/SimpleLogger.h" #include "Util/StringUtil.h" +#include "Util/TimingUtil.h" #include "Util/UUID.h" #include "typedefs.h"