fix indentation

Better file not found error

.gitignore

@@ -33,11 +33,11 @@ ehthumbs.db
 Icon?
 Thumbs.db
 
-# SCons related files #
+# build related files #
 #######################
-SconsBuilder*
-.scon*
-.build
+/build/
+/Util/UUID.cpp
+/Util/GitDescription.cpp
 
 # Eclipse related files #
 #########################
@@ -54,30 +54,38 @@ stxxl.errlog
 
 # compiled protobuffers #
 #########################
-DataStructures/pbf-proto/*.pb.h
-DataStructures/pbf-proto/*.pb.cc
+/DataStructures/pbf-proto/*.pb.h
+/DataStructures/pbf-proto/*.pb.cc
 
 # External Libs #
 #################
-lib/
-win/lib
+/lib/
+/win/lib
 
 # Visual Studio Temp + build Files #
 ####################################
-win/*.user
-win/*.ncb
-win/*.suo
-win/Debug/
-win/Release/
-win/bin/
-win/bin-debug/
+/win/*.user
+/win/*.ncb
+/win/*.suo
+/win/Debug/
+/win/Release/
+/win/bin/
+/win/bin-debug/
 /osrm-extract
+/osrm-io-benchmark
+/osrm-components
 /osrm-routed
+/osrm-datastore
 /osrm-prepare
+/osrm-cli
 /nohup.out
 
 # Sandbox folder #
 ###################
-sandbox/
+/sandbox/
 
-test/profile.lua
+/test/profile.lua
+
+# Deprecated config file #
+##########################
+/server.ini

.travis.yml

@@ -0,0 +1,36 @@
+language: cpp
+compiler:
+  - gcc
+#  - clang
+# Make sure CMake is installed
+install:
+ - sudo apt-get update >/dev/null
+ - sudo apt-get -q install libprotoc-dev libprotobuf7 protobuf-compiler libprotobuf-dev libosmpbf-dev libpng12-dev libbz2-dev libstxxl-dev libstxxl-doc libstxxl1 libxml2-dev libzip-dev libboost1.46-all-dev lua5.1 liblua5.1-0-dev libluabind-dev rubygems osmosis
+before_script:
+ - sudo gem install bundler
+ - bundle install
+ - mkdir build
+ - cd build
+ - cmake .. $CMAKEOPTIONS
+script: make
+branches:
+  only:
+    - master
+    - develop
+env:
+ - CMAKEOPTIONS="-DCMAKE_BUILD_TYPE=Release"
+ - CMAKEOPTIONS="-DCMAKE_BUILD_TYPE=Debug"
+notifications:
+ irc:
+  channels:
+    - irc.oftc.net#osrm
+  on_success: change
+  on_failure: always
+  use_notice: true
+  skip_join: false
+
+  recipients:
+    - dennis@mapbox.com
+  email:
+    on_success: change
+    on_failure: always

AUTHORS.TXT

@@ -1,11 +0,0 @@
-The following people contributed code to the Open Source Routing Machine:
-
-Christian Vetter 
-Dennis Luxen
-Ruslan Krenzler
-Frederik Ramm
-Bharath Vissapragada
-Pascal Neis
-Sasa Ivetic
-Emil Tin
-Henning Moll

Algorithms/Bresenham.h

@@ -1,49 +0,0 @@
-/*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
-
-#ifndef BRESENHAM_H_
-#define BRESENHAM_H_
-
-#include <cmath>
-#include <vector>
-typedef std::pair<unsigned, unsigned> BresenhamPixel;
-
-inline void Bresenham (int x0, int y0, int x1, int y1, std::vector<BresenhamPixel> &resultList) {
-    int dx = std::abs(x1-x0);
-    int dy = std::abs(y1-y0);
-    int sx = (x0 < x1 ? 1 : -1);
-    int sy = (y0 < y1 ? 1 : -1);
-    int err = dx - dy;
-    while(true) {
-        resultList.push_back(std::make_pair(x0,y0));
-        if(x0 == x1 && y0 == y1) break;
-        int e2 = 2* err;
-        if ( e2 > -dy) {
-            err -= dy;
-            x0 += sx;
-        }
-        if(e2 < dx) {
-            err+= dx;
-            y0 += sy;
-        }
-    }
-}
-
-#endif /* BRESENHAM_H_ */

Algorithms/CRC32.cpp

@@ -1,85 +0,0 @@
-/*
- open source routing machine
- Copyright (C) Dennis Luxen, others 2010
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU AFFERO General Public License as published by
- the Free Software Foundation; either version 3 of the License, or
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU Affero General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- or see http://www.gnu.org/licenses/agpl.txt.
- */
-
-#include "CRC32.h"
-
-CRC32::CRC32() : crc(0) {
-    crcFunction = detectBestCRC32C();
-}
-
-unsigned CRC32::SoftwareBasedCRC32(char *str, unsigned len, unsigned ) {
-    boost::crc_optimal<32, 0x1EDC6F41, 0x0, 0x0, true, true> CRC32_Processor;
-    CRC32_Processor.process_bytes( str, len);
-    return CRC32_Processor.checksum();
-}
-
-unsigned CRC32::SSEBasedCRC32( char *str, unsigned len, unsigned crc) {
-    unsigned q=len/sizeof(unsigned),
-            r=len%sizeof(unsigned),
-            *p=(unsigned*)str/*, crc*/;
-
-    //crc=0;
-    while (q--) {
-        __asm__ __volatile__(
-                ".byte 0xf2, 0xf, 0x38, 0xf1, 0xf1;"
-                :"=S"(crc)
-                 :"0"(crc), "c"(*p)
-        );
-        ++p;
-    }
-
-    str=(char*)p;
-    while (r--) {
-        __asm__ __volatile__(
-                ".byte 0xf2, 0xf, 0x38, 0xf1, 0xf1;"
-                :"=S"(crc)
-                 :"0"(crc), "c"(*str)
-        );
-        ++str;
-    }
-    return crc;
-}
-
-CRC32::CRC32CFunctionPtr CRC32::detectBestCRC32C() {
-    static const int SSE42_BIT = 20;
-    unsigned ecx = cpuid(1);
-    bool hasSSE42 = ecx & (1 << SSE42_BIT);
-    if (hasSSE42) {
-        std::cout << "using hardware base sse computation" << std::endl;
-        return &CRC32::SSEBasedCRC32; //crc32 hardware accelarated;
-    } else {
-        std::cout << "using software base sse computation" << std::endl;
-        return &CRC32::SoftwareBasedCRC32; //crc32cSlicingBy8;
-    }
-}
-
-unsigned CRC32::cpuid(unsigned functionInput) {
-    unsigned eax;
-    unsigned ebx;
-    unsigned ecx;
-    unsigned edx;
-    asm("cpuid" : "=a" (eax), "=b" (ebx), "=c" (ecx), "=d" (edx) : "a" (functionInput));
-    return ecx;
-}
-
-unsigned CRC32::operator()(char *str, unsigned len){
-    crc =((*this).*(crcFunction))(str, len, crc);
-    return crc;
-}

Algorithms/CRC32.h

@@ -1,46 +0,0 @@
-/*
- open source routing machine
- Copyright (C) Dennis Luxen, others 2010
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU AFFERO General Public License as published by
- the Free Software Foundation; either version 3 of the License, or
- any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU Affero General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- or see http://www.gnu.org/licenses/agpl.txt.
- */
-
-#ifndef CRC32_H_
-#define CRC32_H_
-
-#include <boost/crc.hpp>  // for boost::crc_32_type
-#include <iostream>
-
-class CRC32 {
-private:
-    unsigned crc;
-    unsigned slowcrc_table[1<<8];
-
-    typedef boost::crc_optimal<32, 0x1EDC6F41, 0x0, 0x0, true, true> my_crc_32_type;
-    typedef unsigned (CRC32::*CRC32CFunctionPtr)(char *str, unsigned len, unsigned crc);
-
-    unsigned SoftwareBasedCRC32(char *str, unsigned len, unsigned crc);
-    unsigned SSEBasedCRC32( char *str, unsigned len, unsigned crc);
-    unsigned cpuid(unsigned functionInput);
-    CRC32CFunctionPtr detectBestCRC32C();
-    CRC32CFunctionPtr crcFunction;
-public:
-    CRC32();
-    unsigned operator()(char *str, unsigned len);
-    virtual ~CRC32() {};
-};
-
-#endif /* CRC32_H_ */

Algorithms/DouglasPeucker.h

@@ -1,32 +1,43 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 DOUGLASPEUCKER_H_
 #define DOUGLASPEUCKER_H_
 
-#include <cassert>
-#include <cmath>
-#include <cfloat>
-#include <stack>
-
 #include "../DataStructures/Coordinate.h"
+#include "../DataStructures/SegmentInformation.h"
+
+#include <boost/assert.hpp>
+
+#include <cmath>
+
+#include <limits>
+#include <stack>
+#include <vector>
 
 /*This class object computes the bitvector of indicating generalized input points
  * according to the (Ramer-)Douglas-Peucker algorithm.
@@ -35,95 +46,24 @@ or see http://www.gnu.org/licenses/agpl.txt.
  * indicating if the points is present in the generalization.
  * Note: points may also be pre-selected*/
 
-//These thresholds are more or less heuristically chosen.
-//                                                  0          1         2         3         4          5         6         7       8       9       10     11       12     13    14   15  16  17   18
-static double DouglasPeuckerThresholds[19] = { 32000000., 16240000., 80240000., 40240000., 20000000., 10000000., 500000., 240000., 120000., 60000., 30000., 19000., 5000., 2000., 200, 16,  6, 3. , 3. };
-
-template<class PointT>
 class DouglasPeucker {
 private:
     typedef std::pair<std::size_t, std::size_t> PairOfPoints;
     //Stack to simulate the recursion
-    std::stack<PairOfPoints > recursionStack;
+    std::stack<PairOfPoints > recursion_stack;
 
     /**
      * This distance computation does integer arithmetic only and is about twice as fast as
      * the other distance function. It is an approximation only, but works more or less ok.
      */
-    template<class CoordT>
-    inline int fastDistance(const CoordT& point, const CoordT& segA, const CoordT& segB) const {
-        const int p2x = (segB.lon - segA.lat);
-        const int p2y = (segB.lon - segA.lat);
-        const int something = p2x*p2x + p2y*p2y;
-        int u = (something < FLT_EPSILON ? 0 : ((point.lon - segA.lon) * p2x + (point.lat - segA.lat) * p2y) / something);
-
-        if (u > 1)
-            u = 1;
-        else if (u < 0)
-            u = 0;
-
-        const int x = segA.lon + u * p2x;
-        const int y = segA.lat + u * p2y;
-
-        const int dx = x - point.lon;
-        const int dy = y - point.lat;
-
-        const int dist = (dx*dx + dy*dy);
-
-        return dist;
-    }
-
-
+    int fastDistance(
+        const FixedPointCoordinate& point,
+        const FixedPointCoordinate& segA,
+        const FixedPointCoordinate& segB
+    ) const;
 public:
-    void Run(std::vector<PointT> & inputVector, const unsigned zoomLevel) {
-        {
-            assert(zoomLevel < 19);
-            assert(1 < inputVector.size());
-            std::size_t leftBorderOfRange = 0;
-            std::size_t rightBorderOfRange = 1;
-            //Sweep linerarily over array and identify those ranges that need to be checked
-//            recursionStack.hint(inputVector.size());
-            do {
-                assert(inputVector[leftBorderOfRange].necessary);
-                assert(inputVector.back().necessary);
+    void Run(std::vector<SegmentInformation> & input_geometry, const unsigned zoom_level);
 
-                if(inputVector[rightBorderOfRange].necessary) {
-                    recursionStack.push(std::make_pair(leftBorderOfRange, rightBorderOfRange));
-                    leftBorderOfRange = rightBorderOfRange;
-                }
-                ++rightBorderOfRange;
-            } while( rightBorderOfRange < inputVector.size());
-        }
-        while(!recursionStack.empty()) {
-            //pop next element
-            const PairOfPoints pair = recursionStack.top();
-            recursionStack.pop();
-            assert(inputVector[pair.first].necessary);
-            assert(inputVector[pair.second].necessary);
-            assert(pair.second < inputVector.size());
-            assert(pair.first < pair.second);
-            int maxDistance = INT_MIN;
-
-            std::size_t indexOfFarthestElement = pair.second;
-            //find index idx of element with maxDistance
-            for(std::size_t i = pair.first+1; i < pair.second; ++i){
-                const double distance = std::fabs(fastDistance(inputVector[i].location, inputVector[pair.first].location, inputVector[pair.second].location));
-                if(distance > DouglasPeuckerThresholds[zoomLevel] && distance > maxDistance) {
-                    indexOfFarthestElement = i;
-                    maxDistance = distance;
-                }
-            }
-            if (maxDistance > DouglasPeuckerThresholds[zoomLevel]) {
-                //  mark idx as necessary
-                inputVector[indexOfFarthestElement].necessary = true;
-                if (1 < indexOfFarthestElement - pair.first) {
-                    recursionStack.push(std::make_pair(pair.first, indexOfFarthestElement) );
-                }
-                if (1 < pair.second - indexOfFarthestElement)
-                    recursionStack.push(std::make_pair(indexOfFarthestElement, pair.second) );
-            }
-        }
-    }
 };
 
 #endif /* DOUGLASPEUCKER_H_ */

Algorithms/DouglasePeucker.cpp

@@ -0,0 +1,166 @@
+/*
+
+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.
+
+*/
+
+#include "DouglasPeucker.h"
+
+//These thresholds are more or less heuristically chosen.
+static double DouglasPeuckerThresholds[19] = {
+    32000000., //z0
+    16240000., //z1
+     8240000., //z2
+     4240000., //z3
+     2000000., //z4
+     1000000., //z5
+      500000., //z6
+      240000., //z7
+      120000., //z8
+       60000., //z9
+       30000., //z10
+       19000., //z11
+        5000., //z12
+        2000., //z13
+         200., //z14
+          16., //z15
+           6., //z16
+           3., //z17
+           3.  //z18
+};
+
+/**
+ * This distance computation does integer arithmetic only and is about twice as
+ * fast as the other distance function. It is an approximation only, but works
+ * more or less ok.
+ */
+int DouglasPeucker::fastDistance(
+    const FixedPointCoordinate& point,
+    const FixedPointCoordinate& segA,
+    const FixedPointCoordinate& segB
+) const {
+    const int p2x = (segB.lon - segA.lon);
+    const int p2y = (segB.lat - segA.lat);
+    const int something = p2x*p2x + p2y*p2y;
+    double u = ( 0 == something  ? 0 : ((point.lon - segA.lon) * p2x + (point.lat - segA.lat) * p2y) / something);
+
+    if (u > 1) {
+        u = 1;
+    } else if (u < 0) {
+        u = 0;
+    }
+
+    const int x = segA.lon + u * p2x;
+    const int y = segA.lat + u * p2y;
+
+    const int dx = x - point.lon;
+    const int dy = y - point.lat;
+
+    const int dist = (dx*dx + dy*dy);
+
+    return dist;
+}
+
+void DouglasPeucker::Run(
+    std::vector<SegmentInformation> & input_geometry,
+    const unsigned zoom_level
+) {
+    {
+        BOOST_ASSERT_MSG(zoom_level < 19, "unsupported zoom level");
+        BOOST_ASSERT_MSG(1 < input_geometry.size(), "geometry invalid");
+        std::size_t left_border = 0;
+        std::size_t right_border = 1;
+        //Sweep linerarily over array and identify those ranges that need to be checked
+        do {
+            BOOST_ASSERT_MSG(
+                input_geometry[left_border].necessary,
+                "left border must be necessary"
+            );
+            BOOST_ASSERT_MSG(
+                input_geometry.back().necessary,
+                "right border must be necessary"
+            );
+
+            if(input_geometry[right_border].necessary) {
+                recursion_stack.push(std::make_pair(left_border, right_border));
+                left_border = right_border;
+            }
+            ++right_border;
+        } while( right_border < input_geometry.size());
+    }
+    while(!recursion_stack.empty()) {
+        //pop next element
+        const PairOfPoints pair = recursion_stack.top();
+        recursion_stack.pop();
+        BOOST_ASSERT_MSG(
+            input_geometry[pair.first].necessary,
+            "left border mus be necessary"
+        );
+        BOOST_ASSERT_MSG(
+            input_geometry[pair.second].necessary,
+            "right border must be necessary"
+        );
+        BOOST_ASSERT_MSG(
+            pair.second < input_geometry.size(),
+            "right border outside of geometry"
+        );
+        BOOST_ASSERT_MSG(
+            pair.first < pair.second,
+            "left border on the wrong side"
+        );
+        int max_distance = INT_MIN;
+
+        std::size_t farthest_element_index = pair.second;
+        //find index idx of element with max_distance
+        for(std::size_t i = pair.first+1; i < pair.second; ++i){
+            const int temp_dist = fastDistance(
+                                    input_geometry[i].location,
+                                    input_geometry[pair.first].location,
+                                    input_geometry[pair.second].location
+                                );
+            const double distance = std::fabs(temp_dist);
+            if(
+                distance > DouglasPeuckerThresholds[zoom_level] &&
+                distance > max_distance
+            ) {
+                farthest_element_index = i;
+                max_distance = distance;
+            }
+        }
+        if (max_distance > DouglasPeuckerThresholds[zoom_level]) {
+            //  mark idx as necessary
+            input_geometry[farthest_element_index].necessary = true;
+            if (1 < (farthest_element_index - pair.first) ) {
+                recursion_stack.push(
+                    std::make_pair(pair.first, farthest_element_index)
+                );
+            }
+            if (1 < (pair.second - farthest_element_index) ) {
+                recursion_stack.push(
+                    std::make_pair(farthest_element_index, pair.second)
+                );
+            }
+        }
+    }
+}

Algorithms/IteratorBasedCRC32.h

@@ -1,27 +1,35 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 ITERATORBASEDCRC32_H_
 #define ITERATORBASEDCRC32_H_
 
+#include "../Util/SimpleLogger.h"
+
 #include <boost/crc.hpp>  // for boost::crc_32_type
 #include <iostream>
 
@@ -30,7 +38,6 @@ class IteratorbasedCRC32 {
 private:
     typedef typename ContainerT::iterator ContainerT_iterator;
     unsigned crc;
-    unsigned slowcrc_table[1<<8];
 
     typedef boost::crc_optimal<32, 0x1EDC6F41, 0x0, 0x0, true, true> my_crc_32_type;
     typedef unsigned (IteratorbasedCRC32::*CRC32CFunctionPtr)(char *str, unsigned len, unsigned crc);
@@ -81,10 +88,10 @@ private:
         unsigned ecx = cpuid(1);
         bool hasSSE42 = ecx & (1 << SSE42_BIT);
         if (hasSSE42) {
-            std::cout << "using hardware base sse computation" << std::endl;
+            SimpleLogger().Write() << "using hardware based CRC32 computation";
             return &IteratorbasedCRC32::SSEBasedCRC32; //crc32 hardware accelarated;
         } else {
-            std::cout << "using software base sse computation" << std::endl;
+            SimpleLogger().Write() << "using software based CRC32 computation";
             return &IteratorbasedCRC32::SoftwareBasedCRC32; //crc32cSlicingBy8;
         }
     }
@@ -94,7 +101,7 @@ public:
         crcFunction = detectBestCRC32C();
     }
 
-    virtual ~IteratorbasedCRC32() {};
+    virtual ~IteratorbasedCRC32() { }
 
     unsigned operator()( ContainerT_iterator iter, const ContainerT_iterator end) {
         unsigned crc = 0;

Algorithms/ObjectToBase64.h

@@ -1,26 +1,36 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 OBJECTTOBASE64_H_
 #define OBJECTTOBASE64_H_
 
+#include "../Util/StringUtil.h"
+
+#include <boost/assert.hpp>
 #include <boost/archive/iterators/base64_from_binary.hpp>
 #include <boost/archive/iterators/binary_from_base64.hpp>
 #include <boost/archive/iterators/transform_width.hpp>
@@ -28,40 +38,63 @@ or see http://www.gnu.org/licenses/agpl.txt.
 
 #include <algorithm>
 #include <string>
-
-#include "../Util/StringUtil.h"
+#include <vector>
 
 typedef
         boost::archive::iterators::base64_from_binary<
-        boost::archive::iterators::transform_width<string::const_iterator, 6, 8>
-> base64_t;
+            boost::archive::iterators::transform_width<const char *, 6, 8>
+        > base64_t;
 
 typedef
         boost::archive::iterators::transform_width<
-        boost::archive::iterators::binary_from_base64<string::const_iterator>, 8, 6
+            boost::archive::iterators::binary_from_base64<
+            std::string::const_iterator>, 8, 6
         > binary_t;
 
-template<class ToEncodeT>
-static void EncodeObjectToBase64(const ToEncodeT & object, std::string& encoded) {
-    encoded.clear();
-    char * pointerToOriginalObject = (char *)&object;
-    encoded = std::string(base64_t(pointerToOriginalObject), base64_t(pointerToOriginalObject+sizeof(ToEncodeT)));
-    //replace "+" with "-" and "/" with "_"
+template<class ObjectT>
+static void EncodeObjectToBase64(const ObjectT & object, std::string& encoded) {
+    const char * char_ptr_to_object = (const char *)&object;
+    std::vector<unsigned char> data(sizeof(object));
+    std::copy(
+        char_ptr_to_object,
+        char_ptr_to_object + sizeof(ObjectT),
+        data.begin()
+    );
+
+    unsigned char number_of_padded_chars = 0; // is in {0,1,2};
+    while(data.size() % 3 != 0)  {
+      ++number_of_padded_chars;
+      data.push_back(0x00);
+    }
+
+    BOOST_ASSERT_MSG(
+        0 == data.size() % 3,
+        "base64 input data size is not a multiple of 3!"
+    );
+    encoded.resize(sizeof(ObjectT));
+    encoded.assign(
+        base64_t( &data[0] ),
+        base64_t( &data[0] + (data.size() - number_of_padded_chars) )
+    );
     replaceAll(encoded, "+", "-");
     replaceAll(encoded, "/", "_");
 }
 
-template<class ToEncodeT>
-static void DecodeObjectFromBase64(ToEncodeT & object, const std::string& _encoded) {
+template<class ObjectT>
+static void DecodeObjectFromBase64(const std::string& input, ObjectT & object) {
     try {
-        string encoded(_encoded);
+    	std::string encoded(input);
         //replace "-" with "+" and "_" with "/"
         replaceAll(encoded, "-", "+");
         replaceAll(encoded, "_", "/");
-        char * pointerToDecodedObject = (char *)&object;
-        std::string dec(binary_t(encoded.begin()), binary_t(encoded.begin() + encoded.length() - 1));
-        std::copy ( dec.begin(), dec.end(), pointerToDecodedObject );
-    } catch(...) {}
+
+        std::copy (
+            binary_t( encoded.begin() ),
+            binary_t( encoded.begin() + encoded.length() - 1),
+            (char *)&object
+        );
+
+    } catch(...) { }
 }
 
 #endif /* OBJECTTOBASE64_H_ */

Algorithms/PolylineCompressor.cpp

@@ -0,0 +1,147 @@
+/*
+
+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.
+
+*/
+
+#include "PolylineCompressor.h"
+
+void PolylineCompressor::encodeVectorSignedNumber(
+    std::vector<int> & numbers,
+    std::string & output
+) const {
+    for(unsigned i = 0; i < numbers.size(); ++i) {
+        numbers[i] <<= 1;
+        if (numbers[i] < 0) {
+            numbers[i] = ~(numbers[i]);
+        }
+    }
+    for(unsigned i = 0; i < numbers.size(); ++i) {
+        encodeNumber(numbers[i], output);
+    }
+}
+
+void PolylineCompressor::encodeNumber(int number_to_encode, std::string & output) const {
+    while (number_to_encode >= 0x20) {
+        int nextValue = (0x20 | (number_to_encode & 0x1f)) + 63;
+        output += static_cast<char>(nextValue);
+        if(92 == nextValue) {
+            output += static_cast<char>(nextValue);
+        }
+        number_to_encode >>= 5;
+    }
+
+    number_to_encode += 63;
+    output += static_cast<char>(number_to_encode);
+    if(92 == number_to_encode) {
+        output += static_cast<char>(number_to_encode);
+    }
+}
+
+void PolylineCompressor::printEncodedString(
+    const std::vector<SegmentInformation> & polyline,
+    std::string & output
+) const {
+    std::vector<int> deltaNumbers;
+    output += "\"";
+    if(!polyline.empty()) {
+        FixedPointCoordinate lastCoordinate = polyline[0].location;
+        deltaNumbers.push_back( lastCoordinate.lat );
+        deltaNumbers.push_back( lastCoordinate.lon );
+        for(unsigned i = 1; i < polyline.size(); ++i) {
+            if(!polyline[i].necessary) {
+                continue;
+            }
+            deltaNumbers.push_back(polyline[i].location.lat - lastCoordinate.lat);
+            deltaNumbers.push_back(polyline[i].location.lon - lastCoordinate.lon);
+            lastCoordinate = polyline[i].location;
+        }
+        encodeVectorSignedNumber(deltaNumbers, output);
+    }
+    output += "\"";
+
+}
+
+void PolylineCompressor::printEncodedString(
+    const std::vector<FixedPointCoordinate>& polyline,
+    std::string &output
+) const {
+    std::vector<int> deltaNumbers(2*polyline.size());
+    output += "\"";
+    if(!polyline.empty()) {
+        deltaNumbers[0] = polyline[0].lat;
+        deltaNumbers[1] = polyline[0].lon;
+        for(unsigned i = 1; i < polyline.size(); ++i) {
+            deltaNumbers[(2*i)]   = (polyline[i].lat - polyline[i-1].lat);
+            deltaNumbers[(2*i)+1] = (polyline[i].lon - polyline[i-1].lon);
+        }
+        encodeVectorSignedNumber(deltaNumbers, output);
+    }
+    output += "\"";
+}
+
+void PolylineCompressor::printUnencodedString(
+    const std::vector<FixedPointCoordinate> & polyline,
+    std::string & output
+) const {
+    output += "[";
+    std::string tmp;
+    for(unsigned i = 0; i < polyline.size(); i++) {
+        convertInternalLatLonToString(polyline[i].lat, tmp);
+        output += "[";
+        output += tmp;
+        convertInternalLatLonToString(polyline[i].lon, tmp);
+        output += ", ";
+        output += tmp;
+        output += "]";
+        if( i < polyline.size()-1 ) {
+            output += ",";
+        }
+    }
+    output += "]";
+}
+
+void PolylineCompressor::printUnencodedString(
+    const std::vector<SegmentInformation> & polyline,
+    std::string & output
+) const {
+    output += "[";
+    std::string tmp;
+    for(unsigned i = 0; i < polyline.size(); i++) {
+        if(!polyline[i].necessary) {
+            continue;
+        }
+        convertInternalLatLonToString(polyline[i].location.lat, tmp);
+        output += "[";
+        output += tmp;
+        convertInternalLatLonToString(polyline[i].location.lon, tmp);
+        output += ", ";
+        output += tmp;
+        output += "]";
+        if( i < polyline.size()-1 ) {
+            output += ",";
+        }
+    }
+    output += "]";
+}

Algorithms/PolylineCompressor.h

@@ -1,134 +1,69 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 POLYLINECOMPRESSOR_H_
 #define POLYLINECOMPRESSOR_H_
 
-#include <string>
-
-//#include "../DataStructures/ExtractorStructs.h"
 #include "../DataStructures/SegmentInformation.h"
 #include "../Util/StringUtil.h"
 
+#include <string>
+#include <vector>
+
 class PolylineCompressor {
 private:
-	inline void encodeVectorSignedNumber(std::vector<int> & numbers, std::string & output) const {
-		for(unsigned i = 0; i < numbers.size(); ++i) {
-			numbers[i] <<= 1;
-			if (numbers[i] < 0) {
-				numbers[i] = ~(numbers[i]);
-			}
-		}
-		for(unsigned i = 0; i < numbers.size(); ++i) {
-			encodeNumber(numbers[i], output);
-		}
-	}
+	void encodeVectorSignedNumber(
+        std::vector<int> & numbers,
+        std::string & output
+    ) const;
 
-	inline void encodeNumber(int numberToEncode, std::string & output) const {
-		while (numberToEncode >= 0x20) {
-			int nextValue = (0x20 | (numberToEncode & 0x1f)) + 63;
-			output += (static_cast<char> (nextValue));
-			if(92 == nextValue)
-				output += (static_cast<char> (nextValue));
-			numberToEncode >>= 5;
-		}
-
-		numberToEncode += 63;
-		output += (static_cast<char> (numberToEncode));
-		if(92 == numberToEncode)
-			output += (static_cast<char> (numberToEncode));
-	}
+	void encodeNumber(int number_to_encode, std::string & output) const;
 
 public:
-    inline void printEncodedString(const std::vector<SegmentInformation>& polyline, std::string &output) const {
-    	std::vector<int> deltaNumbers;
-        output += "\"";
-        if(!polyline.empty()) {
-            _Coordinate lastCoordinate = polyline[0].location;
-            deltaNumbers.push_back( lastCoordinate.lat );
-            deltaNumbers.push_back( lastCoordinate.lon );
-            for(unsigned i = 1; i < polyline.size(); ++i) {
-                if(!polyline[i].necessary)
-                    continue;
-                deltaNumbers.push_back(polyline[i].location.lat - lastCoordinate.lat);
-                deltaNumbers.push_back(polyline[i].location.lon - lastCoordinate.lon);
-                lastCoordinate = polyline[i].location;
-            }
-            encodeVectorSignedNumber(deltaNumbers, output);
-        }
-        output += "\"";
+    void printEncodedString(
+        const std::vector<SegmentInformation> & polyline,
+        std::string & output
+    ) const;
 
-    }
+    void printEncodedString(
+        const std::vector<FixedPointCoordinate>& polyline,
+        std::string &output
+    ) const;
 
-	inline void printEncodedString(const std::vector<_Coordinate>& polyline, std::string &output) const {
-		std::vector<int> deltaNumbers(2*polyline.size());
-		output += "\"";
-		if(!polyline.empty()) {
-			deltaNumbers[0] = polyline[0].lat;
-			deltaNumbers[1] = polyline[0].lon;
-			for(unsigned i = 1; i < polyline.size(); ++i) {
-				deltaNumbers[(2*i)]   = (polyline[i].lat - polyline[i-1].lat);
-				deltaNumbers[(2*i)+1] = (polyline[i].lon - polyline[i-1].lon);
-			}
-			encodeVectorSignedNumber(deltaNumbers, output);
-		}
-		output += "\"";
-	}
+    void printUnencodedString(
+        const std::vector<FixedPointCoordinate> & polyline,
+        std::string & output
+    ) const;
 
-    inline void printUnencodedString(std::vector<_Coordinate> & polyline, std::string & output) const {
-        output += "[";
-        std::string tmp;
-        for(unsigned i = 0; i < polyline.size(); i++) {
-            convertInternalLatLonToString(polyline[i].lat, tmp);
-            output += "[";
-            output += tmp;
-            convertInternalLatLonToString(polyline[i].lon, tmp);
-            output += ", ";
-            output += tmp;
-            output += "]";
-            if( i < polyline.size()-1 ) {
-                output += ",";
-            }
-        }
-        output += "]";
-    }
+    void printUnencodedString(
+        const std::vector<SegmentInformation> & polyline,
+        std::string & output
+    ) const;
 
-    inline void printUnencodedString(std::vector<SegmentInformation> & polyline, std::string & output) const {
-        output += "[";
-        std::string tmp;
-        for(unsigned i = 0; i < polyline.size(); i++) {
-            if(!polyline[i].necessary)
-                continue;
-            convertInternalLatLonToString(polyline[i].location.lat, tmp);
-            output += "[";
-            output += tmp;
-            convertInternalLatLonToString(polyline[i].location.lon, tmp);
-            output += ", ";
-            output += tmp;
-            output += "]";
-            if( i < polyline.size()-1 ) {
-                output += ",";
-            }
-        }
-        output += "]";
-    }
 };
 
 #endif /* POLYLINECOMPRESSOR_H_ */

Algorithms/StronglyConnectedComponents.h

@@ -1,91 +1,110 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 STRONGLYCONNECTEDCOMPONENTS_H_
 #define STRONGLYCONNECTEDCOMPONENTS_H_
 
-#include <cassert>
-
-#include <stack>
-#include <vector>
-
-#include <boost/foreach.hpp>
-#include <boost/make_shared.hpp>
-#include <boost/unordered_map.hpp>
-
-#include <gdal/gdal.h>
-#include <gdal/ogrsf_frmts.h>
-
+#include "../DataStructures/Coordinate.h"
 #include "../DataStructures/DeallocatingVector.h"
 #include "../DataStructures/DynamicGraph.h"
 #include "../DataStructures/ImportEdge.h"
-#include "../DataStructures/NodeCoords.h"
+#include "../DataStructures/QueryNode.h"
 #include "../DataStructures/Percent.h"
 #include "../DataStructures/Restriction.h"
 #include "../DataStructures/TurnInstructions.h"
 
-// Strongly connected components using Tarjan's Algorithm
+#include "../Util/SimpleLogger.h"
+
+#include <boost/assert.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/foreach.hpp>
+#include <boost/integer.hpp>
+#include <boost/make_shared.hpp>
+#include <boost/unordered_map.hpp>
+#include <boost/unordered_set.hpp>
+
+#ifdef __APPLE__
+    #include <gdal.h>
+    #include <ogrsf_frmts.h>
+#else
+    #include <gdal/gdal.h>
+    #include <gdal/ogrsf_frmts.h>
+#endif
+
+#include <stack>
+#include <vector>
 
 class TarjanSCC {
 private:
-    struct _NodeBasedEdgeData {
+
+    struct TarjanNode {
+        TarjanNode() : index(UINT_MAX), lowlink(UINT_MAX), onStack(false) {}
+        unsigned index;
+        unsigned lowlink;
+        bool onStack;
+    };
+
+    struct TarjanEdgeData {
         int distance;
-        unsigned edgeBasedNodeID;
         unsigned nameID:31;
         bool shortcut:1;
+        short type;
+        bool isAccessRestricted:1;
         bool forward:1;
         bool backward:1;
         bool roundabout:1;
         bool ignoreInGrid:1;
-        short type;
-        bool isAccessRestricted;
+        bool reversedEdge:1;
     };
 
-    struct _EdgeBasedEdgeData {
-        int distance;
-        unsigned via;
-        unsigned nameID;
-        bool forward;
-        bool backward;
-        TurnInstruction turnInstruction;
+    struct TarjanStackFrame {
+        explicit TarjanStackFrame(
+            NodeID v,
+            NodeID parent
+        ) : v(v), parent(parent) { }
+        NodeID v;
+        NodeID parent;
     };
 
-    typedef DynamicGraph< _NodeBasedEdgeData > _NodeBasedDynamicGraph;
-    typedef _NodeBasedDynamicGraph::InputEdge _NodeBasedEdge;
-    std::vector<NodeInfo>               inputNodeInfoList;
-    unsigned numberOfTurnRestrictions;
-    boost::shared_ptr<_NodeBasedDynamicGraph>   _nodeBasedGraph;
-    boost::unordered_map<NodeID, bool>          _barrierNodes;
-    boost::unordered_map<NodeID, bool>          _trafficLights;
-
-    typedef std::pair<NodeID, NodeID> RestrictionSource;
-    typedef std::pair<NodeID, bool>   RestrictionTarget;
-    typedef std::vector<RestrictionTarget> EmanatingRestrictionsVector;
+    typedef DynamicGraph<TarjanEdgeData>        TarjanDynamicGraph;
+    typedef TarjanDynamicGraph::InputEdge       TarjanEdge;
+    typedef std::pair<NodeID, NodeID>           RestrictionSource;
+    typedef std::pair<NodeID, bool>             restriction_target;
+    typedef std::vector<restriction_target>      EmanatingRestrictionsVector;
     typedef boost::unordered_map<RestrictionSource, unsigned > RestrictionMap;
-    std::vector<EmanatingRestrictionsVector> _restrictionBucketVector;
-    RestrictionMap _restrictionMap;
 
+    std::vector<NodeInfo>                       m_coordinate_list;
+    std::vector<EmanatingRestrictionsVector>    m_restriction_bucket_list;
+    boost::shared_ptr<TarjanDynamicGraph>       m_node_based_graph;
+    boost::unordered_set<NodeID>                m_barrier_node_list;
+    boost::unordered_set<NodeID>                m_traffic_light_list;
+    unsigned                                    m_restriction_counter;
+    RestrictionMap                              m_restriction_map;
 
-public:
     struct EdgeBasedNode {
         bool operator<(const EdgeBasedNode & other) const {
             return other.id < id;
@@ -104,241 +123,307 @@ public:
         bool ignoreInGrid:1;
     };
 
-private:
-    DeallocatingVector<EdgeBasedNode>   edgeBasedNodes;
-
-    struct TarjanNode {
-        TarjanNode() : index(UINT_MAX), lowlink(UINT_MAX), onStack(false) {}
-        unsigned index;
-        unsigned lowlink;
-        bool onStack;
-    };
-
-    struct TarjanStackFrame {
-        explicit TarjanStackFrame(NodeID _v, NodeID p) : v(_v), parent(p) {}
-        NodeID v;
-        NodeID parent;
-    };
 public:
-    TarjanSCC(int nodes, std::vector<NodeBasedEdge> & inputEdges, std::vector<NodeID> & bn, std::vector<NodeID> & tl, std::vector<_Restriction> & irs, std::vector<NodeInfo> & nI) : inputNodeInfoList(nI), numberOfTurnRestrictions(irs.size()) {
-        BOOST_FOREACH(_Restriction & restriction, irs) {
-            std::pair<NodeID, NodeID> restrictionSource = std::make_pair(restriction.fromNode, restriction.viaNode);
+    TarjanSCC(
+        int number_of_nodes,
+        std::vector<NodeBasedEdge> & input_edges,
+        std::vector<NodeID> & bn,
+        std::vector<NodeID> & tl,
+        std::vector<TurnRestriction> & irs,
+        std::vector<NodeInfo> & nI
+    ) :
+        m_coordinate_list(nI),
+        m_restriction_counter(irs.size())
+    {
+        BOOST_FOREACH(const TurnRestriction & restriction, irs) {
+            std::pair<NodeID, NodeID> restrictionSource = std::make_pair(
+                restriction.fromNode, restriction.viaNode
+            );
             unsigned index;
-            RestrictionMap::iterator restrIter = _restrictionMap.find(restrictionSource);
-            if(restrIter == _restrictionMap.end()) {
-                index = _restrictionBucketVector.size();
-                _restrictionBucketVector.resize(index+1);
-                _restrictionMap[restrictionSource] = index;
+            RestrictionMap::iterator restriction_iterator = m_restriction_map.find(restrictionSource);
+            if(restriction_iterator == m_restriction_map.end()) {
+                index = m_restriction_bucket_list.size();
+                m_restriction_bucket_list.resize(index+1);
+                m_restriction_map[restrictionSource] = index;
             } else {
-                index = restrIter->second;
+                index = restriction_iterator->second;
                 //Map already contains an is_only_*-restriction
-                if(_restrictionBucketVector.at(index).begin()->second)
+                if(m_restriction_bucket_list.at(index).begin()->second) {
                     continue;
-                else if(restriction.flags.isOnly){
+                } else if(restriction.flags.isOnly) {
                     //We are going to insert an is_only_*-restriction. There can be only one.
-                    _restrictionBucketVector.at(index).clear();
+                    m_restriction_bucket_list.at(index).clear();
                 }
             }
 
-            _restrictionBucketVector.at(index).push_back(std::make_pair(restriction.toNode, restriction.flags.isOnly));
+            m_restriction_bucket_list.at(index).push_back(
+                std::make_pair(restriction.toNode, restriction.flags.isOnly)
+            );
         }
 
-        BOOST_FOREACH(NodeID id, bn) {
-            _barrierNodes[id] = true;
-        }
-        BOOST_FOREACH(NodeID id, tl) {
-            _trafficLights[id] = true;
-        }
+        m_barrier_node_list.insert(bn.begin(), bn.end());
+        m_traffic_light_list.insert(tl.begin(), tl.end());
 
-        DeallocatingVector< _NodeBasedEdge > edges;
-        for ( std::vector< NodeBasedEdge >::const_iterator i = inputEdges.begin(); i != inputEdges.end(); ++i ) {
-
-            _NodeBasedEdge edge;
-            if(!i->isForward()) {
-                edge.source = i->target();
-                edge.target = i->source();
-                edge.data.backward = i->isForward();
-                edge.data.forward = i->isBackward();
+        DeallocatingVector< TarjanEdge > edge_list;
+        BOOST_FOREACH(const NodeBasedEdge & input_edge, input_edges) {
+            TarjanEdge edge;
+            if(!input_edge.isForward()) {
+                edge.source = input_edge.target();
+                edge.target = input_edge.source();
+                edge.data.backward = input_edge.isForward();
+                edge.data.forward = input_edge.isBackward();
             } else {
-                edge.source = i->source();
-                edge.target = i->target();
-                edge.data.forward = i->isForward();
-                edge.data.backward = i->isBackward();
+                edge.source = input_edge.source();
+                edge.target = input_edge.target();
+                edge.data.forward = input_edge.isForward();
+                edge.data.backward = input_edge.isBackward();
             }
-            if(edge.source == edge.target)
+            if(edge.source == edge.target) {
                 continue;
+            }
 
-            edge.data.distance = (std::max)((int)i->weight(), 1 );
-            assert( edge.data.distance > 0 );
+            edge.data.distance = (std::max)((int)input_edge.weight(), 1 );
+            BOOST_ASSERT( edge.data.distance > 0 );
             edge.data.shortcut = false;
-            edge.data.roundabout = i->isRoundabout();
-            edge.data.ignoreInGrid = i->ignoreInGrid();
-            edge.data.nameID = i->name();
-            edge.data.type = i->type();
-            edge.data.isAccessRestricted = i->isAccessRestricted();
-            edge.data.edgeBasedNodeID = edges.size();
-            edges.push_back( edge );
+            edge.data.roundabout = input_edge.isRoundabout();
+            edge.data.ignoreInGrid = input_edge.ignoreInGrid();
+            edge.data.nameID = input_edge.name();
+            edge.data.type = input_edge.type();
+            edge.data.isAccessRestricted = input_edge.isAccessRestricted();
+            edge.data.reversedEdge = false;
+            edge_list.push_back( edge );
             if( edge.data.backward ) {
                 std::swap( edge.source, edge.target );
-                edge.data.forward = i->isBackward();
-                edge.data.backward = i->isForward();
-                edge.data.edgeBasedNodeID = edges.size();
-                edges.push_back( edge );
+                edge.data.forward = input_edge.isBackward();
+                edge.data.backward = input_edge.isForward();
+                edge.data.reversedEdge = true;
+                edge_list.push_back( edge );
             }
         }
-        std::vector<NodeBasedEdge>().swap(inputEdges);
-        std::sort( edges.begin(), edges.end() );
-        _nodeBasedGraph = boost::make_shared<_NodeBasedDynamicGraph>( nodes, edges );
+        std::vector<NodeBasedEdge>().swap(input_edges);
+        BOOST_ASSERT_MSG(
+            0 == input_edges.size() && 0 == input_edges.capacity(),
+            "input edge vector not properly deallocated"
+        );
+
+        std::sort( edge_list.begin(), edge_list.end() );
+
+        m_node_based_graph = boost::make_shared<TarjanDynamicGraph>(
+            number_of_nodes,
+            edge_list
+        );
+    }
+
+    ~TarjanSCC() {
+        m_node_based_graph.reset();
     }
 
     void Run() {
-        Percent p(_nodeBasedGraph->GetNumberOfNodes());
+        //remove files from previous run if exist
+        DeleteFileIfExists("component.dbf");
+        DeleteFileIfExists("component.shx");
+        DeleteFileIfExists("component.shp");
 
-        const char *pszDriverName = "ESRI Shapefile";
-        OGRSFDriver *poDriver;
+        Percent p(m_node_based_graph->GetNumberOfNodes());
 
         OGRRegisterAll();
 
-        poDriver = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(
-                pszDriverName );
-        if( poDriver == NULL )
-        {
-            printf( "%s driver not available.\n", pszDriverName );
-            exit( 1 );
+        const char *pszDriverName = "ESRI Shapefile";
+        OGRSFDriver * poDriver = OGRSFDriverRegistrar::GetRegistrar()->
+            GetDriverByName( pszDriverName );
+        if( NULL == poDriver ) {
+            throw OSRMException("ESRI Shapefile driver not available");
         }
-        OGRDataSource *poDS;
+        OGRDataSource * poDS = poDriver->CreateDataSource(
+            "component.shp",
+            NULL
+        );
 
-        poDS = poDriver->CreateDataSource( "component.shp", NULL );
-        if( poDS == NULL ) {
-            printf( "Creation of output file failed.\n" );
-            exit( 1 );
+        if( NULL == poDS ) {
+            throw OSRMException("Creation of output file failed");
         }
 
-        OGRLayer *poLayer;
+        OGRLayer * poLayer = poDS->CreateLayer(
+            "component",
+            NULL,
+            wkbLineString,
+            NULL
+        );
 
-        poLayer = poDS->CreateLayer( "component", NULL, wkbLineString, NULL );
-        if( poLayer == NULL ) {
-            printf( "Layer creation failed.\n" );
-            exit( 1 );
+        if( NULL == poLayer ) {
+            throw OSRMException("Layer creation failed.");
         }
 
-
-        //The following is a hack to distinguish between stuff that happens before the recursive call and stuff that happens after
-        std::stack<std::pair<bool, TarjanStackFrame> > recursionStack; //true = stuff before, false = stuff after call
-        std::stack<NodeID> tarjanStack;
-        std::vector<unsigned> componentsIndex(_nodeBasedGraph->GetNumberOfNodes(), UINT_MAX);
-        std::vector<NodeID> vectorOfComponentSizes;
-        std::vector<TarjanNode> tarjanNodes(_nodeBasedGraph->GetNumberOfNodes());
-        unsigned currentComponent = 0, sizeOfCurrentComponent = 0;
+        //The following is a hack to distinguish between stuff that happens
+        //before the recursive call and stuff that happens after
+        std::stack<std::pair<bool, TarjanStackFrame> > recursion_stack;
+        //true = stuff before, false = stuff after call
+        std::stack<NodeID> tarjan_stack;
+        std::vector<unsigned> components_index(
+            m_node_based_graph->GetNumberOfNodes(),
+            UINT_MAX
+        );
+        std::vector<NodeID> component_size_vector;
+        std::vector<TarjanNode> tarjan_node_list(
+            m_node_based_graph->GetNumberOfNodes()
+        );
+        unsigned component_index = 0, size_of_current_component = 0;
         int index = 0;
-        for(NodeID node = 0, endNodes = _nodeBasedGraph->GetNumberOfNodes(); node < endNodes; ++node) {
-            if(UINT_MAX == componentsIndex[node]) {
-                recursionStack.push(std::make_pair(true, TarjanStackFrame(node,node)) );
+        for(
+            NodeID node = 0, last_node = m_node_based_graph->GetNumberOfNodes();
+            node < last_node;
+            ++node
+        ) {
+            if(UINT_MAX == components_index[node]) {
+                recursion_stack.push(
+                    std::make_pair(true, TarjanStackFrame(node,node))
+                );
             }
 
-            while(!recursionStack.empty()) {
-                bool beforeRecursion = recursionStack.top().first;
-                TarjanStackFrame currentFrame = recursionStack.top().second;
+            while(!recursion_stack.empty()) {
+                bool before_recursion = recursion_stack.top().first;
+                TarjanStackFrame currentFrame = recursion_stack.top().second;
                 NodeID v = currentFrame.v;
-//                INFO("popping node " << v << (beforeRecursion ? " before " : " after ") << "recursion");
-                recursionStack.pop();
+                recursion_stack.pop();
 
-                if(beforeRecursion) {
+                if(before_recursion) {
                     //Mark frame to handle tail of recursion
-                    recursionStack.push(std::make_pair(false, currentFrame));
+                    recursion_stack.push(std::make_pair(false, currentFrame));
 
                     //Mark essential information for SCC
-                    tarjanNodes[v].index = index;
-                    tarjanNodes[v].lowlink = index;
-                    tarjanStack.push(v);
-                    tarjanNodes[v].onStack = true;
+                    tarjan_node_list[v].index = index;
+                    tarjan_node_list[v].lowlink = index;
+                    tarjan_stack.push(v);
+                    tarjan_node_list[v].onStack = true;
                     ++index;
-//                    INFO("pushing " << v << " onto tarjan stack, idx[" << v << "]=" << tarjanNodes[v].index << ", lowlink["<< v << "]=" << tarjanNodes[v].lowlink);
 
                     //Traverse outgoing edges
-                    for(_NodeBasedDynamicGraph::EdgeIterator e2 = _nodeBasedGraph->BeginEdges(v); e2 < _nodeBasedGraph->EndEdges(v); ++e2) {
-                        _NodeBasedDynamicGraph::NodeIterator vprime = _nodeBasedGraph->GetTarget(e2);
-//                        INFO("traversing edge (" << v << "," << vprime << ")");
-                        if(UINT_MAX == tarjanNodes[vprime].index) {
-
-                            recursionStack.push(std::make_pair(true,TarjanStackFrame(vprime, v)));
+                    for(
+                        TarjanDynamicGraph::EdgeIterator e2 = m_node_based_graph->BeginEdges(v);
+                        e2 < m_node_based_graph->EndEdges(v);
+                        ++e2
+                    ) {
+                        const TarjanDynamicGraph::NodeIterator vprime =
+                            m_node_based_graph->GetTarget(e2);
+                        if(UINT_MAX == tarjan_node_list[vprime].index) {
+                            recursion_stack.push(
+                                std::make_pair(
+                                    true,
+                                    TarjanStackFrame(vprime, v)
+                                )
+                            );
                         } else {
-//                            INFO("Node " << vprime << " is already explored");
-                            if(tarjanNodes[vprime].onStack) {
-                                unsigned newLowlink = std::min(tarjanNodes[v].lowlink, tarjanNodes[vprime].index);
-//                                INFO("Setting lowlink[" << v << "] from " << tarjanNodes[v].lowlink << " to " << newLowlink);
-                                tarjanNodes[v].lowlink = newLowlink;
-//                            } else {
-//                                INFO("But node " << vprime << " is not on stack");
+                            if(
+                                tarjan_node_list[vprime].onStack &&
+                                tarjan_node_list[vprime].index < tarjan_node_list[v].lowlink
+                            ) {
+                                tarjan_node_list[v].lowlink = tarjan_node_list[vprime].index;
                             }
                         }
                     }
                 } else {
-
-//                    INFO("we are at the end of recursion and checking node " << v);
-                    { // setting lowlink in its own scope so it does not pollute namespace
-                        //                        NodeID parent = (UINT_MAX == tarjanNodes[v].parent ? v : tarjanNodes[v].parent );
-//                        INFO("parent=" << currentFrame.parent);
-//                        INFO("tarjanNodes[" << v  << "].lowlink=" << tarjanNodes[v].lowlink << ", tarjanNodes[" << currentFrame.parent << "].lowlink=" << tarjanNodes[currentFrame.parent].lowlink);
-                        //Note the index shift by 1 compared to the recursive version
-                        tarjanNodes[currentFrame.parent].lowlink = std::min(tarjanNodes[currentFrame.parent].lowlink, tarjanNodes[v].lowlink);
-//                        INFO("Setting tarjanNodes[" << currentFrame.parent  <<"].lowlink=" << tarjanNodes[currentFrame.parent].lowlink);
-                    }
-//                    INFO("tarjanNodes[" << v  << "].lowlink=" << tarjanNodes[v].lowlink << ", tarjanNodes[" << v  << "].index=" << tarjanNodes[v].index);
-
+                    tarjan_node_list[currentFrame.parent].lowlink =
+                        std::min(
+                            tarjan_node_list[currentFrame.parent].lowlink,
+                            tarjan_node_list[v].lowlink
+                        );
                     //after recursion, lets do cycle checking
                     //Check if we found a cycle. This is the bottom part of the recursion
-                    if(tarjanNodes[v].lowlink == tarjanNodes[v].index) {
+                    if(tarjan_node_list[v].lowlink == tarjan_node_list[v].index) {
                         NodeID vprime;
                         do {
-//                            INFO("identified component " << currentComponent << ": " << tarjanStack.top());
-                            vprime = tarjanStack.top(); tarjanStack.pop();
-                            tarjanNodes[vprime].onStack = false;
-                            componentsIndex[vprime] = currentComponent;
-                            ++sizeOfCurrentComponent;
+                            vprime = tarjan_stack.top(); tarjan_stack.pop();
+                            tarjan_node_list[vprime].onStack = false;
+                            components_index[vprime] = component_index;
+                            ++size_of_current_component;
                         } while( v != vprime);
-                        vectorOfComponentSizes.push_back(sizeOfCurrentComponent);
-                        if(sizeOfCurrentComponent > 1000)
-                            INFO("large component [" << currentComponent << "]=" << sizeOfCurrentComponent);
-                        ++currentComponent;
-                        sizeOfCurrentComponent = 0;
+
+                        component_size_vector.push_back(size_of_current_component);
+
+                        if(size_of_current_component > 1000) {
+                            SimpleLogger().Write() <<
+                            "large component [" << component_index << "]=" <<
+                            size_of_current_component;
+                        }
+
+                        ++component_index;
+                        size_of_current_component = 0;
                     }
                 }
             }
         }
 
-        INFO("identified: " << vectorOfComponentSizes.size() << " many components, marking small components");
+        SimpleLogger().Write() <<
+            "identified: " << component_size_vector.size() <<
+            " many components, marking small components";
 
-        int singleCounter = 0;
-        for(unsigned i = 0; i < vectorOfComponentSizes.size(); ++i){
-            if(1 == vectorOfComponentSizes[i])
-                ++singleCounter;
+        unsigned size_one_counter = 0;
+        for(unsigned i = 0, end = component_size_vector.size(); i < end; ++i){
+            if(1 == component_size_vector[i]) {
+                ++size_one_counter;
+            }
         }
-        INFO("identified " << singleCounter << " SCCs of size 1");
 
-        p.reinit(_nodeBasedGraph->GetNumberOfNodes());
-        for(_NodeBasedDynamicGraph::NodeIterator u = 0; u < _nodeBasedGraph->GetNumberOfNodes(); ++u ) {
-            for(_NodeBasedDynamicGraph::EdgeIterator e1 = _nodeBasedGraph->BeginEdges(u); e1 < _nodeBasedGraph->EndEdges(u); ++e1) {
-                _NodeBasedDynamicGraph::NodeIterator v = _nodeBasedGraph->GetTarget(e1);
+        SimpleLogger().Write() <<
+            "identified " << size_one_counter << " SCCs of size 1";
+
+        uint64_t total_network_distance = 0;
+        p.reinit(m_node_based_graph->GetNumberOfNodes());
+        for(
+            TarjanDynamicGraph::NodeIterator u = 0, last_u_node = m_node_based_graph->GetNumberOfNodes();
+            u < last_u_node;
+            ++u
+         ) {
+            p.printIncrement();
+            for(
+                TarjanDynamicGraph::EdgeIterator e1 = m_node_based_graph->BeginEdges(u), last_edge = m_node_based_graph->EndEdges(u);
+                e1 < last_edge;
+                ++e1
+            ) {
+                if(!m_node_based_graph->GetEdgeData(e1).reversedEdge) {
+                    continue;
+                }
+                const TarjanDynamicGraph::NodeIterator v = m_node_based_graph->GetTarget(e1);
+
+                total_network_distance += 100*ApproximateDistance(
+                        m_coordinate_list[u].lat,
+                        m_coordinate_list[u].lon,
+                        m_coordinate_list[v].lat,
+                        m_coordinate_list[v].lon
+                );
+
+                if( SHRT_MAX != m_node_based_graph->GetEdgeData(e1).type ) {
+                    BOOST_ASSERT(e1 != UINT_MAX);
+                    BOOST_ASSERT(u != UINT_MAX);
+                    BOOST_ASSERT(v != UINT_MAX);
+
+                    const unsigned size_of_containing_component =
+                        std::min(
+                            component_size_vector[components_index[u]],
+                            component_size_vector[components_index[v]]
+                        );
 
-                if(_nodeBasedGraph->GetEdgeData(e1).type != SHRT_MAX) {
-                    assert(e1 != UINT_MAX);
-                    assert(u != UINT_MAX);
-                    assert(v != UINT_MAX);
                     //edges that end on bollard nodes may actually be in two distinct components
-                    if(std::min(vectorOfComponentSizes[componentsIndex[u]], vectorOfComponentSizes[componentsIndex[v]]) < 10) {
-
-                        //INFO("(" << inputNodeInfoList[u].lat/100000. << ";" << inputNodeInfoList[u].lon/100000. << ") -> (" << inputNodeInfoList[v].lat/100000. << ";" << inputNodeInfoList[v].lon/100000. << ")");
+                    if(size_of_containing_component < 10) {
                         OGRLineString lineString;
-                        lineString.addPoint(inputNodeInfoList[u].lon/100000., inputNodeInfoList[u].lat/100000.);
-                        lineString.addPoint(inputNodeInfoList[v].lon/100000., inputNodeInfoList[v].lat/100000.);
+                        lineString.addPoint(
+                            m_coordinate_list[u].lon/COORDINATE_PRECISION,
+                            m_coordinate_list[u].lat/COORDINATE_PRECISION
+                        );
+                        lineString.addPoint(
+                            m_coordinate_list[v].lon/COORDINATE_PRECISION,
+                            m_coordinate_list[v].lat/COORDINATE_PRECISION
+                        );
+
+                        OGRFeature * poFeature = OGRFeature::CreateFeature(
+                            poLayer->GetLayerDefn()
+                        );
 
-                        OGRFeature *poFeature;
-                        poFeature = OGRFeature::CreateFeature( poLayer->GetLayerDefn() );
                         poFeature->SetGeometry( &lineString );
-                        if( poLayer->CreateFeature( poFeature ) != OGRERR_NONE )
-                        {
-                            ERR( "Failed to create feature in shapefile.\n" );
+                        if( OGRERR_NONE != poLayer->CreateFeature(poFeature) ) {
+                            throw OSRMException(
+                                "Failed to create feature in shapefile."
+                            );
                         }
                         OGRFeature::DestroyFeature( poFeature );
                     }
@@ -346,37 +431,70 @@ public:
             }
         }
         OGRDataSource::DestroyDataSource( poDS );
-        std::vector<NodeID>().swap(vectorOfComponentSizes);
-        std::vector<NodeID>().swap(componentsIndex);
+        std::vector<NodeID>().swap(component_size_vector);
+        BOOST_ASSERT_MSG(
+            0 == component_size_vector.size() &&
+            0 == component_size_vector.capacity(),
+            "component_size_vector not properly deallocated"
+        );
 
+        std::vector<NodeID>().swap(components_index);
+        BOOST_ASSERT_MSG(
+            0 == components_index.size() && 0 == components_index.capacity(),
+            "icomponents_index not properly deallocated"
+        );
+
+        SimpleLogger().Write()
+            << "total network distance: " <<
+             (uint64_t)total_network_distance/100/1000. <<
+            " km";
     }
+
 private:
     unsigned CheckForEmanatingIsOnlyTurn(const NodeID u, const NodeID v) const {
-        std::pair < NodeID, NodeID > restrictionSource = std::make_pair(u, v);
-        RestrictionMap::const_iterator restrIter = _restrictionMap.find(restrictionSource);
-        if (restrIter != _restrictionMap.end()) {
-            unsigned index = restrIter->second;
-            BOOST_FOREACH(RestrictionSource restrictionTarget, _restrictionBucketVector.at(index)) {
-                if(restrictionTarget.second) {
-                    return restrictionTarget.first;
+        std::pair < NodeID, NodeID > restriction_source = std::make_pair(u, v);
+        RestrictionMap::const_iterator restriction_iterator = m_restriction_map.find(restriction_source);
+        if (restriction_iterator != m_restriction_map.end()) {
+            const unsigned index = restriction_iterator->second;
+            BOOST_FOREACH(
+                const RestrictionSource & restriction_target,
+                m_restriction_bucket_list.at(index)
+            ) {
+                if(restriction_target.second) {
+                    return restriction_target.first;
                 }
             }
         }
         return UINT_MAX;
     }
-    bool CheckIfTurnIsRestricted(const NodeID u, const NodeID v, const NodeID w) const {
+
+    bool CheckIfTurnIsRestricted(
+        const NodeID u,
+        const NodeID v,
+        const NodeID w
+    ) const {
         //only add an edge if turn is not a U-turn except it is the end of dead-end street.
-        std::pair < NodeID, NodeID > restrictionSource = std::make_pair(u, v);
-        RestrictionMap::const_iterator restrIter = _restrictionMap.find(restrictionSource);
-        if (restrIter != _restrictionMap.end()) {
-            unsigned index = restrIter->second;
-            BOOST_FOREACH(RestrictionTarget restrictionTarget, _restrictionBucketVector.at(index)) {
-                if(w == restrictionTarget.first)
+        std::pair < NodeID, NodeID > restriction_source = std::make_pair(u, v);
+        RestrictionMap::const_iterator restriction_iterator = m_restriction_map.find(restriction_source);
+        if (restriction_iterator != m_restriction_map.end()) {
+            const unsigned index = restriction_iterator->second;
+            BOOST_FOREACH(
+                const restriction_target & restriction_target,
+                m_restriction_bucket_list.at(index)
+            ) {
+                if(w == restriction_target.first) {
                     return true;
+                }
             }
         }
         return false;
     }
+
+    void DeleteFileIfExists(const std::string & file_name) const {
+        if (boost::filesystem::exists(file_name) ) {
+            boost::filesystem::remove(file_name);
+        }
+    }
 };
 
 #endif /* STRONGLYCONNECTEDCOMPONENTS_H_ */

CMakeLists.txt

@@ -0,0 +1,207 @@
+cmake_minimum_required(VERSION 2.6)
+project(OSRM)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+include(FindPackageHandleStandardArgs)
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake")
+include(GetGitRevisionDescription)
+git_describe(GIT_DESCRIPTION)
+
+TRY_RUN(SHARED_LIBRARY_PATH_TYPE SHARED_LIBRARY_PATH_INFO_COMPILED ${PROJECT_BINARY_DIR}/CMakeTmp ${PROJECT_SOURCE_DIR}/cmake/size.cpp OUTPUT_VARIABLE IS_64_SYSTEM)
+if(IS_64_SYSTEM)
+	message(STATUS "System supports 64 bits.")
+	set( HAS64BITS 1 )
+else(IS_64_SYSTEM)
+	MESSAGE(WARNING "Compiling on a 32 bit system is unsupported!")
+	set( HAS64BITS 0 )
+endif(IS_64_SYSTEM)
+
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
+
+add_custom_command(OUTPUT ${CMAKE_SOURCE_DIR}/Util/UUID.cpp UUID.cpp.alwaysbuild
+  COMMAND ${CMAKE_COMMAND} -DSOURCE_DIR=${CMAKE_SOURCE_DIR}
+    -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/UUID-Config.cmake
+  DEPENDS
+    ${CMAKE_SOURCE_DIR}/Util/UUID.cpp.in
+  	${CMAKE_SOURCE_DIR}/cmake/UUID-Config.cmake
+  COMMENT "Configuring UUID.cpp"
+  VERBATIM)
+
+add_custom_target(UUIDConfigure DEPENDS ${CMAKE_SOURCE_DIR}/Util/UUID.cpp )
+
+set(BOOST_COMPONENTS filesystem iostreams program_options regex system thread)
+
+configure_file(Util/GitDescription.cpp.in ${CMAKE_SOURCE_DIR}/Util/GitDescription.cpp)
+file(GLOB ExtractorGlob Extractor/*.cpp)
+set(ExtractorSources extractor.cpp ${ExtractorGlob})
+add_executable(osrm-extract ${ExtractorSources} )
+
+file( GLOB PrepareGlob Contractor/*.cpp )
+set( PrepareSources prepare.cpp ${PrepareGlob} )
+add_executable( osrm-prepare ${PrepareSources} )
+
+file(GLOB ServerGlob Server/*.cpp)
+file(GLOB DescriptorGlob Descriptors/*.cpp)
+file(GLOB DatastructureGlob DataStructures/*.cpp)
+file(GLOB AlgorithmGlob Algorithms/*.cpp)
+file(GLOB HttpGlob Server/Http/*.cpp)
+file(GLOB LibOSRMGlob Library/*.cpp)
+
+set(OSRMSources ${LibOSRMGlob} ${DescriptorGlob} ${DatastructureGlob} ${AlgorithmGlob} ${HttpGlob})
+add_library( OSRM SHARED ${OSRMSources} )
+add_library( UUID STATIC Util/UUID.cpp )
+add_library( GITDESCRIPTION STATIC Util/GitDescription.cpp )
+add_dependencies( UUID UUIDConfigure )
+add_dependencies( GITDESCRIPTION GIT_DESCRIPTION )
+
+add_executable(osrm-routed routed.cpp ${ServerGlob})
+set_target_properties(osrm-routed PROPERTIES COMPILE_FLAGS -DROUTED)
+add_executable(osrm-datastore datastore.cpp)
+
+# Check the release mode
+if(NOT CMAKE_BUILD_TYPE MATCHES Debug)
+	set(CMAKE_BUILD_TYPE Release)
+endif(NOT CMAKE_BUILD_TYPE MATCHES Debug)
+if(CMAKE_BUILD_TYPE MATCHES Debug)
+    message(STATUS "Configuring OSRM in debug mode")
+endif(CMAKE_BUILD_TYPE MATCHES Debug)
+if(CMAKE_BUILD_TYPE MATCHES Release)
+    message(STATUS "Configuring OSRM in release mode")
+endif(CMAKE_BUILD_TYPE MATCHES Release)
+
+# set compile switches
+if (NOT "${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+    # not using Visual Studio C++
+    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fPIC")
+    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -fPIC")
+endif()
+
+# Configuring compilers
+if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+	# using Clang
+	set(CMAKE_CXX_FLAGS "-Wall -Wno-unknown-pragmas -Wno-unneeded-internal-declaration")
+	message(STATUS "OpenMP parallelization not available using clang++")
+elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+	# using GCC
+	set(CMAKE_CXX_FLAGS "-Wall -fopenmp -pedantic")
+elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Intel")
+	# using Intel C++
+	set(CMAKE_CXX_FLAGS "-static-intel -wd10237 -Wall -openmp -ipo")
+elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+	# using Visual Studio C++
+endif()
+
+# Configuring other platform dependencies
+if(APPLE)
+	SET(CMAKE_OSX_ARCHITECTURES "x86_64")
+	message(STATUS "Set Architecture to x64 on OS X")
+    EXEC_PROGRAM(uname ARGS -v  OUTPUT_VARIABLE DARWIN_VERSION)
+    STRING(REGEX MATCH "[0-9]+" DARWIN_VERSION ${DARWIN_VERSION})
+    IF (DARWIN_VERSION GREATER 12)
+        MESSAGE(STATUS "Activating -std=c++11 flag for >= OS X 10.9")
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -stdlib=libc++")
+    ENDIF (DARWIN_VERSION GREATER 12)
+endif()
+
+if(UNIX AND NOT APPLE)
+    target_link_libraries( osrm-datastore rt )
+    target_link_libraries( OSRM rt )
+endif(UNIX AND NOT APPLE)
+
+#Check Boost
+set(BOOST_MIN_VERSION "1.44.0")
+find_package( Boost ${BOOST_MIN_VERSION} COMPONENTS ${BOOST_COMPONENTS} REQUIRED )
+if (NOT Boost_FOUND)
+      message(FATAL_ERROR "Fatal error: Boost (version >= 1.44.0) required.\n")
+endif (NOT Boost_FOUND)
+include_directories(${Boost_INCLUDE_DIRS})
+
+IF( APPLE )
+	target_link_libraries( OSRM ${Boost_LIBRARIES} UUID )
+ELSE( APPLE )
+	target_link_libraries( OSRM ${Boost_LIBRARIES} )
+ENDIF( APPLE )
+target_link_libraries( osrm-extract ${Boost_LIBRARIES} UUID GITDESCRIPTION )
+target_link_libraries( osrm-prepare ${Boost_LIBRARIES} UUID GITDESCRIPTION )
+target_link_libraries( osrm-routed ${Boost_LIBRARIES} OSRM UUID GITDESCRIPTION )
+target_link_libraries( osrm-datastore ${Boost_LIBRARIES} UUID GITDESCRIPTION )
+
+find_package ( BZip2 REQUIRED )
+include_directories(${BZIP_INCLUDE_DIRS})
+target_link_libraries (osrm-extract ${BZIP2_LIBRARIES})
+
+find_package( ZLIB REQUIRED )
+include_directories(${ZLIB_INCLUDE_DIRS})
+target_link_libraries (osrm-extract ${ZLIB_LIBRARY})
+target_link_libraries (osrm-routed ${ZLIB_LIBRARY})
+
+find_package( Threads REQUIRED )
+target_link_libraries (osrm-extract ${Threads_LIBRARY})
+
+find_package( Lua52 )
+IF ( NOT LUA52_FOUND )
+  find_package( Lua51 REQUIRED )
+  IF (NOT APPLE)
+    find_package( LuaJIT 5.1 )
+  ENDIF ( NOT APPLE )
+ELSE( NOT LUA52_FOUND )
+  IF(NOT APPLE)
+    find_package( LuaJIT 5.2 )
+  ENDIF(NOT APPLE)
+ENDIF( NOT LUA52_FOUND )
+
+IF ( LUAJIT_FOUND )
+  target_link_libraries( osrm-extract ${LUAJIT_LIBRARIES} )
+  target_link_libraries( osrm-prepare ${LUAJIT_LIBRARIES} )
+ELSE ()
+  target_link_libraries( osrm-extract ${LUA_LIBRARY} )
+  target_link_libraries( osrm-prepare ${LUA_LIBRARY} )
+ENDIF ()
+include_directories(${LUA_INCLUDE_DIR})
+
+
+find_package( LibXml2 REQUIRED )
+include_directories(${LIBXML2_INCLUDE_DIR})
+target_link_libraries (osrm-extract ${LIBXML2_LIBRARIES})
+
+find_package( Luabind REQUIRED )
+include_directories(${LUABIND_INCLUDE_DIR})
+target_link_libraries (osrm-extract ${LUABIND_LIBRARY})
+target_link_libraries (osrm-prepare ${LUABIND_LIBRARY})
+
+find_package( Protobuf REQUIRED )
+include_directories(${PROTOBUF_INCLUDE_DIRS})
+target_link_libraries (osrm-extract ${PROTOBUF_LIBRARY})
+target_link_libraries (osrm-prepare ${PROTOBUF_LIBRARY})
+
+find_package( STXXL REQUIRED )
+include_directories(${STXXL_INCLUDE_DIR})
+target_link_libraries (OSRM ${STXXL_LIBRARY})
+target_link_libraries (osrm-extract ${STXXL_LIBRARY})
+target_link_libraries (osrm-prepare ${STXXL_LIBRARY})
+
+find_package( OSMPBF REQUIRED )
+include_directories(${OSMPBF_INCLUDE_DIR})
+target_link_libraries (osrm-extract ${OSMPBF_LIBRARY})
+target_link_libraries (osrm-prepare ${OSMPBF_LIBRARY})
+
+if(WITH_TOOLS)
+	message(STATUS "Activating OSRM internal tools")
+	find_package( GDAL )
+	if(GDAL_FOUND)
+		add_executable(osrm-components Tools/componentAnalysis.cpp)
+		include_directories(${GDAL_INCLUDE_DIR})
+		target_link_libraries(
+			osrm-components ${GDAL_LIBRARIES} ${Boost_LIBRARIES} UUID  GITDESCRIPTION
+		)
+	endif(GDAL_FOUND)
+	add_executable ( osrm-cli Tools/simpleclient.cpp)
+	target_link_libraries( osrm-cli ${Boost_LIBRARIES} OSRM UUID GITDESCRIPTION )
+    add_executable ( osrm-io-benchmark Tools/io-benchmark.cpp )
+    target_link_libraries( osrm-io-benchmark ${Boost_LIBRARIES} GITDESCRIPTION)
+    add_executable ( osrm-unlock-all Tools/unlock_all_mutexes.cpp )
+    target_link_libraries( osrm-unlock-all ${Boost_LIBRARIES} GITDESCRIPTION)
+    if(UNIX AND NOT APPLE)
+        target_link_libraries( osrm-unlock-all rt )
+    endif(UNIX AND NOT APPLE)
+endif(WITH_TOOLS)

Contractor/ContractionCleanup.h

@@ -1,261 +0,0 @@
-/*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
-
-#ifndef CONTRACTIONCLEANUP_H_INCLUDED
-#define CONTRACTIONCLEANUP_H_INCLUDED
-
-#include <algorithm>
-#ifndef _WIN32
-#include <sys/time.h>
-#endif
-#include "Contractor.h"
-
-class ContractionCleanup {
-private:
-
-    struct _CleanupHeapData {
-        NodeID parent;
-        _CleanupHeapData( NodeID p ) {
-            parent = p;
-        }
-    };
-    typedef BinaryHeap< NodeID, NodeID, int, _CleanupHeapData > _Heap;
-
-    struct _ThreadData {
-        _Heap* _heapForward;
-        _Heap* _heapBackward;
-        _ThreadData( NodeID nodes ) {
-            _heapBackward = new _Heap(nodes);
-            _heapForward = new _Heap(nodes);
-        }
-        ~_ThreadData() {
-            delete _heapBackward;
-            delete _heapForward;
-        }
-    };
-
-public:
-
-    struct Edge {
-        NodeID source;
-        NodeID target;
-        struct EdgeData {
-        	NodeID via;
-        	unsigned nameID;
-        	int distance;
-        	TurnInstruction turnInstruction;
-        	bool shortcut:1;
-        	bool forward:1;
-        	bool backward:1;
-        } data;
-        bool operator<( const Edge& right ) const {
-            if ( source != right.source )
-                return source < right.source;
-            return target < right.target;
-        }
-
-        //sorts by source and other attributes
-        static bool CompareBySource( const Edge& left, const Edge& right ) {
-            if ( left.source != right.source )
-                return left.source < right.source;
-            int l = ( left.data.forward ? -1 : 0 ) + ( left.data.backward ? -1 : 0 );
-            int r = ( right.data.forward ? -1 : 0 ) + ( right.data.backward ? -1 : 0 );
-            if ( l != r )
-                return l < r;
-            if ( left.target != right.target )
-                return left.target < right.target;
-            return left.data.distance < right.data.distance;
-        }
-
-        bool operator== ( const Edge& right ) const {
-            return ( source == right.source && target == right.target && data.distance == right.data.distance &&
-                    data.shortcut == right.data.shortcut && data.forward == right.data.forward && data.backward == right.data.backward
-                    && data.via == right.data.via && data.nameID == right.data.nameID
-                    );
-        }
-    };
-
-    ContractionCleanup( int numNodes, const std::vector< Edge >& edges ) {
-        _graph = edges;
-        _numNodes = numNodes;
-    }
-
-    ~ContractionCleanup() {
-
-    }
-
-    void Run() {
-        RemoveUselessShortcuts();
-    }
-
-    template< class EdgeT >
-    void GetData( std::vector< EdgeT >& edges ) {
-        for ( int edge = 0, endEdges = ( int ) _graph.size(); edge != endEdges; ++edge ) {
-            if(_graph[edge].data.forward || _graph[edge].data.backward) {
-                EdgeT newEdge;
-                newEdge.source = _graph[edge].source;
-                newEdge.target = _graph[edge].target;
-                newEdge.data = _graph[edge].data;
-                edges.push_back( newEdge );
-            }
-        }
-        sort( edges.begin(), edges.end() );
-    }
-
-private:
-
-    double _Timestamp() {
-        struct timeval tp;
-        gettimeofday(&tp, NULL);
-        return double(tp.tv_sec) + tp.tv_usec / 1000000.;
-    }
-
-    void BuildOutgoingGraph() {
-        //sort edges by source
-        sort( _graph.begin(), _graph.end(), Edge::CompareBySource );
-        try {
-            _firstEdge.resize( _numNodes + 1 );
-        } catch(...) {
-            ERR("Not enough RAM on machine");
-            return;
-        }
-        _firstEdge[0] = 0;
-        for ( NodeID i = 0, node = 0; i < ( NodeID ) _graph.size(); i++ ) {
-            while ( _graph[i].source != node )
-                _firstEdge[++node] = i;
-            if ( i == ( NodeID ) _graph.size() - 1 )
-                while ( node < _numNodes )
-                    _firstEdge[++node] = ( int ) _graph.size();
-        }
-    }
-
-    void RemoveUselessShortcuts() {
-        int maxThreads = omp_get_max_threads();
-        std::vector < _ThreadData* > threadData;
-        for ( int threadNum = 0; threadNum < maxThreads; ++threadNum ) {
-            threadData.push_back( new _ThreadData( _numNodes ) );
-        }
-
-        INFO("Scanning for useless shortcuts");
-        BuildOutgoingGraph();
-/*
-        #pragma omp parallel for
-        for ( int i = 0; i < ( int ) _graph.size(); i++ ) {
-            //only remove shortcuts
-            if ( !_graph[i].data.shortcut )
-                continue;
-
-            if ( _graph[i].data.forward ) {
-                int result = _ComputeDistance( _graph[i].source, _graph[i].target, threadData[omp_get_thread_num()] );
-                if ( result < _graph[i].data.distance ) {
-                    _graph[i].data.forward = false;
-                }
-            }
-            if ( _graph[i].data.backward ) {
-                int result = _ComputeDistance( _graph[i].target, _graph[i].source, threadData[omp_get_thread_num()] );
-                if ( result < _graph[i].data.distance ) {
-                    _graph[i].data.backward = false;
-                }
-            }
-        }
-*/
-        INFO("Removing edges");
-        int useful = 0;
-        for ( int i = 0; i < ( int ) _graph.size(); i++ ) {
-            if ( !_graph[i].data.forward && !_graph[i].data.backward && _graph[i].data.shortcut ) {
-                continue;
-            }
-            _graph[useful] = _graph[i];
-            useful++;
-        }
-        INFO("Removed " << _graph.size() - useful << " useless shortcuts");
-        _graph.resize( useful );
-
-        for ( int threadNum = 0; threadNum < maxThreads; ++threadNum ) {
-            delete threadData[threadNum];
-        }
-    }
-
-    void _ComputeStep( _Heap* heapForward, _Heap* heapBackward, bool forwardDirection, NodeID* middle, int* targetDistance ) {
-
-        const NodeID node = heapForward->DeleteMin();
-        const int distance = heapForward->GetKey( node );
-
-        if ( distance > *targetDistance ) {
-            heapForward->DeleteAll();
-            return;
-        }
-
-        if ( heapBackward->WasInserted( node ) ) {
-            const int newDistance = heapBackward->GetKey( node ) + distance;
-            if ( newDistance < *targetDistance ) {
-                *middle = node;
-                *targetDistance = newDistance;
-            }
-        }
-
-       for ( int edge = _firstEdge[node], endEdges = _firstEdge[node + 1]; edge != endEdges; ++edge ) {
-            const NodeID to = _graph[edge].target;
-            const int edgeWeight = _graph[edge].data.distance;
-            assert( edgeWeight > 0 );
-            const int toDistance = distance + edgeWeight;
-
-            if ( (forwardDirection ? _graph[edge].data.forward : _graph[edge].data.backward ) ) {
-                //New Node discovered -> Add to Heap + Node Info Storage
-                if ( !heapForward->WasInserted( to ) )
-                    heapForward->Insert( to, toDistance, node );
-
-                //Found a shorter Path -> Update distance
-                else if ( toDistance < heapForward->GetKey( to ) ) {
-                    heapForward->DecreaseKey( to, toDistance );
-                    //new parent
-                    heapForward->GetData( to ) = node;
-                }
-            }
-        }
-    }
-
-    int _ComputeDistance( NodeID source, NodeID target, _ThreadData * data ) {
-        data->_heapForward->Clear();
-        data->_heapBackward->Clear();
-        //insert source into heap
-        data->_heapForward->Insert( source, 0, source );
-        data->_heapBackward->Insert( target, 0, target );
-
-        int targetDistance = std::numeric_limits< int >::max();
-        NodeID middle = std::numeric_limits<NodeID>::max();
-
-        while ( data->_heapForward->Size() + data->_heapBackward->Size() > 0 ) {
-            if ( data->_heapForward->Size() > 0 ) {
-                _ComputeStep( data->_heapForward, data->_heapBackward, true, &middle, &targetDistance );
-            }
-
-            if ( data->_heapBackward->Size() > 0 ) {
-                _ComputeStep( data->_heapBackward, data->_heapForward, false, &middle, &targetDistance );
-            }
-        }
-        return targetDistance;
-    }
-    NodeID _numNodes;
-    std::vector< Edge > _graph;
-    std::vector< unsigned > _firstEdge;
-};
-
-#endif // CONTRACTIONCLEANUP_H_INCLUDED

Contractor/Contractor.h

@@ -1,36 +1,32 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 CONTRACTOR_H_INCLUDED
 #define CONTRACTOR_H_INCLUDED
-#include <algorithm>
-#include <limits>
-#include <vector>
-
-#include <cfloat>
-#include <ctime>
-
-#include <boost/foreach.hpp>
-#include <boost/lambda/lambda.hpp>
-#include <boost/make_shared.hpp>
-#include <boost/shared_ptr.hpp>
 
 #include "TemporaryStorage.h"
 #include "../DataStructures/BinaryHeap.h"
@@ -40,8 +36,21 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #include "../DataStructures/XORFastHash.h"
 #include "../DataStructures/XORFastHashStorage.h"
 #include "../Util/OpenMPWrapper.h"
+#include "../Util/SimpleLogger.h"
 #include "../Util/StringUtil.h"
 
+#include <boost/assert.hpp>
+#include <boost/foreach.hpp>
+#include <boost/lambda/lambda.hpp>
+#include <boost/make_shared.hpp>
+#include <boost/shared_ptr.hpp>
+
+#include <ctime>
+
+#include <algorithm>
+#include <limits>
+#include <vector>
+
 class Contractor {
 
 private:
@@ -119,10 +128,11 @@ public:
             newEdge.target = diter->target();
             newEdge.data = _ContractorEdgeData( (std::max)((int)diter->weight(), 1 ),  1,  diter->id(),  false,  diter->isForward(),  diter->isBackward());
 
-            assert( newEdge.data.distance > 0 );
+            BOOST_ASSERT_MSG( newEdge.data.distance > 0, "edge distance < 1" );
 #ifndef NDEBUG
             if ( newEdge.data.distance > 24 * 60 * 60 * 10 ) {
-                WARN("Edge weight large -> " << newEdge.data.distance);
+                SimpleLogger().Write(logWARNING) <<
+                    "Edge weight large -> " << newEdge.data.distance;
             }
 #endif
             edges.push_back( newEdge );
@@ -157,11 +167,13 @@ public:
             forwardEdge.data.distance = backwardEdge.data.distance = std::numeric_limits< int >::max();
             //remove parallel edges
             while ( i < edges.size() && edges[i].source == source && edges[i].target == target ) {
-                if ( edges[i].data.forward )
+            	if ( edges[i].data.forward) {
                     forwardEdge.data.distance = std::min( edges[i].data.distance, forwardEdge.data.distance );
-                if ( edges[i].data.backward )
+                }
+                if ( edges[i].data.backward) {
                     backwardEdge.data.distance = std::min( edges[i].data.distance, backwardEdge.data.distance );
-                i++;
+                }
+                ++i;
             }
             //merge edges (s,t) and (t,s) into bidirectional edge
             if ( forwardEdge.data.distance == backwardEdge.data.distance ) {
@@ -194,9 +206,9 @@ public:
         //            }
         //        }
         //
-        //        INFO("edges at node with id " << highestNode << " has degree " << maxdegree);
+        //        SimpleLogger().Write() << "edges at node with id " << highestNode << " has degree " << maxdegree;
         //        for(unsigned i = _graph->BeginEdges(highestNode); i < _graph->EndEdges(highestNode); ++i) {
-        //            INFO(" ->(" << highestNode << "," << _graph->GetTarget(i) << "); via: " << _graph->GetEdgeData(i).via);
+        //            SimpleLogger().Write() << " ->(" << highestNode << "," << _graph->GetTarget(i) << "); via: " << _graph->GetEdgeData(i).via;
         //        }
 
         //Create temporary file
@@ -230,8 +242,9 @@ public:
 
         //initialize the variables
 #pragma omp parallel for schedule ( guided )
-        for ( int x = 0; x < ( int ) numberOfNodes; ++x )
+        for ( int x = 0; x < ( int ) numberOfNodes; ++x ) {
             remainingNodes[x].id = x;
+        }
 
         std::cout << "initializing elimination PQ ..." << std::flush;
 #pragma omp parallel
@@ -242,10 +255,10 @@ public:
                 nodePriority[x] = _Evaluate( data, &nodeData[x], x );
             }
         }
-        std::cout << "ok" << std::endl << "preprocessing ..." << std::flush;
+        std::cout << "ok" << std::endl << "preprocessing " << numberOfNodes << " nodes ..." << std::flush;
 
         bool flushedContractor = false;
-        while ( numberOfContractedNodes < numberOfNodes ) {
+        while ( numberOfNodes > 2 && numberOfContractedNodes < numberOfNodes ) {
             if(!flushedContractor && (numberOfContractedNodes > (numberOfNodes*0.65) ) ){
                 DeallocatingVector<_ContractorEdge> newSetOfEdges; //this one is not explicitely cleared since it goes out of scope anywa
                 std::cout << " [flush " << numberOfContractedNodes << " nodes] " << std::flush;
@@ -274,13 +287,12 @@ public:
                 TemporaryStorage & tempStorage = TemporaryStorage::GetInstance();
                 //Write dummy number of edges to temporary file
                 //        		std::ofstream temporaryEdgeStorage(temporaryEdgeStorageFilename.c_str(), std::ios::binary);
-                long initialFilePosition = tempStorage.tell(temporaryStorageSlotID);
+                uint64_t initialFilePosition = tempStorage.tell(temporaryStorageSlotID);
                 unsigned numberOfTemporaryEdges = 0;
                 tempStorage.writeToSlot(temporaryStorageSlotID, (char*)&numberOfTemporaryEdges, sizeof(unsigned));
 
                 //walk over all nodes
                 for(unsigned i = 0; i < _graph->GetNumberOfNodes(); ++i) {
-                    //INFO("Restructuring node " << i << "|" << _graph->GetNumberOfNodes());
                     const NodeID start = i;
                     for(_DynamicGraph::EdgeIterator currentEdge = _graph->BeginEdges(start); currentEdge < _graph->EndEdges(start); ++currentEdge) {
                         _DynamicGraph::EdgeData & data = _graph->GetEdgeData(currentEdge);
@@ -299,8 +311,14 @@ public:
                             newEdge.target = newNodeIDFromOldNodeIDMap[target];
                             newEdge.data = data;
                             newEdge.data.originalViaNodeID = true;
-                            assert(UINT_MAX != newNodeIDFromOldNodeIDMap[start] );
-                            assert(UINT_MAX != newNodeIDFromOldNodeIDMap[target]);
+                            BOOST_ASSERT_MSG(
+                                UINT_MAX != newNodeIDFromOldNodeIDMap[start],
+                                "new start id not resolveable"
+                            );
+                            BOOST_ASSERT_MSG(
+                                UINT_MAX != newNodeIDFromOldNodeIDMap[target],
+                                "new target id not resolveable"
+                            );
                             newSetOfEdges.push_back(newEdge);
                         }
                     }
@@ -309,8 +327,6 @@ public:
                 tempStorage.seek(temporaryStorageSlotID, initialFilePosition);
                 tempStorage.writeToSlot(temporaryStorageSlotID, (char*)&numberOfTemporaryEdges, sizeof(unsigned));
 
-                //        		INFO("Flushed " << numberOfTemporaryEdges << " edges to disk");
-
                 //Delete map from old NodeIDs to new ones.
                 std::vector<NodeID>().swap(newNodeIDFromOldNodeIDMap);
 
@@ -422,52 +438,63 @@ public:
             //            avgdegree /= std::max((unsigned)1,(unsigned)remainingNodes.size() );
             //            quaddegree /= std::max((unsigned)1,(unsigned)remainingNodes.size() );
             //
-            //            INFO("rest: " << remainingNodes.size() << ", max: " << maxdegree << ", min: " << mindegree << ", avg: " << avgdegree << ", quad: " << quaddegree);
+            //            SimpleLogger().Write() << "rest: " << remainingNodes.size() << ", max: " << maxdegree << ", min: " << mindegree << ", avg: " << avgdegree << ", quad: " << quaddegree;
 
             p.printStatus(numberOfContractedNodes);
         }
-        BOOST_FOREACH(_ThreadData * data, threadData)
+        BOOST_FOREACH(_ThreadData * data, threadData) {
         	delete data;
+        }
         threadData.clear();
     }
 
     template< class Edge >
     inline void GetEdges( DeallocatingVector< Edge >& edges ) {
         Percent p (_graph->GetNumberOfNodes());
-        INFO("Getting edges of minimized graph");
+        SimpleLogger().Write() << "Getting edges of minimized graph";
         NodeID numberOfNodes = _graph->GetNumberOfNodes();
-        if(oldNodeIDFromNewNodeIDMap.size()) {
+        if(_graph->GetNumberOfNodes()) {
             for ( NodeID node = 0; node < numberOfNodes; ++node ) {
                 p.printStatus(node);
                 for ( _DynamicGraph::EdgeIterator edge = _graph->BeginEdges( node ), endEdges = _graph->EndEdges( node ); edge < endEdges; ++edge ) {
                     const NodeID target = _graph->GetTarget( edge );
                     const _DynamicGraph::EdgeData& data = _graph->GetEdgeData( edge );
                     Edge newEdge;
-                    newEdge.source = oldNodeIDFromNewNodeIDMap[node];
-                    newEdge.target = oldNodeIDFromNewNodeIDMap[target];
-                    assert(UINT_MAX != newEdge.source);
-                    assert(UINT_MAX != newEdge.target);
-
+                    if(0 != oldNodeIDFromNewNodeIDMap.size()) {
+                        newEdge.source = oldNodeIDFromNewNodeIDMap[node];
+                        newEdge.target = oldNodeIDFromNewNodeIDMap[target];
+                    } else {
+                        newEdge.source = node;
+                        newEdge.target = target;
+                    }
+                    BOOST_ASSERT_MSG(
+                        UINT_MAX != newEdge.source,
+                        "Source id invalid"
+                    );
+                    BOOST_ASSERT_MSG(
+                        UINT_MAX != newEdge.target,
+                        "Target id invalid"
+                    );
                     newEdge.data.distance = data.distance;
                     newEdge.data.shortcut = data.shortcut;
-                    if(!data.originalViaNodeID)
+                   if(!data.originalViaNodeID && oldNodeIDFromNewNodeIDMap.size()) {
                         newEdge.data.id = oldNodeIDFromNewNodeIDMap[data.id];
-                    else
+                    } else {
                         newEdge.data.id = data.id;
-
-                    assert(newEdge.data.id != UINT_MAX);
+                    }
+                    BOOST_ASSERT_MSG(
+                        newEdge.data.id != INT_MAX, //2^31
+                        "edge id invalid"
+                    );
                     newEdge.data.forward = data.forward;
                     newEdge.data.backward = data.backward;
                     edges.push_back( newEdge );
                 }
             }
         }
-        INFO("Renumbered edges of minimized graph, freeing space");
         _graph.reset();
         std::vector<NodeID>().swap(oldNodeIDFromNewNodeIDMap);
-        INFO("Loading temporary edges");
 
-        //        std::ifstream temporaryEdgeStorage(temporaryEdgeStorageFilename.c_str(), std::ios::binary);
         TemporaryStorage & tempStorage = TemporaryStorage::GetInstance();
         //Also get the edges from temporary storage
         unsigned numberOfTemporaryEdges = 0;
@@ -492,7 +519,6 @@ public:
             edges.push_back( newEdge );
         }
         tempStorage.deallocateSlot(temporaryStorageSlotID);
-        INFO("Hierarchy has " << edges.size() << " edges");
     }
 
 private:
@@ -515,24 +541,27 @@ private:
 
             if ( heap.GetData( node ).target ) {
                 ++targetsFound;
-                if ( targetsFound >= numTargets )
+                if ( targetsFound >= numTargets ) {
                     return;
+                }
             }
 
             //iterate over all edges of node
             for ( _DynamicGraph::EdgeIterator edge = _graph->BeginEdges( node ), endEdges = _graph->EndEdges( node ); edge != endEdges; ++edge ) {
                 const _ContractorEdgeData& data = _graph->GetEdgeData( edge );
-                if ( !data.forward )
+                if ( !data.forward ){
                     continue;
+                }
                 const NodeID to = _graph->GetTarget( edge );
-                if(middleNode == to)
+                if(middleNode == to) {
                     continue;
+                }
                 const int toDistance = distance + data.distance;
 
                 //New Node discovered -> Add to Heap + Node Info Storage
-                if ( !heap.WasInserted( to ) )
+                if ( !heap.WasInserted( to ) ) {
                     heap.Insert( to, toDistance, _HeapData(currentHop, false) );
-
+                }
                 //Found a shorter Path -> Update distance
                 else if ( toDistance < heap.GetKey( to ) ) {
                     heap.DecreaseKey( to, toDistance );
@@ -582,8 +611,9 @@ private:
 
             for ( _DynamicGraph::EdgeIterator outEdge = _graph->BeginEdges( node ), endOutEdges = _graph->EndEdges( node ); outEdge != endOutEdges; ++outEdge ) {
                 const _ContractorEdgeData& outData = _graph->GetEdgeData( outEdge );
-                if ( !outData.forward )
+                if ( !outData.forward ) {
                     continue;
+                }
                 const NodeID target = _graph->GetTarget( outEdge );
                 const int pathDistance = inData.distance + outData.distance;
                 maxDistance = std::max( maxDistance, pathDistance );
@@ -593,15 +623,16 @@ private:
                 }
             }
 
-            if( Simulate )
+            if( Simulate ) {
                 _Dijkstra( maxDistance, numTargets, 1000, data, node );
-            else
+            } else {
                 _Dijkstra( maxDistance, numTargets, 2000, data, node );
-
+            }
             for ( _DynamicGraph::EdgeIterator outEdge = _graph->BeginEdges( node ), endOutEdges = _graph->EndEdges( node ); outEdge != endOutEdges; ++outEdge ) {
                 const _ContractorEdgeData& outData = _graph->GetEdgeData( outEdge );
-                if ( !outData.forward )
+                if ( !outData.forward ) {
                     continue;
+                }
                 const NodeID target = _graph->GetTarget( outEdge );
                 const int pathDistance = inData.distance + outData.distance;
                 const int distance = heap.GetKey( target );
@@ -641,8 +672,9 @@ private:
                     found = true;
                     break;
                 }
-                if ( !found )
+                if ( !found ) {
                     insertedEdges[insertedEdgesSize++] = insertedEdges[i];
+                }
             }
             insertedEdges.resize( insertedEdgesSize );
         }
@@ -706,7 +738,7 @@ private:
             if ( priority > targetPriority )
                 return false;
             //tie breaking
-            if ( fabs(priority - targetPriority) < FLT_EPSILON && bias(node, target) ) {
+            if ( fabs(priority - targetPriority) < std::numeric_limits<double>::epsilon() && bias(node, target) ) {
                 return false;
             }
             neighbours.push_back( target );
@@ -728,7 +760,7 @@ private:
                 if ( priority > targetPriority)
                     return false;
                 //tie breaking
-                if ( fabs(priority - targetPriority) < FLT_EPSILON && bias(node, target) ) {
+                if ( fabs(priority - targetPriority) < std::numeric_limits<double>::epsilon() && bias(node, target) ) {
                     return false;
                 }
             }

Contractor/EdgeBasedGraphFactory.cpp

@@ -1,213 +1,288 @@
 /*
- open source routing machine
- Copyright (C) Dennis Luxen, others 2010
 
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU AFFERO General Public License as published by
- the Free Software Foundation; either version 3 of the License, or
- any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
- You should have received a copy of the GNU Affero General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- or see http://www.gnu.org/licenses/agpl.txt.
- */
+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.
+
+*/
 
 #include "EdgeBasedGraphFactory.h"
 
-template<>
-EdgeBasedGraphFactory::EdgeBasedGraphFactory(int nodes, std::vector<NodeBasedEdge> & inputEdges, std::vector<NodeID> & bn, std::vector<NodeID> & tl, std::vector<_Restriction> & irs, std::vector<NodeInfo> & nI, SpeedProfileProperties sp) : inputNodeInfoList(nI), numberOfTurnRestrictions(irs.size()), speedProfile(sp) {
-	BOOST_FOREACH(_Restriction & restriction, irs) {
-        std::pair<NodeID, NodeID> restrictionSource = std::make_pair(restriction.fromNode, restriction.viaNode);
+EdgeBasedGraphFactory::EdgeBasedGraphFactory(
+    int number_of_nodes,
+    std::vector<ImportEdge> & input_edge_list,
+    std::vector<NodeID> & barrier_node_list,
+    std::vector<NodeID> & traffic_light_node_list,
+    std::vector<TurnRestriction> & input_restrictions_list,
+    std::vector<NodeInfo> & m_node_info_list,
+    SpeedProfileProperties speed_profile
+) : speed_profile(speed_profile),
+    m_turn_restrictions_count(0),
+    m_node_info_list(m_node_info_list)
+{
+	BOOST_FOREACH(const TurnRestriction & restriction, input_restrictions_list) {
+        std::pair<NodeID, NodeID> restriction_source =
+            std::make_pair(restriction.fromNode, restriction.viaNode);
         unsigned index;
-        RestrictionMap::iterator restrIter = _restrictionMap.find(restrictionSource);
-        if(restrIter == _restrictionMap.end()) {
-            index = _restrictionBucketVector.size();
-            _restrictionBucketVector.resize(index+1);
-            _restrictionMap[restrictionSource] = index;
+        RestrictionMap::iterator restriction_iter = m_restriction_map.find(restriction_source);
+        if(restriction_iter == m_restriction_map.end()) {
+            index = m_restriction_bucket_list.size();
+            m_restriction_bucket_list.resize(index+1);
+            m_restriction_map.emplace(restriction_source, index);
         } else {
-            index = restrIter->second;
+            index = restriction_iter->second;
             //Map already contains an is_only_*-restriction
-            if(_restrictionBucketVector.at(index).begin()->second)
+            if(m_restriction_bucket_list.at(index).begin()->second) {
                 continue;
-            else if(restriction.flags.isOnly){
+            } else if(restriction.flags.isOnly) {
                 //We are going to insert an is_only_*-restriction. There can be only one.
-                _restrictionBucketVector.at(index).clear();
+                m_turn_restrictions_count -= m_restriction_bucket_list.at(index).size();
+                m_restriction_bucket_list.at(index).clear();
             }
         }
-
-        _restrictionBucketVector.at(index).push_back(std::make_pair(restriction.toNode, restriction.flags.isOnly));
+        ++m_turn_restrictions_count;
+        m_restriction_bucket_list.at(index).push_back(
+            std::make_pair( restriction.toNode, restriction.flags.isOnly)
+        );
     }
 
-    BOOST_FOREACH(NodeID id, bn) {
-        _barrierNodes[id] = true;
-    }
-    BOOST_FOREACH(NodeID id, tl) {
-        _trafficLights[id] = true;
-    }
+	m_barrier_nodes.insert(
+        barrier_node_list.begin(),
+        barrier_node_list.end()
+    );
 
-    DeallocatingVector< _NodeBasedEdge > edges;
-    //    edges.reserve( 2 * inputEdges.size() );
-    for ( std::vector< NodeBasedEdge >::const_iterator i = inputEdges.begin(); i != inputEdges.end(); ++i ) {
+    m_traffic_lights.insert(
+        traffic_light_node_list.begin(),
+        traffic_light_node_list.end()
+    );
 
-        _NodeBasedEdge edge;
-        if(!i->isForward()) {
-            edge.source = i->target();
-            edge.target = i->source();
-            edge.data.backward = i->isForward();
-            edge.data.forward = i->isBackward();
+    DeallocatingVector< NodeBasedEdge > edges_list;
+    NodeBasedEdge edge;
+    BOOST_FOREACH(const ImportEdge & import_edge, input_edge_list) {
+        if(!import_edge.isForward()) {
+            edge.source = import_edge.target();
+            edge.target = import_edge.source();
+            edge.data.backward = import_edge.isForward();
+            edge.data.forward = import_edge.isBackward();
         } else {
-            edge.source = i->source();
-            edge.target = i->target();
-            edge.data.forward = i->isForward();
-            edge.data.backward = i->isBackward();
+            edge.source = import_edge.source();
+            edge.target = import_edge.target();
+            edge.data.forward = import_edge.isForward();
+            edge.data.backward = import_edge.isBackward();
         }
-        if(edge.source == edge.target)
-            continue;
-
-        edge.data.distance = (std::max)((int)i->weight(), 1 );
+        if(edge.source == edge.target) {
+        	continue;
+        }
+        edge.data.distance = (std::max)((int)import_edge.weight(), 1 );
         assert( edge.data.distance > 0 );
         edge.data.shortcut = false;
-        edge.data.roundabout = i->isRoundabout();
-        edge.data.ignoreInGrid = i->ignoreInGrid();
-        edge.data.nameID = i->name();
-        edge.data.type = i->type();
-        edge.data.isAccessRestricted = i->isAccessRestricted();
-        edge.data.edgeBasedNodeID = edges.size();
-        edges.push_back( edge );
+        edge.data.roundabout = import_edge.isRoundabout();
+        edge.data.ignoreInGrid = import_edge.ignoreInGrid();
+        edge.data.nameID = import_edge.name();
+        edge.data.type = import_edge.type();
+        edge.data.isAccessRestricted = import_edge.isAccessRestricted();
+        edge.data.edgeBasedNodeID = edges_list.size();
+        edge.data.contraFlow = import_edge.isContraFlow();
+        edges_list.push_back( edge );
         if( edge.data.backward ) {
             std::swap( edge.source, edge.target );
-            edge.data.forward = i->isBackward();
-            edge.data.backward = i->isForward();
-            edge.data.edgeBasedNodeID = edges.size();
-            edges.push_back( edge );
+            edge.data.forward = import_edge.isBackward();
+            edge.data.backward = import_edge.isForward();
+            edge.data.edgeBasedNodeID = edges_list.size();
+            edges_list.push_back( edge );
         }
     }
-    std::vector<NodeBasedEdge>().swap(inputEdges);
-    std::sort( edges.begin(), edges.end() );
-    _nodeBasedGraph = boost::make_shared<_NodeBasedDynamicGraph>( nodes, edges );
+    std::vector<ImportEdge>().swap(input_edge_list);
+    std::sort( edges_list.begin(), edges_list.end() );
+    m_node_based_graph = boost::make_shared<NodeBasedDynamicGraph>(
+        number_of_nodes, edges_list
+    );
 }
 
-void EdgeBasedGraphFactory::GetEdgeBasedEdges(DeallocatingVector< EdgeBasedEdge >& outputEdgeList ) {
-    GUARANTEE(0 == outputEdgeList.size(), "Vector passed to EdgeBasedGraphFactory::GetEdgeBasedEdges(..) is not empty");
-    edgeBasedEdges.swap(outputEdgeList);
+void EdgeBasedGraphFactory::GetEdgeBasedEdges(
+    DeallocatingVector< EdgeBasedEdge >& output_edge_list
+) {
+    BOOST_ASSERT_MSG(
+        0 == output_edge_list.size(),
+        "Vector is not empty"
+    );
+    m_edge_based_edge_list.swap(output_edge_list);
 }
 
-void EdgeBasedGraphFactory::GetEdgeBasedNodes( DeallocatingVector< EdgeBasedNode> & nodes) {
+void EdgeBasedGraphFactory::GetEdgeBasedNodes( std::vector<EdgeBasedNode> & nodes) {
 #ifndef NDEBUG
-    BOOST_FOREACH(EdgeBasedNode & node, edgeBasedNodes){
+    BOOST_FOREACH(const EdgeBasedNode & node, m_edge_based_node_list){
         assert(node.lat1 != INT_MAX); assert(node.lon1 != INT_MAX);
         assert(node.lat2 != INT_MAX); assert(node.lon2 != INT_MAX);
     }
 #endif
-    nodes.swap(edgeBasedNodes);
+    nodes.swap(m_edge_based_node_list);
 }
 
-void EdgeBasedGraphFactory::GetOriginalEdgeData( std::vector< OriginalEdgeData> & oed) {
-    oed.swap(originalEdgeData);
-}
-
-NodeID EdgeBasedGraphFactory::CheckForEmanatingIsOnlyTurn(const NodeID u, const NodeID v) const {
-    std::pair < NodeID, NodeID > restrictionSource = std::make_pair(u, v);
-    RestrictionMap::const_iterator restrIter = _restrictionMap.find(restrictionSource);
-    if (restrIter != _restrictionMap.end()) {
-        unsigned index = restrIter->second;
-        BOOST_FOREACH(RestrictionSource restrictionTarget, _restrictionBucketVector.at(index)) {
-            if(restrictionTarget.second) {
-                return restrictionTarget.first;
+NodeID EdgeBasedGraphFactory::CheckForEmanatingIsOnlyTurn(
+    const NodeID u,
+    const NodeID v
+) const {
+    const std::pair < NodeID, NodeID > restriction_source = std::make_pair(u, v);
+    RestrictionMap::const_iterator restriction_iter = m_restriction_map.find(restriction_source);
+    if (restriction_iter != m_restriction_map.end()) {
+        const unsigned index = restriction_iter->second;
+        BOOST_FOREACH(
+            const RestrictionSource & restriction_target,
+            m_restriction_bucket_list.at(index)
+        ) {
+            if(restriction_target.second) {
+                return restriction_target.first;
             }
         }
     }
     return UINT_MAX;
 }
 
-bool EdgeBasedGraphFactory::CheckIfTurnIsRestricted(const NodeID u, const NodeID v, const NodeID w) const {
+bool EdgeBasedGraphFactory::CheckIfTurnIsRestricted(
+    const NodeID u,
+    const NodeID v,
+    const NodeID w
+) const {
     //only add an edge if turn is not a U-turn except it is the end of dead-end street.
-    std::pair < NodeID, NodeID > restrictionSource = std::make_pair(u, v);
-    RestrictionMap::const_iterator restrIter = _restrictionMap.find(restrictionSource);
-    if (restrIter != _restrictionMap.end()) {
-        unsigned index = restrIter->second;
-        BOOST_FOREACH(RestrictionTarget restrictionTarget, _restrictionBucketVector.at(index)) {
-            if(w == restrictionTarget.first)
+    const std::pair < NodeID, NodeID > restriction_source = std::make_pair(u, v);
+    RestrictionMap::const_iterator restriction_iter = m_restriction_map.find(restriction_source);
+    if (restriction_iter != m_restriction_map.end()) {
+        const unsigned index = restriction_iter->second;
+        BOOST_FOREACH(
+            const RestrictionTarget & restriction_target,
+            m_restriction_bucket_list.at(index)
+        ) {
+            if(w == restriction_target.first) {
                 return true;
+            }
         }
     }
     return false;
 }
 
 void EdgeBasedGraphFactory::InsertEdgeBasedNode(
-        _NodeBasedDynamicGraph::EdgeIterator e1,
-        _NodeBasedDynamicGraph::NodeIterator u,
-        _NodeBasedDynamicGraph::NodeIterator v,
+        EdgeIterator e1,
+        NodeIterator u,
+        NodeIterator v,
         bool belongsToTinyComponent) {
-    _NodeBasedDynamicGraph::EdgeData & data = _nodeBasedGraph->GetEdgeData(e1);
+    EdgeData & data = m_node_based_graph->GetEdgeData(e1);
     EdgeBasedNode currentNode;
     currentNode.nameID = data.nameID;
-    currentNode.lat1 = inputNodeInfoList[u].lat;
-    currentNode.lon1 = inputNodeInfoList[u].lon;
-    currentNode.lat2 = inputNodeInfoList[v].lat;
-    currentNode.lon2 = inputNodeInfoList[v].lon;
+    currentNode.lat1 = m_node_info_list[u].lat;
+    currentNode.lon1 = m_node_info_list[u].lon;
+    currentNode.lat2 = m_node_info_list[v].lat;
+    currentNode.lon2 = m_node_info_list[v].lon;
     currentNode.belongsToTinyComponent = belongsToTinyComponent;
     currentNode.id = data.edgeBasedNodeID;
     currentNode.ignoreInGrid = data.ignoreInGrid;
     currentNode.weight = data.distance;
-    edgeBasedNodes.push_back(currentNode);
+    m_edge_based_node_list.push_back(currentNode);
 }
 
-void EdgeBasedGraphFactory::Run(const char * originalEdgeDataFilename) {
-    Percent p(_nodeBasedGraph->GetNumberOfNodes());
-    int numberOfSkippedTurns(0);
-    int nodeBasedEdgeCounter(0);
-    unsigned numberOfOriginalEdges(0);
-    std::ofstream originalEdgeDataOutFile(originalEdgeDataFilename, std::ios::binary);
-    originalEdgeDataOutFile.write((char*)&numberOfOriginalEdges, sizeof(unsigned));
+void EdgeBasedGraphFactory::Run(
+    const char * original_edge_data_filename,
+    lua_State *lua_state
+) {
+    SimpleLogger().Write() << "Identifying components of the road network";
 
+    Percent p(m_node_based_graph->GetNumberOfNodes());
+    unsigned skipped_turns_counter   = 0;
+    unsigned node_based_edge_counter = 0;
+    unsigned original_edges_counter  = 0;
 
-    INFO("Identifying small components");
+    std::ofstream edge_data_file(
+        original_edge_data_filename,
+        std::ios::binary
+    );
+
+    //writes a dummy value that is updated later
+    edge_data_file.write(
+        (char*)&original_edges_counter,
+        sizeof(unsigned)
+    );
+
+    unsigned current_component = 0, current_component_size = 0;
     //Run a BFS on the undirected graph and identify small components
-    std::queue<std::pair<NodeID, NodeID> > bfsQueue;
-    std::vector<unsigned> componentsIndex(_nodeBasedGraph->GetNumberOfNodes(), UINT_MAX);
-    std::vector<NodeID> vectorOfComponentSizes;
-    unsigned currentComponent = 0, sizeOfCurrentComponent = 0;
+    std::queue<std::pair<NodeID, NodeID> > bfs_queue;
+    std::vector<unsigned> component_index_list(
+        m_node_based_graph->GetNumberOfNodes(),
+        UINT_MAX
+    );
+
+    std::vector<NodeID> component_size_list;
     //put unexplorered node with parent pointer into queue
-    for(NodeID node = 0, endNodes = _nodeBasedGraph->GetNumberOfNodes(); node < endNodes; ++node) {
-        if(UINT_MAX == componentsIndex[node]) {
-            bfsQueue.push(std::make_pair(node, node));
+    for(
+        NodeID node = 0,
+            last_node = m_node_based_graph->GetNumberOfNodes();
+        node < last_node;
+        ++node
+    ) {
+        if(UINT_MAX == component_index_list[node]) {
+            bfs_queue.push(std::make_pair(node, node));
             //mark node as read
-            componentsIndex[node] = currentComponent;
+            component_index_list[node] = current_component;
             p.printIncrement();
-            while(!bfsQueue.empty()) {
+            while(!bfs_queue.empty()) {
                 //fetch element from BFS queue
-                std::pair<NodeID, NodeID> currentQueueItem = bfsQueue.front();
-                bfsQueue.pop();
-                //                INFO("sizeof queue: " << bfsQueue.size() <<  ", sizeOfCurrentComponents: " <<  sizeOfCurrentComponent << ", settled nodes: " << settledNodes++ << ", max: " << endNodes);
-                const NodeID v = currentQueueItem.first;  //current node
-                const NodeID u = currentQueueItem.second; //parent
+                std::pair<NodeID, NodeID> current_queue_item = bfs_queue.front();
+                bfs_queue.pop();
+                // SimpleLogger().Write() << "sizeof queue: " << bfs_queue.size() <<
+                //  ", current_component_sizes: " <<  current_component_size <<
+                //", settled nodes: " << settledNodes++ << ", max: " << endNodes;
+                const NodeID v = current_queue_item.first;  //current node
+                const NodeID u = current_queue_item.second; //parent
                 //increment size counter of current component
-                ++sizeOfCurrentComponent;
-                const bool isBollardNode = (_barrierNodes.find(v) != _barrierNodes.end());
-                if(!isBollardNode) {
-                    const NodeID onlyToNode = CheckForEmanatingIsOnlyTurn(u, v);
+                ++current_component_size;
+                const bool is_barrier_node = (m_barrier_nodes.find(v) != m_barrier_nodes.end());
+                if(!is_barrier_node) {
+                    const NodeID to_node_of_only_restriction = CheckForEmanatingIsOnlyTurn(u, v);
 
                     //relaxieren edge outgoing edge like below where edge-expanded graph
-                    for(_NodeBasedDynamicGraph::EdgeIterator e2 = _nodeBasedGraph->BeginEdges(v); e2 < _nodeBasedGraph->EndEdges(v); ++e2) {
-                        _NodeBasedDynamicGraph::NodeIterator w = _nodeBasedGraph->GetTarget(e2);
+                    for(
+                        EdgeIterator e2 = m_node_based_graph->BeginEdges(v);
+                        e2 < m_node_based_graph->EndEdges(v);
+                        ++e2
+                    ) {
+                        NodeIterator w = m_node_based_graph->GetTarget(e2);
 
-                        if(onlyToNode != UINT_MAX && w != onlyToNode) { //We are at an only_-restriction but not at the right turn.
+                        if(
+                            to_node_of_only_restriction != UINT_MAX &&
+                            w != to_node_of_only_restriction
+                        ) {
+                            //We are at an only_-restriction but not at the right turn.
                             continue;
                         }
-                        if( u != w ) { //only add an edge if turn is not a U-turn except it is the end of dead-end street.
-                            if (!CheckIfTurnIsRestricted(u, v, w) ) { //only add an edge if turn is not prohibited
-                                //insert next (node, parent) only if w has not yet been explored
-                                if(UINT_MAX == componentsIndex[w]) {
+                        if( u != w ) {
+                            //only add an edge if turn is not a U-turn except
+                            //when it is at the end of a dead-end street.
+                            if (!CheckIfTurnIsRestricted(u, v, w) ) {
+                                //only add an edge if turn is not prohibited
+                                if(UINT_MAX == component_index_list[w]) {
+                                    //insert next (node, parent) only if w has
+                                    //not yet been explored
                                     //mark node as read
-                                    componentsIndex[w] = currentComponent;
-                                    bfsQueue.push(std::make_pair(w,v));
+                                    component_index_list[w] = current_component;
+                                    bfs_queue.push(std::make_pair(w,v));
                                     p.printIncrement();
                                 }
                             }
@@ -216,176 +291,288 @@ void EdgeBasedGraphFactory::Run(const char * originalEdgeDataFilename) {
                 }
             }
             //push size into vector
-            vectorOfComponentSizes.push_back(sizeOfCurrentComponent);
+            component_size_list.push_back(current_component_size);
             //reset counters;
-            sizeOfCurrentComponent = 0;
-            ++currentComponent;
+            current_component_size = 0;
+            ++current_component;
         }
     }
-    INFO("identified: " << vectorOfComponentSizes.size() << " many components");
+    SimpleLogger().Write() <<
+        "identified: " << component_size_list.size() << " many components";
+    SimpleLogger().Write() <<
+        "generating edge-expanded nodes";
 
-    p.reinit(_nodeBasedGraph->GetNumberOfNodes());
+    p.reinit(m_node_based_graph->GetNumberOfNodes());
     //loop over all edges and generate new set of nodes.
-    for(_NodeBasedDynamicGraph::NodeIterator u = 0; u < _nodeBasedGraph->GetNumberOfNodes(); ++u ) {
-        for(_NodeBasedDynamicGraph::EdgeIterator e1 = _nodeBasedGraph->BeginEdges(u); e1 < _nodeBasedGraph->EndEdges(u); ++e1) {
-            _NodeBasedDynamicGraph::NodeIterator v = _nodeBasedGraph->GetTarget(e1);
+    for(
+        NodeIterator u = 0,
+            number_of_nodes = m_node_based_graph->GetNumberOfNodes();
+        u < number_of_nodes;
+        ++u
+     ) {
+        p.printIncrement();
+        for(
+            EdgeIterator e1 = m_node_based_graph->BeginEdges(u),
+                last_edge = m_node_based_graph->EndEdges(u);
+            e1 < last_edge;
+            ++e1
+        ) {
+            NodeIterator v = m_node_based_graph->GetTarget(e1);
 
-            if(_nodeBasedGraph->GetEdgeData(e1).type != SHRT_MAX) {
-                assert(e1 != UINT_MAX);
-                assert(u != UINT_MAX);
-                assert(v != UINT_MAX);
-                //edges that end on bollard nodes may actually be in two distinct components
-                InsertEdgeBasedNode(e1, u, v, (std::min(vectorOfComponentSizes[componentsIndex[u]], vectorOfComponentSizes[componentsIndex[v]]) < 1000) );
+            if(m_node_based_graph->GetEdgeData(e1).type != SHRT_MAX) {
+                BOOST_ASSERT_MSG(e1 != UINT_MAX, "edge id invalid");
+                BOOST_ASSERT_MSG(u != UINT_MAX,  "souce node invalid");
+                BOOST_ASSERT_MSG(v != UINT_MAX,  "target node invalid");
+            //Note: edges that end on barrier nodes or on a turn restriction
+            //may actually be in two distinct components. We choose the smallest
+                const unsigned size_of_component = std::min(
+                    component_size_list[component_index_list[u]],
+                    component_size_list[component_index_list[v]]
+                );
+
+                InsertEdgeBasedNode( e1, u, v, size_of_component < 1000 );
             }
         }
     }
 
-    std::vector<NodeID>().swap(vectorOfComponentSizes);
-    std::vector<NodeID>().swap(componentsIndex);
+    SimpleLogger().Write()
+        << "Generated " << m_edge_based_node_list.size() << " nodes in " <<
+        "edge-expanded graph";
+    SimpleLogger().Write() <<
+        "generating edge-expanded edges";
+
+    std::vector<NodeID>().swap(component_size_list);
+    BOOST_ASSERT_MSG(
+        0 == component_size_list.capacity(),
+        "component size vector not deallocated"
+    );
+    std::vector<NodeID>().swap(component_index_list);
+    BOOST_ASSERT_MSG(
+        0 == component_index_list.capacity(),
+        "component index vector not deallocated"
+    );
+    std::vector<OriginalEdgeData> original_edge_data_vector;
+    original_edge_data_vector.reserve(10000);
 
     //Loop over all turns and generate new set of edges.
-    //Three nested loop look super-linear, but we are dealing with a linear number of turns only.
-    for(_NodeBasedDynamicGraph::NodeIterator u = 0; u < _nodeBasedGraph->GetNumberOfNodes(); ++u ) {
-        for(_NodeBasedDynamicGraph::EdgeIterator e1 = _nodeBasedGraph->BeginEdges(u); e1 < _nodeBasedGraph->EndEdges(u); ++e1) {
-            ++nodeBasedEdgeCounter;
-            _NodeBasedDynamicGraph::NodeIterator v = _nodeBasedGraph->GetTarget(e1);
-            //EdgeWeight heightPenalty = ComputeHeightPenalty(u, v);
-            NodeID onlyToNode = CheckForEmanatingIsOnlyTurn(u, v);
-            for(_NodeBasedDynamicGraph::EdgeIterator e2 = _nodeBasedGraph->BeginEdges(v); e2 < _nodeBasedGraph->EndEdges(v); ++e2) {
-                const _NodeBasedDynamicGraph::NodeIterator w = _nodeBasedGraph->GetTarget(e2);
-
-                if(onlyToNode != UINT_MAX && w != onlyToNode) { //We are at an only_-restriction but not at the right turn.
-                    ++numberOfSkippedTurns;
-                    continue;
-                }
-                bool isBollardNode = (_barrierNodes.find(v) != _barrierNodes.end());
-                if(u == w && 1 != _nodeBasedGraph->GetOutDegree(v) ) {
+    //Three nested loop look super-linear, but we are dealing with a (kind of)
+    //linear number of turns only.
+    p.reinit(m_node_based_graph->GetNumberOfNodes());
+    for(
+        NodeIterator u = 0,
+            last_node = m_node_based_graph->GetNumberOfNodes();
+        u < last_node;
+        ++u
+    ) {
+        for(
+            EdgeIterator e1 = m_node_based_graph->BeginEdges(u),
+                last_edge_u = m_node_based_graph->EndEdges(u);
+            e1 < last_edge_u;
+            ++e1
+        ) {
+            ++node_based_edge_counter;
+            NodeIterator v = m_node_based_graph->GetTarget(e1);
+            bool is_barrier_node = (m_barrier_nodes.find(v) != m_barrier_nodes.end());
+            NodeID to_node_of_only_restriction = CheckForEmanatingIsOnlyTurn(u, v);
+            for(
+                EdgeIterator e2 = m_node_based_graph->BeginEdges(v),
+                    last_edge_v = m_node_based_graph->EndEdges(v);
+                    e2 < last_edge_v;
+                    ++e2
+            ) {
+                const NodeIterator w = m_node_based_graph->GetTarget(e2);
+                if(
+                    to_node_of_only_restriction != UINT_MAX &&
+                    w != to_node_of_only_restriction
+                ) {
+                    //We are at an only_-restriction but not at the right turn.
+                    ++skipped_turns_counter;
                     continue;
                 }
 
-                if( !isBollardNode ) { //only add an edge if turn is not a U-turn except it is the end of dead-end street.
-                    if (!CheckIfTurnIsRestricted(u, v, w) || (onlyToNode != UINT_MAX && w == onlyToNode)) { //only add an edge if turn is not prohibited
-                        const _NodeBasedDynamicGraph::EdgeData edgeData1 = _nodeBasedGraph->GetEdgeData(e1);
-                        const _NodeBasedDynamicGraph::EdgeData edgeData2 = _nodeBasedGraph->GetEdgeData(e2);
-                        assert(edgeData1.edgeBasedNodeID < _nodeBasedGraph->GetNumberOfEdges());
-                        assert(edgeData2.edgeBasedNodeID < _nodeBasedGraph->GetNumberOfEdges());
+                if(u == w && 1 != m_node_based_graph->GetOutDegree(v) ) {
+                    continue;
+                }
 
-                        if(!edgeData1.forward || !edgeData2.forward) {
+                if( !is_barrier_node ) {
+                    //only add an edge if turn is not a U-turn except when it is
+                    //at the end of a dead-end street
+                    if (
+                        !CheckIfTurnIsRestricted(u, v, w) ||
+                        (to_node_of_only_restriction != UINT_MAX && w == to_node_of_only_restriction)
+                    ) { //only add an edge if turn is not prohibited
+                        const EdgeData edge_data1 = m_node_based_graph->GetEdgeData(e1);
+                        const EdgeData edge_data2 = m_node_based_graph->GetEdgeData(e2);
+                        assert(edge_data1.edgeBasedNodeID < m_node_based_graph->GetNumberOfEdges());
+                        assert(edge_data2.edgeBasedNodeID < m_node_based_graph->GetNumberOfEdges());
+
+                        if(!edge_data1.forward || !edge_data2.forward) {
                             continue;
                         }
 
-                        unsigned distance = edgeData1.distance;
-                        if(_trafficLights.find(v) != _trafficLights.end()) {
-                            distance += speedProfile.trafficSignalPenalty;
+                        unsigned distance = edge_data1.distance;
+                        if(m_traffic_lights.find(v) != m_traffic_lights.end()) {
+                            distance += speed_profile.trafficSignalPenalty;
                         }
+                        const unsigned penalty =
+                            GetTurnPenalty(u, v, w, lua_state);
                         TurnInstruction turnInstruction = AnalyzeTurn(u, v, w);
-                        if(turnInstruction == TurnInstructions.UTurn)
-                            distance += speedProfile.uTurnPenalty;
-//                        if(!edgeData1.isAccessRestricted && edgeData2.isAccessRestricted) {
-//                            distance += TurnInstructions.AccessRestrictionPenalty;
-//                            turnInstruction |= TurnInstructions.AccessRestrictionFlag;
-//                        }
-
-
-                        //distance += heightPenalty;
-                        //distance += ComputeTurnPenalty(u, v, w);
-                        assert(edgeData1.edgeBasedNodeID != edgeData2.edgeBasedNodeID);
-                        if(originalEdgeData.size() == originalEdgeData.capacity()-3) {
-                            originalEdgeData.reserve(originalEdgeData.size()*1.2);
+                        if(turnInstruction == TurnInstructions.UTurn){
+                            distance += speed_profile.uTurnPenalty;
                         }
-                        OriginalEdgeData oed(v,edgeData2.nameID, turnInstruction);
-                        EdgeBasedEdge newEdge(edgeData1.edgeBasedNodeID, edgeData2.edgeBasedNodeID, edgeBasedEdges.size(), distance, true, false );
-                        originalEdgeData.push_back(oed);
-                        if(originalEdgeData.size() > 100000) {
-                            originalEdgeDataOutFile.write((char*)&(originalEdgeData[0]), originalEdgeData.size()*sizeof(OriginalEdgeData));
-                            originalEdgeData.clear();
+                        distance += penalty;
+
+                        assert(edge_data1.edgeBasedNodeID != edge_data2.edgeBasedNodeID);
+                        original_edge_data_vector.push_back(
+                            OriginalEdgeData(
+                                v,
+                                edge_data2.nameID,
+                                turnInstruction
+                            )
+                        );
+                        ++original_edges_counter;
+
+                        if(original_edge_data_vector.size() > 100000) {
+                            edge_data_file.write(
+                                (char*)&(original_edge_data_vector[0]),
+                                original_edge_data_vector.size()*sizeof(OriginalEdgeData)
+                            );
+                            original_edge_data_vector.clear();
                         }
-                        ++numberOfOriginalEdges;
-                        ++nodeBasedEdgeCounter;
-                        edgeBasedEdges.push_back(newEdge);
+
+                        m_edge_based_edge_list.push_back(
+                            EdgeBasedEdge(
+                                edge_data1.edgeBasedNodeID,
+                                edge_data2.edgeBasedNodeID,
+                                m_edge_based_edge_list.size(),
+                                distance,
+                                true,
+                                false
+                            )
+                        );
                     } else {
-                        ++numberOfSkippedTurns;
+                        ++skipped_turns_counter;
                     }
                 }
             }
         }
         p.printIncrement();
     }
-    numberOfOriginalEdges += originalEdgeData.size();
-    originalEdgeDataOutFile.write((char*)&(originalEdgeData[0]), originalEdgeData.size()*sizeof(OriginalEdgeData));
-    originalEdgeDataOutFile.seekp(std::ios::beg);
-    originalEdgeDataOutFile.write((char*)&numberOfOriginalEdges, sizeof(unsigned));
-    originalEdgeDataOutFile.close();
+    edge_data_file.write(
+        (char*)&(original_edge_data_vector[0]),
+        original_edge_data_vector.size()*sizeof(OriginalEdgeData)
+    );
+    edge_data_file.seekp(std::ios::beg);
+    edge_data_file.write(
+        (char*)&original_edges_counter,
+        sizeof(unsigned)
+    );
+    edge_data_file.close();
 
-//    INFO("Sorting edge-based Nodes");
-//    std::sort(edgeBasedNodes.begin(), edgeBasedNodes.end());
-//    INFO("Removing duplicate nodes (if any)");
-//    edgeBasedNodes.erase( std::unique(edgeBasedNodes.begin(), edgeBasedNodes.end()), edgeBasedNodes.end() );
-//    INFO("Applying vector self-swap trick to free up memory");
-//    INFO("size: " << edgeBasedNodes.size() << ", cap: " << edgeBasedNodes.capacity());
-//    std::vector<EdgeBasedNode>(edgeBasedNodes).swap(edgeBasedNodes);
-//    INFO("size: " << edgeBasedNodes.size() << ", cap: " << edgeBasedNodes.capacity());
-    INFO("Node-based graph contains " << nodeBasedEdgeCounter     << " edges");
-//    INFO("Edge-based graph contains " << edgeBasedEdges.size()    << " edges, blowup is " << 2*((double)edgeBasedEdges.size()/(double)nodeBasedEdgeCounter));
-    INFO("Edge-based graph skipped "  << numberOfSkippedTurns     << " turns, defined by " << numberOfTurnRestrictions << " restrictions.");
-    INFO("Generated " << edgeBasedNodes.size() << " edge based nodes");
+    SimpleLogger().Write() <<
+        "Generated " << m_edge_based_node_list.size() << " edge based nodes";
+    SimpleLogger().Write() <<
+        "Node-based graph contains " << node_based_edge_counter << " edges";
+    SimpleLogger().Write() <<
+        "Edge-expanded graph ...";
+    SimpleLogger().Write() <<
+        "  contains " << m_edge_based_edge_list.size() << " edges";
+    SimpleLogger().Write() <<
+        "  skips "  << skipped_turns_counter << " turns, "
+        "defined by " << m_turn_restrictions_count << " restrictions";
 }
 
-TurnInstruction EdgeBasedGraphFactory::AnalyzeTurn(const NodeID u, const NodeID v, const NodeID w) const {
+int EdgeBasedGraphFactory::GetTurnPenalty(
+    const NodeID u,
+    const NodeID v,
+    const NodeID w,
+    lua_State *lua_state
+) const {
+    const double angle = GetAngleBetweenThreeFixedPointCoordinates (
+        m_node_info_list[u],
+        m_node_info_list[v],
+        m_node_info_list[w]
+    );
+
+    if( speed_profile.has_turn_penalty_function ) {
+        try {
+            //call lua profile to compute turn penalty
+            return luabind::call_function<int>(
+                lua_state,
+                "turn_function",
+                180.-angle
+            );
+        } catch (const luabind::error &er) {
+            SimpleLogger().Write(logWARNING) << er.what();
+        }
+    }
+    return 0;
+}
+
+TurnInstruction EdgeBasedGraphFactory::AnalyzeTurn(
+    const NodeID u,
+    const NodeID v,
+    const NodeID w
+) const {
     if(u == w) {
         return TurnInstructions.UTurn;
     }
 
-    _NodeBasedDynamicGraph::EdgeIterator edge1 = _nodeBasedGraph->FindEdge(u, v);
-    _NodeBasedDynamicGraph::EdgeIterator edge2 = _nodeBasedGraph->FindEdge(v, w);
+    EdgeIterator edge1 = m_node_based_graph->FindEdge(u, v);
+    EdgeIterator edge2 = m_node_based_graph->FindEdge(v, w);
 
-    _NodeBasedDynamicGraph::EdgeData & data1 = _nodeBasedGraph->GetEdgeData(edge1);
-    _NodeBasedDynamicGraph::EdgeData & data2 = _nodeBasedGraph->GetEdgeData(edge2);
+    EdgeData & data1 = m_node_based_graph->GetEdgeData(edge1);
+    EdgeData & data2 = m_node_based_graph->GetEdgeData(edge2);
+
+    if(!data1.contraFlow && data2.contraFlow) {
+    	return TurnInstructions.EnterAgainstAllowedDirection;
+    }
+    if(data1.contraFlow && !data2.contraFlow) {
+    	return TurnInstructions.LeaveAgainstAllowedDirection;
+    }
 
     //roundabouts need to be handled explicitely
     if(data1.roundabout && data2.roundabout) {
         //Is a turn possible? If yes, we stay on the roundabout!
-        if( 1 == (_nodeBasedGraph->EndEdges(v) - _nodeBasedGraph->BeginEdges(v)) ) {
+        if( 1 == m_node_based_graph->GetOutDegree(v) ) {
             //No turn possible.
             return TurnInstructions.NoTurn;
-        } else {
-            return TurnInstructions.StayOnRoundAbout;
         }
+        return TurnInstructions.StayOnRoundAbout;
     }
     //Does turn start or end on roundabout?
     if(data1.roundabout || data2.roundabout) {
         //We are entering the roundabout
-        if( (!data1.roundabout) && data2.roundabout)
+        if( (!data1.roundabout) && data2.roundabout) {
             return TurnInstructions.EnterRoundAbout;
+        }
         //We are leaving the roundabout
-        else if(data1.roundabout && (!data2.roundabout) )
+        if(data1.roundabout && (!data2.roundabout) ) {
             return TurnInstructions.LeaveRoundAbout;
+        }
     }
 
-    //If street names stay the same and if we are certain that it is not a roundabout, we skip it.
-    if( (data1.nameID == data2.nameID) && (0 != data1.nameID))
-        return TurnInstructions.NoTurn;
-    if( (data1.nameID == data2.nameID) && (0 == data1.nameID) && (_nodeBasedGraph->GetOutDegree(v) <= 2) )
-        return TurnInstructions.NoTurn;
+    //If street names stay the same and if we are certain that it is not a
+    //a segment of a roundabout, we skip it.
+    if( data1.nameID == data2.nameID ) {
+        //TODO: Here we should also do a small graph exploration to check for
+        //      more complex situations
+        if( 0 != data1.nameID ) {
+            return TurnInstructions.NoTurn;
+        } else if (m_node_based_graph->GetOutDegree(v) <= 2) {
+            return TurnInstructions.NoTurn;
+        }
+    }
+
+    const double angle = GetAngleBetweenThreeFixedPointCoordinates (
+        m_node_info_list[u],
+        m_node_info_list[v],
+        m_node_info_list[w]
+    );
 
-    double angle = GetAngleBetweenTwoEdges(inputNodeInfoList[u], inputNodeInfoList[v], inputNodeInfoList[w]);
     return TurnInstructions.GetTurnDirectionOfInstruction(angle);
 }
 
 unsigned EdgeBasedGraphFactory::GetNumberOfNodes() const {
-    return _nodeBasedGraph->GetNumberOfEdges();
-}
-
-/* Get angle of line segment (A,C)->(C,B), atan2 magic, formerly cosine theorem*/
-template<class CoordinateT>
-double EdgeBasedGraphFactory::GetAngleBetweenTwoEdges(const CoordinateT& A, const CoordinateT& C, const CoordinateT& B) const {
-    const int v1x = A.lon - C.lon;
-    const int v1y = A.lat - C.lat;
-    const int v2x = B.lon - C.lon;
-    const int v2y = B.lat - C.lat;
-
-    double angle = (atan2((double)v2y,v2x) - atan2((double)v1y,v1x) )*180/M_PI;
-    while(angle < 0)
-        angle += 360;
-    return angle;
+    return m_node_based_graph->GetNumberOfEdges();
 }

Contractor/EdgeBasedGraphFactory.h

@@ -1,66 +1,115 @@
 /*
- open source routing machine
- Copyright (C) Dennis Luxen, others 2010
 
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU AFFERO General Public License as published by
- the Free Software Foundation; either version 3 of the License, or
- any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
- You should have received a copy of the GNU Affero General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 class constructs the edge base representation of a graph from a given node based edge list
- */
+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.
+
+*/
+
+//  This class constructs the edge-expanded routing graph
 
 #ifndef EDGEBASEDGRAPHFACTORY_H_
 #define EDGEBASEDGRAPHFACTORY_H_
 
-#include <algorithm>
-#include <queue>
-#include <vector>
-#include <stxxl.h>
-#include <cstdlib>
-
-#include <boost/foreach.hpp>
-#include <boost/lexical_cast.hpp>
-#include <boost/make_shared.hpp>
-#include <boost/shared_ptr.hpp>
-
-
 #include "../typedefs.h"
 #include "../DataStructures/DeallocatingVector.h"
 #include "../DataStructures/DynamicGraph.h"
+#include "../DataStructures/EdgeBasedNode.h"
 #include "../Extractor/ExtractorStructs.h"
 #include "../DataStructures/HashTable.h"
 #include "../DataStructures/ImportEdge.h"
 #include "../DataStructures/QueryEdge.h"
 #include "../DataStructures/Percent.h"
 #include "../DataStructures/TurnInstructions.h"
-#include "../Util/BaseConfiguration.h"
+#include "../Util/LuaUtil.h"
+#include "../Util/SimpleLogger.h"
+
+#include <boost/foreach.hpp>
+#include <boost/make_shared.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/unordered_map.hpp>
+#include <boost/unordered_set.hpp>
+
+#include <algorithm>
+#include <fstream>
+#include <queue>
+#include <vector>
+
+class EdgeBasedGraphFactory : boost::noncopyable {
+public:
+    struct SpeedProfileProperties{
+        SpeedProfileProperties() :
+            trafficSignalPenalty(0),
+            uTurnPenalty(0),
+            has_turn_penalty_function(false)
+        { }
+
+        int trafficSignalPenalty;
+        int uTurnPenalty;
+        bool has_turn_penalty_function;
+    } speed_profile;
+
+    explicit EdgeBasedGraphFactory(
+        int number_of_nodes,
+        std::vector<ImportEdge> & input_edge_list,
+        std::vector<NodeID> & barrier_node_list,
+        std::vector<NodeID> & traffic_light_node_list,
+        std::vector<TurnRestriction> & input_restrictions_list,
+        std::vector<NodeInfo> & m_node_info_list,
+        SpeedProfileProperties speed_profile
+    );
+
+    void Run(const char * originalEdgeDataFilename, lua_State *myLuaState);
+    void GetEdgeBasedEdges( DeallocatingVector< EdgeBasedEdge >& edges );
+    void GetEdgeBasedNodes( std::vector< EdgeBasedNode> & nodes);
+    void GetOriginalEdgeData( std::vector<OriginalEdgeData> & originalEdgeData);
+    TurnInstruction AnalyzeTurn(
+        const NodeID u,
+        const NodeID v,
+        const NodeID w
+    ) const;
+    int GetTurnPenalty(
+        const NodeID u,
+        const NodeID v,
+        const NodeID w,
+        lua_State *myLuaState
+    ) const;
+
+    unsigned GetNumberOfNodes() const;
 
-class EdgeBasedGraphFactory {
 private:
-    struct _NodeBasedEdgeData {
+    struct NodeBasedEdgeData {
         int distance;
         unsigned edgeBasedNodeID;
-        unsigned nameID:31;
+        unsigned nameID;
+        short type;
+        bool isAccessRestricted:1;
         bool shortcut:1;
         bool forward:1;
         bool backward:1;
         bool roundabout:1;
         bool ignoreInGrid:1;
-        short type;
-        bool isAccessRestricted;
+        bool contraFlow:1;
     };
 
     struct _EdgeBasedEdgeData {
@@ -72,74 +121,46 @@ private:
         TurnInstruction turnInstruction;
     };
 
-    typedef DynamicGraph< _NodeBasedEdgeData > _NodeBasedDynamicGraph;
-    typedef _NodeBasedDynamicGraph::InputEdge _NodeBasedEdge;
-    std::vector<NodeInfo>               inputNodeInfoList;
-    unsigned numberOfTurnRestrictions;
-public:
-    struct EdgeBasedNode {
-        bool operator<(const EdgeBasedNode & other) const {
-            return other.id < id;
-        }
-        bool operator==(const EdgeBasedNode & other) const {
-            return id == other.id;
-        }
-        NodeID id;
-        int lat1;
-        int lat2;
-        int lon1;
-        int lon2:31;
-        bool belongsToTinyComponent:1;
-        NodeID nameID;
-        unsigned weight:31;
-        bool ignoreInGrid:1;
-    };
+    unsigned m_turn_restrictions_count;
 
-
-    struct SpeedProfileProperties{
-        SpeedProfileProperties()  : trafficSignalPenalty(0), uTurnPenalty(0) {}
-        int trafficSignalPenalty;
-        int uTurnPenalty;
-    } speedProfile;
-private:
-    boost::shared_ptr<_NodeBasedDynamicGraph>   _nodeBasedGraph;
-    boost::unordered_map<NodeID, bool>          _barrierNodes;
-    boost::unordered_map<NodeID, bool>          _trafficLights;
-
-    typedef std::pair<NodeID, NodeID> RestrictionSource;
-    typedef std::pair<NodeID, bool>   RestrictionTarget;
-    typedef std::vector<RestrictionTarget> EmanatingRestrictionsVector;
+    typedef DynamicGraph<NodeBasedEdgeData>     NodeBasedDynamicGraph;
+    typedef NodeBasedDynamicGraph::InputEdge    NodeBasedEdge;
+    typedef NodeBasedDynamicGraph::NodeIterator NodeIterator;
+    typedef NodeBasedDynamicGraph::EdgeIterator EdgeIterator;
+    typedef NodeBasedDynamicGraph::EdgeData     EdgeData;
+    typedef std::pair<NodeID, NodeID>           RestrictionSource;
+    typedef std::pair<NodeID, bool>             RestrictionTarget;
+    typedef std::vector<RestrictionTarget>      EmanatingRestrictionsVector;
     typedef boost::unordered_map<RestrictionSource, unsigned > RestrictionMap;
-    std::vector<EmanatingRestrictionsVector> _restrictionBucketVector;
-    RestrictionMap _restrictionMap;
+
+    std::vector<NodeInfo>                       m_node_info_list;
+    std::vector<EmanatingRestrictionsVector>    m_restriction_bucket_list;
+    std::vector<EdgeBasedNode>                  m_edge_based_node_list;
+    DeallocatingVector<EdgeBasedEdge>           m_edge_based_edge_list;
+
+    boost::shared_ptr<NodeBasedDynamicGraph>    m_node_based_graph;
+    boost::unordered_set<NodeID>                m_barrier_nodes;
+    boost::unordered_set<NodeID>                m_traffic_lights;
+
+    RestrictionMap                              m_restriction_map;
 
 
-    DeallocatingVector<EdgeBasedEdge>   edgeBasedEdges;
-    DeallocatingVector<EdgeBasedNode>   edgeBasedNodes;
-    std::vector<OriginalEdgeData>       originalEdgeData;
+    NodeID CheckForEmanatingIsOnlyTurn(
+        const NodeID u,
+        const NodeID v
+    ) const;
+
+    bool CheckIfTurnIsRestricted(
+        const NodeID u,
+        const NodeID v,
+        const NodeID w
+    ) const;
 
-    NodeID CheckForEmanatingIsOnlyTurn(const NodeID u, const NodeID v) const;
-    bool CheckIfTurnIsRestricted(const NodeID u, const NodeID v, const NodeID w) const;
     void InsertEdgeBasedNode(
-            _NodeBasedDynamicGraph::EdgeIterator e1,
-            _NodeBasedDynamicGraph::NodeIterator u,
-            _NodeBasedDynamicGraph::NodeIterator v,
+            NodeBasedDynamicGraph::EdgeIterator e1,
+            NodeBasedDynamicGraph::NodeIterator u,
+            NodeBasedDynamicGraph::NodeIterator v,
             bool belongsToTinyComponent);
-    template<class CoordinateT>
-    double GetAngleBetweenTwoEdges(const CoordinateT& A, const CoordinateT& C, const CoordinateT& B) const;
-//    SRTMLookup srtmLookup;
-
-
-public:
-    template< class InputEdgeT >
-    explicit EdgeBasedGraphFactory(int nodes, std::vector<InputEdgeT> & inputEdges, std::vector<NodeID> & _bollardNodes, std::vector<NodeID> & trafficLights, std::vector<_Restriction> & inputRestrictions, std::vector<NodeInfo> & nI, SpeedProfileProperties speedProfile);
-
-    void Run(const char * originalEdgeDataFilename);
-    void GetEdgeBasedEdges( DeallocatingVector< EdgeBasedEdge >& edges );
-    void GetEdgeBasedNodes( DeallocatingVector< EdgeBasedNode> & nodes);
-    void GetOriginalEdgeData( std::vector< OriginalEdgeData> & originalEdgeData);
-    TurnInstruction AnalyzeTurn(const NodeID u, const NodeID v, const NodeID w) const;
-    unsigned GetNumberOfNodes() const;
 };
 
 #endif /* EDGEBASEDGRAPHFACTORY_H_ */

Contractor/TemporaryStorage.cpp

@@ -1,33 +1,34 @@
 /*
- open source routing machine
- Copyright (C) Dennis Luxen, others 2010
 
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU AFFERO General Public License as published by
- the Free Software Foundation; either version 3 of the License, or
- any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
- You should have received a copy of the GNU Affero General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- or see http://www.gnu.org/licenses/agpl.txt.
- */
+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.
 
-#include <boost/foreach.hpp>
+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.
+
+*/
 
 #include "TemporaryStorage.h"
 
 TemporaryStorage::TemporaryStorage() {
-    try {
-        tempDirectory = boost::filesystem::temp_directory_path();
-    } catch(boost::filesystem::filesystem_error & e) {
-        ERR("could not retrieve location of temporary path: " << e.what());
-    }
+    tempDirectory = boost::filesystem::temp_directory_path();
 }
 
 TemporaryStorage & TemporaryStorage::GetInstance(){
@@ -41,12 +42,8 @@ TemporaryStorage::~TemporaryStorage() {
 
 void TemporaryStorage::removeAll() {
     boost::mutex::scoped_lock lock(mutex);
-    try {
-        for(unsigned slotID = 0; slotID < vectorOfStreamDatas.size(); ++slotID)
-            deallocateSlot(slotID);
-
-    } catch(boost::filesystem::filesystem_error & e) {
-        ERR("could not retrieve location of temporary path: " << e.what());
+    for(unsigned slot_id = 0; slot_id < vectorOfStreamDatas.size(); ++slot_id) {
+        deallocateSlot(slot_id);
     }
     vectorOfStreamDatas.clear();
 }
@@ -55,7 +52,7 @@ int TemporaryStorage::allocateSlot() {
     boost::mutex::scoped_lock lock(mutex);
     try {
         vectorOfStreamDatas.push_back(StreamData());
-        //INFO("created new temporary file: " << vectorOfStreamDatas.back().pathToTemporaryFile);
+        //SimpleLogger().Write() << "created new temporary file: " << vectorOfStreamDatas.back().pathToTemporaryFile;
     } catch(boost::filesystem::filesystem_error & e) {
         abort(e);
     }
@@ -66,13 +63,13 @@ void TemporaryStorage::deallocateSlot(int slotID) {
     try {
         StreamData & data = vectorOfStreamDatas[slotID];
         boost::mutex::scoped_lock lock(*data.readWriteMutex);
-                if(!boost::filesystem::exists(data.pathToTemporaryFile)) {
+        if(!boost::filesystem::exists(data.pathToTemporaryFile)) {
             return;
         }
-        if(data.streamToTemporaryFile->is_open())
+        if(data.streamToTemporaryFile->is_open()) {
             data.streamToTemporaryFile->close();
+        }
 
-        //INFO("deallocating slot " << slotID << " and its file: " << data.pathToTemporaryFile);
         boost::filesystem::remove(data.pathToTemporaryFile);
     } catch(boost::filesystem::filesystem_error & e) {
         abort(e);
@@ -83,8 +80,10 @@ void TemporaryStorage::writeToSlot(int slotID, char * pointer, std::streamsize s
     try {
         StreamData & data = vectorOfStreamDatas[slotID];
         boost::mutex::scoped_lock lock(*data.readWriteMutex);
-        if(!data.writeMode)
-            ERR("Writing after first read is not allowed");
+        BOOST_ASSERT_MSG(
+            data.writeMode,
+            "Writing after first read is not allowed"
+        );
         data.streamToTemporaryFile->write(pointer, size);
     } catch(boost::filesystem::filesystem_error & e) {
         abort(e);
@@ -123,13 +122,11 @@ boost::filesystem::fstream::pos_type TemporaryStorage::tell(int slotID) {
     } catch(boost::filesystem::filesystem_error & e) {
         abort(e);
    }
-//    INFO("telling position: " << position);
     return position;
 }
 
 void TemporaryStorage::abort(boost::filesystem::filesystem_error& ) {
     removeAll();
-//    ERR("I/O Error occured: " << e.what());
 }
 
 void TemporaryStorage::seek(int slotID, boost::filesystem::fstream::pos_type position) {
@@ -137,7 +134,6 @@ void TemporaryStorage::seek(int slotID, boost::filesystem::fstream::pos_type pos
         StreamData & data = vectorOfStreamDatas[slotID];
         boost::mutex::scoped_lock lock(*data.readWriteMutex);
         data.streamToTemporaryFile->seekg(position);
-//        INFO("seeking to position: " << position);
     } catch(boost::filesystem::filesystem_error & e) {
         abort(e);
     }

Contractor/TemporaryStorage.h

@@ -1,22 +1,29 @@
 /*
- open source routing machine
- Copyright (C) Dennis Luxen, others 2010
 
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU AFFERO General Public License as published by
- the Free Software Foundation; either version 3 of the License, or
- any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
- You should have received a copy of the GNU Affero General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 TEMPORARYSTORAGE_H_
 #define TEMPORARYSTORAGE_H_
@@ -24,17 +31,21 @@
 #include <vector>
 #include <fstream>
 
+#include <boost/assert.hpp>
+#include <boost/foreach.hpp>
 #include <boost/filesystem.hpp>
 #include <boost/filesystem/fstream.hpp>
 #include <boost/shared_ptr.hpp>
 #include <boost/thread/mutex.hpp>
 
+#include "../Util/OSRMException.h"
+#include "../Util/SimpleLogger.h"
 #include "../typedefs.h"
 
 //This is one big workaround for latest boost renaming woes.
 
-#ifndef BOOST_FILESYSTEM_VERSION
-#warning Boost Installation with Filesystem3 (>=1.44) is required, activating workaround
+#if BOOST_FILESYSTEM_VERSION < 3
+#warning Boost Installation with Filesystem3 missing, activating workaround
 #include <cstdio>
 namespace boost {
 namespace filesystem {
@@ -54,8 +65,9 @@ inline path unique_path(const path&) {
 
 #endif
 
+#ifndef BOOST_FILESYSTEM_VERSION
 #define BOOST_FILESYSTEM_VERSION 3
-
+#endif
 /**
  * This class implements a singleton file storage for temporary data.
  * temporary slots can be accessed by other objects through an int
@@ -89,8 +101,6 @@ private:
     }
     void abort(boost::filesystem::filesystem_error& e);
 
-    ;
-
     struct StreamData {
         bool writeMode;
         boost::filesystem::path pathToTemporaryFile;
@@ -102,8 +112,9 @@ private:
             streamToTemporaryFile(new boost::filesystem::fstream(pathToTemporaryFile, std::ios::in | std::ios::out | std::ios::trunc | std::ios::binary)),
             readWriteMutex(new boost::mutex)
         {
-            if(streamToTemporaryFile->fail())
-                ERR("Aborting, because temporary file at " << pathToTemporaryFile << " could not be created");
+            if(streamToTemporaryFile->fail()) {
+                throw OSRMException("temporary file could not be created");
+            }
         }
     };
     //vector of file streams that is used to store temporary data

DataStructures/BinaryHeap.h

@@ -1,35 +1,44 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 BINARYHEAP_H_INCLUDED
 #define BINARYHEAP_H_INCLUDED
 
 //Not compatible with non contiguous node ids
 
-#include <cassert>
-#include <limits>
-#include <vector>
-#include <algorithm>
-#include <map>
 #include <boost/unordered_map.hpp>
 
+#include <boost/assert.hpp>
+
+#include <algorithm>
+#include <limits>
+#include <map>
+#include <vector>
+
 template< typename NodeID, typename Key >
 class ArrayStorage {
 public:
@@ -75,10 +84,13 @@ template< typename NodeID, typename Key >
 class UnorderedMapStorage {
 public:
 
-	UnorderedMapStorage( size_t ) {  }
+	UnorderedMapStorage( size_t ) {
+		//hash table gets 1000 Buckets
+		nodes.rehash(1000);
+	}
 
-    Key &operator[]( NodeID node ) {
-        return nodes[node];
+    Key &operator[]( const NodeID node ) {
+    	return nodes[node];
     }
 
     void Clear() {
@@ -120,6 +132,10 @@ public:
         return static_cast<Key>( heap.size() - 1 );
     }
 
+    bool Empty() const {
+        return 0 == Size();
+    }
+
     void Insert( NodeID node, Weight weight, const Data &data ) {
         HeapElement element;
         element.index = static_cast<NodeID>(insertedNodes.size());
@@ -142,13 +158,13 @@ public:
         return insertedNodes[index].weight;
     }
 
-    bool WasRemoved( NodeID node ) {
-        assert( WasInserted( node ) );
+    bool WasRemoved( const NodeID node ) {
+        BOOST_ASSERT( WasInserted( node ) );
         const Key index = nodeIndex[node];
         return insertedNodes[index].key == 0;
     }
 
-    bool WasInserted( NodeID node ) {
+    bool WasInserted( const NodeID node ) {
         const Key index = nodeIndex[node];
         if ( index >= static_cast<Key> (insertedNodes.size()) )
             return false;
@@ -156,12 +172,12 @@ public:
     }
 
     NodeID Min() const {
-        assert( heap.size() > 1 );
+        BOOST_ASSERT( heap.size() > 1 );
         return insertedNodes[heap[1].index].node;
     }
 
     NodeID DeleteMin() {
-        assert( heap.size() > 1 );
+        BOOST_ASSERT( heap.size() > 1 );
         const Key removedIndex = heap[1].index;
         heap[1] = heap[heap.size()-1];
         heap.pop_back();
@@ -180,10 +196,10 @@ public:
     }
 
     void DecreaseKey( NodeID node, Weight weight ) {
-        assert( UINT_MAX != node );
-        const Key index = nodeIndex[node];
-        Key key = insertedNodes[index].key;
-        assert ( key >= 0 );
+        BOOST_ASSERT( UINT_MAX != node );
+        const Key & index = nodeIndex[node];
+        Key & key = insertedNodes[index].key;
+        BOOST_ASSERT ( key >= 0 );
 
         insertedNodes[index].weight = weight;
         heap[key].weight = weight;
@@ -241,7 +257,7 @@ private:
         const Weight weight = heap[key].weight;
         Key nextKey = key >> 1;
         while ( heap[nextKey].weight > weight ) {
-            assert( nextKey != 0 );
+            BOOST_ASSERT( nextKey != 0 );
             heap[key] = heap[nextKey];
             insertedNodes[heap[key].index].key = key;
             key = nextKey;
@@ -255,7 +271,7 @@ private:
     void CheckHeap() {
 #ifndef NDEBUG
         for ( Key i = 2; i < (Key) heap.size(); ++i ) {
-            assert( heap[i].weight >= heap[i >> 1].weight );
+            BOOST_ASSERT( heap[i].weight >= heap[i >> 1].weight );
         }
 #endif
     }

DataStructures/ConcurrentQueue.h

@@ -1,25 +1,34 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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.
 
-#ifndef CONCURRENTQUEUE_H_INCLUDED
-#define CONCURRENTQUEUE_H_INCLUDED
+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 CONCURRENTQUEUE_H_
+#define CONCURRENTQUEUE_H_
+
+#include "../typedefs.h"
 
 #include <boost/bind.hpp>
 #include <boost/circular_buffer.hpp>
@@ -27,57 +36,64 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
 
-#include "../typedefs.h"
-
 template<typename Data>
 class ConcurrentQueue {
 
-    typedef typename boost::circular_buffer<Data>::size_type size_t;
-
 public:
-    ConcurrentQueue(const size_t max_size) : internal_queue(max_size) { }
+    ConcurrentQueue(const size_t max_size) : m_internal_queue(max_size) { }
 
-    inline void push(Data const& data) {
+    inline void push(const Data & data) {
         boost::mutex::scoped_lock lock(m_mutex);
-        m_not_full.wait(lock, boost::bind(&ConcurrentQueue<Data>::is_not_full, this));
-        internal_queue.push_back(data);
+        m_not_full.wait(
+            lock,
+            boost::bind(&ConcurrentQueue<Data>::is_not_full, this)
+        );
+        m_internal_queue.push_back(data);
         lock.unlock();
         m_not_empty.notify_one();
     }
 
     inline bool empty() const {
-        return internal_queue.empty();
+        return m_internal_queue.empty();
     }
 
-    inline void wait_and_pop(Data& popped_value) {
+    inline void wait_and_pop(Data & popped_value) {
         boost::mutex::scoped_lock lock(m_mutex);
-        m_not_empty.wait(lock, boost::bind(&ConcurrentQueue<Data>::is_not_empty, this));
-        popped_value=internal_queue.front();
-        internal_queue.pop_front();
+        m_not_empty.wait(
+            lock,
+            boost::bind(&ConcurrentQueue<Data>::is_not_empty, this)
+        );
+        popped_value = m_internal_queue.front();
+        m_internal_queue.pop_front();
         lock.unlock();
         m_not_full.notify_one();
     }
 
     inline bool try_pop(Data& popped_value) {
         boost::mutex::scoped_lock lock(m_mutex);
-        if(internal_queue.empty()) {
+        if(m_internal_queue.empty()) {
             return false;
         }
-        popped_value=internal_queue.front();
-        internal_queue.pop_front();
+        popped_value=m_internal_queue.front();
+        m_internal_queue.pop_front();
         lock.unlock();
         m_not_full.notify_one();
         return true;
     }
 
 private:
-    boost::circular_buffer<Data> internal_queue;
-    boost::mutex m_mutex;
-    boost::condition m_not_empty;
-    boost::condition m_not_full;
+    inline bool is_not_empty() const {
+        return !m_internal_queue.empty();
+    }
 
-    inline bool is_not_empty() const { return internal_queue.size() > 0; }
-    inline bool is_not_full() const { return internal_queue.size() < internal_queue.capacity(); }
+    inline bool is_not_full() const {
+        return m_internal_queue.size() < m_internal_queue.capacity();
+    }
+
+    boost::circular_buffer<Data>    m_internal_queue;
+    boost::mutex                    m_mutex;
+    boost::condition                m_not_empty;
+    boost::condition                m_not_full;
 };
 
-#endif //#ifndef CONCURRENTQUEUE_H_INCLUDED
+#endif /* CONCURRENTQUEUE_H_ */

DataStructures/Coordinate.h

@@ -1,34 +1,50 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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.
 
-#ifndef COORDINATE_H_
-#define COORDINATE_H_
+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 FIXED_POINT_COORDINATE_H_
+#define FIXED_POINT_COORDINATE_H_
+
+#include "../DataStructures/MercatorUtil.h"
+#include "../Util/StringUtil.h"
+
+#include <boost/assert.hpp>
+#include <cmath>
 #include <climits>
+
 #include <iostream>
 
-struct _Coordinate {
+static const double COORDINATE_PRECISION = 1000000.;
+
+struct FixedPointCoordinate {
     int lat;
     int lon;
-    _Coordinate () : lat(INT_MIN), lon(INT_MIN) {}
-    _Coordinate (int t, int n) : lat(t) , lon(n) {}
+    FixedPointCoordinate () : lat(INT_MIN), lon(INT_MIN) {}
+    explicit FixedPointCoordinate (int lat, int lon) : lat(lat) , lon(lon) {}
+
     void Reset() {
         lat = INT_MIN;
         lon = INT_MIN;
@@ -37,31 +53,36 @@ struct _Coordinate {
         return (INT_MIN != lat) && (INT_MIN != lon);
     }
     inline bool isValid() const {
-        if(lat > 90*100000 || lat < -90*100000 || lon > 180*100000 || lon <-180*100000) {
+        if(
+            lat >   90*COORDINATE_PRECISION ||
+            lat <  -90*COORDINATE_PRECISION ||
+            lon >  180*COORDINATE_PRECISION ||
+            lon < -180*COORDINATE_PRECISION
+        ) {
             return false;
         }
         return true;
     }
-    bool operator==(const _Coordinate & other) const {
+    bool operator==(const FixedPointCoordinate & other) const {
         return lat == other.lat && lon == other.lon;
     }
 };
 
-inline std::ostream & operator<<(std::ostream & out, const _Coordinate & c){
+inline std::ostream & operator<<(std::ostream & out, const FixedPointCoordinate & c){
     out << "(" << c.lat << "," << c.lon << ")";
     return out;
 }
 
 inline double ApproximateDistance( const int lat1, const int lon1, const int lat2, const int lon2 ) {
-    assert(lat1 != INT_MIN);
-    assert(lon1 != INT_MIN);
-    assert(lat2 != INT_MIN);
-    assert(lon2 != INT_MIN);
+    BOOST_ASSERT(lat1 != INT_MIN);
+    BOOST_ASSERT(lon1 != INT_MIN);
+    BOOST_ASSERT(lat2 != INT_MIN);
+    BOOST_ASSERT(lon2 != INT_MIN);
     double RAD = 0.017453292519943295769236907684886;
-    double lt1 = lat1/100000.;
-    double ln1 = lon1/100000.;
-    double lt2 = lat2/100000.;
-    double ln2 = lon2/100000.;
+    double lt1 = lat1/COORDINATE_PRECISION;
+    double ln1 = lon1/COORDINATE_PRECISION;
+    double lt2 = lat2/COORDINATE_PRECISION;
+    double ln2 = lon2/COORDINATE_PRECISION;
     double dlat1=lt1*(RAD);
 
     double dlong1=ln1*(RAD);
@@ -80,20 +101,20 @@ inline double ApproximateDistance( const int lat1, const int lon1, const int lat
     return distance;
 }
 
-inline double ApproximateDistance(const _Coordinate &c1, const _Coordinate &c2) {
+inline double ApproximateDistance(const FixedPointCoordinate &c1, const FixedPointCoordinate &c2) {
     return ApproximateDistance( c1.lat, c1.lon, c2.lat, c2.lon );
 }
 
-inline double ApproximateDistanceByEuclid(const _Coordinate &c1, const _Coordinate &c2) {
-    assert(c1.lat != INT_MIN);
-    assert(c1.lon != INT_MIN);
-    assert(c2.lat != INT_MIN);
-    assert(c2.lon != INT_MIN);
+inline double ApproximateEuclideanDistance(const FixedPointCoordinate &c1, const FixedPointCoordinate &c2) {
+    BOOST_ASSERT(c1.lat != INT_MIN);
+    BOOST_ASSERT(c1.lon != INT_MIN);
+    BOOST_ASSERT(c2.lat != INT_MIN);
+    BOOST_ASSERT(c2.lon != INT_MIN);
     const double RAD = 0.017453292519943295769236907684886;
-    const double lat1 = (c1.lat/100000.)*RAD;
-    const double lon1 = (c1.lon/100000.)*RAD;
-    const double lat2 = (c2.lat/100000.)*RAD;
-    const double lon2 = (c2.lon/100000.)*RAD;
+    const double lat1 = (c1.lat/COORDINATE_PRECISION)*RAD;
+    const double lon1 = (c1.lon/COORDINATE_PRECISION)*RAD;
+    const double lat2 = (c2.lat/COORDINATE_PRECISION)*RAD;
+    const double lon2 = (c2.lon/COORDINATE_PRECISION)*RAD;
 
     const double x = (lon2-lon1) * cos((lat1+lat2)/2.);
     const double y = (lat2-lat1);
@@ -102,5 +123,48 @@ inline double ApproximateDistanceByEuclid(const _Coordinate &c1, const _Coordina
     return d;
 }
 
+static inline void convertInternalLatLonToString(const int value, std::string & output) {
+    char buffer[100];
+    buffer[11] = 0; // zero termination
+    char* string = printInt< 11, 6 >( buffer, value );
+    output = string;
+}
 
-#endif /* COORDINATE_H_ */
+static inline void convertInternalCoordinateToString(const FixedPointCoordinate & coord, std::string & output) {
+    std::string tmp;
+    convertInternalLatLonToString(coord.lon, tmp);
+    output = tmp;
+    output += ",";
+    convertInternalLatLonToString(coord.lat, tmp);
+    output += tmp;
+    output += " ";
+}
+static inline void convertInternalReversedCoordinateToString(const FixedPointCoordinate & coord, std::string & output) {
+    std::string tmp;
+    convertInternalLatLonToString(coord.lat, tmp);
+    output = tmp;
+    output += ",";
+    convertInternalLatLonToString(coord.lon, tmp);
+    output += tmp;
+    output += " ";
+}
+
+
+/* Get angle of line segment (A,C)->(C,B), atan2 magic, formerly cosine theorem*/
+template<class CoordinateT>
+static inline double GetAngleBetweenThreeFixedPointCoordinates (
+    const CoordinateT & A,
+    const CoordinateT & C,
+    const CoordinateT & B
+) {
+    const double v1x = (A.lon - C.lon)/COORDINATE_PRECISION;
+    const double v1y = lat2y(A.lat/COORDINATE_PRECISION) - lat2y(C.lat/COORDINATE_PRECISION);
+    const double v2x = (B.lon - C.lon)/COORDINATE_PRECISION;
+    const double v2y = lat2y(B.lat/COORDINATE_PRECISION) - lat2y(C.lat/COORDINATE_PRECISION);
+
+    double angle = (atan2(v2y,v2x) - atan2(v1y,v1x) )*180/M_PI;
+    while(angle < 0)
+        angle += 360;
+    return angle;
+}
+#endif /* FIXED_POINT_COORDINATE_H_ */

DataStructures/DeallocatingVector.h

@@ -1,28 +1,35 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 DEALLOCATINGVECTOR_H_
 #define DEALLOCATINGVECTOR_H_
 
-#include <cassert>
-#include <cstdlib>
+#include <boost/assert.hpp>
+#include <cstring>
 #include <vector>
 
 #if __cplusplus > 199711L
@@ -32,7 +39,7 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #endif
 
 
-template<typename ElementT, size_t bucketSizeC = 10485760/sizeof(ElementT), bool DeallocateC = false>
+template<typename ElementT, std::size_t bucketSizeC = 8388608/sizeof(ElementT), bool DeallocateC = false>
 class DeallocatingVectorIterator : public std::iterator<std::random_access_iterator_tag, ElementT> {
 protected:
 
@@ -41,45 +48,32 @@ protected:
         //make constructors explicit, so we do not mix random access and deallocation iterators.
         DeallocatingVectorIteratorState();
     public:
-        explicit DeallocatingVectorIteratorState(const DeallocatingVectorIteratorState &r) : mData(r.mData), mIndex(r.mIndex), mBucketList(r.mBucketList) {}
-        //explicit DeallocatingVectorIteratorState(const ElementT * ptr, const size_t idx, const std::vector<ElementT *> & input_list) : mData(ptr), mIndex(idx), mBucketList(input_list) {}
-        explicit DeallocatingVectorIteratorState(const size_t idx, std::vector<ElementT *> & input_list) : mData(DEALLOCATION_VECTOR_NULL_PTR), mIndex(idx), mBucketList(input_list) {
-            setPointerForIndex();
+        explicit DeallocatingVectorIteratorState(const DeallocatingVectorIteratorState &r) : /*mData(r.mData),*/ mIndex(r.mIndex), mBucketList(r.mBucketList) {}
+        explicit DeallocatingVectorIteratorState(const std::size_t idx, std::vector<ElementT *> & input_list) : /*mData(DEALLOCATION_VECTOR_NULL_PTR),*/ mIndex(idx), mBucketList(input_list) {
         }
-        ElementT * mData;
-        size_t mIndex;
+        std::size_t mIndex;
         std::vector<ElementT *> & mBucketList;
 
-        inline void setPointerForIndex() {
-            if(bucketSizeC*mBucketList.size() <= mIndex) {
-                mData = DEALLOCATION_VECTOR_NULL_PTR;
-                return;
-            }
-            size_t _bucket = mIndex/bucketSizeC;
-            size_t _index = mIndex%bucketSizeC;
-            mData = &(mBucketList[_bucket][_index]);
-
-            if(DeallocateC) {
-                //if we hopped over the border of the previous bucket, then delete that bucket.
-                if(0 == _index && _bucket) {
-                    delete[] mBucketList[_bucket-1];
-                    mBucketList[_bucket-1] = DEALLOCATION_VECTOR_NULL_PTR;
-                }
-            }
-
-        }
         inline bool operator!=(const DeallocatingVectorIteratorState &other) {
-            return (mData != other.mData) || (mIndex != other.mIndex) || (mBucketList != other.mBucketList);
+            return mIndex != other.mIndex;
         }
 
         inline bool operator==(const DeallocatingVectorIteratorState &other) {
-            return (mData == other.mData) && (mIndex == other.mIndex) && (mBucketList == other.mBucketList);
+            return mIndex == other.mIndex;
         }
 
-        inline bool operator<(const DeallocatingVectorIteratorState &other) {
+        bool operator<(const DeallocatingVectorIteratorState &other) const {
             return mIndex < other.mIndex;
         }
 
+        bool operator>(const DeallocatingVectorIteratorState &other) const {
+            return mIndex > other.mIndex;
+        }
+
+        bool operator>=(const DeallocatingVectorIteratorState &other) const {
+            return mIndex >= other.mIndex;
+        }
+
         //This is a hack to make assignment operator possible with reference member
         inline DeallocatingVectorIteratorState& operator= (const DeallocatingVectorIteratorState &a) {
             if (this != &a) {
@@ -104,67 +98,70 @@ public:
     template<typename T2>
     DeallocatingVectorIterator(const DeallocatingVectorIterator<T2> & r) : mState(r.mState) {}
 
-    DeallocatingVectorIterator(size_t idx, std::vector<ElementT *> & input_list) : mState(idx, input_list) {}
-    //DeallocatingVectorIterator(size_t idx, const std::vector<ElementT *> & input_list) : mState(idx, input_list) {}
+    DeallocatingVectorIterator(std::size_t idx, std::vector<ElementT *> & input_list) : mState(idx, input_list) {}
     DeallocatingVectorIterator(const DeallocatingVectorIteratorState & r) : mState(r) {}
 
     template<typename T2>
     DeallocatingVectorIterator& operator=(const DeallocatingVectorIterator<T2> &r) {
-        if(DeallocateC) assert(false);
+        if(DeallocateC) BOOST_ASSERT(false);
         mState = r.mState; return *this;
     }
 
     inline DeallocatingVectorIterator& operator++() { //prefix
-//        if(DeallocateC) assert(false);
-        ++mState.mIndex; mState.setPointerForIndex(); return *this;
+        ++mState.mIndex;
+        return *this;
     }
 
     inline DeallocatingVectorIterator& operator--() { //prefix
-        if(DeallocateC) assert(false);
-        --mState.mIndex; mState.setPointerForIndex(); return *this;
+        if(DeallocateC) BOOST_ASSERT(false);
+        --mState.mIndex;
+        return *this;
     }
 
     inline DeallocatingVectorIterator operator++(int) { //postfix
         DeallocatingVectorIteratorState _myState(mState);
-        mState.mIndex++; mState.setPointerForIndex();
+        mState.mIndex++;
         return DeallocatingVectorIterator(_myState);
     }
-    inline DeallocatingVectorIterator operator --(int) { //postfix
-        if(DeallocateC) assert(false);
+    inline DeallocatingVectorIterator operator--(int) { //postfix
+        if(DeallocateC) BOOST_ASSERT(false);
         DeallocatingVectorIteratorState _myState(mState);
-        mState.mIndex--; mState.setPointerForIndex();
+        mState.mIndex--;
         return DeallocatingVectorIterator(_myState);
     }
 
     inline DeallocatingVectorIterator operator+(const difference_type& n) const {
         DeallocatingVectorIteratorState _myState(mState);
-        _myState.mIndex+=n; _myState.setPointerForIndex();
+        _myState.mIndex+=n;
         return DeallocatingVectorIterator(_myState);
     }
 
-    inline DeallocatingVectorIterator& operator+=(const difference_type& n) const {
+    inline DeallocatingVectorIterator& operator+=(const difference_type& n) {
         mState.mIndex+=n; return *this;
     }
 
     inline DeallocatingVectorIterator operator-(const difference_type& n) const {
-        if(DeallocateC) assert(false);
+        if(DeallocateC) BOOST_ASSERT(false);
         DeallocatingVectorIteratorState _myState(mState);
-        _myState.mIndex-=n; _myState.setPointerForIndex();
+        _myState.mIndex-=n;
         return DeallocatingVectorIterator(_myState);
     }
 
     inline DeallocatingVectorIterator& operator-=(const difference_type &n) const {
-        if(DeallocateC) assert(false);
+        if(DeallocateC) BOOST_ASSERT(false);
         mState.mIndex-=n; return *this;
     }
-    inline reference operator*() const { return *mState.mData; }
-    inline pointer operator->() const { return mState.mData; }
-    inline reference operator[](const difference_type &n) const {
-        if(DeallocateC) assert(false);
-        DeallocatingVectorIteratorState _myState(mState);
-        _myState.mIndex += n;
-        _myState.setPointerForIndex;
-        return _myState.mData;
+
+    inline reference operator*() const {
+        std::size_t _bucket = mState.mIndex/bucketSizeC;
+        std::size_t _index = mState.mIndex%bucketSizeC;
+        return (mState.mBucketList[_bucket][_index]);
+    }
+
+    inline pointer operator->() const {
+        std::size_t _bucket = mState.mIndex/bucketSizeC;
+        std::size_t _index = mState.mIndex%bucketSizeC;
+        return &(mState.mBucketList[_bucket][_index]);
     }
 
     inline bool operator!=(const DeallocatingVectorIterator & other) {
@@ -175,20 +172,28 @@ public:
         return mState == other.mState;
     }
 
-    bool operator<(const DeallocatingVectorIterator & other) {
+    inline bool operator<(const DeallocatingVectorIterator & other) const {
         return mState < other.mState;
     }
 
+    inline bool operator>(const DeallocatingVectorIterator & other) const {
+        return mState > other.mState;
+    }
+
+    inline bool operator>=(const DeallocatingVectorIterator & other) const {
+        return mState >= other.mState;
+    }
+
     difference_type operator-(const DeallocatingVectorIterator & other) {
-        if(DeallocateC) assert(false);
+        if(DeallocateC) BOOST_ASSERT(false);
         return mState.mIndex-other.mState.mIndex;
     }
 };
 
-template<typename ElementT, size_t bucketSizeC = 10485760/sizeof(ElementT) >
+template<typename ElementT, std::size_t bucketSizeC = 8388608/sizeof(ElementT) >
 class DeallocatingVector {
 private:
-    size_t mCurrentSize;
+    std::size_t mCurrentSize;
     std::vector<ElementT *> mBucketList;
 
 public:
@@ -227,21 +232,21 @@ public:
     }
 
     inline void push_back(const ElementT & element) {
-        size_t _capacity = capacity();
+        std::size_t _capacity = capacity();
         if(mCurrentSize == _capacity) {
             mBucketList.push_back(new ElementT[bucketSizeC]);
         }
 
-        size_t _index = size()%bucketSizeC;
+        std::size_t _index = size()%bucketSizeC;
         mBucketList.back()[_index] = element;
         ++mCurrentSize;
     }
 
-    inline void reserve(const size_t) const {
+    inline void reserve(const std::size_t) const {
         //don't do anything
     }
 
-    inline void resize(const size_t new_size) {
+    inline void resize(const std::size_t new_size) {
         if(new_size > mCurrentSize) {
             while(capacity() < new_size) {
                 mBucketList.push_back(new ElementT[bucketSizeC]);
@@ -249,7 +254,7 @@ public:
             mCurrentSize = new_size;
         }
         if(new_size < mCurrentSize) {
-            size_t number_of_necessary_buckets = 1+(new_size / bucketSizeC);
+            std::size_t number_of_necessary_buckets = 1+(new_size / bucketSizeC);
 
             for(unsigned i = number_of_necessary_buckets; i < mBucketList.size(); ++i) {
                 delete[] mBucketList[i];
@@ -259,16 +264,16 @@ public:
         }
     }
 
-    inline size_t size() const {
+    inline std::size_t size() const {
         return mCurrentSize;
     }
 
-    inline size_t capacity() const {
+    inline std::size_t capacity() const {
         return mBucketList.size() * bucketSizeC;
     }
 
     inline iterator begin() {
-        return iterator(static_cast<size_t>(0), mBucketList);
+        return iterator(static_cast<std::size_t>(0), mBucketList);
     }
 
     inline iterator end() {
@@ -276,7 +281,7 @@ public:
     }
 
     inline deallocation_iterator dbegin() {
-        return deallocation_iterator(static_cast<size_t>(0), mBucketList);
+        return deallocation_iterator(static_cast<std::size_t>(0), mBucketList);
     }
 
     inline deallocation_iterator dend() {
@@ -284,24 +289,36 @@ public:
     }
 
     inline const_iterator begin() const {
-        return const_iterator(static_cast<size_t>(0), mBucketList);
+        return const_iterator(static_cast<std::size_t>(0), mBucketList);
     }
 
     inline const_iterator end() const {
         return const_iterator(size(), mBucketList);
     }
 
-    inline ElementT & operator[](const size_t index) {
-        size_t _bucket = index / bucketSizeC;
-        size_t _index = index % bucketSizeC;
+    inline ElementT & operator[](const std::size_t index) {
+        std::size_t _bucket = index / bucketSizeC;
+        std::size_t _index = index % bucketSizeC;
         return (mBucketList[_bucket][_index]);
     }
 
-    const inline ElementT & operator[](const size_t index) const {
-        size_t _bucket = index / bucketSizeC;
-        size_t _index = index % bucketSizeC;
+    const inline ElementT & operator[](const std::size_t index) const {
+        std::size_t _bucket = index / bucketSizeC;
+        std::size_t _index = index % bucketSizeC;
         return (mBucketList[_bucket][_index]);
     }
+
+    inline ElementT & back() {
+        std::size_t _bucket = mCurrentSize / bucketSizeC;
+    	std::size_t _index = mCurrentSize % bucketSizeC;
+    	return (mBucketList[_bucket][_index]);
+    }
+
+    const inline ElementT & back() const {
+        std::size_t _bucket = mCurrentSize / bucketSizeC;
+        std::size_t _index = mCurrentSize % bucketSizeC;
+    	return (mBucketList[_bucket][_index]);
+    }
 };
 
 #endif /* DEALLOCATINGVECTOR_H_ */

DataStructures/DynamicGraph.h

@@ -1,38 +1,48 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 DYNAMICGRAPH_H_INCLUDED
 #define DYNAMICGRAPH_H_INCLUDED
 
-#include <vector>
+#include "../DataStructures/DeallocatingVector.h"
+
+#include <boost/assert.hpp>
+#include <boost/integer.hpp>
+
 #include <algorithm>
 #include <limits>
-
-#include "../DataStructures/DeallocatingVector.h"
+#include <vector>
 
 template< typename EdgeDataT>
 class DynamicGraph {
     public:
         typedef EdgeDataT EdgeData;
-        typedef unsigned NodeIterator;
-        typedef unsigned EdgeIterator;
+        typedef uint32_t NodeIterator;
+        typedef uint32_t EdgeIterator;
 
         class InputEdge {
             public:
@@ -47,20 +57,20 @@ class DynamicGraph {
         };
 
         //Constructs an empty graph with a given number of nodes.
-        DynamicGraph( int nodes ) : m_numNodes(nodes), m_numEdges(0) {
+        DynamicGraph( int32_t nodes ) : m_numNodes(nodes), m_numEdges(0) {
             m_nodes.reserve( m_numNodes );
             m_nodes.resize( m_numNodes );
 
             m_edges.reserve( m_numNodes * 1.1 );
             m_edges.resize( m_numNodes );
         }
+
         template<class ContainerT>
-        DynamicGraph( const int nodes, const ContainerT &graph )
-        {
+        DynamicGraph( const int32_t nodes, const ContainerT &graph ) {
             m_numNodes = nodes;
             m_numEdges = ( EdgeIterator ) graph.size();
-            m_nodes.reserve( m_numNodes );
-            m_nodes.resize( m_numNodes );
+            m_nodes.reserve( m_numNodes +1);
+            m_nodes.resize( m_numNodes +1);
             EdgeIterator edge = 0;
             EdgeIterator position = 0;
             for ( NodeIterator node = 0; node < m_numNodes; ++node ) {
@@ -72,6 +82,7 @@ class DynamicGraph {
                 m_nodes[node].edges = edge - lastEdge;
                 position += m_nodes[node].edges;
             }
+            m_nodes.back().firstEdge = position;
             m_edges.reserve( position * 1.1 );
             m_edges.resize( position );
             edge = 0;
@@ -79,7 +90,10 @@ class DynamicGraph {
                 for ( EdgeIterator i = m_nodes[node].firstEdge, e = m_nodes[node].firstEdge + m_nodes[node].edges; i != e; ++i ) {
                     m_edges[i].target = graph[edge].target;
                     m_edges[i].data = graph[edge].data;
-                    GUARANTEE(graph[edge].data.distance > 0, "edge: " << edge << "(" << graph[edge].source << "," << graph[edge].target << ")=" << graph[edge].data.distance);
+                    BOOST_ASSERT_MSG(
+                        graph[edge].data.distance > 0,
+                        "edge distance invalid"
+                    );
                     ++edge;
                 }
             }
@@ -87,50 +101,40 @@ class DynamicGraph {
 
         ~DynamicGraph(){ }
 
-        unsigned GetNumberOfNodes() const
-        {
+        uint32_t GetNumberOfNodes() const {
             return m_numNodes;
         }
 
-        unsigned GetNumberOfEdges() const
-        {
+        uint32_t GetNumberOfEdges() const {
             return m_numEdges;
         }
 
-        unsigned GetOutDegree( const NodeIterator &n ) const
-        {
+        uint32_t GetOutDegree( const NodeIterator n ) const {
             return m_nodes[n].edges;
         }
 
-        NodeIterator GetTarget( const EdgeIterator &e ) const
-        {
+        NodeIterator GetTarget( const EdgeIterator e ) const {
             return NodeIterator( m_edges[e].target );
         }
 
-        EdgeDataT &GetEdgeData( const EdgeIterator &e )
-        {
+        EdgeDataT &GetEdgeData( const EdgeIterator e ) {
             return m_edges[e].data;
         }
 
-        const EdgeDataT &GetEdgeData( const EdgeIterator &e ) const
-        {
+        const EdgeDataT &GetEdgeData( const EdgeIterator e ) const {
             return m_edges[e].data;
         }
 
-        EdgeIterator BeginEdges( const NodeIterator &n ) const
-        {
-            //assert( EndEdges( n ) - EdgeIterator( _nodes[n].firstEdge ) <= 100 );
+        EdgeIterator BeginEdges( const NodeIterator n ) const {
             return EdgeIterator( m_nodes[n].firstEdge );
         }
 
-        EdgeIterator EndEdges( const NodeIterator &n ) const
-        {
+        EdgeIterator EndEdges( const NodeIterator n ) const {
             return EdgeIterator( m_nodes[n].firstEdge + m_nodes[n].edges );
         }
 
         //adds an edge. Invalidates edge iterators for the source node
-        EdgeIterator InsertEdge( const NodeIterator &from, const NodeIterator &to, const EdgeDataT &data )
-        {
+        EdgeIterator InsertEdge( const NodeIterator from, const NodeIterator to, const EdgeDataT &data ) {
             Node &node = m_nodes[from];
             EdgeIterator newFirstEdge = node.edges + node.firstEdge;
             if ( newFirstEdge >= m_edges.size() || !isDummy( newFirstEdge ) ) {
@@ -139,7 +143,7 @@ class DynamicGraph {
                     m_edges[node.firstEdge] = m_edges[node.firstEdge + node.edges];
                 } else {
                     EdgeIterator newFirstEdge = ( EdgeIterator ) m_edges.size();
-                    unsigned newSize = node.edges * 1.1 + 2;
+                    uint32_t newSize = node.edges * 1.1 + 2;
                     EdgeIterator requiredCapacity = newSize + m_edges.size();
                     EdgeIterator oldCapacity = m_edges.capacity();
                     if ( requiredCapacity >= oldCapacity ) {
@@ -164,20 +168,19 @@ class DynamicGraph {
         }
 
         //removes an edge. Invalidates edge iterators for the source node
-        void DeleteEdge( const NodeIterator source, const EdgeIterator &e ) {
+        void DeleteEdge( const NodeIterator source, const EdgeIterator e ) {
             Node &node = m_nodes[source];
             --m_numEdges;
             --node.edges;
-            const unsigned last = node.firstEdge + node.edges;
+            const uint32_t last = node.firstEdge + node.edges;
             //swap with last edge
             m_edges[e] = m_edges[last];
             makeDummy( last );
         }
 
         //removes all edges (source,target)
-        int DeleteEdgesTo( const NodeIterator source, const NodeIterator target )
-        {
-            int deleted = 0;
+        int32_t DeleteEdgesTo( const NodeIterator source, const NodeIterator target ) {
+            int32_t deleted = 0;
             for ( EdgeIterator i = BeginEdges( source ), iend = EndEdges( source ); i < iend - deleted; ++i ) {
                 if ( m_edges[i].target == target ) {
                     do {
@@ -196,10 +199,9 @@ class DynamicGraph {
         }
 
         //searches for a specific edge
-        EdgeIterator FindEdge( const NodeIterator &from, const NodeIterator &to ) const
-        {
+        EdgeIterator FindEdge( const NodeIterator from, const NodeIterator to ) const {
             for ( EdgeIterator i = BeginEdges( from ), iend = EndEdges( from ); i != iend; ++i ) {
-                if ( m_edges[i].target == to ) {
+                if ( to == m_edges[i].target ) {
                     return i;
                 }
             }
@@ -208,13 +210,11 @@ class DynamicGraph {
 
     protected:
 
-        bool isDummy( EdgeIterator edge ) const
-        {
+        bool isDummy( const EdgeIterator edge ) const {
             return m_edges[edge].target == (std::numeric_limits< NodeIterator >::max)();
         }
 
-        void makeDummy( EdgeIterator edge )
-        {
+        void makeDummy( const EdgeIterator edge ) {
             m_edges[edge].target = (std::numeric_limits< NodeIterator >::max)();
         }
 
@@ -222,7 +222,7 @@ class DynamicGraph {
             //index of the first edge
             EdgeIterator firstEdge;
             //amount of edges
-            unsigned edges;
+            uint32_t edges;
         };
 
         struct Edge {
@@ -233,9 +233,8 @@ class DynamicGraph {
         NodeIterator m_numNodes;
         EdgeIterator m_numEdges;
 
-       DeallocatingVector< Node > m_nodes;
-       DeallocatingVector< Edge > m_edges;
-
+        std::vector< Node > m_nodes;
+        DeallocatingVector< Edge > m_edges;
 };
 
 #endif // DYNAMICGRAPH_H_INCLUDED

DataStructures/EdgeBasedNode.h

@@ -0,0 +1,51 @@
+#ifndef EDGE_BASED_NODE_H
+#define EDGE_BASED_NODE_H
+
+#include "Coordinate.h"
+
+struct EdgeBasedNode {
+    EdgeBasedNode() :
+        id(INT_MAX),
+        lat1(INT_MAX),
+        lat2(INT_MAX),
+        lon1(INT_MAX),
+        lon2(INT_MAX >> 1),
+        belongsToTinyComponent(false),
+        nameID(UINT_MAX),
+        weight(UINT_MAX >> 1),
+        ignoreInGrid(false)
+    { }
+
+    bool operator<(const EdgeBasedNode & other) const {
+        return other.id < id;
+    }
+
+    bool operator==(const EdgeBasedNode & other) const {
+        return id == other.id;
+    }
+
+    inline FixedPointCoordinate Centroid() const {
+        FixedPointCoordinate centroid;
+        //The coordinates of the midpoint are given by:
+        //x = (x1 + x2) /2 and y = (y1 + y2) /2.
+        centroid.lon = (std::min(lon1, lon2) + std::max(lon1, lon2))/2;
+        centroid.lat = (std::min(lat1, lat2) + std::max(lat1, lat2))/2;
+        return centroid;
+    }
+
+    inline bool isIgnored() const {
+        return ignoreInGrid;
+    }
+
+    NodeID id;
+    int lat1;
+    int lat2;
+    int lon1;
+    int lon2:31;
+    bool belongsToTinyComponent:1;
+    NodeID nameID;
+    unsigned weight:31;
+    bool ignoreInGrid:1;
+};
+
+#endif //EDGE_BASED_NODE_H

DataStructures/GridEdge.h

@@ -1,82 +0,0 @@
-/*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
-
-#ifndef GRIDEDGE_H_
-#define GRIDEDGE_H_
-
-#include "Coordinate.h"
-
-struct _GridEdge {
-    _GridEdge(NodeID n, NodeID na, int w, _Coordinate sc, _Coordinate tc, bool bttc) : edgeBasedNode(n), nameID(na), weight(w), startCoord(sc), targetCoord(tc), belongsToTinyComponent(bttc) {}
-    _GridEdge() : edgeBasedNode(UINT_MAX), nameID(UINT_MAX), weight(INT_MAX), belongsToTinyComponent(false) {}
-    NodeID edgeBasedNode;
-    NodeID nameID;
-    int weight;
-    _Coordinate startCoord;
-    _Coordinate targetCoord;
-    bool belongsToTinyComponent;
-
-    bool operator< ( const _GridEdge& right) const {
-        return edgeBasedNode < right.edgeBasedNode;
-    }
-    bool operator== ( const _GridEdge& right) const {
-        return edgeBasedNode == right.edgeBasedNode;
-    }
-};
-
-struct GridEntry {
-    GridEntry() : fileIndex(UINT_MAX), ramIndex(UINT_MAX){}
-    GridEntry(_GridEdge e, unsigned f, unsigned r) : edge(e), fileIndex(f), ramIndex(r) {}
-    _GridEdge edge;
-    unsigned fileIndex;
-    unsigned ramIndex;
-    bool operator< ( const GridEntry& right ) const {
-        return (edge.edgeBasedNode < right.edge.edgeBasedNode);
-    }
-    bool operator==( const GridEntry& right ) const {
-        return right.edge.edgeBasedNode == edge.edgeBasedNode;
-    }
-};
-
-struct CompareGridEdgeDataByFileIndex {
-    bool operator ()  (const GridEntry & a, const GridEntry & b) const {
-        return a.fileIndex < b.fileIndex;
-    }
-};
-
-struct CompareGridEdgeDataByRamIndex {
-    typedef GridEntry value_type;
-
-    bool operator ()  (const GridEntry & a, const GridEntry & b) const {
-        return a.ramIndex < b.ramIndex;
-    }
-    value_type max_value() {
-        GridEntry e;
-        e.ramIndex = (1024*1024) - 1;
-        return e;
-    }
-    value_type min_value() {
-        GridEntry e;
-        e.ramIndex = 0;
-        return e;
-    }
-};
-
-#endif /* GRIDEDGE_H_ */

DataStructures/HashTable.h

@@ -1,79 +1,67 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
+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.
 
-  Created on: 18.11.2010
-  Author: dennis
- */
+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 HASHTABLE_H_
 #define HASHTABLE_H_
 
+#include <boost/ref.hpp>
 #include <boost/unordered_map.hpp>
 
 template<typename keyT, typename valueT>
-class HashTable {
-    typedef boost::unordered_map<keyT, valueT> MyHashTable;
+class HashTable : public boost::unordered_map<keyT, valueT> {
+private:
+    typedef boost::unordered_map<keyT, valueT> super;
 public:
-    typedef typename boost::unordered_map<keyT, valueT>::const_iterator MyIterator;
-    typedef MyIterator iterator;
-    HashTable() { }
-    HashTable(const unsigned size) {
-        table.resize(size);
+    HashTable() : super() { }
+
+    HashTable(const unsigned size) : super(size) { }
+
+    HashTable &operator=(const HashTable &other) {
+        super::operator = (other);
+        return *this;
     }
+
     inline void Add(const keyT& key, const valueT& value){
-        table[key] = value;
-    }
-    inline void Set(const keyT& key, const valueT& value){
-        table[key] = value;
+        super::insert(std::make_pair(key, value));
     }
+
     inline valueT Find(const keyT& key) const {
-        if(table.find(key) == table.end())
+        if(super::find(key) == super::end()) {
             return valueT();
-        return table.find(key)->second;
+        }
+        return boost::ref(super::find(key)->second);
     }
 
     inline bool Holds(const keyT& key) const {
-        if(table.find(key) == table.end())
+        if(super::find(key) == super::end()) {
             return false;
+        }
         return true;
     }
-    void EraseAll() {
-        if(table.size() > 0)
-            table.clear();
-    }
-
-    inline valueT operator[] (keyT key) const {
-    	if(table.find(key) == table.end())
-    		return valueT();
-    	return table.find(key)->second;
-    }
-    inline unsigned Size() const {
-        return table.size();
-    }
-    MyIterator begin() const {
-        return table.begin();
-    }
-    MyIterator end() const {
-        return table.end();
-    }
-private:
-    MyHashTable table;
 };
 
 #endif /* HASHTABLE_H_ */

DataStructures/HilbertValue.h

@@ -0,0 +1,97 @@
+/*
+
+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 HILBERTVALUE_H_
+#define HILBERTVALUE_H_
+
+#include "Coordinate.h"
+
+#include <boost/integer.hpp>
+#include <boost/noncopyable.hpp>
+
+// computes a 64 bit value that corresponds to the hilbert space filling curve
+
+class HilbertCode : boost::noncopyable {
+public:
+	static uint64_t GetHilbertNumberForCoordinate(
+		const FixedPointCoordinate & current_coordinate
+	) {
+		unsigned location[2];
+		location[0] = current_coordinate.lat+( 90*COORDINATE_PRECISION);
+		location[1] = current_coordinate.lon+(180*COORDINATE_PRECISION);
+
+		TransposeCoordinate(location);
+		const uint64_t result = BitInterleaving(location[0], location[1]);
+		return result;
+	}
+private:
+	static inline uint64_t BitInterleaving(const uint32_t a, const uint32_t b) {
+		uint64_t result = 0;
+		for(int8_t index = 31; index >= 0; --index){
+			result |= (a >> index) & 1;
+			result <<= 1;
+			result |= (b >> index) & 1;
+			if(0 != index){
+				result <<= 1;
+			}
+		}
+		return result;
+	}
+
+	static inline void TransposeCoordinate( uint32_t * X) {
+		uint32_t M = 1 << (32-1), P, Q, t;
+		int i;
+		// Inverse undo
+		for( Q = M; Q > 1; Q >>= 1 ) {
+			P=Q-1;
+			for( i = 0; i < 2; ++i ) {
+				if( X[i] & Q ) {
+					X[0] ^= P; // invert
+				} else {
+					t = (X[0]^X[i]) & P;
+					X[0] ^= t;
+					X[i] ^= t;
+				}
+			} // exchange
+		}
+		// Gray encode
+		for( i = 1; i < 2; ++i ) {
+			X[i] ^= X[i-1];
+		}
+		t=0;
+		for( Q = M; Q > 1; Q >>= 1 ) {
+			if( X[2-1] & Q ) {
+				t ^= Q-1;
+			}
+		} //check if this for loop is wrong
+		for( i = 0; i < 2; ++i ) {
+			X[i] ^= t;
+		}
+	}
+};
+
+#endif /* HILBERTVALUE_H_ */

DataStructures/ImportEdge.h

@@ -1,31 +1,41 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+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.
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
 */
 
-#ifndef EDGE_H
-#define EDGE_H
+#ifndef IMPORT_EDGE_H
+#define IMPORT_EDGE_H
 
-#include <cassert>
+#include "../Util/OSRMException.h"
+#include "../typedefs.h"
+
+#include <boost/assert.hpp>
 
 class NodeBasedEdge {
-public:
 
+public:
     bool operator< (const NodeBasedEdge& e) const {
         if (source() == e.source()) {
             if (target() == e.target()) {
@@ -40,41 +50,70 @@ public:
         return (source() < e.source());
     }
 
-    /** Default constructor. target and weight are set to 0.*/
-    NodeBasedEdge() :
-        _source(0), _target(0), _name(0), _weight(0), forward(0), backward(0), _type(0), _roundabout(false), _ignoreInGrid(false), _accessRestricted(false) { assert(false); } //shall not be used.
+    explicit NodeBasedEdge(
+        NodeID s,
+        NodeID t,
+        NodeID n,
+        EdgeWeight w,
+        bool f,
+        bool b,
+        short ty,
+        bool ra,
+        bool ig,
+        bool ar,
+        bool cf
+    ) : _source(s),
+        _target(t),
+        _name(n),
+        _weight(w),
+        _type(ty),
+        forward(f),
+        backward(b),
+        _roundabout(ra),
+        _ignoreInGrid(ig),
+        _accessRestricted(ar),
+        _contraFlow(cf)
+    {
+        if(ty < 0) {
+            throw OSRMException("negative edge type");
+        }
+    }
 
-    explicit NodeBasedEdge(NodeID s, NodeID t, NodeID n, EdgeWeight w, bool f, bool b, short ty, bool ra, bool ig, bool ar) :
-            _source(s), _target(t), _name(n), _weight(w), forward(f), backward(b), _type(ty), _roundabout(ra), _ignoreInGrid(ig), _accessRestricted(ar) { if(ty < 0) {ERR("Type: " << ty);}; }
+    NodeID target()             const {return _target; }
+    NodeID source()             const {return _source; }
+    NodeID name()               const { return _name;  }
+    EdgeWeight weight()         const {return _weight; }
+    short type()                const {
+        BOOST_ASSERT_MSG(_type >= 0, "type of ImportEdge invalid");
+                                        return _type;   }
+    bool isBackward()           const { return backward; }
+    bool isForward()            const { return forward; }
+    bool isLocatable()          const { return _type != 14; }
+    bool isRoundabout()         const { return _roundabout; }
+    bool ignoreInGrid()         const { return _ignoreInGrid; }
+    bool isAccessRestricted()   const { return _accessRestricted; }
+    bool isContraFlow()         const { return _contraFlow; }
 
-    NodeID target() const {return _target; }
-    NodeID source() const {return _source; }
-    NodeID name() const { return _name; }
-    EdgeWeight weight() const {return _weight; }
+    //TODO: names need to be fixed.
+    NodeID      _source;
+    NodeID      _target;
+    NodeID      _name;
+    EdgeWeight  _weight;
+    short       _type;
+    bool        forward:1;
+    bool        backward:1;
+    bool        _roundabout:1;
+    bool        _ignoreInGrid:1;
+    bool        _accessRestricted:1;
+    bool        _contraFlow:1;
 
-    short type() const { assert(_type >= 0); return _type; }
-    bool isBackward() const { return backward; }
-    bool isForward() const { return forward; }
-    bool isLocatable() const { return _type != 14; }
-    bool isRoundabout() const { return _roundabout; }
-    bool ignoreInGrid() const { return _ignoreInGrid; }
-    bool isAccessRestricted() const { return _accessRestricted; }
-
-    NodeID _source;
-    NodeID _target;
-    NodeID _name;
-    EdgeWeight _weight;
-    bool forward;
-    bool backward;
-    short _type;
-    bool _roundabout;
-    bool _ignoreInGrid;
-    bool _accessRestricted;
+private:
+    NodeBasedEdge() { }
 };
 
 class EdgeBasedEdge {
-public:
 
+public:
     bool operator< (const EdgeBasedEdge& e) const {
         if (source() == e.source()) {
             if (target() == e.target()) {
@@ -91,45 +130,56 @@ public:
 
     template<class EdgeT>
     EdgeBasedEdge(const EdgeT & myEdge ) :
-        _source(myEdge.source),
-        _target(myEdge.target),
-        _edgeID(myEdge.data.via),
-//        _nameID1(myEdge.data.nameID),
-        _weight(myEdge.data.distance),
-        _forward(myEdge.data.forward),
-        _backward(myEdge.data.backward)//,
-//        _turnInstruction(myEdge.data.turnInstruction)
-                { }
+        m_source(myEdge.source),
+        m_target(myEdge.target),
+        m_edgeID(myEdge.data.via),
+        m_weight(myEdge.data.distance),
+        m_forward(myEdge.data.forward),
+        m_backward(myEdge.data.backward)
+    { }
 
     /** Default constructor. target and weight are set to 0.*/
     EdgeBasedEdge() :
-        _source(0), _target(0), _edgeID(0), _weight(0), _forward(false), _backward(false) { }
+        m_source(0),
+        m_target(0),
+        m_edgeID(0),
+        m_weight(0),
+        m_forward(false),
+        m_backward(false)
+    { }
 
-    explicit EdgeBasedEdge(NodeID s, NodeID t, NodeID v, EdgeWeight w, bool f, bool b) :
-            _source(s), _target(t), _edgeID(v), _weight(w), _forward(f), _backward(b){}
+    explicit EdgeBasedEdge(
+        const NodeID s,
+        const NodeID t,
+        const NodeID v,
+        const EdgeWeight w,
+        const bool f,
+        const bool b
+    ) :
+        m_source(s),
+        m_target(t),
+        m_edgeID(v),
+        m_weight(w),
+        m_forward(f),
+        m_backward(b)
+    {}
 
-    NodeID target() const {return _target; }
-    NodeID source() const {return _source; }
-    EdgeWeight weight() const {return _weight; }
-    NodeID id() const { return _edgeID; }
-    bool isBackward() const { return _backward; }
-    bool isForward() const { return _forward; }
+    NodeID      target()        const { return m_target;   }
+    NodeID      source()        const { return m_source;   }
+    EdgeWeight  weight()        const { return m_weight;   }
+    NodeID      id()            const { return m_edgeID;   }
+    bool        isBackward()    const { return m_backward; }
+    bool        isForward()     const { return m_forward;  }
 
-    NodeID _source;
-    NodeID _target;
-    NodeID _edgeID;
-    EdgeWeight _weight:30;
-    bool _forward:1;
-    bool _backward:1;
-};
-
-struct MinimalEdgeData {
-public:
-    EdgeWeight distance;
-    bool forward;
-    bool backward;
+private:
+    NodeID      m_source;
+    NodeID      m_target;
+    NodeID      m_edgeID;
+    EdgeWeight  m_weight:30;
+    bool        m_forward:1;
+    bool        m_backward:1;
 };
 
 typedef NodeBasedEdge ImportEdge;
 
-#endif // EDGE_H
+#endif /* IMPORT_EDGE_H */

DataStructures/ImportNode.h

@@ -1,39 +1,62 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 IMPORTNODE_H_
 #define IMPORTNODE_H_
 
-#include "NodeCoords.h"
+#include "QueryNode.h"
 #include "../DataStructures/HashTable.h"
 
 
-struct _Node : NodeInfo{
-    _Node(int _lat, int _lon, unsigned int _id, bool _bollard, bool _trafficLight) : NodeInfo(_lat, _lon,  _id), bollard(_bollard), trafficLight(_trafficLight) {}
-    _Node() : bollard(false), trafficLight(false) {}
+struct ExternalMemoryNode : NodeInfo {
+    ExternalMemoryNode(
+        int lat,
+        int lon,
+        unsigned int id,
+        bool bollard,
+        bool traffic_light
+    ) :
+        NodeInfo(lat, lon, id),
+        bollard(bollard),
+        trafficLight(traffic_light)
+    { }
+    ExternalMemoryNode() : bollard(false), trafficLight(false) {}
 
-    static _Node min_value() {
-        return _Node(0,0,0, false, false);
+    static ExternalMemoryNode min_value() {
+        return ExternalMemoryNode(0,0,0, false, false);
     }
-    static _Node max_value() {
-        return _Node((std::numeric_limits<int>::max)(), (std::numeric_limits<int>::max)(), (std::numeric_limits<unsigned int>::max)(), false, false);
+    static ExternalMemoryNode max_value() {
+        return ExternalMemoryNode(
+            std::numeric_limits<int>::max(),
+            std::numeric_limits<int>::max(),
+            std::numeric_limits<unsigned>::max(),
+            false,
+            false
+        );
     }
     NodeID key() const {
         return id;
@@ -42,11 +65,11 @@ struct _Node : NodeInfo{
     bool trafficLight;
 };
 
-struct ImportNode : public _Node {
+struct ImportNode : public ExternalMemoryNode {
     HashTable<std::string, std::string> keyVals;
-	
+
 	inline void Clear() {
-		keyVals.EraseAll();
+		keyVals.clear();
 		lat = 0; lon = 0; id = 0; bollard = false; trafficLight = false;
 	}
 };

DataStructures/InputReaderFactory.h

@@ -1,22 +1,30 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+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.
+
+*/
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
 
 #ifndef INPUTREADERFACTORY_H
 #define INPUTREADERFACTORY_H
@@ -43,21 +51,21 @@ int readFromBz2Stream( void* pointer, char* buffer, int len ) {
             return read;
         } else if(BZ_STREAM_END == context->error) {
             BZ2_bzReadGetUnused(&context->error, context->bz2, &unusedTmpVoid, &context->nUnused);
-            if(BZ_OK != context->error) { cerr << "Could not BZ2_bzReadGetUnused" << endl; exit(-1);};
+            if(BZ_OK != context->error) {std::cerr << "Could not BZ2_bzReadGetUnused" <<std::endl; exit(-1);};
             unusedTmp = (char*)unusedTmpVoid;
             for(int i=0;i<context->nUnused;i++) {
                 context->unused[i] = unusedTmp[i];
             }
             BZ2_bzReadClose(&context->error, context->bz2);
-            if(BZ_OK != context->error) { cerr << "Could not BZ2_bzReadClose" << endl; exit(-1);};
+            if(BZ_OK != context->error) {std::cerr << "Could not BZ2_bzReadClose" <<std::endl; exit(-1);};
             context->error = BZ_STREAM_END; // set to the stream end for next call to this function
             if(0 == context->nUnused && feof(context->file)) {
                 return read;
             } else {
                 context->bz2 = BZ2_bzReadOpen(&context->error, context->file, 0, 0, context->unused, context->nUnused);
-                if(NULL == context->bz2){ cerr << "Could not open file" << endl; exit(-1);};
+                if(NULL == context->bz2){std::cerr << "Could not open file" <<std::endl; exit(-1);};
             }
-        } else { cerr << "Could not read bz2 file" << endl; exit(-1); }
+        } else { std::cerr << "Could not read bz2 file" << std::endl; exit(-1); }
     }
     return read;
 }
@@ -74,7 +82,7 @@ xmlTextReaderPtr inputReaderFactory( const char* name )
 {
     std::string inputName(name);
 
-    if(inputName.find(".osm.bz2")!=string::npos)
+    if(inputName.find(".osm.bz2")!=std::string::npos)
     {
         BZ2Context* context = new BZ2Context();
         context->error = false;

DataStructures/LRUCache.h

@@ -1,22 +1,29 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 LRUCACHE_H
 #define LRUCACHE_H

DataStructures/MercatorUtil.h

@@ -0,0 +1,45 @@
+/*
+
+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 MERCATORUTIL_H_
+#define MERCATORUTIL_H_
+
+#include <cmath>
+
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
+
+inline double y2lat(double a) {
+	return 180./M_PI * (2. * atan(exp(a*M_PI/180.)) - M_PI/2.);
+}
+
+inline double lat2y(double a) {
+	return 180./M_PI * log(tan(M_PI/4.+a*(M_PI/180.)/2.));
+}
+
+#endif /* MERCATORUTIL_H_ */

DataStructures/NNGrid.h

@@ -1,594 +0,0 @@
-/*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
-
-#ifndef NNGRID_H_
-#define NNGRID_H_
-
-#include <algorithm>
-#include <cassert>
-#include <cfloat>
-#include <cmath>
-#include <fstream>
-#include <limits>
-#include <vector>
-
-#ifndef ROUTED
-#include <stxxl.h>
-#endif
-
-#ifdef _WIN32
-#include <math.h>
-#endif
-
-#include <boost/thread.hpp>
-#include <boost/foreach.hpp>
-#include <boost/unordered_map.hpp>
-
-#include "DeallocatingVector.h"
-//#include "ExtractorStructs.h"
-#include "GridEdge.h"
-#include "Percent.h"
-#include "PhantomNodes.h"
-#include "Util.h"
-#include "StaticGraph.h"
-#include "../Algorithms/Bresenham.h"
-
-namespace NNGrid{
-
-static boost::thread_specific_ptr<std::ifstream> localStream;
-
-template<bool WriteAccess = false>
-class NNGrid {
-public:
-    NNGrid() /*: cellCache(500), fileCache(500)*/ {
-        ramIndexTable.resize((1024*1024), ULONG_MAX);
-    }
-
-    NNGrid(const char* rif, const char* _i) {
-        if(WriteAccess) {
-            ERR("Not available in Write mode");
-        }
-        iif = std::string(_i);
-        ramIndexTable.resize((1024*1024), ULONG_MAX);
-        ramInFile.open(rif, std::ios::in | std::ios::binary);
-        if(!ramInFile) { ERR(rif <<  " not found"); }
-
-    }
-
-    ~NNGrid() {
-        if(ramInFile.is_open()) ramInFile.close();
-
-#ifndef ROUTED
-        if (WriteAccess) {
-            entries.clear();
-        }
-#endif
-        if(localStream.get() && localStream->is_open()) {
-            localStream->close();
-        }
-    }
-
-    void OpenIndexFiles() {
-        assert(ramInFile.is_open());
-        ramInFile.read(static_cast<char*>(static_cast<void*>(&ramIndexTable[0]) ), sizeof(unsigned long)*1024*1024);
-        ramInFile.close();
-    }
-
-#ifndef ROUTED
-    template<typename EdgeT>
-    inline void ConstructGrid(DeallocatingVector<EdgeT> & edgeList, char * ramIndexOut, char * fileIndexOut) {
-    	//TODO: Implement this using STXXL-Streams
-        Percent p(edgeList.size());
-        BOOST_FOREACH(EdgeT & edge, edgeList) {
-            p.printIncrement();
-            if(edge.ignoreInGrid)
-                continue;
-            int slat = 100000*lat2y(edge.lat1/100000.);
-            int slon = edge.lon1;
-            int tlat = 100000*lat2y(edge.lat2/100000.);
-            int tlon = edge.lon2;
-            AddEdge( _GridEdge( edge.id, edge.nameID, edge.weight, _Coordinate(slat, slon), _Coordinate(tlat, tlon), edge.belongsToTinyComponent ) );
-        }
-        double timestamp = get_timestamp();
-        //create index file on disk, old one is over written
-        indexOutFile.open(fileIndexOut, std::ios::out | std::ios::binary | std::ios::trunc);
-        //sort entries
-        stxxl::sort(entries.begin(), entries.end(), CompareGridEdgeDataByRamIndex(), 1024*1024*1024);
-        INFO("finished sorting after " << (get_timestamp() - timestamp) << "s");
-        std::vector<GridEntry> entriesInFileWithRAMSameIndex;
-        unsigned indexInRamTable = entries.begin()->ramIndex;
-        unsigned long lastPositionInIndexFile = 0;
-        cout << "writing data ..." << flush;
-        p.reinit(entries.size());
-        boost::unordered_map< unsigned, unsigned > cellMap(1024);
-        BOOST_FOREACH(GridEntry & gridEntry, entries) {
-            p.printIncrement();
-            if(gridEntry.ramIndex != indexInRamTable) {
-                cellMap.clear();
-                BuildCellIndexToFileIndexMap(indexInRamTable, cellMap);
-
-                unsigned numberOfBytesInCell = FillCell(entriesInFileWithRAMSameIndex, lastPositionInIndexFile, cellMap);
-                ramIndexTable[indexInRamTable] = lastPositionInIndexFile;
-                lastPositionInIndexFile += numberOfBytesInCell;
-                entriesInFileWithRAMSameIndex.clear();
-                indexInRamTable = gridEntry.ramIndex;
-            }
-            entriesInFileWithRAMSameIndex.push_back(gridEntry);
-        }
-        cellMap.clear();
-        BuildCellIndexToFileIndexMap(indexInRamTable, cellMap);
-        /*unsigned numberOfBytesInCell = */FillCell(entriesInFileWithRAMSameIndex, lastPositionInIndexFile, cellMap);
-        ramIndexTable[indexInRamTable] = lastPositionInIndexFile;
-        entriesInFileWithRAMSameIndex.clear();
-        std::vector<GridEntry>().swap(entriesInFileWithRAMSameIndex);
-        assert(entriesInFileWithRAMSameIndex.size() == 0);
-        //close index file
-        indexOutFile.close();
-
-        //Serialize RAM Index
-        ofstream ramFile(ramIndexOut, std::ios::out | std::ios::binary | std::ios::trunc);
-        //write 4 MB of index Table in RAM
-        ramFile.write((char *)&ramIndexTable[0], sizeof(unsigned long)*1024*1024 );
-        //close ram index file
-        ramFile.close();
-    }
-#endif
-    inline bool CoordinatesAreEquivalent(const _Coordinate & a, const _Coordinate & b, const _Coordinate & c, const _Coordinate & d) const {
-        return (a == b && c == d) || (a == c && b == d) || (a == d && b == c);
-    }
-
-    bool FindPhantomNodeForCoordinate( const _Coordinate & location, PhantomNode & resultNode, const unsigned zoomLevel) {
-        bool ignoreTinyComponents = (zoomLevel <= 14);
-//        INFO("Coordinate: " << location << ", zoomLevel: " << zoomLevel << ", ignoring tinyComponentents: " << (ignoreTinyComponents ? "yes" : "no"));
-//        double time1 = get_timestamp();
-        bool foundNode = false;
-        const _Coordinate startCoord(100000*(lat2y(static_cast<double>(location.lat)/100000.)), location.lon);
-        /** search for point on edge close to source */
-        const unsigned fileIndex = GetFileIndexForLatLon(startCoord.lat, startCoord.lon);
-        std::vector<_GridEdge> candidates;
-        const int lowerBoundForLoop = (fileIndex < 32768 ? 0 : -32768);
-        for(int j = lowerBoundForLoop; (j < (32768+1)) && (fileIndex != UINT_MAX); j+=32768) {
-            for(int i = -1; i < 2; ++i){
-//                unsigned oldSize = candidates.size();
-                GetContentsOfFileBucketEnumerated(fileIndex+i+j, candidates);
-//                INFO("Getting fileIndex=" << fileIndex+i+j << " with " << candidates.size() - oldSize << " candidates");
-            }
-        }
-//        INFO("looked up " << candidates.size());
-        _GridEdge smallestEdge;
-        _Coordinate tmp, edgeStartCoord, edgeEndCoord;
-        double dist = numeric_limits<double>::max();
-        double r, tmpDist;
-
-        BOOST_FOREACH(_GridEdge candidate, candidates) {
-            if(candidate.belongsToTinyComponent && ignoreTinyComponents)
-                continue;
-            r = 0.;
-            tmpDist = ComputeDistance(startCoord, candidate.startCoord, candidate.targetCoord, tmp, &r);
-//            INFO("dist " << startCoord << "->[" << candidate.startCoord << "-" << candidate.targetCoord << "]=" << tmpDist );
-//            INFO("Looking at edge " << candidate.edgeBasedNode << " at distance " << tmpDist);
-            if(tmpDist < dist && !DoubleEpsilonCompare(dist, tmpDist)) {
-//                INFO("a) " << candidate.edgeBasedNode << ", dist: " << tmpDist << ", tinyCC: " << (candidate.belongsToTinyComponent ? "yes" : "no"));
-                dist = tmpDist;
-                resultNode.edgeBasedNode = candidate.edgeBasedNode;
-                resultNode.nodeBasedEdgeNameID = candidate.nameID;
-                resultNode.weight1 = candidate.weight;
-                resultNode.weight2 = INT_MAX;
-                resultNode.location.lat = tmp.lat;
-                resultNode.location.lon = tmp.lon;
-                edgeStartCoord = candidate.startCoord;
-                edgeEndCoord = candidate.targetCoord;
-                foundNode = true;
-                smallestEdge = candidate;
-                //}  else if(tmpDist < dist) {
-                //INFO("a) ignored " << candidate.edgeBasedNode << " at distance " << std::fabs(dist - tmpDist));
-            } else if(DoubleEpsilonCompare(dist, tmpDist) && 1 == std::abs(static_cast<int>(candidate.edgeBasedNode)-static_cast<int>(resultNode.edgeBasedNode) )  && CoordinatesAreEquivalent(edgeStartCoord, candidate.startCoord, edgeEndCoord, candidate.targetCoord)) {
-                resultNode.edgeBasedNode = std::min(candidate.edgeBasedNode, resultNode.edgeBasedNode);
-                resultNode.weight2 = candidate.weight;
-                //INFO("b) " << candidate.edgeBasedNode << ", dist: " << tmpDist);
-            }
-        }
-
-        //        INFO("startcoord: " << smallestEdge.startCoord << ", tgtcoord" <<  smallestEdge.targetCoord << "result: " << newEndpoint);
-        //        INFO("length of old edge: " << ApproximateDistance(smallestEdge.startCoord, smallestEdge.targetCoord));
-        //        INFO("Length of new edge: " << ApproximateDistance(smallestEdge.startCoord, newEndpoint));
-        //        assert(!resultNode.isBidirected() || (resultNode.weight1 == resultNode.weight2));
-        //        if(resultNode.weight1 != resultNode.weight2) {
-        //            INFO("-> Weight1: " << resultNode.weight1 << ", weight2: " << resultNode.weight2);
-        //            INFO("-> node: " << resultNode.edgeBasedNode << ", bidir: " << (resultNode.isBidirected() ? "yes" : "no"));
-        //        }
-
-//        INFO("startCoord: " << smallestEdge.startCoord << "; targetCoord: " << smallestEdge.targetCoord << "; newEndpoint: " << resultNode.location);
-        double ratio = (foundNode ? std::min(1., ApproximateDistance(smallestEdge.startCoord, resultNode.location)/ApproximateDistance(smallestEdge.startCoord, smallestEdge.targetCoord)) : 0);
-        resultNode.location.lat = round(100000.*(y2lat(static_cast<double>(resultNode.location.lat)/100000.)));
-//        INFO("Length of vector: " << ApproximateDistance(smallestEdge.startCoord, resultNode.location)/ApproximateDistance(smallestEdge.startCoord, smallestEdge.targetCoord));
-        //Hack to fix rounding errors and wandering via nodes.
-        if(std::abs(location.lon - resultNode.location.lon) == 1)
-            resultNode.location.lon = location.lon;
-        if(std::abs(location.lat - resultNode.location.lat) == 1)
-            resultNode.location.lat = location.lat;
-
-        resultNode.weight1 *= ratio;
-        if(INT_MAX != resultNode.weight2) {
-            resultNode.weight2 -= resultNode.weight1;
-        }
-        resultNode.ratio = ratio;
-//        INFO("New weight1: " << resultNode.weight1 << ", new weight2: " << resultNode.weight2 << ", ratio: " << ratio);
-//        INFO("start: " << edgeStartCoord << ", end: " << edgeEndCoord);
-//        INFO("selected node: " << resultNode.edgeBasedNode << ", bidirected: " << (resultNode.isBidirected() ? "yes" : "no") <<  "\n--");
-//        double time2 = get_timestamp();
-//        INFO("NN-Lookup in " << 1000*(time2-time1) << "ms");
-        return foundNode;
-    }
-
-    bool FindRoutingStarts(const _Coordinate& start, const _Coordinate& target, PhantomNodes & routingStarts, unsigned zoomLevel) {
-        routingStarts.Reset();
-        return (FindPhantomNodeForCoordinate( start, routingStarts.startPhantom, zoomLevel) &&
-                FindPhantomNodeForCoordinate( target, routingStarts.targetPhantom, zoomLevel) );
-    }
-
-    bool FindNearestCoordinateOnEdgeInNodeBasedGraph(const _Coordinate& inputCoordinate, _Coordinate& outputCoordinate, unsigned zoomLevel = 18) {
-        PhantomNode resultNode;
-        bool foundNode = FindPhantomNodeForCoordinate(inputCoordinate, resultNode, zoomLevel);
-        outputCoordinate = resultNode.location;
-        return foundNode;
-    }
-
-    void FindNearestPointOnEdge(const _Coordinate& inputCoordinate, _Coordinate& outputCoordinate) {
-        _Coordinate startCoord(100000*(lat2y(static_cast<double>(inputCoordinate.lat)/100000.)), inputCoordinate.lon);
-        unsigned fileIndex = GetFileIndexForLatLon(startCoord.lat, startCoord.lon);
-
-        std::vector<_GridEdge> candidates;
-        boost::unordered_map< unsigned, unsigned > cellMap;
-        for(int j = -32768; j < (32768+1); j+=32768) {
-            for(int i = -1; i < 2; ++i) {
-                GetContentsOfFileBucket(fileIndex+i+j, candidates, cellMap);
-            }
-        }
-        _Coordinate tmp;
-        double dist = (std::numeric_limits<double>::max)();
-        BOOST_FOREACH(_GridEdge candidate, candidates) {
-            double r = 0.;
-            double tmpDist = ComputeDistance(startCoord, candidate.startCoord, candidate.targetCoord, tmp, &r);
-            if(tmpDist < dist) {
-                dist = tmpDist;
-                outputCoordinate.lat = round(100000*(y2lat(static_cast<double>(tmp.lat)/100000.)));
-                outputCoordinate.lon = tmp.lon;
-            }
-        }
-    }
-
-
-private:
-    inline unsigned GetCellIndexFromRAMAndFileIndex(const unsigned ramIndex, const unsigned fileIndex) const {
-        unsigned lineBase = ramIndex/1024;
-        lineBase = lineBase*32*32768;
-        unsigned columnBase = ramIndex%1024;
-        columnBase=columnBase*32;
-        for (int i = 0;i < 32;++i) {
-            for (int j = 0;j < 32;++j) {
-                const unsigned localFileIndex = lineBase + i * 32768 + columnBase + j;
-                if(localFileIndex == fileIndex) {
-                    unsigned cellIndex = i * 32 + j;
-                    return cellIndex;
-                }
-            }
-        }
-        return UINT_MAX;
-    }
-
-    inline void BuildCellIndexToFileIndexMap(const unsigned ramIndex, boost::unordered_map<unsigned, unsigned >& cellMap){
-        unsigned lineBase = ramIndex/1024;
-        lineBase = lineBase*32*32768;
-        unsigned columnBase = ramIndex%1024;
-        columnBase=columnBase*32;
-        std::vector<std::pair<unsigned, unsigned> >insertionVector(1024);
-        for (int i = 0;i < 32;++i) {
-            for (int j = 0;j < 32;++j) {
-                unsigned fileIndex = lineBase + i * 32768 + columnBase + j;
-                unsigned cellIndex = i * 32 + j;
-                insertionVector[i * 32 + j] = std::make_pair(fileIndex, cellIndex);
-            }
-        }
-        cellMap.insert(insertionVector.begin(), insertionVector.end());
-    }
-
-    inline bool DoubleEpsilonCompare(const double d1, const double d2) {
-        return (std::fabs(d1 - d2) < FLT_EPSILON);
-    }
-
-    inline unsigned FillCell(std::vector<GridEntry>& entriesWithSameRAMIndex, const unsigned long fileOffset, boost::unordered_map< unsigned, unsigned > & cellMap ) {
-        std::vector<char> tmpBuffer(32*32*4096,0);
-        unsigned long indexIntoTmpBuffer = 0;
-        unsigned numberOfWrittenBytes = 0;
-        assert(indexOutFile.is_open());
-
-        std::vector<unsigned long> cellIndex(32*32,ULONG_MAX);
-
-        for(unsigned i = 0; i < entriesWithSameRAMIndex.size() -1; ++i) {
-            assert(entriesWithSameRAMIndex[i].ramIndex== entriesWithSameRAMIndex[i+1].ramIndex);
-        }
-
-        //sort & unique
-        std::sort(entriesWithSameRAMIndex.begin(), entriesWithSameRAMIndex.end(), CompareGridEdgeDataByFileIndex());
-//        entriesWithSameRAMIndex.erase(std::unique(entriesWithSameRAMIndex.begin(), entriesWithSameRAMIndex.end()), entriesWithSameRAMIndex.end());
-
-        //traverse each file bucket and write its contents to disk
-        std::vector<GridEntry> entriesWithSameFileIndex;
-        unsigned fileIndex = entriesWithSameRAMIndex.begin()->fileIndex;
-
-        BOOST_FOREACH(GridEntry & gridEntry, entriesWithSameRAMIndex) {
-            assert(cellMap.find(gridEntry.fileIndex) != cellMap.end() ); //asserting that file index belongs to cell index
-            if(gridEntry.fileIndex != fileIndex) {
-                // start in cellIndex vermerken
-                int localFileIndex = entriesWithSameFileIndex.begin()->fileIndex;
-                int localCellIndex = cellMap.find(localFileIndex)->second;
-                assert(cellMap.find(entriesWithSameFileIndex.begin()->fileIndex) != cellMap.end());
-
-                cellIndex[localCellIndex] = indexIntoTmpBuffer + fileOffset;
-                indexIntoTmpBuffer += FlushEntriesWithSameFileIndexToBuffer(entriesWithSameFileIndex, tmpBuffer, indexIntoTmpBuffer);
-                fileIndex = gridEntry.fileIndex;
-            }
-            entriesWithSameFileIndex.push_back(gridEntry);
-        }
-        assert(cellMap.find(entriesWithSameFileIndex.begin()->fileIndex) != cellMap.end());
-        int localFileIndex = entriesWithSameFileIndex.begin()->fileIndex;
-        int localCellIndex = cellMap.find(localFileIndex)->second;
-
-        cellIndex[localCellIndex] = indexIntoTmpBuffer + fileOffset;
-        indexIntoTmpBuffer += FlushEntriesWithSameFileIndexToBuffer(entriesWithSameFileIndex, tmpBuffer, indexIntoTmpBuffer);
-
-        assert(entriesWithSameFileIndex.size() == 0);
-        indexOutFile.write(static_cast<char*>(static_cast<void*>(&cellIndex[0])),32*32*sizeof(unsigned long));
-        numberOfWrittenBytes += 32*32*sizeof(unsigned long);
-
-        //write contents of tmpbuffer to disk
-        indexOutFile.write(&tmpBuffer[0], indexIntoTmpBuffer*sizeof(char));
-        numberOfWrittenBytes += indexIntoTmpBuffer*sizeof(char);
-
-        return numberOfWrittenBytes;
-    }
-
-    inline unsigned FlushEntriesWithSameFileIndexToBuffer( std::vector<GridEntry> &vectorWithSameFileIndex, std::vector<char> & tmpBuffer, const unsigned long index) const {
-        sort( vectorWithSameFileIndex.begin(), vectorWithSameFileIndex.end() );
-        vectorWithSameFileIndex.erase(unique(vectorWithSameFileIndex.begin(), vectorWithSameFileIndex.end()), vectorWithSameFileIndex.end());
-        const unsigned lengthOfBucket = vectorWithSameFileIndex.size();
-        tmpBuffer.resize(tmpBuffer.size()+(sizeof(_GridEdge)*lengthOfBucket) + sizeof(unsigned) );
-        unsigned counter = 0;
-
-        for(unsigned i = 0; i < vectorWithSameFileIndex.size()-1; ++i) {
-            assert( vectorWithSameFileIndex[i].fileIndex == vectorWithSameFileIndex[i+1].fileIndex );
-            assert( vectorWithSameFileIndex[i].ramIndex == vectorWithSameFileIndex[i+1].ramIndex );
-        }
-
-        //write length of bucket
-        memcpy((char*)&(tmpBuffer[index+counter]), (char*)&lengthOfBucket, sizeof(lengthOfBucket));
-        counter += sizeof(lengthOfBucket);
-
-        BOOST_FOREACH(const GridEntry & entry, vectorWithSameFileIndex) {
-            char * data = (char*)&(entry.edge);
-            memcpy(static_cast<char*>(static_cast<void*>(&(tmpBuffer[index+counter]) )), data, sizeof(entry.edge));
-            counter += sizeof(entry.edge);
-        }
-        //Freeing data
-        vectorWithSameFileIndex.clear();
-        return counter;
-    }
-
-    inline void GetContentsOfFileBucketEnumerated(const unsigned fileIndex, std::vector<_GridEdge>& result) const {
-        unsigned ramIndex = GetRAMIndexFromFileIndex(fileIndex);
-        unsigned long startIndexInFile = ramIndexTable[ramIndex];
-        if(startIndexInFile == ULONG_MAX) {
-            return;
-        }
-        unsigned enumeratedIndex = GetCellIndexFromRAMAndFileIndex(ramIndex, fileIndex);
-
-        if(!localStream.get() || !localStream->is_open()) {
-            localStream.reset(new std::ifstream(iif.c_str(), std::ios::in | std::ios::binary));
-        }
-        if(!localStream->good()) {
-            localStream->clear(std::ios::goodbit);
-            DEBUG("Resetting stale filestream");
-        }
-
-        //only read the single necessary cell index
-        localStream->seekg(startIndexInFile+(enumeratedIndex*sizeof(unsigned long)));
-        unsigned long fetchedIndex = 0;
-        localStream->read(static_cast<char*>( static_cast<void*>(&fetchedIndex)), sizeof(unsigned long));
-
-        if(fetchedIndex == ULONG_MAX) {
-            return;
-        }
-        const unsigned long position = fetchedIndex + 32*32*sizeof(unsigned long) ;
-
-        unsigned lengthOfBucket;
-        unsigned currentSizeOfResult = result.size();
-        localStream->seekg(position);
-        localStream->read(static_cast<char*>( static_cast<void*>(&(lengthOfBucket))), sizeof(unsigned));
-        result.resize(currentSizeOfResult+lengthOfBucket);
-        localStream->read(static_cast<char*>( static_cast<void*>(&result[currentSizeOfResult])), lengthOfBucket*sizeof(_GridEdge));
-    }
-
-    inline void GetContentsOfFileBucket(const unsigned fileIndex, std::vector<_GridEdge>& result, boost::unordered_map< unsigned, unsigned> & cellMap) {
-        unsigned ramIndex = GetRAMIndexFromFileIndex(fileIndex);
-        unsigned long startIndexInFile = ramIndexTable[ramIndex];
-        if(startIndexInFile == ULONG_MAX) {
-            return;
-        }
-
-        unsigned long cellIndex[32*32];
-
-        cellMap.clear();
-        BuildCellIndexToFileIndexMap(ramIndex,  cellMap);
-        if(!localStream.get() || !localStream->is_open()) {
-            localStream.reset(new std::ifstream(iif.c_str(), std::ios::in | std::ios::binary));
-        }
-        if(!localStream->good()) {
-            localStream->clear(std::ios::goodbit);
-            DEBUG("Resetting stale filestream");
-        }
-
-        localStream->seekg(startIndexInFile);
-        localStream->read(static_cast<char*>(static_cast<void*>( cellIndex)), 32*32*sizeof(unsigned long));
-        assert(cellMap.find(fileIndex) != cellMap.end());
-        if(cellIndex[cellMap[fileIndex]] == ULONG_MAX) {
-            return;
-        }
-        const unsigned long position = cellIndex[cellMap[fileIndex]] + 32*32*sizeof(unsigned long) ;
-
-        unsigned lengthOfBucket;
-        unsigned currentSizeOfResult = result.size();
-        localStream->seekg(position);
-        localStream->read(static_cast<char*>(static_cast<void*>(&(lengthOfBucket))), sizeof(unsigned));
-        result.resize(currentSizeOfResult+lengthOfBucket);
-        localStream->read(static_cast<char*>(static_cast<void*>(&result[currentSizeOfResult])), lengthOfBucket*sizeof(_GridEdge));
-    }
-
-#ifndef ROUTED
-    inline void AddEdge(const _GridEdge & edge) {
-        std::vector<BresenhamPixel> indexList;
-        GetListOfIndexesForEdgeAndGridSize(edge.startCoord, edge.targetCoord, indexList);
-        for(unsigned i = 0; i < indexList.size(); ++i) {
-            entries.push_back(GridEntry(edge, indexList[i].first, indexList[i].second));
-        }
-    }
-#endif
-
-    inline double ComputeDistance(const _Coordinate& inputPoint, const _Coordinate& source, const _Coordinate& target, _Coordinate& nearest, double *r) {
-//        INFO("comparing point " << inputPoint << " to edge [" << source << "-" << target << "]");
-        const double x = static_cast<double>(inputPoint.lat);
-        const double y = static_cast<double>(inputPoint.lon);
-        const double a = static_cast<double>(source.lat);
-        const double b = static_cast<double>(source.lon);
-        const double c = static_cast<double>(target.lat);
-        const double d = static_cast<double>(target.lon);
-        double p,q,mX,nY;
-//        INFO("x=" << x << ", y=" << y << ", a=" << a << ", b=" << b << ", c=" << c << ", d=" << d);
-        if(fabs(a-c) > FLT_EPSILON){
-            const double m = (d-b)/(c-a); // slope
-            // Projection of (x,y) on line joining (a,b) and (c,d)
-            p = ((x + (m*y)) + (m*m*a - m*b))/(1. + m*m);
-            q = b + m*(p - a);
-        }
-        else{
-            p = c;
-            q = y;
-        }
-        nY = (d*p - c*q)/(a*d - b*c);
-        mX = (p - nY*a)/c;// These values are actually n/m+n and m/m+n , we neednot calculate the values of m an n as we are just interested in the ratio
-//        INFO("p=" << p << ", q=" << q << ", nY=" << nY << ", mX=" << mX);
-        if(std::isnan(mX)) {
-            *r = (target == inputPoint) ? 1. : 0.;
-        } else {
-            *r = mX;
-        }
-//        INFO("r=" << *r);
-        if(*r<=0.){
-            nearest.lat = source.lat;
-            nearest.lon = source.lon;
-//            INFO("a returning distance " << ((b - y)*(b - y) + (a - x)*(a - x)))
-            return ((b - y)*(b - y) + (a - x)*(a - x));
-        }
-        else if(*r >= 1.){
-            nearest.lat = target.lat;
-            nearest.lon = target.lon;
-//            INFO("b returning distance " << ((d - y)*(d - y) + (c - x)*(c - x)))
-
-            return ((d - y)*(d - y) + (c - x)*(c - x));
-        }
-        // point lies in between
-        nearest.lat = p;
-        nearest.lon = q;
-//        INFO("c returning distance " << (p-x)*(p-x) + (q-y)*(q-y))
-
-        return (p-x)*(p-x) + (q-y)*(q-y);
-    }
-
-    inline void GetListOfIndexesForEdgeAndGridSize(const _Coordinate& start, const _Coordinate& target, std::vector<BresenhamPixel> &indexList) const {
-        double lat1 = start.lat/100000.;
-        double lon1 = start.lon/100000.;
-
-        double x1 = ( lon1 + 180.0 ) / 360.0;
-        double y1 = ( lat1 + 180.0 ) / 360.0;
-
-        double lat2 = target.lat/100000.;
-        double lon2 = target.lon/100000.;
-
-        double x2 = ( lon2 + 180.0 ) / 360.0;
-        double y2 = ( lat2 + 180.0 ) / 360.0;
-
-        Bresenham(x1*32768, y1*32768, x2*32768, y2*32768, indexList);
-        BOOST_FOREACH(BresenhamPixel & pixel, indexList) {
-            int fileIndex = (pixel.second-1)*32768 + pixel.first;
-            int ramIndex = GetRAMIndexFromFileIndex(fileIndex);
-            pixel.first = fileIndex;
-            pixel.second = ramIndex;
-        }
-    }
-
-    inline unsigned GetFileIndexForLatLon(const int lt, const int ln) {
-        double lat = lt/100000.;
-        double lon = ln/100000.;
-
-        double x = ( lon + 180.0 ) / 360.0;
-        double y = ( lat + 180.0 ) / 360.0;
-
-        if( x>1.0 || x < 0.)
-            return UINT_MAX;
-        if( y>1.0 || y < 0.)
-            return UINT_MAX;
-
-        unsigned line = (32768 * (32768-1))*y;
-        line = line - (line % 32768);
-        assert(line % 32768 == 0);
-        unsigned column = 32768.*x;
-        unsigned fileIndex = line+column;
-        return fileIndex;
-    }
-
-    inline unsigned GetRAMIndexFromFileIndex(const int fileIndex) const {
-        unsigned fileLine = fileIndex / 32768;
-        fileLine = fileLine / 32;
-        fileLine = fileLine * 1024;
-        unsigned fileColumn = (fileIndex % 32768);
-        fileColumn = fileColumn / 32;
-        unsigned ramIndex = fileLine + fileColumn;
-        assert(ramIndex < 1024*1024);
-        return ramIndex;
-    }
-
-    const static unsigned long END_OF_BUCKET_DELIMITER = UINT_MAX;
-
-    std::ofstream indexOutFile;
-    std::ifstream ramInFile;
-#ifndef ROUTED
-    stxxl::vector<GridEntry> entries;
-#endif
-    std::vector<unsigned long> ramIndexTable; //8 MB for first level index in RAM
-    std::string iif;
-    //    LRUCache<int,std::vector<unsigned> > cellCache;
-    //    LRUCache<int,std::vector<_Edge> > fileCache;
-};
-}
-
-typedef NNGrid::NNGrid<false> ReadOnlyGrid;
-typedef NNGrid::NNGrid<true > WritableGrid;
-
-#endif /* NNGRID_H_ */

DataStructures/NodeCoords.h

@@ -1,69 +0,0 @@
-/*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
-
-#ifndef _NODE_COORDS_H
-#define _NODE_COORDS_H
-
-#include <cassert>
-#include <cstddef>
-#include <climits>
-#include <limits>
-
-#include "../typedefs.h"
-
-template<typename NodeT>
-struct NodeCoords {
-	typedef unsigned key_type; 	//type of NodeID
-	typedef int value_type;		//type of lat,lons
-
-	NodeCoords(int _lat, int _lon, NodeT _id) : lat(_lat), lon(_lon), id(_id) {}
-	NodeCoords() : lat(INT_MAX), lon(INT_MAX), id(UINT_MAX) {}
-	int lat;
-	int lon;
-	NodeT id;
-
-	static NodeCoords<NodeT> min_value() {
-		return NodeCoords<NodeT>(-90*100000,-180*100000,std::numeric_limits<NodeT>::min());
-	}
-	static NodeCoords<NodeT> max_value() {
-		return NodeCoords<NodeT>(90*100000, 180*100000, std::numeric_limits<NodeT>::max());
-	}
-
-	value_type operator[](std::size_t n) const {
-		switch(n) {
-		case 1:
-			return lat;
-			break;
-		case 0:
-			return lon;
-			break;
-		default:
-			assert(false);
-			return UINT_MAX;
-			break;
-		}
-		assert(false);
-		return UINT_MAX;
-	}
-};
-
-typedef NodeCoords<NodeID> NodeInfo;
-
-#endif //_NODE_COORDS_H

DataStructures/NodeInformationHelpDesk.h

@@ -1,124 +0,0 @@
-/*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
-
-#ifndef NODEINFORMATIONHELPDESK_H_
-#define NODEINFORMATIONHELPDESK_H_
-
-#include <fstream>
-#include <iostream>
-#include <vector>
-
-#include "../typedefs.h"
-#include "../DataStructures/QueryEdge.h"
-#include "NNGrid.h"
-#include "PhantomNodes.h"
-#include "NodeCoords.h"
-
-class NodeInformationHelpDesk{
-public:
-    NodeInformationHelpDesk(const char* ramIndexInput, const char* fileIndexInput, const unsigned _numberOfNodes, const unsigned crc) : numberOfNodes(_numberOfNodes), checkSum(crc) {
-        readOnlyGrid = new ReadOnlyGrid(ramIndexInput,fileIndexInput);
-        assert(0 == coordinateVector.size());
-    }
-
-    //Todo: Shared memory mechanism
-//    NodeInformationHelpDesk(const char* ramIndexInput, const char* fileIndexInput, const unsigned crc) : checkSum(crc) {
-//        readOnlyGrid = new ReadOnlyGrid(ramIndexInput,fileIndexInput);
-//    }
-
-	~NodeInformationHelpDesk() {
-		delete readOnlyGrid;
-	}
-	void initNNGrid(std::ifstream& nodesInstream, std::ifstream& edgesInStream) {
-	    DEBUG("Loading node data");
-		NodeInfo b;
-	    while(!nodesInstream.eof()) {
-			nodesInstream.read((char *)&b, sizeof(NodeInfo));
-			coordinateVector.push_back(_Coordinate(b.lat, b.lon));
-		}
-	    std::vector<_Coordinate>(coordinateVector).swap(coordinateVector);
-	    nodesInstream.close();
-
-        DEBUG("Loading edge data");
-        unsigned numberOfOrigEdges(0);
-        edgesInStream.read((char*)&numberOfOrigEdges, sizeof(unsigned));
-        origEdgeData.resize(numberOfOrigEdges);
-        edgesInStream.read((char*)&(origEdgeData[0]), numberOfOrigEdges*sizeof(OriginalEdgeData));
-        edgesInStream.close();
-        DEBUG("Loaded " << numberOfOrigEdges << " orig edges");
-	    DEBUG("Opening NN indices");
-	    readOnlyGrid->OpenIndexFiles();
-	}
-
-	void initNNGrid() {
-	    readOnlyGrid->OpenIndexFiles();
-	}
-
-	inline int getLatitudeOfNode(const unsigned id) const {
-	    const NodeID node = origEdgeData.at(id).viaNode;
-	    return coordinateVector.at(node).lat;
-	}
-
-	inline int getLongitudeOfNode(const unsigned id) const {
-        const NodeID node = origEdgeData.at(id).viaNode;
-	    return coordinateVector.at(node).lon;
-	}
-
-	inline unsigned getNameIndexFromEdgeID(const unsigned id) const {
-	    return origEdgeData.at(id).nameID;
-	}
-
-    inline TurnInstruction getTurnInstructionFromEdgeID(const unsigned id) const {
-        return origEdgeData.at(id).turnInstruction;
-    }
-
-    inline NodeID getNumberOfNodes() const { return numberOfNodes; }
-	inline NodeID getNumberOfNodes2() const { return coordinateVector.size(); }
-
-	inline bool FindNearestNodeCoordForLatLon(const _Coordinate& coord, _Coordinate& result) const {
-		return readOnlyGrid->FindNearestCoordinateOnEdgeInNodeBasedGraph(coord, result);
-	}
-
-	inline bool FindPhantomNodeForCoordinate( const _Coordinate & location, PhantomNode & resultNode, const unsigned zoomLevel) const {
-	    return readOnlyGrid->FindPhantomNodeForCoordinate(location, resultNode, zoomLevel);
-	}
-
-	inline void FindRoutingStarts(const _Coordinate &start, const _Coordinate &target, PhantomNodes & phantomNodes, const unsigned zoomLevel) const {
-		readOnlyGrid->FindRoutingStarts(start, target, phantomNodes, zoomLevel);
-	}
-
-	inline void FindNearestPointOnEdge(const _Coordinate & input, _Coordinate& output){
-	    readOnlyGrid->FindNearestPointOnEdge(input, output);
-	}
-
-	inline unsigned GetCheckSum() const {
-	    return checkSum;
-	}
-
-private:
-	std::vector<_Coordinate> coordinateVector;
-    std::vector<OriginalEdgeData> origEdgeData;
-
-	ReadOnlyGrid * readOnlyGrid;
-	const unsigned numberOfNodes;
-	const unsigned checkSum;
-};
-
-#endif /*NODEINFORMATIONHELPDESK_H_*/

DataStructures/Percent.h

@@ -1,31 +1,37 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 PERCENT_H
 #define PERCENT_H
 
+#include "../Util/OpenMPWrapper.h"
 #include <iostream>
 
-
-class Percent
-{
+class Percent {
 public:
     /**
      * Constructor.
@@ -56,8 +62,7 @@ public:
             std::cout << " 100%" << std::endl;
     }
 
-    void printIncrement()
-    {
+    void printIncrement() {
 #pragma omp atomic
         ++_current_value;
         printStatus(_current_value);

DataStructures/PhantomNodes.h

@@ -1,22 +1,29 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 PHANTOMNODES_H_
 #define PHANTOMNODES_H_
@@ -24,13 +31,20 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #include "Coordinate.h"
 
 struct PhantomNode {
-    PhantomNode() : edgeBasedNode(UINT_MAX), nodeBasedEdgeNameID(UINT_MAX), weight1(INT_MAX), weight2(INT_MAX), ratio(0.) {}
+    PhantomNode() :
+        edgeBasedNode(UINT_MAX),
+        nodeBasedEdgeNameID(UINT_MAX),
+        weight1(INT_MAX),
+        weight2(INT_MAX),
+        ratio(0.)
+    { }
+
     NodeID edgeBasedNode;
     unsigned nodeBasedEdgeNameID;
     int weight1;
     int weight2;
     double ratio;
-    _Coordinate location;
+    FixedPointCoordinate location;
     void Reset() {
         edgeBasedNode = UINT_MAX;
         nodeBasedEdgeNameID = UINT_MAX;
@@ -85,10 +99,4 @@ inline std::ostream& operator<<(std::ostream &out, const PhantomNode & pn){
     return out;
 }
 
-struct NodesOfEdge {
-    NodeID edgeBasedNode;
-    double ratio;
-    _Coordinate projectedPoint;
-};
-
 #endif /* PHANTOMNODES_H_ */

DataStructures/QueryEdge.h

@@ -1,24 +1,29 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 QUERYEDGE_H_
 #define QUERYEDGE_H_
@@ -29,7 +34,11 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #include <climits>
 
 struct OriginalEdgeData{
-    explicit OriginalEdgeData(NodeID v, unsigned n, TurnInstruction t) : viaNode(v), nameID(n), turnInstruction(t) {}
+    explicit OriginalEdgeData(
+        NodeID viaNode,
+        unsigned nameID,
+        TurnInstruction turnInstruction
+    ) : viaNode(viaNode), nameID(nameID), turnInstruction(turnInstruction) {}
     OriginalEdgeData() : viaNode(UINT_MAX), nameID(UINT_MAX), turnInstruction(UCHAR_MAX) {}
     NodeID viaNode;
     unsigned nameID;
@@ -41,28 +50,17 @@ struct QueryEdge {
     NodeID target;
     struct EdgeData {
         NodeID id:31;
-        int distance:30;
         bool shortcut:1;
+        int distance:30;
         bool forward:1;
         bool backward:1;
     } data;
-    bool operator<( const QueryEdge& right ) const {
-        if ( source != right.source )
-            return source < right.source;
-        return target < right.target;
-    }
 
-    //sorts by source and other attributes
-    static bool CompareBySource( const QueryEdge& left, const QueryEdge& right ) {
-        if ( left.source != right.source )
-            return left.source < right.source;
-        int l = ( left.data.forward ? -1 : 0 ) + ( left.data.backward ? -1 : 0 );
-        int r = ( right.data.forward ? -1 : 0 ) + ( right.data.backward ? -1 : 0 );
-        if ( l != r )
-            return l < r;
-        if ( left.target != right.target )
-            return left.target < right.target;
-        return left.data.distance < right.data.distance;
+    bool operator<( const QueryEdge& right ) const {
+        if ( source != right.source ) {
+            return source < right.source;
+        }
+        return target < right.target;
     }
 
     bool operator== ( const QueryEdge& right ) const {

DataStructures/QueryNode.h

@@ -0,0 +1,85 @@
+/*
+
+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 _NODE_COORDS_H
+#define _NODE_COORDS_H
+
+#include "Coordinate.h"
+#include "../typedefs.h"
+
+#include <boost/assert.hpp>
+
+#include <cstddef>
+#include <climits>
+
+#include <limits>
+
+struct NodeInfo {
+	typedef NodeID key_type; 	//type of NodeID
+	typedef int value_type;		//type of lat,lons
+
+	NodeInfo(int _lat, int _lon, NodeID _id) : lat(_lat), lon(_lon), id(_id) {}
+	NodeInfo() : lat(INT_MAX), lon(INT_MAX), id(UINT_MAX) {}
+	int lat;
+	int lon;
+	NodeID id;
+
+	static NodeInfo min_value() {
+		return NodeInfo(
+			 -90*COORDINATE_PRECISION,
+			-180*COORDINATE_PRECISION,
+			std::numeric_limits<NodeID>::min()
+		);
+	}
+
+	static NodeInfo max_value() {
+		return NodeInfo(
+			 90*COORDINATE_PRECISION,
+			180*COORDINATE_PRECISION,
+			std::numeric_limits<NodeID>::max()
+			);
+	}
+
+	value_type operator[](const std::size_t n) const {
+		switch(n) {
+		case 1:
+			return lat;
+			break;
+		case 0:
+			return lon;
+			break;
+		default:
+			BOOST_ASSERT_MSG(false, "should not happen");
+			return UINT_MAX;
+			break;
+		}
+		BOOST_ASSERT_MSG(false, "should not happen");
+		return UINT_MAX;
+	}
+};
+
+#endif //_NODE_COORDS_H

DataStructures/RawRouteData.h

@@ -0,0 +1,56 @@
+/*
+
+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 RAWROUTEDATA_H_
+#define RAWROUTEDATA_H_
+
+#include "../DataStructures/Coordinate.h"
+#include "../DataStructures/PhantomNodes.h"
+#include "../typedefs.h"
+
+#include <vector>
+
+struct _PathData {
+    _PathData(NodeID no, unsigned na, unsigned tu, unsigned dur) : node(no), nameID(na), durationOfSegment(dur), turnInstruction(tu) { }
+    NodeID node;
+    unsigned nameID;
+    unsigned durationOfSegment;
+    short turnInstruction;
+};
+
+struct RawRouteData {
+    std::vector< _PathData > computedShortestPath;
+    std::vector< _PathData > computedAlternativePath;
+    std::vector< PhantomNodes > segmentEndCoordinates;
+    std::vector< FixedPointCoordinate > rawViaNodeCoordinates;
+    unsigned checkSum;
+    int lengthOfShortestPath;
+    int lengthOfAlternativePath;
+    RawRouteData() : checkSum(UINT_MAX), lengthOfShortestPath(INT_MAX), lengthOfAlternativePath(INT_MAX) {}
+};
+
+#endif /* RAWROUTEDATA_H_ */

DataStructures/Restriction.h

@@ -1,97 +1,146 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 RESTRICTION_H_
 #define RESTRICTION_H_
 
+#include "../typedefs.h"
 #include <climits>
 
-struct _Restriction {
+struct TurnRestriction {
     NodeID viaNode;
     NodeID fromNode;
     NodeID toNode;
     struct Bits { //mostly unused
-        Bits() : isOnly(false), unused1(false), unused2(false), unused3(false), unused4(false), unused5(false), unused6(false), unused7(false) {}
-        char isOnly:1;
-        char unused1:1;
-        char unused2:1;
-        char unused3:1;
-        char unused4:1;
-        char unused5:1;
-        char unused6:1;
-        char unused7:1;
+        Bits()
+         :
+            isOnly(false),
+            unused1(false),
+            unused2(false),
+            unused3(false),
+            unused4(false),
+            unused5(false),
+            unused6(false),
+            unused7(false)
+        { }
+
+        bool isOnly:1;
+        bool unused1:1;
+        bool unused2:1;
+        bool unused3:1;
+        bool unused4:1;
+        bool unused5:1;
+        bool unused6:1;
+        bool unused7:1;
     } flags;
 
-    _Restriction(NodeID vn) : viaNode(vn), fromNode(UINT_MAX), toNode(UINT_MAX) { }
-    _Restriction(bool isOnly = false) : viaNode(UINT_MAX), fromNode(UINT_MAX), toNode(UINT_MAX) {
+    TurnRestriction(NodeID viaNode) :
+        viaNode(viaNode),
+        fromNode(UINT_MAX),
+        toNode(UINT_MAX) {
+
+    }
+
+    TurnRestriction(const bool isOnly = false) :
+        viaNode(UINT_MAX),
+        fromNode(UINT_MAX),
+        toNode(UINT_MAX) {
         flags.isOnly = isOnly;
     }
 };
 
-inline bool CmpRestrictionByFrom ( _Restriction a, _Restriction b) { return (a.fromNode < b.fromNode);  }
-
-struct _RawRestrictionContainer {
-    _Restriction restriction;
+struct InputRestrictionContainer {
     EdgeID fromWay;
     EdgeID toWay;
     unsigned viaNode;
+    TurnRestriction restriction;
 
-    _RawRestrictionContainer(EdgeID f, EdgeID t, NodeID vn, unsigned vw) : fromWay(f), toWay(t), viaNode(vw) { restriction.viaNode = vn;}
-    _RawRestrictionContainer(bool isOnly = false) : fromWay(UINT_MAX), toWay(UINT_MAX), viaNode(UINT_MAX) { restriction.flags.isOnly = isOnly;}
-
-    static _RawRestrictionContainer min_value() {
-        return _RawRestrictionContainer(0, 0, 0, 0);
+    InputRestrictionContainer(
+        EdgeID fromWay,
+        EdgeID toWay,
+        NodeID vn,
+        unsigned vw
+    ) :
+        fromWay(fromWay),
+        toWay(toWay),
+        viaNode(vw)
+    {
+        restriction.viaNode = vn;
     }
-    static _RawRestrictionContainer max_value() {
-        return _RawRestrictionContainer(UINT_MAX, UINT_MAX, UINT_MAX, UINT_MAX);
+    InputRestrictionContainer(
+        bool isOnly = false
+    ) :
+        fromWay(UINT_MAX),
+        toWay(UINT_MAX),
+        viaNode(UINT_MAX)
+    {
+        restriction.flags.isOnly = isOnly;
+    }
+
+    static InputRestrictionContainer min_value() {
+        return InputRestrictionContainer(0, 0, 0, 0);
+    }
+    static InputRestrictionContainer max_value() {
+        return InputRestrictionContainer(UINT_MAX, UINT_MAX, UINT_MAX, UINT_MAX);
     }
 };
 
-struct CmpRestrictionContainerByFrom: public std::binary_function<_RawRestrictionContainer, _RawRestrictionContainer, bool> {
-    typedef _RawRestrictionContainer value_type;
-    bool operator ()  (const _RawRestrictionContainer & a, const _RawRestrictionContainer & b) const {
+struct CmpRestrictionContainerByFrom :
+    public std::binary_function<InputRestrictionContainer, InputRestrictionContainer, bool>
+{
+    typedef InputRestrictionContainer value_type;
+    inline bool operator()(
+        const InputRestrictionContainer & a,
+        const InputRestrictionContainer & b
+    ) const {
         return a.fromWay < b.fromWay;
     }
-    value_type max_value()  {
-        return _RawRestrictionContainer::max_value();
+    inline value_type max_value() const {
+        return InputRestrictionContainer::max_value();
     }
-    value_type min_value() {
-        return _RawRestrictionContainer::min_value();
+    inline value_type min_value() const {
+        return InputRestrictionContainer::min_value();
     }
 };
 
-struct CmpRestrictionContainerByTo: public std::binary_function<_RawRestrictionContainer, _RawRestrictionContainer, bool> {
-    typedef _RawRestrictionContainer value_type;
-    bool operator ()  (const _RawRestrictionContainer & a, const _RawRestrictionContainer & b) const {
+struct CmpRestrictionContainerByTo: public std::binary_function<InputRestrictionContainer, InputRestrictionContainer, bool> {
+    typedef InputRestrictionContainer value_type;
+    inline bool operator ()(
+        const InputRestrictionContainer & a,
+        const InputRestrictionContainer & b
+    ) const {
         return a.toWay < b.toWay;
     }
-    value_type max_value()  {
-        return _RawRestrictionContainer::max_value();
+    value_type max_value() const {
+        return InputRestrictionContainer::max_value();
     }
-    value_type min_value() {
-        return _RawRestrictionContainer::min_value();
+    value_type min_value() const {
+        return InputRestrictionContainer::min_value();
     }
 };
 
-
-
 #endif /* RESTRICTION_H_ */

DataStructures/SearchEngine.h

@@ -1,171 +1,67 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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.
 
-#ifndef SEARCHENGINE_H_
-#define SEARCHENGINE_H_
+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.
 
-#include <climits>
-#include <deque>
-#include "SimpleStack.h"
+*/
 
-#include <boost/thread.hpp>
+#ifndef SEARCHENGINE_H
+#define SEARCHENGINE_H
 
-#include "BinaryHeap.h"
-#include "NodeInformationHelpDesk.h"
+#include "Coordinate.h"
+#include "SearchEngineData.h"
 #include "PhantomNodes.h"
+#include "QueryEdge.h"
 #include "../RoutingAlgorithms/AlternativePathRouting.h"
-#include "../RoutingAlgorithms/BasicRoutingInterface.h"
 #include "../RoutingAlgorithms/ShortestPathRouting.h"
 
 #include "../Util/StringUtil.h"
 #include "../typedefs.h"
 
-struct _HeapData {
-	NodeID parent;
-	_HeapData( NodeID p ) : parent(p) { }
-};
+#include <boost/assert.hpp>
 
-typedef boost::thread_specific_ptr<BinaryHeap< NodeID, NodeID, int, _HeapData, UnorderedMapStorage<NodeID, int> > > SearchEngineHeapPtr;
+#include <climits>
+#include <string>
+#include <vector>
 
-template<class EdgeData, class GraphT>
-struct SearchEngineData {
-    typedef SearchEngineHeapPtr HeapPtr;
-    typedef GraphT Graph;
-    SearchEngineData(GraphT * g, NodeInformationHelpDesk * nh, std::vector<string> & n) :graph(g), nodeHelpDesk(nh), names(n) {}
-    const GraphT * graph;
-    NodeInformationHelpDesk * nodeHelpDesk;
-    std::vector<string> & names;
-    static HeapPtr forwardHeap;
-    static HeapPtr backwardHeap;
-    static HeapPtr forwardHeap2;
-    static HeapPtr backwardHeap2;
-    static HeapPtr forwardHeap3;
-    static HeapPtr backwardHeap3;
-
-    inline void InitializeOrClearFirstThreadLocalStorage() {
-        if(!forwardHeap.get()) {
-            forwardHeap.reset(new BinaryHeap< NodeID, NodeID, int, _HeapData, UnorderedMapStorage<NodeID, int> >(nodeHelpDesk->getNumberOfNodes()));
-        }
-        else
-            forwardHeap->Clear();
-
-        if(!backwardHeap.get()) {
-            backwardHeap.reset(new BinaryHeap< NodeID, NodeID, int, _HeapData, UnorderedMapStorage<NodeID, int> >(nodeHelpDesk->getNumberOfNodes()));
-        }
-        else
-            backwardHeap->Clear();
-    }
-
-    inline void InitializeOrClearSecondThreadLocalStorage() {
-        if(!forwardHeap2.get()) {
-            forwardHeap2.reset(new BinaryHeap< NodeID, NodeID, int, _HeapData, UnorderedMapStorage<NodeID, int> >(nodeHelpDesk->getNumberOfNodes()));
-        }
-        else
-            forwardHeap2->Clear();
-
-        if(!backwardHeap2.get()) {
-            backwardHeap2.reset(new BinaryHeap< NodeID, NodeID, int, _HeapData, UnorderedMapStorage<NodeID, int> >(nodeHelpDesk->getNumberOfNodes()));
-        }
-        else
-            backwardHeap2->Clear();
-    }
-
-    inline void InitializeOrClearThirdThreadLocalStorage() {
-        if(!forwardHeap3.get()) {
-            forwardHeap3.reset(new BinaryHeap< NodeID, NodeID, int, _HeapData, UnorderedMapStorage<NodeID, int> >(nodeHelpDesk->getNumberOfNodes()));
-        }
-        else
-            forwardHeap3->Clear();
-
-        if(!backwardHeap3.get()) {
-            backwardHeap3.reset(new BinaryHeap< NodeID, NodeID, int, _HeapData, UnorderedMapStorage<NodeID, int> >(nodeHelpDesk->getNumberOfNodes()));
-        }
-        else
-            backwardHeap3->Clear();
-    }
-};
-
-template<class EdgeData, class GraphT>
+template<class DataFacadeT>
 class SearchEngine {
 private:
-    typedef SearchEngineData<EdgeData, GraphT> SearchEngineDataT;
-    SearchEngineDataT _queryData;
-
-	inline double absDouble(double input) { if(input < 0) return input*(-1); else return input;}
+    DataFacadeT * facade;
+    SearchEngineData engine_working_data;
 public:
-    ShortestPathRouting<SearchEngineDataT> shortestPath;
-    AlternativeRouting<SearchEngineDataT> alternativePaths;
+    ShortestPathRouting<DataFacadeT> shortest_path;
+    AlternativeRouting <DataFacadeT> alternative_path;
 
-    SearchEngine(GraphT * g, NodeInformationHelpDesk * nh, std::vector<string> & n) :
-	    _queryData(g, nh, n),
-	    shortestPath(_queryData),
-	    alternativePaths(_queryData)
-	{}
-	~SearchEngine() {}
+    SearchEngine( DataFacadeT * facade )
+     :
+        facade             (facade),
+        shortest_path      (facade, engine_working_data),
+        alternative_path   (facade, engine_working_data)
+    {}
 
-	inline void GetCoordinatesForNodeID(NodeID id, _Coordinate& result) const {
-		result.lat = _queryData.nodeHelpDesk->getLatitudeOfNode(id);
-		result.lon = _queryData.nodeHelpDesk->getLongitudeOfNode(id);
-	}
-
-	inline void FindRoutingStarts(const _Coordinate & start, const _Coordinate & target, PhantomNodes & routingStarts) const {
-	    _queryData.nodeHelpDesk->FindRoutingStarts(start, target, routingStarts);
-	}
-
-	inline void FindPhantomNodeForCoordinate(const _Coordinate & location, PhantomNode & result, unsigned zoomLevel) const {
-	    _queryData.nodeHelpDesk->FindPhantomNodeForCoordinate(location, result, zoomLevel);
-	}
-
-	inline NodeID GetNameIDForOriginDestinationNodeID(const NodeID s, const NodeID t) const {
-		if(s == t)
-			return 0;
-
-		EdgeID e = _queryData.graph->FindEdge(s, t);
-		if(e == UINT_MAX)
-			e = _queryData.graph->FindEdge( t, s );
-		if(UINT_MAX == e) {
-			return 0;
-		}
-		assert(e != UINT_MAX);
-		const EdgeData ed = _queryData.graph->GetEdgeData(e);
-		return ed.via;
-	}
-
-	inline std::string GetEscapedNameForNameID(const unsigned nameID) const {
-	    return ((nameID >= _queryData.names.size() || nameID == 0) ? std::string("") : HTMLEntitize(_queryData.names.at(nameID)));
-	}
-
-	inline std::string GetEscapedNameForEdgeBasedEdgeID(const unsigned edgeID) const {
-		const unsigned nameID = _queryData.graph->GetEdgeData(edgeID).nameID1;
-		return GetEscapedNameForNameID(nameID);
-	}
+    ~SearchEngine() {}
 
 };
 
-template<class EdgeData, class GraphT> SearchEngineHeapPtr SearchEngineData<EdgeData, GraphT>::forwardHeap;
-template<class EdgeData, class GraphT> SearchEngineHeapPtr SearchEngineData<EdgeData, GraphT>::backwardHeap;
-
-template<class EdgeData, class GraphT> SearchEngineHeapPtr SearchEngineData<EdgeData, GraphT>::forwardHeap2;
-template<class EdgeData, class GraphT> SearchEngineHeapPtr SearchEngineData<EdgeData, GraphT>::backwardHeap2;
-
-template<class EdgeData, class GraphT> SearchEngineHeapPtr SearchEngineData<EdgeData, GraphT>::forwardHeap3;
-template<class EdgeData, class GraphT> SearchEngineHeapPtr SearchEngineData<EdgeData, GraphT>::backwardHeap3;
-
-#endif /* SEARCHENGINE_H_ */
+#endif // SEARCHENGINE_H

DataStructures/SearchEngineData.cpp

@@ -0,0 +1,67 @@
+/*
+
+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.
+
+*/
+
+#include "SearchEngineData.h"
+
+void SearchEngineData::InitializeOrClearFirstThreadLocalStorage(const unsigned number_of_nodes) {
+    if(!forwardHeap.get()) {
+        forwardHeap.reset(new QueryHeap(number_of_nodes));
+    } else {
+        forwardHeap->Clear();
+    }
+    if(!backwardHeap.get()) {
+        backwardHeap.reset(new QueryHeap(number_of_nodes));
+    } else {
+        backwardHeap->Clear();
+    }
+}
+
+void SearchEngineData::InitializeOrClearSecondThreadLocalStorage(const unsigned number_of_nodes) {
+    if(!forwardHeap2.get()) {
+        forwardHeap2.reset(new QueryHeap(number_of_nodes));
+    } else {
+        forwardHeap2->Clear();
+    }
+    if(!backwardHeap2.get()) {
+        backwardHeap2.reset(new QueryHeap(number_of_nodes));
+     } else {
+        backwardHeap2->Clear();
+    }
+}
+
+void SearchEngineData::InitializeOrClearThirdThreadLocalStorage(const unsigned number_of_nodes) {
+    if(!forwardHeap3.get()) {
+        forwardHeap3.reset(new QueryHeap(number_of_nodes));
+    } else {
+        forwardHeap3->Clear();
+    }
+    if(!backwardHeap3.get()) {
+        backwardHeap3.reset(new QueryHeap(number_of_nodes));
+    } else {
+        backwardHeap3->Clear();
+    }
+}

DataStructures/SearchEngineData.h

@@ -0,0 +1,67 @@
+/*
+
+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 SEARCH_ENGINE_DATA_H
+#define SEARCH_ENGINE_DATA_H
+
+#include "BinaryHeap.h"
+#include "QueryEdge.h"
+#include "StaticGraph.h"
+
+#include "../typedefs.h"
+
+#include <boost/thread.hpp>
+
+#include <string>
+#include <vector>
+
+struct _HeapData {
+    NodeID parent;
+    _HeapData( NodeID p ) : parent(p) { }
+};
+
+// typedef StaticGraph<QueryEdge::EdgeData> QueryGraph;
+
+struct SearchEngineData {
+    typedef BinaryHeap< NodeID, NodeID, int, _HeapData, UnorderedMapStorage<NodeID, int> > QueryHeap;
+    typedef boost::thread_specific_ptr<QueryHeap> SearchEngineHeapPtr;
+
+    static SearchEngineHeapPtr forwardHeap;
+    static SearchEngineHeapPtr backwardHeap;
+    static SearchEngineHeapPtr forwardHeap2;
+    static SearchEngineHeapPtr backwardHeap2;
+    static SearchEngineHeapPtr forwardHeap3;
+    static SearchEngineHeapPtr backwardHeap3;
+
+    void InitializeOrClearFirstThreadLocalStorage(const unsigned number_of_nodes);
+
+    void InitializeOrClearSecondThreadLocalStorage(const unsigned number_of_nodes);
+
+    void InitializeOrClearThirdThreadLocalStorage(const unsigned number_of_nodes);
+};
+
+#endif // SEARCH_ENGINE_DATA_H

DataStructures/SegmentInformation.h

@@ -1,41 +1,50 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 SEGMENTINFORMATION_H_
 #define SEGMENTINFORMATION_H_
 
+#include "Coordinate.h"
+#include "TurnInstructions.h"
+#include "../typedefs.h"
+
 #include <climits>
 
-#include "TurnInstructions.h"
-
 struct SegmentInformation {
-    _Coordinate location;
+    FixedPointCoordinate location;
     NodeID nameID;
     double length;
     unsigned duration;
     double bearing;
     TurnInstruction turnInstruction;
     bool necessary;
-    SegmentInformation(const _Coordinate & loc, const NodeID nam, const double len, const unsigned dur, const TurnInstruction tInstr, const bool nec) :
+    SegmentInformation(const FixedPointCoordinate & loc, const NodeID nam, const double len, const unsigned dur, const TurnInstruction tInstr, const bool nec) :
             location(loc), nameID(nam), length(len), duration(dur), bearing(0.), turnInstruction(tInstr), necessary(nec) {}
-    SegmentInformation(const _Coordinate & loc, const NodeID nam, const double len, const unsigned dur, const TurnInstruction tInstr) :
+    SegmentInformation(const FixedPointCoordinate & loc, const NodeID nam, const double len, const unsigned dur, const TurnInstruction tInstr) :
         location(loc), nameID(nam), length(len), duration(dur), bearing(0.), turnInstruction(tInstr), necessary(tInstr != 0) {}
 };
 

DataStructures/SharedMemoryFactory.h

@@ -0,0 +1,250 @@
+/*
+
+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 SHARED_MEMORY_FACTORY_H
+#define SHARED_MEMORY_FACTORY_H
+
+#include "../Util/OSRMException.h"
+#include "../Util/SimpleLogger.h"
+
+#include <boost/noncopyable.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/filesystem/fstream.hpp>
+#include <boost/integer.hpp>
+#include <boost/interprocess/mapped_region.hpp>
+#include <boost/interprocess/xsi_shared_memory.hpp>
+
+#ifdef __linux__
+#include <sys/ipc.h>
+#include <sys/shm.h>
+#endif
+
+#include <cstring>
+
+#include <algorithm>
+#include <exception>
+
+struct OSRMLockFile {
+	boost::filesystem::path operator()() {
+		boost::filesystem::path temp_dir =
+			boost::filesystem::temp_directory_path();
+	    boost::filesystem::path lock_file = temp_dir / "osrm.lock";
+	    return lock_file;
+	}
+};
+
+class SharedMemory : boost::noncopyable {
+
+	//Remove shared memory on destruction
+	class shm_remove : boost::noncopyable {
+	private:
+		int m_shmid;
+		bool m_initialized;
+	public:
+		void SetID(int shmid) {
+		 	m_shmid = shmid;
+		 	m_initialized = true;
+		}
+
+		shm_remove() : m_shmid(INT_MIN), m_initialized(false) {}
+
+		~shm_remove(){
+			if(m_initialized) {
+				SimpleLogger().Write(logDEBUG) <<
+					"automatic memory deallocation";
+				if(!boost::interprocess::xsi_shared_memory::remove(m_shmid)) {
+					SimpleLogger().Write(logDEBUG) << "could not deallocate id " << m_shmid;
+				}
+			}
+		}
+	};
+
+public:
+	void * Ptr() const {
+		return region.get_address();
+	}
+
+	template<typename IdentifierT >
+	SharedMemory(
+		const boost::filesystem::path & lock_file,
+		const IdentifierT id,
+		const uint64_t size = 0,
+		bool read_write = false,
+		bool remove_prev = true
+	) : key(
+			lock_file.string().c_str(),
+			id
+	) {
+    	if( 0 == size ){ //read_only
+    		shm = boost::interprocess::xsi_shared_memory (
+    			boost::interprocess::open_only,
+    			key
+			);
+
+    		region = boost::interprocess::mapped_region (
+    			shm,
+    			(
+    				read_write ?
+    					boost::interprocess::read_write :
+    					boost::interprocess::read_only
+    			)
+			);
+    	} else { //writeable pointer
+    		//remove previously allocated mem
+    		if( remove_prev ) {
+	    		Remove(key);
+	    	}
+    		shm = boost::interprocess::xsi_shared_memory (
+    			boost::interprocess::open_or_create,
+    			key,
+    			size
+    		);
+#ifdef __linux__
+			if( -1 == shmctl(shm.get_shmid(), SHM_LOCK, 0) ) {
+				if( ENOMEM == errno ) {
+					SimpleLogger().Write(logWARNING) <<
+						"could not lock shared memory to RAM";
+				}
+			}
+#endif
+		    region = boost::interprocess::mapped_region (
+		    	shm,
+		    	boost::interprocess::read_write
+	    	);
+
+ 			remover.SetID( shm.get_shmid() );
+ 			SimpleLogger().Write(logDEBUG) <<
+ 				"writeable memory allocated " << size << " bytes";
+    	}
+	}
+
+	template<typename IdentifierT >
+	static bool RegionExists(
+		const IdentifierT id
+	) {
+		bool result = true;
+		try {
+			OSRMLockFile lock_file;
+			boost::interprocess::xsi_key key( lock_file().string().c_str(), id );
+			result = RegionExists(key);
+		} catch(...) {
+			result = false;
+		}
+		return result;
+	}
+
+	template<typename IdentifierT >
+	static bool Remove(
+		const IdentifierT id
+	) {
+		OSRMLockFile lock_file;
+		boost::interprocess::xsi_key key( lock_file().string().c_str(), id );
+		return Remove(key);
+	}
+
+private:
+	static bool RegionExists( const boost::interprocess::xsi_key &key ) {
+		bool result = true;
+	    try {
+		    boost::interprocess::xsi_shared_memory shm(
+		        boost::interprocess::open_only,
+		        key
+		    );
+	    } catch(...) {
+	    	result = false;
+	    }
+	    return result;
+	}
+
+	static bool Remove(
+		const boost::interprocess::xsi_key &key
+	) {
+		bool ret = false;
+		try{
+			SimpleLogger().Write(logDEBUG) << "deallocating prev memory";
+			boost::interprocess::xsi_shared_memory xsi(
+				boost::interprocess::open_only,
+				key
+			);
+			ret = boost::interprocess::xsi_shared_memory::remove(xsi.get_shmid());
+		} catch(const boost::interprocess::interprocess_exception &e){
+			if(e.get_error_code() != boost::interprocess::not_found_error) {
+				throw;
+			}
+		}
+		return ret;
+	}
+
+	boost::interprocess::xsi_key key;
+	boost::interprocess::xsi_shared_memory shm;
+	boost::interprocess::mapped_region region;
+	shm_remove remover;
+};
+
+template<class LockFileT = OSRMLockFile>
+class SharedMemoryFactory_tmpl : boost::noncopyable {
+public:
+
+	template<typename IdentifierT >
+	static SharedMemory * Get(
+		const IdentifierT & id,
+		const uint64_t size = 0,
+		bool read_write = false,
+		bool remove_prev = true
+	) {
+		try {
+			LockFileT lock_file;
+		    if(!boost::filesystem::exists(lock_file()) ) {
+		    	if( 0 == size ) {
+	      			throw OSRMException("lock file does not exist, exiting");
+	      		} else {
+	      			boost::filesystem::ofstream ofs(lock_file());
+	      			ofs.close();
+	      		}
+	      	}
+			return new SharedMemory(
+				lock_file(),
+				id,
+				size,
+				read_write,
+				remove_prev
+			);
+	   	} catch(const boost::interprocess::interprocess_exception &e){
+    		SimpleLogger().Write(logWARNING) <<
+    			"caught exception: " << e.what() <<
+    			", code " << e.get_error_code();
+    		throw OSRMException(e.what());
+    	}
+	}
+
+private:
+	SharedMemoryFactory_tmpl() {}
+};
+
+typedef SharedMemoryFactory_tmpl<> SharedMemoryFactory;
+
+#endif /* SHARED_MEMORY_POINTER_FACTORY_H */

DataStructures/SharedMemoryVectorWrapper.h

@@ -0,0 +1,139 @@
+/*
+
+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 SHARED_MEMORY_VECTOR_WRAPPER_H
+#define SHARED_MEMORY_VECTOR_WRAPPER_H
+
+#include "../Util/SimpleLogger.h"
+
+#include <boost/assert.hpp>
+#include <boost/type_traits.hpp>
+
+#include <algorithm>
+#include <iterator>
+#include <vector>
+
+template<typename DataT>
+class ShMemIterator : public std::iterator<std::input_iterator_tag, DataT> {
+    DataT * p;
+public:
+    ShMemIterator(DataT * x) : p(x) {}
+    ShMemIterator(const ShMemIterator & mit) : p(mit.p) {}
+    ShMemIterator& operator++() {
+        ++p;
+        return *this;
+    }
+    ShMemIterator operator++(int) {
+        ShMemIterator tmp(*this);
+        operator++();
+        return tmp;
+    }
+    ShMemIterator operator+(std::ptrdiff_t diff) {
+        ShMemIterator tmp(p+diff);
+        return tmp;
+    }
+    bool operator==(const ShMemIterator& rhs) {
+        return p==rhs.p;
+    }
+    bool operator!=(const ShMemIterator& rhs) {
+        return p!=rhs.p;
+    }
+    DataT& operator*() {
+        return *p;
+    }
+};
+
+template<typename DataT>
+class SharedMemoryWrapper {
+private:
+    DataT * m_ptr;
+    std::size_t m_size;
+
+public:
+    SharedMemoryWrapper() :
+        m_ptr(NULL),
+        m_size(0)
+    { }
+
+    SharedMemoryWrapper(DataT * ptr, std::size_t size) :
+        m_ptr(ptr),
+        m_size(size)
+    { }
+
+    void swap( SharedMemoryWrapper<DataT> & other ) {
+        BOOST_ASSERT_MSG(m_size != 0 || other.size() != 0, "size invalid");
+        std::swap( m_size, other.m_size);
+        std::swap( m_ptr , other.m_ptr );
+    }
+
+    // void SetData(const DataT * ptr, const std::size_t size) {
+    //     BOOST_ASSERT_MSG( 0 == m_size, "vector not empty");
+    //     BOOST_ASSERT_MSG( 0 < size   , "new vector empty");
+    //     m_ptr.reset(ptr);
+    //     m_size = size;
+    // }
+
+    DataT & at(const std::size_t index) {
+        return m_ptr[index];
+    }
+
+    const DataT & at(const std::size_t index) const {
+        return m_ptr[index];
+    }
+
+    ShMemIterator<DataT> begin() const {
+        return ShMemIterator<DataT>(m_ptr);
+    }
+
+    ShMemIterator<DataT> end() const {
+        return ShMemIterator<DataT>(m_ptr+m_size);
+    }
+
+    std::size_t size() const { return m_size; }
+
+    DataT & operator[](const unsigned index) {
+        BOOST_ASSERT_MSG(index < m_size, "invalid size");
+        return m_ptr[index];
+    }
+
+    const DataT & operator[](const unsigned index) const {
+        BOOST_ASSERT_MSG(index < m_size, "invalid size");
+        return m_ptr[index];
+    }
+};
+
+template<typename DataT, bool UseSharedMemory>
+struct ShM {
+    typedef typename boost::conditional<
+                     UseSharedMemory,
+                     SharedMemoryWrapper<DataT>,
+                     std::vector<DataT>
+                 >::type vector;
+ };
+
+
+#endif //SHARED_MEMORY_VECTOR_WRAPPER_H

DataStructures/SimpleStack.h

@@ -1,71 +0,0 @@
-/*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
-
-#ifndef SIMPLESTACK_H_
-#define SIMPLESTACK_H_
-
-#include <cassert>
-#include <vector>
-
-template<typename StackItemT, class ContainerT = std::vector<StackItemT> >
-class SimpleStack {
-
-private:
-	int last;
-	ContainerT arr;
-
-public:
-	SimpleStack() : last(-1) {
-	}
-
-	SimpleStack(std::size_t size_hint) : last(-1) {
-		hint(size_hint);
-	}
-
-	inline void hint(std::size_t size_hint) {
-		arr.reserve(size_hint);
-	}
-
-	inline void push(StackItemT t) {
-		++last;
-		arr.push_back(t);
-	}
-
-	inline void pop() {
-		arr.pop_back();
-		--last;
-	}
-
-	inline StackItemT top() {
-		assert (last >= 0);
-		return arr[last];
-	}
-
-	inline int size() {
-		return last+1;
-	}
-
-	inline bool empty() {
-		return (-1 == last);
-	}
-};
-
-
-#endif /* SIMPLESTACK_H_ */

DataStructures/StaticGraph.h

@@ -1,33 +1,42 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 STATICGRAPH_H_INCLUDED
 #define STATICGRAPH_H_INCLUDED
 
-#include <vector>
-#include <algorithm>
-
+#include "../DataStructures/Percent.h"
+#include "../DataStructures/SharedMemoryVectorWrapper.h"
+#include "../Util/SimpleLogger.h"
 #include "../typedefs.h"
-#include "ImportEdge.h"
 
-template< typename EdgeDataT>
+#include <algorithm>
+#include <vector>
+
+template< typename EdgeDataT, bool UseSharedMemory = false>
 class StaticGraph {
 public:
     typedef NodeID NodeIterator;
@@ -39,8 +48,9 @@ public:
         NodeIterator source;
         NodeIterator target;
         bool operator<( const InputEdge& right ) const {
-            if ( source != right.source )
+            if ( source != right.source ) {
                 return source < right.source;
+            }
             return target < right.target;
         }
     };
@@ -81,16 +91,16 @@ public:
         }
     }
 
-    StaticGraph( std::vector<_StrNode> & nodes, std::vector<_StrEdge> & edges) {
-        _numNodes = nodes.size();
+    StaticGraph(
+        typename ShM<_StrNode, UseSharedMemory>::vector & nodes,
+        typename ShM<_StrEdge, UseSharedMemory>::vector & edges
+    ) {
+        _numNodes = nodes.size()-1;
         _numEdges = edges.size();
 
         _nodes.swap(nodes);
         _edges.swap(edges);
 
-        //Add dummy node to end of _nodes array;
-        _nodes.push_back(_nodes.back());
-
 #ifndef NDEBUG
         Percent p(GetNumberOfNodes());
         for(unsigned u = 0; u < GetNumberOfNodes(); ++u) {
@@ -100,12 +110,17 @@ public:
                 if(data.shortcut) {
                     unsigned eid2 = FindEdgeInEitherDirection(u, data.id);
                     if(eid2 == UINT_MAX) {
-                        DEBUG("cannot find first segment of edge (" << u << "," << data.id << "," << v << ")");
+                        SimpleLogger().Write(logWARNING) <<
+                            "cannot find first segment of edge (" <<
+                                u << "," << data.id << "," << v << ")";
+
                         data.shortcut = false;
                     }
                     eid2 = FindEdgeInEitherDirection(data.id, v);
                     if(eid2 == UINT_MAX) {
-                        DEBUG("cannot find second segment of edge (" << u << "," << data.id << "," << v << ")");
+                        SimpleLogger().Write(logWARNING) <<
+                            "cannot find second segment of edge (" <<
+                                u << "," << data.id << "," << v << ")";
                         data.shortcut = false;
                     }
                 }
@@ -123,32 +138,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++ ) {
@@ -161,17 +176,18 @@ 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 );
-            if(UINT_MAX != tmp)
+            if(UINT_MAX != tmp) {
                 result = true;
+            }
         }
         return tmp;
     }
@@ -181,8 +197,8 @@ private:
     NodeIterator _numNodes;
     EdgeIterator _numEdges;
 
-    std::vector< _StrNode > _nodes;
-    std::vector< _StrEdge > _edges;
+    typename ShM< _StrNode, UseSharedMemory >::vector _nodes;
+    typename ShM< _StrEdge, UseSharedMemory >::vector _edges;
 };
 
 #endif // STATICGRAPH_H_INCLUDED

DataStructures/StaticKDTree.h

@@ -1,29 +1,36 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
+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.
 
-KD Tree coded by Christian Vetter, Monav Project
+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.
+
+*/
+
+// KD Tree coded by Christian Vetter, Monav Project
 
- */
 #ifndef STATICKDTREE_H_INCLUDED
 #define STATICKDTREE_H_INCLUDED
 
-#include <cassert>
+#include <boost/assert.hpp>
 #include <vector>
 #include <algorithm>
 #include <stack>
@@ -93,8 +100,8 @@ public:
     };
 
     StaticKDTree( std::vector< InputPoint > * points ){
-        assert( k > 0 );
-        assert ( points->size() > 0 );
+        BOOST_ASSERT( k > 0 );
+        BOOST_ASSERT ( points->size() > 0 );
         size = points->size();
         kdtree = new InputPoint[size];
         for ( Iterator i = 0; i != size; ++i ) {
@@ -202,11 +209,11 @@ private:
     public:
         Less( unsigned d ) {
             dimension = d;
-            assert( dimension < k );
+            BOOST_ASSERT( dimension < k );
         }
 
         bool operator() ( const InputPoint& left, const InputPoint& right ) {
-            assert( dimension < k );
+            BOOST_ASSERT( dimension < k );
             return left.coordinates[dimension] < right.coordinates[dimension];
         }
     private:

DataStructures/StaticRTree.h

@@ -0,0 +1,975 @@
+/*
+
+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 STATICRTREE_H_
+#define STATICRTREE_H_
+
+#include "Coordinate.h"
+#include "DeallocatingVector.h"
+#include "HilbertValue.h"
+#include "MercatorUtil.h"
+#include "PhantomNodes.h"
+#include "SharedMemoryFactory.h"
+#include "SharedMemoryVectorWrapper.h"
+
+#include "../Util/OSRMException.h"
+#include "../Util/SimpleLogger.h"
+#include "../Util/TimingUtil.h"
+#include "../typedefs.h"
+
+#include <boost/assert.hpp>
+#include <boost/bind.hpp>
+#include <boost/foreach.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/filesystem/fstream.hpp>
+#include <boost/algorithm/minmax.hpp>
+#include <boost/algorithm/minmax_element.hpp>
+#include <boost/range/algorithm_ext/erase.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/thread.hpp>
+#include <boost/type_traits.hpp>
+
+#include <algorithm>
+#include <limits>
+#include <queue>
+#include <string>
+#include <vector>
+
+//tuning parameters
+const static uint32_t RTREE_BRANCHING_FACTOR = 50;
+const static uint32_t RTREE_LEAF_NODE_SIZE = 1170;
+
+// Implements a static, i.e. packed, R-tree
+
+static boost::thread_specific_ptr<boost::filesystem::ifstream> thread_local_rtree_stream;
+
+template<class DataT, bool UseSharedMemory = false>
+class StaticRTree : boost::noncopyable {
+public:
+    struct RectangleInt2D {
+        RectangleInt2D() :
+            min_lon(INT_MAX),
+            max_lon(INT_MIN),
+            min_lat(INT_MAX),
+            max_lat(INT_MIN) {}
+
+        int32_t min_lon, max_lon;
+        int32_t min_lat, max_lat;
+
+        inline void InitializeMBRectangle(
+                const DataT * objects,
+                const uint32_t element_count
+        ) {
+            for(uint32_t i = 0; i < element_count; ++i) {
+                min_lon = std::min(
+                        min_lon, std::min(objects[i].lon1, objects[i].lon2)
+                );
+                max_lon = std::max(
+                        max_lon, std::max(objects[i].lon1, objects[i].lon2)
+                );
+
+                min_lat = std::min(
+                        min_lat, std::min(objects[i].lat1, objects[i].lat2)
+                );
+                max_lat = std::max(
+                        max_lat, std::max(objects[i].lat1, objects[i].lat2)
+                );
+            }
+        }
+
+        inline void AugmentMBRectangle(const RectangleInt2D & other) {
+            min_lon = std::min(min_lon, other.min_lon);
+            max_lon = std::max(max_lon, other.max_lon);
+            min_lat = std::min(min_lat, other.min_lat);
+            max_lat = std::max(max_lat, other.max_lat);
+        }
+
+        inline FixedPointCoordinate Centroid() const {
+            FixedPointCoordinate centroid;
+            //The coordinates of the midpoints are given by:
+            //x = (x1 + x2) /2 and y = (y1 + y2) /2.
+            centroid.lon = (min_lon + max_lon)/2;
+            centroid.lat = (min_lat + max_lat)/2;
+            return centroid;
+        }
+
+        inline bool Intersects(const RectangleInt2D & other) const {
+            FixedPointCoordinate upper_left (other.max_lat, other.min_lon);
+            FixedPointCoordinate upper_right(other.max_lat, other.max_lon);
+            FixedPointCoordinate lower_right(other.min_lat, other.max_lon);
+            FixedPointCoordinate lower_left (other.min_lat, other.min_lon);
+
+            return (
+                    Contains(upper_left)
+                    || Contains(upper_right)
+                    || Contains(lower_right)
+                    || Contains(lower_left)
+            );
+        }
+
+        inline double GetMinDist(const FixedPointCoordinate & location) const {
+            bool is_contained = Contains(location);
+            if (is_contained) {
+                return 0.0;
+            }
+
+            double min_dist = std::numeric_limits<double>::max();
+            min_dist = std::min(
+                    min_dist,
+                    ApproximateDistance(
+                            location.lat,
+                            location.lon,
+                            max_lat,
+                            min_lon
+                    )
+            );
+            min_dist = std::min(
+                    min_dist,
+                    ApproximateDistance(
+                            location.lat,
+                            location.lon,
+                            max_lat,
+                            max_lon
+                    )
+            );
+            min_dist = std::min(
+                    min_dist,
+                    ApproximateDistance(
+                            location.lat,
+                            location.lon,
+                            min_lat,
+                            max_lon
+                    )
+            );
+            min_dist = std::min(
+                    min_dist,
+                    ApproximateDistance(
+                            location.lat,
+                            location.lon,
+                            min_lat,
+                            min_lon
+                    )
+            );
+            return min_dist;
+        }
+
+        inline double GetMinMaxDist(const FixedPointCoordinate & location) const {
+            double min_max_dist = std::numeric_limits<double>::max();
+            //Get minmax distance to each of the four sides
+            FixedPointCoordinate upper_left (max_lat, min_lon);
+            FixedPointCoordinate upper_right(max_lat, max_lon);
+            FixedPointCoordinate lower_right(min_lat, max_lon);
+            FixedPointCoordinate lower_left (min_lat, min_lon);
+
+            min_max_dist = std::min(
+                    min_max_dist,
+                    std::max(
+                            ApproximateDistance(location, upper_left ),
+                            ApproximateDistance(location, upper_right)
+                    )
+            );
+
+            min_max_dist = std::min(
+                    min_max_dist,
+                    std::max(
+                            ApproximateDistance(location, upper_right),
+                            ApproximateDistance(location, lower_right)
+                    )
+            );
+
+            min_max_dist = std::min(
+                    min_max_dist,
+                    std::max(
+                            ApproximateDistance(location, lower_right),
+                            ApproximateDistance(location, lower_left )
+                    )
+            );
+
+            min_max_dist = std::min(
+                    min_max_dist,
+                    std::max(
+                            ApproximateDistance(location, lower_left ),
+                            ApproximateDistance(location, upper_left )
+                    )
+            );
+            return min_max_dist;
+        }
+
+        inline bool Contains(const FixedPointCoordinate & location) const {
+            bool lats_contained =
+                    (location.lat > min_lat) && (location.lat < max_lat);
+            bool lons_contained =
+                    (location.lon > min_lon) && (location.lon < max_lon);
+            return lats_contained && lons_contained;
+        }
+
+        inline friend std::ostream & operator<< (
+            std::ostream & out,
+            const RectangleInt2D & rect
+        ) {
+            out << rect.min_lat/COORDINATE_PRECISION << ","
+                << rect.min_lon/COORDINATE_PRECISION << " "
+                << rect.max_lat/COORDINATE_PRECISION << ","
+                << rect.max_lon/COORDINATE_PRECISION;
+            return out;
+        }
+    };
+
+    typedef RectangleInt2D RectangleT;
+
+    struct TreeNode {
+        TreeNode() : child_count(0), child_is_on_disk(false) {}
+        RectangleT minimum_bounding_rectangle;
+        uint32_t child_count:31;
+        bool child_is_on_disk:1;
+        uint32_t children[RTREE_BRANCHING_FACTOR];
+    };
+
+private:
+
+    struct WrappedInputElement {
+        explicit WrappedInputElement(
+            const uint32_t _array_index,
+            const uint64_t _hilbert_value
+            ) : m_array_index(_array_index), m_hilbert_value(_hilbert_value) {}
+
+        WrappedInputElement() : m_array_index(UINT_MAX), m_hilbert_value(0) {}
+
+        uint32_t m_array_index;
+        uint64_t m_hilbert_value;
+
+        inline bool operator<(const WrappedInputElement & other) const {
+            return m_hilbert_value < other.m_hilbert_value;
+        }
+    };
+
+    struct LeafNode {
+        LeafNode() : object_count(0) {}
+        uint32_t object_count;
+        DataT objects[RTREE_LEAF_NODE_SIZE];
+    };
+
+    struct QueryCandidate {
+        explicit QueryCandidate(
+            const uint32_t n_id,
+            const double dist
+        ) : node_id(n_id), min_dist(dist) {}
+        QueryCandidate() : node_id(UINT_MAX), min_dist(std::numeric_limits<double>::max()) {}
+        uint32_t node_id;
+        double min_dist;
+        inline bool operator<(const QueryCandidate & other) const {
+            return min_dist < other.min_dist;
+        }
+    };
+
+    typename ShM<TreeNode, UseSharedMemory>::vector m_search_tree;
+    uint64_t m_element_count;
+
+    const std::string m_leaf_node_filename;
+public:
+    //Construct a packed Hilbert-R-Tree with Kamel-Faloutsos algorithm [1]
+    explicit StaticRTree(
+        std::vector<DataT> & input_data_vector,
+        const std::string tree_node_filename,
+        const std::string leaf_node_filename
+    )
+     :  m_element_count(input_data_vector.size()),
+        m_leaf_node_filename(leaf_node_filename)
+    {
+        SimpleLogger().Write() <<
+            "constructing r-tree of " << m_element_count <<
+            " elements";
+
+        double time1 = get_timestamp();
+        std::vector<WrappedInputElement> input_wrapper_vector(m_element_count);
+
+        //generate auxiliary vector of hilbert-values
+#pragma omp parallel for schedule(guided)
+        for(uint64_t element_counter = 0; element_counter < m_element_count; ++element_counter) {
+            input_wrapper_vector[element_counter].m_array_index = element_counter;
+            //Get Hilbert-Value for centroid in mercartor projection
+            DataT & current_element = input_data_vector[element_counter];
+            FixedPointCoordinate current_centroid = current_element.Centroid();
+            current_centroid.lat = COORDINATE_PRECISION*lat2y(current_centroid.lat/COORDINATE_PRECISION);
+
+            uint64_t current_hilbert_value = HilbertCode::GetHilbertNumberForCoordinate(current_centroid);
+            input_wrapper_vector[element_counter].m_hilbert_value = current_hilbert_value;
+
+        }
+        //open leaf file
+        boost::filesystem::ofstream leaf_node_file(leaf_node_filename, std::ios::binary);
+        leaf_node_file.write((char*) &m_element_count, sizeof(uint64_t));
+
+        //sort the hilbert-value representatives
+        std::sort(input_wrapper_vector.begin(), input_wrapper_vector.end());
+        std::vector<TreeNode> tree_nodes_in_level;
+
+        //pack M elements into leaf node and write to leaf file
+        uint64_t processed_objects_count = 0;
+        while(processed_objects_count < m_element_count) {
+
+            LeafNode current_leaf;
+            TreeNode current_node;
+            for(uint32_t current_element_index = 0; RTREE_LEAF_NODE_SIZE > current_element_index; ++current_element_index) {
+                if(m_element_count > (processed_objects_count + current_element_index)) {
+                    uint32_t index_of_next_object = input_wrapper_vector[processed_objects_count + current_element_index].m_array_index;
+                    current_leaf.objects[current_element_index] = input_data_vector[index_of_next_object];
+                    ++current_leaf.object_count;
+                }
+            }
+
+            //generate tree node that resemble the objects in leaf and store it for next level
+            current_node.minimum_bounding_rectangle.InitializeMBRectangle(current_leaf.objects, current_leaf.object_count);
+            current_node.child_is_on_disk = true;
+            current_node.children[0] = tree_nodes_in_level.size();
+            tree_nodes_in_level.push_back(current_node);
+
+            //write leaf_node to leaf node file
+            leaf_node_file.write((char*)&current_leaf, sizeof(current_leaf));
+            processed_objects_count += current_leaf.object_count;
+        }
+
+        //close leaf file
+        leaf_node_file.close();
+
+        uint32_t processing_level = 0;
+        while(1 < tree_nodes_in_level.size()) {
+            std::vector<TreeNode> tree_nodes_in_next_level;
+            uint32_t processed_tree_nodes_in_level = 0;
+            while(processed_tree_nodes_in_level < tree_nodes_in_level.size()) {
+                TreeNode parent_node;
+                //pack RTREE_BRANCHING_FACTOR elements into tree_nodes each
+                for(
+                    uint32_t current_child_node_index = 0;
+                    RTREE_BRANCHING_FACTOR > current_child_node_index;
+                    ++current_child_node_index
+                ) {
+                    if(processed_tree_nodes_in_level < tree_nodes_in_level.size()) {
+                        TreeNode & current_child_node = tree_nodes_in_level[processed_tree_nodes_in_level];
+                        //add tree node to parent entry
+                        parent_node.children[current_child_node_index] = m_search_tree.size();
+                        m_search_tree.push_back(current_child_node);
+                        //augment MBR of parent
+                        parent_node.minimum_bounding_rectangle.AugmentMBRectangle(current_child_node.minimum_bounding_rectangle);
+                        //increase counters
+                        ++parent_node.child_count;
+                        ++processed_tree_nodes_in_level;
+                    }
+                }
+                tree_nodes_in_next_level.push_back(parent_node);
+            }
+            tree_nodes_in_level.swap(tree_nodes_in_next_level);
+            ++processing_level;
+        }
+        BOOST_ASSERT_MSG(1 == tree_nodes_in_level.size(), "tree broken, more than one root node");
+        //last remaining entry is the root node, store it
+        m_search_tree.push_back(tree_nodes_in_level[0]);
+
+        //reverse and renumber tree to have root at index 0
+        std::reverse(m_search_tree.begin(), m_search_tree.end());
+#pragma omp parallel for schedule(guided)
+        for(uint32_t i = 0; i < m_search_tree.size(); ++i) {
+            TreeNode & current_tree_node = m_search_tree[i];
+            for(uint32_t j = 0; j < current_tree_node.child_count; ++j) {
+                const uint32_t old_id = current_tree_node.children[j];
+                const uint32_t new_id = m_search_tree.size() - old_id - 1;
+                current_tree_node.children[j] = new_id;
+            }
+        }
+
+        //open tree file
+        boost::filesystem::ofstream tree_node_file(
+            tree_node_filename,
+            std::ios::binary
+        );
+
+        uint32_t size_of_tree = m_search_tree.size();
+        BOOST_ASSERT_MSG(0 < size_of_tree, "tree empty");
+        tree_node_file.write((char *)&size_of_tree, sizeof(uint32_t));
+        tree_node_file.write((char *)&m_search_tree[0], sizeof(TreeNode)*size_of_tree);
+        //close tree node file.
+        tree_node_file.close();
+        double time2 = get_timestamp();
+        SimpleLogger().Write() <<
+            "finished r-tree construction in " << (time2-time1) << " seconds";
+    }
+
+    //Read-only operation for queries
+    explicit StaticRTree(
+            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.
+
+        if ( !boost::filesystem::exists( node_file ) ) {
+            throw OSRMException("ram index file does not exist");
+        }
+        if ( 0 == boost::filesystem::file_size( node_file ) ) {
+            throw OSRMException("ram index file is empty");
+        }
+        boost::filesystem::ifstream tree_node_file( node_file, std::ios::binary );
+
+        uint32_t tree_size = 0;
+        tree_node_file.read((char*)&tree_size, sizeof(uint32_t));
+        //SimpleLogger().Write() << "reading " << tree_size << " tree nodes in " << (sizeof(TreeNode)*tree_size) << " bytes";
+        m_search_tree.resize(tree_size);
+        tree_node_file.read((char*)&m_search_tree[0], sizeof(TreeNode)*tree_size);
+        tree_node_file.close();
+        //open leaf node file and store thread specific pointer
+        if ( !boost::filesystem::exists( leaf_file ) ) {
+            throw OSRMException("mem index file does not exist");
+        }
+        if ( 0 == boost::filesystem::file_size( leaf_file ) ) {
+            throw OSRMException("mem index file is empty");
+        }
+
+        boost::filesystem::ifstream leaf_node_file( leaf_file, std::ios::binary );
+        leaf_node_file.read((char*)&m_element_count, sizeof(uint64_t));
+        leaf_node_file.close();
+
+        //SimpleLogger().Write() << tree_size << " nodes in search tree";
+        //SimpleLogger().Write() << m_element_count << " elements in leafs";
+    }
+
+    explicit StaticRTree(
+            TreeNode * tree_node_ptr,
+            const uint32_t number_of_nodes,
+            const boost::filesystem::path & leaf_file
+    ) : m_search_tree(tree_node_ptr, number_of_nodes),
+        m_leaf_node_filename(leaf_file.string())
+    {
+        //open leaf node file and store thread specific pointer
+        if ( !boost::filesystem::exists( leaf_file ) ) {
+            throw OSRMException("mem index file does not exist");
+        }
+        if ( 0 == boost::filesystem::file_size( leaf_file ) ) {
+            throw OSRMException("mem index file is empty");
+        }
+
+        boost::filesystem::ifstream leaf_node_file( leaf_file, std::ios::binary );
+        leaf_node_file.read((char*)&m_element_count, sizeof(uint64_t));
+        leaf_node_file.close();
+
+        if( thread_local_rtree_stream.get() ) {
+            thread_local_rtree_stream->close();
+        }
+
+        //SimpleLogger().Write() << tree_size << " nodes in search tree";
+        //SimpleLogger().Write() << m_element_count << " elements in leafs";
+    }
+    //Read-only operation for queries
+/*
+    inline void FindKNearestPhantomNodesForCoordinate(
+        const FixedPointCoordinate & location,
+        const unsigned zoom_level,
+        const unsigned candidate_count,
+        std::vector<std::pair<PhantomNode, double> > & result_vector
+    ) const {
+
+        bool ignore_tiny_components = (zoom_level <= 14);
+        DataT nearest_edge;
+
+        uint32_t io_count = 0;
+        uint32_t explored_tree_nodes_count = 0;
+        SimpleLogger().Write() << "searching for coordinate " << input_coordinate;
+        double min_dist = std::numeric_limits<double>::max();
+        double min_max_dist = std::numeric_limits<double>::max();
+        bool found_a_nearest_edge = false;
+
+        FixedPointCoordinate nearest, current_start_coordinate, current_end_coordinate;
+
+        //initialize queue with root element
+        std::priority_queue<QueryCandidate> traversal_queue;
+        traversal_queue.push(QueryCandidate(0, m_search_tree[0].minimum_bounding_rectangle.GetMinDist(input_coordinate)));
+        BOOST_ASSERT_MSG(std::numberic_limits<double>::epsilon() > (0. - traversal_queue.top().min_dist), "Root element in NN Search has min dist != 0.");
+
+        while(!traversal_queue.empty()) {
+            const QueryCandidate current_query_node = traversal_queue.top(); traversal_queue.pop();
+
+            ++explored_tree_nodes_count;
+            bool prune_downward = (current_query_node.min_dist >= min_max_dist);
+            bool prune_upward    = (current_query_node.min_dist >= min_dist);
+            if( !prune_downward && !prune_upward ) { //downward pruning
+                TreeNode & current_tree_node = m_search_tree[current_query_node.node_id];
+                if (current_tree_node.child_is_on_disk) {
+                    LeafNode current_leaf_node;
+                    LoadLeafFromDisk(current_tree_node.children[0], current_leaf_node);
+                    ++io_count;
+                    for(uint32_t i = 0; i < current_leaf_node.object_count; ++i) {
+                        DataT & current_edge = current_leaf_node.objects[i];
+                        if(ignore_tiny_components && current_edge.belongsToTinyComponent) {
+                            continue;
+                        }
+
+                        double current_ratio = 0.;
+                        double current_perpendicular_distance = ComputePerpendicularDistance(
+                                                                                             input_coordinate,
+                                                                                             FixedPointCoordinate(current_edge.lat1, current_edge.lon1),
+                                                                                             FixedPointCoordinate(current_edge.lat2, current_edge.lon2),
+                                                                                             nearest,
+                                                                                             &current_ratio
+                                                                                             );
+
+                        if(
+                           current_perpendicular_distance < min_dist
+                           && !DoubleEpsilonCompare(
+                                                    current_perpendicular_distance,
+                                                    min_dist
+                                                    )
+                           ) { //found a new minimum
+                            min_dist = current_perpendicular_distance;
+                            result_phantom_node.edgeBasedNode = current_edge.id;
+                            result_phantom_node.nodeBasedEdgeNameID = current_edge.nameID;
+                            result_phantom_node.weight1 = current_edge.weight;
+                            result_phantom_node.weight2 = INT_MAX;
+                            result_phantom_node.location = nearest;
+                            current_start_coordinate.lat = current_edge.lat1;
+                            current_start_coordinate.lon = current_edge.lon1;
+                            current_end_coordinate.lat = current_edge.lat2;
+                            current_end_coordinate.lon = current_edge.lon2;
+                            nearest_edge = current_edge;
+                            found_a_nearest_edge = true;
+                        } else if(
+                                  DoubleEpsilonCompare(current_perpendicular_distance, min_dist) &&
+                                  1 == abs(current_edge.id - result_phantom_node.edgeBasedNode )
+                                  && CoordinatesAreEquivalent(
+                                                              current_start_coordinate,
+                                                              FixedPointCoordinate(
+                                                                          current_edge.lat1,
+                                                                          current_edge.lon1
+                                                                          ),
+                                                              FixedPointCoordinate(
+                                                                          current_edge.lat2,
+                                                                          current_edge.lon2
+                                                                          ),
+                                                              current_end_coordinate
+                                                              )
+                                  ) {
+                            result_phantom_node.edgeBasedNode = std::min(current_edge.id, result_phantom_node.edgeBasedNode);
+                            result_phantom_node.weight2 = current_edge.weight;
+                        }
+                    }
+                } else {
+                    //traverse children, prune if global mindist is smaller than local one
+                    for (uint32_t i = 0; i < current_tree_node.child_count; ++i) {
+                        const int32_t child_id = current_tree_node.children[i];
+                        TreeNode & child_tree_node = m_search_tree[child_id];
+                        RectangleT & child_rectangle = child_tree_node.minimum_bounding_rectangle;
+                        const double current_min_dist = child_rectangle.GetMinDist(input_coordinate);
+                        const double current_min_max_dist = child_rectangle.GetMinMaxDist(input_coordinate);
+                        if( current_min_max_dist < min_max_dist ) {
+                            min_max_dist = current_min_max_dist;
+                        }
+                        if (current_min_dist > min_max_dist) {
+                            continue;
+                        }
+                        if (current_min_dist > min_dist) { //upward pruning
+                            continue;
+                        }
+                        traversal_queue.push(QueryCandidate(child_id, current_min_dist));
+                    }
+                }
+            }
+        }
+
+        const double distance_to_edge =
+        ApproximateDistance (
+            FixedPointCoordinate(nearest_edge.lat1, nearest_edge.lon1),
+            result_phantom_node.location
+        );
+
+        const double length_of_edge =
+        ApproximateDistance(
+            FixedPointCoordinate(nearest_edge.lat1, nearest_edge.lon1),
+            FixedPointCoordinate(nearest_edge.lat2, nearest_edge.lon2)
+        );
+
+        const double ratio = (found_a_nearest_edge ?
+          std::min(1., distance_to_edge/ length_of_edge ) : 0 );
+        result_phantom_node.weight1 *= ratio;
+        if(INT_MAX != result_phantom_node.weight2) {
+            result_phantom_node.weight2 *= (1.-ratio);
+        }
+        result_phantom_node.ratio = ratio;
+
+        //Hack to fix rounding errors and wandering via nodes.
+        if(std::abs(input_coordinate.lon - result_phantom_node.location.lon) == 1) {
+            result_phantom_node.location.lon = input_coordinate.lon;
+        }
+        if(std::abs(input_coordinate.lat - result_phantom_node.location.lat) == 1) {
+            result_phantom_node.location.lat = input_coordinate.lat;
+        }
+
+        SimpleLogger().Write() << "mindist: " << min_distphantom_node.isBidirected() ? "yes" : "no");
+        return found_a_nearest_edge;
+
+    }
+
+  */
+    bool LocateClosestEndPointForCoordinate(
+            const FixedPointCoordinate & input_coordinate,
+            FixedPointCoordinate & result_coordinate,
+            const unsigned zoom_level
+    ) {
+        bool ignore_tiny_components = (zoom_level <= 14);
+        DataT nearest_edge;
+        double min_dist = std::numeric_limits<double>::max();
+        double min_max_dist = std::numeric_limits<double>::max();
+        bool found_a_nearest_edge = false;
+
+        //initialize queue with root element
+        std::priority_queue<QueryCandidate> traversal_queue;
+        double current_min_dist = m_search_tree[0].minimum_bounding_rectangle.GetMinDist(input_coordinate);
+        traversal_queue.push(
+            QueryCandidate(0, current_min_dist)
+        );
+
+        BOOST_ASSERT_MSG(
+            std::numeric_limits<double>::epsilon() > (0. - traversal_queue.top().min_dist),
+            "Root element in NN Search has min dist != 0."
+        );
+
+        while(!traversal_queue.empty()) {
+            const QueryCandidate current_query_node = traversal_queue.top();
+            traversal_queue.pop();
+
+            const bool prune_downward = (current_query_node.min_dist >= min_max_dist);
+            const bool prune_upward = (current_query_node.min_dist >= min_dist);
+            if( !prune_downward && !prune_upward ) { //downward pruning
+                TreeNode & current_tree_node = m_search_tree[current_query_node.node_id];
+                if (current_tree_node.child_is_on_disk) {
+                    LeafNode current_leaf_node;
+                    LoadLeafFromDisk(
+                        current_tree_node.children[0],
+                        current_leaf_node
+                    );
+                    for(uint32_t i = 0; i < current_leaf_node.object_count; ++i) {
+                        const DataT & current_edge = current_leaf_node.objects[i];
+                        if(
+                            ignore_tiny_components &&
+                            current_edge.belongsToTinyComponent
+                        ) {
+                            continue;
+                        }
+                        if(current_edge.isIgnored()) {
+                            continue;
+                        }
+
+                        double current_minimum_distance = ApproximateDistance(
+                                input_coordinate.lat,
+                                input_coordinate.lon,
+                                current_edge.lat1,
+                                current_edge.lon1
+                            );
+                        if( current_minimum_distance < min_dist ) {
+                            //found a new minimum
+                            min_dist = current_minimum_distance;
+                            result_coordinate.lat = current_edge.lat1;
+                            result_coordinate.lon = current_edge.lon1;
+                            found_a_nearest_edge = true;
+                        }
+
+                        current_minimum_distance = ApproximateDistance(
+                                input_coordinate.lat,
+                                input_coordinate.lon,
+                                current_edge.lat2,
+                                current_edge.lon2
+                            );
+
+                        if( current_minimum_distance < min_dist ) {
+                            //found a new minimum
+                            min_dist = current_minimum_distance;
+                            result_coordinate.lat = current_edge.lat2;
+                            result_coordinate.lon = current_edge.lon2;
+                            found_a_nearest_edge = true;
+                        }
+                    }
+                } else {
+                    //traverse children, prune if global mindist is smaller than local one
+                    for (uint32_t i = 0; i < current_tree_node.child_count; ++i) {
+                        const int32_t child_id = current_tree_node.children[i];
+                        const TreeNode & child_tree_node = m_search_tree[child_id];
+                        const RectangleT & child_rectangle = child_tree_node.minimum_bounding_rectangle;
+                        const double current_min_dist = child_rectangle.GetMinDist(input_coordinate);
+                        const double current_min_max_dist = child_rectangle.GetMinMaxDist(input_coordinate);
+                        if( current_min_max_dist < min_max_dist ) {
+                            min_max_dist = current_min_max_dist;
+                        }
+                        if (current_min_dist > min_max_dist) {
+                            continue;
+                        }
+                        if (current_min_dist > min_dist) { //upward pruning
+                            continue;
+                        }
+                        traversal_queue.push(
+                            QueryCandidate(child_id, current_min_dist)
+                        );
+                    }
+                }
+            }
+        }
+
+        return found_a_nearest_edge;
+    }
+
+
+    bool FindPhantomNodeForCoordinate(
+            const FixedPointCoordinate & input_coordinate,
+            PhantomNode & result_phantom_node,
+            const unsigned zoom_level
+    ) {
+
+        bool ignore_tiny_components = (zoom_level <= 14);
+        DataT nearest_edge;
+
+        uint32_t io_count = 0;
+        uint32_t explored_tree_nodes_count = 0;
+        //SimpleLogger().Write() << "searching for coordinate " << input_coordinate;
+        double min_dist = std::numeric_limits<double>::max();
+        double min_max_dist = std::numeric_limits<double>::max();
+        bool found_a_nearest_edge = false;
+
+        FixedPointCoordinate nearest, current_start_coordinate, current_end_coordinate;
+
+        //initialize queue with root element
+        std::priority_queue<QueryCandidate> traversal_queue;
+        double current_min_dist = m_search_tree[0].minimum_bounding_rectangle.GetMinDist(input_coordinate);
+        traversal_queue.push(
+                             QueryCandidate(0, current_min_dist)
+        );
+
+        BOOST_ASSERT_MSG(
+            std::numeric_limits<double>::epsilon() > (0. - traversal_queue.top().min_dist),
+            "Root element in NN Search has min dist != 0."
+        );
+
+        while(!traversal_queue.empty()) {
+            const QueryCandidate current_query_node = traversal_queue.top(); traversal_queue.pop();
+
+            ++explored_tree_nodes_count;
+            bool prune_downward = (current_query_node.min_dist >= min_max_dist);
+            bool prune_upward    = (current_query_node.min_dist >= min_dist);
+            if( !prune_downward && !prune_upward ) { //downward pruning
+                TreeNode & current_tree_node = m_search_tree[current_query_node.node_id];
+                if (current_tree_node.child_is_on_disk) {
+                    LeafNode current_leaf_node;
+                    LoadLeafFromDisk(current_tree_node.children[0], current_leaf_node);
+                    ++io_count;
+                    for(uint32_t i = 0; i < current_leaf_node.object_count; ++i) {
+                        DataT & current_edge = current_leaf_node.objects[i];
+                        if(ignore_tiny_components && current_edge.belongsToTinyComponent) {
+                            continue;
+                        }
+                        if(current_edge.isIgnored()) {
+                            continue;
+                        }
+
+                       double current_ratio = 0.;
+                       double current_perpendicular_distance = ComputePerpendicularDistance(
+                                input_coordinate,
+                                FixedPointCoordinate(current_edge.lat1, current_edge.lon1),
+                                FixedPointCoordinate(current_edge.lat2, current_edge.lon2),
+                                nearest,
+                                &current_ratio
+                        );
+
+                        if(
+                                current_perpendicular_distance < min_dist
+                                && !DoubleEpsilonCompare(
+                                        current_perpendicular_distance,
+                                        min_dist
+                                )
+                        ) { //found a new minimum
+                            min_dist = current_perpendicular_distance;
+                            result_phantom_node.edgeBasedNode = current_edge.id;
+                            result_phantom_node.nodeBasedEdgeNameID = current_edge.nameID;
+                            result_phantom_node.weight1 = current_edge.weight;
+                            result_phantom_node.weight2 = INT_MAX;
+                            result_phantom_node.location = nearest;
+                            current_start_coordinate.lat = current_edge.lat1;
+                            current_start_coordinate.lon = current_edge.lon1;
+                            current_end_coordinate.lat = current_edge.lat2;
+                            current_end_coordinate.lon = current_edge.lon2;
+                            nearest_edge = current_edge;
+                            found_a_nearest_edge = true;
+                        } else if(
+                                DoubleEpsilonCompare(current_perpendicular_distance, min_dist) &&
+                                1 == abs(current_edge.id - result_phantom_node.edgeBasedNode )
+                        && CoordinatesAreEquivalent(
+                                current_start_coordinate,
+                                FixedPointCoordinate(
+                                        current_edge.lat1,
+                                        current_edge.lon1
+                                ),
+                                FixedPointCoordinate(
+                                        current_edge.lat2,
+                                        current_edge.lon2
+                                ),
+                                current_end_coordinate
+                            )
+                        ) {
+
+                            BOOST_ASSERT_MSG(current_edge.id != result_phantom_node.edgeBasedNode, "IDs not different");
+                            result_phantom_node.weight2 = current_edge.weight;
+                            if(current_edge.id < result_phantom_node.edgeBasedNode) {
+                                result_phantom_node.edgeBasedNode = current_edge.id;
+                                std::swap(result_phantom_node.weight1, result_phantom_node.weight2);
+                                std::swap(current_end_coordinate, current_start_coordinate);
+                            }
+                        }
+                    }
+                } else {
+                    //traverse children, prune if global mindist is smaller than local one
+                    for (uint32_t i = 0; i < current_tree_node.child_count; ++i) {
+                        const int32_t child_id = current_tree_node.children[i];
+                        TreeNode & child_tree_node = m_search_tree[child_id];
+                        RectangleT & child_rectangle = child_tree_node.minimum_bounding_rectangle;
+                        const double current_min_dist = child_rectangle.GetMinDist(input_coordinate);
+                        const double current_min_max_dist = child_rectangle.GetMinMaxDist(input_coordinate);
+                        if( current_min_max_dist < min_max_dist ) {
+                            min_max_dist = current_min_max_dist;
+                        }
+                        if (current_min_dist > min_max_dist) {
+                            continue;
+                        }
+                        if (current_min_dist > min_dist) { //upward pruning
+                            continue;
+                        }
+                        traversal_queue.push(QueryCandidate(child_id, current_min_dist));
+                    }
+                }
+            }
+        }
+
+        const double ratio = (found_a_nearest_edge ?
+            std::min(1., ApproximateDistance(current_start_coordinate,
+                result_phantom_node.location)/ApproximateDistance(current_start_coordinate, current_end_coordinate)
+                ) : 0
+            );
+        result_phantom_node.weight1 *= ratio;
+        if(INT_MAX != result_phantom_node.weight2) {
+            result_phantom_node.weight2 *= (1.-ratio);
+        }
+        result_phantom_node.ratio = ratio;
+
+        //Hack to fix rounding errors and wandering via nodes.
+        if(std::abs(input_coordinate.lon - result_phantom_node.location.lon) == 1) {
+            result_phantom_node.location.lon = input_coordinate.lon;
+        }
+        if(std::abs(input_coordinate.lat - result_phantom_node.location.lat) == 1) {
+            result_phantom_node.location.lat = input_coordinate.lat;
+        }
+
+        return found_a_nearest_edge;
+
+    }
+
+private:
+    inline void LoadLeafFromDisk(const uint32_t leaf_id, LeafNode& result_node) {
+        if(
+            !thread_local_rtree_stream.get() ||
+            !thread_local_rtree_stream->is_open()
+        ) {
+            thread_local_rtree_stream.reset(
+                new boost::filesystem::ifstream(
+                        m_leaf_node_filename,
+                        std::ios::in | std::ios::binary
+                )
+            );
+        }
+        if(!thread_local_rtree_stream->good()) {
+            thread_local_rtree_stream->clear(std::ios::goodbit);
+            SimpleLogger().Write(logDEBUG) << "Resetting stale filestream";
+        }
+        uint64_t seek_pos = sizeof(uint64_t) + leaf_id*sizeof(LeafNode);
+        thread_local_rtree_stream->seekg(seek_pos);
+        thread_local_rtree_stream->read((char *)&result_node, sizeof(LeafNode));
+    }
+
+    inline double ComputePerpendicularDistance(
+            const FixedPointCoordinate& inputPoint,
+            const FixedPointCoordinate& source,
+            const FixedPointCoordinate& target,
+            FixedPointCoordinate& nearest, double *r) const {
+        const double x = inputPoint.lat/COORDINATE_PRECISION;
+        const double y = inputPoint.lon/COORDINATE_PRECISION;
+        const double a = source.lat/COORDINATE_PRECISION;
+        const double b = source.lon/COORDINATE_PRECISION;
+        const double c = target.lat/COORDINATE_PRECISION;
+        const double d = target.lon/COORDINATE_PRECISION;
+        double p,q,mX,nY;
+        if(std::fabs(a-c) > std::numeric_limits<double>::epsilon() ){
+            const double m = (d-b)/(c-a); // slope
+            // Projection of (x,y) on line joining (a,b) and (c,d)
+            p = ((x + (m*y)) + (m*m*a - m*b))/(1. + m*m);
+            q = b + m*(p - a);
+        } else {
+            p = c;
+            q = y;
+        }
+        nY = (d*p - c*q)/(a*d - b*c);
+        mX = (p - nY*a)/c;// These values are actually n/m+n and m/m+n , we need
+        // not calculate the explicit values of m an n as we
+        // are just interested in the ratio
+        if(std::isnan(mX)) {
+            *r = (target == inputPoint) ? 1. : 0.;
+        } else {
+            *r = mX;
+        }
+        if(*r<=0.){
+            nearest.lat = source.lat;
+            nearest.lon = source.lon;
+            return ((b - y)*(b - y) + (a - x)*(a - x));
+//            return std::sqrt(((b - y)*(b - y) + (a - x)*(a - x)));
+        } else if(*r >= 1.){
+            nearest.lat = target.lat;
+            nearest.lon = target.lon;
+            return ((d - y)*(d - y) + (c - x)*(c - x));
+//            return std::sqrt(((d - y)*(d - y) + (c - x)*(c - x)));
+        }
+        // point lies in between
+        nearest.lat = p*COORDINATE_PRECISION;
+        nearest.lon = q*COORDINATE_PRECISION;
+//        return std::sqrt((p-x)*(p-x) + (q-y)*(q-y));
+        return (p-x)*(p-x) + (q-y)*(q-y);
+    }
+
+    inline bool CoordinatesAreEquivalent(const FixedPointCoordinate & a, const FixedPointCoordinate & b, const FixedPointCoordinate & c, const FixedPointCoordinate & d) const {
+        return (a == b && c == d) || (a == c && b == d) || (a == d && b == c);
+    }
+
+    inline bool DoubleEpsilonCompare(const double d1, const double d2) const {
+        return (std::fabs(d1 - d2) < std::numeric_limits<double>::epsilon() );
+    }
+
+};
+
+//[1] "On Packing R-Trees"; I. Kamel, C. Faloutsos; 1993; DOI: 10.1145/170088.170403
+//[2] "Nearest Neighbor Queries", N. Roussopulos et al; 1995; DOI: 10.1145/223784.223794
+
+
+#endif /* STATICRTREE_H_ */

DataStructures/TurnInstructions.h

@@ -1,32 +1,39 @@
 /*
- open source routing machine
- Copyright (C) Dennis Luxen, others 2010
 
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU AFFERO General Public License as published by
- the Free Software Foundation; either version 3 of the License, or
- any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
- You should have received a copy of the GNU Affero General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 TURNINSTRUCTIONS_H_
 #define TURNINSTRUCTIONS_H_
 
-#include <string>
+#include <boost/noncopyable.hpp>
 
 typedef unsigned char TurnInstruction;
 
 //This is a hack until c++0x is available enough to use scoped enums
-struct TurnInstructionsClass {
+struct TurnInstructionsClass : boost::noncopyable {
 
     const static TurnInstruction NoTurn = 0;          //Give no instruction at all
     const static TurnInstruction GoStraight = 1;      //Tell user to go straight!
@@ -44,48 +51,14 @@ struct TurnInstructionsClass {
     const static TurnInstruction StayOnRoundAbout = 13;
     const static TurnInstruction StartAtEndOfStreet = 14;
     const static TurnInstruction ReachedYourDestination = 15;
+    const static TurnInstruction EnterAgainstAllowedDirection = 16;
+    const static TurnInstruction LeaveAgainstAllowedDirection = 17;
 
     const static TurnInstruction AccessRestrictionFlag = 128;
     const static TurnInstruction InverseAccessRestrictionFlag = 0x7f; // ~128 does not work without a warning.
 
     const static int AccessRestrictionPenalty = 1 << 15; //unrelated to the bit set in the restriction flag
 
-//    std::string TurnStrings[16];
-//    std::string Ordinals[12];
-
-    //This is a hack until c++0x is available enough to use initializer lists.
-//    TurnInstructionsClass(){
-//        TurnStrings [0] = "";
-//        TurnStrings [1] = "Continue";
-//        TurnStrings [2] = "Turn slight right";
-//        TurnStrings [3] = "Turn right";
-//        TurnStrings [4] = "Turn sharp right";
-//        TurnStrings [5] = "U-Turn";
-//        TurnStrings [6] = "Turn sharp left";
-//        TurnStrings [7] = "Turn left";
-//        TurnStrings [8] = "Turn slight left";
-//        TurnStrings [9] = "Reach via point";
-//        TurnStrings[10] = "Head";
-//        TurnStrings[11] = "Enter roundabout";
-//        TurnStrings[12] = "Leave roundabout";
-//        TurnStrings[13] = "Stay on roundabout";
-//        TurnStrings[14] = "Start";
-//        TurnStrings[15] = "You have reached your destination";
-//
-//        Ordinals[0]     = "zeroth";
-//        Ordinals[1]     = "first";
-//        Ordinals[2]     = "second";
-//        Ordinals[3]     = "third";
-//        Ordinals[4]     = "fourth";
-//        Ordinals[5]     = "fifth";
-//        Ordinals[6]     = "sixth";
-//        Ordinals[7]     = "seventh";
-//        Ordinals[8]     = "eighth";
-//        Ordinals[9]     = "nineth";
-//        Ordinals[10]    = "tenth";
-//        Ordinals[11]    = "one of the too many";
-//    };
-
     static inline TurnInstruction GetTurnDirectionOfInstruction( const double angle ) {
         if(angle >= 23 && angle < 67) {
             return TurnSharpRight;

DataStructures/Util.h

@@ -1,70 +0,0 @@
-/*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
-*/
-
-#ifndef TIMEUTIL_H_
-#define TIMEUTIL_H_
-
-#include <climits>
-#include <cmath>
-#include <cstdlib>
-
-#ifndef M_PI
-#define M_PI 3.14159265358979323846
-#endif
-
-#ifdef _WIN32
- #include <sys/timeb.h>
- #include <sys/types.h>
- #include <winsock.h>
- void gettimeofday(struct timeval* t,void* timezone)
- {       struct _timeb timebuffer;
-        _ftime( &timebuffer );
-        t->tv_sec=timebuffer.time;
-        t->tv_usec=1000*timebuffer.millitm;
- }
-#else
- #include <sys/time.h>
-#endif
-
-#ifdef _WIN32
- #include <boost/functional/hash.hpp>
-#else
- #include <tr1/functional_hash.h>
-#endif
-#include <boost/thread.hpp>
-
-/** Returns a timestamp (now) in seconds (incl. a fractional part). */
-static inline double get_timestamp() {
-    struct timeval tp;
-    gettimeofday(&tp, NULL);
-    return double(tp.tv_sec) + tp.tv_usec / 1000000.;
-}
-
-static inline double y2lat(double a) { return 180/M_PI * (2 * atan(exp(a*M_PI/180)) - M_PI/2); }
-static inline double lat2y(double a) { return 180/M_PI * log(tan(M_PI/4+a*(M_PI/180)/2)); }
-
-static inline unsigned boost_thread_id_hash(boost::thread::id const& id) {
-	std::stringstream ostr;
-	ostr << id;
-	std::tr1::hash<std::string> h;
-	return h(ostr.str());
-}
-
-#endif /* TIMEUTIL_H_ */

DataStructures/XORFastHash.h

@@ -1,22 +1,29 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 FASTXORHASH_H_
 #define FASTXORHASH_H_
@@ -49,7 +56,7 @@ public:
         table1.resize(2 << 16);
         table2.resize(2 << 16);
         for(unsigned i = 0; i < (2 << 16); ++i) {
-            table1[i] = i; table2[i];
+            table1[i] = i; table2[i] = i;
         }
         std::random_shuffle(table1.begin(), table1.end());
         std::random_shuffle(table2.begin(), table2.end());
@@ -75,8 +82,8 @@ public:
         table3.resize(1 << 8);
         table4.resize(1 << 8);
         for(unsigned i = 0; i < (1 << 8); ++i) {
-            table1[i] = i; table2[i];
-            table3[i] = i; table4[i];
+            table1[i] = i; table2[i] = i;
+            table3[i] = i; table4[i] = i;
         }
         std::random_shuffle(table1.begin(), table1.end());
         std::random_shuffle(table2.begin(), table2.end());

DataStructures/XORFastHashStorage.h

@@ -1,32 +1,39 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 XORFASTHASHSTORAGE_H_
 #define XORFASTHASHSTORAGE_H_
 
+#include "XORFastHash.h"
+
 #include <climits>
 #include <vector>
 #include <bitset>
 
-#include "XORFastHash.h"
-
 template< typename NodeID, typename Key >
 class XORFastHashStorage {
 public:

Descriptors/BaseDescriptor.h

@@ -1,55 +1,72 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 BASE_DESCRIPTOR_H_
 #define BASE_DESCRIPTOR_H_
 
-#include <cassert>
+#include "../DataStructures/HashTable.h"
+#include "../DataStructures/PhantomNodes.h"
+#include "../DataStructures/RawRouteData.h"
+#include "../Server/Http/Reply.h"
+#include "../Util/StringUtil.h"
+#include "../typedefs.h"
+
 #include <cmath>
 #include <cstdio>
+
 #include <string>
 #include <vector>
 
-#include "../typedefs.h"
-#include "../DataStructures/PhantomNodes.h"
-#include "../DataStructures/HashTable.h"
-#include "../Util/StringUtil.h"
-
-#include "../Plugins/RawRouteData.h"
-
-struct _DescriptorConfig {
-    _DescriptorConfig() : instructions(true), geometry(true), encodeGeometry(true), z(18) {}
+struct DescriptorConfig {
+    DescriptorConfig() :
+        instructions(true),
+        geometry(true),
+        encode_geometry(true),
+        zoom_level(18)
+    { }
     bool instructions;
     bool geometry;
-    bool encodeGeometry;
-    unsigned short z;
+    bool encode_geometry;
+    unsigned short zoom_level;
 };
 
-template<class SearchEngineT>
+template<class DataFacadeT>
 class BaseDescriptor {
 public:
     BaseDescriptor() { }
     //Maybe someone can explain the pure virtual destructor thing to me (dennis)
     virtual ~BaseDescriptor() { }
-    virtual void Run(http::Reply & reply, const RawRouteData &rawRoute, PhantomNodes &phantomNodes, SearchEngineT &sEngine) = 0;
-    virtual void SetConfig(const _DescriptorConfig & config) = 0;
+    virtual void Run(
+        http::Reply & reply,
+        const RawRouteData &rawRoute,
+        PhantomNodes &phantomNodes,
+        const DataFacadeT * facade
+    ) = 0;
+    virtual void SetConfig(const DescriptorConfig & config) = 0;
 };
 
 #endif /* BASE_DESCRIPTOR_H_ */

Descriptors/DescriptionFactory.cpp

@@ -1,22 +1,29 @@
 /*
- open source routing machine
- Copyright (C) Dennis Luxen, others 2010
 
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU AFFERO General Public License as published by
- the Free Software Foundation; either version 3 of the License, or
- any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
- You should have received a copy of the GNU Affero General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- or see http://www.gnu.org/licenses/agpl.txt.
- */
+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.
+
+*/
 
 #include "DescriptionFactory.h"
 
@@ -32,34 +39,53 @@ inline double DescriptionFactory::RadianToDegree(const double radian) const {
         return radian * (180/M_PI);
 }
 
-double DescriptionFactory::GetBearing(const _Coordinate& A, const _Coordinate& B) const {
-    double deltaLong = DegreeToRadian(B.lon/100000. - A.lon/100000.);
+double DescriptionFactory::GetBearing(
+    const FixedPointCoordinate & A,
+    const FixedPointCoordinate & B
+) const {
+    double deltaLong = DegreeToRadian(B.lon/COORDINATE_PRECISION - A.lon/COORDINATE_PRECISION);
 
-    double lat1 = DegreeToRadian(A.lat/100000.);
-    double lat2 = DegreeToRadian(B.lat/100000.);
+    const double lat1 = DegreeToRadian(A.lat/COORDINATE_PRECISION);
+    const double lat2 = DegreeToRadian(B.lat/COORDINATE_PRECISION);
 
-    double y = sin(deltaLong) * cos(lat2);
-    double x = cos(lat1) * sin(lat2) - sin(lat1) * cos(lat2) * cos(deltaLong);
+    const double y = sin(deltaLong) * cos(lat2);
+    const double x = cos(lat1) * sin(lat2) - sin(lat1) * cos(lat2) * cos(deltaLong);
     double result = RadianToDegree(atan2(y, x));
-    while(result <= 0.)
+    while(result < 0.) {
         result += 360.;
-    while(result >= 360.)
+    }
+    while(result >= 360.) {
         result -= 360.;
-
+    }
     return result;
 }
 
-void DescriptionFactory::SetStartSegment(const PhantomNode & _startPhantom) {
-    startPhantom = _startPhantom;
-    AppendSegment(_startPhantom.location, _PathData(0, _startPhantom.nodeBasedEdgeNameID, 10, _startPhantom.weight1));
+void DescriptionFactory::SetStartSegment(const PhantomNode & sph) {
+    start_phantom = sph;
+    AppendSegment(
+        sph.location,
+        _PathData(0, sph.nodeBasedEdgeNameID, 10, sph.weight1)
+    );
 }
 
-void DescriptionFactory::SetEndSegment(const PhantomNode & _targetPhantom) {
-    targetPhantom = _targetPhantom;
-    pathDescription.push_back(SegmentInformation(_targetPhantom.location, _targetPhantom.nodeBasedEdgeNameID, 0, _targetPhantom.weight1, 0, true) );
+void DescriptionFactory::SetEndSegment(const PhantomNode & tph) {
+    target_phantom = tph;
+    pathDescription.push_back(
+        SegmentInformation(
+            tph.location,
+            tph.nodeBasedEdgeNameID,
+            0,
+            tph.weight1,
+            0,
+            true
+        )
+    );
 }
 
-void DescriptionFactory::AppendSegment(const _Coordinate & coordinate, const _PathData & data ) {
+void DescriptionFactory::AppendSegment(
+    const FixedPointCoordinate & coordinate,
+    const _PathData & data
+) {
     if(1 == pathDescription.size() && pathDescription.back().location == coordinate) {
         pathDescription.back().nameID = data.nameID;
     } else {
@@ -67,144 +93,161 @@ void DescriptionFactory::AppendSegment(const _Coordinate & coordinate, const _Pa
     }
 }
 
-void DescriptionFactory::AppendEncodedPolylineString(std::string & output, bool isEncoded) {
-    if(isEncoded)
-        pc.printEncodedString(pathDescription, output);
-    else
-        pc.printUnencodedString(pathDescription, output);
-}
-
-void DescriptionFactory::AppendEncodedPolylineString(std::string &output) {
-    pc.printEncodedString(pathDescription, output);
-}
-
-void DescriptionFactory::AppendUnencodedPolylineString(std::string &output) {
-    pc.printUnencodedString(pathDescription, output);
-}
-
-void DescriptionFactory::Run(const SearchEngineT &sEngine, const unsigned zoomLevel) {
-
-    if(0 == pathDescription.size())
-        return;
-
-//    unsigned entireLength = 0;
-    /** starts at index 1 */
-    pathDescription[0].length = 0;
-    for(unsigned i = 1; i < pathDescription.size(); ++i) {
-        pathDescription[i].length = ApproximateDistanceByEuclid(pathDescription[i-1].location, pathDescription[i].location);
-    }
-
-    double lengthOfSegment = 0;
-    unsigned durationOfSegment = 0;
-    unsigned indexOfSegmentBegin = 0;
-
-    std::string string0 = sEngine.GetEscapedNameForNameID(pathDescription[0].nameID);
-    std::string string1;
-
-
-    /*Simplify turn instructions
-    Input :
-    10. Turn left on B 36 for 20 km
-    11. Continue on B 35; B 36 for 2 km
-    12. Continue on B 36 for 13 km
-
-    becomes:
-    10. Turn left on B 36 for 35 km
-    */
-//TODO: rework to check only end and start of string.
-//		stl string is way to expensive
-
-//    unsigned lastTurn = 0;
-//    for(unsigned i = 1; i < pathDescription.size(); ++i) {
-//        string1 = sEngine.GetEscapedNameForNameID(pathDescription[i].nameID);
-//        if(TurnInstructionsClass::GoStraight == pathDescription[i].turnInstruction) {
-//            if(std::string::npos != string0.find(string1+";")
-//            		|| std::string::npos != string0.find(";"+string1)
-//            		|| std::string::npos != string0.find(string1+" ;")
-//                    || std::string::npos != string0.find("; "+string1)
-//                    ){
-//                INFO("->next correct: " << string0 << " contains " << string1);
-//                for(; lastTurn != i; ++lastTurn)
-//                    pathDescription[lastTurn].nameID = pathDescription[i].nameID;
-//                pathDescription[i].turnInstruction = TurnInstructionsClass::NoTurn;
-//            } else if(std::string::npos != string1.find(string0+";")
-//            		|| std::string::npos != string1.find(";"+string0)
-//                    || std::string::npos != string1.find(string0+" ;")
-//                    || std::string::npos != string1.find("; "+string0)
-//                    ){
-//                INFO("->prev correct: " << string1 << " contains " << string0);
-//                pathDescription[i].nameID = pathDescription[i-1].nameID;
-//                pathDescription[i].turnInstruction = TurnInstructionsClass::NoTurn;
-//            }
-//        }
-//        if (TurnInstructionsClass::NoTurn != pathDescription[i].turnInstruction) {
-//            lastTurn = i;
-//        }
-//        string0 = string1;
-//    }
-
-
-    for(unsigned i = 1; i < pathDescription.size(); ++i) {
-        entireLength += pathDescription[i].length;
-        lengthOfSegment += pathDescription[i].length;
-        durationOfSegment += pathDescription[i].duration;
-        pathDescription[indexOfSegmentBegin].length = lengthOfSegment;
-        pathDescription[indexOfSegmentBegin].duration = durationOfSegment;
-
-
-        if(TurnInstructionsClass::NoTurn != pathDescription[i].turnInstruction) {
-            //INFO("Turn after " << lengthOfSegment << "m into way with name id " << segment.nameID);
-            assert(pathDescription[i].necessary);
-            lengthOfSegment = 0;
-            durationOfSegment = 0;
-            indexOfSegmentBegin = i;
-        }
-    }
-    //    INFO("#segs: " << pathDescription.size());
-
-    //Post-processing to remove empty or nearly empty path segments
-    if(FLT_EPSILON > pathDescription.back().length) {
-        //        INFO("#segs: " << pathDescription.size() << ", last ratio: " << targetPhantom.ratio << ", length: " << pathDescription.back().length);
-        if(pathDescription.size() > 2){
-            pathDescription.pop_back();
-            pathDescription.back().necessary = true;
-            pathDescription.back().turnInstruction = TurnInstructions.NoTurn;
-            targetPhantom.nodeBasedEdgeNameID = (pathDescription.end()-2)->nameID;
-            //            INFO("Deleting last turn instruction");
-        }
+void DescriptionFactory::AppendEncodedPolylineString(
+    const bool return_encoded,
+    std::vector<std::string> & output
+) {
+    std::string temp;
+    if(return_encoded) {
+        polyline_compressor.printEncodedString(pathDescription, temp);
     } else {
-        pathDescription[indexOfSegmentBegin].duration *= (1.-targetPhantom.ratio);
+        polyline_compressor.printUnencodedString(pathDescription, temp);
     }
-    if(FLT_EPSILON > pathDescription[0].length) {
-        //TODO: this is never called actually?
-        if(pathDescription.size() > 2) {
-            pathDescription.erase(pathDescription.begin());
-            pathDescription[0].turnInstruction = TurnInstructions.HeadOn;
-            pathDescription[0].necessary = true;
-            startPhantom.nodeBasedEdgeNameID = pathDescription[0].nameID;
-            //            INFO("Deleting first turn instruction, ratio: " << startPhantom.ratio << ", length: " << pathDescription[0].length);
-        }
-    } else {
-        pathDescription[0].duration *= startPhantom.ratio;
-    }
-
-    //Generalize poly line
-    dp.Run(pathDescription, zoomLevel);
-
-    //fix what needs to be fixed else
-    for(unsigned i = 0; i < pathDescription.size()-1 && pathDescription.size() >= 2; ++i){
-        if(pathDescription[i].necessary) {
-            double angle = GetBearing(pathDescription[i].location, pathDescription[i+1].location);
-            pathDescription[i].bearing = angle;
-        }
-    }
-
-//    BuildRouteSummary(entireLength, duration);
-    return;
+    output.push_back(temp);
 }
 
-void DescriptionFactory::BuildRouteSummary(const double distance, const unsigned time) {
-    summary.startName = startPhantom.nodeBasedEdgeNameID;
-    summary.destName = targetPhantom.nodeBasedEdgeNameID;
+void DescriptionFactory::AppendEncodedPolylineString(
+    std::vector<std::string> &output
+) const {
+    std::string temp;
+    polyline_compressor.printEncodedString(pathDescription, temp);
+    output.push_back(temp);
+}
+
+void DescriptionFactory::AppendUnencodedPolylineString(
+    std::vector<std::string>& output
+) const {
+    std::string temp;
+    polyline_compressor.printUnencodedString(pathDescription, temp);
+    output.push_back(temp);
+}
+
+// void DescriptionFactory::Run(const SearchEngine &sEngine, const unsigned zoomLevel) {
+
+//     if(0 == pathDescription.size())
+//         return;
+
+// //    unsigned entireLength = 0;
+//     /** starts at index 1 */
+//     pathDescription[0].length = 0;
+//     for(unsigned i = 1; i < pathDescription.size(); ++i) {
+//         pathDescription[i].length = ApproximateEuclideanDistance(pathDescription[i-1].location, pathDescription[i].location);
+//     }
+
+//     double lengthOfSegment = 0;
+//     unsigned durationOfSegment = 0;
+//     unsigned indexOfSegmentBegin = 0;
+
+//     std::string string0 = sEngine.GetEscapedNameForNameID(pathDescription[0].nameID);
+//     std::string string1;
+
+
+//     /*Simplify turn instructions
+//     Input :
+//     10. Turn left on B 36 for 20 km
+//     11. Continue on B 35; B 36 for 2 km
+//     12. Continue on B 36 for 13 km
+
+//     becomes:
+//     10. Turn left on B 36 for 35 km
+//     */
+// //TODO: rework to check only end and start of string.
+// //		stl string is way to expensive
+
+// //    unsigned lastTurn = 0;
+// //    for(unsigned i = 1; i < pathDescription.size(); ++i) {
+// //        string1 = sEngine.GetEscapedNameForNameID(pathDescription[i].nameID);
+// //        if(TurnInstructionsClass::GoStraight == pathDescription[i].turnInstruction) {
+// //            if(std::string::npos != string0.find(string1+";")
+// //            		|| std::string::npos != string0.find(";"+string1)
+// //            		|| std::string::npos != string0.find(string1+" ;")
+// //                    || std::string::npos != string0.find("; "+string1)
+// //                    ){
+// //                SimpleLogger().Write() << "->next correct: " << string0 << " contains " << string1;
+// //                for(; lastTurn != i; ++lastTurn)
+// //                    pathDescription[lastTurn].nameID = pathDescription[i].nameID;
+// //                pathDescription[i].turnInstruction = TurnInstructionsClass::NoTurn;
+// //            } else if(std::string::npos != string1.find(string0+";")
+// //            		|| std::string::npos != string1.find(";"+string0)
+// //                    || std::string::npos != string1.find(string0+" ;")
+// //                    || std::string::npos != string1.find("; "+string0)
+// //                    ){
+// //                SimpleLogger().Write() << "->prev correct: " << string1 << " contains " << string0;
+// //                pathDescription[i].nameID = pathDescription[i-1].nameID;
+// //                pathDescription[i].turnInstruction = TurnInstructionsClass::NoTurn;
+// //            }
+// //        }
+// //        if (TurnInstructionsClass::NoTurn != pathDescription[i].turnInstruction) {
+// //            lastTurn = i;
+// //        }
+// //        string0 = string1;
+// //    }
+
+
+//     for(unsigned i = 1; i < pathDescription.size(); ++i) {
+//         entireLength += pathDescription[i].length;
+//         lengthOfSegment += pathDescription[i].length;
+//         durationOfSegment += pathDescription[i].duration;
+//         pathDescription[indexOfSegmentBegin].length = lengthOfSegment;
+//         pathDescription[indexOfSegmentBegin].duration = durationOfSegment;
+
+
+//         if(TurnInstructionsClass::NoTurn != pathDescription[i].turnInstruction) {
+//             //SimpleLogger().Write() << "Turn after " << lengthOfSegment << "m into way with name id " << segment.nameID;
+//             assert(pathDescription[i].necessary);
+//             lengthOfSegment = 0;
+//             durationOfSegment = 0;
+//             indexOfSegmentBegin = i;
+//         }
+//     }
+//     //    SimpleLogger().Write() << "#segs: " << pathDescription.size();
+
+//     //Post-processing to remove empty or nearly empty path segments
+//     if(FLT_EPSILON > pathDescription.back().length) {
+//         //        SimpleLogger().Write() << "#segs: " << pathDescription.size() << ", last ratio: " << target_phantom.ratio << ", length: " << pathDescription.back().length;
+//         if(pathDescription.size() > 2){
+//             pathDescription.pop_back();
+//             pathDescription.back().necessary = true;
+//             pathDescription.back().turnInstruction = TurnInstructions.NoTurn;
+//             target_phantom.nodeBasedEdgeNameID = (pathDescription.end()-2)->nameID;
+//             //            SimpleLogger().Write() << "Deleting last turn instruction";
+//         }
+//     } else {
+//         pathDescription[indexOfSegmentBegin].duration *= (1.-target_phantom.ratio);
+//     }
+//     if(FLT_EPSILON > pathDescription[0].length) {
+//         //TODO: this is never called actually?
+//         if(pathDescription.size() > 2) {
+//             pathDescription.erase(pathDescription.begin());
+//             pathDescription[0].turnInstruction = TurnInstructions.HeadOn;
+//             pathDescription[0].necessary = true;
+//             start_phantom.nodeBasedEdgeNameID = pathDescription[0].nameID;
+//             //            SimpleLogger().Write() << "Deleting first turn instruction, ratio: " << start_phantom.ratio << ", length: " << pathDescription[0].length;
+//         }
+//     } else {
+//         pathDescription[0].duration *= start_phantom.ratio;
+//     }
+
+//     //Generalize poly line
+//     dp.Run(pathDescription, zoomLevel);
+
+//     //fix what needs to be fixed else
+//     for(unsigned i = 0; i < pathDescription.size()-1 && pathDescription.size() >= 2; ++i){
+//         if(pathDescription[i].necessary) {
+//             double angle = GetBearing(pathDescription[i].location, pathDescription[i+1].location);
+//             pathDescription[i].bearing = angle;
+//         }
+//     }
+
+// //    BuildRouteSummary(entireLength, duration);
+//     return;
+// }
+
+void DescriptionFactory::BuildRouteSummary(
+    const double distance,
+    const unsigned time
+) {
+    summary.startName = start_phantom.nodeBasedEdgeNameID;
+    summary.destName = target_phantom.nodeBasedEdgeNameID;
     summary.BuildDurationAndLengthStrings(distance, time);
 }

Descriptors/DescriptionFactory.h

@@ -1,65 +1,77 @@
 /*
- open source routing machine
- Copyright (C) Dennis Luxen, others 2010
 
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU AFFERO General Public License as published by
- the Free Software Foundation; either version 3 of the License, or
- any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
- You should have received a copy of the GNU Affero General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 DESCRIPTIONFACTORY_H_
 #define DESCRIPTIONFACTORY_H_
 
-#include <vector>
-
-#include "../typedefs.h"
 #include "../Algorithms/DouglasPeucker.h"
 #include "../Algorithms/PolylineCompressor.h"
 #include "../DataStructures/Coordinate.h"
-#include "../DataStructures/QueryEdge.h"
-#include "../DataStructures/SearchEngine.h"
+#include "../DataStructures/PhantomNodes.h"
+#include "../DataStructures/RawRouteData.h"
 #include "../DataStructures/SegmentInformation.h"
 #include "../DataStructures/TurnInstructions.h"
+#include "../Util/SimpleLogger.h"
+#include "../typedefs.h"
+
+#include <limits>
+#include <vector>
 
 /* This class is fed with all way segments in consecutive order
  *  and produces the description plus the encoded polyline */
 
 class DescriptionFactory {
-    DouglasPeucker<SegmentInformation> dp;
-    PolylineCompressor pc;
-    PhantomNode startPhantom, targetPhantom;
-
-    typedef SearchEngine<QueryEdge::EdgeData, StaticGraph<QueryEdge::EdgeData> > SearchEngineT;
+    DouglasPeucker polyline_generalizer;
+    PolylineCompressor polyline_compressor;
+    PhantomNode start_phantom, target_phantom;
 
     double DegreeToRadian(const double degree) const;
     double RadianToDegree(const double degree) const;
 public:
-    struct _RouteSummary {
+    struct RouteSummary {
         std::string lengthString;
         std::string durationString;
         unsigned startName;
         unsigned destName;
-        _RouteSummary() : lengthString("0"), durationString("0"), startName(0), destName(0) {}
-        void BuildDurationAndLengthStrings(const double distance, const unsigned time) {
+        RouteSummary() :
+            lengthString("0"),
+            durationString("0"),
+            startName(0),
+            destName(0)
+        {}
+
+        void BuildDurationAndLengthStrings(
+            const double distance,
+            const unsigned time
+        ) {
             //compute distance/duration for route summary
-            std::ostringstream s;
-            s << round(distance);
-            lengthString = s.str();
+            intToString(round(distance), lengthString);
             int travelTime = time/10 + 1;
-            s.str("");
-            s << travelTime;
-            durationString = s.str();
+            intToString(travelTime, durationString);
         }
     } summary;
 
@@ -69,15 +81,140 @@ public:
     std::vector <SegmentInformation> pathDescription;
     DescriptionFactory();
     virtual ~DescriptionFactory();
-    double GetBearing(const _Coordinate& C, const _Coordinate& B) const;
-    void AppendEncodedPolylineString(std::string &output);
-    void AppendUnencodedPolylineString(std::string &output);
-    void AppendSegment(const _Coordinate & coordinate, const _PathData & data);
+    double GetBearing(const FixedPointCoordinate& C, const FixedPointCoordinate& B) const;
+    void AppendEncodedPolylineString(std::vector<std::string> &output) const;
+    void AppendUnencodedPolylineString(std::vector<std::string> &output) const;
+    void AppendSegment(const FixedPointCoordinate & coordinate, const _PathData & data);
     void BuildRouteSummary(const double distance, const unsigned time);
-    void SetStartSegment(const PhantomNode & startPhantom);
-    void SetEndSegment(const PhantomNode & startPhantom);
-    void AppendEncodedPolylineString(std::string & output, bool isEncoded);
-    void Run(const SearchEngineT &sEngine, const unsigned zoomLevel);
+    void SetStartSegment(const PhantomNode & start_phantom);
+    void SetEndSegment(const PhantomNode & start_phantom);
+    void AppendEncodedPolylineString(
+        const bool return_encoded,
+        std::vector<std::string> & output
+        );
+
+    template<class DataFacadeT>
+    void Run(const DataFacadeT * facade, const unsigned zoomLevel) {
+
+        if( pathDescription.empty() ) {
+            return;
+        }
+
+    //    unsigned entireLength = 0;
+        /** starts at index 1 */
+        pathDescription[0].length = 0;
+        for(unsigned i = 1; i < pathDescription.size(); ++i) {
+            pathDescription[i].length = ApproximateEuclideanDistance(pathDescription[i-1].location, pathDescription[i].location);
+        }
+
+        double lengthOfSegment = 0;
+        unsigned durationOfSegment = 0;
+        unsigned indexOfSegmentBegin = 0;
+
+        // std::string string0 = facade->GetEscapedNameForNameID(pathDescription[0].nameID);
+        // std::string string1;
+
+
+        /*Simplify turn instructions
+        Input :
+        10. Turn left on B 36 for 20 km
+        11. Continue on B 35; B 36 for 2 km
+        12. Continue on B 36 for 13 km
+
+        becomes:
+        10. Turn left on B 36 for 35 km
+        */
+    //TODO: rework to check only end and start of string.
+    //      stl string is way to expensive
+
+    //    unsigned lastTurn = 0;
+    //    for(unsigned i = 1; i < pathDescription.size(); ++i) {
+    //        string1 = sEngine.GetEscapedNameForNameID(pathDescription[i].nameID);
+    //        if(TurnInstructionsClass::GoStraight == pathDescription[i].turnInstruction) {
+    //            if(std::string::npos != string0.find(string1+";")
+    //                  || std::string::npos != string0.find(";"+string1)
+    //                  || std::string::npos != string0.find(string1+" ;")
+    //                    || std::string::npos != string0.find("; "+string1)
+    //                    ){
+    //                SimpleLogger().Write() << "->next correct: " << string0 << " contains " << string1;
+    //                for(; lastTurn != i; ++lastTurn)
+    //                    pathDescription[lastTurn].nameID = pathDescription[i].nameID;
+    //                pathDescription[i].turnInstruction = TurnInstructionsClass::NoTurn;
+    //            } else if(std::string::npos != string1.find(string0+";")
+    //                  || std::string::npos != string1.find(";"+string0)
+    //                    || std::string::npos != string1.find(string0+" ;")
+    //                    || std::string::npos != string1.find("; "+string0)
+    //                    ){
+    //                SimpleLogger().Write() << "->prev correct: " << string1 << " contains " << string0;
+    //                pathDescription[i].nameID = pathDescription[i-1].nameID;
+    //                pathDescription[i].turnInstruction = TurnInstructionsClass::NoTurn;
+    //            }
+    //        }
+    //        if (TurnInstructionsClass::NoTurn != pathDescription[i].turnInstruction) {
+    //            lastTurn = i;
+    //        }
+    //        string0 = string1;
+    //    }
+
+
+        for(unsigned i = 1; i < pathDescription.size(); ++i) {
+            entireLength += pathDescription[i].length;
+            lengthOfSegment += pathDescription[i].length;
+            durationOfSegment += pathDescription[i].duration;
+            pathDescription[indexOfSegmentBegin].length = lengthOfSegment;
+            pathDescription[indexOfSegmentBegin].duration = durationOfSegment;
+
+
+            if(TurnInstructionsClass::NoTurn != pathDescription[i].turnInstruction) {
+                //SimpleLogger().Write() << "Turn after " << lengthOfSegment << "m into way with name id " << pathDescription[i].nameID;
+                assert(pathDescription[i].necessary);
+                lengthOfSegment = 0;
+                durationOfSegment = 0;
+                indexOfSegmentBegin = i;
+            }
+        }
+        //    SimpleLogger().Write() << "#segs: " << pathDescription.size();
+
+        //Post-processing to remove empty or nearly empty path segments
+        if(std::numeric_limits<double>::epsilon() > pathDescription.back().length) {
+            //        SimpleLogger().Write() << "#segs: " << pathDescription.size() << ", last ratio: " << target_phantom.ratio << ", length: " << pathDescription.back().length;
+            if(pathDescription.size() > 2){
+                pathDescription.pop_back();
+                pathDescription.back().necessary = true;
+                pathDescription.back().turnInstruction = TurnInstructions.NoTurn;
+                target_phantom.nodeBasedEdgeNameID = (pathDescription.end()-2)->nameID;
+                //            SimpleLogger().Write() << "Deleting last turn instruction";
+            }
+        } else {
+            pathDescription[indexOfSegmentBegin].duration *= (1.-target_phantom.ratio);
+        }
+        if(std::numeric_limits<double>::epsilon() > pathDescription[0].length) {
+            //TODO: this is never called actually?
+            if(pathDescription.size() > 2) {
+                pathDescription.erase(pathDescription.begin());
+                pathDescription[0].turnInstruction = TurnInstructions.HeadOn;
+                pathDescription[0].necessary = true;
+                start_phantom.nodeBasedEdgeNameID = pathDescription[0].nameID;
+                //            SimpleLogger().Write() << "Deleting first turn instruction, ratio: " << start_phantom.ratio << ", length: " << pathDescription[0].length;
+            }
+        } else {
+            pathDescription[0].duration *= start_phantom.ratio;
+        }
+
+        //Generalize poly line
+        polyline_generalizer.Run(pathDescription, zoomLevel);
+
+        //fix what needs to be fixed else
+        for(unsigned i = 0; i < pathDescription.size()-1 && pathDescription.size() >= 2; ++i){
+            if(pathDescription[i].necessary) {
+                double angle = GetBearing(pathDescription[i].location, pathDescription[i+1].location);
+                pathDescription[i].bearing = angle;
+            }
+        }
+
+    //    BuildRouteSummary(entireLength, duration);
+        return;
+    }
 };
 
 #endif /* DESCRIPTIONFACTORY_H_ */

Descriptors/GPXDescriptor.h

@@ -1,65 +1,103 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 GPX_DESCRIPTOR_H_
 #define GPX_DESCRIPTOR_H_
 
-#include <boost/foreach.hpp>
 #include "BaseDescriptor.h"
 
-template<class SearchEngineT>
-class GPXDescriptor : public BaseDescriptor<SearchEngineT>{
+#include <boost/foreach.hpp>
+
+template<class DataFacadeT>
+class GPXDescriptor : public BaseDescriptor<DataFacadeT> {
 private:
-    _DescriptorConfig config;
-    _Coordinate current;
+    DescriptorConfig config;
+    FixedPointCoordinate current;
 
     std::string tmp;
 public:
-    void SetConfig(const _DescriptorConfig& c) { config = c; }
-    void Run(http::Reply & reply, const RawRouteData &rawRoute, PhantomNodes &phantomNodes, SearchEngineT &sEngine) {
-        reply.content += ("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
-        reply.content += "<gpx creator=\"OSRM Routing Engine\" version=\"1.1\" xmlns=\"http://www.topografix.com/GPX/1/1\" "
+    void SetConfig(const DescriptorConfig & c) { config = c; }
+
+    //TODO: reorder parameters
+    void Run(
+        http::Reply & reply,
+        const RawRouteData &rawRoute,
+        PhantomNodes &phantomNodes,
+        const DataFacadeT * facade
+    ) {
+        reply.content.push_back("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
+        reply.content.push_back(
+                "<gpx creator=\"OSRM Routing Engine\" version=\"1.1\" "
+                "xmlns=\"http://www.topografix.com/GPX/1/1\" "
                 "xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" "
                 "xsi:schemaLocation=\"http://www.topografix.com/GPX/1/1 gpx.xsd"
-                "\">";
-        reply.content += "<rte>";
-        if(rawRoute.lengthOfShortestPath != INT_MAX && rawRoute.computedShortestPath.size()) {
-            convertInternalLatLonToString(phantomNodes.startPhantom.location.lat, tmp);
-            reply.content += "<rtept lat=\"" + tmp + "\" ";
-            convertInternalLatLonToString(phantomNodes.startPhantom.location.lon, tmp);
-            reply.content += "lon=\"" + tmp + "\"></rtept>";
+                "\">");
+        reply.content.push_back(
+                "<metadata><copyright author=\"Project OSRM\"><license>Data (c)"
+                " OpenStreetMap contributors (ODbL)</license></copyright>"
+                "</metadata>");
+        reply.content.push_back("<rte>");
+        bool found_route =  (rawRoute.lengthOfShortestPath != INT_MAX) &&
+                            (rawRoute.computedShortestPath.size()         );
+        if( found_route ) {
+            convertInternalLatLonToString(
+                phantomNodes.startPhantom.location.lat,
+                tmp
+            );
+            reply.content.push_back("<rtept lat=\"" + tmp + "\" ");
+            convertInternalLatLonToString(
+                phantomNodes.startPhantom.location.lon,
+                tmp
+            );
+            reply.content.push_back("lon=\"" + tmp + "\"></rtept>");
 
-            BOOST_FOREACH(_PathData pathData, rawRoute.computedShortestPath) {
-                sEngine.GetCoordinatesForNodeID(pathData.node, current);
+            BOOST_FOREACH(
+                const _PathData & pathData,
+                rawRoute.computedShortestPath
+            ) {
+                current = facade->GetCoordinateOfNode(pathData.node);
 
                 convertInternalLatLonToString(current.lat, tmp);
-                reply.content += "<rtept lat=\"" + tmp + "\" ";
+                reply.content.push_back("<rtept lat=\"" + tmp + "\" ");
                 convertInternalLatLonToString(current.lon, tmp);
-                reply.content += "lon=\"" + tmp + "\"></rtept>";
+                reply.content.push_back("lon=\"" + tmp + "\"></rtept>");
             }
-            convertInternalLatLonToString(phantomNodes.targetPhantom.location.lat, tmp);
-            reply.content += "<rtept lat=\"" + tmp + "\" ";
-            convertInternalLatLonToString(phantomNodes.targetPhantom.location.lon, tmp);
-            reply.content += "lon=\"" + tmp + "\"></rtept>";
+            convertInternalLatLonToString(
+                phantomNodes.targetPhantom.location.lat,
+                tmp
+            );
+            reply.content.push_back("<rtept lat=\"" + tmp + "\" ");
+            convertInternalLatLonToString(
+                phantomNodes.targetPhantom.location.lon,
+                tmp
+            );
+            reply.content.push_back("lon=\"" + tmp + "\"></rtept>");
         }
-        reply.content += "</rte></gpx>";
+        reply.content.push_back("</rte></gpx>");
     }
 };
-#endif /* GPX_DESCRIPTOR_H_ */
+#endif // GPX_DESCRIPTOR_H_

Descriptors/JSONDescriptor.h

@@ -1,31 +1,33 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 JSON_DESCRIPTOR_H_
 #define JSON_DESCRIPTOR_H_
 
-#include <algorithm>
-
-#include <boost/lambda/lambda.hpp>
-#include <boost/bind.hpp>
-
 #include "BaseDescriptor.h"
 #include "DescriptionFactory.h"
 #include "../Algorithms/ObjectToBase64.h"
@@ -34,28 +36,38 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #include "../Util/Azimuth.h"
 #include "../Util/StringUtil.h"
 
-template<class SearchEngineT>
-class JSONDescriptor : public BaseDescriptor<SearchEngineT>{
+#include <boost/bind.hpp>
+#include <boost/lambda/lambda.hpp>
+
+#include <algorithm>
+
+template<class DataFacadeT>
+class JSONDescriptor : public BaseDescriptor<DataFacadeT> {
 private:
-    _DescriptorConfig config;
-    DescriptionFactory descriptionFactory;
+    DescriptorConfig config;
+    DescriptionFactory description_factory;
     DescriptionFactory alternateDescriptionFactory;
-    _Coordinate current;
-    unsigned numberOfEnteredRestrictedAreas;
-    struct {
-        int startIndex;
-        int nameID;
-        int leaveAtExit;
+    FixedPointCoordinate current;
+    unsigned entered_restricted_area_count;
+    struct RoundAbout{
+        RoundAbout() :
+            start_index(INT_MAX),
+            name_id(INT_MAX),
+            leave_at_exit(INT_MAX)
+        {}
+        int start_index;
+        int name_id;
+        int leave_at_exit;
     } roundAbout;
 
     struct Segment {
-        Segment() : nameID(-1), length(-1), position(-1) {}
-        Segment(int n, int l, int p) : nameID(n), length(l), position(p) {}
-        int nameID;
+        Segment() : name_id(-1), length(-1), position(-1) {}
+        Segment(int n, int l, int p) : name_id(n), length(l), position(p) {}
+        int name_id;
         int length;
         int position;
     };
-    std::vector<Segment> shortestSegments, alternativeSegments;
+    std::vector<Segment> shortest_path_segments, alternative_path_segments;
 
     struct RouteNames {
         std::string shortestPathName1;
@@ -65,220 +77,261 @@ private:
     };
 
 public:
-    JSONDescriptor() : numberOfEnteredRestrictedAreas(0) {}
-    void SetConfig(const _DescriptorConfig & c) { config = c; }
+    JSONDescriptor() : entered_restricted_area_count(0) {}
+    void SetConfig(const DescriptorConfig & c) { config = c; }
 
-    void Run(http::Reply & reply, const RawRouteData &rawRoute, PhantomNodes &phantomNodes, SearchEngineT &sEngine) {
+    //TODO: reorder parameters
+    void Run(
+        http::Reply & reply,
+        const RawRouteData & raw_route_information,
+        PhantomNodes & phantom_nodes,
+        const DataFacadeT * facade
+    ) {
 
         WriteHeaderToOutput(reply.content);
 
-        if(rawRoute.lengthOfShortestPath != INT_MAX) {
-            descriptionFactory.SetStartSegment(phantomNodes.startPhantom);
-            reply.content += "0,"
-                    "\"status_message\": \"Found route between points\",";
+        if(raw_route_information.lengthOfShortestPath != INT_MAX) {
+            description_factory.SetStartSegment(phantom_nodes.startPhantom);
+            reply.content.push_back("0,"
+                    "\"status_message\": \"Found route between points\",");
 
             //Get all the coordinates for the computed route
-            BOOST_FOREACH(const _PathData & pathData, rawRoute.computedShortestPath) {
-                sEngine.GetCoordinatesForNodeID(pathData.node, current);
-                descriptionFactory.AppendSegment(current, pathData );
+            BOOST_FOREACH(const _PathData & path_data, raw_route_information.computedShortestPath) {
+                current = facade->GetCoordinateOfNode(path_data.node);
+                description_factory.AppendSegment(current, path_data );
             }
-            descriptionFactory.SetEndSegment(phantomNodes.targetPhantom);
+            description_factory.SetEndSegment(phantom_nodes.targetPhantom);
         } else {
             //We do not need to do much, if there is no route ;-)
-            reply.content += "207,"
-                    "\"status_message\": \"Cannot find route between points\",";
+            reply.content.push_back("207,"
+                    "\"status_message\": \"Cannot find route between points\",");
         }
 
-        descriptionFactory.Run(sEngine, config.z);
-        reply.content += "\"route_geometry\": ";
+        description_factory.Run(facade, config.zoom_level);
+        reply.content.push_back("\"route_geometry\": ");
         if(config.geometry) {
-            descriptionFactory.AppendEncodedPolylineString(reply.content, config.encodeGeometry);
+            description_factory.AppendEncodedPolylineString(
+               config.encode_geometry,
+               reply.content
+            );
         } else {
-            reply.content += "[]";
+            reply.content.push_back("[]");
         }
 
-        reply.content += ","
-                "\"route_instructions\": [";
-        numberOfEnteredRestrictedAreas = 0;
+        reply.content.push_back(","
+                "\"route_instructions\": [");
+        entered_restricted_area_count = 0;
         if(config.instructions) {
-            BuildTextualDescription(descriptionFactory, reply, rawRoute.lengthOfShortestPath, sEngine, shortestSegments);
+            BuildTextualDescription(
+                description_factory,
+                reply,
+                raw_route_information.lengthOfShortestPath,
+                facade,
+                shortest_path_segments
+            );
         } else {
-            BOOST_FOREACH(const SegmentInformation & segment, descriptionFactory.pathDescription) {
-                TurnInstruction currentInstruction = segment.turnInstruction & TurnInstructions.InverseAccessRestrictionFlag;
-                numberOfEnteredRestrictedAreas += (currentInstruction != segment.turnInstruction);
+            BOOST_FOREACH(
+                const SegmentInformation & segment,
+                description_factory.pathDescription
+            ) {
+                TurnInstruction current_instruction = segment.turnInstruction & TurnInstructions.InverseAccessRestrictionFlag;
+                entered_restricted_area_count += (current_instruction != segment.turnInstruction);
             }
         }
-        reply.content += "],";
-        descriptionFactory.BuildRouteSummary(descriptionFactory.entireLength, rawRoute.lengthOfShortestPath - ( numberOfEnteredRestrictedAreas*TurnInstructions.AccessRestrictionPenalty));
+        reply.content.push_back("],");
+        description_factory.BuildRouteSummary(
+            description_factory.entireLength,
+            raw_route_information.lengthOfShortestPath - ( entered_restricted_area_count*TurnInstructions.AccessRestrictionPenalty)
+        );
 
-        reply.content += "\"route_summary\":";
-        reply.content += "{";
-        reply.content += "\"total_distance\":";
-        reply.content += descriptionFactory.summary.lengthString;
-        reply.content += ","
-                "\"total_time\":";
-        reply.content += descriptionFactory.summary.durationString;
-        reply.content += ","
-                "\"start_point\":\"";
-        reply.content += sEngine.GetEscapedNameForNameID(descriptionFactory.summary.startName);
-        reply.content += "\","
-                "\"end_point\":\"";
-        reply.content += sEngine.GetEscapedNameForNameID(descriptionFactory.summary.destName);
-        reply.content += "\"";
-        reply.content += "}";
-        reply.content +=",";
+        reply.content.push_back("\"route_summary\":");
+        reply.content.push_back("{");
+        reply.content.push_back("\"total_distance\":");
+        reply.content.push_back(description_factory.summary.lengthString);
+        reply.content.push_back(","
+                "\"total_time\":");
+        reply.content.push_back(description_factory.summary.durationString);
+        reply.content.push_back(","
+                "\"start_point\":\"");
+        reply.content.push_back(
+            facade->GetEscapedNameForNameID(description_factory.summary.startName)
+        );
+        reply.content.push_back("\","
+                "\"end_point\":\"");
+        reply.content.push_back(
+            facade->GetEscapedNameForNameID(description_factory.summary.destName)
+        );
+        reply.content.push_back("\"");
+        reply.content.push_back("}");
+        reply.content.push_back(",");
 
         //only one alternative route is computed at this time, so this is hardcoded
 
-        if(rawRoute.lengthOfAlternativePath != INT_MAX) {
-            alternateDescriptionFactory.SetStartSegment(phantomNodes.startPhantom);
+        if(raw_route_information.lengthOfAlternativePath != INT_MAX) {
+            alternateDescriptionFactory.SetStartSegment(phantom_nodes.startPhantom);
             //Get all the coordinates for the computed route
-            BOOST_FOREACH(const _PathData & pathData, rawRoute.computedAlternativePath) {
-                sEngine.GetCoordinatesForNodeID(pathData.node, current);
-                alternateDescriptionFactory.AppendSegment(current, pathData );
+            BOOST_FOREACH(const _PathData & path_data, raw_route_information.computedAlternativePath) {
+                current = facade->GetCoordinateOfNode(path_data.node);
+                alternateDescriptionFactory.AppendSegment(current, path_data );
             }
-            alternateDescriptionFactory.SetEndSegment(phantomNodes.targetPhantom);
+            alternateDescriptionFactory.SetEndSegment(phantom_nodes.targetPhantom);
         }
-        alternateDescriptionFactory.Run(sEngine, config.z);
+        alternateDescriptionFactory.Run(facade, config.zoom_level);
 
         //give an array of alternative routes
-        reply.content += "\"alternative_geometries\": [";
-        if(config.geometry && INT_MAX != rawRoute.lengthOfAlternativePath) {
+        reply.content.push_back("\"alternative_geometries\": [");
+        if(config.geometry && INT_MAX != raw_route_information.lengthOfAlternativePath) {
             //Generate the linestrings for each alternative
-            alternateDescriptionFactory.AppendEncodedPolylineString(reply.content, config.encodeGeometry);
+            alternateDescriptionFactory.AppendEncodedPolylineString(
+                config.encode_geometry,
+                reply.content
+            );
         }
-        reply.content += "],";
-        reply.content += "\"alternative_instructions\":[";
-        numberOfEnteredRestrictedAreas = 0;
-        if(INT_MAX != rawRoute.lengthOfAlternativePath) {
-            reply.content += "[";
+        reply.content.push_back("],");
+        reply.content.push_back("\"alternative_instructions\":[");
+        entered_restricted_area_count = 0;
+        if(INT_MAX != raw_route_information.lengthOfAlternativePath) {
+            reply.content.push_back("[");
             //Generate instructions for each alternative
             if(config.instructions) {
-                BuildTextualDescription(alternateDescriptionFactory, reply, rawRoute.lengthOfAlternativePath, sEngine, alternativeSegments);
+                BuildTextualDescription(
+                    alternateDescriptionFactory,
+                    reply,
+                    raw_route_information.lengthOfAlternativePath,
+                    facade,
+                    alternative_path_segments
+                );
             } else {
                 BOOST_FOREACH(const SegmentInformation & segment, alternateDescriptionFactory.pathDescription) {
-                	TurnInstruction currentInstruction = segment.turnInstruction & TurnInstructions.InverseAccessRestrictionFlag;
-                    numberOfEnteredRestrictedAreas += (currentInstruction != segment.turnInstruction);
+                	TurnInstruction current_instruction = segment.turnInstruction & TurnInstructions.InverseAccessRestrictionFlag;
+                    entered_restricted_area_count += (current_instruction != segment.turnInstruction);
                 }
             }
-            reply.content += "]";
+            reply.content.push_back("]");
         }
-        reply.content += "],";
-        reply.content += "\"alternative_summaries\":[";
-        if(INT_MAX != rawRoute.lengthOfAlternativePath) {
+        reply.content.push_back("],");
+        reply.content.push_back("\"alternative_summaries\":[");
+        if(INT_MAX != raw_route_information.lengthOfAlternativePath) {
             //Generate route summary (length, duration) for each alternative
-            alternateDescriptionFactory.BuildRouteSummary(alternateDescriptionFactory.entireLength, rawRoute.lengthOfAlternativePath - ( numberOfEnteredRestrictedAreas*TurnInstructions.AccessRestrictionPenalty));
-            reply.content += "{";
-            reply.content += "\"total_distance\":";
-            reply.content += alternateDescriptionFactory.summary.lengthString;
-            reply.content += ","
-                    "\"total_time\":";
-            reply.content += alternateDescriptionFactory.summary.durationString;
-            reply.content += ","
-                    "\"start_point\":\"";
-            reply.content += sEngine.GetEscapedNameForNameID(descriptionFactory.summary.startName);
-            reply.content += "\","
-                    "\"end_point\":\"";
-            reply.content += sEngine.GetEscapedNameForNameID(descriptionFactory.summary.destName);
-            reply.content += "\"";
-            reply.content += "}";
+            alternateDescriptionFactory.BuildRouteSummary(alternateDescriptionFactory.entireLength, raw_route_information.lengthOfAlternativePath - ( entered_restricted_area_count*TurnInstructions.AccessRestrictionPenalty));
+            reply.content.push_back("{");
+            reply.content.push_back("\"total_distance\":");
+            reply.content.push_back(alternateDescriptionFactory.summary.lengthString);
+            reply.content.push_back(","
+                    "\"total_time\":");
+            reply.content.push_back(alternateDescriptionFactory.summary.durationString);
+            reply.content.push_back(","
+                    "\"start_point\":\"");
+            reply.content.push_back(facade->GetEscapedNameForNameID(description_factory.summary.startName));
+            reply.content.push_back("\","
+                    "\"end_point\":\"");
+            reply.content.push_back(facade->GetEscapedNameForNameID(description_factory.summary.destName));
+            reply.content.push_back("\"");
+            reply.content.push_back("}");
         }
-        reply.content += "],";
+        reply.content.push_back("],");
 
         //Get Names for both routes
         RouteNames routeNames;
-        GetRouteNames(shortestSegments, alternativeSegments, sEngine, routeNames);
+        GetRouteNames(shortest_path_segments, alternative_path_segments, facade, routeNames);
 
-        reply.content += "\"route_name\":[\"";
-        reply.content += routeNames.shortestPathName1;
-        reply.content += "\",\"";
-        reply.content += routeNames.shortestPathName2;
-        reply.content += "\"],"
-                "\"alternative_names\":[";
-        reply.content += "[\"";
-        reply.content += routeNames.alternativePathName1;
-        reply.content += "\",\"";
-        reply.content += routeNames.alternativePathName2;
-        reply.content += "\"]";
-        reply.content += "],";
+        reply.content.push_back("\"route_name\":[\"");
+        reply.content.push_back(routeNames.shortestPathName1);
+        reply.content.push_back("\",\"");
+        reply.content.push_back(routeNames.shortestPathName2);
+        reply.content.push_back("\"],"
+                "\"alternative_names\":[");
+        reply.content.push_back("[\"");
+        reply.content.push_back(routeNames.alternativePathName1);
+        reply.content.push_back("\",\"");
+        reply.content.push_back(routeNames.alternativePathName2);
+        reply.content.push_back("\"]");
+        reply.content.push_back("],");
         //list all viapoints so that the client may display it
-        reply.content += "\"via_points\":[";
+        reply.content.push_back("\"via_points\":[");
         std::string tmp;
-        if(config.geometry && INT_MAX != rawRoute.lengthOfShortestPath) {
-            for(unsigned i = 0; i < rawRoute.segmentEndCoordinates.size(); ++i) {
-                reply.content += "[";
-                if(rawRoute.segmentEndCoordinates[i].startPhantom.location.isSet())
-                    convertInternalReversedCoordinateToString(rawRoute.segmentEndCoordinates[i].startPhantom.location, tmp);
+        if(config.geometry && INT_MAX != raw_route_information.lengthOfShortestPath) {
+            for(unsigned i = 0; i < raw_route_information.segmentEndCoordinates.size(); ++i) {
+                reply.content.push_back("[");
+                if(raw_route_information.segmentEndCoordinates[i].startPhantom.location.isSet())
+                    convertInternalReversedCoordinateToString(raw_route_information.segmentEndCoordinates[i].startPhantom.location, tmp);
                 else
-                    convertInternalReversedCoordinateToString(rawRoute.rawViaNodeCoordinates[i], tmp);
+                    convertInternalReversedCoordinateToString(raw_route_information.rawViaNodeCoordinates[i], tmp);
 
-                reply.content += tmp;
-                reply.content += "],";
+                reply.content.push_back(tmp);
+                reply.content.push_back("],");
             }
-            reply.content += "[";
-            if(rawRoute.segmentEndCoordinates.back().startPhantom.location.isSet())
-                convertInternalReversedCoordinateToString(rawRoute.segmentEndCoordinates.back().targetPhantom.location, tmp);
+            reply.content.push_back("[");
+            if(raw_route_information.segmentEndCoordinates.back().startPhantom.location.isSet())
+                convertInternalReversedCoordinateToString(raw_route_information.segmentEndCoordinates.back().targetPhantom.location, tmp);
             else
-                convertInternalReversedCoordinateToString(rawRoute.rawViaNodeCoordinates.back(), tmp);
-            reply.content += tmp;
-            reply.content += "]";
+                convertInternalReversedCoordinateToString(raw_route_information.rawViaNodeCoordinates.back(), tmp);
+            reply.content.push_back(tmp);
+            reply.content.push_back("]");
         }
-        reply.content += "],";
-        reply.content += "\"hint_data\": {";
-        reply.content += "\"checksum\":";
-        intToString(rawRoute.checkSum, tmp);
-        reply.content += tmp;
-        reply.content += ", \"locations\": [";
+        reply.content.push_back("],");
+        reply.content.push_back("\"hint_data\": {");
+        reply.content.push_back("\"checksum\":");
+        intToString(raw_route_information.checkSum, tmp);
+        reply.content.push_back(tmp);
+        reply.content.push_back(", \"locations\": [");
 
         std::string hint;
-        for(unsigned i = 0; i < rawRoute.segmentEndCoordinates.size(); ++i) {
-            reply.content += "\"";
-            EncodeObjectToBase64(rawRoute.segmentEndCoordinates[i].startPhantom, hint);
-            reply.content += hint;
-            reply.content += "\", ";
+        for(unsigned i = 0; i < raw_route_information.segmentEndCoordinates.size(); ++i) {
+            reply.content.push_back("\"");
+            EncodeObjectToBase64(raw_route_information.segmentEndCoordinates[i].startPhantom, hint);
+            reply.content.push_back(hint);
+            reply.content.push_back("\", ");
         }
-        EncodeObjectToBase64(rawRoute.segmentEndCoordinates.back().targetPhantom, hint);
-        reply.content += "\"";
-        reply.content += hint;
-        reply.content += "\"]";
-        reply.content += "},";
-        reply.content += "\"transactionId\": \"OSRM Routing Engine JSON Descriptor (v0.3)\"";
-        reply.content += "}";
+        EncodeObjectToBase64(raw_route_information.segmentEndCoordinates.back().targetPhantom, hint);
+        reply.content.push_back("\"");
+        reply.content.push_back(hint);
+        reply.content.push_back("\"]");
+        reply.content.push_back("},");
+        reply.content.push_back("\"transactionId\": \"OSRM Routing Engine JSON Descriptor (v0.3)\"");
+        reply.content.push_back("}");
     }
 
-    void GetRouteNames(std::vector<Segment> & shortestSegments, std::vector<Segment> & alternativeSegments, SearchEngineT &sEngine, RouteNames & routeNames) {
-        /*** extract names for both alternatives ***/
+    // construct routes names
+    void GetRouteNames(
+        std::vector<Segment> & shortest_path_segments,
+        std::vector<Segment> & alternative_path_segments,
+        const DataFacadeT * facade,
+        RouteNames & routeNames
+    ) {
 
         Segment shortestSegment1, shortestSegment2;
         Segment alternativeSegment1, alternativeSegment2;
 
-        if(0 < shortestSegments.size()) {
-            sort(shortestSegments.begin(), shortestSegments.end(), boost::bind(&Segment::length, _1) > boost::bind(&Segment::length, _2) );
-            shortestSegment1 = shortestSegments[0];
-            if(0 < alternativeSegments.size()) {
-                sort(alternativeSegments.begin(), alternativeSegments.end(), boost::bind(&Segment::length, _1) > boost::bind(&Segment::length, _2) );
-                alternativeSegment1 = alternativeSegments[0];
+        if(0 < shortest_path_segments.size()) {
+            sort(shortest_path_segments.begin(), shortest_path_segments.end(), boost::bind(&Segment::length, _1) > boost::bind(&Segment::length, _2) );
+            shortestSegment1 = shortest_path_segments[0];
+            if(0 < alternative_path_segments.size()) {
+                sort(alternative_path_segments.begin(), alternative_path_segments.end(), boost::bind(&Segment::length, _1) > boost::bind(&Segment::length, _2) );
+                alternativeSegment1 = alternative_path_segments[0];
             }
-            std::vector<Segment> shortestDifference(shortestSegments.size());
-            std::vector<Segment> alternativeDifference(alternativeSegments.size());
-            std::set_difference(shortestSegments.begin(), shortestSegments.end(), alternativeSegments.begin(), alternativeSegments.end(), shortestDifference.begin(), boost::bind(&Segment::nameID, _1) < boost::bind(&Segment::nameID, _2) );
-            if(0 < shortestDifference.size() ) {
-                unsigned i = 0;
-                while( i < shortestDifference.size() && shortestDifference[i].nameID == shortestSegments[0].nameID) {
+            std::vector<Segment> shortestDifference(shortest_path_segments.size());
+            std::vector<Segment> alternativeDifference(alternative_path_segments.size());
+            std::set_difference(shortest_path_segments.begin(), shortest_path_segments.end(), alternative_path_segments.begin(), alternative_path_segments.end(), shortestDifference.begin(), boost::bind(&Segment::name_id, _1) < boost::bind(&Segment::name_id, _2) );
+            int size_of_difference = shortestDifference.size();
+            if(0 < size_of_difference ) {
+                int i = 0;
+                while( i < size_of_difference && shortestDifference[i].name_id == shortest_path_segments[0].name_id) {
                     ++i;
                 }
-                if(i < shortestDifference.size()) {
+                if(i < size_of_difference ) {
                     shortestSegment2 = shortestDifference[i];
                 }
             }
 
-            std::set_difference(alternativeSegments.begin(), alternativeSegments.end(), shortestSegments.begin(), shortestSegments.end(), alternativeDifference.begin(), boost::bind(&Segment::nameID, _1) < boost::bind(&Segment::nameID, _2) );
-            if(0 < alternativeDifference.size() ) {
-                unsigned i = 0;
-                while( i < alternativeDifference.size() && alternativeDifference[i].nameID == alternativeSegments[0].nameID) {
+            std::set_difference(alternative_path_segments.begin(), alternative_path_segments.end(), shortest_path_segments.begin(), shortest_path_segments.end(), alternativeDifference.begin(), boost::bind(&Segment::name_id, _1) < boost::bind(&Segment::name_id, _2) );
+            size_of_difference = alternativeDifference.size();
+            if(0 < size_of_difference ) {
+                int i = 0;
+                while( i < size_of_difference && alternativeDifference[i].name_id == alternative_path_segments[0].name_id) {
                     ++i;
                 }
-                if(i < alternativeDifference.size()) {
+                if(i < size_of_difference ) {
                     alternativeSegment2 = alternativeDifference[i];
                 }
             }
@@ -288,102 +341,124 @@ public:
             if(alternativeSegment1.position >  alternativeSegment2.position)
                 std::swap(alternativeSegment1, alternativeSegment2);
 
-            routeNames.shortestPathName1 = sEngine.GetEscapedNameForNameID(shortestSegment1.nameID);
-            routeNames.shortestPathName2 = sEngine.GetEscapedNameForNameID(shortestSegment2.nameID);
+            routeNames.shortestPathName1 = facade->GetEscapedNameForNameID(
+                shortestSegment1.name_id
+            );
+            routeNames.shortestPathName2 = facade->GetEscapedNameForNameID(
+                shortestSegment2.name_id
+            );
 
-            routeNames.alternativePathName1 = sEngine.GetEscapedNameForNameID(alternativeSegment1.nameID);
-            routeNames.alternativePathName2 += sEngine.GetEscapedNameForNameID(alternativeSegment2.nameID);
+            routeNames.alternativePathName1 = facade->GetEscapedNameForNameID(
+                alternativeSegment1.name_id
+            );
+            routeNames.alternativePathName2 = facade->GetEscapedNameForNameID(
+                alternativeSegment2.name_id
+            );
         }
     }
 
-    inline void WriteHeaderToOutput(std::string & output) {
-        output += "{"
-                "\"version\": 0.3,"
-                "\"status\":";
+    inline void WriteHeaderToOutput(std::vector<std::string> & output) {
+        output.push_back(
+            "{"
+            "\"version\": 0.3,"
+            "\"status\":"
+        );
     }
 
-    inline void BuildTextualDescription(DescriptionFactory & descriptionFactory, http::Reply & reply, const int lengthOfRoute, const SearchEngineT &sEngine, std::vector<Segment> & segmentVector) {
+    //TODO: reorder parameters
+    inline void BuildTextualDescription(
+        DescriptionFactory & description_factory,
+        http::Reply & reply,
+        const int route_length,
+        const DataFacadeT * facade,
+        std::vector<Segment> & route_segments_list
+    ) {
         //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.leaveAtExit = 0;
-        roundAbout.nameID = 0;
+        roundAbout.leave_at_exit = 0;
+        roundAbout.name_id = 0;
         std::string tmpDist, tmpLength, tmpDuration, tmpBearing, tmpInstruction;
         //Fetch data from Factory and generate a string from it.
-        BOOST_FOREACH(const SegmentInformation & segment, descriptionFactory.pathDescription) {
-        	TurnInstruction currentInstruction = segment.turnInstruction & TurnInstructions.InverseAccessRestrictionFlag;
-            numberOfEnteredRestrictedAreas += (currentInstruction != segment.turnInstruction);
-            if(TurnInstructions.TurnIsNecessary( currentInstruction) ) {
-                if(TurnInstructions.EnterRoundAbout == currentInstruction) {
-                    roundAbout.nameID = segment.nameID;
-                    roundAbout.startIndex = prefixSumOfNecessarySegments;
+        BOOST_FOREACH(const SegmentInformation & segment, description_factory.pathDescription) {
+        	TurnInstruction current_instruction = segment.turnInstruction & TurnInstructions.InverseAccessRestrictionFlag;
+            entered_restricted_area_count += (current_instruction != segment.turnInstruction);
+            if(TurnInstructions.TurnIsNecessary( current_instruction) ) {
+                if(TurnInstructions.EnterRoundAbout == current_instruction) {
+                    roundAbout.name_id = segment.nameID;
+                    roundAbout.start_index = prefixSumOfNecessarySegments;
                 } else {
                     if(0 != prefixSumOfNecessarySegments){
-                        reply.content += ",";
+                        reply.content.push_back(",");
                     }
-                    reply.content += "[\"";
-                    if(TurnInstructions.LeaveRoundAbout == currentInstruction) {
+                    reply.content.push_back("[\"");
+                    if(TurnInstructions.LeaveRoundAbout == current_instruction) {
                         intToString(TurnInstructions.EnterRoundAbout, tmpInstruction);
-                        reply.content += tmpInstruction;
-                        reply.content += "-";
-                        intToString(roundAbout.leaveAtExit+1, tmpInstruction);
-                        reply.content += tmpInstruction;
-                        roundAbout.leaveAtExit = 0;
+                        reply.content.push_back(tmpInstruction);
+                        reply.content.push_back("-");
+                        intToString(roundAbout.leave_at_exit+1, tmpInstruction);
+                        reply.content.push_back(tmpInstruction);
+                        roundAbout.leave_at_exit = 0;
                     } else {
-                        intToString(currentInstruction, tmpInstruction);
-                        reply.content += tmpInstruction;
+                        intToString(current_instruction, tmpInstruction);
+                        reply.content.push_back(tmpInstruction);
                     }
 
-
-                    reply.content += "\",\"";
-                    reply.content += sEngine.GetEscapedNameForNameID(segment.nameID);
-                    reply.content += "\",";
+                    reply.content.push_back("\",\"");
+                    reply.content.push_back(facade->GetEscapedNameForNameID(segment.nameID));
+                    reply.content.push_back("\",");
                     intToString(segment.length, tmpDist);
-                    reply.content += tmpDist;
-                    reply.content += ",";
+                    reply.content.push_back(tmpDist);
+                    reply.content.push_back(",");
                     intToString(prefixSumOfNecessarySegments, tmpLength);
-                    reply.content += tmpLength;
-                    reply.content += ",";
+                    reply.content.push_back(tmpLength);
+                    reply.content.push_back(",");
                     intToString(segment.duration/10, tmpDuration);
-                    reply.content += tmpDuration;
-                    reply.content += ",\"";
+                    reply.content.push_back(tmpDuration);
+                    reply.content.push_back(",\"");
                     intToString(segment.length, tmpLength);
-                    reply.content += tmpLength;
-                    reply.content += "m\",\"";
-                    reply.content += Azimuth::Get(segment.bearing);
-                    reply.content += "\",";
+                    reply.content.push_back(tmpLength);
+                    reply.content.push_back("m\",\"");
+                    reply.content.push_back(Azimuth::Get(segment.bearing));
+                    reply.content.push_back("\",");
                     intToString(round(segment.bearing), tmpBearing);
-                    reply.content += tmpBearing;
-                    reply.content += "]";
+                    reply.content.push_back(tmpBearing);
+                    reply.content.push_back("]");
 
-                    segmentVector.push_back( Segment(segment.nameID, segment.length, segmentVector.size() ));
+                    route_segments_list.push_back(
+                        Segment(
+                            segment.nameID,
+                            segment.length,
+                            route_segments_list.size()
+                        )
+                    );
                 }
-            } else if(TurnInstructions.StayOnRoundAbout == currentInstruction) {
-                ++roundAbout.leaveAtExit;
+            } else if(TurnInstructions.StayOnRoundAbout == current_instruction) {
+                ++roundAbout.leave_at_exit;
             }
             if(segment.necessary)
                 ++prefixSumOfNecessarySegments;
         }
-        if(INT_MAX != lengthOfRoute) {
-            reply.content += ",[\"";
+        if(INT_MAX != route_length) {
+            reply.content.push_back(",[\"");
             intToString(TurnInstructions.ReachedYourDestination, tmpInstruction);
-            reply.content += tmpInstruction;
-            reply.content += "\",\"";
-            reply.content += "\",";
-            reply.content += "0";
-            reply.content += ",";
+            reply.content.push_back(tmpInstruction);
+            reply.content.push_back("\",\"");
+            reply.content.push_back("\",");
+            reply.content.push_back("0");
+            reply.content.push_back(",");
             intToString(prefixSumOfNecessarySegments-1, tmpLength);
-            reply.content += tmpLength;
-            reply.content += ",";
-            reply.content += "0";
-            reply.content += ",\"";
-            reply.content += "\",\"";
-            reply.content += Azimuth::Get(0.0);
-            reply.content += "\",";
-            reply.content += "0.0";
-            reply.content += "]";
+            reply.content.push_back(tmpLength);
+            reply.content.push_back(",");
+            reply.content.push_back("0");
+            reply.content.push_back(",\"");
+            reply.content.push_back("\",\"");
+            reply.content.push_back(Azimuth::Get(0.0));
+            reply.content.push_back("\",");
+            reply.content.push_back("0.0");
+            reply.content.push_back("]");
         }
     }
 

Extractor/BaseParser.cpp

@@ -0,0 +1,104 @@
+/*
+
+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.
+
+*/
+
+#include "BaseParser.h"
+
+BaseParser::BaseParser(ExtractorCallbacks* ec, ScriptingEnvironment& se) :
+extractor_callbacks(ec), scriptingEnvironment(se), luaState(NULL), use_turn_restrictions(true) {
+    luaState = se.getLuaStateForThreadID(0);
+    ReadUseRestrictionsSetting();
+    ReadRestrictionExceptions();
+}
+
+void BaseParser::ReadUseRestrictionsSetting() {
+    if( 0 != luaL_dostring( luaState, "return use_turn_restrictions\n") ) {
+        throw OSRMException(
+            /*lua_tostring( luaState, -1 ) + */"ERROR occured in scripting block"
+        );
+    }
+    if( lua_isboolean( luaState, -1) ) {
+        use_turn_restrictions = lua_toboolean(luaState, -1);
+    }
+    if( use_turn_restrictions ) {
+        SimpleLogger().Write() << "Using turn restrictions";
+    } else {
+        SimpleLogger().Write() << "Ignoring turn restrictions";
+    }
+}
+
+void BaseParser::ReadRestrictionExceptions() {
+    if(lua_function_exists(luaState, "get_exceptions" )) {
+        //get list of turn restriction exceptions
+        luabind::call_function<void>(
+            luaState,
+            "get_exceptions",
+            boost::ref(restriction_exceptions)
+        );
+        SimpleLogger().Write() << "Found " << restriction_exceptions.size() << " exceptions to turn restriction";
+        BOOST_FOREACH(const std::string & str, restriction_exceptions) {
+            SimpleLogger().Write() << "   " << str;
+        }
+    } else {
+        SimpleLogger().Write() << "Found no exceptions to turn restrictions";
+    }
+}
+
+void BaseParser::report_errors(lua_State *L, const int status) const {
+    if( 0!=status ) {
+        std::cerr << "-- " << lua_tostring(L, -1) << std::endl;
+        lua_pop(L, 1); // remove error message
+    }
+}
+
+void BaseParser::ParseNodeInLua(ImportNode& n, lua_State* localLuaState) {
+    luabind::call_function<void>( localLuaState, "node_function", boost::ref(n) );
+}
+
+void BaseParser::ParseWayInLua(ExtractionWay& w, lua_State* localLuaState) {
+    luabind::call_function<void>( localLuaState, "way_function", boost::ref(w) );
+}
+
+bool BaseParser::ShouldIgnoreRestriction(const std::string & except_tag_string) const {
+    //should this restriction be ignored? yes if there's an overlap between:
+    //a) the list of modes in the except tag of the restriction (except_tag_string), ex: except=bus;bicycle
+    //b) the lua profile defines a hierachy of modes, ex: [access, vehicle, bicycle]
+
+    if( "" == except_tag_string ) {
+        return false;
+    }
+
+    //Be warned, this is quadratic work here, but we assume that
+    //only a few exceptions are actually defined.
+    std::vector<std::string> exceptions;
+    boost::algorithm::split_regex(exceptions, except_tag_string, boost::regex("[;][ ]*"));
+    BOOST_FOREACH(std::string& str, exceptions) {
+        if( restriction_exceptions.end() != std::find(restriction_exceptions.begin(), restriction_exceptions.end(), str) ) {
+            return true;
+        }
+    }
+    return false;
+}

Extractor/BaseParser.h

@@ -1,49 +1,67 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 BASEPARSER_H_
 #define BASEPARSER_H_
 
+#include "ExtractorCallbacks.h"
+#include "ScriptingEnvironment.h"
+#include "../Util/OSRMException.h"
+#include "../Util/SimpleLogger.h"
+
 extern "C" {
-#include <lua.h>
-#include <lauxlib.h>
-#include <lualib.h>
+    #include <lua.h>
+    #include <lauxlib.h>
+    #include <lualib.h>
 }
 
-#include "ScriptingEnvironment.h"
+#include <boost/noncopyable.hpp>
 
-template<class ExternalMemoryT, typename NodeT, typename RestrictionT, typename WayT>
-class BaseParser {
+class BaseParser : boost::noncopyable {
 public:
+    BaseParser(ExtractorCallbacks* ec, ScriptingEnvironment& se);
     virtual ~BaseParser() {}
-    virtual bool Init() = 0;
-    virtual void RegisterCallbacks(ExternalMemoryT * externalMemory) = 0;
-    virtual void RegisterScriptingEnvironment(ScriptingEnvironment & _se) = 0;
+    virtual bool ReadHeader() = 0;
     virtual bool Parse() = 0;
 
-    void report_errors(lua_State *L, int status) {
-        if ( status!=0 ) {
-            std::cerr << "-- " << lua_tostring(L, -1) << std::endl;
-            lua_pop(L, 1); // remove error message
-        }
-    }
+    virtual void ParseNodeInLua(ImportNode& n, lua_State* luaStateForThread);
+    virtual void ParseWayInLua(ExtractionWay& n, lua_State* luaStateForThread);
+    virtual void report_errors(lua_State *L, const int status) const;
+
+protected:
+    virtual void ReadUseRestrictionsSetting();
+    virtual void ReadRestrictionExceptions();
+    virtual bool ShouldIgnoreRestriction(const std::string& except_tag_string) const;
+
+    ExtractorCallbacks* extractor_callbacks;
+    ScriptingEnvironment& scriptingEnvironment;
+    lua_State* luaState;
+    std::vector<std::string> restriction_exceptions;
+    bool use_turn_restrictions;
 
 };
 

Extractor/ExtractionContainers.cpp

@@ -1,305 +1,435 @@
 /*
- open source routing machine
- Copyright (C) Dennis Luxen, others 2010
 
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU AFFERO General Public License as published by
- the Free Software Foundation; either version 3 of the License, or
- any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
- You should have received a copy of the GNU Affero General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- or see http://www.gnu.org/licenses/agpl.txt.
- */
+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.
+
+*/
 
 #include "ExtractionContainers.h"
 
-void ExtractionContainers::PrepareData(const std::string & outputFileName, const std::string restrictionsFileName, const unsigned amountOfRAM) {
+void ExtractionContainers::PrepareData(
+    const std::string & output_file_name,
+    const std::string & restrictions_file_name
+) {
     try {
-        unsigned usedNodeCounter = 0;
-        unsigned usedEdgeCounter = 0;
+        unsigned number_of_used_nodes = 0;
+        unsigned number_of_used_edges = 0;
         double time = get_timestamp();
-        boost::uint64_t memory_to_use = static_cast<boost::uint64_t>(amountOfRAM) * 1024 * 1024 * 1024;
 
-        cout << "[extractor] Sorting used nodes        ... " << flush;
-        stxxl::sort(usedNodeIDs.begin(), usedNodeIDs.end(), Cmp(), memory_to_use);
-        cout << "ok, after " << get_timestamp() - time << "s" << endl;
+        std::cout << "[extractor] Sorting used nodes        ... " << std::flush;
+        stxxl::sort(
+            used_node_id_list.begin(),
+            used_node_id_list.end(),
+            Cmp(),
+            4294967296
+        );
+        std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl;
 
         time = get_timestamp();
-        cout << "[extractor] Erasing duplicate nodes   ... " << flush;
-        stxxl::vector<NodeID>::iterator NewEnd = unique ( usedNodeIDs.begin(),usedNodeIDs.end() ) ;
-        usedNodeIDs.resize ( NewEnd - usedNodeIDs.begin() );
-        cout << "ok, after " << get_timestamp() - time << "s" << endl;
+        std::cout << "[extractor] Erasing duplicate nodes   ... " << std::flush;
+        stxxl::vector<NodeID>::iterator NewEnd = std::unique ( used_node_id_list.begin(),used_node_id_list.end() ) ;
+        used_node_id_list.resize ( NewEnd - used_node_id_list.begin() );
+        std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl;
         time = get_timestamp();
 
-        cout << "[extractor] Sorting all nodes         ... " << flush;
-        stxxl::sort(allNodes.begin(), allNodes.end(), CmpNodeByID(), memory_to_use);
-        cout << "ok, after " << get_timestamp() - time << "s" << endl;
+        std::cout << "[extractor] Sorting all nodes         ... " << std::flush;
+        stxxl::sort(
+            all_nodes_list.begin(),
+            all_nodes_list.end(),
+            CmpNodeByID(),
+            4294967296
+        );
+        std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl;
         time = get_timestamp();
 
-        cout << "[extractor] Sorting used ways         ... " << flush;
-        stxxl::sort(wayStartEndVector.begin(), wayStartEndVector.end(), CmpWayByID(), memory_to_use);
-        cout << "ok, after " << get_timestamp() - time << "s" << endl;
+        std::cout << "[extractor] Sorting used ways         ... " << std::flush;
+        stxxl::sort(
+            way_start_end_id_list.begin(),
+            way_start_end_id_list.end(),
+            CmpWayByID(),
+            4294967296
+        );
+        std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl;
 
-        cout << "[extractor] Sorting restrctns. by from... " << flush;
-        stxxl::sort(restrictionsVector.begin(), restrictionsVector.end(), CmpRestrictionContainerByFrom(), memory_to_use);
-        cout << "ok, after " << get_timestamp() - time << "s" << endl;
+        std::cout << "[extractor] Sorting restrctns. by from... " << std::flush;
+        stxxl::sort(
+            restrictions_list.begin(),
+            restrictions_list.end(),
+            CmpRestrictionContainerByFrom(),
+            4294967296
+        );
+        std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl;
 
-        cout << "[extractor] Fixing restriction starts ... " << flush;
-        STXXLRestrictionsVector::iterator restrictionsIT = restrictionsVector.begin();
-        STXXLWayIDStartEndVector::iterator wayStartAndEndEdgeIT = wayStartEndVector.begin();
+        std::cout << "[extractor] Fixing restriction starts ... " << std::flush;
+        STXXLRestrictionsVector::iterator restrictions_iterator = restrictions_list.begin();
+        STXXLWayIDStartEndVector::iterator way_start_and_end_iterator = way_start_end_id_list.begin();
 
-        while(wayStartAndEndEdgeIT != wayStartEndVector.end() && restrictionsIT != restrictionsVector.end()) {
-            if(wayStartAndEndEdgeIT->wayID < restrictionsIT->fromWay){
-                ++wayStartAndEndEdgeIT;
+        while(
+            way_start_and_end_iterator != way_start_end_id_list.end() &&
+            restrictions_iterator      != restrictions_list.end()
+        ) {
+
+            if(way_start_and_end_iterator->wayID < restrictions_iterator->fromWay){
+                ++way_start_and_end_iterator;
                 continue;
             }
-            if(wayStartAndEndEdgeIT->wayID > restrictionsIT->fromWay) {
-                ++restrictionsIT;
+
+            if(way_start_and_end_iterator->wayID > restrictions_iterator->fromWay) {
+                ++restrictions_iterator;
                 continue;
             }
-            assert(wayStartAndEndEdgeIT->wayID == restrictionsIT->fromWay);
-            NodeID viaNode = restrictionsIT->restriction.viaNode;
 
-            if(wayStartAndEndEdgeIT->firstStart == viaNode) {
-                restrictionsIT->restriction.fromNode = wayStartAndEndEdgeIT->firstTarget;
-            } else if(wayStartAndEndEdgeIT->firstTarget == viaNode) {
-                restrictionsIT->restriction.fromNode = wayStartAndEndEdgeIT->firstStart;
-            } else if(wayStartAndEndEdgeIT->lastStart == viaNode) {
-                restrictionsIT->restriction.fromNode = wayStartAndEndEdgeIT->lastTarget;
-            } else if(wayStartAndEndEdgeIT->lastTarget == viaNode) {
-                restrictionsIT->restriction.fromNode = wayStartAndEndEdgeIT->lastStart;
+            BOOST_ASSERT(way_start_and_end_iterator->wayID == restrictions_iterator->fromWay);
+            NodeID via_node_id = restrictions_iterator->restriction.viaNode;
+
+            if(way_start_and_end_iterator->firstStart == via_node_id) {
+                restrictions_iterator->restriction.fromNode = way_start_and_end_iterator->firstTarget;
+            } else if(way_start_and_end_iterator->firstTarget == via_node_id) {
+                restrictions_iterator->restriction.fromNode = way_start_and_end_iterator->firstStart;
+            } else if(way_start_and_end_iterator->lastStart == via_node_id) {
+                restrictions_iterator->restriction.fromNode = way_start_and_end_iterator->lastTarget;
+            } else if(way_start_and_end_iterator->lastTarget == via_node_id) {
+                restrictions_iterator->restriction.fromNode = way_start_and_end_iterator->lastStart;
             }
-            ++restrictionsIT;
+            ++restrictions_iterator;
         }
 
-        cout << "ok, after " << get_timestamp() - time << "s" << endl;
+        std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl;
         time = get_timestamp();
 
-        cout << "[extractor] Sorting restrctns. by to  ... " << flush;
-        stxxl::sort(restrictionsVector.begin(), restrictionsVector.end(), CmpRestrictionContainerByTo(), memory_to_use);
-        cout << "ok, after " << get_timestamp() - time << "s" << endl;
+        std::cout << "[extractor] Sorting restrctns. by to  ... " << std::flush;
+        stxxl::sort(
+            restrictions_list.begin(),
+            restrictions_list.end(),
+            CmpRestrictionContainerByTo(),
+            4294967296
+        );
+        std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl;
 
         time = get_timestamp();
         unsigned usableRestrictionsCounter(0);
-        cout << "[extractor] Fixing restriction ends   ... " << flush;
-        restrictionsIT = restrictionsVector.begin();
-        wayStartAndEndEdgeIT = wayStartEndVector.begin();
-        while(wayStartAndEndEdgeIT != wayStartEndVector.end() && restrictionsIT != restrictionsVector.end()) {
-            if(wayStartAndEndEdgeIT->wayID < restrictionsIT->toWay){
-                ++wayStartAndEndEdgeIT;
+        std::cout << "[extractor] Fixing restriction ends   ... " << std::flush;
+        restrictions_iterator = restrictions_list.begin();
+        way_start_and_end_iterator = way_start_end_id_list.begin();
+        while(
+            way_start_and_end_iterator != way_start_end_id_list.end() &&
+            restrictions_iterator       != restrictions_list.end()
+        ) {
+            if(way_start_and_end_iterator->wayID < restrictions_iterator->toWay){
+                ++way_start_and_end_iterator;
                 continue;
             }
-            if(wayStartAndEndEdgeIT->wayID > restrictionsIT->toWay) {
-                ++restrictionsIT;
+            if(way_start_and_end_iterator->wayID > restrictions_iterator->toWay) {
+                ++restrictions_iterator;
                 continue;
             }
-            NodeID viaNode = restrictionsIT->restriction.viaNode;
-            if(wayStartAndEndEdgeIT->lastStart == viaNode) {
-                restrictionsIT->restriction.toNode = wayStartAndEndEdgeIT->lastTarget;
-            } else if(wayStartAndEndEdgeIT->lastTarget == viaNode) {
-                restrictionsIT->restriction.toNode = wayStartAndEndEdgeIT->lastStart;
-            } else if(wayStartAndEndEdgeIT->firstStart == viaNode) {
-                restrictionsIT->restriction.toNode = wayStartAndEndEdgeIT->firstTarget;
-            } else if(wayStartAndEndEdgeIT->firstTarget == viaNode) {
-                restrictionsIT->restriction.toNode = wayStartAndEndEdgeIT->firstStart;
+            NodeID via_node_id = restrictions_iterator->restriction.viaNode;
+            if(way_start_and_end_iterator->lastStart == via_node_id) {
+                restrictions_iterator->restriction.toNode = way_start_and_end_iterator->lastTarget;
+            } else if(way_start_and_end_iterator->lastTarget == via_node_id) {
+                restrictions_iterator->restriction.toNode = way_start_and_end_iterator->lastStart;
+            } else if(way_start_and_end_iterator->firstStart == via_node_id) {
+                restrictions_iterator->restriction.toNode = way_start_and_end_iterator->firstTarget;
+            } else if(way_start_and_end_iterator->firstTarget == via_node_id) {
+                restrictions_iterator->restriction.toNode = way_start_and_end_iterator->firstStart;
             }
 
-            if(UINT_MAX != restrictionsIT->restriction.fromNode && UINT_MAX != restrictionsIT->restriction.toNode) {
+            if(
+                UINT_MAX != restrictions_iterator->restriction.fromNode &&
+                UINT_MAX != restrictions_iterator->restriction.toNode
+            ) {
                 ++usableRestrictionsCounter;
             }
-            ++restrictionsIT;
+            ++restrictions_iterator;
         }
-        cout << "ok, after " << get_timestamp() - time << "s" << endl;
-        INFO("usable restrictions: " << usableRestrictionsCounter );
+        std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl;
+        SimpleLogger().Write() << "usable restrictions: " << usableRestrictionsCounter;
         //serialize restrictions
-        ofstream restrictionsOutstream;
-        restrictionsOutstream.open(restrictionsFileName.c_str(), ios::binary);
-        restrictionsOutstream.write((char*)&usableRestrictionsCounter, sizeof(unsigned));
-        for(restrictionsIT = restrictionsVector.begin(); restrictionsIT != restrictionsVector.end(); ++restrictionsIT) {
-            if(UINT_MAX != restrictionsIT->restriction.fromNode && UINT_MAX != restrictionsIT->restriction.toNode) {
-                restrictionsOutstream.write((char *)&(restrictionsIT->restriction), sizeof(_Restriction));
+        std::ofstream restrictions_out_stream;
+        restrictions_out_stream.open(restrictions_file_name.c_str(), std::ios::binary);
+        restrictions_out_stream.write((char*)&uuid, sizeof(UUID));
+        restrictions_out_stream.write(
+            (char*)&usableRestrictionsCounter,
+            sizeof(unsigned)
+        );
+        for(
+            restrictions_iterator = restrictions_list.begin();
+            restrictions_iterator != restrictions_list.end();
+            ++restrictions_iterator
+        ) {
+            if(
+                UINT_MAX != restrictions_iterator->restriction.fromNode &&
+                UINT_MAX != restrictions_iterator->restriction.toNode
+            ) {
+                restrictions_out_stream.write(
+                    (char *)&(restrictions_iterator->restriction),
+                    sizeof(TurnRestriction)
+                );
             }
         }
-        restrictionsOutstream.close();
+        restrictions_out_stream.close();
 
-        ofstream fout;
-        fout.open(outputFileName.c_str(), ios::binary);
-        fout.write((char*)&usedNodeCounter, sizeof(unsigned));
+        std::ofstream file_out_stream;
+        file_out_stream.open(output_file_name.c_str(), std::ios::binary);
+        file_out_stream.write((char*)&uuid, sizeof(UUID));
+        file_out_stream.write((char*)&number_of_used_nodes, sizeof(unsigned));
         time = get_timestamp();
-        cout << "[extractor] Confirming/Writing used nodes     ... " << flush;
+        std::cout << "[extractor] Confirming/Writing used nodes     ... " << std::flush;
 
-        STXXLNodeVector::iterator nodesIT = allNodes.begin();
-        STXXLNodeIDVector::iterator usedNodeIDsIT = usedNodeIDs.begin();
-        while(usedNodeIDsIT != usedNodeIDs.end() && nodesIT != allNodes.end()) {
-            if(*usedNodeIDsIT < nodesIT->id){
-                ++usedNodeIDsIT;
+        //identify all used nodes by a merging step of two sorted lists
+        STXXLNodeVector::iterator node_iterator = all_nodes_list.begin();
+        STXXLNodeIDVector::iterator node_id_iterator = used_node_id_list.begin();
+        while(
+            node_id_iterator != used_node_id_list.end() &&
+            node_iterator    != all_nodes_list.end()
+        ) {
+            if(*node_id_iterator < node_iterator->id){
+                ++node_id_iterator;
                 continue;
             }
-            if(*usedNodeIDsIT > nodesIT->id) {
-                ++nodesIT;
+            if(*node_id_iterator > node_iterator->id) {
+                ++node_iterator;
                 continue;
             }
-            if(*usedNodeIDsIT == nodesIT->id) {
-                fout.write((char*)&(*nodesIT), sizeof(_Node));
-                ++usedNodeCounter;
-                ++usedNodeIDsIT;
-                ++nodesIT;
-            }
+            BOOST_ASSERT( *node_id_iterator == node_iterator->id);
+
+            file_out_stream.write(
+                (char*)&(*node_iterator),
+                sizeof(ExternalMemoryNode)
+            );
+
+            ++number_of_used_nodes;
+            ++node_id_iterator;
+            ++node_iterator;
         }
 
-        cout << "ok, after " << get_timestamp() - time << "s" << endl;
+        std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl;
 
-        cout << "[extractor] setting number of nodes   ... " << flush;
-        ios::pos_type positionInFile = fout.tellp();
-        fout.seekp(ios::beg);
-        fout.write((char*)&usedNodeCounter, sizeof(unsigned));
-        fout.seekp(positionInFile);
+        std::cout << "[extractor] setting number of nodes   ... " << std::flush;
+        std::ios::pos_type previous_file_position = file_out_stream.tellp();
+        file_out_stream.seekp(std::ios::beg+sizeof(UUID));
+        file_out_stream.write((char*)&number_of_used_nodes, sizeof(unsigned));
+        file_out_stream.seekp(previous_file_position);
 
-        cout << "ok" << endl;
+        std::cout << "ok" << std::endl;
         time = get_timestamp();
 
         // Sort edges by start.
-        cout << "[extractor] Sorting edges by start    ... " << flush;
-        stxxl::sort(allEdges.begin(), allEdges.end(), CmpEdgeByStartID(), memory_to_use);
-        cout << "ok, after " << get_timestamp() - time << "s" << endl;
+        std::cout << "[extractor] Sorting edges by start    ... " << std::flush;
+        stxxl::sort(
+            all_edges_list.begin(),
+            all_edges_list.end(),
+            CmpEdgeByStartID(),
+            4294967296
+        );
+        std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl;
         time = get_timestamp();
 
-        cout << "[extractor] Setting start coords      ... " << flush;
-        fout.write((char*)&usedEdgeCounter, sizeof(unsigned));
+        std::cout << "[extractor] Setting start coords      ... " << std::flush;
+        file_out_stream.write((char*)&number_of_used_edges, sizeof(unsigned));
         // Traverse list of edges and nodes in parallel and set start coord
-        nodesIT = allNodes.begin();
-        STXXLEdgeVector::iterator edgeIT = allEdges.begin();
-        while(edgeIT != allEdges.end() && nodesIT != allNodes.end()) {
-            if(edgeIT->start < nodesIT->id){
-                ++edgeIT;
+        node_iterator = all_nodes_list.begin();
+        STXXLEdgeVector::iterator edge_iterator = all_edges_list.begin();
+        while(
+            edge_iterator != all_edges_list.end() &&
+            node_iterator != all_nodes_list.end()
+        ) {
+            if(edge_iterator->start < node_iterator->id){
+                ++edge_iterator;
                 continue;
             }
-            if(edgeIT->start > nodesIT->id) {
-                nodesIT++;
+            if(edge_iterator->start > node_iterator->id) {
+                node_iterator++;
                 continue;
             }
-            if(edgeIT->start == nodesIT->id) {
-                edgeIT->startCoord.lat = nodesIT->lat;
-                edgeIT->startCoord.lon = nodesIT->lon;
-                ++edgeIT;
-            }
+
+            BOOST_ASSERT(edge_iterator->start == node_iterator->id);
+            edge_iterator->startCoord.lat = node_iterator->lat;
+            edge_iterator->startCoord.lon = node_iterator->lon;
+            ++edge_iterator;
         }
-        cout << "ok, after " << get_timestamp() - time << "s" << endl;
+        std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl;
         time = get_timestamp();
 
         // Sort Edges by target
-        cout << "[extractor] Sorting edges by target   ... " << flush;
-        stxxl::sort(allEdges.begin(), allEdges.end(), CmpEdgeByTargetID(), memory_to_use);
-        cout << "ok, after " << get_timestamp() - time << "s" << endl;
+        std::cout << "[extractor] Sorting edges by target   ... " << std::flush;
+        stxxl::sort(
+            all_edges_list.begin(),
+            all_edges_list.end(),
+            CmpEdgeByTargetID(),
+            4294967296
+        );
+        std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl;
         time = get_timestamp();
 
-        cout << "[extractor] Setting target coords     ... " << flush;
+        std::cout << "[extractor] Setting target coords     ... " << std::flush;
         // Traverse list of edges and nodes in parallel and set target coord
-        nodesIT = allNodes.begin();
-        edgeIT = allEdges.begin();
+        node_iterator = all_nodes_list.begin();
+        edge_iterator = all_edges_list.begin();
 
-        while(edgeIT != allEdges.end() && nodesIT != allNodes.end()) {
-            if(edgeIT->target < nodesIT->id){
-                ++edgeIT;
+        while(
+            edge_iterator != all_edges_list.end() &&
+            node_iterator != all_nodes_list.end()
+        ) {
+            if(edge_iterator->target < node_iterator->id){
+                ++edge_iterator;
                 continue;
             }
-            if(edgeIT->target > nodesIT->id) {
-                ++nodesIT;
+            if(edge_iterator->target > node_iterator->id) {
+                ++node_iterator;
                 continue;
             }
-            if(edgeIT->target == nodesIT->id) {
-                if(edgeIT->startCoord.lat != INT_MIN && edgeIT->startCoord.lon != INT_MIN) {
-                    edgeIT->targetCoord.lat = nodesIT->lat;
-                    edgeIT->targetCoord.lon = nodesIT->lon;
+            BOOST_ASSERT(edge_iterator->target == node_iterator->id);
+            if(edge_iterator->startCoord.lat != INT_MIN && edge_iterator->startCoord.lon != INT_MIN) {
+                edge_iterator->targetCoord.lat = node_iterator->lat;
+                edge_iterator->targetCoord.lon = node_iterator->lon;
 
-                    double distance = ApproximateDistance(edgeIT->startCoord.lat, edgeIT->startCoord.lon, nodesIT->lat, nodesIT->lon);
-                    assert(edgeIT->speed != -1);
-                    double weight = ( distance * 10. ) / (edgeIT->speed / 3.6);
-                    int intWeight = std::max(1, (int)std::floor((edgeIT->isDurationSet ? edgeIT->speed : weight)+.5) );
-                    int intDist = std::max(1, (int)distance);
-                    short zero = 0;
-                    short one = 1;
+                const double distance = ApproximateDistance(
+                    edge_iterator->startCoord.lat,
+                    edge_iterator->startCoord.lon,
+                    node_iterator->lat,
+                    node_iterator->lon
+                );
 
-                    fout.write((char*)&edgeIT->start, sizeof(unsigned));
-                    fout.write((char*)&edgeIT->target, sizeof(unsigned));
-                    fout.write((char*)&intDist, sizeof(int));
-                    switch(edgeIT->direction) {
-                    case _Way::notSure:
-                        fout.write((char*)&zero, sizeof(short));
-                        break;
-                    case _Way::oneway:
-                        fout.write((char*)&one, sizeof(short));
-                        break;
-                    case _Way::bidirectional:
-                        fout.write((char*)&zero, sizeof(short));
+                BOOST_ASSERT(edge_iterator->speed != -1);
+                const double weight = ( distance * 10. ) / (edge_iterator->speed / 3.6);
+                int integer_weight = std::max( 1, (int)std::floor((edge_iterator->isDurationSet ? edge_iterator->speed : weight)+.5) );
+                int integer_distance = std::max( 1, (int)distance );
+                short zero = 0;
+                short one = 1;
 
-                        break;
-                    case _Way::opposite:
-                        fout.write((char*)&one, sizeof(short));
-                        break;
-                    default:
-                        cerr << "[error] edge with no direction: " << edgeIT->direction << endl;
-                        assert(false);
-                        break;
-                    }
-                    fout.write((char*)&intWeight, sizeof(int));
-                    assert(edgeIT->type >= 0);
-                    fout.write((char*)&edgeIT->type, sizeof(short));
-                    fout.write((char*)&edgeIT->nameID, sizeof(unsigned));
-                    fout.write((char*)&edgeIT->isRoundabout, sizeof(bool));
-                    fout.write((char*)&edgeIT->ignoreInGrid, sizeof(bool));
-                    fout.write((char*)&edgeIT->isAccessRestricted, sizeof(bool));
+                file_out_stream.write((char*)&edge_iterator->start, sizeof(unsigned));
+                file_out_stream.write((char*)&edge_iterator->target, sizeof(unsigned));
+                file_out_stream.write((char*)&integer_distance, sizeof(int));
+                switch(edge_iterator->direction) {
+                case ExtractionWay::notSure:
+                    file_out_stream.write((char*)&zero, sizeof(short));
+                    break;
+                case ExtractionWay::oneway:
+                    file_out_stream.write((char*)&one, sizeof(short));
+                    break;
+                case ExtractionWay::bidirectional:
+                    file_out_stream.write((char*)&zero, sizeof(short));
+
+                    break;
+                case ExtractionWay::opposite:
+                    file_out_stream.write((char*)&one, sizeof(short));
+                    break;
+                default:
+                    throw OSRMException("edge has broken direction");
+                    break;
                 }
-                ++usedEdgeCounter;
-                ++edgeIT;
+                file_out_stream.write(
+                    (char*)&integer_weight, sizeof(int)
+                );
+                BOOST_ASSERT(edge_iterator->type >= 0);
+                file_out_stream.write(
+                    (char*)&edge_iterator->type,
+                    sizeof(short)
+                );
+                file_out_stream.write(
+                    (char*)&edge_iterator->nameID,
+                    sizeof(unsigned)
+                );
+                file_out_stream.write(
+                    (char*)&edge_iterator->isRoundabout,
+                    sizeof(bool)
+                );
+                file_out_stream.write(
+                    (char*)&edge_iterator->ignoreInGrid,
+                    sizeof(bool)
+                );
+                file_out_stream.write(
+                    (char*)&edge_iterator->isAccessRestricted,
+                    sizeof(bool)
+                );
+                file_out_stream.write(
+                    (char*)&edge_iterator->isContraFlow,
+                    sizeof(bool)
+                );
+                ++number_of_used_edges;
             }
+            ++edge_iterator;
         }
-        cout << "ok, after " << get_timestamp() - time << "s" << endl;
-        cout << "[extractor] setting number of edges   ... " << flush;
+        std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl;
+        std::cout << "[extractor] setting number of edges   ... " << std::flush;
 
-        fout.seekp(positionInFile);
-        fout.write((char*)&usedEdgeCounter, sizeof(unsigned));
-        fout.close();
-        cout << "ok" << endl;
+        file_out_stream.seekp(previous_file_position);
+        file_out_stream.write((char*)&number_of_used_edges, sizeof(unsigned));
+        file_out_stream.close();
+        std::cout << "ok" << std::endl;
         time = get_timestamp();
-        cout << "[extractor] writing street name index ... " << flush;
-        std::string nameOutFileName = (outputFileName + ".names");
-        ofstream nameOutFile(nameOutFileName.c_str(), ios::binary);
-        unsigned sizeOfNameIndex = nameVector.size();
-        nameOutFile.write((char *)&(sizeOfNameIndex), sizeof(unsigned));
 
-        BOOST_FOREACH(string str, nameVector) {
-            unsigned lengthOfRawString = strlen(str.c_str());
-            nameOutFile.write((char *)&(lengthOfRawString), sizeof(unsigned));
-            nameOutFile.write(str.c_str(), lengthOfRawString);
+        std::cout << "[extractor] writing street name index ... " << std::flush;
+        std::string name_file_streamName = (output_file_name + ".names");
+        boost::filesystem::ofstream name_file_stream(
+            name_file_streamName,
+            std::ios::binary
+        );
+
+        //write number of names
+        const unsigned number_of_names = name_list.size()+1;
+        name_file_stream.write((char *)&(number_of_names), sizeof(unsigned));
+
+        //compute total number of chars
+        unsigned total_number_of_chars = 0;
+        BOOST_FOREACH(const std::string & temp_string, name_list) {
+            total_number_of_chars += temp_string.length();
+        }
+        //write total number of chars
+        name_file_stream.write(
+            (char *)&(total_number_of_chars),
+            sizeof(unsigned)
+        );
+        //write prefixe sums
+        unsigned name_lengths_prefix_sum = 0;
+        BOOST_FOREACH(const std::string & temp_string, name_list) {
+            name_file_stream.write(
+                (char *)&(name_lengths_prefix_sum),
+                sizeof(unsigned)
+            );
+            name_lengths_prefix_sum += temp_string.length();
+        }
+        //duplicate on purpose!
+        name_file_stream.write(
+            (char *)&(name_lengths_prefix_sum),
+            sizeof(unsigned)
+        );
+
+        //write all chars consecutively
+        BOOST_FOREACH(const std::string & temp_string, name_list) {
+            const unsigned string_length = temp_string.length();
+            name_file_stream.write(temp_string.c_str(), string_length);
         }
 
-        nameOutFile.close();
-        cout << "ok, after " << get_timestamp() - time << "s" << endl;
+        name_file_stream.close();
+        std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl;
+        SimpleLogger().Write() << "Processed " <<
+            number_of_used_nodes << " nodes and " <<
+            number_of_used_edges << " edges";
 
-        //        time = get_timestamp();
-        //        cout << "[extractor] writing address list      ... " << flush;
-        //
-        //        adressFileName.append(".address");
-        //        ofstream addressOutFile(adressFileName.c_str());
-        //        for(STXXLAddressVector::iterator it = adressVector.begin(); it != adressVector.end(); it++) {
-        //            addressOutFile << it->node.id << "|" << it->node.lat << "|" << it->node.lon << "|" << it->city << "|" << it->street << "|" << it->housenumber << "|" << it->state << "|" << it->country << "\n";
-        //        }
-        //        addressOutFile.close();
-        //        cout << "ok, after " << get_timestamp() - time << "s" << endl;
-
-        INFO("Processed " << usedNodeCounter << " nodes and " << usedEdgeCounter << " edges");
-
-
-    } catch ( const exception& e ) {
-        cerr <<  "Caught Execption:" << e.what() << endl;
+    } catch ( const std::exception& e ) {
+        std::cerr <<  "Caught Execption:" << e.what() << std::endl;
     }
 }
 

Extractor/ExtractionContainers.h

@@ -1,69 +1,82 @@
 /*
- open source routing machine
- Copyright (C) Dennis Luxen, others 2010
 
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU AFFERO General Public License as published by
- the Free Software Foundation; either version 3 of the License, or
- any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
- You should have received a copy of the GNU Affero General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 EXTRACTIONCONTAINERS_H_
 #define EXTRACTIONCONTAINERS_H_
 
-#include <boost/foreach.hpp>
-#include <stxxl.h>
-
 #include "ExtractorStructs.h"
-#include "../DataStructures/Util.h"
+#include "../Util/SimpleLogger.h"
+#include "../Util/TimingUtil.h"
+#include "../Util/UUID.h"
+
+#include <boost/assert.hpp>
+#include <boost/foreach.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/filesystem/fstream.hpp>
+
+#include <stxxl/sort>
+#include <stxxl/vector>
 
 class ExtractionContainers {
 public:
-    typedef stxxl::vector<NodeID> STXXLNodeIDVector;
-    typedef stxxl::vector<_Node> STXXLNodeVector;
-    typedef stxxl::vector<_Edge> STXXLEdgeVector;
-    typedef stxxl::vector<std::string> STXXLStringVector;
-    typedef stxxl::vector<_RawRestrictionContainer> STXXLRestrictionsVector;
-    typedef stxxl::vector<_WayIDStartAndEndEdge> STXXLWayIDStartEndVector;
+    typedef stxxl::vector<NodeID>                    STXXLNodeIDVector;
+    typedef stxxl::vector<ExternalMemoryNode>        STXXLNodeVector;
+    typedef stxxl::vector<InternalExtractorEdge>     STXXLEdgeVector;
+    typedef stxxl::vector<std::string>               STXXLStringVector;
+    typedef stxxl::vector<InputRestrictionContainer> STXXLRestrictionsVector;
+    typedef stxxl::vector<_WayIDStartAndEndEdge>     STXXLWayIDStartEndVector;
+
+    STXXLNodeIDVector                               used_node_id_list;
+    STXXLNodeVector                                 all_nodes_list;
+    STXXLEdgeVector                                 all_edges_list;
+    STXXLStringVector                               name_list;
+    STXXLRestrictionsVector                         restrictions_list;
+    STXXLWayIDStartEndVector                        way_start_end_id_list;
+    const UUID uuid;
 
     ExtractionContainers() {
-        //Check if another instance of stxxl is already running or if there is a general problem
-        try {
-            stxxl::vector<unsigned> testForRunningInstance;
-        } catch(std::exception & e) {
-            ERR("Could not instantiate STXXL layer." << std::endl << e.what());
-        }
-
-        nameVector.push_back("");
+        //Check if stxxl can be instantiated
+        stxxl::vector<unsigned> dummy_vector;
+        name_list.push_back("");
     }
+
     virtual ~ExtractionContainers() {
-        usedNodeIDs.clear();
-        allNodes.clear();
-        allEdges.clear();
-        nameVector.clear();
-        restrictionsVector.clear();
-        wayStartEndVector.clear();
+        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 PrepareData( const std::string & outputFileName, const std::string restrictionsFileName, const unsigned amountOfRAM);
-
-    STXXLNodeIDVector           usedNodeIDs;
-    STXXLNodeVector             allNodes;
-    STXXLEdgeVector             allEdges;
-    STXXLStringVector           nameVector;
-    STXXLRestrictionsVector     restrictionsVector;
-    STXXLWayIDStartEndVector    wayStartEndVector;
-
+    void PrepareData(
+        const std::string & output_file_name,
+        const std::string & restrictions_file_name
+    );
 };
 
 #endif /* EXTRACTIONCONTAINERS_H_ */

Extractor/ExtractionHelperFunctions.h

@@ -1,39 +1,46 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 EXTRACTIONHELPERFUNCTIONS_H_
 #define EXTRACTIONHELPERFUNCTIONS_H_
 
+#include "../Util/StringUtil.h"
+
 #include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string_regex.hpp>
 #include <boost/regex.hpp>
 #include <climits>
 
-#include "../Util/StringUtil.h"
+namespace qi = boost::spirit::qi;
 
 //TODO: Move into LUA
 
 inline bool durationIsValid(const std::string &s) {
-    boost::regex e ("((\\d|\\d\\d):)*(\\d|\\d\\d)",boost::regex_constants::icase|boost::regex_constants::perl);
+    boost::regex e ("((\\d|\\d\\d):(\\d|\\d\\d):(\\d|\\d\\d))|((\\d|\\d\\d):(\\d|\\d\\d))|(\\d|\\d\\d)",boost::regex_constants::icase|boost::regex_constants::perl);
 
     std::vector< std::string > result;
     boost::algorithm::split_regex( result, s, boost::regex( ":" ) ) ;
@@ -42,17 +49,28 @@ inline bool durationIsValid(const std::string &s) {
 }
 
 inline unsigned parseDuration(const std::string &s) {
-    int hours = 0;
-    int minutes = 0;
-    boost::regex e ("((\\d|\\d\\d):)*(\\d|\\d\\d)",boost::regex_constants::icase|boost::regex_constants::perl);
+	unsigned hours = 0;
+    unsigned minutes = 0;
+    unsigned seconds = 0;
+    boost::regex e ("((\\d|\\d\\d):(\\d|\\d\\d):(\\d|\\d\\d))|((\\d|\\d\\d):(\\d|\\d\\d))|(\\d|\\d\\d)",boost::regex_constants::icase|boost::regex_constants::perl);
 
     std::vector< std::string > result;
     boost::algorithm::split_regex( result, s, boost::regex( ":" ) ) ;
     bool matched = regex_match(s, e);
     if(matched) {
-        hours = (result.size()== 2) ?  stringToInt(result[0]) : 0;
-        minutes = (result.size()== 2) ?  stringToInt(result[1]) : stringToInt(result[0]);
-        return 600*(hours*60+minutes);
+    	if(1 == result.size()) {
+    		minutes = stringToInt(result[0]);
+    	}
+    	if(2 == result.size()) {
+    		minutes =  stringToInt(result[1]);
+    		hours = stringToInt(result[0]);
+    	}
+    	if(3 == result.size()) {
+            seconds = stringToInt(result[2]);
+            minutes = stringToInt(result[1]);
+            hours   = stringToInt(result[0]);
+    	}
+        return 10*(3600*hours+60*minutes+seconds);
     }
     return UINT_MAX;
 }
@@ -66,5 +84,4 @@ inline int parseMaxspeed(std::string input) { //call-by-value on purpose.
     return n;
 }
 
-
 #endif /* EXTRACTIONHELPERFUNCTIONS_H_ */

Extractor/ExtractorCallbacks.cpp

@@ -1,46 +1,31 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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.
 
-/*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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.
 
+*/
 
 #include "ExtractorCallbacks.h"
-#include "ExtractionHelperFunctions.h"
 
 ExtractorCallbacks::ExtractorCallbacks() {externalMemory = NULL; stringMap = NULL; }
 ExtractorCallbacks::ExtractorCallbacks(ExtractionContainers * ext, StringMap * strMap) {
@@ -48,58 +33,98 @@ ExtractorCallbacks::ExtractorCallbacks(ExtractionContainers * ext, StringMap * s
     stringMap = strMap;
 }
 
-ExtractorCallbacks::~ExtractorCallbacks() {
-}
+ExtractorCallbacks::~ExtractorCallbacks() { }
 
 /** warning: caller needs to take care of synchronization! */
-bool ExtractorCallbacks::nodeFunction(_Node &n) {
-    if(n.lat <= 85*100000 && n.lat >= -85*100000)
-        externalMemory->allNodes.push_back(n);
-    return true;
+void ExtractorCallbacks::nodeFunction(const ExternalMemoryNode &n) {
+    if(n.lat <= 85*COORDINATE_PRECISION && n.lat >= -85*COORDINATE_PRECISION) {
+        externalMemory->all_nodes_list.push_back(n);
+    }
 }
 
-bool ExtractorCallbacks::restrictionFunction(_RawRestrictionContainer &r) {
-    externalMemory->restrictionsVector.push_back(r);
+bool ExtractorCallbacks::restrictionFunction(const InputRestrictionContainer &r) {
+    externalMemory->restrictions_list.push_back(r);
     return true;
 }
 
 /** warning: caller needs to take care of synchronization! */
-bool ExtractorCallbacks::wayFunction(_Way &w) {
-    /*** Store name of way and split it into edge segments ***/
+void ExtractorCallbacks::wayFunction(ExtractionWay &parsed_way) {
+    if((0 < parsed_way.speed) || (0 < parsed_way.duration)) { //Only true if the way is specified by the speed profile
+        if(UINT_MAX == parsed_way.id){
+            SimpleLogger().Write(logDEBUG) <<
+                "found bogus way with id: " << parsed_way.id <<
+                " of size " << parsed_way.path.size();
+            return;
+        }
 
-    if ( w.speed > 0 ) { //Only true if the way is specified by the speed profile
+        if(0 < parsed_way.duration) {
+         //TODO: iterate all way segments and set duration corresponding to the length of each segment
+            parsed_way.speed = parsed_way.duration/(parsed_way.path.size()-1);
+        }
+
+        if(std::numeric_limits<double>::epsilon() >= fabs(-1. - parsed_way.speed)){
+            SimpleLogger().Write(logDEBUG) <<
+                "found way with bogus speed, id: " << parsed_way.id;
+            return;
+        }
 
         //Get the unique identifier for the street name
-        const StringMap::const_iterator strit = stringMap->find(w.name);
-        if(strit == stringMap->end()) {
-            w.nameID = externalMemory->nameVector.size();
-            externalMemory->nameVector.push_back(w.name);
-            stringMap->insert(StringMap::value_type(w.name, w.nameID));
+        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);
+            stringMap->insert(std::make_pair(parsed_way.name, parsed_way.nameID));
         } else {
-            w.nameID = strit->second;
+            parsed_way.nameID = string_map_iterator->second;
         }
 
-        if(fabs(-1. - w.speed) < FLT_EPSILON){
-            WARN("found way with bogus speed, id: " << w.id);
-            return true;
-        }
-        if(w.id == UINT_MAX) {
-            WARN("found way with unknown type: " << w.id);
-            return true;
+        if(ExtractionWay::opposite == parsed_way.direction) {
+            std::reverse( parsed_way.path.begin(), parsed_way.path.end() );
+            parsed_way.direction = ExtractionWay::oneway;
         }
 
-        if ( w.direction == _Way::opposite ){
-            std::reverse( w.path.begin(), w.path.end() );
-        }
+        const bool split_bidirectional_edge = (parsed_way.backward_speed > 0) && (parsed_way.speed != parsed_way.backward_speed);
 
-        for(vector< NodeID >::size_type n = 0; n < w.path.size()-1; ++n) {
-            externalMemory->allEdges.push_back(_Edge(w.path[n], w.path[n+1], w.type, w.direction, w.speed, w.nameID, w.roundabout, w.ignoreInGrid, w.isDurationSet, w.isAccessRestricted));
-            externalMemory->usedNodeIDs.push_back(w.path[n]);
+        for(std::vector< NodeID >::size_type n = 0; n < parsed_way.path.size()-1; ++n) {
+            externalMemory->all_edges_list.push_back(
+                    InternalExtractorEdge(parsed_way.path[n],
+                            parsed_way.path[n+1],
+                            parsed_way.type,
+                            (split_bidirectional_edge ? ExtractionWay::oneway : parsed_way.direction),
+                            parsed_way.speed,
+                            parsed_way.nameID,
+                            parsed_way.roundabout,
+                            parsed_way.ignoreInGrid,
+                            (0 < parsed_way.duration),
+                            parsed_way.isAccessRestricted
+                    )
+            );
+            externalMemory->used_node_id_list.push_back(parsed_way.path[n]);
         }
-        externalMemory->usedNodeIDs.push_back(w.path.back());
+        externalMemory->used_node_id_list.push_back(parsed_way.path.back());
 
         //The following information is needed to identify start and end segments of restrictions
-        externalMemory->wayStartEndVector.push_back(_WayIDStartAndEndEdge(w.id, w.path[0], w.path[1], w.path[w.path.size()-2], w.path[w.path.size()-1]));
+        externalMemory->way_start_end_id_list.push_back(_WayIDStartAndEndEdge(parsed_way.id, parsed_way.path[0], parsed_way.path[1], parsed_way.path[parsed_way.path.size()-2], parsed_way.path.back()));
+
+        if(split_bidirectional_edge) { //Only true if the way should be split
+            std::reverse( parsed_way.path.begin(), parsed_way.path.end() );
+            for(std::vector< NodeID >::size_type n = 0; n < parsed_way.path.size()-1; ++n) {
+                externalMemory->all_edges_list.push_back(
+                        InternalExtractorEdge(parsed_way.path[n],
+                                parsed_way.path[n+1],
+                                parsed_way.type,
+                                ExtractionWay::oneway,
+                                parsed_way.backward_speed,
+                                parsed_way.nameID,
+                                parsed_way.roundabout,
+                                parsed_way.ignoreInGrid,
+                                (0 < parsed_way.duration),
+                                parsed_way.isAccessRestricted,
+                                (ExtractionWay::oneway == parsed_way.direction)
+                        )
+                );
+            }
+            externalMemory->way_start_end_id_list.push_back(_WayIDStartAndEndEdge(parsed_way.id, parsed_way.path[0], parsed_way.path[1], parsed_way.path[parsed_way.path.size()-2], parsed_way.path.back()));
+        }
     }
-    return true;
 }

Extractor/ExtractorCallbacks.h

@@ -1,28 +1,38 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 EXTRACTORCALLBACKS_H_
 #define EXTRACTORCALLBACKS_H_
 
-#include <string>
-#include <vector>
+#include "ExtractionContainers.h"
+#include "ExtractionHelperFunctions.h"
+#include "ExtractorStructs.h"
+
+#include "../DataStructures/Coordinate.h"
 
 #include <cfloat>
 
@@ -30,8 +40,8 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #include <boost/algorithm/string/regex.hpp>
 #include <boost/regex.hpp>
 
-#include "ExtractionContainers.h"
-#include "ExtractorStructs.h"
+#include <string>
+#include <vector>
 
 class ExtractorCallbacks{
 private:
@@ -45,12 +55,12 @@ public:
     ~ExtractorCallbacks();
 
     /** warning: caller needs to take care of synchronization! */
-    bool nodeFunction(_Node &n);
+    void nodeFunction(const ExternalMemoryNode &n);
 
-    bool restrictionFunction(_RawRestrictionContainer &r);
+    bool restrictionFunction(const InputRestrictionContainer &r);
 
     /** warning: caller needs to take care of synchronization! */
-    bool wayFunction(_Way &w);
+    void wayFunction(ExtractionWay &w);
 
 };
 

Extractor/ExtractorStructs.h

@@ -1,95 +1,107 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 <climits>
-#include <string>
+#include "../DataStructures/Coordinate.h"
+#include "../DataStructures/HashTable.h"
+#include "../DataStructures/ImportNode.h"
+#include "../DataStructures/QueryNode.h"
+#include "../DataStructures/Restriction.h"
+#include "../typedefs.h"
 
 #include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string/regex.hpp>
 #include <boost/regex.hpp>
 #include <boost/unordered_map.hpp>
 
-#include "../DataStructures/Coordinate.h"
-#include "../DataStructures/HashTable.h"
-#include "../DataStructures/ImportNode.h"
-#include "../DataStructures/NodeCoords.h"
-#include "../DataStructures/Restriction.h"
-#include "../DataStructures/Util.h"
-#include "../typedefs.h"
+#include <climits>
+#include <string>
 
 typedef boost::unordered_map<std::string, NodeID > StringMap;
 typedef boost::unordered_map<std::string, std::pair<int, short> > StringToIntPairMap;
 
-struct _Way {
-    _Way() {
+struct ExtractionWay {
+    ExtractionWay() {
 		Clear();
     }
-	
+
 	inline void Clear(){
 		id = UINT_MAX;
 		nameID = UINT_MAX;
 		path.clear();
-		keyVals.EraseAll();
-        direction = _Way::notSure;
+		keyVals.clear();
+        direction = ExtractionWay::notSure;
         speed = -1;
+        backward_speed = -1;
+        duration = -1;
         type = -1;
         access = true;
         roundabout = false;
-        isDurationSet = false;
         isAccessRestricted = false;
         ignoreInGrid = false;
     }
 
-    enum {
+    enum Directions {
         notSure = 0, oneway, bidirectional, opposite
-    } direction;
+    };
+    Directions direction;
     unsigned id;
     unsigned nameID;
     std::string name;
     double speed;
+    double backward_speed;
+    double duration;
     short type;
     bool access;
     bool roundabout;
-    bool isDurationSet;
     bool isAccessRestricted;
     bool ignoreInGrid;
     std::vector< NodeID > path;
     HashTable<std::string, std::string> keyVals;
 };
 
-struct _Relation {
-    _Relation() : type(unknown){}
+struct ExtractorRelation {
+    ExtractorRelation() : type(unknown){}
     enum {
         unknown = 0, ferry, turnRestriction
     } type;
     HashTable<std::string, std::string> keyVals;
 };
 
-struct _Edge {
-    _Edge() : start(0), target(0), type(0), direction(0), speed(0), nameID(0), isRoundabout(false), ignoreInGrid(false), isDurationSet(false), isAccessRestricted(false) {};
-    _Edge(NodeID s, NodeID t) : start(s), target(t), type(0), direction(0), speed(0), nameID(0), isRoundabout(false), ignoreInGrid(false), isDurationSet(false), isAccessRestricted(false) { }
-    _Edge(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) { }
-    _Edge(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) {
+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;
@@ -102,19 +114,21 @@ struct _Edge {
     bool ignoreInGrid;
     bool isDurationSet;
     bool isAccessRestricted;
+    bool isContraFlow;
 
-    _Coordinate startCoord;
-    _Coordinate targetCoord;
+    FixedPointCoordinate startCoord;
+    FixedPointCoordinate targetCoord;
 
-    static _Edge min_value() {
-        return _Edge(0,0);
+    static InternalExtractorEdge min_value() {
+        return InternalExtractorEdge(0,0);
     }
-    static _Edge max_value() {
-        return _Edge((numeric_limits<unsigned>::max)(), (numeric_limits<unsigned>::max)());
+    static InternalExtractorEdge max_value() {
+        return InternalExtractorEdge((std::numeric_limits<unsigned>::max)(), (std::numeric_limits<unsigned>::max)());
     }
-
 };
 
+
+
 struct _WayIDStartAndEndEdge {
     unsigned wayID;
     NodeID firstStart;
@@ -125,10 +139,10 @@ struct _WayIDStartAndEndEdge {
     _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((numeric_limits<unsigned>::min)(), (numeric_limits<unsigned>::min)(), (numeric_limits<unsigned>::min)(), (numeric_limits<unsigned>::min)(), (numeric_limits<unsigned>::min)());
+        return _WayIDStartAndEndEdge((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() {
-        return _WayIDStartAndEndEdge((numeric_limits<unsigned>::max)(), (numeric_limits<unsigned>::max)(), (numeric_limits<unsigned>::max)(), (numeric_limits<unsigned>::max)(), (numeric_limits<unsigned>::max)());
+        return _WayIDStartAndEndEdge((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)());
     }
 };
 
@@ -147,7 +161,7 @@ struct CmpWayByID : public std::binary_function<_WayIDStartAndEndEdge, _WayIDSta
 
 struct Cmp : public std::binary_function<NodeID, NodeID, bool> {
     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() {
@@ -158,51 +172,49 @@ struct Cmp : public std::binary_function<NodeID, NodeID, bool> {
     }
 };
 
-struct CmpNodeByID : public std::binary_function<_Node, _Node, bool> {
-    typedef _Node value_type;
-    bool operator ()  (const _Node & a, const _Node & b) const {
+struct CmpNodeByID : public std::binary_function<ExternalMemoryNode, ExternalMemoryNode, bool> {
+    typedef ExternalMemoryNode value_type;
+    bool operator () (
+        const ExternalMemoryNode & a,
+        const ExternalMemoryNode & b
+    ) const {
         return a.id < b.id;
     }
     value_type max_value()  {
-        return _Node::max_value();
+        return ExternalMemoryNode::max_value();
     }
     value_type min_value() {
-        return _Node::min_value();
+        return ExternalMemoryNode::min_value();
     }
 };
 
-struct CmpEdgeByStartID : public std::binary_function<_Edge, _Edge, bool>
-{
-    typedef _Edge value_type;
-    bool operator ()  (const _Edge & a, const _Edge & b) const {
+struct CmpEdgeByStartID : public std::binary_function<InternalExtractorEdge, InternalExtractorEdge, bool> {
+    typedef InternalExtractorEdge value_type;
+    bool operator ()  (const InternalExtractorEdge & a, const InternalExtractorEdge & b) const {
         return a.start < b.start;
     }
     value_type max_value() {
-        return _Edge::max_value();
+        return InternalExtractorEdge::max_value();
     }
     value_type min_value() {
-        return _Edge::min_value();
+        return InternalExtractorEdge::min_value();
     }
 };
 
-struct CmpEdgeByTargetID : public std::binary_function<_Edge, _Edge, bool>
-{
-    typedef _Edge value_type;
-    bool operator ()  (const _Edge & a, const _Edge & b) const
-    {
+struct CmpEdgeByTargetID : public std::binary_function<InternalExtractorEdge, InternalExtractorEdge, bool> {
+    typedef InternalExtractorEdge value_type;
+    bool operator ()  (const InternalExtractorEdge & a, const InternalExtractorEdge & b) const {
         return a.target < b.target;
     }
-    value_type max_value()
-    {
-        return _Edge::max_value();
+    value_type max_value() {
+        return InternalExtractorEdge::max_value();
     }
-    value_type min_value()
-    {
-        return _Edge::min_value();
+    value_type min_value() {
+        return InternalExtractorEdge::min_value();
     }
 };
 
-inline string GetRandomString() {
+inline std::string GetRandomString() {
     char s[128];
     static const char alphanum[] =
             "0123456789"
@@ -213,7 +225,7 @@ inline string GetRandomString() {
         s[i] = alphanum[rand() % (sizeof(alphanum) - 1)];
     }
     s[127] = 0;
-    return string(s);
+    return std::string(s);
 }
 
 #endif /* EXTRACTORSTRUCTS_H_ */

Extractor/LuaUtil.h

@@ -1,35 +0,0 @@
-/*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
-
-
-
-#ifndef LUAUTIL_H_
-#define LUAUTIL_H_
-
-#include <iostream>
-
-template<typename T>
-void LUA_print(T number) {
-  std::cout << "[LUA] " << number << std::endl;
-}
-
-
-
-#endif /* LUAUTIL_H_ */

Extractor/PBFParser.cpp

@@ -0,0 +1,504 @@
+/*
+
+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.
+
+*/
+
+#include "PBFParser.h"
+
+PBFParser::PBFParser(const char * fileName, ExtractorCallbacks* ec, ScriptingEnvironment& se) : BaseParser( ec, se ) {
+	GOOGLE_PROTOBUF_VERIFY_VERSION;
+	//TODO: What is the bottleneck here? Filling the queue or reading the stuff from disk?
+	//NOTE: With Lua scripting, it is parsing the stuff. I/O is virtually for free.
+	threadDataQueue = boost::make_shared<ConcurrentQueue<_ThreadData*> >( 2500 ); /* Max 2500 items in queue, hardcoded. */
+	input.open(fileName, std::ios::in | std::ios::binary);
+
+	if (!input) {
+		throw OSRMException("pbf file not found.");
+	}
+
+#ifndef NDEBUG
+	blockCount = 0;
+	groupCount = 0;
+#endif
+}
+
+PBFParser::~PBFParser() {
+	if(input.is_open()) {
+		input.close();
+	}
+
+	// Clean up any leftover ThreadData objects in the queue
+	_ThreadData* td;
+	while (threadDataQueue->try_pop(td)) {
+		delete td;
+	}
+	google::protobuf::ShutdownProtobufLibrary();
+
+#ifndef NDEBUG
+	SimpleLogger().Write(logDEBUG) <<
+		"parsed " << blockCount <<
+		" blocks from pbf with " << groupCount <<
+		" groups";
+#endif
+}
+
+inline bool PBFParser::ReadHeader() {
+	_ThreadData initData;
+	/** read Header */
+	if(!readPBFBlobHeader(input, &initData)) {
+		return false;
+	}
+
+	if(readBlob(input, &initData)) {
+		if(!initData.PBFHeaderBlock.ParseFromArray(&(initData.charBuffer[0]), initData.charBuffer.size() ) ) {
+			std::cerr << "[error] Header not parseable!" << std::endl;
+			return false;
+		}
+
+		for(int i = 0, featureSize = initData.PBFHeaderBlock.required_features_size(); i < featureSize; ++i) {
+			const std::string& feature = initData.PBFHeaderBlock.required_features( i );
+			bool supported = false;
+			if ( "OsmSchema-V0.6" == feature ) {
+				supported = true;
+			}
+			else if ( "DenseNodes" == feature ) {
+				supported = true;
+			}
+
+			if ( !supported ) {
+				std::cerr << "[error] required feature not supported: " << feature.data() << std::endl;
+				return false;
+			}
+		}
+	} else {
+		std::cerr << "[error] blob not loaded!" << std::endl;
+	}
+	return true;
+}
+
+inline void PBFParser::ReadData() {
+	bool keepRunning = true;
+	do {
+		_ThreadData *threadData = new _ThreadData();
+		keepRunning = readNextBlock(input, threadData);
+
+		if (keepRunning) {
+			threadDataQueue->push(threadData);
+		} else {
+			threadDataQueue->push(NULL); // No more data to read, parse stops when NULL encountered
+			delete threadData;
+		}
+	} while(keepRunning);
+}
+
+inline void PBFParser::ParseData() {
+	while (true) {
+		_ThreadData *threadData;
+		threadDataQueue->wait_and_pop(threadData);
+		if( NULL==threadData ) {
+			SimpleLogger().Write() << "Parse Data Thread Finished";
+			threadDataQueue->push(NULL); // Signal end of data for other threads
+			break;
+		}
+
+		loadBlock(threadData);
+
+		for(int i = 0, groupSize = threadData->PBFprimitiveBlock.primitivegroup_size(); i < groupSize; ++i) {
+			threadData->currentGroupID = i;
+			loadGroup(threadData);
+
+			if(threadData->entityTypeIndicator == TypeNode) {
+				parseNode(threadData);
+			}
+			if(threadData->entityTypeIndicator == TypeWay) {
+				parseWay(threadData);
+			}
+			if(threadData->entityTypeIndicator == TypeRelation) {
+				parseRelation(threadData);
+			}
+			if(threadData->entityTypeIndicator == TypeDenseNode) {
+				parseDenseNode(threadData);
+			}
+		}
+
+		delete threadData;
+		threadData = NULL;
+	}
+}
+
+inline bool PBFParser::Parse() {
+	// Start the read and parse threads
+	boost::thread readThread(boost::bind(&PBFParser::ReadData, this));
+
+	//Open several parse threads that are synchronized before call to
+	boost::thread parseThread(boost::bind(&PBFParser::ParseData, this));
+
+	// Wait for the threads to finish
+	readThread.join();
+	parseThread.join();
+
+	return true;
+}
+
+inline void PBFParser::parseDenseNode(_ThreadData * threadData) {
+	const OSMPBF::DenseNodes& dense = threadData->PBFprimitiveBlock.primitivegroup( threadData->currentGroupID ).dense();
+	int denseTagIndex = 0;
+	int64_t m_lastDenseID = 0;
+	int64_t m_lastDenseLatitude = 0;
+	int64_t m_lastDenseLongitude = 0;
+
+	const int number_of_nodes = dense.id_size();
+	std::vector<ImportNode> extracted_nodes_vector(number_of_nodes);
+	for(int i = 0; i < number_of_nodes; ++i) {
+		m_lastDenseID += dense.id( i );
+		m_lastDenseLatitude += dense.lat( i );
+		m_lastDenseLongitude += dense.lon( i );
+		extracted_nodes_vector[i].id = m_lastDenseID;
+		extracted_nodes_vector[i].lat = COORDINATE_PRECISION*( ( double ) m_lastDenseLatitude * threadData->PBFprimitiveBlock.granularity() + threadData->PBFprimitiveBlock.lat_offset() ) / NANO;
+		extracted_nodes_vector[i].lon = COORDINATE_PRECISION*( ( double ) m_lastDenseLongitude * threadData->PBFprimitiveBlock.granularity() + threadData->PBFprimitiveBlock.lon_offset() ) / NANO;
+		while (denseTagIndex < dense.keys_vals_size()) {
+			const int tagValue = dense.keys_vals( denseTagIndex );
+			if( 0 == tagValue ) {
+				++denseTagIndex;
+				break;
+			}
+			const int keyValue = dense.keys_vals ( denseTagIndex+1 );
+			const std::string & key = threadData->PBFprimitiveBlock.stringtable().s(tagValue);
+			const std::string & value = threadData->PBFprimitiveBlock.stringtable().s(keyValue);
+			extracted_nodes_vector[i].keyVals.emplace(key, value);
+			denseTagIndex += 2;
+		}
+	}
+
+#pragma omp parallel for schedule ( guided )
+	for(int i = 0; i < number_of_nodes; ++i) {
+	    ImportNode &n = extracted_nodes_vector[i];
+	    ParseNodeInLua( n, scriptingEnvironment.getLuaStateForThreadID(omp_get_thread_num()) );
+	}
+
+	BOOST_FOREACH(const ImportNode &n, extracted_nodes_vector) {
+	    extractor_callbacks->nodeFunction(n);
+	}
+}
+
+inline void PBFParser::parseNode(_ThreadData * ) {
+	throw OSRMException(
+		"Parsing of simple nodes not supported. PBF should use dense nodes"
+	);
+}
+
+inline void PBFParser::parseRelation(_ThreadData * threadData) {
+	//TODO: leave early, if relation is not a restriction
+	//TODO: reuse rawRestriction container
+	if( !use_turn_restrictions ) {
+		return;
+	}
+	const OSMPBF::PrimitiveGroup& group = threadData->PBFprimitiveBlock.primitivegroup( threadData->currentGroupID );
+
+	for(int i = 0, relation_size = group.relations_size(); i < relation_size; ++i ) {
+		std::string except_tag_string;
+		const OSMPBF::Relation& inputRelation = threadData->PBFprimitiveBlock.primitivegroup( threadData->currentGroupID ).relations(i);
+		bool isRestriction = false;
+		bool isOnlyRestriction = false;
+		for(int k = 0, endOfKeys = inputRelation.keys_size(); k < endOfKeys; ++k) {
+			const std::string & key = threadData->PBFprimitiveBlock.stringtable().s(inputRelation.keys(k));
+			const std::string & val = threadData->PBFprimitiveBlock.stringtable().s(inputRelation.vals(k));
+			if ("type" == key) {
+				if( "restriction" == val) {
+					isRestriction = true;
+				} else {
+					break;
+				}
+			}
+			if ("restriction" == key) {
+				if(val.find("only_") == 0) {
+					isOnlyRestriction = true;
+				}
+			}
+			if ("except" == key) {
+				except_tag_string = val;
+			}
+		}
+
+		if( isRestriction && ShouldIgnoreRestriction(except_tag_string) ) {
+			continue;
+		}
+
+		if(isRestriction) {
+			int64_t lastRef = 0;
+			InputRestrictionContainer currentRestrictionContainer(isOnlyRestriction);
+			for(
+				int rolesIndex = 0, last_role =  inputRelation.roles_sid_size();
+				rolesIndex < last_role;
+				++rolesIndex
+			) {
+				const std::string & role = threadData->PBFprimitiveBlock.stringtable().s( inputRelation.roles_sid( rolesIndex ) );
+				lastRef += inputRelation.memids(rolesIndex);
+
+				if(!("from" == role || "to" == role || "via" == role)) {
+					continue;
+				}
+
+				switch(inputRelation.types(rolesIndex)) {
+				case 0: //node
+					if("from" == role || "to" == role) { //Only via should be a node
+						continue;
+					}
+					assert("via" == role);
+					if(UINT_MAX != currentRestrictionContainer.viaNode) {
+						currentRestrictionContainer.viaNode = UINT_MAX;
+					}
+					assert(UINT_MAX == currentRestrictionContainer.viaNode);
+					currentRestrictionContainer.restriction.viaNode = lastRef;
+					break;
+				case 1: //way
+					assert("from" == role || "to" == role || "via" == role);
+					if("from" == role) {
+						currentRestrictionContainer.fromWay = lastRef;
+					}
+					if ("to" == role) {
+						currentRestrictionContainer.toWay = lastRef;
+					}
+					if ("via" == role) {
+						assert(currentRestrictionContainer.restriction.toNode == UINT_MAX);
+						currentRestrictionContainer.viaNode = lastRef;
+					}
+					break;
+				case 2: //relation, not used. relations relating to relations are evil.
+					continue;
+					assert(false);
+					break;
+
+				default: //should not happen
+					assert(false);
+					break;
+				}
+			}
+			if(!extractor_callbacks->restrictionFunction(currentRestrictionContainer)) {
+				std::cerr << "[PBFParser] relation not parsed" << std::endl;
+			}
+		}
+	}
+}
+
+inline void PBFParser::parseWay(_ThreadData * threadData) {
+	const int number_of_ways = threadData->PBFprimitiveBlock.primitivegroup( threadData->currentGroupID ).ways_size();
+	std::vector<ExtractionWay> parsed_way_vector(number_of_ways);
+	for(int i = 0; i < number_of_ways; ++i) {
+		const OSMPBF::Way& inputWay = threadData->PBFprimitiveBlock.primitivegroup( threadData->currentGroupID ).ways( i );
+		parsed_way_vector[i].id = inputWay.id();
+		unsigned pathNode(0);
+		const int number_of_referenced_nodes = inputWay.refs_size();
+		for(int j = 0; j < number_of_referenced_nodes; ++j) {
+			pathNode += inputWay.refs(j);
+			parsed_way_vector[i].path.push_back(pathNode);
+		}
+		assert(inputWay.keys_size() == inputWay.vals_size());
+		const int number_of_keys = inputWay.keys_size();
+		for(int j = 0; j < number_of_keys; ++j) {
+			const std::string & key = threadData->PBFprimitiveBlock.stringtable().s(inputWay.keys(j));
+			const std::string & val = threadData->PBFprimitiveBlock.stringtable().s(inputWay.vals(j));
+			parsed_way_vector[i].keyVals.emplace(key, val);
+		}
+	}
+
+#pragma omp parallel for schedule ( guided )
+	for(int i = 0; i < number_of_ways; ++i) {
+	    ExtractionWay & w = parsed_way_vector[i];
+		if(2 > w.path.size()) {
+        	continue;
+    	}
+	    ParseWayInLua( w, scriptingEnvironment.getLuaStateForThreadID( omp_get_thread_num()) );
+	}
+
+	BOOST_FOREACH(ExtractionWay & w, parsed_way_vector) {
+		if(2 > w.path.size()) {
+        	continue;
+    	}
+	    extractor_callbacks->wayFunction(w);
+	}
+}
+
+inline void PBFParser::loadGroup(_ThreadData * threadData) {
+#ifndef NDEBUG
+	++groupCount;
+#endif
+
+	const OSMPBF::PrimitiveGroup& group = threadData->PBFprimitiveBlock.primitivegroup( threadData->currentGroupID );
+	threadData->entityTypeIndicator = TypeDummy;
+	if ( 0 != group.nodes_size() ) {
+		threadData->entityTypeIndicator = TypeNode;
+	}
+	if ( 0 != group.ways_size() ) {
+		threadData->entityTypeIndicator = TypeWay;
+	}
+	if ( 0 != group.relations_size() ) {
+		threadData->entityTypeIndicator = TypeRelation;
+	}
+	if ( group.has_dense() )  {
+		threadData->entityTypeIndicator = TypeDenseNode;
+		assert( 0 != group.dense().id_size() );
+	}
+	assert( threadData->entityTypeIndicator != TypeDummy );
+}
+
+inline void PBFParser::loadBlock(_ThreadData * threadData) {
+#ifndef NDEBUG
+	++blockCount;
+#endif
+	threadData->currentGroupID = 0;
+	threadData->currentEntityID = 0;
+}
+
+inline bool PBFParser::readPBFBlobHeader(std::fstream& stream, _ThreadData * threadData) {
+	int size(0);
+	stream.read((char *)&size, sizeof(int));
+	size = swapEndian(size);
+	if(stream.eof()) {
+		return false;
+	}
+	if ( size > MAX_BLOB_HEADER_SIZE || size < 0 ) {
+		return false;
+	}
+	char *data = new char[size];
+	stream.read(data, size*sizeof(data[0]));
+
+	bool dataSuccessfullyParsed = (threadData->PBFBlobHeader).ParseFromArray( data, size);
+	delete[] data;
+	return dataSuccessfullyParsed;
+}
+
+inline bool PBFParser::unpackZLIB(std::fstream &, _ThreadData * threadData) {
+	unsigned rawSize = threadData->PBFBlob.raw_size();
+	char* unpackedDataArray = new char[rawSize];
+	z_stream compressedDataStream;
+	compressedDataStream.next_in = ( unsigned char* ) threadData->PBFBlob.zlib_data().data();
+	compressedDataStream.avail_in = threadData->PBFBlob.zlib_data().size();
+	compressedDataStream.next_out = ( unsigned char* ) unpackedDataArray;
+	compressedDataStream.avail_out = rawSize;
+	compressedDataStream.zalloc = Z_NULL;
+	compressedDataStream.zfree = Z_NULL;
+	compressedDataStream.opaque = Z_NULL;
+	int ret = inflateInit( &compressedDataStream );
+	if ( ret != Z_OK ) {
+		std::cerr << "[error] failed to init zlib stream" << std::endl;
+		delete[] unpackedDataArray;
+		return false;
+	}
+
+	ret = inflate( &compressedDataStream, Z_FINISH );
+	if ( ret != Z_STREAM_END ) {
+		std::cerr << "[error] failed to inflate zlib stream" << std::endl;
+		std::cerr << "[error] Error type: " << ret << std::endl;
+		delete[] unpackedDataArray;
+		return false;
+	}
+
+	ret = inflateEnd( &compressedDataStream );
+	if ( ret != Z_OK ) {
+		std::cerr << "[error] failed to deinit zlib stream" << std::endl;
+		delete[] unpackedDataArray;
+		return false;
+	}
+
+	threadData->charBuffer.clear(); threadData->charBuffer.resize(rawSize);
+	std::copy(unpackedDataArray, unpackedDataArray + rawSize, threadData->charBuffer.begin());
+	delete[] unpackedDataArray;
+	return true;
+}
+
+inline bool PBFParser::unpackLZMA(std::fstream &, _ThreadData * ) {
+	return false;
+}
+
+inline bool PBFParser::readBlob(std::fstream& stream, _ThreadData * threadData) {
+	if(stream.eof()) {
+		return false;
+	}
+
+	const int size = threadData->PBFBlobHeader.datasize();
+	if ( size < 0 || size > MAX_BLOB_SIZE ) {
+		std::cerr << "[error] invalid Blob size:" << size << std::endl;
+		return false;
+	}
+
+	char* data = new char[size];
+	stream.read(data, sizeof(data[0])*size);
+
+	if ( !threadData->PBFBlob.ParseFromArray( data, size ) ) {
+		std::cerr << "[error] failed to parse blob" << std::endl;
+		delete[] data;
+		return false;
+	}
+
+	if ( threadData->PBFBlob.has_raw() ) {
+		const std::string& data = threadData->PBFBlob.raw();
+		threadData->charBuffer.clear();
+		threadData->charBuffer.resize( data.size() );
+		std::copy(data.begin(), data.end(), threadData->charBuffer.begin());
+	} else if ( threadData->PBFBlob.has_zlib_data() ) {
+		if ( !unpackZLIB(stream, threadData) ) {
+			std::cerr << "[error] zlib data encountered that could not be unpacked" << std::endl;
+			delete[] data;
+			return false;
+		}
+	} else if ( threadData->PBFBlob.has_lzma_data() ) {
+		if ( !unpackLZMA(stream, threadData) ) {
+			std::cerr << "[error] lzma data encountered that could not be unpacked" << std::endl;
+		}
+		delete[] data;
+		return false;
+	} else {
+		std::cerr << "[error] Blob contains no data" << std::endl;
+		delete[] data;
+		return false;
+	}
+	delete[] data;
+	return true;
+}
+
+bool PBFParser::readNextBlock(std::fstream& stream, _ThreadData * threadData) {
+	if(stream.eof()) {
+		return false;
+	}
+
+	if ( !readPBFBlobHeader(stream, threadData) ){
+		return false;
+	}
+
+	if ( threadData->PBFBlobHeader.type() != "OSMData" ) {
+		return false;
+	}
+
+	if ( !readBlob(stream, threadData) ) {
+		return false;
+	}
+
+	if ( !threadData->PBFprimitiveBlock.ParseFromArray( &(threadData->charBuffer[0]), threadData-> charBuffer.size() ) ) {
+		std::cerr << "failed to parse PrimitiveBlock" << std::endl;
+		return false;
+	}
+	return true;
+}

Extractor/PBFParser.h

@@ -1,64 +1,67 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 PBFPARSER_H_
 #define PBFPARSER_H_
 
-#include <zlib.h>
+#include "BaseParser.h"
+
+#include "../DataStructures/Coordinate.h"
+#include "../DataStructures/HashTable.h"
+#include "../DataStructures/ConcurrentQueue.h"
+#include "../Util/MachineInfo.h"
+#include "../Util/OpenMPWrapper.h"
+#include "../Util/OSRMException.h"
+#include "../Util/SimpleLogger.h"
+#include "../typedefs.h"
+
+#include <boost/shared_ptr.hpp>
 #include <boost/make_shared.hpp>
 #include <boost/ref.hpp>
-#include <boost/shared_ptr.hpp>
 
 #include <osmpbf/fileformat.pb.h>
 #include <osmpbf/osmformat.pb.h>
 
-#include "../typedefs.h"
+#include <zlib.h>
 
-#include "BaseParser.h"
-#include "ExtractorCallbacks.h"
-#include "ExtractorStructs.h"
-#include "ScriptingEnvironment.h"
-#include "../DataStructures/HashTable.h"
-#include "../DataStructures/ConcurrentQueue.h"
-#include "../Util/OpenMPWrapper.h"
-
-class PBFParser : public BaseParser<ExtractorCallbacks, _Node, _RawRestrictionContainer, _Way> {
-
-//    typedef BaseParser<ExtractorCallbacks, _Node, _RawRestrictionContainer, _Way> super;
+class PBFParser : public BaseParser {
 
     enum EntityType {
-        TypeNode = 1,
-        TypeWay = 2,
-        TypeRelation = 4,
+        TypeDummy     = 0,
+        TypeNode      = 1,
+        TypeWay       = 2,
+        TypeRelation  = 4,
         TypeDenseNode = 8
-    } ;
-
-    enum Endianness {
-        LittleEndian = 1,
-        BigEndian = 2
     };
 
     struct _ThreadData {
         int currentGroupID;
         int currentEntityID;
-        short entityTypeIndicator;
+        EntityType entityTypeIndicator;
 
         OSMPBF::BlobHeader PBFBlobHeader;
         OSMPBF::Blob PBFBlob;
@@ -70,512 +73,27 @@ class PBFParser : public BaseParser<ExtractorCallbacks, _Node, _RawRestrictionCo
     };
 
 public:
-    PBFParser(const char * fileName) : externalMemory(NULL){
-        GOOGLE_PROTOBUF_VERIFY_VERSION;
-        //TODO: What is the bottleneck here? Filling the queue or reading the stuff from disk?
-        //NOTE: With Lua scripting, it is parsing the stuff. I/O is virtually for free.
-        threadDataQueue = boost::make_shared<ConcurrentQueue<_ThreadData*> >( 2500 ); /* Max 2500 items in queue, hardcoded. */
-        input.open(fileName, std::ios::in | std::ios::binary);
+    PBFParser(const char * fileName, ExtractorCallbacks* ec, ScriptingEnvironment& se);
+    virtual ~PBFParser();
 
-        if (!input) {
-            std::cerr << fileName << ": File not found." << std::endl;
-        }
-
-#ifndef NDEBUG
-        blockCount = 0;
-        groupCount = 0;
-#endif
-    }
-
-    void RegisterCallbacks(ExtractorCallbacks * em) {
-        externalMemory = em;
-    }
-
-    //call by value, but who cares. It is done once.
-    void RegisterScriptingEnvironment(ScriptingEnvironment & _se) {
-        scriptingEnvironment = _se;
-    }
-
-    ~PBFParser() {
-        if(input.is_open())
-            input.close();
-
-        // Clean up any leftover ThreadData objects in the queue
-        _ThreadData* td;
-        while (threadDataQueue->try_pop(td)) {
-            delete td;
-        }
-        google::protobuf::ShutdownProtobufLibrary();
-
-#ifndef NDEBUG
-        DEBUG("parsed " << blockCount << " blocks from pbf with " << groupCount << " groups");
-#endif
-    }
-
-    inline bool Init() {
-        _ThreadData initData;
-        /** read Header */
-        if(!readPBFBlobHeader(input, &initData)) {
-            return false;
-        }
-
-        if(readBlob(input, &initData)) {
-            if(!initData.PBFHeaderBlock.ParseFromArray(&(initData.charBuffer[0]), initData.charBuffer.size() ) ) {
-                std::cerr << "[error] Header not parseable!" << std::endl;
-                return false;
-            }
-
-            for(int i = 0, featureSize = initData.PBFHeaderBlock.required_features_size(); i < featureSize; ++i) {
-                const std::string& feature = initData.PBFHeaderBlock.required_features( i );
-                bool supported = false;
-                if ( "OsmSchema-V0.6" == feature )
-                    supported = true;
-                else if ( "DenseNodes" == feature )
-                    supported = true;
-
-                if ( !supported ) {
-                    std::cerr << "[error] required feature not supported: " << feature.data() << std::endl;
-                    return false;
-                }
-            }
-        } else {
-            std::cerr << "[error] blob not loaded!" << std::endl;
-        }
-        return true;
-    }
-
-    inline void ReadData() {
-        bool keepRunning = true;
-        do {
-            _ThreadData *threadData = new _ThreadData();
-            keepRunning = readNextBlock(input, threadData);
-
-            if (keepRunning)
-                threadDataQueue->push(threadData);
-            else {
-                threadDataQueue->push(NULL); // No more data to read, parse stops when NULL encountered
-                delete threadData;
-            }
-        } while(keepRunning);
-    }
-
-    inline void ParseData() {
-        while (1) {
-            _ThreadData *threadData;
-            threadDataQueue->wait_and_pop(threadData);
-            if (threadData == NULL) {
-                INFO("Parse Data Thread Finished");
-                threadDataQueue->push(NULL); // Signal end of data for other threads
-                break;
-            }
-
-            loadBlock(threadData);
-
-            for(int i = 0, groupSize = threadData->PBFprimitiveBlock.primitivegroup_size(); i < groupSize; ++i) {
-                threadData->currentGroupID = i;
-                loadGroup(threadData);
-
-                if(threadData->entityTypeIndicator == TypeNode)
-                    parseNode(threadData);
-                if(threadData->entityTypeIndicator == TypeWay)
-                    parseWay(threadData);
-                if(threadData->entityTypeIndicator == TypeRelation)
-                    parseRelation(threadData);
-                if(threadData->entityTypeIndicator == TypeDenseNode)
-                    parseDenseNode(threadData);
-            }
-
-            delete threadData;
-            threadData = NULL;
-        }
-    }
-
-    inline bool Parse() {
-        // Start the read and parse threads
-        boost::thread readThread(boost::bind(&PBFParser::ReadData, this));
-
-        //Open several parse threads that are synchronized before call to
-        boost::thread parseThread(boost::bind(&PBFParser::ParseData, this));
-
-        // Wait for the threads to finish
-        readThread.join();
-        parseThread.join();
-
-        return true;
-    }
+    inline bool ReadHeader();
+	inline bool Parse();
 
 private:
+    inline void ReadData();
+    inline void ParseData();
+    inline void parseDenseNode  (_ThreadData * threadData);
+    inline void parseNode       (_ThreadData * threadData);
+    inline void parseRelation   (_ThreadData * threadData);
+    inline void parseWay        (_ThreadData * threadData);
 
-    inline void parseDenseNode(_ThreadData * threadData) {
-        const OSMPBF::DenseNodes& dense = threadData->PBFprimitiveBlock.primitivegroup( threadData->currentGroupID ).dense();
-        int denseTagIndex = 0;
-        int m_lastDenseID = 0;
-        int m_lastDenseLatitude = 0;
-        int m_lastDenseLongitude = 0;
-
-        ImportNode n;
-		std::vector<ImportNode> nodesToParse;
-        for(int i = 0, idSize = dense.id_size(); i < idSize; ++i) {
-			n.Clear();
-            m_lastDenseID += dense.id( i );
-            m_lastDenseLatitude += dense.lat( i );
-            m_lastDenseLongitude += dense.lon( i );
-            n.id = m_lastDenseID;
-            n.lat = 100000*( ( double ) m_lastDenseLatitude * threadData->PBFprimitiveBlock.granularity() +threadData-> PBFprimitiveBlock.lat_offset() ) / NANO;
-            n.lon = 100000*( ( double ) m_lastDenseLongitude * threadData->PBFprimitiveBlock.granularity() + threadData->PBFprimitiveBlock.lon_offset() ) / NANO;
-            while (denseTagIndex < dense.keys_vals_size()) {
-                const int tagValue = dense.keys_vals( denseTagIndex );
-                if(tagValue == 0) {
-                    ++denseTagIndex;
-                    break;
-                }
-                const int keyValue = dense.keys_vals ( denseTagIndex+1 );
-                const std::string & key = threadData->PBFprimitiveBlock.stringtable().s(tagValue).data();
-                const std::string & value = threadData->PBFprimitiveBlock.stringtable().s(keyValue).data();
-                n.keyVals.Add(key, value);
-                denseTagIndex += 2;
-            }
-            nodesToParse.push_back(n);
-        }
-
-        unsigned endi_nodes = nodesToParse.size();
-#pragma omp parallel for schedule ( guided )
-        for(unsigned i = 0; i < endi_nodes; ++i) {
-            ImportNode &n = nodesToParse[i];
-            /** Pass the unpacked node to the LUA call back **/
-            try {
-                luabind::call_function<int>(
-                        scriptingEnvironment.getLuaStateForThreadID(omp_get_thread_num()),
-                        "node_function",
-                        boost::ref(n)
-                );
-            } catch (const luabind::error &er) {
-                lua_State* Ler=er.state();
-                report_errors(Ler, -1);
-                ERR(er.what());
-            }
-//            catch (...) {
-//                ERR("Unknown error occurred during PBF dense node parsing!");
-//            }
-        }
-
-
-        BOOST_FOREACH(ImportNode &n, nodesToParse) {
-            if(!externalMemory->nodeFunction(n))
-                std::cerr << "[PBFParser] dense node not parsed" << std::endl;
-        }
-    }
-
-    inline void parseNode(_ThreadData * ) {
-        ERR("Parsing of simple nodes not supported. PBF should use dense nodes");
-    }
-
-    inline void parseRelation(_ThreadData * threadData) {
-		//TODO: leave early, if relatio is not a restriction
-		//TODO: reuse rawRestriction container
-        const OSMPBF::PrimitiveGroup& group = threadData->PBFprimitiveBlock.primitivegroup( threadData->currentGroupID );
-        for(int i = 0; i < group.relations_size(); ++i ) {
-            const OSMPBF::Relation& inputRelation = threadData->PBFprimitiveBlock.primitivegroup( threadData->currentGroupID ).relations(i);
-            bool isRestriction = false;
-            bool isOnlyRestriction = false;
-            for(int k = 0, endOfKeys = inputRelation.keys_size(); k < endOfKeys; ++k) {
-                const std::string & key = threadData->PBFprimitiveBlock.stringtable().s(inputRelation.keys(k));
-                const std::string & val = threadData->PBFprimitiveBlock.stringtable().s(inputRelation.vals(k));
-                if ("type" == key) {
-					if( "restriction" == val)
-                    	isRestriction = true;
-					else 
-						break;
-                }
-                if ("restriction" == key) {
-                    if(val.find("only_") == 0)
-                        isOnlyRestriction = true;
-                }
-
-            }
-            if(isRestriction) {
-                long long lastRef = 0;
-                _RawRestrictionContainer currentRestrictionContainer(isOnlyRestriction);
-                for(int rolesIndex = 0; rolesIndex < inputRelation.roles_sid_size(); ++rolesIndex) {
-                    std::string role(threadData->PBFprimitiveBlock.stringtable().s( inputRelation.roles_sid( rolesIndex ) ).data());
-                    lastRef += inputRelation.memids(rolesIndex);
-
-                    if(false == ("from" == role || "to" == role || "via" == role)) {
-                        continue;
-                    }
-
-                    switch(inputRelation.types(rolesIndex)) {
-                    case 0: //node
-                        if("from" == role || "to" == role) //Only via should be a node
-                            continue;
-                        assert("via" == role);
-                        if(UINT_MAX != currentRestrictionContainer.viaNode)
-                            currentRestrictionContainer.viaNode = UINT_MAX;
-                        assert(UINT_MAX == currentRestrictionContainer.viaNode);
-                        currentRestrictionContainer.restriction.viaNode = lastRef;
-                        break;
-                    case 1: //way
-                        assert("from" == role || "to" == role || "via" == role);
-                        if("from" == role) {
-                            currentRestrictionContainer.fromWay = lastRef;
-                        }
-                        if ("to" == role) {
-                            currentRestrictionContainer.toWay = lastRef;
-                        }
-                        if ("via" == role) {
-                            assert(currentRestrictionContainer.restriction.toNode == UINT_MAX);
-                            currentRestrictionContainer.viaNode = lastRef;
-                        }
-                        break;
-                    case 2: //relation, not used. relations relating to relations are evil.
-                        continue;
-                        assert(false);
-                        break;
-
-                    default: //should not happen
-                        //cout << "unknown";
-                        assert(false);
-                        break;
-                    }
-                }
-                //                if(UINT_MAX != currentRestriction.viaNode) {
-                //                    cout << "restr from " << currentRestriction.from << " via ";
-                //                    cout << "node " << currentRestriction.viaNode;
-                //                    cout << " to " << currentRestriction.to << endl;
-                //                }
-                if(!externalMemory->restrictionFunction(currentRestrictionContainer))
-                    std::cerr << "[PBFParser] relation not parsed" << std::endl;
-            }
-        }
-    }
-
-    inline void parseWay(_ThreadData * threadData) {
-            _Way w;
-            std::vector<_Way> waysToParse(threadData->PBFprimitiveBlock.primitivegroup( threadData->currentGroupID ).ways_size());
-            for(int i = 0, ways_size = threadData->PBFprimitiveBlock.primitivegroup( threadData->currentGroupID ).ways_size(); i < ways_size; ++i) {
-				w.Clear();
-                const OSMPBF::Way& inputWay = threadData->PBFprimitiveBlock.primitivegroup( threadData->currentGroupID ).ways( i );
-                w.id = inputWay.id();
-                unsigned pathNode(0);
-                for(int i = 0; i < inputWay.refs_size(); ++i) {
-                    pathNode += inputWay.refs(i);
-                    w.path.push_back(pathNode);
-                }
-                assert(inputWay.keys_size() == inputWay.vals_size());
-                for(int i = 0; i < inputWay.keys_size(); ++i) {
-                    const std::string & key = threadData->PBFprimitiveBlock.stringtable().s(inputWay.keys(i));
-                    const std::string & val = threadData->PBFprimitiveBlock.stringtable().s(inputWay.vals(i));
-                    w.keyVals.Add(key, val);
-                }
-
-                waysToParse.push_back(w);
-            }
-
-            unsigned endi_ways = waysToParse.size();
-#pragma omp parallel for schedule ( guided )
-            for(unsigned i = 0; i < endi_ways; ++i) {
-                _Way & w = waysToParse[i];
-                /** Pass the unpacked way to the LUA call back **/
-                try {
-                    luabind::call_function<int>(
-                        scriptingEnvironment.getLuaStateForThreadID(omp_get_thread_num()),
-                        "way_function",
-                        boost::ref(w),
-                        w.path.size()
-                    );
-
-                } catch (const luabind::error &er) {
-                    lua_State* Ler=er.state();
-                    report_errors(Ler, -1);
-                    ERR(er.what());
-                }
-//                catch (...) {
-//                    ERR("Unknown error!");
-//                }
-            }
-
-            BOOST_FOREACH(_Way & w, waysToParse) {
-                if(!externalMemory->wayFunction(w)) {
-                    std::cerr << "[PBFParser] way not parsed" << std::endl;
-                }
-            }
-    }
-
-    inline void loadGroup(_ThreadData * threadData) {
-#ifndef NDEBUG
-        ++groupCount;
-#endif
-		
-        const OSMPBF::PrimitiveGroup& group = threadData->PBFprimitiveBlock.primitivegroup( threadData->currentGroupID );
-        threadData->entityTypeIndicator = 0;
-        if ( group.nodes_size() != 0 ) {
-            threadData->entityTypeIndicator = TypeNode;
-        }
-        if ( group.ways_size() != 0 ) {
-            threadData->entityTypeIndicator = TypeWay;
-        }
-        if ( group.relations_size() != 0 ) {
-            threadData->entityTypeIndicator = TypeRelation;
-        }
-        if ( group.has_dense() )  {
-            threadData->entityTypeIndicator = TypeDenseNode;
-            assert( group.dense().id_size() != 0 );
-        }
-        assert( threadData->entityTypeIndicator != 0 );
-    }
-
-    inline void loadBlock(_ThreadData * threadData) {
-#ifndef NDEBUG
-        ++blockCount;
-#endif
-        threadData->currentGroupID = 0;
-        threadData->currentEntityID = 0;
-    }
-
-    /* Reverses Network Byte Order into something usable, compiles down to a bswap-mov combination */
-    inline unsigned swapEndian(unsigned x) const {
-        if(getMachineEndianness() == LittleEndian)
-            return ( (x>>24) | ((x<<8) & 0x00FF0000) | ((x>>8) & 0x0000FF00) | (x<<24) );
-        return x;
-    }
-
-    inline bool readPBFBlobHeader(std::fstream& stream, _ThreadData * threadData) {
-        int size(0);
-        stream.read((char *)&size, sizeof(int));
-        size = swapEndian(size);
-        if(stream.eof()) {
-            return false;
-        }
-        if ( size > MAX_BLOB_HEADER_SIZE || size < 0 ) {
-            return false;
-        }
-        char *data = new char[size];
-        stream.read(data, size*sizeof(data[0]));
-
-        bool dataSuccessfullyParsed = (threadData->PBFBlobHeader).ParseFromArray( data, size);
-        delete[] data;
-        return dataSuccessfullyParsed;
-    }
-
-    inline bool unpackZLIB(std::fstream &, _ThreadData * threadData) {
-        unsigned rawSize = threadData->PBFBlob.raw_size();
-        char* unpackedDataArray = new char[rawSize];
-        z_stream compressedDataStream;
-        compressedDataStream.next_in = ( unsigned char* ) threadData->PBFBlob.zlib_data().data();
-        compressedDataStream.avail_in = threadData->PBFBlob.zlib_data().size();
-        compressedDataStream.next_out = ( unsigned char* ) unpackedDataArray;
-        compressedDataStream.avail_out = rawSize;
-        compressedDataStream.zalloc = Z_NULL;
-        compressedDataStream.zfree = Z_NULL;
-        compressedDataStream.opaque = Z_NULL;
-        int ret = inflateInit( &compressedDataStream );
-        if ( ret != Z_OK ) {
-            std::cerr << "[error] failed to init zlib stream" << std::endl;
-            delete[] unpackedDataArray;
-            return false;
-        }
-
-        ret = inflate( &compressedDataStream, Z_FINISH );
-        if ( ret != Z_STREAM_END ) {
-            std::cerr << "[error] failed to inflate zlib stream" << std::endl;
-            std::cerr << "[error] Error type: " << ret << std::endl;
-            delete[] unpackedDataArray;
-            return false;
-        }
-
-        ret = inflateEnd( &compressedDataStream );
-        if ( ret != Z_OK ) {
-            std::cerr << "[error] failed to deinit zlib stream" << std::endl;
-            delete[] unpackedDataArray;
-            return false;
-        }
-
-        threadData->charBuffer.clear(); threadData->charBuffer.resize(rawSize);
-		std::copy(unpackedDataArray, unpackedDataArray + rawSize, threadData->charBuffer.begin());
-        delete[] unpackedDataArray;
-        return true;
-    }
-
-    inline bool unpackLZMA(std::fstream &, _ThreadData * ) const {
-        return false;
-    }
-
-    inline bool readBlob(std::fstream& stream, _ThreadData * threadData) {
-        if(stream.eof())
-            return false;
-
-        const int size = threadData->PBFBlobHeader.datasize();
-        if ( size < 0 || size > MAX_BLOB_SIZE ) {
-            std::cerr << "[error] invalid Blob size:" << size << std::endl;
-            return false;
-        }
-
-        char* data = new char[size];
-        stream.read(data, sizeof(data[0])*size);
-
-        if ( !threadData->PBFBlob.ParseFromArray( data, size ) ) {
-            std::cerr << "[error] failed to parse blob" << std::endl;
-            delete[] data;
-            return false;
-        }
-
-        if ( threadData->PBFBlob.has_raw() ) {
-            const std::string& data = threadData->PBFBlob.raw();
-            threadData->charBuffer.clear();
-            threadData->charBuffer.resize( data.size() );
-			std::copy(data.begin(), data.end(), threadData->charBuffer.begin());
-        } else if ( threadData->PBFBlob.has_zlib_data() ) {
-            if ( !unpackZLIB(stream, threadData) ) {
-                std::cerr << "[error] zlib data encountered that could not be unpacked" << std::endl;
-	            delete[] data;
-                return false;
-            }
-        } else if ( threadData->PBFBlob.has_lzma_data() ) {
-            if ( !unpackLZMA(stream, threadData) )
-                std::cerr << "[error] lzma data encountered that could not be unpacked" << std::endl;
-            delete[] data;
-            return false;
-        } else {
-            std::cerr << "[error] Blob contains no data" << std::endl;
-            delete[] data;
-            return false;
-        }
-        delete[] data;
-        return true;
-    }
-
-    inline bool readNextBlock(std::fstream& stream, _ThreadData * threadData) {
-        if(stream.eof()) {
-            return false;
-        }
-
-        if ( !readPBFBlobHeader(stream, threadData) ){
-            return false;
-        }
-
-        if ( threadData->PBFBlobHeader.type() != "OSMData" ) {
-            return false;
-        }
-
-        if ( !readBlob(stream, threadData) ) {
-            return false;
-        }
-
-        if ( !threadData->PBFprimitiveBlock.ParseFromArray( &(threadData->charBuffer[0]), threadData-> charBuffer.size() ) ) {
-            ERR("failed to parse PrimitiveBlock");
-            return false;
-        }
-        return true;
-    }
-
-	//Is optimized to a single 'mov eax,1' on GCC, clang and icc using -O3
-    inline Endianness getMachineEndianness() const {
-        int i(1);
-        char *p = (char *) &i;
-        if (1 == p[0])
-            return LittleEndian;
-        return BigEndian;
-    }
+    inline void loadGroup       (_ThreadData * threadData);
+    inline void loadBlock       (_ThreadData * threadData);
+    inline bool readPBFBlobHeader(std::fstream & stream, _ThreadData * threadData);
+    inline bool unpackZLIB       (std::fstream & stream, _ThreadData * threadData);
+    inline bool unpackLZMA       (std::fstream & stream, _ThreadData * threadData);
+    inline bool readBlob         (std::fstream & stream, _ThreadData * threadData);
+    inline bool readNextBlock    (std::fstream & stream, _ThreadData * threadData);
 
     static const int NANO = 1000 * 1000 * 1000;
     static const int MAX_BLOB_HEADER_SIZE = 64 * 1024;
@@ -586,15 +104,9 @@ private:
     unsigned groupCount;
     unsigned blockCount;
 #endif
-	
-    ExtractorCallbacks * externalMemory;
-    /* the input stream to parse */
-    std::fstream input;
 
-    /* ThreadData Queue */
+    std::fstream input;     // the input stream to parse
     boost::shared_ptr<ConcurrentQueue < _ThreadData* > > threadDataQueue;
-
-    ScriptingEnvironment scriptingEnvironment;
 };
 
 #endif /* PBFPARSER_H_ */

Extractor/ScriptingEnvironment.cpp

@@ -1,40 +1,40 @@
 /*
- open source routing machine
- Copyright (C) Dennis Luxen, others 2010
 
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU AFFERO General Public License as published by
- the Free Software Foundation; either version 3 of the License, or
- any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
- You should have received a copy of the GNU Affero General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- or see http://www.gnu.org/licenses/agpl.txt.
- */
+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.
 
-extern "C" {
-#include <lua.h>
-#include <lauxlib.h>
-#include <lualib.h>
-}
+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.
+
+*/
 
 #include "ScriptingEnvironment.h"
-#include "../typedefs.h"
-#include "../Util/OpenMPWrapper.h"
 
 ScriptingEnvironment::ScriptingEnvironment() {}
 ScriptingEnvironment::ScriptingEnvironment(const char * fileName) {
-	INFO("Using script " << fileName);
+	SimpleLogger().Write() << "Using script " << fileName;
 
     // Create a new lua state
-    for(int i = 0; i < omp_get_max_threads(); ++i)
+    for(int i = 0; i < omp_get_max_threads(); ++i) {
         luaStateVector.push_back(luaL_newstate());
+    }
 
     // Connect LuaBind to this lua state for all threads
 #pragma omp parallel
@@ -44,69 +44,66 @@ ScriptingEnvironment::ScriptingEnvironment(const char * fileName) {
         //open utility libraries string library;
         luaL_openlibs(myLuaState);
 
+        luaAddScriptFolderToLoadPath( myLuaState, fileName );
+
         // Add our function to the state's global scope
         luabind::module(myLuaState) [
-                                     luabind::def("print", LUA_print<std::string>),
-                                     luabind::def("parseMaxspeed", parseMaxspeed),
-                                     luabind::def("durationIsValid", durationIsValid),
-                                     luabind::def("parseDuration", parseDuration)
-        ];
-//#pragma omp critical
-//        {
-//            if(0 != luaL_dostring(
-//                    myLuaState,
-//                    "print('Initializing LUA engine')\n"
-//            )) {
-//                ERR(lua_tostring(myLuaState,-1)<< " occured in scripting block");
-//            }
-//        }
-        luabind::module(myLuaState) [
-                                     luabind::class_<HashTable<std::string, std::string> >("keyVals")
-                                     .def("Add", &HashTable<std::string, std::string>::Add)
-                                     .def("Find", &HashTable<std::string, std::string>::Find)
-                                     .def("Holds", &HashTable<std::string, std::string>::Holds)
-                                     ];
-
-        luabind::module(myLuaState) [
-                                     luabind::class_<ImportNode>("Node")
-                                     .def(luabind::constructor<>())
-                                     .def_readwrite("lat", &ImportNode::lat)
-                                     .def_readwrite("lon", &ImportNode::lon)
-                                     .def_readwrite("id", &ImportNode::id)
-                                     .def_readwrite("bollard", &ImportNode::bollard)
-                                     .def_readwrite("traffic_light", &ImportNode::trafficLight)
-                                     .def_readwrite("tags", &ImportNode::keyVals)
-                                     ];
-
-        luabind::module(myLuaState) [
-                                     luabind::class_<_Way>("Way")
-                                     .def(luabind::constructor<>())
-                                     .def_readwrite("name", &_Way::name)
-                                     .def_readwrite("speed", &_Way::speed)
-                                     .def_readwrite("type", &_Way::type)
-                                     .def_readwrite("access", &_Way::access)
-                                     .def_readwrite("roundabout", &_Way::roundabout)
-                                     .def_readwrite("is_duration_set", &_Way::isDurationSet)
-                                     .def_readwrite("is_access_restricted", &_Way::isAccessRestricted)
-                                     .def_readwrite("ignore_in_grid", &_Way::ignoreInGrid)
-                                     .def_readwrite("tags", &_Way::keyVals)
-                                     .def_readwrite("direction", &_Way::direction)
-                                     .enum_("constants")
-                                     [
-                                      luabind::value("notSure", 0),
-                                      luabind::value("oneway", 1),
-                                      luabind::value("bidirectional", 2),
-                                      luabind::value("opposite", 3)
-        ]
+            luabind::def("print", LUA_print<std::string>),
+            luabind::def("parseMaxspeed", parseMaxspeed),
+            luabind::def("durationIsValid", durationIsValid),
+            luabind::def("parseDuration", parseDuration)
+        ];
+
+        luabind::module(myLuaState) [
+            luabind::class_<HashTable<std::string, std::string> >("keyVals")
+            .def("Add", &HashTable<std::string, std::string>::Add)
+            .def("Find", &HashTable<std::string, std::string>::Find)
+            .def("Holds", &HashTable<std::string, std::string>::Holds)
+        ];
+
+        luabind::module(myLuaState) [
+            luabind::class_<ImportNode>("Node")
+            .def(luabind::constructor<>())
+            .def_readwrite("lat", &ImportNode::lat)
+            .def_readwrite("lon", &ImportNode::lon)
+            .def_readonly("id", &ImportNode::id)
+            .def_readwrite("bollard", &ImportNode::bollard)
+            .def_readwrite("traffic_light", &ImportNode::trafficLight)
+            .def_readwrite("tags", &ImportNode::keyVals)
+        ];
+
+        luabind::module(myLuaState) [
+            luabind::class_<ExtractionWay>("Way")
+            .def(luabind::constructor<>())
+            .def_readonly("id", &ExtractionWay::id)
+            .def_readwrite("name", &ExtractionWay::name)
+            .def_readwrite("speed", &ExtractionWay::speed)
+            .def_readwrite("backward_speed", &ExtractionWay::backward_speed)
+            .def_readwrite("duration", &ExtractionWay::duration)
+            .def_readwrite("type", &ExtractionWay::type)
+            .def_readwrite("access", &ExtractionWay::access)
+            .def_readwrite("roundabout", &ExtractionWay::roundabout)
+            .def_readwrite("is_access_restricted", &ExtractionWay::isAccessRestricted)
+            .def_readwrite("ignore_in_grid", &ExtractionWay::ignoreInGrid)
+            .def_readwrite("tags", &ExtractionWay::keyVals)
+            .def_readwrite("direction", &ExtractionWay::direction)
+            .enum_("constants") [
+				  luabind::value("notSure", 0),
+				  luabind::value("oneway", 1),
+				  luabind::value("bidirectional", 2),
+				  luabind::value("opposite", 3)
+			]
+    	];
+
+        // fails on c++11/OS X 10.9
+        luabind::module(myLuaState) [
+             luabind::class_<std::vector<std::string> >("vector")
+             .def("Add", static_cast<void (std::vector<std::string>::*)(const std::string&)>(&std::vector<std::string>::push_back)
+             )
         ];
 
-        // Now call our function in a lua script
-//#pragma omp critical
-//        {
-//            INFO("Parsing speedprofile from " << fileName );
-//        }
         if(0 != luaL_dofile(myLuaState, fileName) ) {
-            ERR(lua_tostring(myLuaState,-1)<< " occured in scripting block");
+            throw OSRMException("ERROR occured in scripting block");
         }
     }
 }

Extractor/ScriptingEnvironment.h

@@ -1,38 +1,43 @@
 /*
- open source routing machine
- Copyright (C) Dennis Luxen, others 2010
 
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU AFFERO General Public License as published by
- the Free Software Foundation; either version 3 of the License, or
- any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
- You should have received a copy of the GNU Affero General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 SCRIPTINGENVIRONMENT_H_
 #define SCRIPTINGENVIRONMENT_H_
 
-extern "C" {
-#include <lua.h>
-#include <lauxlib.h>
-#include <lualib.h>
-}
-#include <luabind/luabind.hpp>
-
 #include "ExtractionHelperFunctions.h"
 #include "ExtractorStructs.h"
-#include "LuaUtil.h"
-
 #include "../DataStructures/ImportNode.h"
+#include "../Util/LuaUtil.h"
+#include "../Util/OpenMPWrapper.h"
+#include "../Util/OSRMException.h"
+#include "../Util/SimpleLogger.h"
+#include "../typedefs.h"
+
+#include <vector>
 
 class ScriptingEnvironment {
 public:

Extractor/XMLParser.cpp

@@ -0,0 +1,284 @@
+/*
+
+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.
+
+*/
+
+#include "XMLParser.h"
+
+#include "ExtractorStructs.h"
+#include "../DataStructures/HashTable.h"
+#include "../DataStructures/InputReaderFactory.h"
+
+#include <boost/ref.hpp>
+
+XMLParser::XMLParser(const char * filename, ExtractorCallbacks* ec, ScriptingEnvironment& se) : BaseParser(ec, se) {
+	SimpleLogger().Write(logWARNING) <<
+		"Parsing plain .osm/.osm.bz2 is deprecated. Switch to .pbf";
+
+	inputReader = inputReaderFactory(filename);
+}
+
+bool XMLParser::ReadHeader() {
+	return (xmlTextReaderRead( inputReader ) == 1);
+}
+bool XMLParser::Parse() {
+	while ( xmlTextReaderRead( inputReader ) == 1 ) {
+		const int type = xmlTextReaderNodeType( inputReader );
+
+		//1 is Element
+		if ( type != 1 ) {
+			continue;
+		}
+
+		xmlChar* currentName = xmlTextReaderName( inputReader );
+		if ( currentName == NULL ) {
+			continue;
+		}
+
+		if ( xmlStrEqual( currentName, ( const xmlChar* ) "node" ) == 1 ) {
+			ImportNode n = _ReadXMLNode();
+			ParseNodeInLua( n, luaState );
+			extractor_callbacks->nodeFunction(n);
+//			if(!extractor_callbacks->nodeFunction(n))
+//				std::cerr << "[XMLParser] dense node not parsed" << std::endl;
+		}
+
+		if ( xmlStrEqual( currentName, ( const xmlChar* ) "way" ) == 1 ) {
+			ExtractionWay way = _ReadXMLWay( );
+			ParseWayInLua( way, luaState );
+			extractor_callbacks->wayFunction(way);
+//			if(!extractor_callbacks->wayFunction(way))
+//				std::cerr << "[PBFParser] way not parsed" << std::endl;
+		}
+		if( use_turn_restrictions ) {
+			if ( xmlStrEqual( currentName, ( const xmlChar* ) "relation" ) == 1 ) {
+				InputRestrictionContainer r = _ReadXMLRestriction();
+				if(r.fromWay != UINT_MAX) {
+					if(!extractor_callbacks->restrictionFunction(r)) {
+						std::cerr << "[XMLParser] restriction not parsed" << std::endl;
+					}
+				}
+			}
+		}
+		xmlFree( currentName );
+	}
+	return true;
+}
+
+InputRestrictionContainer XMLParser::_ReadXMLRestriction() {
+    InputRestrictionContainer restriction;
+    std::string except_tag_string;
+
+	if ( xmlTextReaderIsEmptyElement( inputReader ) != 1 ) {
+		const int depth = xmlTextReaderDepth( inputReader );while ( xmlTextReaderRead( inputReader ) == 1 ) {
+			const int childType = xmlTextReaderNodeType( inputReader );
+			if ( childType != 1 && childType != 15 ) {
+				continue;
+			}
+			const int childDepth = xmlTextReaderDepth( inputReader );
+			xmlChar* childName = xmlTextReaderName( inputReader );
+			if ( childName == NULL ) {
+				continue;
+			}
+			if ( depth == childDepth && childType == 15 && xmlStrEqual( childName, ( const xmlChar* ) "relation" ) == 1 ) {
+				xmlFree( childName );
+				break;
+			}
+			if ( childType != 1 ) {
+				xmlFree( childName );
+				continue;
+			}
+
+			if ( xmlStrEqual( childName, ( const xmlChar* ) "tag" ) == 1 ) {
+				xmlChar* k = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "k" );
+				xmlChar* value = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "v" );
+				if ( k != NULL && value != NULL ) {
+					if(xmlStrEqual(k, ( const xmlChar* ) "restriction" )){
+						if(0 == std::string((const char *) value).find("only_")) {
+							restriction.restriction.flags.isOnly = true;
+						}
+					}
+					if ( xmlStrEqual(k, (const xmlChar *) "except") ) {
+						except_tag_string = (const char*) value;
+					}
+				}
+
+				if ( k != NULL ) {
+					xmlFree( k );
+				}
+				if ( value != NULL ) {
+					xmlFree( value );
+				}
+			} else if ( xmlStrEqual( childName, ( const xmlChar* ) "member" ) == 1 ) {
+				xmlChar* ref = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "ref" );
+				if ( ref != NULL ) {
+					xmlChar * role = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "role" );
+					xmlChar * type = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "type" );
+
+					if(xmlStrEqual(role, (const xmlChar *) "to") && xmlStrEqual(type, (const xmlChar *) "way")) {
+						restriction.toWay = stringToUint((const char*) ref);
+					}
+					if(xmlStrEqual(role, (const xmlChar *) "from") && xmlStrEqual(type, (const xmlChar *) "way")) {
+						restriction.fromWay = stringToUint((const char*) ref);
+					}
+					if(xmlStrEqual(role, (const xmlChar *) "via") && xmlStrEqual(type, (const xmlChar *) "node")) {
+						restriction.restriction.viaNode = stringToUint((const char*) ref);
+					}
+
+					if(NULL != type) {
+						xmlFree( type );
+					}
+					if(NULL != role) {
+						xmlFree( role );
+					}
+					if(NULL != ref) {
+						xmlFree( ref );
+					}
+				}
+			}
+			xmlFree( childName );
+		}
+	}
+
+	if( ShouldIgnoreRestriction(except_tag_string) ) {
+		restriction.fromWay = UINT_MAX;				 //workaround to ignore the restriction
+	}
+	return restriction;
+}
+
+ExtractionWay XMLParser::_ReadXMLWay() {
+	ExtractionWay way;
+	if ( xmlTextReaderIsEmptyElement( inputReader ) != 1 ) {
+		const int depth = xmlTextReaderDepth( inputReader );
+		while ( xmlTextReaderRead( inputReader ) == 1 ) {
+			const int childType = xmlTextReaderNodeType( inputReader );
+			if ( childType != 1 && childType != 15 ) {
+				continue;
+			}
+			const int childDepth = xmlTextReaderDepth( inputReader );
+			xmlChar* childName = xmlTextReaderName( inputReader );
+			if ( childName == NULL ) {
+				continue;
+			}
+
+			if ( depth == childDepth && childType == 15 && xmlStrEqual( childName, ( const xmlChar* ) "way" ) == 1 ) {
+				xmlChar* id = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "id" );
+				way.id = stringToUint((char*)id);
+				xmlFree(id);
+				xmlFree( childName );
+				break;
+			}
+			if ( childType != 1 ) {
+				xmlFree( childName );
+				continue;
+			}
+
+			if ( xmlStrEqual( childName, ( const xmlChar* ) "tag" ) == 1 ) {
+				xmlChar* k = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "k" );
+				xmlChar* value = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "v" );
+				//				cout << "->k=" << k << ", v=" << value << endl;
+				if ( k != NULL && value != NULL ) {
+					way.keyVals.Add(std::string( (char *) k ), std::string( (char *) value));
+				}
+				if ( k != NULL ) {
+					xmlFree( k );
+				}
+				if ( value != NULL ) {
+					xmlFree( value );
+				}
+			} else if ( xmlStrEqual( childName, ( const xmlChar* ) "nd" ) == 1 ) {
+				xmlChar* ref = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "ref" );
+				if ( ref != NULL ) {
+					way.path.push_back( stringToUint(( const char* ) ref ) );
+					xmlFree( ref );
+				}
+			}
+			xmlFree( childName );
+		}
+	}
+	return way;
+}
+
+ImportNode XMLParser::_ReadXMLNode() {
+	ImportNode node;
+
+	xmlChar* attribute = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "lat" );
+	if ( attribute != NULL ) {
+		node.lat =  static_cast<NodeID>(COORDINATE_PRECISION*atof(( const char* ) attribute ) );
+		xmlFree( attribute );
+	}
+	attribute = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "lon" );
+	if ( attribute != NULL ) {
+		node.lon =  static_cast<NodeID>(COORDINATE_PRECISION*atof(( const char* ) attribute ));
+		xmlFree( attribute );
+	}
+	attribute = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "id" );
+	if ( attribute != NULL ) {
+		node.id =  stringToUint(( const char* ) attribute );
+		xmlFree( attribute );
+	}
+
+	if ( xmlTextReaderIsEmptyElement( inputReader ) != 1 ) {
+		const int depth = xmlTextReaderDepth( inputReader );
+		while ( xmlTextReaderRead( inputReader ) == 1 ) {
+			const int childType = xmlTextReaderNodeType( inputReader );
+			// 1 = Element, 15 = EndElement
+			if ( childType != 1 && childType != 15 ) {
+				continue;
+			}
+			const int childDepth = xmlTextReaderDepth( inputReader );
+			xmlChar* childName = xmlTextReaderName( inputReader );
+			if ( childName == NULL ) {
+				continue;
+			}
+
+			if ( depth == childDepth && childType == 15 && xmlStrEqual( childName, ( const xmlChar* ) "node" ) == 1 ) {
+				xmlFree( childName );
+				break;
+			}
+			if ( childType != 1 ) {
+				xmlFree( childName );
+				continue;
+			}
+
+			if ( xmlStrEqual( childName, ( const xmlChar* ) "tag" ) == 1 ) {
+				xmlChar* k = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "k" );
+				xmlChar* value = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "v" );
+				if ( k != NULL && value != NULL ) {
+					node.keyVals.Add(std::string( reinterpret_cast<char*>(k) ), std::string( reinterpret_cast<char*>(value)));
+				}
+				if ( k != NULL ) {
+					xmlFree( k );
+				}
+				if ( value != NULL ) {
+					xmlFree( value );
+				}
+			}
+
+			xmlFree( childName );
+		}
+	}
+	return node;
+}

Extractor/XMLParser.h

@@ -1,308 +1,53 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 XMLPARSER_H_
 #define XMLPARSER_H_
 
-#include <boost/ref.hpp>
+#include "BaseParser.h"
+#include "../DataStructures/Coordinate.h"
+#include "../Util/SimpleLogger.h"
+#include "../Util/StringUtil.h"
+#include "../typedefs.h"
+
 #include <libxml/xmlreader.h>
 
-#include "../typedefs.h"
-#include "BaseParser.h"
-#include "ExtractorStructs.h"
-#include "ExtractorCallbacks.h"
-#include "ScriptingEnvironment.h"
-#include "../DataStructures/HashTable.h"
-#include "../DataStructures/InputReaderFactory.h"
 
-class XMLParser : public BaseParser<ExtractorCallbacks, _Node, _RawRestrictionContainer, _Way> {
+class XMLParser : public BaseParser {
 public:
-    XMLParser(const char * filename) : externalMemory(NULL), myLuaState(NULL){
-        WARN("Parsing plain .osm/.osm.bz2 is deprecated. Switch to .pbf");
-        inputReader = inputReaderFactory(filename);
-    }
-    virtual ~XMLParser() {}
-
-    void RegisterCallbacks(ExtractorCallbacks * em) {
-        externalMemory = em;
-    }
-
-    void RegisterScriptingEnvironment(ScriptingEnvironment & _se) {
-        myLuaState = _se.getLuaStateForThreadID(0);
-    }
-
-    bool Init() {
-        return (xmlTextReaderRead( inputReader ) == 1);
-    }
-    bool Parse() {
-        while ( xmlTextReaderRead( inputReader ) == 1 ) {
-            const int type = xmlTextReaderNodeType( inputReader );
-
-            //1 is Element
-            if ( type != 1 )
-                continue;
-
-            xmlChar* currentName = xmlTextReaderName( inputReader );
-            if ( currentName == NULL )
-                continue;
-
-            if ( xmlStrEqual( currentName, ( const xmlChar* ) "node" ) == 1 ) {
-                ImportNode n = _ReadXMLNode(  );
-                /** Pass the unpacked node to the LUA call back **/
-                try {
-                    luabind::call_function<int>(
-                            myLuaState,
-                            "node_function",
-                            boost::ref(n)
-                    );
-                    if(!externalMemory->nodeFunction(n))
-                        std::cerr << "[XMLParser] dense node not parsed" << std::endl;
-                } catch (const luabind::error &er) {
-                    cerr << er.what() << endl;
-                    lua_State* Ler=er.state();
-                    report_errors(Ler, -1);
-                } catch (std::exception & e) {
-                    ERR(e.what());
-                } catch (...) {
-                    ERR("Unknown error occurred during XML node parsing!");
-                }
-            }
-
-            if ( xmlStrEqual( currentName, ( const xmlChar* ) "way" ) == 1 ) {
-                string name;
-                _Way way = _ReadXMLWay( );
-
-                /** Pass the unpacked way to the LUA call back **/
-                try {
-                    luabind::call_function<int>(
-                            myLuaState,
-                            "way_function",
-                            boost::ref(way),
-                            way.path.size()
-                    );
-                    if(!externalMemory->wayFunction(way)) {
-                        std::cerr << "[PBFParser] way not parsed" << std::endl;
-                    }
-                } catch (const luabind::error &er) {
-                    cerr << er.what() << endl;
-                    lua_State* Ler=er.state();
-                    report_errors(Ler, -1);
-                } catch (std::exception & e) {
-                    ERR(e.what());
-                } catch (...) {
-                    ERR("Unknown error occurred during XML way parsing!");
-                }
-            }
-            if ( xmlStrEqual( currentName, ( const xmlChar* ) "relation" ) == 1 ) {
-                _RawRestrictionContainer r = _ReadXMLRestriction();
-                if(r.fromWay != UINT_MAX) {
-                    if(!externalMemory->restrictionFunction(r)) {
-                        std::cerr << "[XMLParser] restriction not parsed" << std::endl;
-                    }
-                }
-            }
-            xmlFree( currentName );
-        }
-        return true;
-    }
+    XMLParser(const char* filename, ExtractorCallbacks* ec, ScriptingEnvironment& se);
+    bool ReadHeader();
+    bool Parse();
 
 private:
-    _RawRestrictionContainer _ReadXMLRestriction ( ) {
-        _RawRestrictionContainer restriction;
-
-        if ( xmlTextReaderIsEmptyElement( inputReader ) != 1 ) {
-            const int depth = xmlTextReaderDepth( inputReader );while ( xmlTextReaderRead( inputReader ) == 1 ) {
-                const int childType = xmlTextReaderNodeType( inputReader );
-                if ( childType != 1 && childType != 15 )
-                    continue;
-                const int childDepth = xmlTextReaderDepth( inputReader );
-                xmlChar* childName = xmlTextReaderName( inputReader );
-                if ( childName == NULL )
-                    continue;
-
-                if ( depth == childDepth && childType == 15 && xmlStrEqual( childName, ( const xmlChar* ) "relation" ) == 1 ) {
-                    xmlFree( childName );
-                    break;
-                }
-                if ( childType != 1 ) {
-                    xmlFree( childName );
-                    continue;
-                }
-
-                if ( xmlStrEqual( childName, ( const xmlChar* ) "tag" ) == 1 ) {
-                    xmlChar* k = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "k" );
-                    xmlChar* value = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "v" );
-                    if ( k != NULL && value != NULL ) {
-                        if(xmlStrEqual(k, ( const xmlChar* ) "restriction" )){
-                            if(0 == std::string((const char *) value).find("only_"))
-                                restriction.restriction.flags.isOnly = true;
-                        }
-
-                    }
-                    if ( k != NULL )
-                        xmlFree( k );
-                    if ( value != NULL )
-                        xmlFree( value );
-                } else if ( xmlStrEqual( childName, ( const xmlChar* ) "member" ) == 1 ) {
-                    xmlChar* ref = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "ref" );
-                    if ( ref != NULL ) {
-                        xmlChar * role = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "role" );
-                        xmlChar * type = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "type" );
-                        if(xmlStrEqual(role, (const xmlChar *) "to") && xmlStrEqual(type, (const xmlChar *) "way")) {
-                            restriction.toWay = atoi((const char*) ref);
-                        }
-                        if(xmlStrEqual(role, (const xmlChar *) "from") && xmlStrEqual(type, (const xmlChar *) "way")) {
-                            restriction.fromWay = atoi((const char*) ref);
-                        }
-                        if(xmlStrEqual(role, (const xmlChar *) "via") && xmlStrEqual(type, (const xmlChar *) "node")) {
-                            restriction.restriction.viaNode = atoi((const char*) ref);
-                        }
-
-                        if(NULL != type)
-                            xmlFree( type );
-                        if(NULL != role)
-                            xmlFree( role );
-                        if(NULL != ref)
-                            xmlFree( ref );
-                    }
-                }
-                xmlFree( childName );
-            }
-        }
-        return restriction;
-    }
-
-    _Way _ReadXMLWay( ) {
-        _Way way;
-        if ( xmlTextReaderIsEmptyElement( inputReader ) != 1 ) {
-            const int depth = xmlTextReaderDepth( inputReader );
-            while ( xmlTextReaderRead( inputReader ) == 1 ) {
-                const int childType = xmlTextReaderNodeType( inputReader );
-                if ( childType != 1 && childType != 15 )
-                    continue;
-                const int childDepth = xmlTextReaderDepth( inputReader );
-                xmlChar* childName = xmlTextReaderName( inputReader );
-                if ( childName == NULL )
-                    continue;
-
-                if ( depth == childDepth && childType == 15 && xmlStrEqual( childName, ( const xmlChar* ) "way" ) == 1 ) {
-                    xmlChar* id = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "id" );
-                    way.id = atoi((char*)id);
-                    xmlFree(id);
-                    xmlFree( childName );
-                    break;
-                }
-                if ( childType != 1 ) {
-                    xmlFree( childName );
-                    continue;
-                }
-
-                if ( xmlStrEqual( childName, ( const xmlChar* ) "tag" ) == 1 ) {
-                    xmlChar* k = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "k" );
-                    xmlChar* value = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "v" );
-                    //                cout << "->k=" << k << ", v=" << value << endl;
-                    if ( k != NULL && value != NULL ) {
-
-                        way.keyVals.Add(std::string( (char *) k ), std::string( (char *) value));
-                    }
-                    if ( k != NULL )
-                        xmlFree( k );
-                    if ( value != NULL )
-                        xmlFree( value );
-                } else if ( xmlStrEqual( childName, ( const xmlChar* ) "nd" ) == 1 ) {
-                    xmlChar* ref = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "ref" );
-                    if ( ref != NULL ) {
-                        way.path.push_back( atoi(( const char* ) ref ) );
-                        xmlFree( ref );
-                    }
-                }
-                xmlFree( childName );
-            }
-        }
-        return way;
-    }
-
-    ImportNode _ReadXMLNode( ) {
-        ImportNode node;
-
-        xmlChar* attribute = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "lat" );
-        if ( attribute != NULL ) {
-            node.lat =  static_cast<NodeID>(100000.*atof(( const char* ) attribute ) );
-            xmlFree( attribute );
-        }
-        attribute = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "lon" );
-        if ( attribute != NULL ) {
-            node.lon =  static_cast<NodeID>(100000.*atof(( const char* ) attribute ));
-            xmlFree( attribute );
-        }
-        attribute = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "id" );
-        if ( attribute != NULL ) {
-            node.id =  atoi(( const char* ) attribute );
-            xmlFree( attribute );
-        }
-
-        if ( xmlTextReaderIsEmptyElement( inputReader ) != 1 ) {
-            const int depth = xmlTextReaderDepth( inputReader );
-            while ( xmlTextReaderRead( inputReader ) == 1 ) {
-                const int childType = xmlTextReaderNodeType( inputReader );
-                // 1 = Element, 15 = EndElement
-                if ( childType != 1 && childType != 15 )
-                    continue;
-                const int childDepth = xmlTextReaderDepth( inputReader );
-                xmlChar* childName = xmlTextReaderName( inputReader );
-                if ( childName == NULL )
-                    continue;
-
-                if ( depth == childDepth && childType == 15 && xmlStrEqual( childName, ( const xmlChar* ) "node" ) == 1 ) {
-                    xmlFree( childName );
-                    break;
-                }
-                if ( childType != 1 ) {
-                    xmlFree( childName );
-                    continue;
-                }
-
-                if ( xmlStrEqual( childName, ( const xmlChar* ) "tag" ) == 1 ) {
-                    xmlChar* k = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "k" );
-                    xmlChar* value = xmlTextReaderGetAttribute( inputReader, ( const xmlChar* ) "v" );
-                    if ( k != NULL && value != NULL ) {
-                        node.keyVals.Add(std::string( reinterpret_cast<char*>(k) ), std::string( reinterpret_cast<char*>(value)));
-                    }
-                    if ( k != NULL )
-                        xmlFree( k );
-                    if ( value != NULL )
-                        xmlFree( value );
-                }
-
-                xmlFree( childName );
-            }
-        }
-        return node;
-    }
-    /* Input Reader */
+    InputRestrictionContainer _ReadXMLRestriction();
+    ExtractionWay _ReadXMLWay();
+    ImportNode _ReadXMLNode();
     xmlTextReaderPtr inputReader;
-
-    //holds the callback functions and storage for our temporary data
-    ExtractorCallbacks * externalMemory;
-
-    lua_State *myLuaState;
 };
 
 #endif /* XMLPARSER_H_ */

Gemfile.lock

@@ -1,23 +1,23 @@
 GEM
   remote: http://rubygems.org/
   specs:
-    builder (3.0.0)
-    cucumber (1.1.4)
+    builder (3.2.2)
+    cucumber (1.3.8)
       builder (>= 2.1.2)
-      diff-lcs (>= 1.1.2)
-      gherkin (~> 2.7.1)
-      json (>= 1.4.6)
-      term-ansicolor (>= 1.0.6)
-    diff-lcs (1.1.3)
-    gherkin (2.7.6)
-      json (>= 1.4.6)
-    json (1.6.5)
+      diff-lcs (>= 1.1.3)
+      gherkin (~> 2.12.1)
+      multi_json (>= 1.7.5, < 2.0)
+      multi_test (>= 0.0.2)
+    diff-lcs (1.2.4)
+    gherkin (2.12.1)
+      multi_json (~> 1.3)
+    multi_json (1.8.0)
+    multi_test (0.0.2)
     osmlib-base (0.1.4)
-    rake (0.9.2.2)
-    rspec-expectations (2.11.3)
-      diff-lcs (~> 1.1.3)
-    sys-proctable (0.9.1)
-    term-ansicolor (1.0.7)
+    rake (10.1.0)
+    rspec-expectations (2.14.3)
+      diff-lcs (>= 1.1.3, < 2.0)
+    sys-proctable (0.9.3)
 
 PLATFORMS
   ruby

LICENCE.TXT

@@ -1,661 +1,22 @@
-                    GNU AFFERO GENERAL PUBLIC LICENSE
-                       Version 3, 19 November 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-                            Preamble
-
-  The GNU Affero General Public License is a free, copyleft license for
-software and other kinds of works, specifically designed to ensure
-cooperation with the community in the case of network server software.
-
-  The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works.  By contrast,
-our General Public Licenses are intended to guarantee your freedom to
-share and change all versions of a program--to make sure it remains free
-software for all its users.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-them if you wish), that you receive source code or can get it if you
-want it, that you can change the software or use pieces of it in new
-free programs, and that you know you can do these things.
-
-  Developers that use our General Public Licenses protect your rights
-with two steps: (1) assert copyright on the software, and (2) offer
-you this License which gives you legal permission to copy, distribute
-and/or modify the software.
-
-  A secondary benefit of defending all users' freedom is that
-improvements made in alternate versions of the program, if they
-receive widespread use, become available for other developers to
-incorporate.  Many developers of free software are heartened and
-encouraged by the resulting cooperation.  However, in the case of
-software used on network servers, this result may fail to come about.
-The GNU General Public License permits making a modified version and
-letting the public access it on a server without ever releasing its
-source code to the public.
-
-  The GNU Affero General Public License is designed specifically to
-ensure that, in such cases, the modified source code becomes available
-to the community.  It requires the operator of a network server to
-provide the source code of the modified version running there to the
-users of that server.  Therefore, public use of a modified version, on
-a publicly accessible server, gives the public access to the source
-code of the modified version.
-
-  An older license, called the Affero General Public License and
-published by Affero, was designed to accomplish similar goals.  This is
-a different license, not a version of the Affero GPL, but Affero has
-released a new version of the Affero GPL which permits relicensing under
-this license.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-                       TERMS AND CONDITIONS
-
-  0. Definitions.
-
-  "This License" refers to version 3 of the GNU Affero General Public License.
-
-  "Copyright" also means copyright-like laws that apply to other kinds of
-works, such as semiconductor masks.
-
-  "The Program" refers to any copyrightable work licensed under this
-License.  Each licensee is addressed as "you".  "Licensees" and
-"recipients" may be individuals or organizations.
-
-  To "modify" a work means to copy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of an
-exact copy.  The resulting work is called a "modified version" of the
-earlier work or a work "based on" the earlier work.
-
-  A "covered work" means either the unmodified Program or a work based
-on the Program.
-
-  To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy.  Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-
-  To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies.  Mere interaction with a user through
-a computer network, with no transfer of a copy, is not conveying.
-
-  An interactive user interface displays "Appropriate Legal Notices"
-to the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License.  If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-
-  1. Source Code.
-
-  The "source code" for a work means the preferred form of the work
-for making modifications to it.  "Object code" means any non-source
-form of a work.
-
-  A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-
-  The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form.  A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-
-  The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities.  However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work.  For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-
-  The Corresponding Source need not include anything that users
-can regenerate automatically from other parts of the Corresponding
-Source.
-
-  The Corresponding Source for a work in source code form is that
-same work.
-
-  2. Basic Permissions.
-
-  All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met.  This License explicitly affirms your unlimited
-permission to run the unmodified Program.  The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work.  This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-
-  You may make, run and propagate covered works that you do not
-convey, without conditions so long as your license otherwise remains
-in force.  You may convey covered works to others for the sole purpose
-of having them make modifications exclusively for you, or provide you
-with facilities for running those works, provided that you comply with
-the terms of this License in conveying all material for which you do
-not control copyright.  Those thus making or running the covered works
-for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of
-your copyrighted material outside their relationship with you.
-
-  Conveying under any other circumstances is permitted solely under
-the conditions stated below.  Sublicensing is not allowed; section 10
-makes it unnecessary.
-
-  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
-  No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
-  When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-
-  4. Conveying Verbatim Copies.
-
-  You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
-  You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
-  5. Conveying Modified Source Versions.
-
-  You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-
-    a) The work must carry prominent notices stating that you modified
-    it, and giving a relevant date.
-
-    b) The work must carry prominent notices stating that it is
-    released under this License and any conditions added under section
-    7.  This requirement modifies the requirement in section 4 to
-    "keep intact all notices".
-
-    c) You must license the entire work, as a whole, under this
-    License to anyone who comes into possession of a copy.  This
-    License will therefore apply, along with any applicable section 7
-    additional terms, to the whole of the work, and all its parts,
-    regardless of how they are packaged.  This License gives no
-    permission to license the work in any other way, but it does not
-    invalidate such permission if you have separately received it.
-
-    d) If the work has interactive user interfaces, each must display
-    Appropriate Legal Notices; however, if the Program has interactive
-    interfaces that do not display Appropriate Legal Notices, your
-    work need not make them do so.
-
-  A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit.  Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
-  6. Conveying Non-Source Forms.
-
-  You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-
-    a) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by the
-    Corresponding Source fixed on a durable physical medium
-    customarily used for software interchange.
-
-    b) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by a
-    written offer, valid for at least three years and valid for as
-    long as you offer spare parts or customer support for that product
-    model, to give anyone who possesses the object code either (1) a
-    copy of the Corresponding Source for all the software in the
-    product that is covered by this License, on a durable physical
-    medium customarily used for software interchange, for a price no
-    more than your reasonable cost of physically performing this
-    conveying of source, or (2) access to copy the
-    Corresponding Source from a network server at no charge.
-
-    c) Convey individual copies of the object code with a copy of the
-    written offer to provide the Corresponding Source.  This
-    alternative is allowed only occasionally and noncommercially, and
-    only if you received the object code with such an offer, in accord
-    with subsection 6b.
-
-    d) Convey the object code by offering access from a designated
-    place (gratis or for a charge), and offer equivalent access to the
-    Corresponding Source in the same way through the same place at no
-    further charge.  You need not require recipients to copy the
-    Corresponding Source along with the object code.  If the place to
-    copy the object code is a network server, the Corresponding Source
-    may be on a different server (operated by you or a third party)
-    that supports equivalent copying facilities, provided you maintain
-    clear directions next to the object code saying where to find the
-    Corresponding Source.  Regardless of what server hosts the
-    Corresponding Source, you remain obligated to ensure that it is
-    available for as long as needed to satisfy these requirements.
-
-    e) Convey the object code using peer-to-peer transmission, provided
-    you inform other peers where the object code and Corresponding
-    Source of the work are being offered to the general public at no
-    charge under subsection 6d.
-
-  A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
-  A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling.  In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage.  For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product.  A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-
-  "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source.  The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-
-  If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information.  But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
-  The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed.  Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-
-  Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
-  7. Additional Terms.
-
-  "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law.  If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
-  When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it.  (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.)  You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
-  Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-
-    a) Disclaiming warranty or limiting liability differently from the
-    terms of sections 15 and 16 of this License; or
-
-    b) Requiring preservation of specified reasonable legal notices or
-    author attributions in that material or in the Appropriate Legal
-    Notices displayed by works containing it; or
-
-    c) Prohibiting misrepresentation of the origin of that material, or
-    requiring that modified versions of such material be marked in
-    reasonable ways as different from the original version; or
-
-    d) Limiting the use for publicity purposes of names of licensors or
-    authors of the material; or
-
-    e) Declining to grant rights under trademark law for use of some
-    trade names, trademarks, or service marks; or
-
-    f) Requiring indemnification of licensors and authors of that
-    material by anyone who conveys the material (or modified versions of
-    it) with contractual assumptions of liability to the recipient, for
-    any liability that these contractual assumptions directly impose on
-    those licensors and authors.
-
-  All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10.  If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term.  If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
-  If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
-  Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-
-  8. Termination.
-
-  You may not propagate or modify a covered work except as expressly
-provided under this License.  Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
-  However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-
-  Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
-  Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License.  If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
-  9. Acceptance Not Required for Having Copies.
-
-  You are not required to accept this License in order to receive or
-run a copy of the Program.  Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance.  However,
-nothing other than this License grants you permission to propagate or
-modify any covered work.  These actions infringe copyright if you do
-not accept this License.  Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
-  10. Automatic Licensing of Downstream Recipients.
-
-  Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License.  You are not responsible
-for enforcing compliance by third parties with this License.
-
-  An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations.  If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
-  You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License.  For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
-  11. Patents.
-
-  A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based.  The
-work thus licensed is called the contributor's "contributor version".
-
-  A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version.  For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
-  Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
-  In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement).  To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
-  If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients.  "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
-  If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
-  A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License.  You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-
-  Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
-  12. No Surrender of Others' Freedom.
-
-  If conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all.  For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-
-  13. Remote Network Interaction; Use with the GNU General Public License.
-
-  Notwithstanding any other provision of this License, if you modify the
-Program, your modified version must prominently offer all users
-interacting with it remotely through a computer network (if your version
-supports such interaction) an opportunity to receive the Corresponding
-Source of your version by providing access to the Corresponding Source
-from a network server at no charge, through some standard or customary
-means of facilitating copying of software.  This Corresponding Source
-shall include the Corresponding Source for any work covered by version 3
-of the GNU General Public License that is incorporated pursuant to the
-following paragraph.
-
-  Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU General Public License into a single
-combined work, and to convey the resulting work.  The terms of this
-License will continue to apply to the part which is the covered work,
-but the work with which it is combined will remain governed by version
-3 of the GNU General Public License.
-
-  14. Revised Versions of this License.
-
-  The Free Software Foundation may publish revised and/or new versions of
-the GNU Affero General Public License from time to time.  Such new versions
-will be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-  Each version is given a distinguishing version number.  If the
-Program specifies that a certain numbered version of the GNU Affero General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation.  If the Program does not specify a version number of the
-GNU Affero General Public License, you may choose any version ever published
-by the Free Software Foundation.
-
-  If the Program specifies that a proxy can decide which future
-versions of the GNU Affero General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-
-  Later license versions may give you additional or different
-permissions.  However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
-  15. Disclaimer of Warranty.
-
-  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
-OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
-IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. Limitation of Liability.
-
-  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
-GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
-USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
-DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
-PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGES.
-
-  17. Interpretation of Sections 15 and 16.
-
-  If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
-
-                     END OF TERMS AND CONDITIONS
-
-            How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-state the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper mail.
-
-  If your software can interact with users remotely through a computer
-network, you should also make sure that it provides a way for users to
-get its source.  For example, if your program is a web application, its
-interface could display a "Source" link that leads users to an archive
-of the code.  There are many ways you could offer source, and different
-solutions will be better for different programs; see section 13 for the
-specific requirements.
-
-  You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU AGPL, see
-<http://www.gnu.org/licenses/>.
+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.

Library/OSRM.cpp

@@ -0,0 +1,131 @@
+/*
+
+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.
+
+*/
+
+#include "OSRM.h"
+
+OSRM::OSRM( const ServerPaths & server_paths, const bool use_shared_memory )
+ :
+    use_shared_memory(use_shared_memory)
+{
+    if( !use_shared_memory ) {
+        query_data_facade = new InternalDataFacade<QueryEdge::EdgeData>(
+            server_paths
+        );
+    } else {
+        query_data_facade = new SharedDataFacade<QueryEdge::EdgeData>( );
+    }
+
+    //The following plugins handle all requests.
+    RegisterPlugin(
+        new HelloWorldPlugin()
+    );
+    RegisterPlugin(
+        new LocatePlugin<BaseDataFacade<QueryEdge::EdgeData> >(
+            query_data_facade
+        )
+    );
+    RegisterPlugin(
+        new NearestPlugin<BaseDataFacade<QueryEdge::EdgeData> >(
+            query_data_facade
+        )
+    );
+    RegisterPlugin(
+        new TimestampPlugin<BaseDataFacade<QueryEdge::EdgeData> >(
+            query_data_facade
+        )
+    );
+    RegisterPlugin(
+        new ViaRoutePlugin<BaseDataFacade<QueryEdge::EdgeData> >(
+            query_data_facade
+        )
+    );
+}
+
+OSRM::~OSRM() {
+    BOOST_FOREACH(PluginMap::value_type & plugin_pointer, plugin_map) {
+        delete plugin_pointer.second;
+    }
+}
+
+void OSRM::RegisterPlugin(BasePlugin * plugin) {
+    SimpleLogger().Write()  << "loaded plugin: " << plugin->GetDescriptor();
+    if( plugin_map.find(plugin->GetDescriptor()) != plugin_map.end() ) {
+        delete plugin_map.find(plugin->GetDescriptor())->second;
+    }
+    plugin_map.emplace(plugin->GetDescriptor(), plugin);
+}
+
+void OSRM::RunQuery(RouteParameters & route_parameters, http::Reply & reply) {
+    const PluginMap::const_iterator & iter = plugin_map.find(
+        route_parameters.service
+    );
+
+    if(plugin_map.end() != iter) {
+        reply.status = http::Reply::ok;
+        if( use_shared_memory ) {
+            // lock update pending
+            boost::interprocess::scoped_lock<
+                boost::interprocess::named_mutex
+            > pending_lock(barrier.pending_update_mutex);
+
+            // lock query
+            boost::interprocess::scoped_lock<
+                boost::interprocess::named_mutex
+            > query_lock(barrier.query_mutex);
+
+            // unlock update pending
+            pending_lock.unlock();
+
+            // increment query count
+            ++(barrier.number_of_queries);
+
+            (static_cast<SharedDataFacade<QueryEdge::EdgeData>* >(query_data_facade))->CheckAndReloadFacade();
+        }
+
+        iter->second->HandleRequest(route_parameters, reply );
+        if( use_shared_memory ) {
+            // lock query
+            boost::interprocess::scoped_lock<
+                boost::interprocess::named_mutex
+            > query_lock(barrier.query_mutex);
+
+            // decrement query count
+            --(barrier.number_of_queries);
+            BOOST_ASSERT_MSG(
+                0 <= barrier.number_of_queries,
+                "invalid number of queries"
+            );
+
+            // notify all processes that were waiting for this condition
+            if (0 == barrier.number_of_queries) {
+                barrier.no_running_queries_condition.notify_all();
+            }
+        }
+    } else {
+        reply = http::Reply::StockReply(http::Reply::badRequest);
+    }
+}

Library/OSRM.h

@@ -0,0 +1,80 @@
+/*
+
+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 OSRM_H
+#define OSRM_H
+
+#include "OSRM.h"
+
+#include "../Plugins/BasePlugin.h"
+#include "../Plugins/HelloWorldPlugin.h"
+#include "../Plugins/LocatePlugin.h"
+#include "../Plugins/NearestPlugin.h"
+#include "../Plugins/TimestampPlugin.h"
+#include "../Plugins/ViaRoutePlugin.h"
+#include "../Server/DataStructures/BaseDataFacade.h"
+#include "../Server/DataStructures/InternalDataFacade.h"
+#include "../Server/DataStructures/SharedBarriers.h"
+#include "../Server/DataStructures/SharedDataFacade.h"
+#include "../Server/DataStructures/RouteParameters.h"
+#include "../Util/InputFileUtil.h"
+#include "../Util/OSRMException.h"
+#include "../Util/SimpleLogger.h"
+
+#include <boost/assert.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/foreach.hpp>
+#include <boost/interprocess/shared_memory_object.hpp>
+#include <boost/interprocess/mapped_region.hpp>
+#include <boost/interprocess/sync/scoped_lock.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/thread.hpp>
+
+#include <vector>
+
+class OSRM : boost::noncopyable {
+private:
+    typedef boost::unordered_map<std::string, BasePlugin *> PluginMap;
+public:
+    OSRM(
+        const ServerPaths & paths,
+        const bool use_shared_memory = false
+    );
+    ~OSRM();
+    void RunQuery(RouteParameters & route_parameters, http::Reply & reply);
+
+private:
+    void RegisterPlugin(BasePlugin * plugin);
+    PluginMap plugin_map;
+    bool use_shared_memory;
+    SharedBarriers barrier;
+    //base class pointer to the objects
+    BaseDataFacade<QueryEdge::EdgeData> * query_data_facade;
+};
+
+#endif //OSRM_H

Plugins/BasePlugin.h

@@ -1,41 +1,59 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 BASEPLUGIN_H_
 #define BASEPLUGIN_H_
 
-#include <cassert>
+#include "../DataStructures/Coordinate.h"
+#include "../Server/DataStructures/RouteParameters.h"
+#include "../Server/Http/Reply.h"
+
 #include <string>
 #include <vector>
 
-#include "RouteParameters.h"
-#include "../Server/BasicDatastructures.h"
-
 class BasePlugin {
 public:
 	BasePlugin() { }
 	//Maybe someone can explain the pure virtual destructor thing to me (dennis)
 	virtual ~BasePlugin() { }
-	virtual std::string GetDescriptor() const = 0;
-	virtual std::string GetVersionString() const = 0 ;
+	virtual const std::string & GetDescriptor() const = 0;
 	virtual void HandleRequest(const RouteParameters & routeParameters, http::Reply& reply) = 0;
+
+	inline bool checkCoord(const FixedPointCoordinate & c) {
+        if(
+            c.lat >   90*COORDINATE_PRECISION ||
+            c.lat <  -90*COORDINATE_PRECISION ||
+            c.lon >  180*COORDINATE_PRECISION ||
+            c.lon < -180*COORDINATE_PRECISION
+        ) {
+            return false;
+        }
+        return true;
+    }
 };
 
 #endif /* BASEPLUGIN_H_ */

Plugins/HelloWorldPlugin.h

@@ -1,50 +1,101 @@
 /*
- * LocatePlugin.h
- *
- *  Created on: 01.01.2011
- *      Author: dennis
- */
+
+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 HELLOWORLDPLUGIN_H_
 #define HELLOWORLDPLUGIN_H_
 
-#include <sstream>
-
 #include "BasePlugin.h"
-#include "RouteParameters.h"
+#include "../Util/StringUtil.h"
+
+#include <string>
 
 class HelloWorldPlugin : public BasePlugin {
+    private:
+        std::string temp_string;
 public:
-	HelloWorldPlugin() {}
-	virtual ~HelloWorldPlugin() { /*std::cout << GetDescriptor() << " destructor" << std::endl;*/ }
-	std::string GetDescriptor() const { return std::string("hello"); }
-	std::string GetVersionString() const { return std::string("0.1a"); }
+	HelloWorldPlugin() : descriptor_string("hello"){}
+	virtual ~HelloWorldPlugin() { }
+	const std::string & GetDescriptor()    const { return descriptor_string; }
 
 	void HandleRequest(const RouteParameters & routeParameters, http::Reply& reply) {
 		reply.status = http::Reply::ok;
-		reply.content.append("<html><head><title>Hello World Demonstration Document</title></head><body><h1>Hello, World!</h1>");
-		std::stringstream content;
-		content << "<pre>";
-        content << "zoom level: " << routeParameters.zoomLevel << "\n";
-        content << "checksum: " << routeParameters.checkSum << "\n";
-        content << "instructions: " << (routeParameters.printInstructions ? "yes" : "no") << "\n";
-        content << "geometry: " << (routeParameters.geometry ? "yes" : "no") << "\n";
-        content << "compression: " << (routeParameters.compression ? "yes" : "no") << "\n";
-        content << "output format: " << routeParameters.outputFormat << "\n";
-        content << "json parameter: " << routeParameters.jsonpParameter << "\n";
-        content << "language: " << routeParameters.language << "<br>";
-        content << "Number of locations: " << routeParameters.coordinates.size() << "\n";
+		reply.content.push_back("<html><head><title>Hello World Demonstration Document</title></head><body><h1>Hello, World!</h1>");
+		reply.content.push_back("<pre>");
+        reply.content.push_back("zoom level: ");
+        intToString(routeParameters.zoomLevel, temp_string);
+        reply.content.push_back(temp_string);
+        reply.content.push_back("\nchecksum: ");
+        intToString(routeParameters.checkSum, temp_string);
+        reply.content.push_back(temp_string);
+        reply.content.push_back("\ninstructions: ");
+        reply.content.push_back((routeParameters.printInstructions ? "yes" : "no"));
+        reply.content.push_back(temp_string);
+        reply.content.push_back("\ngeometry: ");
+        reply.content.push_back((routeParameters.geometry ? "yes" : "no"));
+        reply.content.push_back("\ncompression: ");
+        reply.content.push_back((routeParameters.compression ? "yes" : "no"));
+        reply.content.push_back("\noutput format: ");
+        reply.content.push_back(routeParameters.outputFormat);
+        reply.content.push_back("\njson parameter: ");
+        reply.content.push_back(routeParameters.jsonpParameter);
+        reply.content.push_back("\nlanguage: ");
+        reply.content.push_back(routeParameters.language);
+        reply.content.push_back("\nNumber of locations: ");
+        intToString(routeParameters.coordinates.size(), temp_string);
+        reply.content.push_back(temp_string);
+        reply.content.push_back("\n");
         for(unsigned i = 0; i < routeParameters.coordinates.size(); ++i) {
-            content << "  [" << i << "] " << routeParameters.coordinates[i].lat/100000. << "," << routeParameters.coordinates[i].lon/100000. << "\n";
+            reply.content.push_back( "  [");
+            intToString(i, temp_string);
+            reply.content.push_back(temp_string);
+            reply.content.push_back("] ");
+            doubleToString(routeParameters.coordinates[i].lat/COORDINATE_PRECISION, temp_string);
+            reply.content.push_back(temp_string);
+            reply.content.push_back(",");
+            doubleToString(routeParameters.coordinates[i].lon/COORDINATE_PRECISION, temp_string);
+            reply.content.push_back(temp_string);
+            reply.content.push_back("\n");
         }
-        content << "Number of hints: " << routeParameters.hints.size() << "\n";
+        reply.content.push_back( "Number of hints: ");
+        intToString(routeParameters.hints.size(), temp_string);
+        reply.content.push_back(temp_string);
+        reply.content.push_back("\n");
         for(unsigned i = 0; i < routeParameters.hints.size(); ++i) {
-            content << "  [" << i << "] " << routeParameters.hints[i] << "\n";
+            reply.content.push_back( "  [");
+            intToString(i, temp_string);
+            reply.content.push_back(temp_string);
+            reply.content.push_back("] ");
+            reply.content.push_back(routeParameters.hints[i]);
+            reply.content.push_back("\n");
         }
-        content << "</pre>";
-		reply.content.append(content.str());
-		reply.content.append("</body></html>");
+        reply.content.push_back( "</pre></body></html>");
 	}
+private:
+    std::string descriptor_string;
 };
 
 #endif /* HELLOWORLDPLUGIN_H_ */

Plugins/LocatePlugin.h

@@ -1,89 +1,100 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 LOCATEPLUGIN_H_
 #define LOCATEPLUGIN_H_
 
-#include <fstream>
-
-#include "../Server/DataStructures/QueryObjectsStorage.h"
 #include "BasePlugin.h"
-#include "RouteParameters.h"
 #include "../Util/StringUtil.h"
-#include "../DataStructures/NodeInformationHelpDesk.h"
 
-/*
- * This Plugin locates the nearest node in the road network for a given coordinate.
- */
+//locates the nearest node in the road network for a given coordinate.
+
+template<class DataFacadeT>
 class LocatePlugin : public BasePlugin {
 public:
-    LocatePlugin(QueryObjectsStorage * objects) {
-        nodeHelpDesk = objects->nodeHelpDesk;
-    }
-    std::string GetDescriptor() const { return std::string("locate"); }
-    std::string GetVersionString() const { return std::string("0.3 (DL)"); }
-    void HandleRequest(const RouteParameters & routeParameters, http::Reply& reply) {
+    LocatePlugin(DataFacadeT * facade)
+     :
+        descriptor_string("locate"),
+        facade(facade)
+    { }
+    const std::string & GetDescriptor() const { return descriptor_string; }
+
+    void HandleRequest(
+        const RouteParameters & routeParameters,
+        http::Reply& reply
+    ) {
         //check number of parameters
         if(!routeParameters.coordinates.size()) {
-            reply = http::Reply::stockReply(http::Reply::badRequest);
+            reply = http::Reply::StockReply(http::Reply::badRequest);
             return;
         }
         if(false == checkCoord(routeParameters.coordinates[0])) {
-            reply = http::Reply::stockReply(http::Reply::badRequest);
+            reply = http::Reply::StockReply(http::Reply::badRequest);
             return;
         }
 
         //query to helpdesk
-        _Coordinate result;
-        std::string JSONParameter, tmp;
+        FixedPointCoordinate result;
+        std::string tmp;
         //json
 
-//        JSONParameter = routeParameters.options.Find("jsonp");
-        if("" != routeParameters.jsonpParameter) {
-            reply.content += JSONParameter;
-            reply.content += "(";
+        if(!routeParameters.jsonpParameter.empty()) {
+            reply.content.push_back(routeParameters.jsonpParameter);
+            reply.content.push_back("(");
         }
         reply.status = http::Reply::ok;
-        reply.content += ("{");
-        reply.content += ("\"version\":0.3,");
-        if(!nodeHelpDesk->FindNearestNodeCoordForLatLon(routeParameters.coordinates[0], result)) {
-            reply.content += ("\"status\":207,");
-            reply.content += ("\"mapped_coordinate\":[]");
+        reply.content.push_back ("{");
+        reply.content.push_back ("\"version\":0.3,");
+        if(
+            !facade->LocateClosestEndPointForCoordinate(
+                routeParameters.coordinates[0],
+                result
+             )
+        ) {
+            reply.content.push_back ("\"status\":207,");
+            reply.content.push_back ("\"mapped_coordinate\":[]");
         } else {
             //Write coordinate to stream
             reply.status = http::Reply::ok;
-            reply.content += ("\"status\":0,");
-            reply.content += ("\"mapped_coordinate\":");
+            reply.content.push_back ("\"status\":0,");
+            reply.content.push_back ("\"mapped_coordinate\":");
             convertInternalLatLonToString(result.lat, tmp);
-            reply.content += "[";
-            reply.content += tmp;
+            reply.content.push_back("[");
+            reply.content.push_back(tmp);
             convertInternalLatLonToString(result.lon, tmp);
-            reply.content += ",";
-            reply.content += tmp;
-            reply.content += "]";
+            reply.content.push_back(",");
+            reply.content.push_back(tmp);
+            reply.content.push_back("]");
         }
-        reply.content += ",\"transactionId\": \"OSRM Routing Engine JSON Locate (v0.3)\"";
-        reply.content += ("}");
+        reply.content.push_back(",\"transactionId\": \"OSRM Routing Engine JSON Locate (v0.3)\"");
+        reply.content.push_back("}");
         reply.headers.resize(3);
-        if("" != JSONParameter) {
-            reply.content += ")";
+        if(!routeParameters.jsonpParameter.empty()) {
+            reply.content.push_back( ")");
             reply.headers[1].name = "Content-Type";
             reply.headers[1].value = "text/javascript";
             reply.headers[2].name = "Content-Disposition";
@@ -95,19 +106,18 @@ public:
             reply.headers[2].value = "attachment; filename=\"location.json\"";
         }
         reply.headers[0].name = "Content-Length";
-        intToString(reply.content.size(), tmp);
+        unsigned content_length = 0;
+        BOOST_FOREACH(const std::string & snippet, reply.content) {
+            content_length += snippet.length();
+        }
+        intToString(content_length, tmp);
         reply.headers[0].value = tmp;
         return;
     }
-private:
-    inline bool checkCoord(const _Coordinate & c) {
-        if(c.lat > 90*100000 || c.lat < -90*100000 || c.lon > 180*100000 || c.lon <-180*100000) {
-            return false;
-        }
-        return true;
-    }
 
-    NodeInformationHelpDesk * nodeHelpDesk;
+private:
+    std::string descriptor_string;
+    DataFacadeT * facade;
 };
 
 #endif /* LOCATEPLUGIN_H_ */

Plugins/NearestPlugin.h

@@ -1,100 +1,109 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 NearestPlugin_H_
 #define NearestPlugin_H_
 
-#include <fstream>
-
 #include "BasePlugin.h"
-#include "RouteParameters.h"
-
-#include "../Server/DataStructures/QueryObjectsStorage.h"
-
-#include "../DataStructures/NodeInformationHelpDesk.h"
+#include "../DataStructures/PhantomNodes.h"
 #include "../Util/StringUtil.h"
 
 /*
  * This Plugin locates the nearest point on a street in the road network for a given coordinate.
  */
+
+template<class DataFacadeT>
 class NearestPlugin : public BasePlugin {
 public:
-    NearestPlugin(QueryObjectsStorage * objects) : names(objects->names) {
-        nodeHelpDesk = objects->nodeHelpDesk;
-
-        descriptorTable.Set("", 0); //default descriptor
-        descriptorTable.Set("json", 1);
+    NearestPlugin(DataFacadeT * facade )
+     :
+        facade(facade),
+        descriptor_string("nearest")
+    {
+        descriptorTable.insert(std::make_pair(""    , 0)); //default descriptor
+        descriptorTable.insert(std::make_pair("json", 1));
     }
-    std::string GetDescriptor() const { return std::string("nearest"); }
-    std::string GetVersionString() const { return std::string("0.3 (DL)"); }
+    const std::string & GetDescriptor() const { return descriptor_string; }
     void HandleRequest(const RouteParameters & routeParameters, http::Reply& reply) {
         //check number of parameters
         if(!routeParameters.coordinates.size()) {
-            reply = http::Reply::stockReply(http::Reply::badRequest);
+            reply = http::Reply::StockReply(http::Reply::badRequest);
             return;
         }
-        if(false == checkCoord(routeParameters.coordinates[0])) {
-            reply = http::Reply::stockReply(http::Reply::badRequest);
+        if( !checkCoord(routeParameters.coordinates[0]) ) {
+            reply = http::Reply::StockReply(http::Reply::badRequest);
             return;
         }
 
-        //query to helpdesk
         PhantomNode result;
-        nodeHelpDesk->FindPhantomNodeForCoordinate(routeParameters.coordinates[0], result, routeParameters.zoomLevel);
+        facade->FindPhantomNodeForCoordinate(
+            routeParameters.coordinates[0],
+            result,
+            routeParameters.zoomLevel
+        );
 
-        std::string tmp;
-        std::string JSONParameter;
+        std::string temp_string;
         //json
 
         if("" != routeParameters.jsonpParameter) {
-            reply.content += routeParameters.jsonpParameter;
-            reply.content += "(";
+            reply.content.push_back(routeParameters.jsonpParameter);
+            reply.content.push_back("(");
         }
 
         reply.status = http::Reply::ok;
-        reply.content += ("{");
-        reply.content += ("\"version\":0.3,");
-        reply.content += ("\"status\":");
-        if(UINT_MAX != result.edgeBasedNode)
-            reply.content += "0,";
-        else
-            reply.content += "207,";
-        reply.content += ("\"mapped_coordinate\":");
-        reply.content += "[";
+        reply.content.push_back("{");
+        reply.content.push_back("\"version\":0.3,");
+        reply.content.push_back("\"status\":");
         if(UINT_MAX != result.edgeBasedNode) {
-            convertInternalLatLonToString(result.location.lat, tmp);
-            reply.content += tmp;
-            convertInternalLatLonToString(result.location.lon, tmp);
-            reply.content += ",";
-            reply.content += tmp;
+            reply.content.push_back("0,");
+        } else {
+            reply.content.push_back("207,");
         }
-        reply.content += "],";
-        reply.content += "\"name\":\"";
-        if(UINT_MAX != result.edgeBasedNode)
-            reply.content += names[result.nodeBasedEdgeNameID];
-        reply.content += "\"";
-        reply.content += ",\"transactionId\":\"OSRM Routing Engine JSON Nearest (v0.3)\"";
-        reply.content += ("}");
+        reply.content.push_back("\"mapped_coordinate\":");
+        reply.content.push_back("[");
+        if(UINT_MAX != result.edgeBasedNode) {
+            convertInternalLatLonToString(result.location.lat, temp_string);
+            reply.content.push_back(temp_string);
+            convertInternalLatLonToString(result.location.lon, temp_string);
+            reply.content.push_back(",");
+            reply.content.push_back(temp_string);
+        }
+        reply.content.push_back("],");
+        reply.content.push_back("\"name\":\"");
+        if(UINT_MAX != result.edgeBasedNode) {
+            facade->GetName(result.nodeBasedEdgeNameID, temp_string);
+            reply.content.push_back(temp_string);
+        }
+        reply.content.push_back("\"");
+        reply.content.push_back(",\"transactionId\":\"OSRM Routing Engine JSON Nearest (v0.3)\"");
+        reply.content.push_back("}");
         reply.headers.resize(3);
-        if("" != JSONParameter) {
-            reply.content += ")";
+        if( !routeParameters.jsonpParameter.empty() ) {
+            reply.content.push_back(")");
             reply.headers[1].name = "Content-Type";
             reply.headers[1].value = "text/javascript";
             reply.headers[2].name = "Content-Disposition";
@@ -106,20 +115,18 @@ public:
             reply.headers[2].value = "attachment; filename=\"location.json\"";
         }
         reply.headers[0].name = "Content-Length";
-        intToString(reply.content.size(), tmp);
-        reply.headers[0].value = tmp;
-    }
-private:
-    inline bool checkCoord(const _Coordinate & c) {
-        if(c.lat > 90*100000 || c.lat < -90*100000 || c.lon > 180*100000 || c.lon <-180*100000) {
-            return false;
+        unsigned content_length = 0;
+        BOOST_FOREACH(const std::string & snippet, reply.content) {
+            content_length += snippet.length();
         }
-        return true;
+        intToString(content_length, temp_string);
+        reply.headers[0].value = temp_string;
     }
 
-    NodeInformationHelpDesk * nodeHelpDesk;
+private:
+    DataFacadeT * facade;
     HashTable<std::string, unsigned> descriptorTable;
-    std::vector<std::string> & names;
+    std::string descriptor_string;
 };
 
 #endif /* NearestPlugin_H_ */

Plugins/PluginMapFactory.h

@@ -1,34 +0,0 @@
-/*
-    open source routing machine
-    Copyright (C) Dennis Luxen, 2010
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
-
-#ifndef PLUGINMAPFACTORY_H_
-#define PLUGINMAPFACTORY_H_
-
-//#include "../DataStructures/HashTable.h"
-//#include "../Plugins/BasePlugin.h"
-//
-//struct PluginMapFactory {
-//	static HashTable<std::string, BasePlugin *> * CreatePluginMap() {
-//		HashTable<std::string, BasePlugin *> * map = new HashTable<std::string, BasePlugin *>();
-//
-//	}
-//};
-
-#endif	/* PLUGINMAPFACTORY_H_ */

Plugins/RawRouteData.h

@@ -1,45 +0,0 @@
-/*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
-
-#ifndef RAWROUTEDATA_H_
-#define RAWROUTEDATA_H_
-
-#include "../typedefs.h"
-
-struct _PathData {
-    _PathData(NodeID no, unsigned na, unsigned tu, unsigned dur) : node(no), nameID(na), durationOfSegment(dur), turnInstruction(tu) { }
-    NodeID node;
-    unsigned nameID;
-    unsigned durationOfSegment;
-    short turnInstruction;
-};
-
-struct RawRouteData {
-    std::vector< _PathData > computedShortestPath;
-    std::vector< _PathData > computedAlternativePath;
-    std::vector< PhantomNodes > segmentEndCoordinates;
-    std::vector< _Coordinate > rawViaNodeCoordinates;
-    unsigned checkSum;
-    int lengthOfShortestPath;
-    int lengthOfAlternativePath;
-    RawRouteData() : checkSum(UINT_MAX), lengthOfShortestPath(INT_MAX), lengthOfAlternativePath(INT_MAX) {}
-};
-
-#endif /* RAWROUTEDATA_H_ */

Plugins/RouteParameters.h

@@ -1,107 +0,0 @@
-/*
-    open source routing machine
-    Copyright (C) Dennis Luxen, 2010
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
-
-#ifndef ROUTE_PARAMETERS_H
-#define ROUTE_PARAMETERS_H
-
-#include <string>
-#include <vector>
-
-#include <boost/fusion/sequence/intrinsic.hpp>
-
-#include "../DataStructures/Coordinate.h"
-
-struct RouteParameters {
-    RouteParameters() : zoomLevel(18), printInstructions(false), alternateRoute(true), geometry(true), compression(true), deprecatedAPI(false), checkSum(-1) {}
-    short zoomLevel;
-    bool printInstructions;
-    bool alternateRoute;
-    bool geometry;
-    bool compression;
-    bool deprecatedAPI;
-    unsigned checkSum;
-    std::string service;
-    std::string outputFormat;
-    std::string jsonpParameter;
-    std::string language;
-    std::vector<std::string> hints;
-    std::vector<_Coordinate> coordinates;
-    typedef HashTable<std::string, std::string>::MyIterator OptionsIterator;
-
-    void setZoomLevel(const short i) {
-        if (18 > i && 0 < i)
-            zoomLevel = i;
-    }
-
-    void setAlternateRouteFlag(const bool b) {
-        alternateRoute = b;
-    }
-
-    void setDeprecatedAPIFlag(const std::string &) {
-        deprecatedAPI = true;
-    }
-
-    void setChecksum(const unsigned c) {
-        checkSum = c;
-    }
-
-    void setInstructionFlag(const bool b) {
-        printInstructions = b;
-    }
-
-    void setService( const std::string & s) {
-        service = s;
-    }
-
-    void setOutputFormat(const std::string & s) {
-        outputFormat = s;
-    }
-
-    void setJSONpParameter(const std::string & s) {
-        jsonpParameter = s;
-    }
-
-    void addHint(const std::string & s) {
-        hints.resize(coordinates.size());
-        hints.back() = s;
-    }
-
-    void setLanguage(const std::string & s) {
-        language = s;
-    }
-
-    void setGeometryFlag(const bool b) {
-        geometry = b;
-    }
-
-    void setCompressionFlag(const bool b) {
-        compression = b;
-    }
-
-    void addCoordinate(boost::fusion::vector < double, double > arg_) {
-        int lat = 100000.*boost::fusion::at_c < 0 > (arg_);
-        int lon = 100000.*boost::fusion::at_c < 1 > (arg_);
-        _Coordinate myCoordinate(lat, lon);
-        coordinates.push_back(_Coordinate(lat, lon));
-    }
-};
-
-
-#endif /*ROUTE_PARAMETERS_H*/

Plugins/TimestampPlugin.h

@@ -1,59 +1,64 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 TIMESTAMPPLUGIN_H_
 #define TIMESTAMPPLUGIN_H_
 
-#include <cassert>
-
 #include "BasePlugin.h"
-#include "RouteParameters.h"
 
+template<class DataFacadeT>
 class TimestampPlugin : public BasePlugin {
 public:
-    TimestampPlugin(QueryObjectsStorage * o) : objects(o) {
-    }
-    std::string GetDescriptor() const { return std::string("timestamp"); }
-    std::string GetVersionString() const { return std::string("0.3 (DL)"); }
+    TimestampPlugin(const DataFacadeT * facade)
+     : facade(facade), descriptor_string("timestamp")
+    { }
+    const std::string & GetDescriptor() const { return descriptor_string; }
     void HandleRequest(const RouteParameters & routeParameters, http::Reply& reply) {
         std::string tmp;
 
         //json
         if("" != routeParameters.jsonpParameter) {
-            reply.content += routeParameters.jsonpParameter;
-            reply.content += "(";
+            reply.content.push_back(routeParameters.jsonpParameter);
+            reply.content.push_back("(");
         }
 
         reply.status = http::Reply::ok;
-        reply.content += ("{");
-        reply.content += ("\"version\":0.3,");
-        reply.content += ("\"status\":");
-            reply.content += "0,";
-        reply.content += ("\"timestamp\":\"");
-        reply.content += objects->timestamp;
-        reply.content += "\"";
-        reply.content += ",\"transactionId\":\"OSRM Routing Engine JSON timestamp (v0.3)\"";
-        reply.content += ("}");
+        reply.content.push_back("{");
+        reply.content.push_back("\"version\":0.3,");
+        reply.content.push_back("\"status\":");
+            reply.content.push_back("0,");
+        reply.content.push_back("\"timestamp\":\"");
+        reply.content.push_back(facade->GetTimestamp());
+        reply.content.push_back("\"");
+        reply.content.push_back(",\"transactionId\":\"OSRM Routing Engine JSON timestamp (v0.3)\"");
+        reply.content.push_back("}");
         reply.headers.resize(3);
         if("" != routeParameters.jsonpParameter) {
-            reply.content += ")";
+            reply.content.push_back(")");
             reply.headers[1].name = "Content-Type";
             reply.headers[1].value = "text/javascript";
             reply.headers[2].name = "Content-Disposition";
@@ -64,12 +69,16 @@ public:
             reply.headers[2].name = "Content-Disposition";
             reply.headers[2].value = "attachment; filename=\"timestamp.json\"";
         }
-        reply.headers[0].name = "Content-Length";
-        intToString(reply.content.size(), tmp);
+        unsigned content_length = 0;
+        BOOST_FOREACH(const std::string & snippet, reply.content) {
+            content_length += snippet.length();
+        }
+        intToString(content_length, tmp);
         reply.headers[0].value = tmp;
     }
 private:
-    QueryObjectsStorage * objects;
+    const DataFacadeT * facade;
+    std::string descriptor_string;
 };
 
 #endif /* TIMESTAMPPLUGIN_H_ */

Plugins/ViaRoutePlugin.h

@@ -1,91 +1,93 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 VIAROUTEPLUGIN_H_
 #define VIAROUTEPLUGIN_H_
 
-#include <cstdlib>
-#include <fstream>
-#include <sstream>
-#include <string>
-#include <vector>
-
 #include "BasePlugin.h"
-#include "RouteParameters.h"
 
 #include "../Algorithms/ObjectToBase64.h"
-
+#include "../DataStructures/QueryEdge.h"
+#include "../DataStructures/SearchEngine.h"
 #include "../Descriptors/BaseDescriptor.h"
 #include "../Descriptors/GPXDescriptor.h"
 #include "../Descriptors/JSONDescriptor.h"
-
-#include "../DataStructures/HashTable.h"
-#include "../DataStructures/QueryEdge.h"
-#include "../DataStructures/StaticGraph.h"
-#include "../DataStructures/SearchEngine.h"
-
+#include "../Util/SimpleLogger.h"
 #include "../Util/StringUtil.h"
 
-#include "../Server/DataStructures/QueryObjectsStorage.h"
+#include <boost/unordered_map.hpp>
 
+#include <cstdlib>
+
+#include <string>
+#include <vector>
+
+template<class DataFacadeT>
 class ViaRoutePlugin : public BasePlugin {
 private:
-    NodeInformationHelpDesk * nodeHelpDesk;
-    std::vector<std::string> & names;
-    StaticGraph<QueryEdge::EdgeData> * graph;
-    HashTable<std::string, unsigned> descriptorTable;
-    std::string pluginDescriptorString;
-    SearchEngine<QueryEdge::EdgeData, StaticGraph<QueryEdge::EdgeData> > * searchEngine;
+    boost::unordered_map<std::string, unsigned> descriptorTable;
+    SearchEngine<DataFacadeT> * search_engine_ptr;
 public:
 
-    ViaRoutePlugin(QueryObjectsStorage * objects, std::string psd = "viaroute") : names(objects->names), pluginDescriptorString(psd) {
-        nodeHelpDesk = objects->nodeHelpDesk;
-        graph = objects->graph;
+    ViaRoutePlugin(DataFacadeT * facade)
+     :
+        descriptor_string("viaroute"),
+        facade(facade)
+    {
+        //TODO: set up an engine for each thread!!
+        search_engine_ptr = new SearchEngine<DataFacadeT>(facade);
 
-        searchEngine = new SearchEngine<QueryEdge::EdgeData, StaticGraph<QueryEdge::EdgeData> >(graph, nodeHelpDesk, names);
-
-        descriptorTable.Set("", 0); //default descriptor
-        descriptorTable.Set("json", 0);
-        descriptorTable.Set("gpx", 1);
+        descriptorTable.emplace("json", 0);
+        descriptorTable.emplace("gpx" , 1);
     }
 
     virtual ~ViaRoutePlugin() {
-        delete searchEngine;
+        delete search_engine_ptr;
     }
 
-    std::string GetDescriptor() const { return pluginDescriptorString; }
-    std::string GetVersionString() const { return std::string("0.3 (DL)"); }
-    void HandleRequest(const RouteParameters & routeParameters, http::Reply& reply) {
+    const std::string & GetDescriptor() const { return descriptor_string; }
+
+    void HandleRequest(
+        const RouteParameters & routeParameters,
+        http::Reply& reply
+    ) {
         //check number of parameters
         if( 2 > routeParameters.coordinates.size() ) {
-            reply = http::Reply::stockReply(http::Reply::badRequest);
+            reply = http::Reply::StockReply(http::Reply::badRequest);
             return;
         }
 
         RawRouteData rawRoute;
-        rawRoute.checkSum = nodeHelpDesk->GetCheckSum();
+        rawRoute.checkSum = facade->GetCheckSum();
         bool checksumOK = (routeParameters.checkSum == rawRoute.checkSum);
         std::vector<std::string> textCoord;
         for(unsigned i = 0; i < routeParameters.coordinates.size(); ++i) {
-            if(false == checkCoord(routeParameters.coordinates[i])) {
-                reply = http::Reply::stockReply(http::Reply::badRequest);
+            if( !checkCoord(routeParameters.coordinates[i]) ) {
+                reply = http::Reply::StockReply(http::Reply::badRequest);
                 return;
             }
             rawRoute.rawViaNodeCoordinates.push_back(routeParameters.coordinates[i]);
@@ -93,15 +95,19 @@ public:
         std::vector<PhantomNode> phantomNodeVector(rawRoute.rawViaNodeCoordinates.size());
         for(unsigned i = 0; i < rawRoute.rawViaNodeCoordinates.size(); ++i) {
             if(checksumOK && i < routeParameters.hints.size() && "" != routeParameters.hints[i]) {
-//                INFO("Decoding hint: " << routeParameters.hints[i] << " for location index " << i);
-                DecodeObjectFromBase64(phantomNodeVector[i], routeParameters.hints[i]);
-                if(phantomNodeVector[i].isValid(nodeHelpDesk->getNumberOfNodes())) {
-//                    INFO("Decoded hint " << i << " successfully");
+//                SimpleLogger().Write() <<"Decoding hint: " << routeParameters.hints[i] << " for location index " << i;
+                DecodeObjectFromBase64(routeParameters.hints[i], phantomNodeVector[i]);
+                if(phantomNodeVector[i].isValid(facade->GetNumberOfNodes())) {
+//                    SimpleLogger().Write() << "Decoded hint " << i << " successfully";
                     continue;
                 }
             }
-//            INFO("Brute force lookup of coordinate " << i);
-            searchEngine->FindPhantomNodeForCoordinate( rawRoute.rawViaNodeCoordinates[i], phantomNodeVector[i], routeParameters.zoomLevel);
+//            SimpleLogger().Write() << "Brute force lookup of coordinate " << i;
+            facade->FindPhantomNodeForCoordinate(
+                rawRoute.rawViaNodeCoordinates[i],
+                phantomNodeVector[i],
+                routeParameters.zoomLevel
+            );
         }
 
         for(unsigned i = 0; i < phantomNodeVector.size()-1; ++i) {
@@ -110,69 +116,81 @@ public:
             segmentPhantomNodes.targetPhantom = phantomNodeVector[i+1];
             rawRoute.segmentEndCoordinates.push_back(segmentPhantomNodes);
         }
-        if( ( routeParameters.alternateRoute ) && (1 == rawRoute.segmentEndCoordinates.size()) ) {
-//            INFO("Checking for alternative paths");
-            searchEngine->alternativePaths(rawRoute.segmentEndCoordinates[0],  rawRoute);
-
+        if(
+            ( routeParameters.alternateRoute ) &&
+            (1 == rawRoute.segmentEndCoordinates.size())
+        ) {
+            search_engine_ptr->alternative_path(
+                rawRoute.segmentEndCoordinates[0],
+                rawRoute
+            );
         } else {
-            searchEngine->shortestPath(rawRoute.segmentEndCoordinates, rawRoute);
+            search_engine_ptr->shortest_path(
+                rawRoute.segmentEndCoordinates,
+                rawRoute
+            );
         }
 
-
         if(INT_MAX == rawRoute.lengthOfShortestPath ) {
-            DEBUG( "Error occurred, single path not found" );
+            SimpleLogger().Write(logDEBUG) <<
+                "Error occurred, single path not found";
         }
         reply.status = http::Reply::ok;
 
         //TODO: Move to member as smart pointer
-        BaseDescriptor<SearchEngine<QueryEdge::EdgeData, StaticGraph<QueryEdge::EdgeData> > > * desc;
+        BaseDescriptor<DataFacadeT> * desc;
         if("" != routeParameters.jsonpParameter) {
-            reply.content += routeParameters.jsonpParameter;
-            reply.content += "(";
+            reply.content.push_back(routeParameters.jsonpParameter);
+            reply.content.push_back("(");
         }
 
-        _DescriptorConfig descriptorConfig;
-        unsigned descriptorType = descriptorTable[routeParameters.outputFormat];
-        descriptorConfig.z = routeParameters.zoomLevel;
+        DescriptorConfig descriptorConfig;
+
+        unsigned descriptorType = 0;
+        if(descriptorTable.find(routeParameters.outputFormat) != descriptorTable.end() ) {
+            descriptorType = descriptorTable.find(routeParameters.outputFormat)->second;
+        }
+        descriptorConfig.zoom_level = routeParameters.zoomLevel;
         descriptorConfig.instructions = routeParameters.printInstructions;
         descriptorConfig.geometry = routeParameters.geometry;
-        descriptorConfig.encodeGeometry = routeParameters.compression;
+        descriptorConfig.encode_geometry = routeParameters.compression;
 
         switch(descriptorType){
         case 0:
-            desc = new JSONDescriptor<SearchEngine<QueryEdge::EdgeData, StaticGraph<QueryEdge::EdgeData> > >();
+            desc = new JSONDescriptor<DataFacadeT>();
 
             break;
         case 1:
-            desc = new GPXDescriptor<SearchEngine<QueryEdge::EdgeData, StaticGraph<QueryEdge::EdgeData> > >();
+            desc = new GPXDescriptor<DataFacadeT>();
 
             break;
         default:
-            desc = new JSONDescriptor<SearchEngine<QueryEdge::EdgeData, StaticGraph<QueryEdge::EdgeData> > >();
+            desc = new JSONDescriptor<DataFacadeT>();
 
             break;
         }
 
         PhantomNodes phantomNodes;
         phantomNodes.startPhantom = rawRoute.segmentEndCoordinates[0].startPhantom;
-//        INFO("Start location: " << phantomNodes.startPhantom.location)
         phantomNodes.targetPhantom = rawRoute.segmentEndCoordinates[rawRoute.segmentEndCoordinates.size()-1].targetPhantom;
-//        INFO("TargetLocation: " << phantomNodes.targetPhantom.location);
-//        INFO("Number of segments: " << rawRoute.segmentEndCoordinates.size());
         desc->SetConfig(descriptorConfig);
 
-        desc->Run(reply, rawRoute, phantomNodes, *searchEngine);
+        desc->Run(reply, rawRoute, phantomNodes, facade);
         if("" != routeParameters.jsonpParameter) {
-            reply.content += ")\n";
+            reply.content.push_back(")\n");
         }
         reply.headers.resize(3);
         reply.headers[0].name = "Content-Length";
         std::string tmp;
-        intToString(reply.content.size(), tmp);
+        unsigned content_length = 0;
+        BOOST_FOREACH(const std::string & snippet, reply.content) {
+            content_length += snippet.length();
+        }
+        intToString(content_length, tmp);
         reply.headers[0].value = tmp;
         switch(descriptorType){
         case 0:
-            if("" != routeParameters.jsonpParameter){
+            if( !routeParameters.jsonpParameter.empty() ){
                 reply.headers[1].name = "Content-Type";
                 reply.headers[1].value = "text/javascript";
                 reply.headers[2].name = "Content-Disposition";
@@ -193,7 +211,7 @@ public:
 
             break;
         default:
-            if("" != routeParameters.jsonpParameter){
+            if( !routeParameters.jsonpParameter.empty() ){
                 reply.headers[1].name = "Content-Type";
                 reply.headers[1].value = "text/javascript";
                 reply.headers[2].name = "Content-Disposition";
@@ -204,7 +222,6 @@ public:
                 reply.headers[2].name = "Content-Disposition";
                 reply.headers[2].value = "attachment; filename=\"route.json\"";
             }
-
             break;
         }
 
@@ -212,12 +229,8 @@ public:
         return;
     }
 private:
-    inline bool checkCoord(const _Coordinate & c) {
-        if(c.lat > 90*100000 || c.lat < -90*100000 || c.lon > 180*100000 || c.lon <-180*100000) {
-            return false;
-        }
-        return true;
-    }
+    std::string descriptor_string;
+    DataFacadeT * facade;
 };
 
 

README.TXT

@@ -1,7 +0,0 @@
-For instructions on how to compile and run OSRM, please consult the Wiki at
-
-https://github.com/DennisOSRM/Project-OSRM/wiki
-
-or use our free and daily updated online service at
-
-http://map.project-osrm.org

README.md

@@ -0,0 +1,40 @@
+# Readme
+
+For instructions on how to compile and run OSRM, please consult the Wiki at
+
+https://github.com/DennisOSRM/Project-OSRM/wiki
+
+or use our free and daily updated online service at
+
+http://map.project-osrm.org
+
+## References in publications
+
+When using the code in a (scientific) publication, please cite
+
+```
+@inproceedings{luxen-vetter-2011,
+ author = {Luxen, Dennis and Vetter, Christian},
+ title = {Real-time routing with OpenStreetMap data},
+ booktitle = {Proceedings of the 19th ACM SIGSPATIAL International Conference on Advances in Geographic Information Systems},
+ series = {GIS '11},
+ year = {2011},
+ isbn = {978-1-4503-1031-4},
+ location = {Chicago, Illinois},
+ pages = {513--516},
+ numpages = {4},
+ url = {http://doi.acm.org/10.1145/2093973.2094062},
+ doi = {10.1145/2093973.2094062},
+ acmid = {2094062},
+ publisher = {ACM},
+ address = {New York, NY, USA},
+}
+```
+
+## Current build status
+
+| build config |  branch | status |
+|:-------------|:--------|:------------|
+| Project OSRM | master  | [![Build Status](https://travis-ci.org/DennisOSRM/Project-OSRM.png?branch=master)](https://travis-ci.org/DennisOSRM/Project-OSRM) |
+| Project OSRM | develop | [![Build Status](https://travis-ci.org/DennisOSRM/Project-OSRM.png?branch=develop)](https://travis-ci.org/DennisOSRM/Project-OSRM) |
+| LUAbind fork | master  | [![Build Status](https://travis-ci.org/DennisOSRM/luabind.png?branch=master)](https://travis-ci.org/DennisOSRM/luabind) |

Rakefile

@@ -4,9 +4,11 @@ require 'digest/sha1'
 require 'cucumber/rake/task'
 require 'sys/proctable'
 
+BUILD_FOLDER = 'build'
 DATA_FOLDER = 'sandbox'
-PROFILE = 'bicycle'
+PROFILE = 'examples/postgis'
 OSRM_PORT = 5000
+PROFILES_FOLDER = '../profiles'
 
 Cucumber::Rake::Task.new do |t|
   t.cucumber_opts = %w{--format pretty}
@@ -16,7 +18,7 @@ areas = {
   :kbh => { :country => 'denmark', :bbox => 'top=55.6972 left=12.5222 right=12.624 bottom=55.6376' },
   :frd => { :country => 'denmark', :bbox => 'top=55.7007 left=12.4765 bottom=55.6576 right=12.5698' },
   :regh => { :country => 'denmark', :bbox => 'top=56.164 left=11.792 bottom=55.403 right=12.731' },
-  :dk => { :country => 'denmark', :bbox => nil },
+  :denmark => { :country => 'denmark', :bbox => nil },
   :skaane => { :country => 'sweden', :bbox => 'top=56.55 left=12.4 bottom=55.3 right=14.6' }
 }
 
@@ -57,49 +59,31 @@ def wait_for_shutdown name
   raise "*** Could not terminate #{name}."
 end
 
-def write_server_ini osm_file
-  s=<<-EOF
-  Threads = 1
-  IP = 0.0.0.0
-  Port = #{OSRM_PORT}
-
-  hsgrData=#{osm_file}.osrm.hsgr
-  nodesData=#{osm_file}.osrm.nodes
-  edgesData=#{osm_file}.osrm.edges
-  ramIndex=#{osm_file}.osrm.ramIndex
-  fileIndex=#{osm_file}.osrm.fileIndex
-  namesData=#{osm_file}.osrm.names
-  timestamp=#{osm_file}.osrm.timestamp
-  EOF
-  File.open( 'server.ini', 'w') {|f| f.write( s ) }
-end
-
 
 desc "Rebuild and run tests."
-task :default => [:build, :cucumber]
+task :default => [:build]
 
-desc "Build using SConsstruct."
+desc "Build using CMake."
 task :build do
-  system "scons"
+  if Dir.exists? BUILD_FOLDER
+    Dir.chdir BUILD_FOLDER do
+      system "make"
+    end
+  else
+    system "mkdir build; cd build; cmake ..; make"
+  end
 end
 
 desc "Setup config files."
 task :setup do
-  Dir.mkdir "#{DATA_FOLDER}" unless File.exist? "#{DATA_FOLDER}"
-  ['server.ini','extractor.ini','contractor.ini'].each do |file|
-    unless File.exist? "#{DATA_FOLDER}/#{file}"
-      puts "Copying #{file} template to #{DATA_FOLDER}/#{file}" 
-      FileUtils.cp file, "#{DATA_FOLDER}/#{file}"
-    end
-  end
 end
 
 desc "Download OSM data."
-task :download => :setup do
+task :download do
   Dir.mkdir "#{DATA_FOLDER}" unless File.exist? "#{DATA_FOLDER}"
   puts "Downloading..."
-  puts "curl http://download.geofabrik.de/openstreetmap/europe/#{osm_data_country}.osm.pbf -o #{DATA_FOLDER}/#{osm_data_country}.osm.pbf"
-  raise "Error while downloading data." unless system "curl http://download.geofabrik.de/openstreetmap/europe/#{osm_data_country}.osm.pbf -o #{DATA_FOLDER}/#{osm_data_country}.osm.pbf"
+  puts "curl http://download.geofabrik.de/europe/#{osm_data_country}-latest.osm.pbf -o #{DATA_FOLDER}/#{osm_data_country}.osm.pbf"
+  raise "Error while downloading data." unless system "curl http://download.geofabrik.de/europe/#{osm_data_country}-latest.osm.pbf -o #{DATA_FOLDER}/#{osm_data_country}.osm.pbf"
   if osm_data_area_bbox
     puts "Cropping and converting to protobuffer..."
     raise "Error while cropping data." unless system "osmosis --read-pbf file=#{DATA_FOLDER}/#{osm_data_country}.osm.pbf --bounding-box #{osm_data_area_bbox} --write-pbf file=#{DATA_FOLDER}/#{osm_data_area_name}.osm.pbf omitmetadata=true"
@@ -114,12 +98,20 @@ task :crop do
 end
 
 desc "Reprocess OSM data."
-task :process => :setup do
+task :process => [:extract,:prepare] do
+end
+
+desc "Extract OSM data."
+task :extract do
   Dir.chdir DATA_FOLDER do
-    raise "Error while extracting data." unless system "../osrm-extract #{osm_data_area_name}.osm.pbf ../profiles/#{PROFILE}.lua"
-    puts
-    raise "Error while preparing data." unless system "../osrm-prepare #{osm_data_area_name}.osrm #{osm_data_area_name}.osrm.restrictions ../profiles/#{PROFILE}.lua"
-    puts
+    raise "Error while extracting data." unless system "../#{BUILD_FOLDER}/osrm-extract #{osm_data_area_name}.osm.pbf --profile ../profiles/#{PROFILE}.lua"
+  end
+end
+
+desc "Prepare OSM data."
+task :prepare do
+  Dir.chdir DATA_FOLDER do
+    raise "Error while preparing data." unless system "../#{BUILD_FOLDER}/osrm-prepare #{osm_data_area_name}.osrm --profile ../profiles/#{PROFILE}.lua"
   end
 end
 
@@ -136,19 +128,17 @@ task :test do
 end
 
 desc "Run the routing server in the terminal. Press Ctrl-C to stop."
-task :run => :setup do
+task :run do
   Dir.chdir DATA_FOLDER do
-    write_server_ini osm_data_area_name
-    system "../osrm-routed"
+    system "../#{BUILD_FOLDER}/osrm-routed #{osm_data_area_name}.osrm --port #{OSRM_PORT}"
   end
 end
 
 desc "Launch the routing server in the background. Use rake:down to stop it."
-task :up => :setup do
+task :up do
   Dir.chdir DATA_FOLDER do
     abort("Already up.") if up?
-    write_server_ini osm_data_area_name
-    pipe = IO.popen('../osrm-routed 1>>osrm-routed.log 2>>osrm-routed.log')
+    pipe = IO.popen("../#{BUILD_FOLDER}/osrm-routed #{osm_data_area_name}.osrm --port #{OSRM_PORT} 1>>osrm-routed.log 2>>osrm-routed.log")
     timeout = 5
     (timeout*10).times do
       begin

RoutingAlgorithms/AlternativePathRouting.h

@@ -1,43 +1,58 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 ALTERNATIVEROUTES_H_
 #define ALTERNATIVEROUTES_H_
 
-#include <cmath>
-
 #include "BasicRoutingInterface.h"
+#include "../DataStructures/SearchEngineData.h"
 
-const double VIAPATH_ALPHA   = 0.25;
-const double VIAPATH_EPSILON = 0.25;
-const double VIAPATH_GAMMA   = 0.80;
+#include <boost/unordered_map.hpp>
+#include <cmath>
+#include <vector>
 
-template<class QueryDataT>
-class AlternativeRouting : private BasicRoutingInterface<QueryDataT>{
-    typedef BasicRoutingInterface<QueryDataT> super;
-    typedef std::pair<NodeID, int> PreselectedNode;
-    typedef typename QueryDataT::HeapPtr HeapPtr;
-    typedef std::pair<NodeID, NodeID> UnpackEdge;
+const double VIAPATH_ALPHA   = 0.15;
+const double VIAPATH_EPSILON = 0.10; //alternative at most 15% longer
+const double VIAPATH_GAMMA   = 0.75; //alternative shares at most 75% with the shortest.
+
+template<class DataFacadeT>
+class AlternativeRouting : private BasicRoutingInterface<DataFacadeT> {
+    typedef BasicRoutingInterface<DataFacadeT> super;
+    typedef typename DataFacadeT::EdgeData EdgeData;
+    typedef SearchEngineData::QueryHeap QueryHeap;
+    typedef std::pair<NodeID, NodeID> SearchSpaceEdge;
 
     struct RankedCandidateNode {
-        RankedCandidateNode(NodeID n, int l, int s) : node(n), length(l), sharing(s) {}
+        RankedCandidateNode(const NodeID n, const int l, const int s) :
+            node(n),
+            length(l),
+            sharing(s)
+        { }
+
         NodeID node;
         int length;
         int sharing;
@@ -45,95 +60,195 @@ class AlternativeRouting : private BasicRoutingInterface<QueryDataT>{
             return (2*length + sharing) < (2*other.length + other.sharing);
         }
     };
+    DataFacadeT * facade;
+    SearchEngineData & engine_working_data;
 public:
 
-    AlternativeRouting(QueryDataT & qd) : super(qd) { }
+    AlternativeRouting(
+        DataFacadeT * facade,
+        SearchEngineData & engine_working_data
+    ) :
+        super(facade),
+        facade(facade),
+        engine_working_data(engine_working_data)
+    { }
 
     ~AlternativeRouting() {}
 
-    void operator()(const PhantomNodes & phantomNodePair, RawRouteData & rawRouteData) {
-        if(!phantomNodePair.AtLeastOnePhantomNodeIsUINTMAX() || phantomNodePair.PhantomNodesHaveEqualLocation()) {
-            rawRouteData.lengthOfShortestPath = rawRouteData.lengthOfAlternativePath = INT_MAX;
+    void operator()(
+        const PhantomNodes & phantom_node_pair,
+        RawRouteData & raw_route_data) {
+        if( (!phantom_node_pair.AtLeastOnePhantomNodeIsUINTMAX()) ||
+              phantom_node_pair.PhantomNodesHaveEqualLocation()
+        ) {
+            raw_route_data.lengthOfShortestPath = INT_MAX;
+            raw_route_data.lengthOfAlternativePath = INT_MAX;
             return;
         }
 
-        std::vector<NodeID> alternativePath;
-        std::vector<NodeID> viaNodeCandidates;
-        std::vector <NodeID> packedShortestPath;
-        std::vector<PreselectedNode> nodesThatPassPreselection;
+        std::vector<NodeID>          alternative_path;
+        std::vector<NodeID>          via_node_candidate_list;
+        std::vector<SearchSpaceEdge> forward_search_space;
+        std::vector<SearchSpaceEdge> reverse_search_space;
 
-        HeapPtr & forwardHeap = super::_queryData.forwardHeap;
-        HeapPtr & backwardHeap = super::_queryData.backwardHeap;
-        HeapPtr & forwardHeap2 = super::_queryData.forwardHeap2;
-        HeapPtr & backwardHeap2 = super::_queryData.backwardHeap2;
+        //Init queues, semi-expensive because access to TSS invokes a sys-call
+        engine_working_data.InitializeOrClearFirstThreadLocalStorage(
+            super::facade->GetNumberOfNodes()
+        );
+        engine_working_data.InitializeOrClearSecondThreadLocalStorage(
+            super::facade->GetNumberOfNodes()
+        );
+        engine_working_data.InitializeOrClearThirdThreadLocalStorage(
+            super::facade->GetNumberOfNodes()
+        );
 
-        //Initialize Queues
-        super::_queryData.InitializeOrClearFirstThreadLocalStorage();
-        int _upperBound = INT_MAX;
-        NodeID middle = UINT_MAX;
-        forwardHeap->Insert(phantomNodePair.startPhantom.edgeBasedNode, -phantomNodePair.startPhantom.weight1, phantomNodePair.startPhantom.edgeBasedNode);
-        if(phantomNodePair.startPhantom.isBidirected() ) {
-            forwardHeap->Insert(phantomNodePair.startPhantom.edgeBasedNode+1, -phantomNodePair.startPhantom.weight2, phantomNodePair.startPhantom.edgeBasedNode+1);
-        }
-        backwardHeap->Insert(phantomNodePair.targetPhantom.edgeBasedNode, phantomNodePair.targetPhantom.weight1, phantomNodePair.targetPhantom.edgeBasedNode);
-        if(phantomNodePair.targetPhantom.isBidirected() ) {
-            backwardHeap->Insert(phantomNodePair.targetPhantom.edgeBasedNode+1, phantomNodePair.targetPhantom.weight2, phantomNodePair.targetPhantom.edgeBasedNode+1);
+        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;
+        forward_heap1.Insert(
+            phantom_node_pair.startPhantom.edgeBasedNode,
+            -phantom_node_pair.startPhantom.weight1,
+            phantom_node_pair.startPhantom.edgeBasedNode
+        );
+        if(phantom_node_pair.startPhantom.isBidirected() ) {
+            forward_heap1.Insert(
+                phantom_node_pair.startPhantom.edgeBasedNode+1,
+                -phantom_node_pair.startPhantom.weight2,
+                phantom_node_pair.startPhantom.edgeBasedNode+1
+            );
         }
 
-        const int offset = (phantomNodePair.startPhantom.isBidirected() ? std::max(phantomNodePair.startPhantom.weight1, phantomNodePair.startPhantom.weight2) : phantomNodePair.startPhantom.weight1)
-            + (phantomNodePair.targetPhantom.isBidirected() ? std::max(phantomNodePair.targetPhantom.weight1, phantomNodePair.targetPhantom.weight2) : phantomNodePair.targetPhantom.weight1);
+        reverse_heap1.Insert(
+            phantom_node_pair.targetPhantom.edgeBasedNode,
+            phantom_node_pair.targetPhantom.weight1,
+            phantom_node_pair.targetPhantom.edgeBasedNode
+        );
+        if(phantom_node_pair.targetPhantom.isBidirected() ) {
+        	reverse_heap1.Insert(
+                phantom_node_pair.targetPhantom.edgeBasedNode+1,
+                phantom_node_pair.targetPhantom.weight2,
+                phantom_node_pair.targetPhantom.edgeBasedNode+1
+            );
+        }
 
-        //exploration dijkstra from nodes s and t until deletemin/(1+epsilon) > _lengthOfShortestPath
-        while(forwardHeap->Size() + backwardHeap->Size() > 0){
-            if(forwardHeap->Size() > 0){
-                AlternativeRoutingStep(forwardHeap, backwardHeap, &middle, &_upperBound, 2*offset, true, viaNodeCandidates);
+        const int forward_offset =  super::ComputeEdgeOffset(
+                                        phantom_node_pair.startPhantom
+                                    );
+        const int reverse_offset =  super::ComputeEdgeOffset(
+                                        phantom_node_pair.targetPhantom
+                                    );
+
+        //search from s and t till new_min/(1+epsilon) > length_of_shortest_path
+        while(0 < (forward_heap1.Size() + reverse_heap1.Size())){
+            if(0 < forward_heap1.Size()){
+                AlternativeRoutingStep<true>(
+                    forward_heap1,
+                    reverse_heap1,
+                    &middle_node,
+                    &upper_bound_to_shortest_path_distance,
+                    via_node_candidate_list,
+                    forward_search_space,
+                    forward_offset
+                );
             }
-            if(backwardHeap->Size() > 0){
-                AlternativeRoutingStep(backwardHeap, forwardHeap, &middle, &_upperBound, 2*offset, false, viaNodeCandidates);
+            if(0 < reverse_heap1.Size()){
+                AlternativeRoutingStep<false>(
+                    reverse_heap1,
+                    forward_heap1,
+                    &middle_node,
+                    &upper_bound_to_shortest_path_distance,
+                    via_node_candidate_list,
+                    reverse_search_space,
+                    reverse_offset
+                );
             }
         }
-        std::sort(viaNodeCandidates.begin(), viaNodeCandidates.end());
-        int size = std::unique(viaNodeCandidates.begin(), viaNodeCandidates.end())- viaNodeCandidates.begin();
-        viaNodeCandidates.resize(size);
+        sort_unique_resize(via_node_candidate_list);
 
-        //save (packed) shortest path of shortest path and keep it for later use.
-        //we need it during the checks and dont want to recompute it always
-        super::RetrievePackedPathFromHeap(forwardHeap, backwardHeap, middle, packedShortestPath);
+        std::vector<NodeID> packed_forward_path;
+        std::vector<NodeID> packed_reverse_path;
 
-        //ch-pruning of via nodes in both search spaces
-        BOOST_FOREACH(const NodeID node, viaNodeCandidates) {
-            if(node == middle) //subpath optimality tells us that this case is just the shortest path
-                continue;
+        super::RetrievePackedPathFromSingleHeap(
+            forward_heap1,
+            middle_node,
+            packed_forward_path
+        );
+        super::RetrievePackedPathFromSingleHeap(
+            reverse_heap1,
+            middle_node,
+            packed_reverse_path
+        );
 
-            int sharing = approximateAmountOfSharing(node, forwardHeap, backwardHeap, packedShortestPath);
-            int length1 = forwardHeap->GetKey(node);
-            int length2 = backwardHeap->GetKey(node);
-            bool lengthPassed = (length1+length2 < _upperBound*(1+VIAPATH_EPSILON));
-            bool sharingPassed = (sharing <= _upperBound*VIAPATH_GAMMA);
-            bool stretchPassed = length1+length2 - sharing < (1.+VIAPATH_EPSILON)*(_upperBound-sharing);
+        boost::unordered_map<NodeID, int> approximated_forward_sharing;
+        boost::unordered_map<NodeID, int> approximated_reverse_sharing;
 
-            if(lengthPassed && sharingPassed && stretchPassed)
-                nodesThatPassPreselection.push_back(std::make_pair(node, length1+length2));
+        unsigned index_into_forward_path = 0;
+        //sweep over search space, compute forward sharing for each current edge (u,v)
+        BOOST_FOREACH(const SearchSpaceEdge & current_edge, forward_search_space) {
+        	const NodeID u = current_edge.first;
+        	const NodeID v = current_edge.second;
+        	if(packed_forward_path.size() < index_into_forward_path && current_edge == forward_search_space[index_into_forward_path]) {
+        		//current_edge is on shortest path => sharing(u):=queue.GetKey(u);
+        		++index_into_forward_path;
+        		approximated_forward_sharing[v] = forward_heap1.GetKey(u);
+        	} else {
+        		//sharing (s) = sharing (t)
+        		approximated_forward_sharing[v] = approximated_forward_sharing[u];
+        	}
         }
 
+        unsigned index_into_reverse_path = 0;
+        //sweep over search space, compute backward sharing
+        BOOST_FOREACH(const SearchSpaceEdge & current_edge, reverse_search_space) {
+        	const NodeID u = current_edge.first;
+        	const NodeID v = current_edge.second;
+        	if(packed_reverse_path.size() < index_into_reverse_path && current_edge == reverse_search_space[index_into_reverse_path]) {
+        		//current_edge is on shortest path => sharing(u):=queue.GetKey(u);
+        		++index_into_reverse_path;
+        		approximated_reverse_sharing[v] = reverse_heap1.GetKey(u);
+        	} else {
+        		//sharing (s) = sharing (t)
+        		approximated_reverse_sharing[v] = approximated_reverse_sharing[u];
+        	}
+        }
+        std::vector<NodeID> nodes_that_passed_preselection;
+        BOOST_FOREACH(const NodeID node, via_node_candidate_list) {
+            int approximated_sharing = approximated_forward_sharing[node] + approximated_reverse_sharing[node];
+            int approximated_length = forward_heap1.GetKey(node)+reverse_heap1.GetKey(node);
+            bool lengthPassed = (approximated_length < upper_bound_to_shortest_path_distance*(1+VIAPATH_EPSILON));
+            bool sharingPassed = (approximated_sharing <= upper_bound_to_shortest_path_distance*VIAPATH_GAMMA);
+            bool stretchPassed = approximated_length - approximated_sharing < (1.+VIAPATH_EPSILON)*(upper_bound_to_shortest_path_distance-approximated_sharing);
+
+            if(lengthPassed && sharingPassed && stretchPassed) {
+                nodes_that_passed_preselection.push_back(node);
+            }
+        }
+
+        std::vector<NodeID> & packedShortestPath = packed_forward_path;
+        std::reverse(packedShortestPath.begin(), packedShortestPath.end());
+        packedShortestPath.push_back(middle_node);
+        packedShortestPath.insert(packedShortestPath.end(),packed_reverse_path.begin(), packed_reverse_path.end());
         std::vector<RankedCandidateNode > rankedCandidates;
 
         //prioritizing via nodes for deep inspection
-        BOOST_FOREACH(const PreselectedNode node, nodesThatPassPreselection) {
+        BOOST_FOREACH(const NodeID node, nodes_that_passed_preselection) {
             int lengthOfViaPath = 0, sharingOfViaPath = 0;
-
-            computeLengthAndSharingOfViaPath(node, &lengthOfViaPath, &sharingOfViaPath, offset, packedShortestPath);
-            if(sharingOfViaPath <= VIAPATH_GAMMA*_upperBound)
-                rankedCandidates.push_back(RankedCandidateNode(node.first, lengthOfViaPath, sharingOfViaPath));
+            computeLengthAndSharingOfViaPath(node, &lengthOfViaPath, &sharingOfViaPath, forward_offset+reverse_offset, packedShortestPath);
+            if(sharingOfViaPath <= upper_bound_to_shortest_path_distance*VIAPATH_GAMMA) {
+                rankedCandidates.push_back(RankedCandidateNode(node, lengthOfViaPath, sharingOfViaPath));
+            }
         }
-
         std::sort(rankedCandidates.begin(), rankedCandidates.end());
 
         NodeID selectedViaNode = UINT_MAX;
         int lengthOfViaPath = INT_MAX;
         NodeID s_v_middle = UINT_MAX, v_t_middle = UINT_MAX;
-        BOOST_FOREACH(const RankedCandidateNode candidate, rankedCandidates){
-            if(viaNodeCandidatePasses_T_Test(forwardHeap, backwardHeap, forwardHeap2, backwardHeap2, candidate, offset, _upperBound, &lengthOfViaPath, &s_v_middle, &v_t_middle)) {
+        BOOST_FOREACH(const RankedCandidateNode & candidate, rankedCandidates){
+            if(viaNodeCandidatePasses_T_Test(forward_heap1, reverse_heap1, forward_heap2, reverse_heap2, candidate, forward_offset+reverse_offset, upper_bound_to_shortest_path_distance, &lengthOfViaPath, &s_v_middle, &v_t_middle)) {
                 // select first admissable
                 selectedViaNode = candidate.node;
                 break;
@@ -141,24 +256,24 @@ public:
         }
 
         //Unpack shortest path and alternative, if they exist
-        if(INT_MAX != _upperBound) {
-            super::UnpackPath(packedShortestPath, rawRouteData.computedShortestPath);
-            rawRouteData.lengthOfShortestPath = _upperBound;
+        if(INT_MAX != upper_bound_to_shortest_path_distance) {
+            super::UnpackPath(packedShortestPath, raw_route_data.computedShortestPath);
+            raw_route_data.lengthOfShortestPath = upper_bound_to_shortest_path_distance;
         } else {
-            rawRouteData.lengthOfShortestPath = INT_MAX;
+            raw_route_data.lengthOfShortestPath = INT_MAX;
         }
 
         if(selectedViaNode != UINT_MAX) {
-            retrievePackedViaPath(forwardHeap, backwardHeap, forwardHeap2, backwardHeap2, s_v_middle, v_t_middle, rawRouteData.computedAlternativePath);
-            rawRouteData.lengthOfAlternativePath = lengthOfViaPath;
+            retrievePackedViaPath(forward_heap1, reverse_heap1, forward_heap2, reverse_heap2, s_v_middle, v_t_middle, raw_route_data.computedAlternativePath);
+            raw_route_data.lengthOfAlternativePath = lengthOfViaPath;
         } else {
-            rawRouteData.lengthOfAlternativePath = INT_MAX;
+            raw_route_data.lengthOfAlternativePath = INT_MAX;
         }
     }
 
 private:
     //unpack <s,..,v,..,t> by exploring search spaces from v
-    inline void retrievePackedViaPath(const HeapPtr & _forwardHeap1, const HeapPtr & _backwardHeap1, const HeapPtr & _forwardHeap2, const HeapPtr & _backwardHeap2,
+    inline void retrievePackedViaPath(QueryHeap & _forwardHeap1, QueryHeap & _backwardHeap1, QueryHeap & _forwardHeap2, QueryHeap & _backwardHeap2,
             const NodeID s_v_middle, const NodeID v_t_middle, std::vector<_PathData> & unpackedPath) {
         //unpack [s,v)
         std::vector<NodeID> packed_s_v_path, packed_v_t_path;
@@ -170,16 +285,18 @@ private:
         super::UnpackPath(packed_s_v_path, unpackedPath);
     }
 
-    inline void computeLengthAndSharingOfViaPath(const PreselectedNode& node, int *lengthOfViaPath, int *sharingOfViaPath,
-            const int offset, const std::vector<NodeID> & packedShortestPath) {
+    inline void computeLengthAndSharingOfViaPath(const NodeID via_node, int *real_length_of_via_path, int *sharing_of_via_path,
+            const int offset, const std::vector<NodeID> & packed_shortest_path) {
         //compute and unpack <s,..,v> and <v,..,t> 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()
+        );
 
-        HeapPtr & existingForwardHeap  = super::_queryData.forwardHeap;
-        HeapPtr & existingBackwardHeap = super::_queryData.backwardHeap;
-        HeapPtr & newForwardHeap       = super::_queryData.forwardHeap2;
-        HeapPtr & 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;
@@ -189,18 +306,18 @@ private:
 
         NodeID s_v_middle = UINT_MAX;
         int upperBoundFor_s_v_Path = INT_MAX;//compute path <s,..,v> by reusing forward search from s
-        newBackwardHeap->Insert(node.first, 0, node.first);
-        while (newBackwardHeap->Size() > 0) {
+        newBackwardHeap.Insert(via_node, 0, via_node);
+        while (0 < newBackwardHeap.Size()) {
             super::RoutingStep(newBackwardHeap, existingForwardHeap, &s_v_middle, &upperBoundFor_s_v_Path, 2 * offset, false);
         }
         //compute path <v,..,t> by reusing backward search from node t
         NodeID v_t_middle = UINT_MAX;
         int upperBoundFor_v_t_Path = INT_MAX;
-        newForwardHeap->Insert(node.first, 0, node.first);
-        while (newForwardHeap->Size() > 0) {
+        newForwardHeap.Insert(via_node, 0, via_node);
+        while (0 < newForwardHeap.Size() ) {
             super::RoutingStep(newForwardHeap, existingBackwardHeap, &v_t_middle, &upperBoundFor_v_t_Path, 2 * offset, true);
         }
-        *lengthOfViaPath = upperBoundFor_s_v_Path + upperBoundFor_v_t_Path;
+        *real_length_of_via_path = upperBoundFor_s_v_Path + upperBoundFor_v_t_Path;
 
         if(UINT_MAX == s_v_middle || UINT_MAX == v_t_middle)
             return;
@@ -211,35 +328,35 @@ private:
 
         //partial unpacking, compute sharing
         //First partially unpack s-->v until paths deviate, note length of common path.
-        for (unsigned i = 0, lengthOfPackedPath = std::min( packed_s_v_path.size(), packedShortestPath.size()) - 1; (i < lengthOfPackedPath); ++i) {
-            if (packed_s_v_path[i] == packedShortestPath[i] && packed_s_v_path[i + 1] == packedShortestPath[i + 1]) {
-                typename QueryDataT::Graph::EdgeIterator edgeID = super::_queryData.graph->FindEdgeInEitherDirection(packed_s_v_path[i], packed_s_v_path[i + 1]);
-                *sharingOfViaPath += super::_queryData.graph->GetEdgeData(edgeID).distance;
+        for (unsigned i = 0, lengthOfPackedPath = std::min( packed_s_v_path.size(), packed_shortest_path.size()) - 1; (i < lengthOfPackedPath); ++i) {
+            if (packed_s_v_path[i] == packed_shortest_path[i] && packed_s_v_path[i + 1] == packed_shortest_path[i + 1]) {
+                EdgeID edgeID = facade->FindEdgeInEitherDirection(packed_s_v_path[i], packed_s_v_path[i + 1]);
+                *sharing_of_via_path += facade->GetEdgeData(edgeID).distance;
             } else {
-                if (packed_s_v_path[i] == packedShortestPath[i]) {
+                if (packed_s_v_path[i] == packed_shortest_path[i]) {
                     super::UnpackEdge(packed_s_v_path[i], packed_s_v_path[i+1], partiallyUnpackedViaPath);
-                    super::UnpackEdge(packedShortestPath[i], packedShortestPath[i+1], partiallyUnpackedShortestPath);
+                    super::UnpackEdge(packed_shortest_path[i], packed_shortest_path[i+1], partiallyUnpackedShortestPath);
                     break;
                 }
             }
         }
         //traverse partially unpacked edge and note common prefix
         for (int i = 0, lengthOfPackedPath = std::min( partiallyUnpackedViaPath.size(), partiallyUnpackedShortestPath.size()) - 1; (i < lengthOfPackedPath) && (partiallyUnpackedViaPath[i] == partiallyUnpackedShortestPath[i] && partiallyUnpackedViaPath[i+1] == partiallyUnpackedShortestPath[i+1]); ++i) {
-            typename QueryDataT::Graph::EdgeIterator edgeID = super::_queryData.graph->FindEdgeInEitherDirection(partiallyUnpackedViaPath[i], partiallyUnpackedViaPath[i+1]);
-            *sharingOfViaPath += super::_queryData.graph->GetEdgeData(edgeID).distance;
+            EdgeID edgeID = facade->FindEdgeInEitherDirection(partiallyUnpackedViaPath[i], partiallyUnpackedViaPath[i+1]);
+            *sharing_of_via_path += facade->GetEdgeData(edgeID).distance;
         }
 
         //Second, partially unpack v-->t in reverse order until paths deviate and note lengths
         int viaPathIndex = packed_v_t_path.size() - 1;
-        int shortestPathIndex = packedShortestPath.size() - 1;
+        int shortestPathIndex = packed_shortest_path.size() - 1;
         for (; viaPathIndex > 0 && shortestPathIndex > 0; --viaPathIndex,--shortestPathIndex ) {
-            if (packed_v_t_path[viaPathIndex - 1] == packedShortestPath[shortestPathIndex - 1] && packed_v_t_path[viaPathIndex] == packedShortestPath[shortestPathIndex]) {
-                typename QueryDataT::Graph::EdgeIterator edgeID = super::_queryData.graph->FindEdgeInEitherDirection( packed_v_t_path[viaPathIndex - 1], packed_v_t_path[viaPathIndex]);
-                *sharingOfViaPath += super::_queryData.graph->GetEdgeData(edgeID).distance;
+            if (packed_v_t_path[viaPathIndex - 1] == packed_shortest_path[shortestPathIndex - 1] && packed_v_t_path[viaPathIndex] == packed_shortest_path[shortestPathIndex]) {
+                EdgeID edgeID = facade->FindEdgeInEitherDirection( packed_v_t_path[viaPathIndex - 1], packed_v_t_path[viaPathIndex]);
+                *sharing_of_via_path += facade->GetEdgeData(edgeID).distance;
             } else {
-                if (packed_v_t_path[viaPathIndex] == packedShortestPath[shortestPathIndex]) {
+                if (packed_v_t_path[viaPathIndex] == packed_shortest_path[shortestPathIndex]) {
                     super::UnpackEdge(packed_v_t_path[viaPathIndex-1], packed_v_t_path[viaPathIndex], partiallyUnpackedViaPath);
-                    super::UnpackEdge(packedShortestPath[shortestPathIndex-1] , packedShortestPath[shortestPathIndex], partiallyUnpackedShortestPath);
+                    super::UnpackEdge(packed_shortest_path[shortestPathIndex-1] , packed_shortest_path[shortestPathIndex], partiallyUnpackedShortestPath);
                     break;
                 }
             }
@@ -249,16 +366,16 @@ private:
         shortestPathIndex = partiallyUnpackedShortestPath.size() - 1;
         for (; viaPathIndex > 0 && shortestPathIndex > 0; --viaPathIndex,--shortestPathIndex) {
             if (partiallyUnpackedViaPath[viaPathIndex - 1] == partiallyUnpackedShortestPath[shortestPathIndex - 1] && partiallyUnpackedViaPath[viaPathIndex] == partiallyUnpackedShortestPath[shortestPathIndex]) {
-                typename QueryDataT::Graph::EdgeIterator edgeID = super::_queryData.graph->FindEdgeInEitherDirection( partiallyUnpackedViaPath[viaPathIndex - 1], partiallyUnpackedViaPath[viaPathIndex]);
-                *sharingOfViaPath += super::_queryData.graph->GetEdgeData(edgeID).distance;
+                EdgeID edgeID = facade->FindEdgeInEitherDirection( partiallyUnpackedViaPath[viaPathIndex - 1], partiallyUnpackedViaPath[viaPathIndex]);
+                *sharing_of_via_path += facade->GetEdgeData(edgeID).distance;
             } else {
                 break;
             }
         }
-        //finished partial unpacking spree! Amount of sharing is stored to appropriate poiner variable
+        //finished partial unpacking spree! Amount of sharing is stored to appropriate pointer variable
     }
 
-    inline int approximateAmountOfSharing(const NodeID middleNodeIDOfAlternativePath, HeapPtr & _forwardHeap, HeapPtr & _backwardHeap, const std::vector<NodeID> & packedShortestPath) {
+    inline int approximateAmountOfSharing(const NodeID middleNodeIDOfAlternativePath, QueryHeap & _forwardHeap, QueryHeap & _backwardHeap, const std::vector<NodeID> & packedShortestPath) {
         std::vector<NodeID> packedAlternativePath;
         super::RetrievePackedPathFromHeap(_forwardHeap, _backwardHeap, middleNodeIDOfAlternativePath, packedAlternativePath);
 
@@ -269,9 +386,9 @@ private:
         int aindex = 0;
         //compute forward sharing
         while( (packedAlternativePath[aindex] == packedShortestPath[aindex]) && (packedAlternativePath[aindex+1] == packedShortestPath[aindex+1]) ) {
-            //            INFO("retrieving edge (" << packedAlternativePath[aindex] << "," << packedAlternativePath[aindex+1] << ")");
-            typename QueryDataT::Graph::EdgeIterator edgeID = super::_queryData.graph->FindEdgeInEitherDirection(packedAlternativePath[aindex], packedAlternativePath[aindex+1]);
-            sharing += super::_queryData.graph->GetEdgeData(edgeID).distance;
+            //            SimpleLogger().Write() << "retrieving edge (" << packedAlternativePath[aindex] << "," << packedAlternativePath[aindex+1] << ")";
+            EdgeID edgeID = facade->FindEdgeInEitherDirection(packedAlternativePath[aindex], packedAlternativePath[aindex+1]);
+            sharing += facade->GetEdgeData(edgeID).distance;
             ++aindex;
         }
 
@@ -279,55 +396,65 @@ private:
         int bindex = packedShortestPath.size()-1;
         //compute backward sharing
         while( aindex > 0 && bindex > 0 && (packedAlternativePath[aindex] == packedShortestPath[bindex]) && (packedAlternativePath[aindex-1] == packedShortestPath[bindex-1]) ) {
-            typename QueryDataT::Graph::EdgeIterator edgeID = super::_queryData.graph->FindEdgeInEitherDirection(packedAlternativePath[aindex], packedAlternativePath[aindex-1]);
-            sharing += super::_queryData.graph->GetEdgeData(edgeID).distance;
+            EdgeID edgeID = facade->FindEdgeInEitherDirection(packedAlternativePath[aindex], packedAlternativePath[aindex-1]);
+            sharing += facade->GetEdgeData(edgeID).distance;
             --aindex; --bindex;
         }
         return sharing;
     }
 
-    inline void AlternativeRoutingStep(HeapPtr & _forwardHeap, HeapPtr & _backwardHeap, NodeID *middle, int *_upperbound, const int edgeBasedOffset, const bool forwardDirection, std::vector<NodeID>& searchSpaceIntersection) const {
-        const NodeID node = _forwardHeap->DeleteMin();
+    template<bool forwardDirection>
+    inline void AlternativeRoutingStep(
+    		QueryHeap & _forward_heap,
+    		QueryHeap & _reverse_heap,
+    		NodeID *middle_node,
+    		int *upper_bound_to_shortest_path_distance,
+    		std::vector<NodeID>& searchSpaceIntersection,
+    		std::vector<SearchSpaceEdge> & search_space,
+    		const int edgeBasedOffset
+    		) const {
+        const NodeID node = _forward_heap.DeleteMin();
+        const int distance = _forward_heap.GetKey(node);
+        int scaledDistance = (distance-edgeBasedOffset)/(1.+VIAPATH_EPSILON);
+        if(scaledDistance > *upper_bound_to_shortest_path_distance){
+            _forward_heap.DeleteAll();
+            return;
+        }
 
-        const int distance = _forwardHeap->GetKey(node);
-        if(_backwardHeap->WasInserted(node) ){
+        search_space.push_back(std::make_pair(_forward_heap.GetData( node ).parent, node));
+
+        if(_reverse_heap.WasInserted(node) ){
             searchSpaceIntersection.push_back(node);
 
-            const int newDistance = _backwardHeap->GetKey(node) + distance;
-            if(newDistance < *_upperbound ){
+            const int newDistance = _reverse_heap.GetKey(node) + distance;
+            if(newDistance < *upper_bound_to_shortest_path_distance ){
                 if(newDistance>=0 ) {
-                    *middle = node;
-                    *_upperbound = newDistance;
+                    *middle_node = node;
+                    *upper_bound_to_shortest_path_distance = newDistance;
                 }
             }
         }
 
-        int scaledDistance = (distance-edgeBasedOffset)/(1.+VIAPATH_EPSILON);
-        if(scaledDistance > *_upperbound){
-            _forwardHeap->DeleteAll();
-            return;
-        }
-
-        for ( typename QueryDataT::Graph::EdgeIterator edge = super::_queryData.graph->BeginEdges( node ); edge < super::_queryData.graph->EndEdges(node); edge++ ) {
-            const typename QueryDataT::Graph::EdgeData & data = super::_queryData.graph->GetEdgeData(edge);
+        for ( EdgeID edge = facade->BeginEdges( node ); edge < facade->EndEdges(node); edge++ ) {
+            const EdgeData & data = facade->GetEdgeData(edge);
             bool forwardDirectionFlag = (forwardDirection ? data.forward : data.backward );
             if(forwardDirectionFlag) {
 
-                const NodeID to = super::_queryData.graph->GetTarget(edge);
+                const NodeID to = facade->GetTarget(edge);
                 const int edgeWeight = data.distance;
 
                 assert( edgeWeight > 0 );
                 const int toDistance = distance + edgeWeight;
 
                 //New Node discovered -> Add to Heap + Node Info Storage
-                if ( !_forwardHeap->WasInserted( to ) ) {
-                    _forwardHeap->Insert( to, toDistance, node );
+                if ( !_forward_heap.WasInserted( to ) ) {
+                    _forward_heap.Insert( to, toDistance, node );
 
                 }
                 //Found a shorter Path -> Update distance
-                else if ( toDistance < _forwardHeap->GetKey( to ) ) {
-                    _forwardHeap->GetData( to ).parent = node;
-                    _forwardHeap->DecreaseKey( to, toDistance );
+                else if ( toDistance < _forward_heap.GetKey( to ) ) {
+                    _forward_heap.GetData( to ).parent = node;
+                    _forward_heap.DecreaseKey( to, toDistance );
                     //new parent
                 }
             }
@@ -335,16 +462,17 @@ private:
     }
 
     //conduct T-Test
-    inline bool viaNodeCandidatePasses_T_Test( HeapPtr& existingForwardHeap, HeapPtr& existingBackwardHeap, HeapPtr& newForwardHeap, HeapPtr& newBackwardHeap, const RankedCandidateNode& candidate, const int offset, const int lengthOfShortestPath, int * lengthOfViaPath, NodeID * s_v_middle, NodeID * v_t_middle) {
+    inline bool viaNodeCandidatePasses_T_Test( QueryHeap& existingForwardHeap, QueryHeap& existingBackwardHeap, QueryHeap& newForwardHeap, QueryHeap& newBackwardHeap, const RankedCandidateNode& candidate, const int offset, const int lengthOfShortestPath, int * lengthOfViaPath, NodeID * s_v_middle, NodeID * v_t_middle) {
+    	newForwardHeap.Clear();
+    	newBackwardHeap.Clear();
         std::vector < NodeID > packed_s_v_path;
         std::vector < NodeID > packed_v_t_path;
 
-        super::_queryData.InitializeOrClearSecondThreadLocalStorage();
         *s_v_middle = UINT_MAX;
         int upperBoundFor_s_v_Path = INT_MAX;
         //compute path <s,..,v> by reusing forward search from s
-        newBackwardHeap->Insert(candidate.node, 0, candidate.node);
-        while (newBackwardHeap->Size() > 0) {
+        newBackwardHeap.Insert(candidate.node, 0, candidate.node);
+        while (newBackwardHeap.Size() > 0) {
             super::RoutingStep(newBackwardHeap, existingForwardHeap, s_v_middle, &upperBoundFor_s_v_Path, 2*offset, false);
         }
 
@@ -354,8 +482,8 @@ private:
         //compute path <v,..,t> by reusing backward search from t
         *v_t_middle = UINT_MAX;
         int upperBoundFor_v_t_Path = INT_MAX;
-        newForwardHeap->Insert(candidate.node, 0, candidate.node);
-        while (newForwardHeap->Size() > 0) {
+        newForwardHeap.Insert(candidate.node, 0, candidate.node);
+        while (newForwardHeap.Size() > 0) {
             super::RoutingStep(newForwardHeap, existingBackwardHeap, v_t_middle, &upperBoundFor_v_t_Path, 2*offset, true);
         }
 
@@ -369,14 +497,21 @@ private:
         super::RetrievePackedPathFromHeap(newForwardHeap, existingBackwardHeap, *v_t_middle, packed_v_t_path);
 
         NodeID s_P = *s_v_middle, t_P = *v_t_middle;
+        if(UINT_MAX == s_P) {
+            return false;
+        }
+
+        if(UINT_MAX == t_P) {
+            return false;
+        }
         const int T_threshold = VIAPATH_EPSILON * lengthOfShortestPath;
         int unpackedUntilDistance = 0;
 
-        std::stack<UnpackEdge> unpackStack;
+        std::stack<SearchSpaceEdge> unpackStack;
         //Traverse path s-->v
         for (unsigned i = packed_s_v_path.size() - 1; (i > 0) && unpackStack.empty(); --i) {
-            typename QueryDataT::Graph::EdgeIterator edgeID = super::_queryData.graph->FindEdgeInEitherDirection( packed_s_v_path[i - 1], packed_s_v_path[i]);
-            int lengthOfCurrentEdge = super::_queryData.graph->GetEdgeData(edgeID).distance;
+            EdgeID edgeID = facade->FindEdgeInEitherDirection( packed_s_v_path[i - 1], packed_s_v_path[i]);
+            int lengthOfCurrentEdge = facade->GetEdgeData(edgeID).distance;
             if (lengthOfCurrentEdge + unpackedUntilDistance >= T_threshold) {
                 unpackStack.push(std::make_pair(packed_s_v_path[i - 1], packed_s_v_path[i]));
             } else {
@@ -386,17 +521,17 @@ private:
         }
 
         while (!unpackStack.empty()) {
-            const UnpackEdge viaPathEdge = unpackStack.top();
+            const SearchSpaceEdge viaPathEdge = unpackStack.top();
             unpackStack.pop();
-            typename QueryDataT::Graph::EdgeIterator edgeIDInViaPath = super::_queryData.graph->FindEdgeInEitherDirection(viaPathEdge.first, viaPathEdge.second);
+            EdgeID edgeIDInViaPath = facade->FindEdgeInEitherDirection(viaPathEdge.first, viaPathEdge.second);
             if(UINT_MAX == edgeIDInViaPath)
                 return false;
-            typename QueryDataT::Graph::EdgeData currentEdgeData = super::_queryData.graph->GetEdgeData(edgeIDInViaPath);
+            EdgeData currentEdgeData = facade->GetEdgeData(edgeIDInViaPath);
             bool IsViaEdgeShortCut = currentEdgeData.shortcut;
             if (IsViaEdgeShortCut) {
                 const NodeID middleOfViaPath = currentEdgeData.id;
-                typename QueryDataT::Graph::EdgeIterator edgeIDOfSecondSegment = super::_queryData.graph->FindEdgeInEitherDirection(middleOfViaPath, viaPathEdge.second);
-                int lengthOfSecondSegment = super::_queryData.graph->GetEdgeData(edgeIDOfSecondSegment).distance;
+                EdgeID edgeIDOfSecondSegment = facade->FindEdgeInEitherDirection(middleOfViaPath, viaPathEdge.second);
+                int lengthOfSecondSegment = facade->GetEdgeData(edgeIDOfSecondSegment).distance;
                 //attention: !unpacking in reverse!
                 //Check if second segment is the one to go over treshold? if yes add second segment to stack, else push first segment to stack and add distance of second one.
                 if (unpackedUntilDistance + lengthOfSecondSegment >= T_threshold) {
@@ -416,8 +551,8 @@ private:
         unpackedUntilDistance = 0;
         //Traverse path s-->v
         for (unsigned i = 0, lengthOfPackedPath = packed_v_t_path.size() - 1; (i < lengthOfPackedPath) && unpackStack.empty(); ++i) {
-            typename QueryDataT::Graph::EdgeIterator edgeID = super::_queryData.graph->FindEdgeInEitherDirection( packed_v_t_path[i], packed_v_t_path[i + 1]);
-            int lengthOfCurrentEdge = super::_queryData.graph->GetEdgeData(edgeID).distance;
+            EdgeID edgeID = facade->FindEdgeInEitherDirection( packed_v_t_path[i], packed_v_t_path[i + 1]);
+            int lengthOfCurrentEdge = facade->GetEdgeData(edgeID).distance;
             if (lengthOfCurrentEdge + unpackedUntilDistance >= T_threshold) {
                 unpackStack.push( std::make_pair(packed_v_t_path[i], packed_v_t_path[i + 1]));
             } else {
@@ -427,17 +562,17 @@ private:
         }
 
         while (!unpackStack.empty()) {
-            const UnpackEdge viaPathEdge = unpackStack.top();
+            const SearchSpaceEdge viaPathEdge = unpackStack.top();
             unpackStack.pop();
-            typename QueryDataT::Graph::EdgeIterator edgeIDInViaPath = super::_queryData.graph->FindEdgeInEitherDirection(viaPathEdge.first, viaPathEdge.second);
+            EdgeID edgeIDInViaPath = facade->FindEdgeInEitherDirection(viaPathEdge.first, viaPathEdge.second);
             if(UINT_MAX == edgeIDInViaPath)
                 return false;
-            typename QueryDataT::Graph::EdgeData currentEdgeData = super::_queryData.graph->GetEdgeData(edgeIDInViaPath);
+            EdgeData currentEdgeData = facade->GetEdgeData(edgeIDInViaPath);
             const bool IsViaEdgeShortCut = currentEdgeData.shortcut;
             if (IsViaEdgeShortCut) {
                 const NodeID middleOfViaPath = currentEdgeData.id;
-                typename QueryDataT::Graph::EdgeIterator edgeIDOfFirstSegment = super::_queryData.graph->FindEdgeInEitherDirection(viaPathEdge.first, middleOfViaPath);
-                int lengthOfFirstSegment = super::_queryData.graph->GetEdgeData( edgeIDOfFirstSegment).distance;
+                EdgeID edgeIDOfFirstSegment = facade->FindEdgeInEitherDirection(viaPathEdge.first, middleOfViaPath);
+                int lengthOfFirstSegment = facade->GetEdgeData( edgeIDOfFirstSegment).distance;
                 //Check if first segment is the one to go over treshold? if yes first segment to stack, else push second segment to stack and add distance of first one.
                 if (unpackedUntilDistance + lengthOfFirstSegment >= T_threshold) {
                     unpackStack.push( std::make_pair(viaPathEdge.first, middleOfViaPath));
@@ -454,20 +589,23 @@ private:
 
         lengthOfPathT_Test_Path += unpackedUntilDistance;
         //Run actual T-Test query and compare if distances equal.
-        HeapPtr& forwardHeap = super::_queryData.forwardHeap3;
-        HeapPtr& backwardHeap = super::_queryData.backwardHeap3;
-        super::_queryData.InitializeOrClearThirdThreadLocalStorage();
+        engine_working_data.InitializeOrClearThirdThreadLocalStorage(
+            super::facade->GetNumberOfNodes()
+        );
+
+        QueryHeap& forward_heap3 = *engine_working_data.forwardHeap3;
+        QueryHeap& backward_heap3 = *engine_working_data.backwardHeap3;
         int _upperBound = INT_MAX;
         NodeID middle = UINT_MAX;
-        forwardHeap->Insert(s_P, 0, s_P);
-        backwardHeap->Insert(t_P, 0, t_P);
+        forward_heap3.Insert(s_P, 0, s_P);
+        backward_heap3.Insert(t_P, 0, t_P);
         //exploration from s and t until deletemin/(1+epsilon) > _lengthOfShortestPath
-        while (forwardHeap->Size() + backwardHeap->Size() > 0) {
-            if (forwardHeap->Size() > 0) {
-                super::RoutingStep(forwardHeap, backwardHeap, &middle, &_upperBound, offset, true);
+        while (forward_heap3.Size() + backward_heap3.Size() > 0) {
+            if (forward_heap3.Size() > 0) {
+                super::RoutingStep(forward_heap3, backward_heap3, &middle, &_upperBound, offset, true);
             }
-            if (backwardHeap->Size() > 0) {
-                super::RoutingStep(backwardHeap, forwardHeap, &middle, &_upperBound, offset, false);
+            if (backward_heap3.Size() > 0) {
+                super::RoutingStep(backward_heap3, forward_heap3, &middle, &_upperBound, offset, false);
             }
         }
         return (_upperBound <= lengthOfPathT_Test_Path);

RoutingAlgorithms/BasicRoutingInterface.h

@@ -1,226 +1,321 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 BASICROUTINGINTERFACE_H_
 #define BASICROUTINGINTERFACE_H_
 
-#include <cassert>
+#include "../DataStructures/RawRouteData.h"
+#include "../DataStructures/SearchEngineData.h"
+#include "../Util/ContainerUtils.h"
+#include "../Util/SimpleLogger.h"
+
+#include <boost/assert.hpp>
+#include <boost/noncopyable.hpp>
+
 #include <climits>
 
-#include "../Plugins/RawRouteData.h"
+#include <stack>
 
-template<class QueryDataT>
-class BasicRoutingInterface {
+SearchEngineData::SearchEngineHeapPtr SearchEngineData::forwardHeap;
+SearchEngineData::SearchEngineHeapPtr SearchEngineData::backwardHeap;
+SearchEngineData::SearchEngineHeapPtr SearchEngineData::forwardHeap2;
+SearchEngineData::SearchEngineHeapPtr SearchEngineData::backwardHeap2;
+SearchEngineData::SearchEngineHeapPtr SearchEngineData::forwardHeap3;
+SearchEngineData::SearchEngineHeapPtr SearchEngineData::backwardHeap3;
+
+template<class DataFacadeT>
+class BasicRoutingInterface : boost::noncopyable {
+private:
+    typedef typename DataFacadeT::EdgeData EdgeData;
 protected:
-    QueryDataT & _queryData;
+    DataFacadeT * facade;
 public:
-    BasicRoutingInterface(QueryDataT & qd) : _queryData(qd) { }
+    BasicRoutingInterface( DataFacadeT * facade ) : facade(facade) { }
     virtual ~BasicRoutingInterface(){ };
 
-    inline void RoutingStep(typename QueryDataT::HeapPtr & _forwardHeap, typename QueryDataT::HeapPtr & _backwardHeap, NodeID *middle, int *_upperbound, const int edgeBasedOffset, const bool forwardDirection) const {
-        const NodeID node = _forwardHeap->DeleteMin();
-        const int distance = _forwardHeap->GetKey(node);
-//        INFO((forwardDirection ? "[forw]" : "[back]") << " settled node " << node << " at distance " << distance);
-        if(_backwardHeap->WasInserted(node) ){
-//            INFO((forwardDirection ? "[forw]"     : "[back]") << " scanned node " << node << " in both directions, upper bound: " << *_upperbound);
-            const int newDistance = _backwardHeap->GetKey(node) + distance;
-            if(newDistance < *_upperbound ){
-                if(newDistance>=0 ) {
-//                    INFO((forwardDirection ? "[forw]" : "[back]") << " -> node " << node << " is new middle at total distance " << newDistance);
-                    *middle = node;
-                    *_upperbound = newDistance;
-                } else {
-//                    INFO((forwardDirection ? "[forw]" : "[back]") << " -> ignored " << node << " as new middle at total distance " << newDistance);
+    inline void RoutingStep(
+        SearchEngineData::QueryHeap & forward_heap,
+        SearchEngineData::QueryHeap & reverse_heap,
+        NodeID * middle_node_id,
+        int * upper_bound,
+        const int edge_expansion_offset,
+        const bool forward_direction
+    ) const {
+        const NodeID node = forward_heap.DeleteMin();
+        const int distance = forward_heap.GetKey(node);
+        //SimpleLogger().Write() << "Settled (" << forward_heap.GetData( node ).parent << "," << node << ")=" << distance;
+        if(reverse_heap.WasInserted(node) ){
+            const int new_distance = reverse_heap.GetKey(node) + distance;
+            if(new_distance < *upper_bound ){
+                if( new_distance >= 0 ) {
+                    *middle_node_id = node;
+                    *upper_bound = new_distance;
                 }
             }
         }
 
-        if(distance-edgeBasedOffset > *_upperbound){
-            _forwardHeap->DeleteAll();
+        if( (distance-edge_expansion_offset) > *upper_bound ){
+            forward_heap.DeleteAll();
             return;
         }
 
-        for ( typename QueryDataT::Graph::EdgeIterator edge = _queryData.graph->BeginEdges( node ); edge < _queryData.graph->EndEdges(node); edge++ ) {
-            const typename QueryDataT::Graph::EdgeData & data = _queryData.graph->GetEdgeData(edge);
-            bool backwardDirectionFlag = (!forwardDirection) ? data.forward : data.backward;
-            if(backwardDirectionFlag) {
-                const NodeID to = _queryData.graph->GetTarget(edge);
-                const int edgeWeight = data.distance;
+        //Stalling
+        for(
+            EdgeID edge = facade->BeginEdges( node );
+            edge < facade->EndEdges(node);
+            ++edge
+         ) {
+            const EdgeData & data = facade->GetEdgeData(edge);
+            const bool reverse_flag = (!forward_direction) ? data.forward : data.backward;
+            if( reverse_flag ) {
+                const NodeID to = facade->GetTarget(edge);
+                const int edge_weight = data.distance;
 
-                assert( edgeWeight > 0 );
+                BOOST_ASSERT_MSG( edge_weight > 0, "edge_weight invalid" );
 
-                //Stalling
-                if(_forwardHeap->WasInserted( to )) {
-                    if(_forwardHeap->GetKey( to ) + edgeWeight < distance) {
+                if(forward_heap.WasInserted( to )) {
+                    if(forward_heap.GetKey( to ) + edge_weight < distance) {
                         return;
                     }
                 }
             }
         }
 
-        for ( typename QueryDataT::Graph::EdgeIterator edge = _queryData.graph->BeginEdges( node ); edge < _queryData.graph->EndEdges(node); edge++ ) {
-            const typename QueryDataT::Graph::EdgeData & data = _queryData.graph->GetEdgeData(edge);
-            bool forwardDirectionFlag = (forwardDirection ? data.forward : data.backward );
-            if(forwardDirectionFlag) {
+        for(
+            EdgeID edge = facade->BeginEdges(node), end_edge = facade->EndEdges(node);
+            edge < end_edge;
+            ++edge
+        ) {
+            const EdgeData & data = facade->GetEdgeData(edge);
+            bool forward_directionFlag = (forward_direction ? data.forward : data.backward );
+            if( forward_directionFlag ) {
 
-                const NodeID to = _queryData.graph->GetTarget(edge);
-                const int edgeWeight = data.distance;
+                const NodeID to = facade->GetTarget(edge);
+                const int edge_weight = data.distance;
 
-                assert( edgeWeight > 0 );
-                const int toDistance = distance + edgeWeight;
+                BOOST_ASSERT_MSG( edge_weight > 0, "edge_weight invalid" );
+                const int to_distance = distance + edge_weight;
 
                 //New Node discovered -> Add to Heap + Node Info Storage
-                if ( !_forwardHeap->WasInserted( to ) ) {
-                    //                    INFO((forwardDirection ? "[forw]" : "[back]") << " scanning edge (" << node << "," << to << ") with distance " << toDistance << ", edge length: " << data.distance);
-                    _forwardHeap->Insert( to, toDistance, node );
+                if ( !forward_heap.WasInserted( to ) ) {
+                    forward_heap.Insert( to, to_distance, node );
                 }
                 //Found a shorter Path -> Update distance
-                else if ( toDistance < _forwardHeap->GetKey( to ) ) {
-                    //                    INFO((forwardDirection ? "[forw]" : "[back]") << " decrease and scanning edge (" << node << "," << to << ") from " << _forwardHeap->GetKey(to) << "to " << toDistance << ", edge length: " << data.distance);
-                    _forwardHeap->GetData( to ).parent = node;
-                    _forwardHeap->DecreaseKey( to, toDistance );
+                else if ( to_distance < forward_heap.GetKey( to ) ) {
+                    forward_heap.GetData( to ).parent = node;
+                    forward_heap.DecreaseKey( to, to_distance );
                     //new parent
                 }
             }
         }
     }
 
-    inline void UnpackPath(std::vector<NodeID> & packedPath, std::vector<_PathData> & unpackedPath) const {
-
-        const unsigned sizeOfPackedPath = packedPath.size();
-        std::stack<std::pair<NodeID, NodeID> > recursionStack;
+    inline void UnpackPath(
+        const std::vector<NodeID> & packed_path,
+        std::vector<_PathData> & unpacked_path
+    ) const {
+        const unsigned packed_path_size = packed_path.size();
+        std::stack<std::pair<NodeID, NodeID> > recursion_stack;
 
         //We have to push the path in reverse order onto the stack because it's LIFO.
-        for(unsigned i = sizeOfPackedPath-1; i > 0; --i){
-            recursionStack.push(std::make_pair(packedPath[i-1], packedPath[i]));
+        for(unsigned i = packed_path_size-1; i > 0; --i){
+            recursion_stack.push(
+                std::make_pair(packed_path[i-1], packed_path[i])
+            );
         }
 
         std::pair<NodeID, NodeID> edge;
-        while(!recursionStack.empty()) {
-            edge = recursionStack.top();
-            recursionStack.pop();
-//            INFO("Unpacking edge (" << edge.first << "," << edge.second << ")");
+        while(!recursion_stack.empty()) {
+            edge = recursion_stack.top();
+            recursion_stack.pop();
 
-            typename QueryDataT::Graph::EdgeIterator smallestEdge = SPECIAL_EDGEID;
-            int smallestWeight = INT_MAX;
-            for(typename QueryDataT::Graph::EdgeIterator eit = _queryData.graph->BeginEdges(edge.first);eit < _queryData.graph->EndEdges(edge.first);++eit){
-                const int weight = _queryData.graph->GetEdgeData(eit).distance;
-//                INFO("Checking edge (" << edge.first << "/" << _queryData.graph->GetTarget(eit) << ")");
-                if(_queryData.graph->GetTarget(eit) == edge.second && weight < smallestWeight && _queryData.graph->GetEdgeData(eit).forward){
-//                    INFO("1smallest " << eit << ", " << weight);
-                    smallestEdge = eit;
-                    smallestWeight = weight;
+            EdgeID smaller_edge_id = SPECIAL_EDGEID;
+            int edge_weight = INT_MAX;
+            for(
+                EdgeID edge_id = facade->BeginEdges(edge.first);
+                edge_id < facade->EndEdges(edge.first);
+                ++edge_id
+            ){
+                const int weight = facade->GetEdgeData(edge_id).distance;
+                if(
+                    (facade->GetTarget(edge_id) == edge.second) &&
+                    (weight < edge_weight)                      &&
+                    facade->GetEdgeData(edge_id).forward
+                ){
+                    smaller_edge_id = edge_id;
+                    edge_weight = weight;
                 }
             }
 
-            if(smallestEdge == SPECIAL_EDGEID){
-                for(typename QueryDataT::Graph::EdgeIterator eit = _queryData.graph->BeginEdges(edge.second);eit < _queryData.graph->EndEdges(edge.second);++eit){
-                    const int weight = _queryData.graph->GetEdgeData(eit).distance;
-//                    INFO("Checking edge (" << edge.first << "/" << _queryData.graph->GetTarget(eit) << ")");
-                    if(_queryData.graph->GetTarget(eit) == edge.first && weight < smallestWeight && _queryData.graph->GetEdgeData(eit).backward){
-//                      INFO("2smallest " << eit << ", " << weight);
-                        smallestEdge = eit;
-                        smallestWeight = weight;
+            if( SPECIAL_EDGEID == smaller_edge_id ){
+                for(
+                    EdgeID edge_id = facade->BeginEdges(edge.second);
+                    edge_id < facade->EndEdges(edge.second);
+                    ++edge_id
+                ){
+                    const int weight = facade->GetEdgeData(edge_id).distance;
+                    if(
+                        (facade->GetTarget(edge_id) == edge.first) &&
+                        (weight < edge_weight)              &&
+                        facade->GetEdgeData(edge_id).backward
+                    ){
+                        smaller_edge_id = edge_id;
+                        edge_weight = weight;
                     }
                 }
             }
-            assert(smallestWeight != INT_MAX);
+            BOOST_ASSERT_MSG(edge_weight != INT_MAX, "edge id invalid");
 
-            const typename QueryDataT::Graph::EdgeData& ed = _queryData.graph->GetEdgeData(smallestEdge);
-            if(ed.shortcut) {//unpack
-                const NodeID middle = ed.id;
+            const EdgeData& ed = facade->GetEdgeData(smaller_edge_id);
+            if( ed.shortcut ) {//unpack
+                const NodeID middle_node_id = ed.id;
                 //again, we need to this in reversed order
-                recursionStack.push(std::make_pair(middle, edge.second));
-                recursionStack.push(std::make_pair(edge.first, middle));
+                recursion_stack.push(std::make_pair(middle_node_id, edge.second));
+                recursion_stack.push(std::make_pair(edge.first, middle_node_id));
             } else {
-                assert(!ed.shortcut);
-                unpackedPath.push_back(_PathData(ed.id, _queryData.nodeHelpDesk->getNameIndexFromEdgeID(ed.id), _queryData.nodeHelpDesk->getTurnInstructionFromEdgeID(ed.id), ed.distance) );
+                BOOST_ASSERT_MSG(!ed.shortcut, "edge must be a shortcut");
+                unpacked_path.push_back(
+                    _PathData(
+                        ed.id,
+                        facade->GetNameIndexFromEdgeID(ed.id),
+                        facade->GetTurnInstructionForEdgeID(ed.id),
+                        ed.distance
+                    )
+                );
             }
         }
     }
 
-    inline void UnpackEdge(const NodeID s, const NodeID t, std::vector<NodeID> & unpackedPath) const {
-
-        std::stack<std::pair<NodeID, NodeID> > recursionStack;
-        recursionStack.push(std::make_pair(s,t));
+    inline void UnpackEdge(
+        const NodeID s,
+        const NodeID t,
+        std::vector<NodeID> & unpacked_path
+    ) const {
+        std::stack<std::pair<NodeID, NodeID> > recursion_stack;
+        recursion_stack.push(std::make_pair(s,t));
 
         std::pair<NodeID, NodeID> edge;
-        while(!recursionStack.empty()) {
-            edge = recursionStack.top();
-            recursionStack.pop();
+        while(!recursion_stack.empty()) {
+            edge = recursion_stack.top();
+            recursion_stack.pop();
 
-            typename QueryDataT::Graph::EdgeIterator smallestEdge = SPECIAL_EDGEID;
-            int smallestWeight = INT_MAX;
-            for(typename QueryDataT::Graph::EdgeIterator eit = _queryData.graph->BeginEdges(edge.first);eit < _queryData.graph->EndEdges(edge.first);++eit){
-                const int weight = _queryData.graph->GetEdgeData(eit).distance;
-                if(_queryData.graph->GetTarget(eit) == edge.second && weight < smallestWeight && _queryData.graph->GetEdgeData(eit).forward){
-                    smallestEdge = eit;
-                    smallestWeight = weight;
+            EdgeID smaller_edge_id = SPECIAL_EDGEID;
+            int edge_weight = INT_MAX;
+            for(
+                EdgeID edge_id = facade->BeginEdges(edge.first);
+                edge_id < facade->EndEdges(edge.first);
+                ++edge_id
+            ){
+                const int weight = facade->GetEdgeData(edge_id).distance;
+                if(
+                    (facade->GetTarget(edge_id) == edge.second) &&
+                    (weight < edge_weight)               &&
+                    facade->GetEdgeData(edge_id).forward
+                ){
+                    smaller_edge_id = edge_id;
+                    edge_weight = weight;
                 }
             }
 
-            if(smallestEdge == SPECIAL_EDGEID){
-                for(typename QueryDataT::Graph::EdgeIterator eit = _queryData.graph->BeginEdges(edge.second);eit < _queryData.graph->EndEdges(edge.second);++eit){
-                    const int weight = _queryData.graph->GetEdgeData(eit).distance;
-                    if(_queryData.graph->GetTarget(eit) == edge.first && weight < smallestWeight && _queryData.graph->GetEdgeData(eit).backward){
-                        smallestEdge = eit;
-                        smallestWeight = weight;
+            if( SPECIAL_EDGEID == smaller_edge_id ){
+                for(
+                    EdgeID edge_id = facade->BeginEdges(edge.second);
+                    edge_id < facade->EndEdges(edge.second);
+                    ++edge_id
+                ){
+                    const int weight = facade->GetEdgeData(edge_id).distance;
+                    if(
+                        (facade->GetTarget(edge_id) == edge.first) &&
+                        (weight < edge_weight)              &&
+                        facade->GetEdgeData(edge_id).backward
+                    ){
+                        smaller_edge_id = edge_id;
+                        edge_weight = weight;
                     }
                 }
             }
-            assert(smallestWeight != INT_MAX);
+            BOOST_ASSERT_MSG(edge_weight != INT_MAX, "edge weight invalid");
 
-            const typename QueryDataT::Graph::EdgeData& ed = _queryData.graph->GetEdgeData(smallestEdge);
+            const EdgeData& ed = facade->GetEdgeData(smaller_edge_id);
             if(ed.shortcut) {//unpack
-                const NodeID middle = ed.id;
+                const NodeID middle_node_id = ed.id;
                 //again, we need to this in reversed order
-//                INFO("unpacking (" << middle << "," <<  edge.second << ") and (" << edge.first << "," << middle << ")");
-                recursionStack.push(std::make_pair(middle, edge.second));
-                recursionStack.push(std::make_pair(edge.first, middle));
+                recursion_stack.push(
+                    std::make_pair(middle_node_id, edge.second)
+                );
+                recursion_stack.push(
+                    std::make_pair(edge.first, middle_node_id)
+                );
             } else {
-                assert(!ed.shortcut);
-                unpackedPath.push_back(edge.first );
+                BOOST_ASSERT_MSG(!ed.shortcut, "edge must be shortcut");
+                unpacked_path.push_back(edge.first );
             }
         }
-        unpackedPath.push_back(t);
+        unpacked_path.push_back(t);
     }
 
-    inline void RetrievePackedPathFromHeap(const typename QueryDataT::HeapPtr & _fHeap, const typename QueryDataT::HeapPtr & _bHeap, const NodeID middle, std::vector<NodeID>& packedPath) {
-        NodeID pathNode = middle;
-        while(pathNode != _fHeap->GetData(pathNode).parent) {
-            pathNode = _fHeap->GetData(pathNode).parent;
-            packedPath.push_back(pathNode);
+    inline void RetrievePackedPathFromHeap(
+        SearchEngineData::QueryHeap & forward_heap,
+        SearchEngineData::QueryHeap & reverse_heap,
+        const NodeID middle_node_id,
+        std::vector<NodeID> & packed_path
+    ) const {
+        NodeID current_node_id = middle_node_id;
+        while(current_node_id != forward_heap.GetData(current_node_id).parent) {
+            current_node_id = forward_heap.GetData(current_node_id).parent;
+            packed_path.push_back(current_node_id);
         }
 
-        std::reverse(packedPath.begin(), packedPath.end());
-
-        packedPath.push_back(middle);
-        pathNode = middle;
-        while (pathNode != _bHeap->GetData(pathNode).parent){
-            pathNode = _bHeap->GetData(pathNode).parent;
-            packedPath.push_back(pathNode);
+        std::reverse(packed_path.begin(), packed_path.end());
+        packed_path.push_back(middle_node_id);
+        current_node_id = middle_node_id;
+        while (current_node_id != reverse_heap.GetData(current_node_id).parent){
+            current_node_id = reverse_heap.GetData(current_node_id).parent;
+            packed_path.push_back(current_node_id);
     	}
     }
+
+//TODO: reorder parameters
+    inline void RetrievePackedPathFromSingleHeap(
+        SearchEngineData::QueryHeap & search_heap,
+        const NodeID middle_node_id,
+        std::vector<NodeID>& packed_path
+    ) const {
+        NodeID current_node_id = middle_node_id;
+        while(current_node_id != search_heap.GetData(current_node_id).parent) {
+            current_node_id = search_heap.GetData(current_node_id).parent;
+            packed_path.push_back(current_node_id);
+        }
+    }
+
+    int ComputeEdgeOffset(const PhantomNode & phantom) const {
+        return phantom.weight1 + (phantom.isBidirected() ? phantom.weight2 : 0);
+    }
+
 };
 
-
 #endif /* BASICROUTINGINTERFACE_H_ */

RoutingAlgorithms/ShortestPathRouting.h

@@ -1,260 +1,341 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 SHORTESTPATHROUTING_H_
 #define SHORTESTPATHROUTING_H_
 
-#include "BasicRoutingInterface.h"
+#include <boost/assert.hpp>
+
+#include "BasicRoutingInterface.h"
+#include "../DataStructures/SearchEngineData.h"
+
+template<class DataFacadeT>
+class ShortestPathRouting : public BasicRoutingInterface<DataFacadeT>{
+    typedef BasicRoutingInterface<DataFacadeT> super;
+    typedef SearchEngineData::QueryHeap QueryHeap;
+    SearchEngineData & engine_working_data;
 
-template<class QueryDataT>
-class ShortestPathRouting : public BasicRoutingInterface<QueryDataT>{
-    typedef BasicRoutingInterface<QueryDataT> super;
 public:
-    ShortestPathRouting(QueryDataT & qd) : super(qd) {}
+    ShortestPathRouting(
+        DataFacadeT * facade,
+        SearchEngineData & engine_working_data
+    ) :
+        super(facade),
+        engine_working_data(engine_working_data)
+    {}
 
     ~ShortestPathRouting() {}
 
-    void operator()(std::vector<PhantomNodes> & phantomNodesVector,  RawRouteData & rawRouteData) {
-        BOOST_FOREACH(PhantomNodes & phantomNodePair, phantomNodesVector) {
-            if(!phantomNodePair.AtLeastOnePhantomNodeIsUINTMAX()) {
-                rawRouteData.lengthOfShortestPath = rawRouteData.lengthOfAlternativePath = INT_MAX;
+    void operator()(
+        std::vector<PhantomNodes> & phantom_nodes_vector,
+        RawRouteData & raw_route_data
+    ) const {
+        BOOST_FOREACH(
+            const PhantomNodes & phantom_node_pair,
+            phantom_nodes_vector
+        ){
+            if(!phantom_node_pair.AtLeastOnePhantomNodeIsUINTMAX()) {
+                raw_route_data.lengthOfShortestPath = INT_MAX;
+                raw_route_data.lengthOfAlternativePath = INT_MAX;
                 return;
             }
         }
         int distance1 = 0;
         int distance2 = 0;
 
-        bool searchFrom1stStartNode(true);
-        bool searchFrom2ndStartNode(true);
-        NodeID middle1 = ( NodeID ) UINT_MAX;
-        NodeID middle2 = ( NodeID ) UINT_MAX;
-        std::vector<NodeID> packedPath1;
-        std::vector<NodeID> packedPath2;
+        bool search_from_1st_node = true;
+        bool search_from_2nd_node = true;
+        NodeID middle1 = UINT_MAX;
+        NodeID middle2 = UINT_MAX;
+        std::vector<NodeID> packed_path1;
+        std::vector<NodeID> packed_path2;
 
-        typename QueryDataT::HeapPtr & forwardHeap = super::_queryData.forwardHeap;
-        typename QueryDataT::HeapPtr & backwardHeap = super::_queryData.backwardHeap;
-
-        typename QueryDataT::HeapPtr & forwardHeap2 = super::_queryData.forwardHeap2;
-        typename QueryDataT::HeapPtr & backwardHeap2 = super::_queryData.backwardHeap2;
+        engine_working_data.InitializeOrClearFirstThreadLocalStorage(
+            super::facade->GetNumberOfNodes()
+        );
+        engine_working_data.InitializeOrClearSecondThreadLocalStorage(
+            super::facade->GetNumberOfNodes()
+        );
+        engine_working_data.InitializeOrClearThirdThreadLocalStorage(
+            super::facade->GetNumberOfNodes()
+        );
 
+        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(PhantomNodes & phantomNodePair, phantomNodesVector) {
-            super::_queryData.InitializeOrClearFirstThreadLocalStorage();
-            super::_queryData.InitializeOrClearSecondThreadLocalStorage();
+        BOOST_FOREACH(
+            const PhantomNodes & phantom_node_pair,
+            phantom_nodes_vector
+        ){
+            forward_heap1.Clear();	forward_heap2.Clear();
+            reverse_heap1.Clear();	reverse_heap2.Clear();
+            int local_upper_bound1 = INT_MAX;
+            int local_upper_bound2 = INT_MAX;
 
-            int _localUpperbound1 = INT_MAX;
-            int _localUpperbound2 = INT_MAX;
+            middle1 = UINT_MAX;
+            middle2 = UINT_MAX;
 
             //insert new starting nodes into forward heap, adjusted by previous distances.
-            if(searchFrom1stStartNode) {
-                forwardHeap->Insert(phantomNodePair.startPhantom.edgeBasedNode, -phantomNodePair.startPhantom.weight1, phantomNodePair.startPhantom.edgeBasedNode);
-                forwardHeap2->Insert(phantomNodePair.startPhantom.edgeBasedNode, -phantomNodePair.startPhantom.weight1, phantomNodePair.startPhantom.edgeBasedNode);
-//              INFO("a 1,2)forw insert " << phantomNodePair.startPhantom.edgeBasedNode << " with weight " << phantomNodePair.startPhantom.weight1);
-//          } else {
-//              INFO("Skipping first start node");
-            }
-            if(phantomNodePair.startPhantom.isBidirected() && searchFrom2ndStartNode) {
-                forwardHeap->Insert(phantomNodePair.startPhantom.edgeBasedNode+1, -phantomNodePair.startPhantom.weight2, phantomNodePair.startPhantom.edgeBasedNode+1);
-                forwardHeap2->Insert(phantomNodePair.startPhantom.edgeBasedNode+1, -phantomNodePair.startPhantom.weight2, phantomNodePair.startPhantom.edgeBasedNode+1);
-//              INFO("b 1,2)forw insert " << phantomNodePair.startPhantom.edgeBasedNode+1 << " with weight " << -phantomNodePair.startPhantom.weight1);
-//          } else if(!searchFrom2ndStartNode) {
-//              INFO("Skipping second start node");
+            if(search_from_1st_node) {
+                forward_heap1.Insert(
+                    phantom_node_pair.startPhantom.edgeBasedNode,
+                    distance1-phantom_node_pair.startPhantom.weight1,
+                    phantom_node_pair.startPhantom.edgeBasedNode
+                );
+                // INFO("fw1: " << phantom_node_pair.startPhantom.edgeBasedNode << "´, w: " << -phantomNodePair.startPhantom.weight1);
+                forward_heap2.Insert(
+                    phantom_node_pair.startPhantom.edgeBasedNode,
+                    distance1-phantom_node_pair.startPhantom.weight1,
+                    phantom_node_pair.startPhantom.edgeBasedNode
+                );
+                // INFO("fw2: " << phantom_node_pair.startPhantom.edgeBasedNode << "´, w: " << -phantomNodePair.startPhantom.weight1);
+           }
+            if(phantom_node_pair.startPhantom.isBidirected() && search_from_2nd_node) {
+                forward_heap1.Insert(
+                    phantom_node_pair.startPhantom.edgeBasedNode+1,
+                    distance2-phantom_node_pair.startPhantom.weight2,
+                    phantom_node_pair.startPhantom.edgeBasedNode+1
+                );
+                // INFO("fw1: " << phantom_node_pair.startPhantom.edgeBasedNode+1 << "´, w: " << -phantomNodePair.startPhantom.weight2);
+                forward_heap2.Insert(
+                    phantom_node_pair.startPhantom.edgeBasedNode+1,
+                    distance2-phantom_node_pair.startPhantom.weight2,
+                    phantom_node_pair.startPhantom.edgeBasedNode+1
+                );
+                // INFO("fw2: " << phantom_node_pair.startPhantom.edgeBasedNode+1 << "´, w: " << -phantomNodePair.startPhantom.weight2);
             }
 
-//            backwardHeap->Clear();
-//            backwardHeap2->Clear();
             //insert new backward nodes into backward heap, unadjusted.
-            backwardHeap->Insert(phantomNodePair.targetPhantom.edgeBasedNode, phantomNodePair.targetPhantom.weight1, phantomNodePair.targetPhantom.edgeBasedNode);
-//          INFO("1) back insert " << phantomNodePair.targetPhantom.edgeBasedNode << " with weight " << phantomNodePair.targetPhantom.weight1);
-            if(phantomNodePair.targetPhantom.isBidirected() ) {
-//              INFO("2) back insert " << phantomNodePair.targetPhantom.edgeBasedNode+1 << " with weight " << phantomNodePair.targetPhantom.weight2);
-                backwardHeap2->Insert(phantomNodePair.targetPhantom.edgeBasedNode+1, phantomNodePair.targetPhantom.weight2, phantomNodePair.targetPhantom.edgeBasedNode+1);
-            }
-            int offset = (phantomNodePair.startPhantom.isBidirected() ? std::max(phantomNodePair.startPhantom.weight1, phantomNodePair.startPhantom.weight2) : phantomNodePair.startPhantom.weight1) ;
-            offset += (phantomNodePair.targetPhantom.isBidirected() ? std::max(phantomNodePair.targetPhantom.weight1, phantomNodePair.targetPhantom.weight2) : phantomNodePair.targetPhantom.weight1) ;
+            reverse_heap1.Insert(
+                phantom_node_pair.targetPhantom.edgeBasedNode,
+                phantom_node_pair.targetPhantom.weight1,
+                phantom_node_pair.targetPhantom.edgeBasedNode
+            );
+            // INFO("rv1: " << phantom_node_pair.targetPhantom.edgeBasedNode << ", w;" << phantom_node_pair.targetPhantom.weight1 );
+            if(phantom_node_pair.targetPhantom.isBidirected() ) {
+                reverse_heap2.Insert(
+                    phantom_node_pair.targetPhantom.edgeBasedNode+1,
+                    phantom_node_pair.targetPhantom.weight2,
+                    phantom_node_pair.targetPhantom.edgeBasedNode+1
+                );
+                // INFO("rv2: " << phantom_node_pair.targetPhantom.edgeBasedNode+1 << ", w;" << phantom_node_pair.targetPhantom.weight2 );
+           }
+            const int forward_offset =  super::ComputeEdgeOffset(
+                                            phantom_node_pair.startPhantom
+                                        );
+            const int reverse_offset =  super::ComputeEdgeOffset(
+                                            phantom_node_pair.targetPhantom
+                                        );
 
             //run two-Target Dijkstra routing step.
-            while(forwardHeap->Size() + backwardHeap->Size() > 0){
-                if(forwardHeap->Size() > 0){
-                    super::RoutingStep(forwardHeap, backwardHeap, &middle1, &_localUpperbound1, 2*offset, true);
+            while(0 < (forward_heap1.Size() + reverse_heap1.Size() )){
+                if( !forward_heap1.Empty()){
+                    super::RoutingStep(
+                        forward_heap1,
+                        reverse_heap1,
+                        &middle1,
+                        &local_upper_bound1,
+                        forward_offset,
+                        true
+                    );
                 }
-                if(backwardHeap->Size() > 0){
-                    super::RoutingStep(backwardHeap, forwardHeap, &middle1, &_localUpperbound1, 2*offset, false);
+                if( !reverse_heap1.Empty() ){
+                    super::RoutingStep(
+                        reverse_heap1,
+                        forward_heap1,
+                        &middle1,
+                        &local_upper_bound1,
+                        reverse_offset,
+                        false
+                    );
                 }
             }
-            if(backwardHeap2->Size() > 0) {
-                while(forwardHeap2->Size() + backwardHeap2->Size() > 0){
-                    if(forwardHeap2->Size() > 0){
-                        super::RoutingStep(forwardHeap2, backwardHeap2, &middle2, &_localUpperbound2, 2*offset, true);
+            if( !reverse_heap2.Empty() ) {
+                while(0 < (forward_heap2.Size() + reverse_heap2.Size() )){
+                    if( !forward_heap2.Empty() ){
+                        super::RoutingStep(
+                            forward_heap2,
+                            reverse_heap2,
+                            &middle2,
+                            &local_upper_bound2,
+                            forward_offset,
+                            true
+                        );
                     }
-                    if(backwardHeap2->Size() > 0){
-                        super::RoutingStep(backwardHeap2, forwardHeap2, &middle2, &_localUpperbound2, 2*offset, false);
+                    if( !reverse_heap2.Empty() ){
+                        super::RoutingStep(
+                            reverse_heap2,
+                            forward_heap2,
+                            &middle2,
+                            &local_upper_bound2,
+                            reverse_offset,
+                            false
+                        );
                     }
                 }
             }
-//          INFO("upperbound1: " << _localUpperbound1 << ", distance1: " << distance1);
-//          INFO("upperbound2: " << _localUpperbound2 << ", distance2: " << distance2);
 
             //No path found for both target nodes?
-            if(INT_MAX == _localUpperbound1 && INT_MAX == _localUpperbound2) {
-                rawRouteData.lengthOfShortestPath = rawRouteData.lengthOfAlternativePath = INT_MAX;
+            if(
+                (INT_MAX == local_upper_bound1) &&
+                (INT_MAX == local_upper_bound2)
+            ) {
+                raw_route_data.lengthOfShortestPath = INT_MAX;
+                raw_route_data.lengthOfAlternativePath = INT_MAX;
                 return;
             }
             if(UINT_MAX == middle1) {
-                searchFrom1stStartNode = false;
-//              INFO("Next Search will not start from 1st");
-            } else {
-//              INFO("Next Search will start from 1st");
-                searchFrom1stStartNode = true;
+                search_from_1st_node = false;
             }
             if(UINT_MAX == middle2) {
-                searchFrom2ndStartNode = false;
-//              INFO("Next Search will not start from 2nd");
-            } else {
-                searchFrom2ndStartNode = true;
-//              INFO("Next Search will start from 2nd");
+                search_from_2nd_node = false;
             }
 
             //Was at most one of the two paths not found?
-            assert(!(INT_MAX == distance1 && INT_MAX == distance2));
-
-//          INFO("middle1: " << middle1);
+            BOOST_ASSERT_MSG(
+                (INT_MAX != distance1 || INT_MAX != distance2),
+                "no path found"
+            );
 
             //Unpack paths if they exist
-            std::vector<NodeID> temporaryPackedPath1;
-            std::vector<NodeID> temporaryPackedPath2;
-            if(INT_MAX != _localUpperbound1) {
-                super::RetrievePackedPathFromHeap(forwardHeap, backwardHeap, middle1, temporaryPackedPath1);
-//              INFO("temporaryPackedPath1 ends with " << *(temporaryPackedPath1.end()-1) );
+            std::vector<NodeID> temporary_packed_path1;
+            std::vector<NodeID> temporary_packed_path2;
+            if(INT_MAX != local_upper_bound1) {
+                super::RetrievePackedPathFromHeap(
+                    forward_heap1,
+                    reverse_heap1,
+                    middle1,
+                    temporary_packed_path1
+                );
             }
-//          INFO("middle2: " << middle2);
 
-            if(INT_MAX != _localUpperbound2) {
-                super::RetrievePackedPathFromHeap(forwardHeap2, backwardHeap2, middle2, temporaryPackedPath2);
-//                INFO("temporaryPackedPath2 ends with " << *(temporaryPackedPath2.end()-1) );
+            if(INT_MAX != local_upper_bound2) {
+                super::RetrievePackedPathFromHeap(
+                    forward_heap2,
+                    reverse_heap2,
+                    middle2,
+                    temporary_packed_path2
+                );
             }
 
             //if one of the paths was not found, replace it with the other one.
-            if(0 == temporaryPackedPath1.size()) {
-//              INFO("Deleting path 1");
-                temporaryPackedPath1.insert(temporaryPackedPath1.end(), temporaryPackedPath2.begin(), temporaryPackedPath2.end());
-                _localUpperbound1 = _localUpperbound2;
+            if( temporary_packed_path1.empty() ) {
+                temporary_packed_path1.insert(
+                    temporary_packed_path1.end(),
+                    temporary_packed_path2.begin(),
+                    temporary_packed_path2.end()
+                );
+                local_upper_bound1 = local_upper_bound2;
             }
-            if(0 == temporaryPackedPath2.size()) {
-//              INFO("Deleting path 2");
-                temporaryPackedPath2.insert(temporaryPackedPath2.end(), temporaryPackedPath1.begin(), temporaryPackedPath1.end());
-                _localUpperbound2 = _localUpperbound1;
+            if( temporary_packed_path2.empty() ) {
+                temporary_packed_path2.insert(
+                    temporary_packed_path2.end(),
+                    temporary_packed_path1.begin(),
+                    temporary_packed_path1.end()
+                );
+                local_upper_bound2 = local_upper_bound1;
             }
 
-            assert(0 < temporaryPackedPath1.size() && 0 < temporaryPackedPath2.size());
+            BOOST_ASSERT_MSG(
+                !temporary_packed_path1.empty() ||
+                !temporary_packed_path2.empty(),
+                "tempory packed paths empty"
+            );
 
             //Plug paths together, s.t. end of packed path is begin of temporary packed path
-            if(0 < packedPath1.size() && 0 < packedPath2.size() ) {
-//              INFO("Both paths are non-empty");
-                if( *(temporaryPackedPath1.begin()) == *(temporaryPackedPath2.begin())) {
-//                  INFO("both paths start with the same node:" << *(temporaryPackedPath1.begin()));
-                    //both new route segments start with the same node, thus one of the packedPath must go.
-                    assert( (packedPath1.size() == packedPath2.size() ) || (*(packedPath1.end()-1) != *(packedPath2.end()-1)) );
-                    if( *(packedPath1.end()-1) == *(temporaryPackedPath1.begin())) {
-//                      INFO("Deleting packedPath2 that ends with " << *(packedPath2.end()-1) << ", other ends with " << *(packedPath1.end()-1));
-                        packedPath2.clear();
-                        packedPath2.insert(packedPath2.end(), packedPath1.begin(), packedPath1.end());
-                        distance2 = distance1;
-//                      INFO("packedPath2 now ends with " <<  *(packedPath2.end()-1));
+            if( !packed_path1.empty() && !packed_path2.empty() ) {
+                if(
+                    temporary_packed_path1.front() ==
+                    temporary_packed_path2.front()
+                ) {
+                    //both new route segments start with the same node
+                    //thus, one of the packedPath must go.
+                    BOOST_ASSERT_MSG(
+                        (packed_path1.size() == packed_path2.size() ) ||
+                        (packed_path1.back() != packed_path2.back() ),
+                        "packed paths must be different"
+                    );
+
+                    if( packed_path1.back() == temporary_packed_path1.front()) {
+                        packed_path2.clear();
+                        packed_path2.insert(
+                            packed_path2.end(),
+                            packed_path1.begin(),
+                            packed_path1.end()
+                        );
                     } else {
-//                      INFO("Deleting path1 that ends with " << *(packedPath1.end()-1) << ", other ends with " << *(packedPath2.end()-1));
-                        packedPath1.clear();
-                        packedPath1.insert(packedPath1.end(), packedPath2.begin(), packedPath2.end());
-                        distance1 = distance2;
-//                      INFO("Path1 now ends with " <<  *(packedPath1.end()-1));
+                        packed_path1.clear();
+                        packed_path1.insert(
+                            packed_path1.end(),
+                            packed_path2.begin(),
+                            packed_path2.end()
+                        );
                     }
                 } else  {
                     //packed paths 1 and 2 may need to switch.
-                    if(*(packedPath1.end()-1) != *(temporaryPackedPath1.begin())) {
-//                      INFO("Switching");
-                        packedPath1.swap(packedPath2);
+                    if( packed_path1.back() != temporary_packed_path1.front()) {
+                        packed_path1.swap(packed_path2);
                         std::swap(distance1, distance2);
                     }
                 }
             }
-            packedPath1.insert(packedPath1.end(), temporaryPackedPath1.begin(), temporaryPackedPath1.end());
-            packedPath2.insert(packedPath2.end(), temporaryPackedPath2.begin(), temporaryPackedPath2.end());
+            packed_path1.insert(
+                packed_path1.end(),
+                temporary_packed_path1.begin(),
+                temporary_packed_path1.end()
+            );
+            packed_path2.insert(
+                packed_path2.end(),
+                temporary_packed_path2.begin(),
+                temporary_packed_path2.end()
+            );
 
-            if( (packedPath1.back() == packedPath2.back()) && phantomNodePair.targetPhantom.isBidirected() ) {
-//              INFO("both paths end in same direction on bidirected edge, make sure start only start with : " << packedPath1.back());
-
-                NodeID lastNodeID = packedPath2.back();
-                searchFrom1stStartNode &= !(lastNodeID == phantomNodePair.targetPhantom.edgeBasedNode+1);
-                searchFrom2ndStartNode &= !(lastNodeID == phantomNodePair.targetPhantom.edgeBasedNode);
-//                INFO("Next search from node " << phantomNodePair.targetPhantom.edgeBasedNode << ": " << (searchFrom1stStartNode ? "yes" : "no") );
-//                INFO("Next search from node " << phantomNodePair.targetPhantom.edgeBasedNode+1 << ": " << (searchFrom2ndStartNode ? "yes" : "no") );
+            if(
+                (packed_path1.back() == packed_path2.back()) &&
+                phantom_node_pair.targetPhantom.isBidirected()
+            ) {
+                const NodeID last_node_id = packed_path2.back();
+                search_from_1st_node &= !(last_node_id == phantom_node_pair.targetPhantom.edgeBasedNode+1);
+                search_from_2nd_node &= !(last_node_id == phantom_node_pair.targetPhantom.edgeBasedNode);
             }
 
-            distance1 += _localUpperbound1;
-            distance2 += _localUpperbound2;
+            distance1 = local_upper_bound1;
+            distance2 = local_upper_bound2;
         }
 
-//      INFO("length path1: " << distance1);
-//      INFO("length path2: " << distance2);
-        if(distance1 <= distance2){
-            //remove consecutive duplicates
-//          std::cout << "unclean 1: ";
-//          for(unsigned i = 0; i < packedPath1.size(); ++i)
-//              std::cout << packedPath1[i] << " ";
-//          std::cout << std::endl;
-
-//          std::cout << "cleaned 1: ";
-//          for(unsigned i = 0; i < packedPath1.size(); ++i)
-//              std::cout << packedPath1[i] << " ";
-//          std::cout << std::endl;
-//            super::UnpackPath(packedPath1, rawRouteData.computedShortestPath);
-        } else {
-            std::swap(packedPath1, packedPath2);
-//          std::cout << "unclean 2: ";
-//          for(unsigned i = 0; i < packedPath2.size(); ++i)
-//              std::cout << packedPath2[i] << " ";
-//          std::cout << std::endl;
-//            _RemoveConsecutiveDuplicatesFromContainer(packedPath2);
-//          std::cout << "cleaned 2: ";
-//          for(unsigned i = 0; i < packedPath2.size(); ++i)
-//              std::cout << packedPath2[i] << " ";
-//          std::cout << std::endl;
-//            super::UnpackPath(packedPath2, unpackedPath);
+        if( distance1 > distance2 ) {
+            std::swap( packed_path1, packed_path2 );
         }
-        _RemoveConsecutiveDuplicatesFromContainer(packedPath1);
-        super::UnpackPath(packedPath1, rawRouteData.computedShortestPath);
-        rawRouteData.lengthOfShortestPath = std::min(distance1, distance2);
-//      INFO("Found via route with distance " << std::min(distance1, distance2));
-        return;
-    }
-private:
-    template<class ContainerT>
-    void _RemoveConsecutiveDuplicatesFromContainer(ContainerT & packedPath) {
-        //remove consecutive duplicates
-        typename ContainerT::iterator it;
-        // using default comparison:
-        it = std::unique(packedPath.begin(), packedPath.end());
-        packedPath.resize(it - packedPath.begin());
+        remove_consecutive_duplicates_from_vector(packed_path1);
+        super::UnpackPath(packed_path1, raw_route_data.computedShortestPath);
+        raw_route_data.lengthOfShortestPath = std::min(distance1, distance2);
     }
 };
 

SConstruct

@@ -1,299 +0,0 @@
-#Sconstruct
-
-import os
-import os.path
-import string
-import sys
-from subprocess import call
-
-def CheckBoost(context, version):
-    # Boost versions are in format major.minor.subminor
-    v_arr = version.split(".")
-    version_n = 0
-    if len(v_arr) > 0:
-        version_n += int(v_arr[0])*100000
-    if len(v_arr) > 1:
-        version_n += int(v_arr[1])*100
-    if len(v_arr) > 2:
-        version_n += int(v_arr[2])
-    
-    context.Message('Checking for Boost version >= %s... ' % (version))
-    ret = context.TryRun("""
-    #include <boost/version.hpp>
-    
-    int main()
-    {
-        return BOOST_VERSION >= %d ? 0 : 1;
-    }
-    """ % version_n, '.cpp')[0]
-    context.Result(ret)
-    return ret
-
-def CheckProtobuf(context, version):
-    # Protobuf versions are in format major.minor.subminor
-    v_arr = version.split(".")
-    version_n = 0
-    if len(v_arr) > 0:
-        version_n += int(v_arr[0])*1000000
-    if len(v_arr) > 1:
-        version_n += int(v_arr[1])*1000
-    if len(v_arr) > 2:
-        version_n += int(v_arr[2])
-    
-    context.Message('Checking for Protobuffer version >= %s... ' % (version))
-    ret = context.TryRun("""
-    #include <google/protobuf/stubs/common.h>
-	int main() {
-	return (GOOGLE_PROTOBUF_VERSION >= %d) ? 0 : 1;
-    }
-    """ % version_n, '.cpp')[0]
-    context.Result(ret)
-    return ret
-
-# Adding various options to the SConstruct
-AddOption('--cxx', dest='cxx', type='string', nargs=1, action='store', metavar='STRING', help='C++ Compiler')
-AddOption('--stxxlroot', dest='stxxlroot', type='string', nargs=1, action='store', metavar='STRING', help='root directory of STXXL')
-AddOption('--verbosity', dest='verbosity', type='string', nargs=1, action='store', metavar='STRING', help='make Scons talking')
-AddOption('--buildconfiguration', dest='buildconfiguration', type='string', nargs=1, action='store', metavar='STRING', help='debug or release')
-AddOption('--all-flags', dest='allflags', type='string', nargs=0, action='store', metavar='STRING', help='turn off -march optimization in release mode')
-AddOption('--with-tools', dest='withtools', type='string', nargs=0, action='store', metavar='STRING', help='build tools for data analysis')
-AddOption('--no-march', dest='nomarch', type='string', nargs=0, action='store', metavar='STRING', help='turn off native optimizations')
-
-env = Environment( ENV = {'PATH' : os.environ['PATH']} ,COMPILER = GetOption('cxx'))
-env["CC"] = os.getenv("CC") or env["CC"]
-env["CXX"] = os.getenv("CXX") or env["CXX"]
-env["ENV"].update(x for x in os.environ.items() if x[0].startswith("CCC_"))
-try:
-	env['ENV']['TERM'] = os.environ['TERM']
-except KeyError:
-	env['ENV']['TERM'] = 'none'
-	
-conf = Configure(env, custom_tests = { 'CheckBoost' : CheckBoost, 'CheckProtobuf' : CheckProtobuf })
-
-if GetOption('cxx') is None:
-    #default Compiler
-    if sys.platform == 'darwin':	#Mac OS X
-        env['CXX'] = 'clang++'
-    print 'Using default C++ Compiler: ', env['CXX'].strip()
-else:
-    env.Replace(CXX = GetOption('cxx'))
-    print 'Using user supplied C++ Compiler: ', env['CXX']
-
-if GetOption('allflags') is not None:
-    env.Append(CXXFLAGS = ["-Wextra", "-Wall", "-Wnon-virtual-dtor", "-Wundef", "-Wno-long-long", "-Woverloaded-virtual", "-Wfloat-equal", "-Wredundant-decls"])
-
-if "clang" in env["CXX"]:
-    print "Warning building with clang removes OpenMP parallelization"
-    if GetOption('allflags') is not None:
-        env.Append(CXXFLAGS = ["-W#warnings", "-Wc++0x-compat", "-Waddress-of-temporary", "-Wambiguous-member-template", "-Warray-bounds", "-Watomic-properties", "-Wbind-to-temporary-copy", "-Wbuiltin-macro-redefined", "-Wc++-compat", "-Wc++0x-extensions", "-Wcomments", "-Wconditional-uninitialized", "-Wconstant-logical-operand", "-Wdeclaration-after-statement", "-Wdeprecated", "-Wdeprecated-implementations", "-Wdeprecated-writable-strings", "-Wduplicate-method-arg", "-Wempty-body", "-Wendif-labels", "-Wenum-compare", "-Wformat=2", "-Wfour-char-constants", "-Wgnu", "-Wincomplete-implementation", "-Winvalid-noreturn", "-Winvalid-offsetof", "-Winvalid-token-paste", "-Wlocal-type-template-args", "-Wmethod-signatures", "-Wmicrosoft", "-Wmissing-declarations", "-Wnon-pod-varargs", "-Wnonfragile-abi2", "-Wnull-dereference", "-Wout-of-line-declaration", "-Woverlength-strings", "-Wpacked", "-Wpointer-arith", "-Wpointer-sign", "-Wprotocol", "-Wreadonly-setter-attrs", "-Wselector", "-Wshift-overflow", "-Wshift-sign-overflow", "-Wstrict-selector-match", "-Wsuper-class-method-mismatch", "-Wtautological-compare", "-Wtypedef-redefinition", "-Wundeclared-selector", "-Wunnamed-type-template-args", "-Wunused-exception-parameter", "-Wunused-member-function", "-Wused-but-marked-unused", "-Wvariadic-macros"])
-else:
-	env.Append(CCFLAGS = ['-minline-all-stringops', '-fopenmp'])
-	env.Append(LINKFLAGS = '-fopenmp')
-
-if GetOption('buildconfiguration') == 'debug':
-	env.Append(CCFLAGS = ['-Wall', '-g3', '-rdynamic'])
-else:
-	env.Append(CCFLAGS = ['-O3', '-DNDEBUG'])
-
-if sys.platform == 'darwin':	#Mac OS X
-	#os x default installations
-	env.Append(CPPPATH = ['/usr/include/libxml2'] )
-	env.Append(CPPPATH = ['/usr/X11/include'])		#comes with os x
-#	env.Append(LIBPATH = ['/usr/X11/lib'])			#needed for libpng
-	
-	#assume stxxl and boost are installed via homebrew. call brew binary to get folder locations
-	import subprocess
-	stxxl_prefix = subprocess.check_output(["brew", "--prefix", "libstxxl"]).strip()
-	env.Append(CPPPATH = [stxxl_prefix+"/include"] )
-	env.Append(LIBPATH = [stxxl_prefix+"/lib"] )
-	boost_prefix = subprocess.check_output(["brew", "--prefix", "boost"]).strip()
-	env.Append(CPPPATH = [boost_prefix+"/include"] )
-	env.Append(LIBPATH = [boost_prefix+"/lib"] )
-	if not conf.CheckLibWithHeader('lua', 'lua.h', 'C'):
-		print "lua library not found. Exiting"
-		Exit(-1)
-	
-	if not conf.CheckLibWithHeader('luabind', 'luabind/luabind.hpp', 'CXX'):
-		print "luabind library not found. Exiting"
-		Exit(-1)
-
-elif sys.platform.startswith("freebsd"):
-	env.ParseConfig('pkg-config --cflags --libs protobuf')
-	env.Append(CPPPATH = ['/usr/local/include', '/usr/local/include/libxml2'])
-	env.Append(LIBPATH = ['/usr/local/lib'])
-	if GetOption('stxxlroot') is not None:
-	   env.Append(CPPPATH = GetOption('stxxlroot')+'/include')
-	   env.Append(LIBPATH = GetOption('stxxlroot')+'/lib')
-	   print 'STXXLROOT = ', GetOption('stxxlroot')
-elif sys.platform == 'win32':
-	#SCons really wants to use Microsoft compiler
-	print "Compiling is not yet supported on Windows"
-	Exit(-1)
-else:
-	print "Default platform"
-	if GetOption('stxxlroot') is not None:
-	   env.Append(CPPPATH = GetOption('stxxlroot')+'/include')
-	   env.Append(LIBPATH = GetOption('stxxlroot')+'/lib')
-	   print 'STXXLROOT = ', GetOption('stxxlroot')
-	env.Append(CPPPATH = ['/usr/include', '/usr/include/include', '/usr/include/libxml2/'])
-	if not conf.CheckLibWithHeader('pthread', 'pthread.h', 'CXX'):
-		print "pthread not found. Exiting"
-		Exit(-1)
-	
-	if not conf.CheckLibWithHeader('luajit-5.1', 'luajit-2.0/lua.h', 'CXX'):
-		print "luajit library not found. Checking for interpreter"
-		env.ParseConfig('pkg-config --cflags --libs lua5.1')
-	env.ParseConfig('pkg-config --cflags --libs luabind')
-
-#Check if architecture optimizations shall be turned off
-if GetOption('buildconfiguration') != 'debug' and sys.platform != 'darwin' and GetOption('nomarch') is None:
-	env.Append(CCFLAGS = ['-march=native'])
-
-if not conf.CheckHeader('omp.h'):
-	print "Compiler does not support OpenMP. Exiting"
-	Exit(-1)
-if not conf.CheckLibWithHeader('bz2', 'bzlib.h', 'CXX'):
-	print "bz2 library not found. Exiting"
-	Exit(-1)
-if GetOption('withtools') is not None:
-	if not conf.CheckLibWithHeader('gdal', 'gdal/gdal.h', 'CXX'):
-		print "gdal library not found. Exiting"
-		Exit(-1)
-if not conf.CheckLibWithHeader('osmpbf', 'osmpbf/osmpbf.h', 'CXX'):
-	print "osmpbf library not found. Exiting"
-	print "Either install libosmpbf-dev (Ubuntu) or use https://github.com/scrosby/OSM-binary"
-	Exit(-1)
-if not conf.CheckLibWithHeader('protobuf', 'google/protobuf/descriptor.h', 'CXX'):
-	print "Google Protobuffer library not found. Exiting"
-	Exit(-1)
-#check for protobuf 2.3.0
-if not (conf.CheckProtobuf('2.3.0')):
-	print 'libprotobuf version >= 2.3.0 needed'
-	Exit(-1);
-if not (env.Detect('protoc')):
-	print 'protobuffer compiler not found'
-	Exit(-1);
-if not conf.CheckLibWithHeader('stxxl', 'stxxl.h', 'CXX'):
-	print "stxxl library not found. Exiting"
-	Exit(-1)
-if not conf.CheckLibWithHeader('xml2', 'libxml/xmlreader.h', 'CXX'):
-	print "libxml2 library or header not found. Exiting"
-	Exit(-1)
-if not conf.CheckLibWithHeader('z', 'zlib.h', 'CXX'):
-	print "zlib library or header not found. Exiting"
-	Exit(-1)
-#Check BOOST installation
-if not (conf.CheckBoost('1.44')):
-	print 'Boost version >= 1.44 needed'
-	Exit(-1);
-if not conf.CheckLib('boost_system', language="C++"):
-	if not conf.CheckLib('boost_system-mt', language="C++"):
-		print "boost_system library not found. Exiting"
-		Exit(-1)
-	else:
-		print "using boost -mt"
-		env.Append(CCFLAGS = ' -lboost_system-mt')
-		env.Append(LINKFLAGS = ' -lboost_system-mt')
-if not conf.CheckLibWithHeader('boost_thread', 'boost/thread.hpp', 'CXX'):
-	if not conf.CheckLibWithHeader('boost_thread-mt', 'boost/thread.hpp', 'CXX'):
-		print "boost thread library not found. Exiting"
-		Exit(-1)
-	else:
-		print "using boost -mt"
-		env.Append(CCFLAGS = ' -lboost_thread-mt')
-		env.Append(LINKFLAGS = ' -lboost_thread-mt')
-if not conf.CheckLibWithHeader('boost_regex', 'boost/regex.hpp', 'CXX'):
-	if not conf.CheckLibWithHeader('boost_regex-mt', 'boost/regex.hpp', 'CXX'):
-		print "boost/regex.hpp not found. Exiting"
-		Exit(-1)
-	else:
-		print "using boost_regex -mt"
-		env.Append(CCFLAGS = ' -lboost_regex-mt')
-		env.Append(LINKFLAGS = ' -lboost_regex-mt')
-if not conf.CheckLib('boost_filesystem', language="C++"):
-	if not conf.CheckLib('boost_filesystem-mt', language="C++"):
-		print "boost_filesystem library not found. Exiting"
-		Exit(-1)
-	else:
-		print "using boost -mt"
-		env.Append(CCFLAGS = ' -lboost_filesystem-mt')
-		env.Append(LINKFLAGS = ' -lboost_filesystem-mt')
-if not conf.CheckCXXHeader('boost/archive/iterators/base64_from_binary.hpp'):
-	print "boost/archive/iterators/base64_from_binary.hpp not found. Exiting"
-	Exit(-1)
-if not conf.CheckCXXHeader('boost/archive/iterators/binary_from_base64.hpp'):
-	print "boost/archive/iterators/binary_from_base64.hpp not found. Exiting"
-	Exit(-1)
-if not conf.CheckCXXHeader('boost/archive/iterators/transform_width.hpp'):
-	print "boost/archive/iterators/transform_width.hpp not found. Exiting"
-	Exit(-1)
-if not conf.CheckCXXHeader('boost/bind.hpp'):
-	print "boost/bind.hpp not found. Exiting"
-	Exit(-1)
-if not conf.CheckCXXHeader('boost/circular_buffer.hpp'):
-	print "boost/circular_buffer.hpp not found. Exiting"
-	Exit(-1)
-if not conf.CheckCXXHeader('boost/enable_shared_from_this.hpp'):
-	print "boost/bind.hpp not found. Exiting"
-	Exit(-1)
-if not conf.CheckCXXHeader('boost/foreach.hpp'):
-	print "boost/foreach.hpp not found. Exiting"
-	Exit(-1)
-if not conf.CheckCXXHeader('boost/lexical_cast.hpp'):
-	print "boost/foreach.hpp not found. Exiting"
-	Exit(-1)
-if not conf.CheckCXXHeader('boost/logic/tribool.hpp'):
-	print "boost/foreach.hpp not found. Exiting"
-	Exit(-1)
-if not conf.CheckCXXHeader('boost/math/tr1.hpp'):
-	print "boost/foreach.hpp not found. Exiting"
-	Exit(-1)
-if not conf.CheckCXXHeader('boost/noncopyable.hpp'):
-	print "boost/noncopyable.hpp not found. Exiting"
-	Exit(-1)
-if not conf.CheckCXXHeader('boost/property_tree/ptree.hpp'):
-	print "boost/property_tree/ptree.hpp not found. Exiting"
-	Exit(-1)
-if not conf.CheckCXXHeader('boost/property_tree/ini_parser.hpp'):
-	print "boost/property_tree/ini_parser.hpp not found. Exiting"
-	Exit(-1)
-if not conf.CheckCXXHeader('boost/shared_ptr.hpp'):
-	print "boost/shared_ptr.hpp not found. Exiting"
-	Exit(-1)
-if not conf.CheckCXXHeader('boost/thread/mutex.hpp'):
-	print "boost/shared_ptr.hpp not found. Exiting"
-	Exit(-1)
-if not conf.CheckCXXHeader('boost/thread/thread.hpp'):
-	print "boost/thread/thread.hpp not found. Exiting"
-	Exit(-1)
-if not conf.CheckCXXHeader('boost/thread/condition.hpp'):
-	print "boost/thread/condition.hpp not found. Exiting"
-	Exit(-1)
-if not conf.CheckCXXHeader('boost/thread/thread.hpp'):
-	print "boost/thread/thread.hpp not found. Exiting"
-	Exit(-1)
-if not conf.CheckCXXHeader('boost/thread.hpp'):
-	print "boost thread header not found. Exiting"
-	Exit(-1)
-if not conf.CheckCXXHeader('boost/tuple/tuple.hpp'):
-	print "boost thread header not found. Exiting"
-	Exit(-1)
-if not conf.CheckCXXHeader('boost/unordered_map.hpp'):
-	print "boost thread header not found. Exiting"
-	Exit(-1)
-
-#checks for intels thread building blocks library
-#if not conf.CheckLibWithHeader('tbb', 'tbb/tbb.h', 'CXX'):
-#	print "Intel TBB library not found. Exiting"
-#	Exit(-1)
-#if not conf.CheckCXXHeader('tbb/task_scheduler_init.h'):
-#	print "tbb/task_scheduler_init.h not found. Exiting"
-#	Exit(-1)
-
-env.Program(target = 'osrm-extract', source = ["extractor.cpp", Glob('Util/*.cpp'), Glob('Extractor/*.cpp')])
-env.Program(target = 'osrm-prepare', source = ["createHierarchy.cpp", Glob('Contractor/*.cpp'), Glob('Util/SRTMLookup/*.cpp'), Glob('Algorithms/*.cpp')])
-env.Program(target = 'osrm-routed', source = ["routed.cpp", 'Descriptors/DescriptionFactory.cpp', Glob('ThirdParty/*.cc'), Glob('Server/DataStructures/*.cpp')], CCFLAGS = env['CCFLAGS'] + ['-DROUTED'])
-if GetOption('withtools') is not None:
-	env.Program(target = 'Tools/osrm-component', source = ["Tools/componentAnalysis.cpp"])
-env = conf.Finish()
-

Server/APIGrammar.h

@@ -1,24 +1,29 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 APIGRAMMAR_H_
 #define APIGRAMMAR_H_
@@ -33,7 +38,7 @@ template <typename Iterator, class HandlerT>
 struct APIGrammar : qi::grammar<Iterator> {
     APIGrammar(HandlerT * h) : APIGrammar::base_type(api_call), handler(h) {
         api_call = qi::lit('/') >> string[boost::bind(&HandlerT::setService, handler, ::_1)] >> *(query);
-        query    = ('?') >> (+(zoom | output | jsonp | checksum | location | hint | cmp | language | instruction | alt_route | old_API) ) ;
+        query    = ('?') >> (+(zoom | output | jsonp | checksum | location | hint | cmp | language | instruction | geometry | alt_route | old_API) ) ;
 
         zoom        = (-qi::lit('&')) >> qi::lit('z')            >> '=' >> qi::short_[boost::bind(&HandlerT::setZoomLevel, handler, ::_1)];
         output      = (-qi::lit('&')) >> qi::lit("output")       >> '=' >> string[boost::bind(&HandlerT::setOutputFormat, handler, ::_1)];

Server/BasicDatastructures.h

@@ -1,150 +0,0 @@
-/*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
-*/
-
-#ifndef BASIC_DATASTRUCTURES_H
-#define BASIC_DATASTRUCTURES_H
-#include <string>
-#include <boost/lexical_cast.hpp>
-
-namespace http {
-
-const std::string okString 					= "HTTP/1.0 200 OK\r\n";
-const std::string badRequestString 			= "HTTP/1.0 400 Bad Request\r\n";
-const std::string internalServerErrorString = "HTTP/1.0 500 Internal Server Error\r\n";
-
-const char okHTML[] 				 = "";
-const char badRequestHTML[] 		 = "<html><head><title>Bad Request</title></head><body><h1>400 Bad Request</h1></body></html>";
-const char internalServerErrorHTML[] = "<html><head><title>Internal Server Error</title></head><body><h1>500 Internal Server Error</h1></body></html>";
-const char seperators[]  			 = { ':', ' ' };
-const char crlf[]		             = { '\r', '\n' };
-
-struct Header {
-  std::string name;
-  std::string value;
-  void Clear() {
-      name.clear();
-      value.clear();
-  }
-};
-
-enum CompressionType {
-    noCompression,
-    gzipRFC1952,
-    deflateRFC1951
-} Compression;
-
-struct Request {
-	std::string uri;
-	std::string referrer;
-	std::string agent;
-	boost::asio::ip::address endpoint;
-};
-
-struct Reply {
-    Reply() : status(ok) { content.reserve(2 << 20); }
-	enum status_type {
-		ok 					= 200,
-		badRequest 		    = 400,
-		internalServerError = 500
-	} status;
-
-	std::vector<Header> headers;
-    std::vector<boost::asio::const_buffer> toBuffers();
-    std::vector<boost::asio::const_buffer> HeaderstoBuffers();
-	std::string content;
-	static Reply stockReply(status_type status);
-	void setSize(unsigned size) {
-	    for (std::size_t i = 0; i < headers.size(); ++i) {
-	            Header& h = headers[i];
-	            if("Content-Length" == h.name) {
-	                std::stringstream sizeString;
-	                sizeString << size;
-	                h.value = sizeString.str();
-	            }
-	    }
-	}
-};
-
-boost::asio::const_buffer ToBuffer(Reply::status_type status) {
-	switch (status) {
-	case Reply::ok:
-		return boost::asio::buffer(okString);
-	case Reply::internalServerError:
-		return boost::asio::buffer(internalServerErrorString);
-	default:
-		return boost::asio::buffer(badRequestString);
-	}
-}
-
-std::string ToString(Reply::status_type status) {
-	switch (status) {
-	case Reply::ok:
-		return okHTML;
-	case Reply::badRequest:
-		return badRequestHTML;
-	default:
-		return internalServerErrorHTML;
-	}
-}
-
-std::vector<boost::asio::const_buffer> Reply::toBuffers(){
-	std::vector<boost::asio::const_buffer> buffers;
-	buffers.push_back(ToBuffer(status));
-	for (std::size_t i = 0; i < headers.size(); ++i) {
-		Header& h = headers[i];
-		buffers.push_back(boost::asio::buffer(h.name));
-		buffers.push_back(boost::asio::buffer(seperators));
-		buffers.push_back(boost::asio::buffer(h.value));
-		buffers.push_back(boost::asio::buffer(crlf));
-	}
-	buffers.push_back(boost::asio::buffer(crlf));
-	buffers.push_back(boost::asio::buffer(content));
-	return buffers;
-}
-
-std::vector<boost::asio::const_buffer> Reply::HeaderstoBuffers(){
-    std::vector<boost::asio::const_buffer> buffers;
-    buffers.push_back(ToBuffer(status));
-    for (std::size_t i = 0; i < headers.size(); ++i) {
-        Header& h = headers[i];
-//        std::cout << h.name << ": " << h.value << std::endl;
-        buffers.push_back(boost::asio::buffer(h.name));
-        buffers.push_back(boost::asio::buffer(seperators));
-        buffers.push_back(boost::asio::buffer(h.value));
-        buffers.push_back(boost::asio::buffer(crlf));
-    }
-    buffers.push_back(boost::asio::buffer(crlf));
-    return buffers;
-}
-
-Reply Reply::stockReply(Reply::status_type status) {
-	Reply rep;
-	rep.status = status;
-	rep.content = ToString(status);
-	rep.headers.resize(2);
-	rep.headers[0].name = "Content-Length";
-	rep.headers[0].value = boost::lexical_cast<std::string>(rep.content.size());
-	rep.headers[1].name = "Content-Type";
-	rep.headers[1].value = "text/html";
-	return rep;
-}
-} // namespace http
-
-#endif //BASIC_DATASTRUCTURES_H

Server/Connection.h

@@ -1,179 +1,318 @@
 /*
-    open source routing machine
-    Copyright (C) Dennis Luxen, others 2010
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU AFFERO General Public License as published by
-the Free Software Foundation; either version 3 of the License, or
-any later version.
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
 
-You should have received a copy of the GNU Affero General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-or see http://www.gnu.org/licenses/agpl.txt.
- */
+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 CONNECTION_H
 #define CONNECTION_H
 
-#include <vector>
-
-#include <boost/asio.hpp>
-#include <boost/array.hpp>
-#include <boost/bind.hpp>
-#include <boost/noncopyable.hpp>
-#include <boost/shared_ptr.hpp>
-#include <boost/enable_shared_from_this.hpp>
-
-#include "../DataStructures/Util.h"
-#include "BasicDatastructures.h"
+#include "Http/CompressionType.h"
 #include "RequestHandler.h"
 #include "RequestParser.h"
 
-#include "zlib.h"
+#include <boost/array.hpp>
+#include <boost/asio.hpp>
+#include <boost/assert.hpp>
+#include <boost/bind.hpp>
+#include <boost/enable_shared_from_this.hpp>
+#include <boost/iostreams/filtering_stream.hpp>
+#include <boost/iostreams/filter/gzip.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/shared_ptr.hpp>
+
+
+// #include <zlib.h>
+
+#include <string>
+#include <vector>
 
 namespace http {
 
 /// Represents a single connection from a client.
-class Connection : public boost::enable_shared_from_this<Connection>, private boost::noncopyable {
+class Connection : 	public boost::enable_shared_from_this<Connection>,
+					private boost::noncopyable {
 public:
-	explicit Connection(boost::asio::io_service& io_service, RequestHandler& handler) : strand(io_service), TCPsocket(io_service), requestHandler(handler) {}
+	explicit Connection(
+		boost::asio::io_service& io_service,
+		RequestHandler& handler
+	) : strand(io_service), TCP_socket(io_service), request_handler(handler) { }
 
 	boost::asio::ip::tcp::socket& socket() {
-		return TCPsocket;
+		return TCP_socket;
 	}
 
 	/// Start the first asynchronous operation for the connection.
 	void start() {
-	    TCPsocket.async_read_some(boost::asio::buffer(incomingDataBuffer), strand.wrap( boost::bind(&Connection::handleRead, this->shared_from_this(), boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred)));
+	    TCP_socket.async_read_some(
+	    	boost::asio::buffer(incoming_data_buffer),
+	    	strand.wrap( boost::bind(
+	    					&Connection::handle_read,
+	    					this->shared_from_this(),
+	    					boost::asio::placeholders::error,
+	    					boost::asio::placeholders::bytes_transferred)
+	    	)
+	    );
 	}
 
 private:
-	void handleRead(const boost::system::error_code& e, std::size_t bytes_transferred) {
-		if (!e) {
-			CompressionType compressionType(noCompression);
+	void handle_read(
+		const boost::system::error_code& e,
+		std::size_t bytes_transferred
+	) {
+		if( !e ) {
+			CompressionType compression_type(noCompression);
 			boost::tribool result;
-			boost::tie(result, boost::tuples::ignore) = requestParser.Parse( request, incomingDataBuffer.data(), incomingDataBuffer.data() + bytes_transferred, &compressionType);
+			boost::tie(result, boost::tuples::ignore) = request_parser.Parse(
+				request,
+				incoming_data_buffer.data(),
+				incoming_data_buffer.data() + bytes_transferred,
+				&compression_type
+			);
 
-			if (result) {
-				//                std::cout << "----" << std::endl;
-				//				if(compressionType == gzipRFC1952)
-				//					std::cout << "[debug] using gzip" << std::endl;
-				//				if(compressionType == deflateRFC1951)
-				//					std::cout << "[debug] using deflate" << std::endl;
-				//				if(compressionType == noCompression)
-				//					std::cout << "[debug] no compression" << std::endl;
-			    request.endpoint = TCPsocket.remote_endpoint().address();
-				requestHandler.handle_request(request, reply);
+			if( result ) {
+				request.endpoint = TCP_socket.remote_endpoint().address();
+				request_handler.handle_request(request, reply);
 
-				Header compressionHeader;
-				std::vector<unsigned char> compressed;
-				std::vector<boost::asio::const_buffer> outputBuffer;
-				switch(compressionType) {
+				Header compression_header;
+				std::vector<char> compressed_output;
+				std::vector<boost::asio::const_buffer> output_buffer;
+				switch(compression_type) {
 				case deflateRFC1951:
-					compressionHeader.name = "Content-Encoding";
-					compressionHeader.value = "deflate";
-					reply.headers.insert(reply.headers.begin(), compressionHeader);   //push_back(compressionHeader);
-					compressCharArray(reply.content.c_str(), reply.content.length(), compressed, compressionType);
-					reply.setSize(compressed.size());
-					outputBuffer = reply.HeaderstoBuffers();
-					outputBuffer.push_back(boost::asio::buffer(compressed));
-					boost::asio::async_write(TCPsocket, outputBuffer, strand.wrap( boost::bind(&Connection::handleWrite, this->shared_from_this(), boost::asio::placeholders::error)));
+					compression_header.name = "Content-Encoding";
+					compression_header.value = "deflate";
+					reply.headers.insert(
+						reply.headers.begin(),
+						compression_header
+					);
+					compressBufferCollection(
+						reply.content,
+						compression_type,
+						compressed_output
+					);
+					reply.setSize(compressed_output.size());
+					output_buffer = reply.HeaderstoBuffers();
+					output_buffer.push_back(
+						boost::asio::buffer(compressed_output)
+					);
+					boost::asio::async_write(
+						TCP_socket,
+						output_buffer,
+						strand.wrap(
+							boost::bind(
+								&Connection::handle_write,
+								this->shared_from_this(),
+								boost::asio::placeholders::error
+							)
+						)
+					);
 					break;
 				case gzipRFC1952:
-					compressionHeader.name = "Content-Encoding";
-					compressionHeader.value = "gzip";
-					reply.headers.insert(reply.headers.begin(), compressionHeader);
-					compressCharArray(reply.content.c_str(), reply.content.length(), compressed, compressionType);
-					reply.setSize(compressed.size());
-					outputBuffer = reply.HeaderstoBuffers();
-					outputBuffer.push_back(boost::asio::buffer(compressed));
-					boost::asio::async_write(TCPsocket, outputBuffer, strand.wrap( boost::bind(&Connection::handleWrite, this->shared_from_this(), boost::asio::placeholders::error)));break;
+					compression_header.name = "Content-Encoding";
+					compression_header.value = "gzip";
+					reply.headers.insert(
+						reply.headers.begin(),
+						compression_header
+					);
+					compressBufferCollection(
+						reply.content,
+						compression_type,
+						compressed_output
+					);
+					reply.setSize(compressed_output.size());
+					output_buffer = reply.HeaderstoBuffers();
+					output_buffer.push_back(
+						boost::asio::buffer(compressed_output)
+					);
+					boost::asio::async_write(
+						TCP_socket,
+						output_buffer,
+						strand.wrap(
+							boost::bind(
+								&Connection::handle_write,
+								this->shared_from_this(),
+								boost::asio::placeholders::error
+							)
+						)
+					);
+					break;
 				case noCompression:
-					boost::asio::async_write(TCPsocket, reply.toBuffers(), strand.wrap( boost::bind(&Connection::handleWrite, this->shared_from_this(), boost::asio::placeholders::error)));
+					boost::asio::async_write(
+						TCP_socket,
+						reply.toBuffers(),
+						strand.wrap(
+							boost::bind(
+								&Connection::handle_write,
+								this->shared_from_this(),
+								boost::asio::placeholders::error
+								)
+							)
+						);
 					break;
 				}
-
 			} else if (!result) {
-				reply = Reply::stockReply(Reply::badRequest);
-				boost::asio::async_write(TCPsocket, reply.toBuffers(), strand.wrap( boost::bind(&Connection::handleWrite, this->shared_from_this(), boost::asio::placeholders::error)));
+				reply = Reply::StockReply(Reply::badRequest);
+				boost::asio::async_write(
+					TCP_socket,
+					reply.toBuffers(),
+					strand.wrap(
+						boost::bind(
+							&Connection::handle_write,
+							this->shared_from_this(),
+							boost::asio::placeholders::error
+						)
+					)
+				);
 			} else {
-				TCPsocket.async_read_some(boost::asio::buffer(incomingDataBuffer), strand.wrap( boost::bind(&Connection::handleRead, this->shared_from_this(), boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred)));
+				TCP_socket.async_read_some(
+					boost::asio::buffer(incoming_data_buffer),
+					strand.wrap(
+						boost::bind(
+							&Connection::handle_read,
+							this->shared_from_this(),
+							boost::asio::placeholders::error,
+							boost::asio::placeholders::bytes_transferred
+						)
+					)
+				);
 			}
 		}
 	}
 
 	/// Handle completion of a write operation.
-	void handleWrite(const boost::system::error_code& e) {
+	void handle_write(const boost::system::error_code& e) {
 		if (!e) {
 			// Initiate graceful connection closure.
 			boost::system::error_code ignoredEC;
-			TCPsocket.shutdown(boost::asio::ip::tcp::socket::shutdown_both, ignoredEC);
+			TCP_socket.shutdown(
+				boost::asio::ip::tcp::socket::shutdown_both,
+				ignoredEC
+			);
 		}
-		// No new asynchronous operations are started. This means that all shared_ptr
-		// references to the connection object will disappear and the object will be
-		// destroyed automatically after this handler returns. The connection class's
-		// destructor closes the socket.
 	}
 
-	void compressCharArray(const void *in_data, size_t in_data_size, std::vector<unsigned char> &buffer, CompressionType type) {
-		const size_t BUFSIZE = 128 * 1024;
-		unsigned char temp_buffer[BUFSIZE];
+	void compressBufferCollection(
+		std::vector<std::string> uncompressed_data,
+		CompressionType compression_type,
+	   	std::vector<char> & compressed_data
+   	) {
+   		boost::iostreams::gzip_params compression_parameters;
 
-		z_stream strm;
-		strm.zalloc = Z_NULL;
-		strm.zfree = Z_NULL;
-		strm.opaque = Z_NULL;
-		strm.total_out = 0;
-		strm.next_in = (unsigned char *)(in_data);
-		strm.avail_in = in_data_size;
-		strm.next_out = temp_buffer;
-		strm.avail_out = BUFSIZE;
-		strm.data_type = Z_ASCII;
+   		compression_parameters.level = boost::iostreams::zlib::best_speed;
+   		if ( deflateRFC1951 == compression_type ) {
+   			compression_parameters.noheader = true;
+   		}
 
-		switch(type){
-		case deflateRFC1951:
-			deflateInit(&strm, Z_BEST_SPEED);
-			break;
-		case gzipRFC1952:
-			/*
-			 * Big thanks to deusty who explains how to have gzip compression turned on by the right call to deflateInit2():
-			 * http://deusty.blogspot.com/2007/07/gzip-compressiondecompression.html
-			 */
-			deflateInit2(&strm, Z_DEFAULT_COMPRESSION, Z_DEFLATED, (15+16), 9, Z_DEFAULT_STRATEGY);
-			break;
-		default:
-			assert(false);
-			break;
+		BOOST_ASSERT( compressed_data.empty() );
+		boost::iostreams::filtering_ostream compressing_stream;
+
+		compressing_stream.push(
+			boost::iostreams::gzip_compressor(compression_parameters)
+		);
+		compressing_stream.push(
+			boost::iostreams::back_inserter(compressed_data)
+		);
+
+		BOOST_FOREACH( const std::string & line, uncompressed_data) {
+			compressing_stream << line;
 		}
 
-		int deflate_res = Z_OK;
-		do {
-			if (strm.avail_out == 0) {
-				buffer.insert(buffer.end(), temp_buffer, temp_buffer + BUFSIZE);
-				strm.next_out = temp_buffer;
-				strm.avail_out = BUFSIZE;
-			}
-			deflate_res = deflate(&strm, Z_FINISH);
-
-		} while (deflate_res == Z_OK);
-
-		assert(deflate_res == Z_STREAM_END);
-		buffer.insert(buffer.end(), temp_buffer, temp_buffer + BUFSIZE - strm.avail_out);
-		deflateEnd(&strm);
+		compressing_stream.reset();
 	}
 
+	// Big thanks to deusty who explains how to use gzip compression by
+	// the right call to deflateInit2():
+	// http://deusty.blogspot.com/2007/07/gzip-compressiondecompression.html
+	// void compressCharArray(
+	// 	const char * in_data,
+	// 	size_t in_data_size,
+	// 	std::vector<unsigned char> & buffer,
+	// 	CompressionType type
+	// ) {
+	// 	const size_t BUFSIZE = 128 * 1024;
+	// 	unsigned char temp_buffer[BUFSIZE];
+
+	// 	z_stream strm;
+	// 	strm.zalloc = Z_NULL;
+	// 	strm.zfree = Z_NULL;
+	// 	strm.opaque = Z_NULL;
+	// 	strm.total_out = 0;
+	// 	strm.next_in = (unsigned char *)(in_data);
+	// 	strm.avail_in = in_data_size;
+	// 	strm.next_out = temp_buffer;
+	// 	strm.avail_out = BUFSIZE;
+	// 	strm.data_type = Z_ASCII;
+
+	// 	switch(type){
+	// 	case deflateRFC1951:
+	// 		deflateInit(&strm, Z_BEST_SPEED);
+	// 		break;
+	// 	case gzipRFC1952:
+	// 		deflateInit2(
+	// 			&strm,
+	// 			Z_DEFAULT_COMPRESSION,
+	// 			Z_DEFLATED,
+	// 			(15+16),
+	// 			9,
+	// 			Z_DEFAULT_STRATEGY
+	// 		);
+	// 		break;
+	// 	default:
+	// 		BOOST_ASSERT_MSG(false, "should not happen");
+	// 		break;
+	// 	}
+
+	// 	int deflate_res = Z_OK;
+	// 	do {
+	// 		if ( 0 == strm.avail_out ) {
+	// 			buffer.insert(buffer.end(), temp_buffer, temp_buffer + BUFSIZE);
+	// 			strm.next_out = temp_buffer;
+	// 			strm.avail_out = BUFSIZE;
+	// 		}
+	// 		deflate_res = deflate(&strm, Z_FINISH);
+
+	// 	} while (deflate_res == Z_OK);
+
+	// 	BOOST_ASSERT_MSG(
+	// 		deflate_res == Z_STREAM_END,
+	// 		"compression not properly finished"
+	// 	);
+
+	// 	buffer.insert(
+	// 		buffer.end(),
+	// 		temp_buffer,
+	// 		temp_buffer + BUFSIZE - strm.avail_out
+	// 	);
+	// 	deflateEnd(&strm);
+	// }
+
 	boost::asio::io_service::strand strand;
-	boost::asio::ip::tcp::socket TCPsocket;
-	RequestHandler& requestHandler;
-	boost::array<char, 8192> incomingDataBuffer;
+	boost::asio::ip::tcp::socket TCP_socket;
+	RequestHandler& request_handler;
+	boost::array<char, 8192> incoming_data_buffer;
 	Request request;
-	RequestParser requestParser;
+	RequestParser request_parser;
 	Reply reply;
 };