fix indentation

Better file not found error

.gitignore

@@ -37,6 +37,7 @@ Thumbs.db
 #######################
 /build/
 /Util/UUID.cpp
+/Util/GitDescription.cpp
 
 # Eclipse related files #
 #########################
@@ -71,7 +72,10 @@ stxxl.errlog
 /win/bin/
 /win/bin-debug/
 /osrm-extract
+/osrm-io-benchmark
+/osrm-components
 /osrm-routed
+/osrm-datastore
 /osrm-prepare
 /osrm-cli
 /nohup.out
@@ -81,3 +85,7 @@ stxxl.errlog
 /sandbox/
 
 /test/profile.lua
+
+# Deprecated config file #
+##########################
+/server.ini

.travis.yml

@@ -5,7 +5,7 @@ compiler:
 # Make sure CMake is installed
 install:
  - sudo apt-get update >/dev/null
- - sudo apt-get -q install build-essential git cmake pkg-config libprotoc-dev libprotobuf7 protobuf-compiler libprotobuf-dev libosmpbf-dev libpng12-dev libbz2-dev libstxxl-dev libstxxl-doc libstxxl1 libxml2-dev libzip-dev libboost-thread-dev libboost-system-dev libboost-regex-dev libboost-filesystem-dev lua5.1 liblua5.1-0-dev libluabind-dev rubygems osmosis
+ - 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
@@ -13,9 +13,6 @@ before_script:
  - cd build
  - cmake .. $CMAKEOPTIONS
 script: make
-after_script:
- - cd ..
- - cucumber -p verify
 branches:
   only:
     - master

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,50 +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, const int x1, int const 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) {
-        SimpleLogger().Write() << "using hardware base sse computation";
-        return &CRC32::SSEBasedCRC32; //crc32 hardware accelarated;
-    } else {
-        SimpleLogger().Write() << "using software base sse computation";
-        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,47 +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 "../Util/SimpleLogger.h"
-
-#include <boost/crc.hpp>  // for boost::crc_32_type
-#include <iostream>
-
-class CRC32 {
-private:
-    unsigned crc;
-
-    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,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:
 
-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 "../DataStructures/Coordinate.h"
+#include "../DataStructures/SegmentInformation.h"
+
+#include <boost/assert.hpp>
 
-#include <cassert>
 #include <cmath>
-#include <cfloat>
+
+#include <limits>
 #include <stack>
 #include <vector>
 
@@ -36,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,23 +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 ITERATORBASEDCRC32_H_
 #define ITERATORBASEDCRC32_H_

Algorithms/ObjectToBase64.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 OBJECTTOBASE64_H_
 #define 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,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 POLYLINECOMPRESSOR_H_
 #define POLYLINECOMPRESSOR_H_
@@ -25,112 +32,38 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #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(
+    void 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 += "\"";
+    ) const;
 
-    }
+    void printEncodedString(
+        const std::vector<FixedPointCoordinate>& polyline,
+        std::string &output
+    ) const;
 
-	inline void 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 printUnencodedString(
+        const std::vector<FixedPointCoordinate> & polyline,
+        std::string & output
+    ) const;
 
-    inline void printUnencodedString(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 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,25 +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.
 
-Strongly connected components using Tarjan's Algorithm
+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_
@@ -35,11 +39,13 @@ 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>
@@ -48,7 +54,7 @@ Strongly connected components using Tarjan's Algorithm
     #include <gdal/gdal.h>
     #include <gdal/ogrsf_frmts.h>
 #endif
-#include <cassert>
+
 #include <stack>
 #include <vector>
 
@@ -64,7 +70,6 @@ private:
 
     struct TarjanEdgeData {
         int distance;
-        unsigned edgeBasedNodeID;
         unsigned nameID:31;
         bool shortcut:1;
         short type;
@@ -77,26 +82,28 @@ private:
     };
 
     struct TarjanStackFrame {
-        explicit TarjanStackFrame(NodeID _v, NodeID p) : v(_v), parent(p) {}
+        explicit TarjanStackFrame(
+            NodeID v,
+            NodeID parent
+        ) : v(v), parent(parent) { }
         NodeID v;
         NodeID parent;
     };
 
-    typedef DynamicGraph<TarjanEdgeData> TarjanDynamicGraph;
-    typedef TarjanDynamicGraph::InputEdge TarjanEdge;
-    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<NodeInfo>               inputNodeInfoList;
-    unsigned numberOfTurnRestrictions;
-    boost::shared_ptr<TarjanDynamicGraph>   _nodeBasedGraph;
-    boost::unordered_map<NodeID, bool>          _barrierNodes;
-    boost::unordered_map<NodeID, bool>          _trafficLights;
-
-    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;
 
     struct EdgeBasedNode {
         bool operator<(const EdgeBasedNode & other) const {
@@ -116,93 +123,99 @@ private:
         bool ignoreInGrid:1;
     };
 
-    DeallocatingVector<EdgeBasedNode>   edgeBasedNodes;
 public:
     TarjanSCC(
-        int nodes,
-        std::vector<NodeBasedEdge> & inputEdges,
+        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
     ) :
-        inputNodeInfoList(nI),
-        numberOfTurnRestrictions(irs.size())
+        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(
+            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;
-        }
-
-        DeallocatingVector< TarjanEdge > edges;
-        for ( std::vector< NodeBasedEdge >::const_iterator i = inputEdges.begin(); i != inputEdges.end(); ++i ) {
+        m_barrier_node_list.insert(bn.begin(), bn.end());
+        m_traffic_light_list.insert(tl.begin(), tl.end());
 
+        DeallocatingVector< TarjanEdge > edge_list;
+        BOOST_FOREACH(const NodeBasedEdge & input_edge, input_edges) {
             TarjanEdge edge;
-            if(!i->isForward()) {
-                edge.source = i->target();
-                edge.target = i->source();
-                edge.data.backward = i->isForward();
-                edge.data.forward = i->isBackward();
+            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();
+            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;
-            edges.push_back( edge );
+            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();
+                edge.data.forward = input_edge.isBackward();
+                edge.data.backward = input_edge.isForward();
                 edge.data.reversedEdge = true;
-                edges.push_back( edge );
+                edge_list.push_back( edge );
             }
         }
-        std::vector<NodeBasedEdge>().swap(inputEdges);
-        std::sort( edges.begin(), edges.end() );
-        _nodeBasedGraph = boost::make_shared<TarjanDynamicGraph>( 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() {
@@ -211,162 +224,203 @@ public:
         DeleteFileIfExists("component.shx");
         DeleteFileIfExists("component.shp");
 
-        Percent p(_nodeBasedGraph->GetNumberOfNodes());
-
-        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;
-//                SimpleLogger().Write() << "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;
-//                    SimpleLogger().Write() << "pushing " << v << " onto tarjan stack, idx[" << v << "]=" << tarjanNodes[v].index << ", lowlink["<< v << "]=" << tarjanNodes[v].lowlink;
 
                     //Traverse outgoing edges
-                    for(TarjanDynamicGraph::EdgeIterator e2 = _nodeBasedGraph->BeginEdges(v); e2 < _nodeBasedGraph->EndEdges(v); ++e2) {
-                        TarjanDynamicGraph::NodeIterator vprime = _nodeBasedGraph->GetTarget(e2);
-//                        SimpleLogger().Write() << "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 {
-//                            SimpleLogger().Write() << "Node " << vprime << " is already explored";
-                            if(tarjanNodes[vprime].onStack) {
-                                unsigned newLowlink = std::min(tarjanNodes[v].lowlink, tarjanNodes[vprime].index);
-//                                SimpleLogger().Write() << "Setting lowlink[" << v << "] from " << tarjanNodes[v].lowlink << " to " << newLowlink;
-                                tarjanNodes[v].lowlink = newLowlink;
-//                            } else {
-//                                SimpleLogger().Write() << "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 {
-
-//                    SimpleLogger().Write() << "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 );
-//                        SimpleLogger().Write() << "parent=" << currentFrame.parent;
-//                        SimpleLogger().Write() << "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);
-//                        SimpleLogger().Write() << "Setting tarjanNodes[" << currentFrame.parent  <<"].lowlink=" << tarjanNodes[currentFrame.parent].lowlink;
-                    }
-//                    SimpleLogger().Write() << "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 {
-//                            SimpleLogger().Write() << "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)
-                            SimpleLogger().Write() << "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;
                     }
                 }
             }
         }
 
-        SimpleLogger().Write() << "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;
+            }
         }
-        SimpleLogger().Write() << "identified " << singleCounter << " SCCs of size 1";
+
+        SimpleLogger().Write() <<
+            "identified " << size_one_counter << " SCCs of size 1";
+
         uint64_t total_network_distance = 0;
-        p.reinit(_nodeBasedGraph->GetNumberOfNodes());
-        for(TarjanDynamicGraph::NodeIterator u = 0; u < _nodeBasedGraph->GetNumberOfNodes(); ++u ) {
+        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 = _nodeBasedGraph->BeginEdges(u); e1 < _nodeBasedGraph->EndEdges(u); ++e1) {
-                if(_nodeBasedGraph->GetEdgeData(e1).reversedEdge) {
+            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;
                 }
-                TarjanDynamicGraph::NodeIterator v = _nodeBasedGraph->GetTarget(e1);
+                const TarjanDynamicGraph::NodeIterator v = m_node_based_graph->GetTarget(e1);
 
                 total_network_distance += 100*ApproximateDistance(
-                        inputNodeInfoList[u].lat,
-                        inputNodeInfoList[u].lon,
-                        inputNodeInfoList[v].lat,
-                        inputNodeInfoList[v].lon
+                        m_coordinate_list[u].lat,
+                        m_coordinate_list[u].lon,
+                        m_coordinate_list[v].lat,
+                        m_coordinate_list[v].lon
                 );
 
-                if(_nodeBasedGraph->GetEdgeData(e1).type != SHRT_MAX) {
-                    assert(e1 != UINT_MAX);
-                    assert(u != UINT_MAX);
-                    assert(v != UINT_MAX);
+                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]]
+                        );
 
                     //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/COORDINATE_PRECISION << ";" << inputNodeInfoList[u].lon/COORDINATE_PRECISION << ") -> (" << inputNodeInfoList[v].lat/COORDINATE_PRECISION << ";" << inputNodeInfoList[v].lon/COORDINATE_PRECISION << ")");
+                    if(size_of_containing_component < 10) {
                         OGRLineString lineString;
-                        lineString.addPoint(inputNodeInfoList[u].lon/COORDINATE_PRECISION, inputNodeInfoList[u].lat/COORDINATE_PRECISION);
-                        lineString.addPoint(inputNodeInfoList[v].lon/COORDINATE_PRECISION, inputNodeInfoList[v].lat/COORDINATE_PRECISION);
-                        OGRFeature *poFeature;
-                        poFeature = OGRFeature::CreateFeature( poLayer->GetLayerDefn() );
+                        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()
+                        );
+
                         poFeature->SetGeometry( &lineString );
-                        if( poLayer->CreateFeature( poFeature ) != OGRERR_NONE ) {
+                        if( OGRERR_NONE != poLayer->CreateFeature(poFeature) ) {
                             throw OSRMException(
                                 "Failed to create feature in shapefile."
                             );
@@ -377,39 +431,66 @@ public:
             }
         }
         OGRDataSource::DestroyDataSource( poDS );
-        std::vector<NodeID>().swap(vectorOfComponentSizes);
-        std::vector<NodeID>().swap(componentsIndex);
-        SimpleLogger().Write() << "total network distance: " << (uint64_t)total_network_distance/100/1000. << " km";
+        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 {
+    void DeleteFileIfExists(const std::string & file_name) const {
         if (boost::filesystem::exists(file_name) ) {
             boost::filesystem::remove(file_name);
         }

CMakeLists.txt

@@ -1,8 +1,12 @@
 cmake_minimum_required(VERSION 2.6)
-set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 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.")
@@ -15,8 +19,8 @@ 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} -P
-    ${CMAKE_SOURCE_DIR}/cmake/UUID-Config.cmake
+  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
@@ -25,28 +29,34 @@ add_custom_command(OUTPUT ${CMAKE_SOURCE_DIR}/Util/UUID.cpp UUID.cpp.alwaysbuild
 
 add_custom_target(UUIDConfigure DEPENDS ${CMAKE_SOURCE_DIR}/Util/UUID.cpp )
 
-set(BOOST_COMPONENTS filesystem regex system thread)
+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 createHierarchy.cpp ${PrepareGlob})
-add_executable(osrm-prepare ${PrepareSources} )
-
-add_executable(osrm-routed routed.cpp )
-set_target_properties(osrm-routed PROPERTIES COMPILE_FLAGS -DROUTED)
+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)
-file(GLOB SearchEngineSource DataStructures/SearchEngine*.cpp)
-file(GLOB ServerStructureGlob Server/DataStructures/*.cpp)
 
-set(OSRMSources ${LibOSRMGlob} ${DescriptorGlob} ${SearchEngineSource} ${ServerStructureGlob})
-add_library(OSRM SHARED ${OSRMSources})
-add_library(UUID STATIC Util/UUID.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)
@@ -59,7 +69,14 @@ if(CMAKE_BUILD_TYPE MATCHES Release)
     message(STATUS "Configuring OSRM in release mode")
 endif(CMAKE_BUILD_TYPE MATCHES Release)
 
-#Configuring compilers
+# 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")
@@ -74,11 +91,23 @@ 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("Set Architecture to x64 on OS X")
+	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 )
@@ -92,9 +121,10 @@ IF( APPLE )
 ELSE( APPLE )
 	target_link_libraries( OSRM ${Boost_LIBRARIES} )
 ENDIF( APPLE )
-target_link_libraries( osrm-extract ${Boost_LIBRARIES} UUID )
-target_link_libraries( osrm-prepare ${Boost_LIBRARIES} UUID )
-target_link_libraries( osrm-routed ${Boost_LIBRARIES} OSRM UUID )
+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})
@@ -108,17 +138,27 @@ target_link_libraries (osrm-routed ${ZLIB_LIBRARY})
 find_package( Threads REQUIRED )
 target_link_libraries (osrm-extract ${Threads_LIBRARY})
 
-find_package( LuaJIT )
-IF( NOT APPLE AND LUAJIT_INCLUDE_DIR AND LUAJIT_LIBRARIES)
-	include_directories(${LUAJIT_INCLUDE_DIR})
-	target_link_libraries( osrm-extract ${LUAJIT_LIBRARIES} )
-	target_link_libraries( osrm-prepare ${LUAJIT_LIBRARIES} )
-ELSE( LUAJIT_INCLUDE_DIR )
-	find_package( Lua51 REQUIRED AND LUAJIT_LIBRARIES )
-	include_directories(${LUA_INCLUDE_DIR})
-	target_link_libraries( osrm-extract ${LUA_LIBRARY} )
-	target_link_libraries( osrm-prepare ${LUA_LIBRARY} )
-ENDIF( NOT APPLE AND LUAJIT_INCLUDE_DIR AND LUAJIT_LIBRARIES )
+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})
@@ -146,15 +186,22 @@ target_link_libraries (osrm-extract ${OSMPBF_LIBRARY})
 target_link_libraries (osrm-prepare ${OSMPBF_LIBRARY})
 
 if(WITH_TOOLS)
-	message("-- Activating OSRM internal 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
+			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 )
+	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/Contractor.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 CONTRACTOR_H_INCLUDED
 #define CONTRACTOR_H_INCLUDED
@@ -38,7 +45,6 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #include <boost/make_shared.hpp>
 #include <boost/shared_ptr.hpp>
 
-#include <cfloat>
 #include <ctime>
 
 #include <algorithm>
@@ -732,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 );
@@ -754,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,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 "EdgeBasedGraphFactory.h"
 
@@ -40,7 +47,7 @@ EdgeBasedGraphFactory::EdgeBasedGraphFactory(
         if(restriction_iter == m_restriction_map.end()) {
             index = m_restriction_bucket_list.size();
             m_restriction_bucket_list.resize(index+1);
-            m_restriction_map[restriction_source] = index;
+            m_restriction_map.emplace(restriction_source, index);
         } else {
             index = restriction_iter->second;
             //Map already contains an is_only_*-restriction
@@ -292,6 +299,8 @@ void EdgeBasedGraphFactory::Run(
     }
     SimpleLogger().Write() <<
         "identified: " << component_size_list.size() << " many components";
+    SimpleLogger().Write() <<
+        "generating edge-expanded nodes";
 
     p.reinit(m_node_based_graph->GetNumberOfNodes());
     //loop over all edges and generate new set of nodes.
@@ -301,6 +310,7 @@ void EdgeBasedGraphFactory::Run(
         u < number_of_nodes;
         ++u
      ) {
+        p.printIncrement();
         for(
             EdgeIterator e1 = m_node_based_graph->BeginEdges(u),
                 last_edge = m_node_based_graph->EndEdges(u);
@@ -325,6 +335,12 @@ void EdgeBasedGraphFactory::Run(
         }
     }
 
+    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(),
@@ -341,6 +357,7 @@ void EdgeBasedGraphFactory::Run(
     //Loop over all turns and generate new set of edges.
     //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();

Contractor/EdgeBasedGraphFactory.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.
+
+*/
 
 //  This class constructs the edge-expanded routing graph
 
@@ -26,6 +33,7 @@
 #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"
@@ -49,51 +57,6 @@
 
 class EdgeBasedGraphFactory : boost::noncopyable {
 public:
-    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;
-    };
-
     struct SpeedProfileProperties{
         SpeedProfileProperties() :
             trafficSignalPenalty(0),

Contractor/TemporaryStorage.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 "TemporaryStorage.h"
 

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_

DataStructures/BinaryHeap.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 BINARYHEAP_H_INCLUDED
 #define BINARYHEAP_H_INCLUDED
@@ -25,7 +32,7 @@ or see http://www.gnu.org/licenses/agpl.txt.
 
 #include <boost/unordered_map.hpp>
 
-#include <cassert>
+#include <boost/assert.hpp>
 
 #include <algorithm>
 #include <limits>
@@ -125,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());
@@ -148,7 +159,7 @@ public:
     }
 
     bool WasRemoved( const NodeID node ) {
-        assert( WasInserted( node ) );
+        BOOST_ASSERT( WasInserted( node ) );
         const Key index = nodeIndex[node];
         return insertedNodes[index].key == 0;
     }
@@ -161,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();
@@ -185,10 +196,10 @@ public:
     }
 
     void DecreaseKey( NodeID node, Weight weight ) {
-        assert( UINT_MAX != node );
+        BOOST_ASSERT( UINT_MAX != node );
         const Key & index = nodeIndex[node];
         Key & key = insertedNodes[index].key;
-        assert ( key >= 0 );
+        BOOST_ASSERT ( key >= 0 );
 
         insertedNodes[index].weight = weight;
         heap[key].weight = weight;
@@ -246,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;
@@ -260,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,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 FIXED_POINT_COORDINATE_H_
 #define FIXED_POINT_COORDINATE_H_
@@ -24,7 +31,7 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #include "../DataStructures/MercatorUtil.h"
 #include "../Util/StringUtil.h"
 
-#include <cassert>
+#include <boost/assert.hpp>
 #include <cmath>
 #include <climits>
 
@@ -67,10 +74,10 @@ inline std::ostream & operator<<(std::ostream & out, const FixedPointCoordinate
 }
 
 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/COORDINATE_PRECISION;
     double ln1 = lon1/COORDINATE_PRECISION;
@@ -99,10 +106,10 @@ inline double ApproximateDistance(const FixedPointCoordinate &c1, const FixedPoi
 }
 
 inline double ApproximateEuclideanDistance(const FixedPointCoordinate &c1, const FixedPointCoordinate &c2) {
-    assert(c1.lat != INT_MIN);
-    assert(c1.lon != INT_MIN);
-    assert(c2.lat != INT_MIN);
-    assert(c2.lon != INT_MIN);
+    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/COORDINATE_PRECISION)*RAD;
     const double lon1 = (c1.lon/COORDINATE_PRECISION)*RAD;
@@ -118,8 +125,8 @@ inline double ApproximateEuclideanDistance(const FixedPointCoordinate &c1, const
 
 static inline void convertInternalLatLonToString(const int value, std::string & output) {
     char buffer[100];
-    buffer[10] = 0; // Nullterminierung
-    char* string = printInt< 10, 6 >( buffer, value );
+    buffer[11] = 0; // zero termination
+    char* string = printInt< 11, 6 >( buffer, value );
     output = string;
 }
 

DataStructures/DeallocatingVector.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 DEALLOCATINGVECTOR_H_
 #define DEALLOCATINGVECTOR_H_
 
-#include <cassert>
+#include <boost/assert.hpp>
+#include <cstring>
 #include <vector>
 
 #if __cplusplus > 199711L
@@ -40,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 std::size_t idx, const std::vector<ElementT *> & input_list) : mData(ptr), mIndex(idx), mBucketList(input_list) {}
-        explicit DeallocatingVectorIteratorState(const std::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;
         std::size_t mIndex;
         std::vector<ElementT *> & mBucketList;
 
-        inline void setPointerForIndex() {
-            if(bucketSizeC*mBucketList.size() <= mIndex) {
-                mData = DEALLOCATION_VECTOR_NULL_PTR;
-                return;
-            }
-            std::size_t _bucket = mIndex/bucketSizeC;
-            std::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,66 +99,69 @@ public:
     DeallocatingVectorIterator(const DeallocatingVectorIterator<T2> & r) : mState(r.mState) {}
 
     DeallocatingVectorIterator(std::size_t idx, std::vector<ElementT *> & input_list) : mState(idx, input_list) {}
-    //DeallocatingVectorIterator(std::size_t idx, const 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) {
@@ -174,12 +172,20 @@ 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;
     }
 };

DataStructures/DynamicGraph.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 DYNAMICGRAPH_H_INCLUDED
 #define 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/HashTable.h

@@ -1,25 +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.
 
-  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_
@@ -36,6 +40,11 @@ public:
 
     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){
         super::insert(std::make_pair(key, value));
     }

DataStructures/HilbertValue.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 HILBERTVALUE_H_
 #define HILBERTVALUE_H_

DataStructures/ImportEdge.h

@@ -1,33 +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:
 
-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 EDGE_H
-#define EDGE_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 IMPORT_EDGE_H
+#define IMPORT_EDGE_H
 
 #include "../Util/OSRMException.h"
-#include <cassert>
+#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()) {
@@ -58,9 +66,9 @@ public:
         _target(t),
         _name(n),
         _weight(w),
+        _type(ty),
         forward(f),
         backward(b),
-        _type(ty),
         _roundabout(ra),
         _ignoreInGrid(ig),
         _accessRestricted(ar),
@@ -71,42 +79,41 @@ public:
         }
     }
 
-    NodeID target() const {return _target; }
-    NodeID source() const {return _source; }
-    NodeID name() const { return _name; }
-    EdgeWeight weight() const {return _weight; }
+    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; }
 
-    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; }
-    bool isContraFlow() const { return _contraFlow; }
-
-    NodeID _source;
-    NodeID _target;
-    NodeID _name;
-    EdgeWeight _weight;
-    bool forward;
-    bool backward;
-    short _type;
-    bool _roundabout;
-    bool _ignoreInGrid;
-    bool _accessRestricted;
-    bool _contraFlow;
+    //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;
 
 private:
-    /** 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), _contraFlow(false) { assert(false); } //shall not be used.
-
+    NodeBasedEdge() { }
 };
 
 class EdgeBasedEdge {
-public:
 
+public:
     bool operator< (const EdgeBasedEdge& e) const {
         if (source() == e.source()) {
             if (target() == e.target()) {
@@ -141,7 +148,14 @@ public:
         m_backward(false)
     { }
 
-    explicit EdgeBasedEdge(const NodeID s, const NodeID t, const NodeID v, const EdgeWeight w, const bool f, const bool 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),
@@ -150,21 +164,22 @@ public:
         m_backward(b)
     {}
 
-    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      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;  }
+
 private:
-    NodeID m_source;
-    NodeID m_target;
-    NodeID m_edgeID;
-    EdgeWeight m_weight:30;
-    bool m_forward:1;
-    bool m_backward:1;
+    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,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 IMPORTNODE_H_
 #define IMPORTNODE_H_
@@ -25,15 +32,31 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #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,7 +65,7 @@ struct _Node : NodeInfo{
     bool trafficLight;
 };
 
-struct ImportNode : public _Node {
+struct ImportNode : public ExternalMemoryNode {
     HashTable<std::string, std::string> keyVals;
 
 	inline void Clear() {

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

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

@@ -1,21 +1,28 @@
 /*
-    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 MERCATORUTIL_H_
@@ -28,11 +35,11 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #endif
 
 inline double y2lat(double a) {
-	return 180/M_PI * (2 * atan(exp(a*M_PI/180)) - M_PI/2);
+	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));
+	return 180./M_PI * log(tan(M_PI/4.+a*(M_PI/180.)/2.));
 }
 
 #endif /* MERCATORUTIL_H_ */

DataStructures/NodeInformationHelpDesk.h

@@ -1,204 +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 "QueryNode.h"
-#include "PhantomNodes.h"
-#include "StaticRTree.h"
-#include "../Contractor/EdgeBasedGraphFactory.h"
-#include "../Util/OSRMException.h"
-#include "../typedefs.h"
-
-#include <boost/assert.hpp>
-#include <boost/filesystem.hpp>
-#include <boost/filesystem/fstream.hpp>
-#include <boost/noncopyable.hpp>
-
-#include <iostream>
-#include <string>
-#include <vector>
-
-typedef EdgeBasedGraphFactory::EdgeBasedNode RTreeLeaf;
-
-class NodeInformationHelpDesk : boost::noncopyable {
-public:
-    NodeInformationHelpDesk(
-        const std::string & ramIndexInput,
-        const std::string & fileIndexInput,
-        const std::string & nodes_filename,
-        const std::string & edges_filename,
-        const unsigned number_of_nodes,
-        const unsigned check_sum
-    ) : number_of_nodes(number_of_nodes), check_sum(check_sum)
-    {
-        if ( ramIndexInput.empty() ) {
-            throw OSRMException("no ram index file name in server ini");
-        }
-        if ( fileIndexInput.empty() ) {
-            throw OSRMException("no mem index file name in server ini");
-        }
-        if ( nodes_filename.empty() ) {
-            throw OSRMException("no nodes file name in server ini");
-        }
-        if ( edges_filename.empty() ) {
-            throw OSRMException("no edges file name in server ini");
-        }
-
-        read_only_rtree = new StaticRTree<RTreeLeaf>(
-            ramIndexInput,
-            fileIndexInput
-        );
-        BOOST_ASSERT_MSG(
-            0 == coordinateVector.size(),
-            "Coordinate vector not empty"
-        );
-
-        LoadNodesAndEdges(nodes_filename, edges_filename);
-    }
-
-    //Todo: Shared memory mechanism
-	~NodeInformationHelpDesk() {
-		delete read_only_rtree;
-	}
-
-	inline int getLatitudeOfNode(const unsigned id) const {
-	    const NodeID node = origEdgeData_viaNode.at(id);
-	    return coordinateVector.at(node).lat;
-	}
-
-	inline int getLongitudeOfNode(const unsigned id) const {
-        const NodeID node = origEdgeData_viaNode.at(id);
-	    return coordinateVector.at(node).lon;
-	}
-
-	inline unsigned getNameIndexFromEdgeID(const unsigned id) const {
-	    return origEdgeData_nameID.at(id);
-	}
-
-    inline TurnInstruction getTurnInstructionFromEdgeID(const unsigned id) const {
-        return origEdgeData_turnInstruction.at(id);
-    }
-
-    inline NodeID getNumberOfNodes() const {
-        return number_of_nodes;
-    }
-
-	inline NodeID getNumberOfNodes2() const {
-        return coordinateVector.size();
-    }
-
-    inline bool FindNearestNodeCoordForLatLon(
-            const FixedPointCoordinate& input_coordinate,
-            FixedPointCoordinate& result,
-            const unsigned zoom_level = 18
-    ) const {
-        PhantomNode resulting_phantom_node;
-        bool foundNode = FindPhantomNodeForCoordinate(
-            input_coordinate,
-            resulting_phantom_node, zoom_level
-        );
-        result = resulting_phantom_node.location;
-        return foundNode;
-    }
-
-    inline bool FindPhantomNodeForCoordinate(
-            const FixedPointCoordinate & input_coordinate,
-            PhantomNode & resulting_phantom_node,
-            const unsigned zoom_level
-    ) const {
-        return read_only_rtree->FindPhantomNodeForCoordinate(
-                input_coordinate,
-                resulting_phantom_node,
-                zoom_level
-        );
-    }
-
-	inline unsigned GetCheckSum() const {
-	    return check_sum;
-	}
-
-private:
-    void LoadNodesAndEdges(
-        const std::string & nodes_filename,
-        const std::string & edges_filename
-    ) {
-        boost::filesystem::path nodes_file(nodes_filename);
-        if ( !boost::filesystem::exists( nodes_file ) ) {
-            throw OSRMException("nodes file does not exist");
-        }
-        if ( 0 == boost::filesystem::file_size( nodes_file ) ) {
-            throw OSRMException("nodes file is empty");
-        }
-
-        boost::filesystem::path edges_file(edges_filename);
-        if ( !boost::filesystem::exists( edges_file ) ) {
-            throw OSRMException("edges file does not exist");
-        }
-        if ( 0 == boost::filesystem::file_size( edges_file ) ) {
-            throw OSRMException("edges file is empty");
-        }
-
-        boost::filesystem::ifstream nodes_input_stream(nodes_file, std::ios::binary);
-        boost::filesystem::ifstream edges_input_stream(edges_file, std::ios::binary);
-
-        SimpleLogger().Write(logDEBUG) << "Loading node data";
-        NodeInfo b;
-        while(!nodes_input_stream.eof()) {
-            nodes_input_stream.read((char *)&b, sizeof(NodeInfo));
-            coordinateVector.push_back(FixedPointCoordinate(b.lat, b.lon));
-        }
-        std::vector<FixedPointCoordinate>(coordinateVector).swap(coordinateVector);
-        nodes_input_stream.close();
-
-        SimpleLogger().Write(logDEBUG) << "Loading edge data";
-        unsigned numberOfOrigEdges(0);
-        edges_input_stream.read((char*)&numberOfOrigEdges, sizeof(unsigned));
-        origEdgeData_viaNode.resize(numberOfOrigEdges);
-        origEdgeData_nameID.resize(numberOfOrigEdges);
-        origEdgeData_turnInstruction.resize(numberOfOrigEdges);
-
-        OriginalEdgeData deserialized_originalEdgeData;
-        for(unsigned i = 0; i < numberOfOrigEdges; ++i) {
-            edges_input_stream.read(
-                (char*)&(deserialized_originalEdgeData),
-                sizeof(OriginalEdgeData)
-            );
-            origEdgeData_viaNode[i] = deserialized_originalEdgeData.viaNode;
-            origEdgeData_nameID[i]  = deserialized_originalEdgeData.nameID;
-            origEdgeData_turnInstruction[i] = deserialized_originalEdgeData.turnInstruction;
-        }
-        edges_input_stream.close();
-        SimpleLogger().Write(logDEBUG) << "Loaded " << numberOfOrigEdges << " orig edges";
-        SimpleLogger().Write(logDEBUG) << "Opening NN indices";
-    }
-
-	std::vector<FixedPointCoordinate> coordinateVector;
-	std::vector<NodeID> origEdgeData_viaNode;
-	std::vector<unsigned> origEdgeData_nameID;
-	std::vector<TurnInstruction> origEdgeData_turnInstruction;
-
-	StaticRTree<EdgeBasedGraphFactory::EdgeBasedNode> * read_only_rtree;
-	const unsigned number_of_nodes;
-	const unsigned check_sum;
-};
-
-#endif /*NODEINFORMATIONHELPDESK_H_*/

DataStructures/Percent.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 PERCENT_H
 #define PERCENT_H
@@ -24,8 +31,7 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #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_
@@ -92,10 +99,4 @@ inline std::ostream& operator<<(std::ostream &out, const PhantomNode & pn){
     return out;
 }
 
-struct NodesOfEdge {
-    NodeID edgeBasedNode;
-    double ratio;
-    FixedPointCoordinate projectedPoint;
-};
-
 #endif /* PHANTOMNODES_H_ */

DataStructures/QueryEdge.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 QUERYEDGE_H_
 #define QUERYEDGE_H_

DataStructures/QueryNode.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 _NODE_COORDS_H
 #define _NODE_COORDS_H

DataStructures/RawRouteData.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 RAWROUTEDATA_H_
 #define RAWROUTEDATA_H_

DataStructures/Restriction.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 RESTRICTION_H_
 #define RESTRICTION_H_
@@ -68,13 +73,13 @@ struct TurnRestriction {
     }
 };
 
-struct _RawRestrictionContainer {
-    TurnRestriction restriction;
+struct InputRestrictionContainer {
     EdgeID fromWay;
     EdgeID toWay;
     unsigned viaNode;
+    TurnRestriction restriction;
 
-    _RawRestrictionContainer(
+    InputRestrictionContainer(
         EdgeID fromWay,
         EdgeID toWay,
         NodeID vn,
@@ -86,7 +91,7 @@ struct _RawRestrictionContainer {
     {
         restriction.viaNode = vn;
     }
-    _RawRestrictionContainer(
+    InputRestrictionContainer(
         bool isOnly = false
     ) :
         fromWay(UINT_MAX),
@@ -96,37 +101,45 @@ struct _RawRestrictionContainer {
         restriction.flags.isOnly = isOnly;
     }
 
-    static _RawRestrictionContainer min_value() {
-        return _RawRestrictionContainer(0, 0, 0, 0);
+    static InputRestrictionContainer min_value() {
+        return InputRestrictionContainer(0, 0, 0, 0);
     }
-    static _RawRestrictionContainer max_value() {
-        return _RawRestrictionContainer(UINT_MAX, UINT_MAX, UINT_MAX, UINT_MAX);
+    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();
     }
 };
 

DataStructures/SearchEngine.cpp

@@ -1,89 +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 "SearchEngine.h"
-
-SearchEngine::SearchEngine(
-    QueryGraph * g,
-    NodeInformationHelpDesk * nh,
-    std::vector<std::string> & n
-    ) :
-        _queryData(g, nh, n),
-        shortestPath(_queryData),
-        alternativePaths(_queryData)
-    {}
-    SearchEngine::~SearchEngine() {}
-
-void SearchEngine::GetCoordinatesForNodeID(
-    NodeID id,
-    FixedPointCoordinate& result
-    ) const {
-    result.lat = _queryData.nodeHelpDesk->getLatitudeOfNode(id);
-    result.lon = _queryData.nodeHelpDesk->getLongitudeOfNode(id);
-}
-
-void SearchEngine::FindPhantomNodeForCoordinate(
-    const FixedPointCoordinate & location,
-    PhantomNode & result,
-    const unsigned zoomLevel
-    ) const {
-    _queryData.nodeHelpDesk->FindPhantomNodeForCoordinate(
-        location,
-        result, zoomLevel
-    );
-}
-
-NodeID SearchEngine::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 QueryEdge::EdgeData ed = _queryData.graph->GetEdgeData(e);
-    return ed.id;
-}
-
-std::string SearchEngine::GetEscapedNameForNameID(const unsigned nameID) const {
-    bool is_name_invalid = (nameID >= _queryData.names.size() || nameID == 0);
-    if (is_name_invalid) {
-        return std::string("");
-    }
-
-    return HTMLEntitize(_queryData.names.at(nameID));
-}
-
-SearchEngineHeapPtr SearchEngineData::forwardHeap;
-SearchEngineHeapPtr SearchEngineData::backwardHeap;
-
-SearchEngineHeapPtr SearchEngineData::forwardHeap2;
-SearchEngineHeapPtr SearchEngineData::backwardHeap2;
-
-SearchEngineHeapPtr SearchEngineData::forwardHeap3;
-SearchEngineHeapPtr SearchEngineData::backwardHeap3;
-

DataStructures/SearchEngine.h

@@ -1,68 +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.
+
+*/
+
+#ifndef SEARCHENGINE_H
+#define SEARCHENGINE_H
 
 #include "Coordinate.h"
-#include "NodeInformationHelpDesk.h"
+#include "SearchEngineData.h"
 #include "PhantomNodes.h"
 #include "QueryEdge.h"
-#include "SearchEngineData.h"
 #include "../RoutingAlgorithms/AlternativePathRouting.h"
 #include "../RoutingAlgorithms/ShortestPathRouting.h"
 
 #include "../Util/StringUtil.h"
 #include "../typedefs.h"
 
+#include <boost/assert.hpp>
+
 #include <climits>
 #include <string>
 #include <vector>
 
+template<class DataFacadeT>
 class SearchEngine {
 private:
-    SearchEngineData _queryData;
-
+    DataFacadeT * facade;
+    SearchEngineData engine_working_data;
 public:
-    ShortestPathRouting<SearchEngineData> shortestPath;
-    AlternativeRouting<SearchEngineData> alternativePaths;
+    ShortestPathRouting<DataFacadeT> shortest_path;
+    AlternativeRouting <DataFacadeT> alternative_path;
 
-    SearchEngine(
-        QueryGraph * g,
-        NodeInformationHelpDesk * nh,
-        std::vector<std::string> & n
-    );
-	~SearchEngine();
+    SearchEngine( DataFacadeT * facade )
+     :
+        facade             (facade),
+        shortest_path      (facade, engine_working_data),
+        alternative_path   (facade, engine_working_data)
+    {}
 
-	void GetCoordinatesForNodeID(NodeID id, FixedPointCoordinate& result) const;
+    ~SearchEngine() {}
 
-    void FindPhantomNodeForCoordinate(
-        const FixedPointCoordinate & location,
-        PhantomNode & result,
-        unsigned zoomLevel
-    ) const;
-
-    NodeID GetNameIDForOriginDestinationNodeID(
-        const NodeID s, const NodeID t) const;
-
-    std::string GetEscapedNameForNameID(const unsigned nameID) const;
 };
 
-#endif /* SEARCHENGINE_H_ */
+#endif // SEARCHENGINE_H

DataStructures/SearchEngineData.cpp

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

DataStructures/SearchEngineData.h

@@ -1,26 +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 SEARCH_ENGINE_DATA_H
+#define SEARCH_ENGINE_DATA_H
 
 #include "BinaryHeap.h"
 #include "QueryEdge.h"
-#include "NodeInformationHelpDesk.h"
 #include "StaticGraph.h"
 
 #include "../typedefs.h"
@@ -34,17 +43,13 @@ struct _HeapData {
     NodeID parent;
     _HeapData( NodeID p ) : parent(p) { }
 };
-typedef StaticGraph<QueryEdge::EdgeData> QueryGraph;
-typedef BinaryHeap< NodeID, NodeID, int, _HeapData, UnorderedMapStorage<NodeID, int> > QueryHeapType;
-typedef boost::thread_specific_ptr<QueryHeapType> SearchEngineHeapPtr;
+
+// typedef StaticGraph<QueryEdge::EdgeData> QueryGraph;
 
 struct SearchEngineData {
-    typedef QueryGraph Graph;
-    typedef QueryHeapType QueryHeap;
-    SearchEngineData(QueryGraph * g, NodeInformationHelpDesk * nh, std::vector<std::string> & n) :graph(g), nodeHelpDesk(nh), names(n) {}
-    const QueryGraph * graph;
-    NodeInformationHelpDesk * nodeHelpDesk;
-    std::vector<std::string> & names;
+    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;
@@ -52,9 +57,11 @@ struct SearchEngineData {
     static SearchEngineHeapPtr forwardHeap3;
     static SearchEngineHeapPtr backwardHeap3;
 
-    void InitializeOrClearFirstThreadLocalStorage();
+    void InitializeOrClearFirstThreadLocalStorage(const unsigned number_of_nodes);
 
-    void InitializeOrClearSecondThreadLocalStorage();
+    void InitializeOrClearSecondThreadLocalStorage(const unsigned number_of_nodes);
 
-    void InitializeOrClearThirdThreadLocalStorage();
+    void InitializeOrClearThirdThreadLocalStorage(const unsigned number_of_nodes);
 };
+
+#endif // SEARCH_ENGINE_DATA_H

DataStructures/SegmentInformation.h

@@ -1,26 +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.
+
+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"
 

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 "../DataStructures/Percent.h"
+#include "../DataStructures/SharedMemoryVectorWrapper.h"
 #include "../Util/SimpleLogger.h"
 #include "../typedefs.h"
 
 #include <algorithm>
 #include <vector>
 
-template< typename EdgeDataT>
+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) {
@@ -128,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++ ) {
@@ -166,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;
     }
@@ -186,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

@@ -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:
 
-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 STATICRTREE_H_
 #define STATICRTREE_H_
 
-#include "MercatorUtil.h"
 #include "Coordinate.h"
-#include "PhantomNodes.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"
@@ -41,12 +51,10 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #include <boost/range/algorithm_ext/erase.hpp>
 #include <boost/noncopyable.hpp>
 #include <boost/thread.hpp>
-
-#include <cassert>
-#include <cfloat>
-#include <climits>
+#include <boost/type_traits.hpp>
 
 #include <algorithm>
+#include <limits>
 #include <queue>
 #include <string>
 #include <vector>
@@ -59,9 +67,9 @@ const static uint32_t RTREE_LEAF_NODE_SIZE = 1170;
 
 static boost::thread_specific_ptr<boost::filesystem::ifstream> thread_local_rtree_stream;
 
-template<class DataT>
+template<class DataT, bool UseSharedMemory = false>
 class StaticRTree : boost::noncopyable {
-private:
+public:
     struct RectangleInt2D {
         RectangleInt2D() :
             min_lon(INT_MAX),
@@ -129,7 +137,7 @@ private:
                 return 0.0;
             }
 
-            double min_dist = DBL_MAX;
+            double min_dist = std::numeric_limits<double>::max();
             min_dist = std::min(
                     min_dist,
                     ApproximateDistance(
@@ -170,7 +178,7 @@ private:
         }
 
         inline double GetMinMaxDist(const FixedPointCoordinate & location) const {
-            double min_max_dist = DBL_MAX;
+            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);
@@ -233,6 +241,16 @@ private:
 
     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,
@@ -255,20 +273,12 @@ private:
         DataT objects[RTREE_LEAF_NODE_SIZE];
     };
 
-    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];
-    };
-
     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(DBL_MAX) {}
+        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 {
@@ -276,7 +286,7 @@ private:
         }
     };
 
-    std::vector<TreeNode> m_search_tree;
+    typename ShM<TreeNode, UseSharedMemory>::vector m_search_tree;
     uint64_t m_element_count;
 
     const std::string m_leaf_node_filename;
@@ -410,11 +420,10 @@ public:
 
     //Read-only operation for queries
     explicit StaticRTree(
-            const std::string & node_filename,
-            const std::string & leaf_filename
-    ) : m_leaf_node_filename(leaf_filename) {
+            const boost::filesystem::path & node_file,
+            const boost::filesystem::path & leaf_file
+    ) : m_leaf_node_filename(leaf_file.string()) {
         //open tree node file and load into RAM.
-        boost::filesystem::path node_file(node_filename);
 
         if ( !boost::filesystem::exists( node_file ) ) {
             throw OSRMException("ram index file does not exist");
@@ -430,9 +439,7 @@ public:
         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
-        boost::filesystem::path leaf_file(leaf_filename);
         if ( !boost::filesystem::exists( leaf_file ) ) {
             throw OSRMException("mem index file does not exist");
         }
@@ -447,6 +454,34 @@ public:
         //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,
@@ -461,8 +496,8 @@ public:
         uint32_t io_count = 0;
         uint32_t explored_tree_nodes_count = 0;
         SimpleLogger().Write() << "searching for coordinate " << input_coordinate;
-        double min_dist = DBL_MAX;
-        double min_max_dist = DBL_MAX;
+        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;
@@ -470,7 +505,7 @@ public:
         //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(FLT_EPSILON > (0. - traversal_queue.top().min_dist), "Root element in NN Search has min dist != 0.");
+        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();
@@ -595,6 +630,113 @@ public:
     }
 
   */
+    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,
@@ -607,8 +749,8 @@ public:
         uint32_t io_count = 0;
         uint32_t explored_tree_nodes_count = 0;
         //SimpleLogger().Write() << "searching for coordinate " << input_coordinate;
-        double min_dist = DBL_MAX;
-        double min_max_dist = DBL_MAX;
+        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;
@@ -621,8 +763,8 @@ public:
         );
 
         BOOST_ASSERT_MSG(
-                         FLT_EPSILON > (0. - traversal_queue.top().min_dist),
-                         "Root element in NN Search has min dist != 0."
+            std::numeric_limits<double>::epsilon() > (0. - traversal_queue.top().min_dist),
+            "Root element in NN Search has min dist != 0."
         );
 
         while(!traversal_queue.empty()) {
@@ -637,7 +779,6 @@ public:
                     LeafNode current_leaf_node;
                     LoadLeafFromDisk(current_tree_node.children[0], current_leaf_node);
                     ++io_count;
-                    //SimpleLogger().Write() << "checking " << current_leaf_node.object_count << " elements";
                     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) {
@@ -691,16 +832,14 @@ public:
                                 current_end_coordinate
                             )
                         ) {
+
                             BOOST_ASSERT_MSG(current_edge.id != result_phantom_node.edgeBasedNode, "IDs not different");
-                            //SimpleLogger().Write() << "found bidirected edge on nodes " << current_edge.id << " and " << result_phantom_node.edgeBasedNode;
                             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);
-                            //    SimpleLogger().Write() <<"case 2";
                             }
-                            //SimpleLogger().Write() << "w1: " << result_phantom_node.weight1 << ", w2: " << result_phantom_node.weight2;
                         }
                     }
                 } else {
@@ -748,9 +887,13 @@ public:
         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()) {
+        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,
@@ -772,14 +915,14 @@ private:
             const FixedPointCoordinate& source,
             const FixedPointCoordinate& target,
             FixedPointCoordinate& nearest, double *r) const {
-        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);
+        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(fabs(a-c) > FLT_EPSILON){
+        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);
@@ -809,8 +952,8 @@ private:
 //            return std::sqrt(((d - y)*(d - y) + (c - x)*(c - x)));
         }
         // point lies in between
-        nearest.lat = p;
-        nearest.lon = q;
+        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);
     }
@@ -820,7 +963,7 @@ private:
     }
 
     inline bool DoubleEpsilonCompare(const double d1, const double d2) const {
-        return (std::fabs(d1 - d2) < FLT_EPSILON);
+        return (std::fabs(d1 - d2) < std::numeric_limits<double>::epsilon() );
     }
 
 };

DataStructures/TurnInstructions.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 TURNINSTRUCTIONS_H_
 #define TURNINSTRUCTIONS_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_

DataStructures/XORFastHashStorage.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 XORFASTHASHSTORAGE_H_
 #define XORFASTHASHSTORAGE_H_

Descriptors/BaseDescriptor.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 BASE_DESCRIPTOR_H_
 #define BASE_DESCRIPTOR_H_
@@ -24,33 +31,42 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #include "../DataStructures/HashTable.h"
 #include "../DataStructures/PhantomNodes.h"
 #include "../DataStructures/RawRouteData.h"
-#include "../DataStructures/SearchEngine.h"
-#include "../Server/BasicDatastructures.h"
+#include "../Server/Http/Reply.h"
 #include "../Util/StringUtil.h"
 #include "../typedefs.h"
 
-#include <cassert>
 #include <cmath>
 #include <cstdio>
 
 #include <string>
 #include <vector>
 
-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 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, SearchEngine &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"
 
@@ -38,31 +45,47 @@ double DescriptionFactory::GetBearing(
 ) const {
     double deltaLong = DegreeToRadian(B.lon/COORDINATE_PRECISION - A.lon/COORDINATE_PRECISION);
 
-    double lat1 = DegreeToRadian(A.lat/COORDINATE_PRECISION);
-    double lat2 = DegreeToRadian(B.lat/COORDINATE_PRECISION);
+    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 FixedPointCoordinate & 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 {
@@ -70,144 +93,161 @@ void DescriptionFactory::AppendSegment(const FixedPointCoordinate & coordinate,
     }
 }
 
-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 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: " << 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;
-            //            SimpleLogger().Write() << "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;
-            //            SimpleLogger().Write() << "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,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 DESCRIPTIONFACTORY_H_
 #define DESCRIPTIONFACTORY_H_
@@ -24,32 +31,43 @@
 #include "../Algorithms/DouglasPeucker.h"
 #include "../Algorithms/PolylineCompressor.h"
 #include "../DataStructures/Coordinate.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;
+    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
             intToString(round(distance), lengthString);
             int travelTime = time/10 + 1;
@@ -64,14 +82,139 @@ public:
     DescriptionFactory();
     virtual ~DescriptionFactory();
     double GetBearing(const FixedPointCoordinate& C, const FixedPointCoordinate& B) const;
-    void AppendEncodedPolylineString(std::string &output);
-    void AppendUnencodedPolylineString(std::string &output);
+    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 SearchEngine &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,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 GPX_DESCRIPTOR_H_
 #define GPX_DESCRIPTOR_H_
@@ -25,42 +32,72 @@ or see http://www.gnu.org/licenses/agpl.txt.
 
 #include <boost/foreach.hpp>
 
-class GPXDescriptor : public BaseDescriptor{
+template<class DataFacadeT>
+class GPXDescriptor : public BaseDescriptor<DataFacadeT> {
 private:
-    _DescriptorConfig config;
+    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, SearchEngine &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 += "<metadata><copyright author=\"Project OSRM\"><license>Data (c) OpenStreetMap contributors (ODbL)</license></copyright></metadata>";
-        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(const _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,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 JSON_DESCRIPTOR_H_
 #define JSON_DESCRIPTOR_H_
@@ -34,32 +41,33 @@ or see http://www.gnu.org/licenses/agpl.txt.
 
 #include <algorithm>
 
-class JSONDescriptor : public BaseDescriptor{
+template<class DataFacadeT>
+class JSONDescriptor : public BaseDescriptor<DataFacadeT> {
 private:
-    _DescriptorConfig config;
-    DescriptionFactory descriptionFactory;
+    DescriptorConfig config;
+    DescriptionFactory description_factory;
     DescriptionFactory alternateDescriptionFactory;
     FixedPointCoordinate current;
-    unsigned numberOfEnteredRestrictedAreas;
+    unsigned entered_restricted_area_count;
     struct RoundAbout{
         RoundAbout() :
-            startIndex(INT_MAX),
-            nameID(INT_MAX),
-            leaveAtExit(INT_MAX)
+            start_index(INT_MAX),
+            name_id(INT_MAX),
+            leave_at_exit(INT_MAX)
         {}
-        int startIndex;
-        int nameID;
-        int leaveAtExit;
+        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;
@@ -69,207 +77,246 @@ 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, SearchEngine &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, const SearchEngine &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) );
+            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].nameID == shortestSegments[0].nameID) {
+                while( i < size_of_difference && shortestDifference[i].name_id == shortest_path_segments[0].name_id) {
                     ++i;
                 }
                 if(i < size_of_difference ) {
@@ -277,11 +324,11 @@ public:
                 }
             }
 
-            std::set_difference(alternativeSegments.begin(), alternativeSegments.end(), shortestSegments.begin(), shortestSegments.end(), alternativeDifference.begin(), boost::bind(&Segment::nameID, _1) < boost::bind(&Segment::nameID, _2) );
+            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].nameID == alternativeSegments[0].nameID) {
+                while( i < size_of_difference && alternativeDifference[i].name_id == alternative_path_segments[0].name_id) {
                     ++i;
                 }
                 if(i < size_of_difference ) {
@@ -294,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 SearchEngine &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

@@ -1,21 +1,28 @@
 /*
-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.
 */
 
 #include "BaseParser.h"
@@ -72,13 +79,10 @@ void BaseParser::ParseNodeInLua(ImportNode& n, lua_State* localLuaState) {
 }
 
 void BaseParser::ParseWayInLua(ExtractionWay& w, lua_State* localLuaState) {
-    if(2 > w.path.size()) {
-        return;
-    }
     luabind::call_function<void>( localLuaState, "way_function", boost::ref(w) );
 }
 
-bool BaseParser::ShouldIgnoreRestriction(const std::string& except_tag_string) const {
+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]

Extractor/BaseParser.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 BASEPARSER_H_
 #define BASEPARSER_H_

Extractor/ExtractionContainers.cpp

@@ -1,308 +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 & output_file_name, 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;
 
         std::cout << "[extractor] Sorting used nodes        ... " << std::flush;
-        stxxl::sort(usedNodeIDs.begin(), usedNodeIDs.end(), Cmp(), memory_to_use);
+        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();
         std::cout << "[extractor] Erasing duplicate nodes   ... " << std::flush;
-        stxxl::vector<NodeID>::iterator NewEnd = std::unique ( usedNodeIDs.begin(),usedNodeIDs.end() ) ;
-        usedNodeIDs.resize ( NewEnd - usedNodeIDs.begin() );
+        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();
 
         std::cout << "[extractor] Sorting all nodes         ... " << std::flush;
-        stxxl::sort(allNodes.begin(), allNodes.end(), CmpNodeByID(), memory_to_use);
+        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();
 
         std::cout << "[extractor] Sorting used ways         ... " << std::flush;
-        stxxl::sort(wayStartEndVector.begin(), wayStartEndVector.end(), CmpWayByID(), memory_to_use);
+        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;
 
         std::cout << "[extractor] Sorting restrctns. by from... " << std::flush;
-        stxxl::sort(restrictionsVector.begin(), restrictionsVector.end(), CmpRestrictionContainerByFrom(), memory_to_use);
+        stxxl::sort(
+            restrictions_list.begin(),
+            restrictions_list.end(),
+            CmpRestrictionContainerByFrom(),
+            4294967296
+        );
         std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl;
 
         std::cout << "[extractor] Fixing restriction starts ... " << std::flush;
-        STXXLRestrictionsVector::iterator restrictionsIT = restrictionsVector.begin();
-        STXXLWayIDStartEndVector::iterator wayStartAndEndEdgeIT = wayStartEndVector.begin();
+        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;
         }
 
         std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl;
         time = get_timestamp();
 
         std::cout << "[extractor] Sorting restrctns. by to  ... " << std::flush;
-        stxxl::sort(restrictionsVector.begin(), restrictionsVector.end(), CmpRestrictionContainerByTo(), memory_to_use);
+        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);
         std::cout << "[extractor] Fixing restriction ends   ... " << std::flush;
-        restrictionsIT = restrictionsVector.begin();
-        wayStartAndEndEdgeIT = wayStartEndVector.begin();
-        while(wayStartAndEndEdgeIT != wayStartEndVector.end() && restrictionsIT != restrictionsVector.end()) {
-            if(wayStartAndEndEdgeIT->wayID < restrictionsIT->toWay){
-                ++wayStartAndEndEdgeIT;
+        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;
         }
         std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl;
         SimpleLogger().Write() << "usable restrictions: " << usableRestrictionsCounter;
         //serialize restrictions
-        std::ofstream restrictionsOutstream;
-        restrictionsOutstream.open(restrictionsFileName.c_str(), std::ios::binary);
-        restrictionsOutstream.write((char*)&uuid, sizeof(UUID));
-        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(TurnRestriction));
+        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();
 
-        std::ofstream fout;
-        fout.open(output_file_name.c_str(), std::ios::binary);
-        fout.write((char*)&uuid, sizeof(UUID));
-        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();
         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;
         }
 
         std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl;
 
         std::cout << "[extractor] setting number of nodes   ... " << std::flush;
-        std::ios::pos_type positionInFile = fout.tellp();
-        fout.seekp(std::ios::beg+sizeof(UUID));
-        fout.write((char*)&usedNodeCounter, sizeof(unsigned));
-        fout.seekp(positionInFile);
+        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);
 
         std::cout << "ok" << std::endl;
         time = get_timestamp();
 
         // Sort edges by start.
         std::cout << "[extractor] Sorting edges by start    ... " << std::flush;
-        stxxl::sort(allEdges.begin(), allEdges.end(), CmpEdgeByStartID(), memory_to_use);
+        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();
 
         std::cout << "[extractor] Setting start coords      ... " << std::flush;
-        fout.write((char*)&usedEdgeCounter, sizeof(unsigned));
+        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;
         }
         std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl;
         time = get_timestamp();
 
         // Sort Edges by target
         std::cout << "[extractor] Sorting edges by target   ... " << std::flush;
-        stxxl::sort(allEdges.begin(), allEdges.end(), CmpEdgeByTargetID(), memory_to_use);
+        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();
 
         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 ExtractionWay::notSure:
-                        fout.write((char*)&zero, sizeof(short));
-                        break;
-                    case ExtractionWay::oneway:
-                        fout.write((char*)&one, sizeof(short));
-                        break;
-                    case ExtractionWay::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 ExtractionWay::opposite:
-                        fout.write((char*)&one, sizeof(short));
-                        break;
-                    default:
-                      std::cerr << "[error] edge with no direction: " << edgeIT->direction << std::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));
-                    fout.write((char*)&edgeIT->isContraFlow, sizeof(bool));
-                    ++usedEdgeCounter;
+                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;
                 }
-                ++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;
         }
         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();
+        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();
-        std::cout << "[extractor] writing street name index ... " << std::flush;
-        std::string nameOutFileName = (output_file_name + ".names");
-        std::ofstream nameOutFile(nameOutFileName.c_str(), std::ios::binary);
-        unsigned sizeOfNameIndex = nameVector.size();
-        nameOutFile.write((char *)&(sizeOfNameIndex), sizeof(unsigned));
 
-        BOOST_FOREACH(const std::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();
+        name_file_stream.close();
         std::cout << "ok, after " << get_timestamp() - time << "s" << std::endl;
-
-        //        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;
-
-        SimpleLogger().Write() << "Processed " << usedNodeCounter << " nodes and " << usedEdgeCounter << " edges";
-
+        SimpleLogger().Write() << "Processed " <<
+            number_of_used_nodes << " nodes and " <<
+            number_of_used_edges << " edges";
 
     } catch ( const std::exception& e ) {
-      std::cerr <<  "Caught Execption:" << e.what() << std::endl;
+        std::cerr <<  "Caught Execption:" << e.what() << std::endl;
     }
 }
 

Extractor/ExtractionContainers.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 EXTRACTIONCONTAINERS_H_
 #define EXTRACTIONCONTAINERS_H_
@@ -26,42 +33,50 @@
 #include "../Util/TimingUtil.h"
 #include "../Util/UUID.h"
 
+#include <boost/assert.hpp>
 #include <boost/foreach.hpp>
-#include <stxxl.h>
+#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<InternalExtractorEdge> 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
-        stxxl::vector<unsigned> testForRunningInstance;
-        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 & output_file_name, const std::string restrictionsFileName, const unsigned amountOfRAM);
-
-    STXXLNodeIDVector           usedNodeIDs;
-    STXXLNodeVector             allNodes;
-    STXXLEdgeVector             allEdges;
-    STXXLStringVector           nameVector;
-    STXXLRestrictionsVector     restrictionsVector;
-    STXXLWayIDStartEndVector    wayStartEndVector;
-    const UUID uuid;
+    void PrepareData(
+        const std::string & output_file_name,
+        const std::string & restrictions_file_name
+    );
 };
 
 #endif /* EXTRACTIONCONTAINERS_H_ */

Extractor/ExtractionHelperFunctions.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 EXTRACTIONHELPERFUNCTIONS_H_
 #define EXTRACTIONHELPERFUNCTIONS_H_

Extractor/ExtractorCallbacks.cpp

@@ -1,23 +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 "ExtractorCallbacks.h"
 
@@ -30,14 +36,14 @@ ExtractorCallbacks::ExtractorCallbacks(ExtractionContainers * ext, StringMap * s
 ExtractorCallbacks::~ExtractorCallbacks() { }
 
 /** warning: caller needs to take care of synchronization! */
-void ExtractorCallbacks::nodeFunction(const _Node &n) {
+void ExtractorCallbacks::nodeFunction(const ExternalMemoryNode &n) {
     if(n.lat <= 85*COORDINATE_PRECISION && n.lat >= -85*COORDINATE_PRECISION) {
-        externalMemory->allNodes.push_back(n);
+        externalMemory->all_nodes_list.push_back(n);
     }
 }
 
-bool ExtractorCallbacks::restrictionFunction(const _RawRestrictionContainer &r) {
-    externalMemory->restrictionsVector.push_back(r);
+bool ExtractorCallbacks::restrictionFunction(const InputRestrictionContainer &r) {
+    externalMemory->restrictions_list.push_back(r);
     return true;
 }
 
@@ -56,7 +62,7 @@ void ExtractorCallbacks::wayFunction(ExtractionWay &parsed_way) {
             parsed_way.speed = parsed_way.duration/(parsed_way.path.size()-1);
         }
 
-        if(FLT_EPSILON >= fabs(-1. - parsed_way.speed)){
+        if(std::numeric_limits<double>::epsilon() >= fabs(-1. - parsed_way.speed)){
             SimpleLogger().Write(logDEBUG) <<
                 "found way with bogus speed, id: " << parsed_way.id;
             return;
@@ -65,8 +71,8 @@ void ExtractorCallbacks::wayFunction(ExtractionWay &parsed_way) {
         //Get the unique identifier for the street name
         const StringMap::const_iterator string_map_iterator = stringMap->find(parsed_way.name);
         if(stringMap->end() == string_map_iterator) {
-            parsed_way.nameID = externalMemory->nameVector.size();
-            externalMemory->nameVector.push_back(parsed_way.name);
+            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 {
             parsed_way.nameID = string_map_iterator->second;
@@ -80,7 +86,7 @@ void ExtractorCallbacks::wayFunction(ExtractionWay &parsed_way) {
         const bool split_bidirectional_edge = (parsed_way.backward_speed > 0) && (parsed_way.speed != parsed_way.backward_speed);
 
         for(std::vector< NodeID >::size_type n = 0; n < parsed_way.path.size()-1; ++n) {
-            externalMemory->allEdges.push_back(
+            externalMemory->all_edges_list.push_back(
                     InternalExtractorEdge(parsed_way.path[n],
                             parsed_way.path[n+1],
                             parsed_way.type,
@@ -93,17 +99,17 @@ void ExtractorCallbacks::wayFunction(ExtractionWay &parsed_way) {
                             parsed_way.isAccessRestricted
                     )
             );
-            externalMemory->usedNodeIDs.push_back(parsed_way.path[n]);
+            externalMemory->used_node_id_list.push_back(parsed_way.path[n]);
         }
-        externalMemory->usedNodeIDs.push_back(parsed_way.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(parsed_way.id, parsed_way.path[0], parsed_way.path[1], parsed_way.path[parsed_way.path.size()-2], parsed_way.path.back()));
+        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->allEdges.push_back(
+                externalMemory->all_edges_list.push_back(
                         InternalExtractorEdge(parsed_way.path[n],
                                 parsed_way.path[n+1],
                                 parsed_way.type,
@@ -118,7 +124,7 @@ void ExtractorCallbacks::wayFunction(ExtractionWay &parsed_way) {
                         )
                 );
             }
-            externalMemory->wayStartEndVector.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()));
+            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()));
         }
     }
 }

Extractor/ExtractorCallbacks.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 EXTRACTORCALLBACKS_H_
 #define EXTRACTORCALLBACKS_H_
@@ -48,9 +55,9 @@ public:
     ~ExtractorCallbacks();
 
     /** warning: caller needs to take care of synchronization! */
-    void nodeFunction(const _Node &n);
+    void nodeFunction(const ExternalMemoryNode &n);
 
-    bool restrictionFunction(const _RawRestrictionContainer &r);
+    bool restrictionFunction(const InputRestrictionContainer &r);
 
     /** warning: caller needs to take care of synchronization! */
     void wayFunction(ExtractionWay &w);

Extractor/ExtractorStructs.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 EXTRACTORSTRUCTS_H_
 #define EXTRACTORSTRUCTS_H_
@@ -154,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() {
@@ -165,16 +172,19 @@ 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();
     }
 };
 

Extractor/PBFParser.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 "PBFParser.h"
 
@@ -173,14 +180,14 @@ inline void PBFParser::parseDenseNode(_ThreadData * threadData) {
 		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 ) {
+			if( 0 == tagValue ) {
 				++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();
-			extracted_nodes_vector[i].keyVals.insert(std::make_pair(key, value));
+			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;
 		}
 	}
@@ -191,7 +198,7 @@ inline void PBFParser::parseDenseNode(_ThreadData * threadData) {
 	    ParseNodeInLua( n, scriptingEnvironment.getLuaStateForThreadID(omp_get_thread_num()) );
 	}
 
-	BOOST_FOREACH(ImportNode &n, extracted_nodes_vector) {
+	BOOST_FOREACH(const ImportNode &n, extracted_nodes_vector) {
 	    extractor_callbacks->nodeFunction(n);
 	}
 }
@@ -209,7 +216,8 @@ inline void PBFParser::parseRelation(_ThreadData * threadData) {
 		return;
 	}
 	const OSMPBF::PrimitiveGroup& group = threadData->PBFprimitiveBlock.primitivegroup( threadData->currentGroupID );
-	for(int i = 0; i < group.relations_size(); ++i ) {
+
+	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;
@@ -240,9 +248,13 @@ inline void PBFParser::parseRelation(_ThreadData * threadData) {
 
 		if(isRestriction) {
 			int64_t 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());
+			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)) {
@@ -280,7 +292,6 @@ inline void PBFParser::parseRelation(_ThreadData * threadData) {
 					break;
 
 				default: //should not happen
-					//cout << "unknown";
 					assert(false);
 					break;
 				}
@@ -309,17 +320,23 @@ inline void PBFParser::parseWay(_ThreadData * threadData) {
 		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.insert(std::make_pair(key, val));
+			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];
-	    ParseWayInLua( w, scriptingEnvironment.getLuaStateForThreadID(omp_get_thread_num()) );
+		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);
 	}
 }
@@ -330,21 +347,21 @@ inline void PBFParser::loadGroup(_ThreadData * threadData) {
 #endif
 
 	const OSMPBF::PrimitiveGroup& group = threadData->PBFprimitiveBlock.primitivegroup( threadData->currentGroupID );
-	threadData->entityTypeIndicator = 0;
-	if ( group.nodes_size() != 0 ) {
+	threadData->entityTypeIndicator = TypeDummy;
+	if ( 0 != group.nodes_size() ) {
 		threadData->entityTypeIndicator = TypeNode;
 	}
-	if ( group.ways_size() != 0 ) {
+	if ( 0 != group.ways_size() ) {
 		threadData->entityTypeIndicator = TypeWay;
 	}
-	if ( group.relations_size() != 0 ) {
+	if ( 0 != group.relations_size() ) {
 		threadData->entityTypeIndicator = TypeRelation;
 	}
 	if ( group.has_dense() )  {
 		threadData->entityTypeIndicator = TypeDenseNode;
-		assert( group.dense().id_size() != 0 );
+		assert( 0 != group.dense().id_size() );
 	}
-	assert( threadData->entityTypeIndicator != 0 );
+	assert( threadData->entityTypeIndicator != TypeDummy );
 }
 
 inline void PBFParser::loadBlock(_ThreadData * threadData) {

Extractor/PBFParser.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 PBFPARSER_H_
 #define PBFPARSER_H_
@@ -44,16 +51,17 @@
 class PBFParser : public BaseParser {
 
     enum EntityType {
-        TypeNode = 1,
-        TypeWay = 2,
-        TypeRelation = 4,
+        TypeDummy     = 0,
+        TypeNode      = 1,
+        TypeWay       = 2,
+        TypeRelation  = 4,
         TypeDenseNode = 8
-    } ;
+    };
 
     struct _ThreadData {
         int currentGroupID;
         int currentEntityID;
-        short entityTypeIndicator;
+        EntityType entityTypeIndicator;
 
         OSMPBF::BlobHeader PBFBlobHeader;
         OSMPBF::Blob PBFBlob;
@@ -74,18 +82,18 @@ public:
 private:
     inline void ReadData();
     inline void ParseData();
-    inline void parseDenseNode(_ThreadData * threadData);
-    inline void parseNode(_ThreadData * );
-    inline void parseRelation(_ThreadData * threadData);
-    inline void parseWay(_ThreadData * threadData);
+    inline void parseDenseNode  (_ThreadData * threadData);
+    inline void parseNode       (_ThreadData * threadData);
+    inline void parseRelation   (_ThreadData * threadData);
+    inline void parseWay        (_ThreadData * threadData);
 
-    inline void loadGroup(_ThreadData * threadData);
-    inline void loadBlock(_ThreadData * threadData);
-    inline bool readPBFBlobHeader(std::fstream& stream, _ThreadData * threadData);
-    inline bool unpackZLIB(std::fstream &, _ThreadData * threadData);
-    inline bool unpackLZMA(std::fstream &, _ThreadData * );
-    inline bool readBlob(std::fstream& stream, _ThreadData * threadData) ;
-    inline bool readNextBlock(std::fstream& stream, _ThreadData * threadData);
+    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;

Extractor/ScriptingEnvironment.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 "ScriptingEnvironment.h"
 
@@ -59,7 +66,7 @@ ScriptingEnvironment::ScriptingEnvironment(const char * fileName) {
             .def(luabind::constructor<>())
             .def_readwrite("lat", &ImportNode::lat)
             .def_readwrite("lon", &ImportNode::lon)
-            .def_readwrite("id", &ImportNode::id)
+            .def_readonly("id", &ImportNode::id)
             .def_readwrite("bollard", &ImportNode::bollard)
             .def_readwrite("traffic_light", &ImportNode::trafficLight)
             .def_readwrite("tags", &ImportNode::keyVals)
@@ -68,6 +75,7 @@ ScriptingEnvironment::ScriptingEnvironment(const char * fileName) {
         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)
@@ -87,9 +95,11 @@ ScriptingEnvironment::ScriptingEnvironment(const char * fileName) {
 			]
     	];
 
+        // fails on c++11/OS X 10.9
         luabind::module(myLuaState) [
-            luabind::class_<std::vector<std::string> >("vector")
-            .def("Add", &std::vector<std::string>::push_back)
+             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)
+             )
         ];
 
         if(0 != luaL_dofile(myLuaState, fileName) ) {

Extractor/ScriptingEnvironment.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 SCRIPTINGENVIRONMENT_H_
 #define SCRIPTINGENVIRONMENT_H_

Extractor/XMLParser.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 "XMLParser.h"
 
@@ -67,7 +74,7 @@ bool XMLParser::Parse() {
 		}
 		if( use_turn_restrictions ) {
 			if ( xmlStrEqual( currentName, ( const xmlChar* ) "relation" ) == 1 ) {
-				_RawRestrictionContainer r = _ReadXMLRestriction();
+				InputRestrictionContainer r = _ReadXMLRestriction();
 				if(r.fromWay != UINT_MAX) {
 					if(!extractor_callbacks->restrictionFunction(r)) {
 						std::cerr << "[XMLParser] restriction not parsed" << std::endl;
@@ -80,8 +87,8 @@ bool XMLParser::Parse() {
 	return true;
 }
 
-_RawRestrictionContainer XMLParser::_ReadXMLRestriction() {
-    _RawRestrictionContainer restriction;
+InputRestrictionContainer XMLParser::_ReadXMLRestriction() {
+    InputRestrictionContainer restriction;
     std::string except_tag_string;
 
 	if ( xmlTextReaderIsEmptyElement( inputReader ) != 1 ) {

Extractor/XMLParser.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 XMLPARSER_H_
 #define XMLPARSER_H_
@@ -37,7 +44,7 @@ public:
     bool Parse();
 
 private:
-    _RawRestrictionContainer _ReadXMLRestriction();
+    InputRestrictionContainer _ReadXMLRestriction();
     ExtractionWay _ReadXMLWay();
     ImportNode _ReadXMLNode();
     xmlTextReaderPtr inputReader;

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

@@ -1,122 +1,131 @@
 /*
-    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.
+
+*/
 
 #include "OSRM.h"
 
-OSRM::OSRM(const char * server_ini_path) {
-    if( !testDataFile(server_ini_path) ){
-        std::string error_message = std::string(server_ini_path) + " not found";
-        throw OSRMException(error_message.c_str());
+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>( );
     }
 
-    IniFile serverConfig(server_ini_path);
-
-    boost::filesystem::path base_path =
-               boost::filesystem::absolute(server_ini_path).parent_path();
-
-    if ( !serverConfig.Holds("hsgrData")) {
-        throw OSRMException("no ram index file name in server ini");
-    }
-    if ( !serverConfig.Holds("ramIndex") ) {
-        throw OSRMException("no mem index file name in server ini");
-    }
-    if ( !serverConfig.Holds("fileIndex") ) {
-        throw OSRMException("no nodes file name in server ini");
-    }
-    if ( !serverConfig.Holds("nodesData") ) {
-        throw OSRMException("no nodes file name in server ini");
-    }
-    if ( !serverConfig.Holds("edgesData") ) {
-        throw OSRMException("no edges file name in server ini");
-    }
-
-    boost::filesystem::path hsgr_path = boost::filesystem::absolute(
-            serverConfig.GetParameter("hsgrData"),
-            base_path
+    //The following plugins handle all requests.
+    RegisterPlugin(
+        new HelloWorldPlugin()
     );
-
-    boost::filesystem::path ram_index_path = boost::filesystem::absolute(
-            serverConfig.GetParameter("ramIndex"),
-            base_path
+    RegisterPlugin(
+        new LocatePlugin<BaseDataFacade<QueryEdge::EdgeData> >(
+            query_data_facade
+        )
     );
-
-    boost::filesystem::path file_index_path = boost::filesystem::absolute(
-            serverConfig.GetParameter("fileIndex"),
-            base_path
+    RegisterPlugin(
+        new NearestPlugin<BaseDataFacade<QueryEdge::EdgeData> >(
+            query_data_facade
+        )
     );
-
-    boost::filesystem::path node_data_path = boost::filesystem::absolute(
-            serverConfig.GetParameter("nodesData"),
-            base_path
+    RegisterPlugin(
+        new TimestampPlugin<BaseDataFacade<QueryEdge::EdgeData> >(
+            query_data_facade
+        )
     );
-    boost::filesystem::path edge_data_path = boost::filesystem::absolute(
-            serverConfig.GetParameter("edgesData"),
-            base_path
+    RegisterPlugin(
+        new ViaRoutePlugin<BaseDataFacade<QueryEdge::EdgeData> >(
+            query_data_facade
+        )
     );
-    boost::filesystem::path name_data_path = boost::filesystem::absolute(
-            serverConfig.GetParameter("namesData"),
-            base_path
-    );
-    boost::filesystem::path timestamp_path = boost::filesystem::absolute(
-            serverConfig.GetParameter("timestamp"),
-            base_path
-    );
-
-    objects = new QueryObjectsStorage(
-        hsgr_path.string(),
-        ram_index_path.string(),
-        file_index_path.string(),
-        node_data_path.string(),
-        edge_data_path.string(),
-        name_data_path.string(),
-        timestamp_path.string()
-    );
-
-    RegisterPlugin(new HelloWorldPlugin());
-    RegisterPlugin(new LocatePlugin(objects));
-    RegisterPlugin(new NearestPlugin(objects));
-    RegisterPlugin(new TimestampPlugin(objects));
-    RegisterPlugin(new ViaRoutePlugin(objects));
 }
 
 OSRM::~OSRM() {
-    BOOST_FOREACH(PluginMap::value_type & plugin_pointer, pluginMap) {
+    BOOST_FOREACH(PluginMap::value_type & plugin_pointer, plugin_map) {
         delete plugin_pointer.second;
     }
-    delete objects;
 }
 
 void OSRM::RegisterPlugin(BasePlugin * plugin) {
     SimpleLogger().Write()  << "loaded plugin: " << plugin->GetDescriptor();
-    if( pluginMap.find(plugin->GetDescriptor()) != pluginMap.end() ) {
-        delete pluginMap[plugin->GetDescriptor()];
+    if( plugin_map.find(plugin->GetDescriptor()) != plugin_map.end() ) {
+        delete plugin_map.find(plugin->GetDescriptor())->second;
     }
-    pluginMap.insert(std::make_pair(plugin->GetDescriptor(), plugin));
+    plugin_map.emplace(plugin->GetDescriptor(), plugin);
 }
 
 void OSRM::RunQuery(RouteParameters & route_parameters, http::Reply & reply) {
-    const PluginMap::const_iterator & iter = pluginMap.find(route_parameters.service);
-    if(pluginMap.end() != iter) {
+    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);
+        reply = http::Reply::StockReply(http::Reply::badRequest);
     }
 }

Library/OSRM.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 OSRM_H
 #define OSRM_H
@@ -29,30 +36,45 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #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/IniFile.h"
 #include "../Util/InputFileUtil.h"
 #include "../Util/OSRMException.h"
 #include "../Util/SimpleLogger.h"
-#include "../Server/BasicDatastructures.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;
-    QueryObjectsStorage * objects;
 public:
-    OSRM(const char * server_ini_path);
+    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 pluginMap;
+    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,29 +1,36 @@
 /*
-    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 "../DataStructures/Coordinate.h"
-#include "../Server/BasicDatastructures.h"
 #include "../Server/DataStructures/RouteParameters.h"
+#include "../Server/Http/Reply.h"
 
 #include <string>
 #include <vector>

Plugins/HelloWorldPlugin.h

@@ -1,31 +1,41 @@
 /*
-    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 HELLOWORLDPLUGIN_H_
 #define HELLOWORLDPLUGIN_H_
 
 #include "BasePlugin.h"
+#include "../Util/StringUtil.h"
 
-#include <sstream>
+#include <string>
 
 class HelloWorldPlugin : public BasePlugin {
+    private:
+        std::string temp_string;
 public:
 	HelloWorldPlugin() : descriptor_string("hello"){}
 	virtual ~HelloWorldPlugin() { }
@@ -33,28 +43,56 @@ public:
 
 	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/COORDINATE_PRECISION << "," << routeParameters.coordinates[i].lon/COORDINATE_PRECISION << "\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;

Plugins/LocatePlugin.h

@@ -1,48 +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 LOCATEPLUGIN_H_
 #define LOCATEPLUGIN_H_
 
 #include "BasePlugin.h"
-#include "../DataStructures/NodeInformationHelpDesk.h"
-#include "../Server/DataStructures/QueryObjectsStorage.h"
 #include "../Util/StringUtil.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) : descriptor_string("locate") {
-        nodeHelpDesk = objects->nodeHelpDesk;
-    }
+    LocatePlugin(DataFacadeT * facade)
+     :
+        descriptor_string("locate"),
+        facade(facade)
+    { }
     const std::string & GetDescriptor() const { return descriptor_string; }
-    void HandleRequest(const RouteParameters & routeParameters, http::Reply& reply) {
+
+    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;
         }
 
@@ -51,35 +62,39 @@ public:
         std::string tmp;
         //json
 
-//        JSONParameter = routeParameters.options.Find("jsonp");
-        if("" != routeParameters.jsonpParameter) {
-            reply.content += routeParameters.jsonpParameter;
-            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("" != routeParameters.jsonpParameter) {
-            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";
@@ -91,14 +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:
-    NodeInformationHelpDesk * nodeHelpDesk;
     std::string descriptor_string;
+    DataFacadeT * facade;
 };
 
 #endif /* LOCATEPLUGIN_H_ */

Plugins/NearestPlugin.h

@@ -1,44 +1,49 @@
 /*
-    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 "BasePlugin.h"
-
-#include "../DataStructures/NodeInformationHelpDesk.h"
-#include "../Server/DataStructures/QueryObjectsStorage.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 )
+    NearestPlugin(DataFacadeT * facade )
      :
-        names(objects->names),
+        facade(facade),
         descriptor_string("nearest")
     {
-        nodeHelpDesk = objects->nodeHelpDesk;
-
         descriptorTable.insert(std::make_pair(""    , 0)); //default descriptor
         descriptorTable.insert(std::make_pair("json", 1));
     }
@@ -46,53 +51,59 @@ public:
     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 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("" != routeParameters.jsonpParameter) {
-            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";
@@ -104,14 +115,17 @@ 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;
+        unsigned content_length = 0;
+        BOOST_FOREACH(const std::string & snippet, reply.content) {
+            content_length += snippet.length();
+        }
+        intToString(content_length, temp_string);
+        reply.headers[0].value = temp_string;
     }
 
 private:
-    NodeInformationHelpDesk * nodeHelpDesk;
+    DataFacadeT * facade;
     HashTable<std::string, unsigned> descriptorTable;
-    std::vector<std::string> & names;
     std::string descriptor_string;
 };
 

Plugins/TimestampPlugin.h

@@ -1,32 +1,40 @@
 /*
-    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 "BasePlugin.h"
 
+template<class DataFacadeT>
 class TimestampPlugin : public BasePlugin {
 public:
-    TimestampPlugin(QueryObjectsStorage * o)
-     : objects(o), descriptor_string("timestamp")
+    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) {
@@ -34,23 +42,23 @@ public:
 
         //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";
@@ -61,12 +69,15 @@ 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;
 };
 

Plugins/ViaRoutePlugin.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 VIAROUTEPLUGIN_H_
 #define VIAROUTEPLUGIN_H_
@@ -24,66 +31,63 @@ or see http://www.gnu.org/licenses/agpl.txt.
 #include "BasePlugin.h"
 
 #include "../Algorithms/ObjectToBase64.h"
-#include "../DataStructures/HashTable.h"
 #include "../DataStructures/QueryEdge.h"
-#include "../DataStructures/StaticGraph.h"
 #include "../DataStructures/SearchEngine.h"
 #include "../Descriptors/BaseDescriptor.h"
 #include "../Descriptors/GPXDescriptor.h"
 #include "../Descriptors/JSONDescriptor.h"
-#include "../Server/DataStructures/QueryObjectsStorage.h"
 #include "../Util/SimpleLogger.h"
 #include "../Util/StringUtil.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;
-    SearchEngine * searchEnginePtr;
+    boost::unordered_map<std::string, unsigned> descriptorTable;
+    SearchEngine<DataFacadeT> * search_engine_ptr;
 public:
 
-    ViaRoutePlugin(QueryObjectsStorage * objects)
+    ViaRoutePlugin(DataFacadeT * facade)
      :
-        names(objects->names),
-        descriptor_string("viaroute")
+        descriptor_string("viaroute"),
+        facade(facade)
     {
-        nodeHelpDesk = objects->nodeHelpDesk;
-        graph = objects->graph;
+        //TODO: set up an engine for each thread!!
+        search_engine_ptr = new SearchEngine<DataFacadeT>(facade);
 
-        searchEnginePtr = new SearchEngine(graph, nodeHelpDesk, names);
-
-        descriptorTable.insert(std::make_pair(""    , 0));
-        descriptorTable.insert(std::make_pair("json", 0));
-        descriptorTable.insert(std::make_pair("gpx" , 1));
+        descriptorTable.emplace("json", 0);
+        descriptorTable.emplace("gpx" , 1);
     }
 
     virtual ~ViaRoutePlugin() {
-        delete searchEnginePtr;
+        delete search_engine_ptr;
     }
 
     const std::string & GetDescriptor() const { return descriptor_string; }
 
-    void HandleRequest(const RouteParameters & routeParameters, http::Reply& reply) {
+    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,13 +97,17 @@ public:
             if(checksumOK && i < routeParameters.hints.size() && "" != routeParameters.hints[i]) {
 //                SimpleLogger().Write() <<"Decoding hint: " << routeParameters.hints[i] << " for location index " << i;
                 DecodeObjectFromBase64(routeParameters.hints[i], phantomNodeVector[i]);
-                if(phantomNodeVector[i].isValid(nodeHelpDesk->getNumberOfNodes())) {
+                if(phantomNodeVector[i].isValid(facade->GetNumberOfNodes())) {
 //                    SimpleLogger().Write() << "Decoded hint " << i << " successfully";
                     continue;
                 }
             }
 //            SimpleLogger().Write() << "Brute force lookup of coordinate " << i;
-            searchEnginePtr->FindPhantomNodeForCoordinate( rawRoute.rawViaNodeCoordinates[i], phantomNodeVector[i], routeParameters.zoomLevel);
+            facade->FindPhantomNodeForCoordinate(
+                rawRoute.rawViaNodeCoordinates[i],
+                phantomNodeVector[i],
+                routeParameters.zoomLevel
+            );
         }
 
         for(unsigned i = 0; i < phantomNodeVector.size()-1; ++i) {
@@ -108,69 +116,81 @@ public:
             segmentPhantomNodes.targetPhantom = phantomNodeVector[i+1];
             rawRoute.segmentEndCoordinates.push_back(segmentPhantomNodes);
         }
-        if( ( routeParameters.alternateRoute ) && (1 == rawRoute.segmentEndCoordinates.size()) ) {
-//            SimpleLogger().Write() << "Checking for alternative paths";
-            searchEnginePtr->alternativePaths(rawRoute.segmentEndCoordinates[0],  rawRoute);
-
+        if(
+            ( routeParameters.alternateRoute ) &&
+            (1 == rawRoute.segmentEndCoordinates.size())
+        ) {
+            search_engine_ptr->alternative_path(
+                rawRoute.segmentEndCoordinates[0],
+                rawRoute
+            );
         } else {
-            searchEnginePtr->shortestPath(rawRoute.segmentEndCoordinates, rawRoute);
+            search_engine_ptr->shortest_path(
+                rawRoute.segmentEndCoordinates,
+                rawRoute
+            );
         }
 
-
         if(INT_MAX == rawRoute.lengthOfShortestPath ) {
-            SimpleLogger().Write(logDEBUG) << "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 * 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();
+            desc = new JSONDescriptor<DataFacadeT>();
 
             break;
         case 1:
-            desc = new GPXDescriptor();
+            desc = new GPXDescriptor<DataFacadeT>();
 
             break;
         default:
-            desc = new JSONDescriptor();
+            desc = new JSONDescriptor<DataFacadeT>();
 
             break;
         }
 
         PhantomNodes phantomNodes;
         phantomNodes.startPhantom = rawRoute.segmentEndCoordinates[0].startPhantom;
-//        SimpleLogger().Write() << "Start location: " << phantomNodes.startPhantom.location;
         phantomNodes.targetPhantom = rawRoute.segmentEndCoordinates[rawRoute.segmentEndCoordinates.size()-1].targetPhantom;
-//        SimpleLogger().Write() << "TargetLocation: " << phantomNodes.targetPhantom.location;
-//        SimpleLogger().Write() << "Number of segments: " << rawRoute.segmentEndCoordinates.size();
         desc->SetConfig(descriptorConfig);
 
-        desc->Run(reply, rawRoute, phantomNodes, *searchEnginePtr);
+        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";
@@ -191,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";
@@ -210,6 +230,7 @@ public:
     }
 private:
     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

Rakefile

@@ -6,7 +6,7 @@ require 'sys/proctable'
 
 BUILD_FOLDER = 'build'
 DATA_FOLDER = 'sandbox'
-PROFILE = 'bicycle'
+PROFILE = 'examples/postgis'
 OSRM_PORT = 5000
 PROFILES_FOLDER = '../profiles'
 
@@ -59,23 +59,6 @@ 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]
@@ -93,17 +76,10 @@ 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/europe/#{osm_data_country}-latest.osm.pbf -o #{DATA_FOLDER}/#{osm_data_country}.osm.pbf"
@@ -122,26 +98,20 @@ task :crop do
 end
 
 desc "Reprocess OSM data."
-task :process => :setup do
-  Dir.chdir DATA_FOLDER do
-    raise "Error while extracting data." unless system "../#{BUILD_FOLDER}/osrm-extract #{osm_data_area_name}.osm.pbf #{PROFILES_FOLDER}/#{PROFILE}.lua"
-    puts
-    raise "Error while preparing data." unless system "../#{BUILD_FOLDER}/osrm-prepare #{osm_data_area_name}.osrm #{osm_data_area_name}.osrm.restrictions #{PROFILES_FOLDER}/#{PROFILE}.lua"
-    puts
-  end
+task :process => [:extract,:prepare] do
 end
 
 desc "Extract OSM data."
-task :extract => :setup do
+task :extract do
   Dir.chdir DATA_FOLDER do
-    raise "Error while extracting data." unless system "../#{BUILD_FOLDER}/osrm-extract #{osm_data_area_name}.osm.pbf ../profiles/#{PROFILE}.lua"
+    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 => :setup do
+task :prepare do
   Dir.chdir DATA_FOLDER do
-    raise "Error while preparing data." unless system "../#{BUILD_FOLDER}/osrm-prepare #{osm_data_area_name}.osrm #{osm_data_area_name}.osrm.restrictions ../profiles/#{PROFILE}.lua"
+    raise "Error while preparing data." unless system "../#{BUILD_FOLDER}/osrm-prepare #{osm_data_area_name}.osrm --profile ../profiles/#{PROFILE}.lua"
   end
 end
 
@@ -158,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 "../#{BUILD_FOLDER}/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("../#{BUILD_FOLDER}/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,27 +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 ALTERNATIVEROUTES_H_
 #define ALTERNATIVEROUTES_H_
 
 #include "BasicRoutingInterface.h"
+#include "../DataStructures/SearchEngineData.h"
+
 #include <boost/unordered_map.hpp>
 #include <cmath>
 #include <vector>
@@ -30,15 +39,20 @@ 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 QueryDataT>
-class AlternativeRouting : private BasicRoutingInterface<QueryDataT> {
-    typedef BasicRoutingInterface<QueryDataT> super;
-    typedef typename QueryDataT::Graph SearchGraph;
-    typedef typename QueryDataT::QueryHeap QueryHeap;
+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(const NodeID n, const int l, const 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;
@@ -46,66 +60,129 @@ class AlternativeRouting : private BasicRoutingInterface<QueryDataT> {
             return (2*length + sharing) < (2*other.length + other.sharing);
         }
     };
-
-    const SearchGraph * search_graph;
-
+    DataFacadeT * facade;
+    SearchEngineData & engine_working_data;
 public:
 
-    AlternativeRouting(QueryDataT & qd) : super(qd), search_graph(qd.graph) { }
+    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>          alternative_path;
+        std::vector<NodeID>          via_node_candidate_list;
         std::vector<SearchSpaceEdge> forward_search_space;
         std::vector<SearchSpaceEdge> reverse_search_space;
 
-        //Initialize Queues, semi-expensive because access to TSS invokes a system call
-        super::_queryData.InitializeOrClearFirstThreadLocalStorage();
-        super::_queryData.InitializeOrClearSecondThreadLocalStorage();
-        super::_queryData.InitializeOrClearThirdThreadLocalStorage();
+        //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()
+        );
 
-        QueryHeap & forward_heap1 = *(super::_queryData.forwardHeap);
-        QueryHeap & reverse_heap1 = *(super::_queryData.backwardHeap);
-        QueryHeap & forward_heap2 = *(super::_queryData.forwardHeap2);
-        QueryHeap & reverse_heap2 = *(super::_queryData.backwardHeap2);
+        QueryHeap & forward_heap1 = *(engine_working_data.forwardHeap);
+        QueryHeap & reverse_heap1 = *(engine_working_data.backwardHeap);
+        QueryHeap & forward_heap2 = *(engine_working_data.forwardHeap2);
+        QueryHeap & reverse_heap2 = *(engine_working_data.backwardHeap2);
 
         int upper_bound_to_shortest_path_distance = INT_MAX;
         NodeID middle_node = UINT_MAX;
-        forward_heap1.Insert(phantomNodePair.startPhantom.edgeBasedNode, -phantomNodePair.startPhantom.weight1, phantomNodePair.startPhantom.edgeBasedNode);
-        if(phantomNodePair.startPhantom.isBidirected() ) {
-            forward_heap1.Insert(phantomNodePair.startPhantom.edgeBasedNode+1, -phantomNodePair.startPhantom.weight2, phantomNodePair.startPhantom.edgeBasedNode+1);
-        }
-        reverse_heap1.Insert(phantomNodePair.targetPhantom.edgeBasedNode, phantomNodePair.targetPhantom.weight1, phantomNodePair.targetPhantom.edgeBasedNode);
-        if(phantomNodePair.targetPhantom.isBidirected() ) {
-        	reverse_heap1.Insert(phantomNodePair.targetPhantom.edgeBasedNode+1, phantomNodePair.targetPhantom.weight2, phantomNodePair.targetPhantom.edgeBasedNode+1);
+        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 forward_offset = phantomNodePair.startPhantom.weight1 + (phantomNodePair.startPhantom.isBidirected() ? phantomNodePair.startPhantom.weight2 : 0);
-        const int reverse_offset = phantomNodePair.targetPhantom.weight1 + (phantomNodePair.targetPhantom.isBidirected() ? phantomNodePair.targetPhantom.weight2 : 0);
+        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
+        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, viaNodeCandidates, forward_search_space, forward_offset);
+                AlternativeRoutingStep<true>(
+                    forward_heap1,
+                    reverse_heap1,
+                    &middle_node,
+                    &upper_bound_to_shortest_path_distance,
+                    via_node_candidate_list,
+                    forward_search_space,
+                    forward_offset
+                );
             }
             if(0 < reverse_heap1.Size()){
-                AlternativeRoutingStep<false>(reverse_heap1, forward_heap1, &middle_node, &upper_bound_to_shortest_path_distance, viaNodeCandidates, reverse_search_space, reverse_offset);
+                AlternativeRoutingStep<false>(
+                    reverse_heap1,
+                    forward_heap1,
+                    &middle_node,
+                    &upper_bound_to_shortest_path_distance,
+                    via_node_candidate_list,
+                    reverse_search_space,
+                    reverse_offset
+                );
             }
         }
-        sort_unique_resize(viaNodeCandidates);
+        sort_unique_resize(via_node_candidate_list);
 
         std::vector<NodeID> packed_forward_path;
         std::vector<NodeID> packed_reverse_path;
 
-        super::RetrievePackedPathFromSingleHeap(forward_heap1, middle_node, packed_forward_path);
-        super::RetrievePackedPathFromSingleHeap(reverse_heap1, middle_node, packed_reverse_path);
+        super::RetrievePackedPathFromSingleHeap(
+            forward_heap1,
+            middle_node,
+            packed_forward_path
+        );
+        super::RetrievePackedPathFromSingleHeap(
+            reverse_heap1,
+            middle_node,
+            packed_reverse_path
+        );
+
         boost::unordered_map<NodeID, int> approximated_forward_sharing;
         boost::unordered_map<NodeID, int> approximated_reverse_sharing;
 
@@ -139,7 +216,7 @@ public:
         	}
         }
         std::vector<NodeID> nodes_that_passed_preselection;
-        BOOST_FOREACH(const NodeID node, viaNodeCandidates) {
+        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));
@@ -180,17 +257,17 @@ public:
 
         //Unpack shortest path and alternative, if they exist
         if(INT_MAX != upper_bound_to_shortest_path_distance) {
-            super::UnpackPath(packedShortestPath, rawRouteData.computedShortestPath);
-            rawRouteData.lengthOfShortestPath = 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(forward_heap1, reverse_heap1, forward_heap2, reverse_heap2, 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;
         }
     }
 
@@ -212,12 +289,14 @@ private:
             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()
+        );
 
-        QueryHeap & existingForwardHeap  = *super::_queryData.forwardHeap;
-        QueryHeap & existingBackwardHeap = *super::_queryData.backwardHeap;
-        QueryHeap & newForwardHeap       = *super::_queryData.forwardHeap2;
-        QueryHeap & newBackwardHeap      = *super::_queryData.backwardHeap2;
+        QueryHeap & existingForwardHeap  = *engine_working_data.forwardHeap;
+        QueryHeap & existingBackwardHeap = *engine_working_data.backwardHeap;
+        QueryHeap & newForwardHeap       = *engine_working_data.forwardHeap2;
+        QueryHeap & newBackwardHeap      = *engine_working_data.backwardHeap2;
 
         std::vector < NodeID > packed_s_v_path;
         std::vector < NodeID > packed_v_t_path;
@@ -251,8 +330,8 @@ private:
         //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(), 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]) {
-                typename SearchGraph::EdgeIterator edgeID = search_graph->FindEdgeInEitherDirection(packed_s_v_path[i], packed_s_v_path[i + 1]);
-                *sharing_of_via_path += search_graph->GetEdgeData(edgeID).distance;
+                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] == packed_shortest_path[i]) {
                     super::UnpackEdge(packed_s_v_path[i], packed_s_v_path[i+1], partiallyUnpackedViaPath);
@@ -263,8 +342,8 @@ private:
         }
         //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 SearchGraph::EdgeIterator edgeID = search_graph->FindEdgeInEitherDirection(partiallyUnpackedViaPath[i], partiallyUnpackedViaPath[i+1]);
-            *sharing_of_via_path += search_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
@@ -272,8 +351,8 @@ private:
         int shortestPathIndex = packed_shortest_path.size() - 1;
         for (; viaPathIndex > 0 && shortestPathIndex > 0; --viaPathIndex,--shortestPathIndex ) {
             if (packed_v_t_path[viaPathIndex - 1] == packed_shortest_path[shortestPathIndex - 1] && packed_v_t_path[viaPathIndex] == packed_shortest_path[shortestPathIndex]) {
-                typename SearchGraph::EdgeIterator edgeID = search_graph->FindEdgeInEitherDirection( packed_v_t_path[viaPathIndex - 1], packed_v_t_path[viaPathIndex]);
-                *sharing_of_via_path += search_graph->GetEdgeData(edgeID).distance;
+                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] == packed_shortest_path[shortestPathIndex]) {
                     super::UnpackEdge(packed_v_t_path[viaPathIndex-1], packed_v_t_path[viaPathIndex], partiallyUnpackedViaPath);
@@ -287,8 +366,8 @@ private:
         shortestPathIndex = partiallyUnpackedShortestPath.size() - 1;
         for (; viaPathIndex > 0 && shortestPathIndex > 0; --viaPathIndex,--shortestPathIndex) {
             if (partiallyUnpackedViaPath[viaPathIndex - 1] == partiallyUnpackedShortestPath[shortestPathIndex - 1] && partiallyUnpackedViaPath[viaPathIndex] == partiallyUnpackedShortestPath[shortestPathIndex]) {
-                typename SearchGraph::EdgeIterator edgeID = search_graph->FindEdgeInEitherDirection( partiallyUnpackedViaPath[viaPathIndex - 1], partiallyUnpackedViaPath[viaPathIndex]);
-                *sharing_of_via_path += search_graph->GetEdgeData(edgeID).distance;
+                EdgeID edgeID = facade->FindEdgeInEitherDirection( partiallyUnpackedViaPath[viaPathIndex - 1], partiallyUnpackedViaPath[viaPathIndex]);
+                *sharing_of_via_path += facade->GetEdgeData(edgeID).distance;
             } else {
                 break;
             }
@@ -308,8 +387,8 @@ private:
         //compute forward sharing
         while( (packedAlternativePath[aindex] == packedShortestPath[aindex]) && (packedAlternativePath[aindex+1] == packedShortestPath[aindex+1]) ) {
             //            SimpleLogger().Write() << "retrieving edge (" << packedAlternativePath[aindex] << "," << packedAlternativePath[aindex+1] << ")";
-            typename SearchGraph::EdgeIterator edgeID = search_graph->FindEdgeInEitherDirection(packedAlternativePath[aindex], packedAlternativePath[aindex+1]);
-            sharing += search_graph->GetEdgeData(edgeID).distance;
+            EdgeID edgeID = facade->FindEdgeInEitherDirection(packedAlternativePath[aindex], packedAlternativePath[aindex+1]);
+            sharing += facade->GetEdgeData(edgeID).distance;
             ++aindex;
         }
 
@@ -317,8 +396,8 @@ 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 SearchGraph::EdgeIterator edgeID = search_graph->FindEdgeInEitherDirection(packedAlternativePath[aindex], packedAlternativePath[aindex-1]);
-            sharing += search_graph->GetEdgeData(edgeID).distance;
+            EdgeID edgeID = facade->FindEdgeInEitherDirection(packedAlternativePath[aindex], packedAlternativePath[aindex-1]);
+            sharing += facade->GetEdgeData(edgeID).distance;
             --aindex; --bindex;
         }
         return sharing;
@@ -356,12 +435,12 @@ private:
             }
         }
 
-        for ( typename SearchGraph::EdgeIterator edge = search_graph->BeginEdges( node ); edge < search_graph->EndEdges(node); edge++ ) {
-            const typename SearchGraph::EdgeData & data = search_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 = search_graph->GetTarget(edge);
+                const NodeID to = facade->GetTarget(edge);
                 const int edgeWeight = data.distance;
 
                 assert( edgeWeight > 0 );
@@ -431,8 +510,8 @@ private:
         std::stack<SearchSpaceEdge> unpackStack;
         //Traverse path s-->v
         for (unsigned i = packed_s_v_path.size() - 1; (i > 0) && unpackStack.empty(); --i) {
-            typename SearchGraph::EdgeIterator edgeID = search_graph->FindEdgeInEitherDirection( packed_s_v_path[i - 1], packed_s_v_path[i]);
-            int lengthOfCurrentEdge = search_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 {
@@ -444,15 +523,15 @@ private:
         while (!unpackStack.empty()) {
             const SearchSpaceEdge viaPathEdge = unpackStack.top();
             unpackStack.pop();
-            typename SearchGraph::EdgeIterator edgeIDInViaPath = search_graph->FindEdgeInEitherDirection(viaPathEdge.first, viaPathEdge.second);
+            EdgeID edgeIDInViaPath = facade->FindEdgeInEitherDirection(viaPathEdge.first, viaPathEdge.second);
             if(UINT_MAX == edgeIDInViaPath)
                 return false;
-            typename SearchGraph::EdgeData currentEdgeData = search_graph->GetEdgeData(edgeIDInViaPath);
+            EdgeData currentEdgeData = facade->GetEdgeData(edgeIDInViaPath);
             bool IsViaEdgeShortCut = currentEdgeData.shortcut;
             if (IsViaEdgeShortCut) {
                 const NodeID middleOfViaPath = currentEdgeData.id;
-                typename SearchGraph::EdgeIterator edgeIDOfSecondSegment = search_graph->FindEdgeInEitherDirection(middleOfViaPath, viaPathEdge.second);
-                int lengthOfSecondSegment = search_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) {
@@ -472,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 SearchGraph::EdgeIterator edgeID = search_graph->FindEdgeInEitherDirection( packed_v_t_path[i], packed_v_t_path[i + 1]);
-            int lengthOfCurrentEdge = search_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 {
@@ -485,15 +564,15 @@ private:
         while (!unpackStack.empty()) {
             const SearchSpaceEdge viaPathEdge = unpackStack.top();
             unpackStack.pop();
-            typename SearchGraph::EdgeIterator edgeIDInViaPath = search_graph->FindEdgeInEitherDirection(viaPathEdge.first, viaPathEdge.second);
+            EdgeID edgeIDInViaPath = facade->FindEdgeInEitherDirection(viaPathEdge.first, viaPathEdge.second);
             if(UINT_MAX == edgeIDInViaPath)
                 return false;
-            typename SearchGraph::EdgeData currentEdgeData = search_graph->GetEdgeData(edgeIDInViaPath);
+            EdgeData currentEdgeData = facade->GetEdgeData(edgeIDInViaPath);
             const bool IsViaEdgeShortCut = currentEdgeData.shortcut;
             if (IsViaEdgeShortCut) {
                 const NodeID middleOfViaPath = currentEdgeData.id;
-                typename SearchGraph::EdgeIterator edgeIDOfFirstSegment = search_graph->FindEdgeInEitherDirection(viaPathEdge.first, middleOfViaPath);
-                int lengthOfFirstSegment = search_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));
@@ -510,10 +589,12 @@ private:
 
         lengthOfPathT_Test_Path += unpackedUntilDistance;
         //Run actual T-Test query and compare if distances equal.
-        super::_queryData.InitializeOrClearThirdThreadLocalStorage();
+        engine_working_data.InitializeOrClearThirdThreadLocalStorage(
+            super::facade->GetNumberOfNodes()
+        );
 
-        QueryHeap& forward_heap3 = *super::_queryData.forwardHeap3;
-        QueryHeap& backward_heap3 = *super::_queryData.backwardHeap3;
+        QueryHeap& forward_heap3 = *engine_working_data.forwardHeap3;
+        QueryHeap& backward_heap3 = *engine_working_data.backwardHeap3;
         int _upperBound = INT_MAX;
         NodeID middle = UINT_MAX;
         forward_heap3.Insert(s_P, 0, s_P);

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 "../DataStructures/RawRouteData.h"
+#include "../DataStructures/SearchEngineData.h"
 #include "../Util/ContainerUtils.h"
 #include "../Util/SimpleLogger.h"
 
+#include <boost/assert.hpp>
 #include <boost/noncopyable.hpp>
 
-#include <cassert>
 #include <climits>
 
 #include <stack>
 
-template<class QueryDataT>
-class BasicRoutingInterface : boost::noncopyable{
+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::QueryHeap & _forwardHeap, typename QueryDataT::QueryHeap & _backwardHeap, NodeID *middle, int *_upperbound, const int edgeBasedOffset, const bool forwardDirection) const {
-        const NodeID node = _forwardHeap.DeleteMin();
-        const int distance = _forwardHeap.GetKey(node);
-        //SimpleLogger().Write() << "Settled (" << _forwardHeap.GetData( node ).parent << "," << node << ")=" << distance;
-        if(_backwardHeap.WasInserted(node) ){
-            const int newDistance = _backwardHeap.GetKey(node) + distance;
-            if(newDistance < *_upperbound ){
-                if(newDistance>=0 ) {
-                    *middle = node;
-                    *_upperbound = newDistance;
-                } else {
+    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;
         }
 
         //Stalling
-        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;
+        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" );
 
-                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 ) ) {
-                    _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 ) ) {
-                    _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(const 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();
+        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 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
-                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(typename QueryDataT::QueryHeap & _fHeap, typename QueryDataT::QueryHeap & _bHeap, const NodeID middle, std::vector<NodeID>& packedPath) const {
-        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);
     	}
     }
 
-    inline void RetrievePackedPathFromSingleHeap(typename QueryDataT::QueryHeap & search_heap, const NodeID middle, std::vector<NodeID>& packed_path) const {
-        NodeID pathNode = middle;
-        while(pathNode != search_heap.GetData(pathNode).parent) {
-            pathNode = search_heap.GetData(pathNode).parent;
-            packed_path.push_back(pathNode);
+//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,200 +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;
-    typedef typename QueryDataT::QueryHeap QueryHeap;
 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) const {
-        BOOST_FOREACH(const 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;
+        bool search_from_1st_node = true;
+        bool search_from_2nd_node = true;
         NodeID middle1 = UINT_MAX;
         NodeID middle2 = UINT_MAX;
-        std::vector<NodeID> packedPath1;
-        std::vector<NodeID> packedPath2;
+        std::vector<NodeID> packed_path1;
+        std::vector<NodeID> packed_path2;
 
-        super::_queryData.InitializeOrClearFirstThreadLocalStorage();
-        super::_queryData.InitializeOrClearSecondThreadLocalStorage();
-        super::_queryData.InitializeOrClearThirdThreadLocalStorage();
+        engine_working_data.InitializeOrClearFirstThreadLocalStorage(
+            super::facade->GetNumberOfNodes()
+        );
+        engine_working_data.InitializeOrClearSecondThreadLocalStorage(
+            super::facade->GetNumberOfNodes()
+        );
+        engine_working_data.InitializeOrClearThirdThreadLocalStorage(
+            super::facade->GetNumberOfNodes()
+        );
 
-        QueryHeap & forward_heap1 = *(super::_queryData.forwardHeap);
-        QueryHeap & reverse_heap1 = *(super::_queryData.backwardHeap);
-        QueryHeap & forward_heap2 = *(super::_queryData.forwardHeap2);
-        QueryHeap & reverse_heap2 = *(super::_queryData.backwardHeap2);
+        QueryHeap & forward_heap1 = *(engine_working_data.forwardHeap);
+        QueryHeap & reverse_heap1 = *(engine_working_data.backwardHeap);
+        QueryHeap & forward_heap2 = *(engine_working_data.forwardHeap2);
+        QueryHeap & reverse_heap2 = *(engine_working_data.backwardHeap2);
 
         //Get distance to next pair of target nodes.
-        BOOST_FOREACH(const PhantomNodes & phantomNodePair, phantomNodesVector) {
+        BOOST_FOREACH(
+            const PhantomNodes & phantom_node_pair,
+            phantom_nodes_vector
+        ){
             forward_heap1.Clear();	forward_heap2.Clear();
             reverse_heap1.Clear();	reverse_heap2.Clear();
-            int _localUpperbound1 = INT_MAX;
-            int _localUpperbound2 = INT_MAX;
+            int local_upper_bound1 = INT_MAX;
+            int local_upper_bound2 = INT_MAX;
 
             middle1 = UINT_MAX;
             middle2 = UINT_MAX;
 
             //insert new starting nodes into forward heap, adjusted by previous distances.
-            if(searchFrom1stStartNode) {
-                forward_heap1.Insert(phantomNodePair.startPhantom.edgeBasedNode, -phantomNodePair.startPhantom.weight1, phantomNodePair.startPhantom.edgeBasedNode);
-                // INFO("fw1: " << phantomNodePair.startPhantom.edgeBasedNode << "´, w: " << -phantomNodePair.startPhantom.weight1);
-                forward_heap2.Insert(phantomNodePair.startPhantom.edgeBasedNode, -phantomNodePair.startPhantom.weight1, phantomNodePair.startPhantom.edgeBasedNode);
-                // INFO("fw2: " << phantomNodePair.startPhantom.edgeBasedNode << "´, w: " << -phantomNodePair.startPhantom.weight1);
+            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(phantomNodePair.startPhantom.isBidirected() && searchFrom2ndStartNode) {
-                forward_heap1.Insert(phantomNodePair.startPhantom.edgeBasedNode+1, -phantomNodePair.startPhantom.weight2, phantomNodePair.startPhantom.edgeBasedNode+1);
-                // INFO("fw1: " << phantomNodePair.startPhantom.edgeBasedNode+1 << "´, w: " << -phantomNodePair.startPhantom.weight2);
-                forward_heap2.Insert(phantomNodePair.startPhantom.edgeBasedNode+1, -phantomNodePair.startPhantom.weight2, phantomNodePair.startPhantom.edgeBasedNode+1);
-                // INFO("fw2: " << phantomNodePair.startPhantom.edgeBasedNode+1 << "´, w: " << -phantomNodePair.startPhantom.weight2);
+            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);
             }
 
             //insert new backward nodes into backward heap, unadjusted.
-            reverse_heap1.Insert(phantomNodePair.targetPhantom.edgeBasedNode, phantomNodePair.targetPhantom.weight1, phantomNodePair.targetPhantom.edgeBasedNode);
-            // INFO("rv1: " << phantomNodePair.targetPhantom.edgeBasedNode << ", w;" << phantomNodePair.targetPhantom.weight1 );
-            if(phantomNodePair.targetPhantom.isBidirected() ) {
-                reverse_heap2.Insert(phantomNodePair.targetPhantom.edgeBasedNode+1, phantomNodePair.targetPhantom.weight2, phantomNodePair.targetPhantom.edgeBasedNode+1);
-                // INFO("rv2: " << phantomNodePair.targetPhantom.edgeBasedNode+1 << ", w;" << phantomNodePair.targetPhantom.weight2 );
+            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 = phantomNodePair.startPhantom.weight1 + (phantomNodePair.startPhantom.isBidirected() ? phantomNodePair.startPhantom.weight2 : 0);
-            const int reverse_offset = phantomNodePair.targetPhantom.weight1 + (phantomNodePair.targetPhantom.isBidirected() ? phantomNodePair.targetPhantom.weight2 : 0);
+            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(0 < (forward_heap1.Size() + reverse_heap1.Size() )){
-                if(0 < forward_heap1.Size()){
-                    super::RoutingStep(forward_heap1, reverse_heap1, &middle1, &_localUpperbound1, forward_offset, true);
+                if( !forward_heap1.Empty()){
+                    super::RoutingStep(
+                        forward_heap1,
+                        reverse_heap1,
+                        &middle1,
+                        &local_upper_bound1,
+                        forward_offset,
+                        true
+                    );
                 }
-                if(0 < reverse_heap1.Size() ){
-                    super::RoutingStep(reverse_heap1, forward_heap1, &middle1, &_localUpperbound1, reverse_offset, false);
+                if( !reverse_heap1.Empty() ){
+                    super::RoutingStep(
+                        reverse_heap1,
+                        forward_heap1,
+                        &middle1,
+                        &local_upper_bound1,
+                        reverse_offset,
+                        false
+                    );
                 }
             }
-            if(0 < reverse_heap2.Size()) {
+            if( !reverse_heap2.Empty() ) {
                 while(0 < (forward_heap2.Size() + reverse_heap2.Size() )){
-                    if(0 < forward_heap2.Size()){
-                        super::RoutingStep(forward_heap2, reverse_heap2, &middle2, &_localUpperbound2, forward_offset, true);
+                    if( !forward_heap2.Empty() ){
+                        super::RoutingStep(
+                            forward_heap2,
+                            reverse_heap2,
+                            &middle2,
+                            &local_upper_bound2,
+                            forward_offset,
+                            true
+                        );
                     }
-                    if(0 < reverse_heap2.Size()){
-                        super::RoutingStep(reverse_heap2, forward_heap2, &middle2, &_localUpperbound2, reverse_offset, false);
+                    if( !reverse_heap2.Empty() ){
+                        super::RoutingStep(
+                            reverse_heap2,
+                            forward_heap2,
+                            &middle2,
+                            &local_upper_bound2,
+                            reverse_offset,
+                            false
+                        );
                     }
                 }
             }
 
             //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;
+                search_from_1st_node = false;
             }
             if(UINT_MAX == middle2) {
-                searchFrom2ndStartNode = false;
+                search_from_2nd_node = false;
             }
 
             //Was at most one of the two paths not found?
-            assert(!(INT_MAX == distance1 && INT_MAX == distance2));
+            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(forward_heap1, reverse_heap1, middle1, temporaryPackedPath1);
+            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
+                );
             }
 
-            if(INT_MAX != _localUpperbound2) {
-                super::RetrievePackedPathFromHeap(forward_heap2, reverse_heap2, middle2, temporaryPackedPath2);
+            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()) {
-                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()) {
-                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() ) {
-                if( *(temporaryPackedPath1.begin()) == *(temporaryPackedPath2.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())) {
-                        packedPath2.clear();
-                        packedPath2.insert(packedPath2.end(), packedPath1.begin(), packedPath1.end());
-                        distance2 = distance1;
+            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 {
-                        packedPath1.clear();
-                        packedPath1.insert(packedPath1.end(), packedPath2.begin(), packedPath2.end());
-                        distance1 = distance2;
+                        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())) {
-                        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() ) {
-
-                NodeID lastNodeID = packedPath2.back();
-                searchFrom1stStartNode &= !(lastNodeID == phantomNodePair.targetPhantom.edgeBasedNode+1);
-                searchFrom2ndStartNode &= !(lastNodeID == phantomNodePair.targetPhantom.edgeBasedNode);
+            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;
         }
 
-        if(distance1 > distance2){
-            std::swap(packedPath1, packedPath2);
+        if( distance1 > distance2 ) {
+            std::swap( packed_path1, packed_path2 );
         }
-        remove_consecutive_duplicates_from_vector(packedPath1);
-        super::UnpackPath(packedPath1, rawRouteData.computedShortestPath);
-        rawRouteData.lengthOfShortestPath = std::min(distance1, distance2);
-        return;
+        remove_consecutive_duplicates_from_vector(packed_path1);
+        super::UnpackPath(packed_path1, raw_route_data.computedShortestPath);
+        raw_route_data.lengthOfShortestPath = std::min(distance1, distance2);
     }
 };
 

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_

Server/BasicDatastructures.h

@@ -1,161 +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 "../Util/StringUtil.h"
-
-#include <boost/asio.hpp>
-#include <boost/foreach.hpp>
-
-#include <string>
-#include <sstream>
-#include <vector>
-
-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(const unsigned size) {
-		BOOST_FOREACH ( Header& h,  headers) {
-			if("Content-Length" == h.name) {
-				std::string sizeString;
-				intToString(size,h.value);
-			}
-		}
-	}
-};
-
-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(3);
-	rep.headers[0].name = "Access-Control-Allow-Origin";
-	rep.headers[0].value = "*";
-	rep.headers[1].name = "Content-Length";
-
-    std::string s;
-    intToString(rep.content.size(), s);
-
-    rep.headers[1].value = s;
-	rep.headers[2].name = "Content-Type";
-	rep.headers[2].value = "text/html";
-	return rep;
-}
-} // namespace http
-
-#endif //BASIC_DATASTRUCTURES_H

Server/Connection.h

@@ -1,178 +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 "BasicDatastructures.h"
+#include "Http/CompressionType.h"
 #include "RequestHandler.h"
 #include "RequestParser.h"
 
-#include <boost/asio.hpp>
 #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 <boost/enable_shared_from_this.hpp>
 
-#include <zlib.h>
 
+// #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;
 };
 

Server/DataStructures/BaseDataFacade.h

@@ -0,0 +1,122 @@
+/*
+
+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 QUERY_DATA_FACADE_H
+#define QUERY_DATA_FACADE_H
+
+//Exposes all data access interfaces to the algorithms via base class ptr
+
+#include "../../DataStructures/Coordinate.h"
+#include "../../DataStructures/EdgeBasedNode.h"
+#include "../../DataStructures/ImportNode.h"
+#include "../../DataStructures/PhantomNodes.h"
+#include "../../DataStructures/TurnInstructions.h"
+#include "../../Util/OSRMException.h"
+#include "../../Util/StringUtil.h"
+#include "../../typedefs.h"
+
+#include <string>
+
+template<class EdgeDataT>
+class BaseDataFacade {
+public:
+    typedef EdgeBasedNode RTreeLeaf;
+    typedef EdgeDataT EdgeData;
+    BaseDataFacade( ) { }
+    virtual ~BaseDataFacade() { }
+
+    //search graph access
+    virtual unsigned GetNumberOfNodes() const = 0;
+
+    virtual unsigned GetNumberOfEdges() const = 0;
+
+    virtual unsigned GetOutDegree( const NodeID n ) const = 0;
+
+    virtual NodeID GetTarget( const EdgeID e ) const = 0;
+
+    virtual EdgeDataT &GetEdgeData( const EdgeID e ) = 0;
+
+    // virtual const EdgeDataT &GetEdgeData( const EdgeID e ) const = 0;
+
+    virtual EdgeID BeginEdges( const NodeID n ) const = 0;
+
+    virtual EdgeID EndEdges( const NodeID n ) const = 0;
+
+    //searches for a specific edge
+    virtual EdgeID FindEdge( const NodeID from, const NodeID to ) const = 0;
+
+    virtual EdgeID FindEdgeInEitherDirection(
+        const NodeID from,
+        const NodeID to
+    ) const = 0;
+
+    virtual EdgeID FindEdgeIndicateIfReverse(
+        const NodeID from,
+        const NodeID to,
+        bool & result
+    ) const = 0;
+
+    //node and edge information access
+    virtual FixedPointCoordinate GetCoordinateOfNode(
+        const unsigned id
+    ) const = 0;
+
+    virtual TurnInstruction GetTurnInstructionForEdgeID(
+        const unsigned id
+    ) const  = 0;
+
+    virtual bool LocateClosestEndPointForCoordinate(
+        const FixedPointCoordinate& input_coordinate,
+        FixedPointCoordinate& result,
+        const unsigned zoom_level = 18
+    ) const  = 0;
+
+    virtual bool FindPhantomNodeForCoordinate(
+        const FixedPointCoordinate & input_coordinate,
+        PhantomNode & resulting_phantom_node,
+        const unsigned zoom_level
+    ) const  = 0;
+
+    virtual unsigned GetCheckSum() const = 0;
+
+    virtual unsigned GetNameIndexFromEdgeID(const unsigned id) const  = 0;
+
+    virtual void GetName(
+        const unsigned name_id,
+        std::string & result
+    ) const = 0;
+
+    std::string GetEscapedNameForNameID(const unsigned name_id) const {
+        std::string temporary_string;
+        GetName(name_id, temporary_string);
+        return HTMLEntitize(temporary_string);
+    }
+
+    virtual std::string GetTimestamp() const = 0;
+};
+
+#endif // QUERY_DATA_FACADE_H

Server/DataStructures/InternalDataFacade.h

@@ -0,0 +1,396 @@
+/*
+
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef INTERNAL_DATA_FACADE
+#define INTERNAL_DATA_FACADE
+
+//implements all data storage when shared memory is _NOT_ used
+
+#include "BaseDataFacade.h"
+
+#include "../../DataStructures/Coordinate.h"
+#include "../../DataStructures/QueryNode.h"
+#include "../../DataStructures/QueryEdge.h"
+#include "../../DataStructures/SharedMemoryVectorWrapper.h"
+#include "../../DataStructures/StaticGraph.h"
+#include "../../DataStructures/StaticRTree.h"
+#include "../../Util/BoostFileSystemFix.h"
+#include "../../Util/GraphLoader.h"
+#include "../../Util/IniFile.h"
+#include "../../Util/ProgramOptions.h"
+#include "../../Util/SimpleLogger.h"
+
+template<class EdgeDataT>
+class InternalDataFacade : public BaseDataFacade<EdgeDataT> {
+
+private:
+    typedef BaseDataFacade<EdgeDataT>             super;
+    typedef StaticGraph<typename super::EdgeData> QueryGraph;
+    typedef typename QueryGraph::InputEdge        InputEdge;
+    typedef typename super::RTreeLeaf             RTreeLeaf;
+
+    InternalDataFacade() { }
+
+    unsigned                                 m_check_sum;
+    unsigned                                 m_number_of_nodes;
+    QueryGraph                             * m_query_graph;
+    std::string                              m_timestamp;
+
+    ShM<FixedPointCoordinate, false>::vector m_coordinate_list;
+    ShM<NodeID, false>::vector               m_via_node_list;
+    ShM<unsigned, false>::vector             m_name_ID_list;
+    ShM<TurnInstruction, false>::vector      m_turn_instruction_list;
+    ShM<char, false>::vector                 m_names_char_list;
+    ShM<unsigned, false>::vector             m_name_begin_indices;
+
+    StaticRTree<RTreeLeaf, false>          * m_static_rtree;
+
+
+    void LoadTimestamp(const boost::filesystem::path & timestamp_path) {
+        if( boost::filesystem::exists(timestamp_path) ) {
+            SimpleLogger().Write() << "Loading Timestamp";
+            boost::filesystem::ifstream timestampInStream( timestamp_path );
+            if(!timestampInStream) {
+                SimpleLogger().Write(logWARNING) << timestamp_path << " not found";
+            }
+            getline(timestampInStream, m_timestamp);
+            timestampInStream.close();
+        }
+        if(m_timestamp.empty()) {
+            m_timestamp = "n/a";
+        }
+        if(25 < m_timestamp.length()) {
+            m_timestamp.resize(25);
+        }
+    }
+
+    void LoadGraph(const boost::filesystem::path & hsgr_path) {
+        typename ShM<typename QueryGraph::_StrNode, false>::vector node_list;
+        typename ShM<typename QueryGraph::_StrEdge, false>::vector edge_list;
+
+        SimpleLogger().Write() << "loading graph from " << hsgr_path.string();
+
+        m_number_of_nodes = readHSGRFromStream(
+            hsgr_path,
+            node_list,
+            edge_list,
+            &m_check_sum
+        );
+
+        BOOST_ASSERT_MSG(0 != node_list.size(), "node list empty");
+        BOOST_ASSERT_MSG(0 != edge_list.size(), "edge list empty");
+        SimpleLogger().Write() << "loaded " << node_list.size() << " nodes and " << edge_list.size() << " edges";
+        m_query_graph = new QueryGraph(node_list, edge_list);
+
+        BOOST_ASSERT_MSG(0 == node_list.size(), "node list not flushed");
+        BOOST_ASSERT_MSG(0 == edge_list.size(), "edge list not flushed");
+        SimpleLogger().Write() << "Data checksum is " << m_check_sum;
+    }
+
+    void LoadNodeAndEdgeInformation(
+        const boost::filesystem::path nodes_file,
+        const boost::filesystem::path edges_file
+    ) {
+        boost::filesystem::ifstream nodes_input_stream(
+            nodes_file,
+            std::ios::binary
+        );
+
+        SimpleLogger().Write(logDEBUG) << "Loading node data";
+        NodeInfo current_node;
+        unsigned number_of_coordinates = 0;
+        nodes_input_stream.read(
+            (char *)&number_of_coordinates,
+            sizeof(unsigned)
+        );
+        m_coordinate_list.resize(number_of_coordinates);
+        for(unsigned i = 0; i < number_of_coordinates; ++i) {
+            nodes_input_stream.read((char *)&current_node, sizeof(NodeInfo));
+            m_coordinate_list[i] = FixedPointCoordinate(
+                    current_node.lat,
+                    current_node.lon
+            );
+        }
+        std::vector<FixedPointCoordinate>(m_coordinate_list).swap(m_coordinate_list);
+        nodes_input_stream.close();
+
+        SimpleLogger().Write(logDEBUG) << "Loading edge data";
+        boost::filesystem::ifstream edges_input_stream(
+            edges_file,
+            std::ios::binary
+        );
+        unsigned number_of_edges = 0;
+        edges_input_stream.read((char*)&number_of_edges, sizeof(unsigned));
+        m_via_node_list.resize(number_of_edges);
+        m_name_ID_list.resize(number_of_edges);
+        m_turn_instruction_list.resize(number_of_edges);
+
+        OriginalEdgeData current_edge_data;
+        for(unsigned i = 0; i < number_of_edges; ++i) {
+            edges_input_stream.read(
+                (char*)&(current_edge_data),
+                sizeof(OriginalEdgeData)
+            );
+            m_via_node_list[i] = current_edge_data.viaNode;
+            m_name_ID_list[i]  = current_edge_data.nameID;
+            m_turn_instruction_list[i] = current_edge_data.turnInstruction;
+        }
+        edges_input_stream.close();
+    }
+
+    void LoadRTree(
+        const boost::filesystem::path & ram_index_path,
+        const boost::filesystem::path & file_index_path
+    ) {
+        m_static_rtree = new StaticRTree<RTreeLeaf>(
+            ram_index_path,
+            file_index_path
+        );
+    }
+
+    void LoadStreetNames(
+        const boost::filesystem::path & names_file
+    ) {
+        boost::filesystem::ifstream name_stream(names_file, std::ios::binary);
+        unsigned number_of_names = 0;
+        unsigned number_of_chars = 0;
+        name_stream.read((char *)&number_of_names, sizeof(unsigned));
+        name_stream.read((char *)&number_of_chars, sizeof(unsigned));
+        BOOST_ASSERT_MSG(0 != number_of_names, "name file broken");
+        BOOST_ASSERT_MSG(0 != number_of_chars, "name file broken");
+
+        m_name_begin_indices.resize(number_of_names);
+        name_stream.read(
+            (char*)&m_name_begin_indices[0],
+            number_of_names*sizeof(unsigned)
+        );
+
+        m_names_char_list.resize(number_of_chars+1); //+1 gives sentinel element
+        name_stream.read(
+            (char *)&m_names_char_list[0],
+            number_of_chars*sizeof(char)
+        );
+        BOOST_ASSERT_MSG(
+            0 != m_names_char_list.size(),
+            "could not load any names"
+        );
+        name_stream.close();
+    }
+public:
+    ~InternalDataFacade() {
+        delete m_query_graph;
+        delete m_static_rtree;
+    }
+
+    InternalDataFacade( const ServerPaths & server_paths ) {
+        //generate paths of data files
+        if( server_paths.find("hsgrdata") == server_paths.end() ) {
+            throw OSRMException("no hsgr file given in ini file");
+        }
+        if( server_paths.find("ramindex") == server_paths.end() ) {
+            throw OSRMException("no ram index file given in ini file");
+        }
+        if( server_paths.find("fileindex") == server_paths.end() ) {
+            throw OSRMException("no leaf index file given in ini file");
+        }
+        if( server_paths.find("nodesdata") == server_paths.end() ) {
+            throw OSRMException("no nodes file given in ini file");
+        }
+        if( server_paths.find("edgesdata") == server_paths.end() ) {
+            throw OSRMException("no edges file given in ini file");
+        }
+        if( server_paths.find("namesdata") == server_paths.end() ) {
+            throw OSRMException("no names file given in ini file");
+        }
+
+        ServerPaths::const_iterator paths_iterator = server_paths.find("hsgrdata");
+        BOOST_ASSERT(server_paths.end() != paths_iterator);
+        const boost::filesystem::path & hsgr_path = paths_iterator->second;
+        paths_iterator = server_paths.find("timestamp");
+        BOOST_ASSERT(server_paths.end() != paths_iterator);
+        const boost::filesystem::path & timestamp_path = paths_iterator->second;
+        paths_iterator = server_paths.find("ramindex");
+        BOOST_ASSERT(server_paths.end() != paths_iterator);
+        const boost::filesystem::path & ram_index_path = paths_iterator->second;
+        paths_iterator = server_paths.find("fileindex");
+        BOOST_ASSERT(server_paths.end() != paths_iterator);
+        const boost::filesystem::path & file_index_path = paths_iterator->second;
+        paths_iterator = server_paths.find("nodesdata");
+        BOOST_ASSERT(server_paths.end() != paths_iterator);
+        const boost::filesystem::path & nodes_data_path = paths_iterator->second;
+        paths_iterator = server_paths.find("edgesdata");
+        BOOST_ASSERT(server_paths.end() != paths_iterator);
+        const boost::filesystem::path & edges_data_path = paths_iterator->second;
+        paths_iterator = server_paths.find("namesdata");
+        BOOST_ASSERT(server_paths.end() != paths_iterator);
+        const boost::filesystem::path & names_data_path = paths_iterator->second;
+
+        //load data
+        SimpleLogger().Write() << "loading graph data";
+        LoadGraph(hsgr_path);
+        SimpleLogger().Write() << "loading egde information";
+        LoadNodeAndEdgeInformation(nodes_data_path, edges_data_path);
+        SimpleLogger().Write() << "loading r-tree";
+        LoadRTree(ram_index_path, file_index_path);
+        SimpleLogger().Write() << "loading timestamp";
+        LoadTimestamp(timestamp_path);
+        SimpleLogger().Write() << "loading street names";
+        LoadStreetNames(names_data_path);
+    }
+
+    //search graph access
+    unsigned GetNumberOfNodes() const {
+        return m_query_graph->GetNumberOfNodes();
+    }
+
+    unsigned GetNumberOfEdges() const {
+        return m_query_graph->GetNumberOfEdges();
+    }
+
+    unsigned GetOutDegree( const NodeID n ) const {
+        return m_query_graph->GetOutDegree(n);
+    }
+
+    NodeID GetTarget( const EdgeID e ) const {
+        return m_query_graph->GetTarget(e); }
+
+    EdgeDataT &GetEdgeData( const EdgeID e ) {
+        return m_query_graph->GetEdgeData(e);
+    }
+
+    const EdgeDataT &GetEdgeData( const EdgeID e ) const {
+        return m_query_graph->GetEdgeData(e);
+    }
+
+    EdgeID BeginEdges( const NodeID n ) const {
+        return m_query_graph->BeginEdges(n);
+    }
+
+    EdgeID EndEdges( const NodeID n ) const {
+        return m_query_graph->EndEdges(n);
+    }
+
+    //searches for a specific edge
+    EdgeID FindEdge( const NodeID from, const NodeID to ) const {
+        return m_query_graph->FindEdge(from, to);
+    }
+
+    EdgeID FindEdgeInEitherDirection(
+        const NodeID from,
+        const NodeID to
+    ) const {
+        return m_query_graph->FindEdgeInEitherDirection(from, to);
+    }
+
+    EdgeID FindEdgeIndicateIfReverse(
+        const NodeID from,
+        const NodeID to,
+        bool & result
+    ) const {
+        return m_query_graph->FindEdgeIndicateIfReverse(from, to, result);
+    }
+
+    //node and edge information access
+    FixedPointCoordinate GetCoordinateOfNode(
+        const unsigned id
+    ) const {
+        const NodeID node = m_via_node_list.at(id);
+        return m_coordinate_list.at(node);
+    };
+
+    TurnInstruction GetTurnInstructionForEdgeID(
+        const unsigned id
+    ) const {
+        return m_turn_instruction_list.at(id);
+    }
+
+    bool LocateClosestEndPointForCoordinate(
+        const FixedPointCoordinate& input_coordinate,
+        FixedPointCoordinate& result,
+        const unsigned zoom_level = 18
+    ) const {
+        return  m_static_rtree->LocateClosestEndPointForCoordinate(
+                    input_coordinate,
+                    result,
+                    zoom_level
+                );
+    }
+
+    bool FindPhantomNodeForCoordinate(
+        const FixedPointCoordinate & input_coordinate,
+        PhantomNode & resulting_phantom_node,
+        const unsigned zoom_level
+    ) const {
+        return  m_static_rtree->FindPhantomNodeForCoordinate(
+                    input_coordinate,
+                    resulting_phantom_node,
+                    zoom_level
+                );
+    }
+
+    unsigned GetCheckSum() const { return m_check_sum; }
+
+    unsigned GetNameIndexFromEdgeID(const unsigned id) const {
+        return m_name_ID_list.at(id);
+    };
+
+    void GetName( const unsigned name_id, std::string & result ) const {
+        if(UINT_MAX == name_id) {
+            result = "";
+            return;
+        }
+        BOOST_ASSERT_MSG(
+            name_id < m_name_begin_indices.size(),
+            "name id too high"
+        );
+        unsigned begin_index = m_name_begin_indices[name_id];
+        unsigned end_index = m_name_begin_indices[name_id+1];
+        BOOST_ASSERT_MSG(
+            begin_index < m_names_char_list.size(),
+            "begin index of name too high"
+        );
+        BOOST_ASSERT_MSG(
+            end_index < m_names_char_list.size(),
+            "end index of name too high"
+        );
+
+        BOOST_ASSERT_MSG(begin_index <= end_index, "string ends before begin");
+        result.clear();
+        result.resize(end_index - begin_index);
+        std::copy(
+            m_names_char_list.begin() + begin_index,
+            m_names_char_list.begin() + end_index,
+            result.begin()
+        );
+    }
+
+    std::string GetTimestamp() const {
+        return m_timestamp;
+    }
+};
+
+#endif  // INTERNAL_DATA_FACADE

Server/DataStructures/QueryObjectsStorage.cpp

@@ -1,130 +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 "QueryObjectsStorage.h"
-
-QueryObjectsStorage::QueryObjectsStorage(
-	const std::string & hsgrPath,
-	const std::string & ramIndexPath,
-	const std::string & fileIndexPath,
-	const std::string & nodesPath,
-	const std::string & edgesPath,
-	const std::string & namesPath,
-	const std::string & timestampPath
-) {
-	if( hsgrPath.empty() ) {
-		throw OSRMException("no hsgr file given in ini file");
-	}
-	if( ramIndexPath.empty() ) {
-		throw OSRMException("no ram index file given in ini file");
-	}
-	if( fileIndexPath.empty() ) {
-		throw OSRMException("no mem index file given in ini file");
-	}
-	if( nodesPath.empty() ) {
-		throw OSRMException("no nodes file given in ini file");
-	}
-	if( edgesPath.empty() ) {
-		throw OSRMException("no edges file given in ini file");
-	}
-	if( namesPath.empty() ) {
-		throw OSRMException("no names file given in ini file");
-	}
-
-	SimpleLogger().Write() << "loading graph data";
-	//Deserialize road network graph
-	std::vector< QueryGraph::_StrNode> nodeList;
-	std::vector< QueryGraph::_StrEdge> edgeList;
-	const int n = readHSGRFromStream(
-		hsgrPath,
-		nodeList,
-		edgeList,
-		&checkSum
-	);
-
-	SimpleLogger().Write() << "Data checksum is " << checkSum;
-	graph = new QueryGraph(nodeList, edgeList);
-	assert(0 == nodeList.size());
-	assert(0 == edgeList.size());
-
-	if(timestampPath.length()) {
-	    SimpleLogger().Write() << "Loading Timestamp";
-	    std::ifstream timestampInStream(timestampPath.c_str());
-	    if(!timestampInStream) {
-	    	SimpleLogger().Write(logWARNING) <<  timestampPath <<  " not found";
-	    }
-
-	    getline(timestampInStream, timestamp);
-	    timestampInStream.close();
-	}
-	if(!timestamp.length()) {
-	    timestamp = "n/a";
-	}
-	if(25 < timestamp.length()) {
-	    timestamp.resize(25);
-	}
-
-    SimpleLogger().Write() << "Loading auxiliary information";
-    //Init nearest neighbor data structure
-	nodeHelpDesk = new NodeInformationHelpDesk(
-		ramIndexPath,
-		fileIndexPath,
-		nodesPath,
-		edgesPath,
-		n,
-		checkSum
-	);
-
-	//deserialize street name list
-	SimpleLogger().Write() << "Loading names index";
-	boost::filesystem::path names_file(namesPath);
-
-    if ( !boost::filesystem::exists( names_file ) ) {
-        throw OSRMException("names file does not exist");
-    }
-    if ( 0 == boost::filesystem::file_size( names_file ) ) {
-        throw OSRMException("names file is empty");
-    }
-
-	boost::filesystem::ifstream name_stream(names_file, std::ios::binary);
-	unsigned size = 0;
-	name_stream.read((char *)&size, sizeof(unsigned));
-	BOOST_ASSERT_MSG(0 != size, "name file empty");
-
-	char buf[1024];
-	for( unsigned i = 0; i < size; ++i ) {
-		unsigned size_of_string = 0;
-		name_stream.read((char *)&size_of_string, sizeof(unsigned));
-		buf[size_of_string] = '\0'; // instead of memset
-		name_stream.read(buf, size_of_string);
-		names.push_back(buf);
-	}
-	std::vector<std::string>(names).swap(names);
-	BOOST_ASSERT_MSG(0 != names.size(), "could not load any names");
-	name_stream.close();
-	SimpleLogger().Write() << "All query data structures loaded";
-}
-
-QueryObjectsStorage::~QueryObjectsStorage() {
-	//        delete names;
-	delete graph;
-	delete nodeHelpDesk;
-}

Server/DataStructures/QueryObjectsStorage.h

@@ -1,63 +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 QUERYOBJECTSSTORAGE_H_
-#define QUERYOBJECTSSTORAGE_H_
-
-#include "../../Util/GraphLoader.h"
-#include "../../Util/OSRMException.h"
-#include "../../Util/SimpleLogger.h"
-#include "../../DataStructures/NodeInformationHelpDesk.h"
-#include "../../DataStructures/QueryEdge.h"
-#include "../../DataStructures/StaticGraph.h"
-
-#include <boost/assert.hpp>
-#include <boost/filesystem.hpp>
-#include <boost/filesystem/fstream.hpp>
-
-#include <vector>
-#include <string>
-
-
-struct QueryObjectsStorage {
-    typedef StaticGraph<QueryEdge::EdgeData>    QueryGraph;
-    typedef QueryGraph::InputEdge               InputEdge;
-
-    NodeInformationHelpDesk * nodeHelpDesk;
-    std::vector<std::string> names;
-    QueryGraph * graph;
-    std::string timestamp;
-    unsigned checkSum;
-
-    QueryObjectsStorage(
-        const std::string & hsgrPath,
-        const std::string & ramIndexPath,
-        const std::string & fileIndexPath,
-        const std::string & nodesPath,
-        const std::string & edgesPath,
-        const std::string & namesPath,
-        const std::string & timestampPath
-    );
-
-    ~QueryObjectsStorage();
-};
-
-#endif /* QUERYOBJECTSSTORAGE_H_ */

Server/DataStructures/RouteParameters.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 ROUTE_PARAMETERS_H
 #define ROUTE_PARAMETERS_H

Server/DataStructures/SharedBarriers.h

@@ -0,0 +1,40 @@
+#include <boost/interprocess/sync/named_mutex.hpp>
+#include <boost/interprocess/sync/named_condition.hpp>
+
+struct SharedBarriers {
+
+   SharedBarriers ()
+    :
+      pending_update_mutex(
+         boost::interprocess::open_or_create,
+         "pending_update"
+      ),
+      update_mutex(
+         boost::interprocess::open_or_create,
+         "update"
+      ),
+      query_mutex(
+         boost::interprocess::open_or_create,
+         "query"
+      ),
+      no_running_queries_condition(
+         boost::interprocess::open_or_create,
+         "no_running_queries"
+      ),
+      update_ongoing(false),
+      number_of_queries(0)
+   { }
+
+   // Mutex to protect access to the boolean variable
+   boost::interprocess::named_mutex   pending_update_mutex;
+   boost::interprocess::named_mutex   update_mutex;
+   boost::interprocess::named_mutex   query_mutex;
+
+   // Condition that no update is running
+   boost::interprocess::named_condition  no_running_queries_condition;
+
+   // Is there an ongoing update?
+   bool update_ongoing;
+   // Is there any query?
+   int number_of_queries;
+};

Server/DataStructures/SharedDataFacade.h

@@ -0,0 +1,385 @@
+/*
+
+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_DATA_FACADE_H
+#define SHARED_DATA_FACADE_H
+
+//implements all data storage when shared memory is _NOT_ used
+
+#include <boost/make_shared.hpp>
+#include <boost/shared_ptr.hpp>
+
+#include "BaseDataFacade.h"
+#include "SharedDataType.h"
+
+#include "../../DataStructures/StaticGraph.h"
+#include "../../DataStructures/StaticRTree.h"
+#include "../../Util/BoostFileSystemFix.h"
+#include "../../Util/ProgramOptions.h"
+#include "../../Util/SimpleLogger.h"
+
+#include <algorithm>
+
+template<class EdgeDataT>
+class SharedDataFacade : public BaseDataFacade<EdgeDataT> {
+
+private:
+    typedef EdgeDataT EdgeData;
+    typedef BaseDataFacade<EdgeData>                        super;
+    typedef StaticGraph<EdgeData, true>                     QueryGraph;
+    typedef typename StaticGraph<EdgeData, true>::_StrNode  GraphNode;
+    typedef typename StaticGraph<EdgeData, true>::_StrEdge  GraphEdge;
+    typedef typename QueryGraph::InputEdge                  InputEdge;
+    typedef typename super::RTreeLeaf                       RTreeLeaf;
+    typedef typename StaticRTree<RTreeLeaf, true>::TreeNode RTreeNode;
+
+    SharedDataLayout    * data_layout;
+    char                * shared_memory;
+    SharedDataTimestamp * data_timestamp_ptr;
+
+    SharedDataType     CURRENT_LAYOUT;
+    SharedDataType     CURRENT_DATA;
+    unsigned           CURRENT_TIMESTAMP;
+
+    unsigned                                m_check_sum;
+    unsigned                                m_number_of_nodes;
+    boost::shared_ptr<QueryGraph>           m_query_graph;
+    boost::shared_ptr<SharedMemory>         m_layout_memory;
+    boost::shared_ptr<SharedMemory>         m_large_memory;
+    std::string                             m_timestamp;
+
+    ShM<FixedPointCoordinate, true>::vector m_coordinate_list;
+    ShM<NodeID, true>::vector               m_via_node_list;
+    ShM<unsigned, true>::vector             m_name_ID_list;
+    ShM<TurnInstruction, true>::vector      m_turn_instruction_list;
+    ShM<char, true>::vector                 m_names_char_list;
+    ShM<unsigned, true>::vector             m_name_begin_indices;
+    boost::shared_ptr<StaticRTree<RTreeLeaf, true> > m_static_rtree;
+
+    // SharedDataFacade() { }
+
+    void LoadTimestamp() {
+        char * timestamp_ptr = shared_memory + data_layout->GetTimeStampOffset();
+        m_timestamp.resize(data_layout->timestamp_length);
+        std::copy(
+            timestamp_ptr,
+            timestamp_ptr+data_layout->timestamp_length,
+            m_timestamp.begin()
+        );
+    }
+
+    void LoadRTree(
+        const boost::filesystem::path & file_index_path
+    ) {
+        RTreeNode * tree_ptr = (RTreeNode *)(
+            shared_memory + data_layout->GetRSearchTreeOffset()
+        );
+        m_static_rtree = boost::make_shared<StaticRTree<RTreeLeaf, true> >(
+            tree_ptr,
+            data_layout->r_search_tree_size,
+            file_index_path
+        );
+    }
+
+    void LoadGraph() {
+        m_number_of_nodes = data_layout->graph_node_list_size;
+        GraphNode * graph_nodes_ptr = (GraphNode *)(
+            shared_memory + data_layout->GetGraphNodeListOffset()
+        );
+
+        GraphEdge * graph_edges_ptr = (GraphEdge *)(
+            shared_memory + data_layout->GetGraphEdgeListOffsett()
+        );
+
+        typename ShM<GraphNode, true>::vector node_list(
+            graph_nodes_ptr,
+            data_layout->graph_node_list_size
+        );
+        typename ShM<GraphEdge, true>::vector edge_list(
+            graph_edges_ptr,
+            data_layout->graph_edge_list_size
+        );
+        m_query_graph.reset(
+            new QueryGraph(node_list, edge_list)
+        );
+
+    }
+
+    void LoadNodeAndEdgeInformation() {
+
+        FixedPointCoordinate * coordinate_list_ptr = (FixedPointCoordinate *)(
+            shared_memory + data_layout->GetCoordinateListOffset()
+        );
+        typename ShM<FixedPointCoordinate, true>::vector coordinate_list(
+                coordinate_list_ptr,
+                data_layout->coordinate_list_size
+        );
+        m_coordinate_list.swap( coordinate_list );
+
+        TurnInstruction * turn_instruction_list_ptr = (TurnInstruction *)(
+            shared_memory + data_layout->GetTurnInstructionListOffset()
+        );
+        typename ShM<TurnInstruction, true>::vector turn_instruction_list(
+            turn_instruction_list_ptr,
+            data_layout->turn_instruction_list_size
+        );
+        m_turn_instruction_list.swap(turn_instruction_list);
+
+        unsigned * name_id_list_ptr = (unsigned *)(
+            shared_memory + data_layout->GetNameIDListOffset()
+        );
+        typename ShM<unsigned, true>::vector name_id_list(
+            name_id_list_ptr,
+            data_layout->name_id_list_size
+        );
+        m_name_ID_list.swap(name_id_list);
+    }
+
+    void LoadViaNodeList() {
+        NodeID * via_node_list_ptr = (NodeID *)(
+            shared_memory + data_layout->GetViaNodeListOffset()
+        );
+        typename ShM<NodeID, true>::vector via_node_list(
+            via_node_list_ptr,
+            data_layout->via_node_list_size
+        );
+        m_via_node_list.swap(via_node_list);
+    }
+
+    void LoadNames() {
+        unsigned * street_names_index_ptr = (unsigned *)(
+            shared_memory + data_layout->GetNameIndexOffset()
+        );
+        typename ShM<unsigned, true>::vector name_begin_indices(
+            street_names_index_ptr,
+            data_layout->name_index_list_size
+        );
+        m_name_begin_indices.swap(name_begin_indices);
+
+        char * names_list_ptr = (char *)(
+            shared_memory + data_layout->GetNameListOffset()
+        );
+        typename ShM<char, true>::vector names_char_list(
+            names_list_ptr,
+            data_layout->name_char_list_size
+        );
+        m_names_char_list.swap(names_char_list);
+    }
+
+public:
+    SharedDataFacade( ) {
+        data_timestamp_ptr = (SharedDataTimestamp *)SharedMemoryFactory::Get(
+            CURRENT_REGIONS,
+            sizeof(SharedDataTimestamp),
+            false,
+            false
+        )->Ptr();
+
+        CURRENT_LAYOUT = LAYOUT_NONE;
+        CURRENT_DATA = DATA_NONE;
+        CURRENT_TIMESTAMP = 0;
+
+        //load data
+        CheckAndReloadFacade();
+    }
+
+    void CheckAndReloadFacade() {
+        if(
+            CURRENT_LAYOUT    != data_timestamp_ptr->layout    ||
+            CURRENT_DATA      != data_timestamp_ptr->data      ||
+            CURRENT_TIMESTAMP != data_timestamp_ptr->timestamp
+        ) {
+            // release the previous shared memory segments
+            SharedMemory::Remove(CURRENT_LAYOUT);
+            SharedMemory::Remove(CURRENT_DATA);
+
+            CURRENT_LAYOUT    = data_timestamp_ptr->layout;
+            CURRENT_DATA      = data_timestamp_ptr->data;
+            CURRENT_TIMESTAMP = data_timestamp_ptr->timestamp;
+
+            m_layout_memory.reset( SharedMemoryFactory::Get(CURRENT_LAYOUT) );
+
+            data_layout = (SharedDataLayout *)(
+                m_layout_memory->Ptr()
+            );
+            boost::filesystem::path ram_index_path(data_layout->ram_index_file_name);
+            if( !boost::filesystem::exists(ram_index_path) ) {
+                throw OSRMException(
+                    "no leaf index file given. "
+                    "Is any data loaded into shared memory?"
+                );
+            }
+
+            m_large_memory.reset( SharedMemoryFactory::Get(CURRENT_DATA) );
+            shared_memory = (char *)(
+                m_large_memory->Ptr()
+            );
+
+            LoadGraph();
+            LoadNodeAndEdgeInformation();
+            LoadRTree(ram_index_path);
+            LoadTimestamp();
+            LoadViaNodeList();
+            LoadNames();
+
+            data_layout->PrintInformation();
+        }
+    }
+
+
+    //search graph access
+    unsigned GetNumberOfNodes() const {
+        return m_query_graph->GetNumberOfNodes();
+    }
+
+    unsigned GetNumberOfEdges() const {
+        return m_query_graph->GetNumberOfEdges();
+    }
+
+    unsigned GetOutDegree( const NodeID n ) const {
+        return m_query_graph->GetOutDegree(n);
+    }
+
+    NodeID GetTarget( const EdgeID e ) const {
+        return m_query_graph->GetTarget(e); }
+
+    EdgeDataT &GetEdgeData( const EdgeID e ) {
+        return m_query_graph->GetEdgeData(e);
+    }
+
+    // const EdgeDataT &GetEdgeData( const EdgeID e ) const {
+    //     return m_query_graph->GetEdgeData(e);
+    // }
+
+    EdgeID BeginEdges( const NodeID n ) const {
+        return m_query_graph->BeginEdges(n);
+    }
+
+    EdgeID EndEdges( const NodeID n ) const {
+        return m_query_graph->EndEdges(n);
+    }
+
+    //searches for a specific edge
+    EdgeID FindEdge( const NodeID from, const NodeID to ) const {
+        return m_query_graph->FindEdge(from, to);
+    }
+
+    EdgeID FindEdgeInEitherDirection(
+        const NodeID from,
+        const NodeID to
+    ) const {
+        return m_query_graph->FindEdgeInEitherDirection(from, to);
+    }
+
+    EdgeID FindEdgeIndicateIfReverse(
+        const NodeID from,
+        const NodeID to,
+        bool & result
+    ) const {
+        return m_query_graph->FindEdgeIndicateIfReverse(from, to, result);
+    }
+
+    //node and edge information access
+    FixedPointCoordinate GetCoordinateOfNode(
+        const unsigned id
+    ) const {
+        const NodeID node = m_via_node_list.at(id);
+        return m_coordinate_list.at(node);
+    };
+
+    TurnInstruction GetTurnInstructionForEdgeID(
+        const unsigned id
+    ) const {
+        return m_turn_instruction_list.at(id);
+    }
+
+    bool LocateClosestEndPointForCoordinate(
+        const FixedPointCoordinate& input_coordinate,
+        FixedPointCoordinate& result,
+        const unsigned zoom_level = 18
+    ) const {
+        return  m_static_rtree->LocateClosestEndPointForCoordinate(
+                    input_coordinate,
+                    result,
+                    zoom_level
+                );
+    }
+
+    bool FindPhantomNodeForCoordinate(
+        const FixedPointCoordinate & input_coordinate,
+        PhantomNode & resulting_phantom_node,
+        const unsigned zoom_level
+    ) const {
+        return  m_static_rtree->FindPhantomNodeForCoordinate(
+                    input_coordinate,
+                    resulting_phantom_node,
+                    zoom_level
+                );
+    }
+
+    unsigned GetCheckSum() const { return m_check_sum; }
+
+    unsigned GetNameIndexFromEdgeID(const unsigned id) const {
+        return m_name_ID_list.at(id);
+    };
+
+    void GetName( const unsigned name_id, std::string & result ) const {
+        if(UINT_MAX == name_id) {
+            result = "";
+            return;
+        }
+        BOOST_ASSERT_MSG(
+            name_id < m_name_begin_indices.size(),
+            "name id too high"
+        );
+        unsigned begin_index = m_name_begin_indices[name_id];
+        unsigned end_index = m_name_begin_indices[name_id+1];
+        BOOST_ASSERT_MSG(
+            begin_index < m_names_char_list.size(),
+            "begin index of name too high"
+        );
+        BOOST_ASSERT_MSG(
+            end_index < m_names_char_list.size(),
+            "end index of name too high"
+        );
+
+        BOOST_ASSERT_MSG(begin_index <= end_index, "string ends before begin");
+        result.clear();
+        result.resize(end_index - begin_index);
+        std::copy(
+            m_names_char_list.begin() + begin_index,
+            m_names_char_list.begin() + end_index,
+            result.begin()
+        );
+    }
+
+    std::string GetTimestamp() const {
+        return m_timestamp;
+    }
+};
+
+#endif  // SHARED_DATA_FACADE_H

Server/DataStructures/SharedDataType.h

@@ -0,0 +1,229 @@
+/*
+
+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_DATA_TYPE_H_
+#define SHARED_DATA_TYPE_H_
+
+#include "BaseDataFacade.h"
+
+#include "../../DataStructures/Coordinate.h"
+#include "../../DataStructures/QueryEdge.h"
+#include "../../DataStructures/StaticGraph.h"
+#include "../../DataStructures/StaticRTree.h"
+#include "../../DataStructures/TurnInstructions.h"
+
+#include "../../typedefs.h"
+
+#include <boost/integer.hpp>
+
+typedef BaseDataFacade<QueryEdge::EdgeData>::RTreeLeaf RTreeLeaf;
+typedef StaticRTree<RTreeLeaf, true>::TreeNode RTreeNode;
+typedef StaticGraph<QueryEdge::EdgeData> QueryGraph;
+
+struct SharedDataLayout {
+    uint64_t name_index_list_size;
+    uint64_t name_char_list_size;
+    uint64_t name_id_list_size;
+    uint64_t via_node_list_size;
+    uint64_t graph_node_list_size;
+    uint64_t graph_edge_list_size;
+    uint64_t coordinate_list_size;
+    uint64_t turn_instruction_list_size;
+    uint64_t r_search_tree_size;
+
+    unsigned checksum;
+    unsigned timestamp_length;
+
+    char ram_index_file_name[1024];
+
+    SharedDataLayout() :
+        name_index_list_size(0),
+        name_char_list_size(0),
+        name_id_list_size(0),
+        via_node_list_size(0),
+        graph_node_list_size(0),
+        graph_edge_list_size(0),
+        coordinate_list_size(0),
+        turn_instruction_list_size(0),
+        r_search_tree_size(0),
+        checksum(0),
+        timestamp_length(0)
+    {
+        ram_index_file_name[0] = '\0';
+    }
+
+    void PrintInformation() const {
+        SimpleLogger().Write(logDEBUG) << "-";
+        SimpleLogger().Write(logDEBUG) << "name_index_list_size:       " << name_index_list_size;
+        SimpleLogger().Write(logDEBUG) << "name_char_list_size:        " << name_char_list_size;
+        SimpleLogger().Write(logDEBUG) << "name_id_list_size:          " << name_id_list_size;
+        SimpleLogger().Write(logDEBUG) << "via_node_list_size:         " << via_node_list_size;
+        SimpleLogger().Write(logDEBUG) << "graph_node_list_size:       " << graph_node_list_size;
+        SimpleLogger().Write(logDEBUG) << "graph_edge_list_size:       " << graph_edge_list_size;
+        SimpleLogger().Write(logDEBUG) << "timestamp_length:           " << timestamp_length;
+        SimpleLogger().Write(logDEBUG) << "coordinate_list_size:       " << coordinate_list_size;
+        SimpleLogger().Write(logDEBUG) << "turn_instruction_list_size: " << turn_instruction_list_size;
+        SimpleLogger().Write(logDEBUG) << "r_search_tree_size:         " << r_search_tree_size;
+        SimpleLogger().Write(logDEBUG) << "sizeof(checksum):           " << sizeof(checksum);
+        SimpleLogger().Write(logDEBUG) << "ram index file name:        " << ram_index_file_name;
+    }
+
+    uint64_t GetSizeOfLayout() const {
+        uint64_t result =
+            (name_index_list_size       * sizeof(unsigned)            ) +
+            (name_char_list_size        * sizeof(char)                ) +
+            (name_id_list_size          * sizeof(unsigned)            ) +
+            (via_node_list_size         * sizeof(NodeID)              ) +
+            (graph_node_list_size       * sizeof(QueryGraph::_StrNode)) +
+            (graph_edge_list_size       * sizeof(QueryGraph::_StrEdge)) +
+            (timestamp_length           * sizeof(char)                ) +
+            (coordinate_list_size       * sizeof(FixedPointCoordinate)) +
+            (turn_instruction_list_size * sizeof(TurnInstructions)    ) +
+            (r_search_tree_size         * sizeof(RTreeNode)           ) +
+            sizeof(checksum)                                            +
+            1024*sizeof(char);
+        return result;
+    }
+
+    uint64_t GetNameIndexOffset() const {
+        return 0;
+    }
+    uint64_t GetNameListOffset() const {
+        uint64_t result =
+            (name_index_list_size       * sizeof(unsigned)            );
+        return result;
+    }
+    uint64_t GetNameIDListOffset() const {
+        uint64_t result =
+            (name_index_list_size       * sizeof(unsigned)            ) +
+            (name_char_list_size        * sizeof(char)                );
+        return result;
+    }
+    uint64_t GetViaNodeListOffset() const {
+        uint64_t result =
+            (name_index_list_size       * sizeof(unsigned)            ) +
+            (name_char_list_size        * sizeof(char)                ) +
+            (name_id_list_size          * sizeof(unsigned)            );
+        return result;
+    }
+    uint64_t GetGraphNodeListOffset() const {
+        uint64_t result =
+            (name_index_list_size       * sizeof(unsigned)            ) +
+            (name_char_list_size        * sizeof(char)                ) +
+            (name_id_list_size          * sizeof(unsigned)            ) +
+            (via_node_list_size         * sizeof(NodeID)              );
+        return result;
+    }
+    uint64_t GetGraphEdgeListOffsett() const {
+        uint64_t result =
+            (name_index_list_size           * sizeof(unsigned)            ) +
+            (name_char_list_size            * sizeof(char)                ) +
+            (name_id_list_size          * sizeof(unsigned)            ) +
+            (via_node_list_size         * sizeof(NodeID)              ) +
+            (graph_node_list_size       * sizeof(QueryGraph::_StrNode)) ;
+        return result;
+    }
+    uint64_t GetTimeStampOffset() const {
+        uint64_t result =
+            (name_index_list_size       * sizeof(unsigned)            ) +
+            (name_char_list_size        * sizeof(char)                ) +
+            (name_id_list_size          * sizeof(unsigned)            ) +
+            (via_node_list_size         * sizeof(NodeID)              ) +
+            (graph_node_list_size       * sizeof(QueryGraph::_StrNode)) +
+            (graph_edge_list_size       * sizeof(QueryGraph::_StrEdge));
+        return result;
+    }
+    uint64_t GetCoordinateListOffset() const {
+        uint64_t result =
+            (name_index_list_size       * sizeof(unsigned)            ) +
+            (name_char_list_size        * sizeof(char)                ) +
+            (name_id_list_size          * sizeof(unsigned)            ) +
+            (via_node_list_size         * sizeof(NodeID)              ) +
+            (graph_node_list_size       * sizeof(QueryGraph::_StrNode)) +
+            (graph_edge_list_size       * sizeof(QueryGraph::_StrEdge)) +
+            (timestamp_length           * sizeof(char)                );
+        return result;
+    }
+    uint64_t GetTurnInstructionListOffset() const {
+        uint64_t result =
+            (name_index_list_size       * sizeof(unsigned)            ) +
+            (name_char_list_size        * sizeof(char)                ) +
+            (name_id_list_size          * sizeof(unsigned)            ) +
+            (via_node_list_size         * sizeof(NodeID)              ) +
+            (graph_node_list_size       * sizeof(QueryGraph::_StrNode)) +
+            (graph_edge_list_size       * sizeof(QueryGraph::_StrEdge)) +
+            (timestamp_length           * sizeof(char)                ) +
+            (coordinate_list_size       * sizeof(FixedPointCoordinate));
+        return result;
+    }
+    uint64_t GetRSearchTreeOffset() const {
+        uint64_t result =
+            (name_index_list_size       * sizeof(unsigned)            ) +
+            (name_char_list_size        * sizeof(char)                ) +
+            (name_id_list_size          * sizeof(unsigned)            ) +
+            (via_node_list_size         * sizeof(NodeID)              ) +
+            (graph_node_list_size       * sizeof(QueryGraph::_StrNode)) +
+            (graph_edge_list_size       * sizeof(QueryGraph::_StrEdge)) +
+            (timestamp_length           * sizeof(char)                ) +
+            (coordinate_list_size       * sizeof(FixedPointCoordinate)) +
+            (turn_instruction_list_size * sizeof(TurnInstructions)    );
+        return result;
+    }
+    uint64_t GetChecksumOffset() const {
+        uint64_t result =
+            (name_index_list_size       * sizeof(unsigned)            ) +
+            (name_char_list_size        * sizeof(char)                ) +
+            (name_id_list_size          * sizeof(unsigned)            ) +
+            (via_node_list_size         * sizeof(NodeID)              ) +
+            (graph_node_list_size       * sizeof(QueryGraph::_StrNode)) +
+            (graph_edge_list_size       * sizeof(QueryGraph::_StrEdge)) +
+            (timestamp_length           * sizeof(char)                ) +
+            (coordinate_list_size       * sizeof(FixedPointCoordinate)) +
+            (turn_instruction_list_size * sizeof(TurnInstructions)    ) +
+            (r_search_tree_size         * sizeof(RTreeNode)           );
+        return result;
+    }
+};
+
+enum SharedDataType {
+    CURRENT_REGIONS,
+    LAYOUT_1,
+    DATA_1,
+    LAYOUT_2,
+    DATA_2,
+    LAYOUT_NONE,
+    DATA_NONE
+};
+
+struct SharedDataTimestamp {
+    SharedDataType layout;
+    SharedDataType data;
+    unsigned timestamp;
+};
+
+#endif /* SHARED_DATA_TYPE_H_ */

Server/Http/CompressionType.h

@@ -0,0 +1,41 @@
+/*
+
+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 BASIC_DATASTRUCTURES_H
+#define BASIC_DATASTRUCTURES_H
+
+namespace http {
+
+enum CompressionType {
+    noCompression,
+    gzipRFC1952,
+    deflateRFC1951
+};
+
+} // namespace http
+
+#endif //BASIC_DATASTRUCTURES_H

Server/Http/Header.h

@@ -0,0 +1,46 @@
+/*
+
+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 HTTP_HEADER_H
+#define HTTP_HEADER_H
+
+#include <string>
+
+namespace http {
+
+    struct Header {
+        std::string name;
+        std::string value;
+        void Clear() {
+            name.clear();
+            value.clear();
+        }
+    };
+}
+
+#endif //HTTP_HEADER_H
+