Merge branch 'develop' for release v0.3.8

cleanup indentation of lua profiles

.gitignore

@@ -72,8 +72,12 @@ stxxl.errlog
 /win/bin/
 /win/bin-debug/
 /osrm-extract
+/osrm-io-benchmark
+/osrm-components
 /osrm-routed
+/osrm-datastore
 /osrm-prepare
+/osrm-unlock-all
 /osrm-cli
 /nohup.out
 

.travis.yml

@@ -2,26 +2,35 @@ language: cpp
 compiler:
   - gcc
 #  - clang
+# Make sure CMake is installed
 install:
  - sudo apt-get update >/dev/null
- - sudo apt-get -q install libprotoc-dev libprotobuf7 protobuf-compiler libprotobuf-dev libosmpbf-dev libpng12-dev libbz2-dev libstxxl-dev libstxxl-doc libstxxl1 libxml2-dev libzip-dev libboost1.46-all-dev lua5.1 liblua5.1-0-dev libluabind-dev rubygems osmosis
+ - sudo apt-get -q install libprotoc-dev libprotobuf7 libprotobuf-dev libosmpbf-dev libbz2-dev libstxxl-dev libstxxl1 libxml2-dev libzip-dev libboost1.46-all-dev lua5.1 liblua5.1-0-dev libluabind-dev rubygems
+ - curl -s https://gist.githubusercontent.com/DennisOSRM/803a64a9178ec375069f/raw/ | sudo bash
 before_script:
- - sudo gem install bundler
+ - rvm use 1.9.3
+ - gem install bundler
  - bundle install
  - mkdir build
  - cd build
  - cmake .. $CMAKEOPTIONS
-script: make
-after_script:
+script:
+ - make -j 2
  - cd ..
  - cucumber -p verify
+after_script:
+# - cd ..
+# - cucumber -p verify
 branches:
   only:
     - master
     - develop
+cache:
+- bundler
+- apt
 env:
- - CMAKEOPTIONS="-DCMAKE_BUILD_TYPE=Release"
- - CMAKEOPTIONS="-DCMAKE_BUILD_TYPE=Debug"
+ - CMAKEOPTIONS="-DCMAKE_BUILD_TYPE=Release" OSRM_PORT=5000 OSRM_TIMEOUT=60
+ - CMAKEOPTIONS="-DCMAKE_BUILD_TYPE=Debug" OSRM_PORT=5010 OSRM_TIMEOUT=60
 notifications:
  irc:
   channels:
@@ -30,6 +39,7 @@ notifications:
   on_failure: always
   use_notice: true
   skip_join: false
+
   recipients:
     - dennis@mapbox.com
   email:

Algorithms/CRC32.cpp

@@ -1,92 +0,0 @@
-/*
-
-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 "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/DouglasPeucker.cpp

@@ -0,0 +1,198 @@
+/*
+
+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"
+#include "../DataStructures/SegmentInformation.h"
+#include "../Util/MercatorUtil.h"
+
+#include <limits>
+
+//These thresholds are more or less heuristically chosen.
+static double DouglasPeuckerThresholds[19] = {
+      262144., //z0
+      131072., //z1
+       65536., //z2
+       32768., //z3
+       16384., //z4
+        8192., //z5
+        4096., //z6
+        2048., //z7
+         960., //z8
+         480., //z9
+         240., //z10
+          90., //z11
+          50., //z12
+          25., //z13
+          15., //z14
+           5., //z15
+            .65, //z16
+            .5, //z17
+            .35  //z18
+};
+
+/**
+ * Yuck! Code duplication. This function is also in EgdeBasedNode.h
+ */
+double DouglasPeucker::ComputeDistance(
+    const FixedPointCoordinate& point,
+    const FixedPointCoordinate& segA,
+    const FixedPointCoordinate& segB
+) const {
+    const double x = lat2y(point.lat/COORDINATE_PRECISION);
+    const double y = point.lon/COORDINATE_PRECISION;
+    const double a = lat2y(segA.lat/COORDINATE_PRECISION);
+    const double b = segA.lon/COORDINATE_PRECISION;
+    const double c = lat2y(segB.lat/COORDINATE_PRECISION);
+    const double d = segB.lon/COORDINATE_PRECISION;
+    double p,q,nY;
+    if( std::abs(a-c) > std::numeric_limits<double>::epsilon() ){
+        const double m = (d-b)/(c-a); // slope
+        // Projection of (x,y) on line joining (a,b) and (c,d)
+        p = ((x + (m*y)) + (m*m*a - m*b))/(1. + m*m);
+        q = b + m*(p - a);
+    } else {
+        p = c;
+        q = y;
+    }
+    nY = (d*p - c*q)/(a*d - b*c);
+
+    //discretize the result to coordinate precision. it's a hack!
+    if( std::abs(nY) < (1./COORDINATE_PRECISION) ) {
+        nY = 0.;
+    }
+
+    double r = (p - nY*a)/c;
+    if( std::isnan(r) ) {
+        r = ((segB.lat == point.lat) && (segB.lon == point.lon)) ? 1. : 0.;
+    } else if( std::abs(r) <= std::numeric_limits<double>::epsilon() ) {
+        r = 0.;
+    } else if( std::abs(r-1.) <= std::numeric_limits<double>::epsilon() ) {
+        r = 1.;
+    }
+    FixedPointCoordinate nearest_location;
+    BOOST_ASSERT( !std::isnan(r) );
+    if( r <= 0. ){
+        nearest_location.lat = segA.lat;
+        nearest_location.lon = segA.lon;
+    } else if( r >= 1. ){
+        nearest_location.lat = segB.lat;
+        nearest_location.lon = segB.lon;
+    } else { // point lies in between
+        nearest_location.lat = y2lat(p)*COORDINATE_PRECISION;
+        nearest_location.lon = q*COORDINATE_PRECISION;
+    }
+    BOOST_ASSERT( nearest_location.isValid() );
+    const double approximated_distance = FixedPointCoordinate::ApproximateEuclideanDistance(
+        point,
+        nearest_location
+    );
+    BOOST_ASSERT( 0. <= approximated_distance );
+    return approximated_distance;
+}
+
+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 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"
+        );
+        double max_distance = std::numeric_limits<double>::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 = ComputeDistance(
+                                    input_geometry[i].location,
+                                    input_geometry[pair.first].location,
+                                    input_geometry[pair.second].location
+                                );
+            const double distance = std::abs(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/DouglasPeucker.h

@@ -28,9 +28,12 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef DOUGLASPEUCKER_H_
 #define DOUGLASPEUCKER_H_
 
-#include "../DataStructures/Coordinate.h"
+#include "../Util/SimpleLogger.h"
+
+#include <osrm/Coordinate.h>
 
 #include <boost/assert.hpp>
+#include <boost/foreach.hpp>
 
 #include <cmath>
 
@@ -38,133 +41,32 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <stack>
 #include <vector>
 
-/*This class object computes the bitvector of indicating generalized input points
- * according to the (Ramer-)Douglas-Peucker algorithm.
+/* This class object computes the bitvector of indicating generalized input
+ * points according to the (Ramer-)Douglas-Peucker algorithm.
  *
- * Input is vector of pairs. Each pair consists of the point information and a bit
- * indicating if the points is present in the generalization.
+ * Input is vector of pairs. Each pair consists of the point information and a
+ * bit 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. };
+struct SegmentInformation;
 
-template<class PointT>
 class DouglasPeucker {
 private:
     typedef std::pair<std::size_t, std::size_t> PairOfPoints;
     //Stack to simulate the recursion
-    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 = ( 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;
-    }
-
+    std::stack<PairOfPoints> recursion_stack;
 
+    double ComputeDistance(
+        const FixedPointCoordinate& point,
+        const FixedPointCoordinate& segA,
+        const FixedPointCoordinate& segB
+    ) const;
 public:
-    void Run(std::vector<PointT> & 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"
-                );
+    void Run(
+        std::vector<SegmentInformation> & input_geometry,
+        const unsigned zoom_level
+    );
 
-                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)
-                    );
-                }
-            }
-        }
-    }
 };
 
 #endif /* DOUGLASPEUCKER_H_ */

Algorithms/IteratorBasedCRC32.h

@@ -25,32 +25,55 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 */
 
-#ifndef ITERATORBASEDCRC32_H_
-#define ITERATORBASEDCRC32_H_
+#ifndef ITERATOR_BASED_CRC32_H
+#define ITERATOR_BASED_CRC32_H
 
 #include "../Util/SimpleLogger.h"
 
-#include <boost/crc.hpp>  // for boost::crc_32_type
 #include <iostream>
 
+#if defined(__x86_64__)
+    #include <cpuid.h>
+#else
+    #include <boost/crc.hpp>  // for boost::crc_32_type
+
+    inline void __get_cpuid(
+        int param,
+        unsigned *eax,
+        unsigned *ebx,
+        unsigned *ecx,
+        unsigned *edx
+    ) { *ecx = 0; }
+#endif
+
 template<class ContainerT>
 class IteratorbasedCRC32 {
 private:
-    typedef typename ContainerT::iterator ContainerT_iterator;
+    typedef typename ContainerT::iterator IteratorType;
     unsigned crc;
 
-    typedef boost::crc_optimal<32, 0x1EDC6F41, 0x0, 0x0, true, true> my_crc_32_type;
-    typedef unsigned (IteratorbasedCRC32::*CRC32CFunctionPtr)(char *str, unsigned len, unsigned crc);
+    bool use_SSE42_CRC_function;
 
-    unsigned 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();
+#if !defined(__x86_64__)
+        boost::crc_optimal<32, 0x1EDC6F41, 0x0, 0x0, true, true> CRC32_processor;
+#endif
+    unsigned SoftwareBasedCRC32( char *str, unsigned len )
+    {
+#if !defined(__x86_64__)
+        CRC32_processor.process_bytes( str, len);
+        return CRC32_processor.checksum();
+#else
+        return 0;
+#endif
     }
-    unsigned SSEBasedCRC32( char *str, unsigned len, unsigned crc){
-        unsigned q=len/sizeof(unsigned),
-                r=len%sizeof(unsigned),
-                *p=(unsigned*)str/*, crc*/;
+
+    // adapted from http://byteworm.com/2010/10/13/crc32/
+    unsigned SSE42BasedCRC32( char *str, unsigned len )
+    {
+#if defined(__x86_64__)
+        unsigned q = len/sizeof(unsigned);
+        unsigned r = len%sizeof(unsigned);
+        unsigned *p = (unsigned*)str;
 
         //crc=0;
         while (q--) {
@@ -71,47 +94,55 @@ private:
             );
             ++str;
         }
+#endif
         return crc;
     }
 
-    unsigned cpuid(unsigned functionInput){
-        unsigned eax;
-        unsigned ebx;
-        unsigned ecx;
-        unsigned edx;
-        asm("cpuid" : "=a" (eax), "=b" (ebx), "=c" (ecx), "=d" (edx) : "a" (functionInput));
+    inline unsigned cpuid() const
+    {
+        unsigned eax = 0, ebx = 0, ecx = 0, edx = 0;
+        // on X64 this calls hardware cpuid(.) instr. otherwise a dummy impl.
+        __get_cpuid( 1, &eax,  &ebx, &ecx, &edx );
         return ecx;
     }
 
-    CRC32CFunctionPtr detectBestCRC32C(){
-        static const int SSE42_BIT = 20;
-        unsigned ecx = cpuid(1);
-        bool hasSSE42 = ecx & (1 << SSE42_BIT);
-        if (hasSSE42) {
+    bool DetectNativeCRC32Support()
+    {
+        static const int SSE42_BIT = 0x00100000;
+        const unsigned ecx = cpuid();
+        const bool has_SSE42 = ecx & SSE42_BIT;
+        if (has_SSE42) {
             SimpleLogger().Write() << "using hardware based CRC32 computation";
-            return &IteratorbasedCRC32::SSEBasedCRC32; //crc32 hardware accelarated;
         } else {
             SimpleLogger().Write() << "using software based CRC32 computation";
-            return &IteratorbasedCRC32::SoftwareBasedCRC32; //crc32cSlicingBy8;
         }
+        return has_SSE42;
     }
-    CRC32CFunctionPtr crcFunction;
+
 public:
-    IteratorbasedCRC32(): crc(0) {
-        crcFunction = detectBestCRC32C();
+    IteratorbasedCRC32() : crc(0)
+    {
+        use_SSE42_CRC_function = DetectNativeCRC32Support();
     }
 
-    virtual ~IteratorbasedCRC32() { }
-
-    unsigned operator()( ContainerT_iterator iter, const ContainerT_iterator end) {
+    unsigned operator()( IteratorType iter, const IteratorType end )
+    {
         unsigned crc = 0;
         while(iter != end) {
             char * data = reinterpret_cast<char*>(&(*iter) );
-            crc =((*this).*(crcFunction))(data, sizeof(typename ContainerT::value_type*), crc);
+
+            if (use_SSE42_CRC_function)
+            {
+                crc = SSE42BasedCRC32( data, sizeof(typename ContainerT::value_type) );
+            }
+            else
+            {
+                crc = SoftwareBasedCRC32( data, sizeof(typename ContainerT::value_type) );
+            }
             ++iter;
         }
         return crc;
     }
 };
 
-#endif /* ITERATORBASEDCRC32_H_ */
+#endif /* ITERATOR_BASED_CRC32_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++) {
+        FixedPointCoordinate::convertInternalLatLonToString(polyline[i].lat, tmp);
+        output += "[";
+        output += tmp;
+        FixedPointCoordinate::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;
+        }
+        FixedPointCoordinate::convertInternalLatLonToString(polyline[i].location.lat, tmp);
+        output += "[";
+        output += tmp;
+        FixedPointCoordinate::convertInternalLatLonToString(polyline[i].location.lon, tmp);
+        output += ", ";
+        output += tmp;
+        output += "]";
+        if( i < polyline.size()-1 ) {
+            output += ",";
+        }
+    }
+    output += "]";
+}

Algorithms/PolylineCompressor.h

@@ -32,112 +32,38 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #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

@@ -28,7 +28,6 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef STRONGLYCONNECTEDCOMPONENTS_H_
 #define STRONGLYCONNECTEDCOMPONENTS_H_
 
-#include "../DataStructures/Coordinate.h"
 #include "../DataStructures/DeallocatingVector.h"
 #include "../DataStructures/DynamicGraph.h"
 #include "../DataStructures/ImportEdge.h"
@@ -39,6 +38,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "../Util/SimpleLogger.h"
 
+#include <osrm/Coordinate.h>
+
 #include <boost/assert.hpp>
 #include <boost/filesystem.hpp>
 #include <boost/foreach.hpp>
@@ -385,7 +386,7 @@ public:
                 }
                 const TarjanDynamicGraph::NodeIterator v = m_node_based_graph->GetTarget(e1);
 
-                total_network_distance += 100*ApproximateDistance(
+                total_network_distance += 100*FixedPointCoordinate::ApproximateDistance(
                         m_coordinate_list[u].lat,
                         m_coordinate_list[u].lon,
                         m_coordinate_list[v].lat,

CMakeLists.txt

@@ -1,168 +1,269 @@
 cmake_minimum_required(VERSION 2.6)
-set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 project(OSRM)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+include(CheckCXXCompilerFlag)
 include(FindPackageHandleStandardArgs)
-set(HUGO "${CMAKE_CURRENT_SOURCE_DIR}")
 
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake")
 include(GetGitRevisionDescription)
 git_describe(GIT_DESCRIPTION)
 
-TRY_RUN(SHARED_LIBRARY_PATH_TYPE SHARED_LIBRARY_PATH_INFO_COMPILED ${PROJECT_BINARY_DIR}/CMakeTmp ${PROJECT_SOURCE_DIR}/cmake/size.cpp OUTPUT_VARIABLE IS_64_SYSTEM)
-if(IS_64_SYSTEM)
-	message(STATUS "System supports 64 bits.")
-	set( HAS64BITS 1 )
-else(IS_64_SYSTEM)
-	MESSAGE(WARNING "Compiling on a 32 bit system is unsupported!")
-	set( HAS64BITS 0 )
-endif(IS_64_SYSTEM)
-
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
 
+set(bitness 32)
+if(CMAKE_SIZEOF_VOID_P EQUAL 8)
+  set(bitness 64)
+  message(STATUS "Building on a 64 bit system")
+else()
+  message(WARNING "Building on a 32 bit system is unsupported")
+endif()
+
+include_directories(${CMAKE_SOURCE_DIR}/Include/)
+
 add_custom_command(OUTPUT ${CMAKE_SOURCE_DIR}/Util/UUID.cpp UUID.cpp.alwaysbuild
   COMMAND ${CMAKE_COMMAND} -DSOURCE_DIR=${CMAKE_SOURCE_DIR}
     -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/UUID-Config.cmake
   DEPENDS
     ${CMAKE_SOURCE_DIR}/Util/UUID.cpp.in
-  	${CMAKE_SOURCE_DIR}/cmake/UUID-Config.cmake
+    ${CMAKE_SOURCE_DIR}/cmake/UUID-Config.cmake
   COMMENT "Configuring UUID.cpp"
   VERBATIM)
 
-add_custom_target(UUIDConfigure DEPENDS ${CMAKE_SOURCE_DIR}/Util/UUID.cpp )
+add_custom_target(UUIDConfigure DEPENDS ${CMAKE_SOURCE_DIR}/Util/UUID.cpp)
 
-set(BOOST_COMPONENTS filesystem program_options regex system thread)
+set(BOOST_COMPONENTS date_time filesystem iostreams program_options regex system thread)
 
-configure_file(Util/GitDescription.cpp.in ${CMAKE_SOURCE_DIR}/Util/GitDescription.cpp)
+configure_file(
+  ${CMAKE_SOURCE_DIR}/Util/GitDescription.cpp.in
+  ${CMAKE_SOURCE_DIR}/Util/GitDescription.cpp
+)
 file(GLOB ExtractorGlob Extractor/*.cpp)
-set(ExtractorSources extractor.cpp ${ExtractorGlob} Util/GitDescription.cpp)
-add_executable(osrm-extract ${ExtractorSources} )
+set(ExtractorSources extractor.cpp ${ExtractorGlob})
+add_executable(osrm-extract ${ExtractorSources})
 
-file(GLOB PrepareGlob Contractor/*.cpp)
-set(PrepareSources createHierarchy.cpp ${PrepareGlob} Util/GitDescription.cpp)
-add_executable(osrm-prepare ${PrepareSources} )
-
-add_executable(osrm-routed routed.cpp Util/GitDescription.cpp)
-set_target_properties(osrm-routed PROPERTIES COMPILE_FLAGS -DROUTED)
+file(GLOB PrepareGlob Contractor/*.cpp DataStructures/HilbertValue.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/SearchEngineData.cpp)
+file(GLOB CoordinateGlob DataStructures/Coordinate.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})
+set(
+  OSRMSources
+  ${LibOSRMGlob}
+  ${DescriptorGlob}
+  ${DatastructureGlob}
+  ${CoordinateGlob}
+  ${AlgorithmGlob}
+  ${HttpGlob}
+)
+add_library(COORDLIB STATIC ${CoordinateGlob})
+add_library(OSRM ${OSRMSources} Util/GitDescription.cpp Util/UUID.cpp)
 add_library(UUID STATIC Util/UUID.cpp)
-add_dependencies( UUID UUIDConfigure )
+add_library(GITDESCRIPTION STATIC Util/GitDescription.cpp)
+add_dependencies(UUID UUIDConfigure)
+add_dependencies(GITDESCRIPTION GIT_DESCRIPTION)
+
+add_executable(osrm-routed routed.cpp ${ServerGlob})
+set_target_properties(osrm-routed PROPERTIES COMPILE_FLAGS -DROUTED)
+add_executable(osrm-datastore datastore.cpp)
 
 # Check the release mode
 if(NOT CMAKE_BUILD_TYPE MATCHES Debug)
-	set(CMAKE_BUILD_TYPE Release)
-endif(NOT CMAKE_BUILD_TYPE MATCHES Debug)
+  set(CMAKE_BUILD_TYPE Release)
+endif()
 if(CMAKE_BUILD_TYPE MATCHES Debug)
-    message(STATUS "Configuring OSRM in debug mode")
-endif(CMAKE_BUILD_TYPE MATCHES Debug)
+  message(STATUS "Configuring OSRM in debug mode")
+  if(NOT "${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+    message(STATUS "adding profiling flags")
+    set(CMAKE_CXX_FLAGS "${CMAKE_C_FLAGS} -fprofile-arcs -ftest-coverage -fno-inline")
+    set(CMAKE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fprofile-arcs -ftest-coverage -fno-inline")
+  endif()
+endif()
 if(CMAKE_BUILD_TYPE MATCHES Release)
     message(STATUS "Configuring OSRM in release mode")
-endif(CMAKE_BUILD_TYPE MATCHES Release)
-
-#Configuring compilers
-if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
-	# using Clang
-	set(CMAKE_CXX_FLAGS "-Wall -Wno-unknown-pragmas -Wno-unneeded-internal-declaration")
-	message(STATUS "OpenMP parallelization not available using clang++")
-elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-	# using GCC
-	set(CMAKE_CXX_FLAGS "-Wall -fopenmp -pedantic")
-elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Intel")
-	# using Intel C++
-	set(CMAKE_CXX_FLAGS "-static-intel -wd10237 -Wall -openmp -ipo")
-elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-	# using Visual Studio C++
 endif()
 
+# Configuring compilers
+if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+  # using Clang
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wno-unknown-pragmas -Wno-unneeded-internal-declaration -pedantic -fPIC")
+  message(STATUS "OpenMP parallelization not available using clang++")
+elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+  # using GCC
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -fopenmp -pedantic -fPIC")
+elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Intel")
+  # using Intel C++
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -static-intel -wd10237 -Wall -openmp -ipo -fPIC")
+elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+  # using Visual Studio C++
+endif()
+
+# Check if LTO is available
+set(LTO_FLAGS "")
+CHECK_CXX_COMPILER_FLAG("-flto" HAS_LTO_FLAG)
+if    (HAS_LTO_FLAG)
+  set(LTO_FLAGS "${LTO_FLAGS} -flto")
+endif (HAS_LTO_FLAG)
+
+# disable partitioning of LTO process when possible (fixes Debian issues)
+set(LTO_PARTITION_FLAGS "")
+CHECK_CXX_COMPILER_FLAG("-flto-partition=none" HAS_LTO_PARTITION_FLAG)
+if    (HAS_LTO_PARTITION_FLAG)
+  set(LTO_PARTITION_FLAGS "${LTO_PARTITION_FLAGS} -flto-partition=none")
+endif (HAS_LTO_PARTITION_FLAG)
+
+# Add Link-Time-Optimization flags, if supported (GCC >= 4.5) and enabled
+set(CMAKE_CXX_FLAGS           "${CMAKE_CXX_FLAGS}           ${LTO_FLAGS}")
+set(CMAKE_EXE_LINKER_FLAGS    "${CMAKE_EXE_LINKER_FLAGS}    ${LTO_FLAGS} ${LTO_PARTITION_FLAGS}")
+set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${LTO_FLAGS} ${LTO_PARTITION_FLAGS}")
+
+# Configuring other platform dependencies
 if(APPLE)
-	SET(CMAKE_OSX_ARCHITECTURES "x86_64")
-	message("Set Architecture to x64 on OS X")
+  set(CMAKE_OSX_ARCHITECTURES "x86_64")
+  message(STATUS "Set Architecture to x64 on OS X")
+  exec_program(uname ARGS -v  OUTPUT_VARIABLE DARWIN_VERSION)
+  string(REGEX MATCH "[0-9]+" DARWIN_VERSION ${DARWIN_VERSION})
+  if(DARWIN_VERSION GREATER 12 AND NOT OSXLIBSTD)
+    message(STATUS "Activating -std=c++11 flag for >= OS X 10.9")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+  endif()
+  if(OSXLIBSTD)
+    message(STATUS "linking against ${OSXLIBSTD}")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=${OSXLIBSTD}")
+  elseif(DARWIN_VERSION GREATER 12)
+    message(STATUS "linking against libc++")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++")
+  endif()
+endif()
+
+if(UNIX AND NOT APPLE)
+  target_link_libraries(osrm-datastore rt)
+  target_link_libraries(OSRM rt)
 endif()
 
 #Check Boost
-set(BOOST_MIN_VERSION "1.44.0")
-find_package( Boost ${BOOST_MIN_VERSION} COMPONENTS ${BOOST_COMPONENTS} REQUIRED )
-if (NOT Boost_FOUND)
-      message(FATAL_ERROR "Fatal error: Boost (version >= 1.44.0) required.\n")
-endif (NOT Boost_FOUND)
+set(BOOST_MIN_VERSION "1.46.0")
+find_package(Boost ${BOOST_MIN_VERSION} COMPONENTS ${BOOST_COMPONENTS} REQUIRED)
+if(NOT Boost_FOUND)
+  message(FATAL_ERROR "Fatal error: Boost (version >= 1.46.0) required.\n")
+endif()
 include_directories(${Boost_INCLUDE_DIRS})
 
-IF( APPLE )
-	target_link_libraries( OSRM ${Boost_LIBRARIES} UUID )
-ELSE( APPLE )
-	target_link_libraries( OSRM ${Boost_LIBRARIES} )
-ENDIF( APPLE )
-target_link_libraries( osrm-extract ${Boost_LIBRARIES} UUID )
-target_link_libraries( osrm-prepare ${Boost_LIBRARIES} UUID )
-target_link_libraries( osrm-routed ${Boost_LIBRARIES} OSRM UUID )
+target_link_libraries(OSRM ${Boost_LIBRARIES} COORDLIB)
+target_link_libraries(osrm-extract ${Boost_LIBRARIES} UUID GITDESCRIPTION COORDLIB)
+target_link_libraries(osrm-prepare ${Boost_LIBRARIES} UUID GITDESCRIPTION COORDLIB)
+target_link_libraries(osrm-routed ${Boost_LIBRARIES} OSRM UUID GITDESCRIPTION)
+target_link_libraries(osrm-datastore ${Boost_LIBRARIES} UUID GITDESCRIPTION COORDLIB)
 
-find_package ( BZip2 REQUIRED )
-include_directories(${BZIP_INCLUDE_DIRS})
-target_link_libraries (osrm-extract ${BZIP2_LIBRARIES})
+find_package(Threads REQUIRED)
+target_link_libraries(osrm-extract ${CMAKE_THREAD_LIBS_INIT})
 
-find_package( ZLIB REQUIRED )
-include_directories(${ZLIB_INCLUDE_DIRS})
-target_link_libraries (osrm-extract ${ZLIB_LIBRARY})
-target_link_libraries (osrm-routed ${ZLIB_LIBRARY})
+find_package(Lua52)
+if(NOT LUA52_FOUND)
+  find_package(Lua51 REQUIRED)
+  if(NOT APPLE)
+    find_package(LuaJIT 5.1)
+  endif()
+else()
+  if(NOT APPLE)
+    find_package(LuaJIT 5.2)
+  endif()
+endif()
 
-find_package( Threads REQUIRED )
-target_link_libraries (osrm-extract ${Threads_LIBRARY})
+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( 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( LibXml2 REQUIRED )
+find_package(LibXml2 REQUIRED)
 include_directories(${LIBXML2_INCLUDE_DIR})
-target_link_libraries (osrm-extract ${LIBXML2_LIBRARIES})
+target_link_libraries(osrm-extract ${LIBXML2_LIBRARIES})
 
 find_package( Luabind REQUIRED )
 include_directories(${LUABIND_INCLUDE_DIR})
-target_link_libraries (osrm-extract ${LUABIND_LIBRARY})
-target_link_libraries (osrm-prepare ${LUABIND_LIBRARY})
-
-find_package( Protobuf REQUIRED )
-include_directories(${PROTOBUF_INCLUDE_DIRS})
-target_link_libraries (osrm-extract ${PROTOBUF_LIBRARY})
-target_link_libraries (osrm-prepare ${PROTOBUF_LIBRARY})
+target_link_libraries(osrm-extract ${LUABIND_LIBRARY})
+target_link_libraries(osrm-prepare ${LUABIND_LIBRARY})
 
 find_package( STXXL REQUIRED )
 include_directories(${STXXL_INCLUDE_DIR})
-target_link_libraries (OSRM ${STXXL_LIBRARY})
-target_link_libraries (osrm-extract ${STXXL_LIBRARY})
-target_link_libraries (osrm-prepare ${STXXL_LIBRARY})
+target_link_libraries(OSRM ${STXXL_LIBRARY})
+target_link_libraries(osrm-extract ${STXXL_LIBRARY})
+target_link_libraries(osrm-prepare ${STXXL_LIBRARY})
 
 find_package( OSMPBF REQUIRED )
 include_directories(${OSMPBF_INCLUDE_DIR})
-target_link_libraries (osrm-extract ${OSMPBF_LIBRARY})
-target_link_libraries (osrm-prepare ${OSMPBF_LIBRARY})
+target_link_libraries(osrm-extract ${OSMPBF_LIBRARY})
+target_link_libraries(osrm-prepare ${OSMPBF_LIBRARY})
+
+find_package(Protobuf REQUIRED)
+include_directories(${PROTOBUF_INCLUDE_DIRS})
+target_link_libraries(osrm-extract ${PROTOBUF_LIBRARY})
+target_link_libraries(osrm-prepare ${PROTOBUF_LIBRARY})
+
+find_package(BZip2 REQUIRED)
+include_directories(${BZIP_INCLUDE_DIRS})
+target_link_libraries(osrm-extract ${BZIP2_LIBRARIES})
+
+find_package(ZLIB REQUIRED)
+include_directories(${ZLIB_INCLUDE_DIRS})
+target_link_libraries(osrm-extract ${ZLIB_LIBRARY})
+target_link_libraries(osrm-routed ${ZLIB_LIBRARY})
 
 if(WITH_TOOLS)
-	message("-- 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
-		)
-	endif(GDAL_FOUND)
-	add_executable ( osrm-cli Tools/simpleclient.cpp Util/GitDescription.cpp)
-	target_link_libraries( osrm-cli ${Boost_LIBRARIES} OSRM UUID )
-    add_executable ( osrm-io-benchmark Tools/io-benchmark.cpp )
-    target_link_libraries( osrm-io-benchmark ${Boost_LIBRARIES} )
-endif(WITH_TOOLS)
+  message(STATUS "Activating OSRM internal tools")
+  find_package(GDAL)
+  if(GDAL_FOUND)
+    add_executable(osrm-components Tools/componentAnalysis.cpp)
+    include_directories(${GDAL_INCLUDE_DIR})
+    target_link_libraries(
+      osrm-components
+      ${GDAL_LIBRARIES} ${Boost_LIBRARIES} UUID GITDESCRIPTION COORDLIB)
+  endif()
+  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()
+endif()
+
+file(GLOB InstallGlob Include/osrm/*.h Library/OSRM.h)
+
+# Add RPATH info to executables so that when they are run after being installed
+# (i.e., from /usr/local/bin/) the linker can find library dependencies. For
+# more info see http://www.cmake.org/Wiki/CMake_RPATH_handling
+set_property(TARGET osrm-extract PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
+set_property(TARGET osrm-prepare PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
+set_property(TARGET osrm-datastore PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
+set_property(TARGET osrm-routed PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
+
+install(FILES ${InstallGlob} DESTINATION include/osrm)
+install(TARGETS osrm-extract DESTINATION bin)
+install(TARGETS osrm-prepare DESTINATION bin)
+install(TARGETS osrm-datastore DESTINATION bin)
+install(TARGETS osrm-routed DESTINATION bin)
+install(TARGETS OSRM DESTINATION lib)
+list(GET Boost_LIBRARIES 1 BOOST_LIBRARY_FIRST)
+get_filename_component(BOOST_LIBRARY_LISTING "${BOOST_LIBRARY_FIRST}" PATH)
+set(BOOST_LIBRARY_LISTING "-L${BOOST_LIBRARY_LISTING}")
+foreach (lib ${Boost_LIBRARIES})
+  get_filename_component(BOOST_LIBRARY_NAME "${lib}" NAME_WE)
+  string(REPLACE "lib" "" BOOST_LIBRARY_NAME ${BOOST_LIBRARY_NAME})
+  set(BOOST_LIBRARY_LISTING "${BOOST_LIBRARY_LISTING} -l${BOOST_LIBRARY_NAME}")
+endforeach ()
+
+configure_file(${CMAKE_SOURCE_DIR}/cmake/pkgconfig.in libosrm.pc @ONLY)
+install(FILES ${PROJECT_BINARY_DIR}/libosrm.pc DESTINATION lib/pkgconfig)

Contractor/Contractor.h

@@ -45,8 +45,6 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <boost/make_shared.hpp>
 #include <boost/shared_ptr.hpp>
 
-#include <ctime>
-
 #include <algorithm>
 #include <limits>
 #include <vector>
@@ -54,10 +52,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 class Contractor {
 
 private:
-    struct _ContractorEdgeData {
-        _ContractorEdgeData() :
+    struct ContractorEdgeData {
+        ContractorEdgeData() :
             distance(0), id(0), originalEdges(0), shortcut(0), forward(0), backward(0), originalViaNodeID(false) {}
-        _ContractorEdgeData( unsigned _distance, unsigned _originalEdges, unsigned _id, bool _shortcut, bool _forward, bool _backward) :
+        ContractorEdgeData( unsigned _distance, unsigned _originalEdges, unsigned _id, bool _shortcut, bool _forward, bool _backward) :
             distance(_distance), id(_id), originalEdges(std::min((unsigned)1<<28, _originalEdges) ), shortcut(_shortcut), forward(_forward), backward(_backward), originalViaNodeID(false) {}
         unsigned distance;
         unsigned id;
@@ -75,7 +73,7 @@ private:
         _HeapData( short h, bool t ) : hop(h), target(t) {}
     };
 
-    typedef DynamicGraph< _ContractorEdgeData > _DynamicGraph;
+    typedef DynamicGraph< ContractorEdgeData > _DynamicGraph;
     //    typedef BinaryHeap< NodeID, NodeID, int, _HeapData, ArrayStorage<NodeID, NodeID> > _Heap;
     typedef BinaryHeap< NodeID, NodeID, int, _HeapData, XORFastHashStorage<NodeID, NodeID> > _Heap;
     typedef _DynamicGraph::InputEdge _ContractorEdge;
@@ -118,6 +116,7 @@ public:
     Contractor( int nodes, ContainerT& inputEdges) {
         std::vector< _ContractorEdge > edges;
         edges.reserve(inputEdges.size()*2);
+        temp_edge_counter = 0;
 
         typename ContainerT::deallocation_iterator diter = inputEdges.dbegin();
         typename ContainerT::deallocation_iterator dend  = inputEdges.dend();
@@ -126,7 +125,7 @@ public:
         while(diter!=dend) {
             newEdge.source = diter->source();
             newEdge.target = diter->target();
-            newEdge.data = _ContractorEdgeData( (std::max)((int)diter->weight(), 1 ),  1,  diter->id(),  false,  diter->isForward(),  diter->isBackward());
+            newEdge.data = ContractorEdgeData( (std::max)((int)diter->weight(), 1 ),  1,  diter->id(),  false,  diter->isForward(),  diter->isBackward());
 
             BOOST_ASSERT_MSG( newEdge.data.distance > 0, "edge distance < 1" );
 #ifndef NDEBUG
@@ -195,6 +194,7 @@ public:
         _graph = boost::make_shared<_DynamicGraph>( nodes, edges );
         edges.clear();
         std::vector<_ContractorEdge>().swap(edges);
+        BOOST_ASSERT( 0 == edges.capacity() );
         //        unsigned maxdegree = 0;
         //        NodeID highestNode = 0;
         //
@@ -214,14 +214,14 @@ public:
         //Create temporary file
 
         //        GetTemporaryFileName(temporaryEdgeStorageFilename);
-        temporaryStorageSlotID = TemporaryStorage::GetInstance().allocateSlot();
+        edge_storage_slot = TemporaryStorage::GetInstance().AllocateSlot();
         std::cout << "contractor finished initalization" << std::endl;
     }
 
     ~Contractor() {
         //Delete temporary file
         //        remove(temporaryEdgeStorageFilename.c_str());
-        TemporaryStorage::GetInstance().deallocateSlot(temporaryStorageSlotID);
+        TemporaryStorage::GetInstance().DeallocateSlot(edge_storage_slot);
     }
 
     void Run() {
@@ -264,11 +264,11 @@ public:
                 std::cout << " [flush " << numberOfContractedNodes << " nodes] " << std::flush;
 
                 //Delete old heap data to free memory that we need for the coming operations
-                BOOST_FOREACH(_ThreadData * data, threadData)
+                BOOST_FOREACH(_ThreadData * data, threadData) {
                 	delete data;
+                }
                 threadData.clear();
 
-
                 //Create new priority array
                 std::vector<float> newNodePriority(remainingNodes.size());
                 //this map gives the old IDs from the new ones, necessary to get a consistent graph at the end of contraction
@@ -285,12 +285,6 @@ public:
                     remainingNodes[newNodeID].id = newNodeID;
                 }
                 TemporaryStorage & tempStorage = TemporaryStorage::GetInstance();
-                //Write dummy number of edges to temporary file
-                //        		std::ofstream temporaryEdgeStorage(temporaryEdgeStorageFilename.c_str(), std::ios::binary);
-                uint64_t initialFilePosition = tempStorage.tell(temporaryStorageSlotID);
-                unsigned numberOfTemporaryEdges = 0;
-                tempStorage.writeToSlot(temporaryStorageSlotID, (char*)&numberOfTemporaryEdges, sizeof(unsigned));
-
                 //walk over all nodes
                 for(unsigned i = 0; i < _graph->GetNumberOfNodes(); ++i) {
                     const NodeID start = i;
@@ -299,11 +293,11 @@ public:
                         const NodeID target = _graph->GetTarget(currentEdge);
                         if(UINT_MAX == newNodeIDFromOldNodeIDMap[i] ){
                             //Save edges of this node w/o renumbering.
-                            tempStorage.writeToSlot(temporaryStorageSlotID, (char*)&start,  sizeof(NodeID));
-                            tempStorage.writeToSlot(temporaryStorageSlotID, (char*)&target, sizeof(NodeID));
-                            tempStorage.writeToSlot(temporaryStorageSlotID, (char*)&data,   sizeof(_DynamicGraph::EdgeData));
-                            ++numberOfTemporaryEdges;
-                        }else {
+                            tempStorage.WriteToSlot(edge_storage_slot, (char*)&start,  sizeof(NodeID));
+                            tempStorage.WriteToSlot(edge_storage_slot, (char*)&target, sizeof(NodeID));
+                            tempStorage.WriteToSlot(edge_storage_slot, (char*)&data,   sizeof(_DynamicGraph::EdgeData));
+                            ++temp_edge_counter;
+                        } else {
                             //node is not yet contracted.
                             //add (renumbered) outgoing edges to new DynamicGraph.
                             _ContractorEdge newEdge;
@@ -323,9 +317,6 @@ public:
                         }
                     }
                 }
-                //Note the number of temporarily stored edges
-                tempStorage.seek(temporaryStorageSlotID, initialFilePosition);
-                tempStorage.writeToSlot(temporaryStorageSlotID, (char*)&numberOfTemporaryEdges, sizeof(unsigned));
 
                 //Delete map from old NodeIDs to new ones.
                 std::vector<NodeID>().swap(newNodeIDFromOldNodeIDMap);
@@ -394,10 +385,14 @@ public:
                     _DynamicGraph::EdgeIterator currentEdgeID = _graph->FindEdge(edge.source, edge.target);
                     if(currentEdgeID < _graph->EndEdges(edge.source) ) {
                         _DynamicGraph::EdgeData & currentEdgeData = _graph->GetEdgeData(currentEdgeID);
-                        if( currentEdgeData.shortcut
-                                && edge.data.forward == currentEdgeData.forward
-                                && edge.data.backward == currentEdgeData.backward ) {
-                            currentEdgeData.distance = std::min(currentEdgeData.distance, edge.data.distance);
+                        if( currentEdgeData.shortcut &&
+                            edge.data.forward == currentEdgeData.forward &&
+                            edge.data.backward == currentEdgeData.backward &&
+                            edge.data.distance < currentEdgeData.distance
+                        ) {
+                            // found a duplicate edge with smaller weight, update it.
+                            currentEdgeData = edge.data;
+                            // currentEdgeData.distance = std::min(currentEdgeData.distance, edge.data.distance);
                             continue;
                         }
                     }
@@ -454,13 +449,13 @@ public:
         SimpleLogger().Write() << "Getting edges of minimized graph";
         NodeID numberOfNodes = _graph->GetNumberOfNodes();
         if(_graph->GetNumberOfNodes()) {
+            Edge newEdge;
             for ( NodeID node = 0; node < numberOfNodes; ++node ) {
                 p.printStatus(node);
                 for ( _DynamicGraph::EdgeIterator edge = _graph->BeginEdges( node ), endEdges = _graph->EndEdges( node ); edge < endEdges; ++edge ) {
                     const NodeID target = _graph->GetTarget( edge );
                     const _DynamicGraph::EdgeData& data = _graph->GetEdgeData( edge );
-                    Edge newEdge;
-                    if(0 != oldNodeIDFromNewNodeIDMap.size()) {
+                    if( !oldNodeIDFromNewNodeIDMap.empty() ) {
                         newEdge.source = oldNodeIDFromNewNodeIDMap[node];
                         newEdge.target = oldNodeIDFromNewNodeIDMap[target];
                     } else {
@@ -477,7 +472,10 @@ public:
                     );
                     newEdge.data.distance = data.distance;
                     newEdge.data.shortcut = data.shortcut;
-                   if(!data.originalViaNodeID && oldNodeIDFromNewNodeIDMap.size()) {
+                    if(
+                        !data.originalViaNodeID            &&
+                        !oldNodeIDFromNewNodeIDMap.empty()
+                    ) {
                         newEdge.data.id = oldNodeIDFromNewNodeIDMap[data.id];
                     } else {
                         newEdge.data.id = data.id;
@@ -494,31 +492,29 @@ public:
         }
         _graph.reset();
         std::vector<NodeID>().swap(oldNodeIDFromNewNodeIDMap);
+        BOOST_ASSERT( 0 == oldNodeIDFromNewNodeIDMap.capacity() );
 
         TemporaryStorage & tempStorage = TemporaryStorage::GetInstance();
-        //Also get the edges from temporary storage
-        unsigned numberOfTemporaryEdges = 0;
-        tempStorage.readFromSlot(temporaryStorageSlotID, (char*)&numberOfTemporaryEdges, sizeof(unsigned));
         //loads edges of graph before renumbering, no need for further numbering action.
         NodeID start;
         NodeID target;
-        //edges.reserve(edges.size()+numberOfTemporaryEdges);
         _DynamicGraph::EdgeData data;
-        for(unsigned i = 0; i < numberOfTemporaryEdges; ++i) {
-            tempStorage.readFromSlot(temporaryStorageSlotID, (char*)&start,  sizeof(NodeID));
-            tempStorage.readFromSlot(temporaryStorageSlotID, (char*)&target, sizeof(NodeID));
-            tempStorage.readFromSlot(temporaryStorageSlotID, (char*)&data,   sizeof(_DynamicGraph::EdgeData));
-            Edge newEdge;
-            newEdge.source =  start;
-            newEdge.target = target;
-            newEdge.data.distance = data.distance;
-            newEdge.data.shortcut = data.shortcut;
-            newEdge.data.id = data.id;
-            newEdge.data.forward = data.forward;
-            newEdge.data.backward = data.backward;
-            edges.push_back( newEdge );
+
+        Edge restored_edge;
+        for(unsigned i = 0; i < temp_edge_counter; ++i) {
+            tempStorage.ReadFromSlot(edge_storage_slot, (char*)&start,  sizeof(NodeID));
+            tempStorage.ReadFromSlot(edge_storage_slot, (char*)&target, sizeof(NodeID));
+            tempStorage.ReadFromSlot(edge_storage_slot, (char*)&data,   sizeof(_DynamicGraph::EdgeData));
+            restored_edge.source =  start;
+            restored_edge.target = target;
+            restored_edge.data.distance = data.distance;
+            restored_edge.data.shortcut = data.shortcut;
+            restored_edge.data.id = data.id;
+            restored_edge.data.forward = data.forward;
+            restored_edge.data.backward = data.backward;
+            edges.push_back( restored_edge );
         }
-        tempStorage.deallocateSlot(temporaryStorageSlotID);
+        tempStorage.DeallocateSlot(edge_storage_slot);
     }
 
 private:
@@ -548,7 +544,7 @@ private:
 
             //iterate over all edges of node
             for ( _DynamicGraph::EdgeIterator edge = _graph->BeginEdges( node ), endEdges = _graph->EndEdges( node ); edge != endEdges; ++edge ) {
-                const _ContractorEdgeData& data = _graph->GetEdgeData( edge );
+                const ContractorEdgeData& data = _graph->GetEdgeData( edge );
                 if ( !data.forward ){
                     continue;
                 }
@@ -594,7 +590,7 @@ private:
         std::vector< _ContractorEdge >& insertedEdges = data->insertedEdges;
 
         for ( _DynamicGraph::EdgeIterator inEdge = _graph->BeginEdges( node ), endInEdges = _graph->EndEdges( node ); inEdge != endInEdges; ++inEdge ) {
-            const _ContractorEdgeData& inData = _graph->GetEdgeData( inEdge );
+            const ContractorEdgeData& inData = _graph->GetEdgeData( inEdge );
             const NodeID source = _graph->GetTarget( inEdge );
             if ( Simulate ) {
                 assert( stats != NULL );
@@ -610,7 +606,7 @@ private:
             unsigned numTargets = 0;
 
             for ( _DynamicGraph::EdgeIterator outEdge = _graph->BeginEdges( node ), endOutEdges = _graph->EndEdges( node ); outEdge != endOutEdges; ++outEdge ) {
-                const _ContractorEdgeData& outData = _graph->GetEdgeData( outEdge );
+                const ContractorEdgeData& outData = _graph->GetEdgeData( outEdge );
                 if ( !outData.forward ) {
                     continue;
                 }
@@ -629,7 +625,7 @@ private:
                 _Dijkstra( maxDistance, numTargets, 2000, data, node );
             }
             for ( _DynamicGraph::EdgeIterator outEdge = _graph->BeginEdges( node ), endOutEdges = _graph->EndEdges( node ); outEdge != endOutEdges; ++outEdge ) {
-                const _ContractorEdgeData& outData = _graph->GetEdgeData( outEdge );
+                const ContractorEdgeData& outData = _graph->GetEdgeData( outEdge );
                 if ( !outData.forward ) {
                     continue;
                 }
@@ -645,7 +641,7 @@ private:
                         _ContractorEdge newEdge;
                         newEdge.source = source;
                         newEdge.target = target;
-                        newEdge.data = _ContractorEdgeData( pathDistance, outData.originalEdges + inData.originalEdges, node/*, 0, inData.turnInstruction*/, true, true, false);;
+                        newEdge.data = ContractorEdgeData( pathDistance, outData.originalEdges + inData.originalEdges, node/*, 0, inData.turnInstruction*/, true, true, false);;
                         insertedEdges.push_back( newEdge );
                         std::swap( newEdge.source, newEdge.target );
                         newEdge.data.forward = false;
@@ -738,7 +734,7 @@ private:
             if ( priority > targetPriority )
                 return false;
             //tie breaking
-            if ( fabs(priority - targetPriority) < std::numeric_limits<double>::epsilon() && bias(node, target) ) {
+            if ( std::abs(priority - targetPriority) < std::numeric_limits<double>::epsilon() && bias(node, target) ) {
                 return false;
             }
             neighbours.push_back( target );
@@ -760,7 +756,7 @@ private:
                 if ( priority > targetPriority)
                     return false;
                 //tie breaking
-                if ( fabs(priority - targetPriority) < std::numeric_limits<double>::epsilon() && bias(node, target) ) {
+                if ( std::abs(priority - targetPriority) < std::numeric_limits<double>::epsilon() && bias(node, target) ) {
                     return false;
                 }
             }
@@ -784,7 +780,8 @@ private:
 
     boost::shared_ptr<_DynamicGraph> _graph;
     std::vector<_DynamicGraph::InputEdge> contractedEdges;
-    unsigned temporaryStorageSlotID;
+    unsigned edge_storage_slot;
+    uint64_t temp_edge_counter;
     std::vector<NodeID> oldNodeIDFromNewNodeIDMap;
     XORFastHash fastHash;
 };

Contractor/EdgeBasedGraphFactory.cpp

@@ -25,7 +25,21 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 */
 
+
 #include "EdgeBasedGraphFactory.h"
+#include "../Util/ComputeAngle.h"
+
+#include <boost/assert.hpp>
+#include <boost/foreach.hpp>
+#include <boost/make_shared.hpp>
+
+//TODO: CompressionWorker
+//TODO: EdgeBasedEdgeGenerator
+
+// template<class Work>
+// inline static void TraverseGraph(NodeBasedDynamicGraph & graph, Work & work) {
+
+// }
 
 EdgeBasedGraphFactory::EdgeBasedGraphFactory(
     int number_of_nodes,
@@ -43,7 +57,8 @@ EdgeBasedGraphFactory::EdgeBasedGraphFactory(
         std::pair<NodeID, NodeID> restriction_source =
             std::make_pair(restriction.fromNode, restriction.viaNode);
         unsigned index;
-        RestrictionMap::iterator restriction_iter = m_restriction_map.find(restriction_source);
+        RestrictionMap::iterator restriction_iter;
+        restriction_iter = m_restriction_map.find(restriction_source);
         if(restriction_iter == m_restriction_map.end()) {
             index = m_restriction_bucket_list.size();
             m_restriction_bucket_list.resize(index+1);
@@ -93,7 +108,7 @@ EdgeBasedGraphFactory::EdgeBasedGraphFactory(
         	continue;
         }
         edge.data.distance = (std::max)((int)import_edge.weight(), 1 );
-        assert( edge.data.distance > 0 );
+        BOOST_ASSERT( edge.data.distance > 0 );
         edge.data.shortcut = false;
         edge.data.roundabout = import_edge.isRoundabout();
         edge.data.ignoreInGrid = import_edge.ignoreInGrid();
@@ -131,8 +146,8 @@ void EdgeBasedGraphFactory::GetEdgeBasedEdges(
 void EdgeBasedGraphFactory::GetEdgeBasedNodes( std::vector<EdgeBasedNode> & nodes) {
 #ifndef NDEBUG
     BOOST_FOREACH(const EdgeBasedNode & node, m_edge_based_node_list){
-        assert(node.lat1 != INT_MAX); assert(node.lon1 != INT_MAX);
-        assert(node.lat2 != INT_MAX); assert(node.lon2 != INT_MAX);
+        BOOST_ASSERT(node.lat1 != INT_MAX); BOOST_ASSERT(node.lon1 != INT_MAX);
+        BOOST_ASSERT(node.lat2 != INT_MAX); BOOST_ASSERT(node.lon2 != INT_MAX);
     }
 #endif
     nodes.swap(m_edge_based_node_list);
@@ -143,7 +158,8 @@ NodeID EdgeBasedGraphFactory::CheckForEmanatingIsOnlyTurn(
     const NodeID v
 ) const {
     const std::pair < NodeID, NodeID > restriction_source = std::make_pair(u, v);
-    RestrictionMap::const_iterator restriction_iter = m_restriction_map.find(restriction_source);
+    RestrictionMap::const_iterator restriction_iter;
+    restriction_iter = m_restriction_map.find(restriction_source);
     if (restriction_iter != m_restriction_map.end()) {
         const unsigned index = restriction_iter->second;
         BOOST_FOREACH(
@@ -165,7 +181,8 @@ bool EdgeBasedGraphFactory::CheckIfTurnIsRestricted(
 ) const {
     //only add an edge if turn is not a U-turn except it is the end of dead-end street.
     const std::pair < NodeID, NodeID > restriction_source = std::make_pair(u, v);
-    RestrictionMap::const_iterator restriction_iter = m_restriction_map.find(restriction_source);
+    RestrictionMap::const_iterator restriction_iter;
+    restriction_iter = m_restriction_map.find(restriction_source);
     if (restriction_iter != m_restriction_map.end()) {
         const unsigned index = restriction_iter->second;
         BOOST_FOREACH(
@@ -199,13 +216,34 @@ void EdgeBasedGraphFactory::InsertEdgeBasedNode(
     m_edge_based_node_list.push_back(currentNode);
 }
 
+
+void EdgeBasedGraphFactory::FlushVectorToStream(
+    std::ofstream & edge_data_file,
+    std::vector<OriginalEdgeData> & original_edge_data_vector
+) const {
+    edge_data_file.write(
+        (char*)&(original_edge_data_vector[0]),
+        original_edge_data_vector.size()*sizeof(OriginalEdgeData)
+    );
+    original_edge_data_vector.clear();
+}
+
 void EdgeBasedGraphFactory::Run(
     const char * original_edge_data_filename,
     lua_State *lua_state
 ) {
+    SimpleLogger().Write() << "Compressing geometry of input graph";
+    //TODO: iterate over all turns
+
+    //TODO: compress geometries
+
+    //TODO: update turn restrictions if concerned by compression
+
+    //TODO: do some compression statistics
+
+
     SimpleLogger().Write() << "Identifying components of the road network";
 
-    Percent p(m_node_based_graph->GetNumberOfNodes());
     unsigned skipped_turns_counter   = 0;
     unsigned node_based_edge_counter = 0;
     unsigned original_edges_counter  = 0;
@@ -221,93 +259,21 @@ void EdgeBasedGraphFactory::Run(
         sizeof(unsigned)
     );
 
-    unsigned current_component = 0, current_component_size = 0;
     //Run a BFS on the undirected graph and identify small components
-    std::queue<std::pair<NodeID, NodeID> > bfs_queue;
-    std::vector<unsigned> component_index_list(
-        m_node_based_graph->GetNumberOfNodes(),
-        UINT_MAX
-    );
+    std::vector<unsigned> component_index_list;
+    std::vector<NodeID> component_index_size;
+    BFSCompentExplorer( component_index_list, component_index_size);
 
-    std::vector<NodeID> component_size_list;
-    //put unexplorered node with parent pointer into queue
-    for(
-        NodeID node = 0,
-            last_node = m_node_based_graph->GetNumberOfNodes();
-        node < last_node;
-        ++node
-    ) {
-        if(UINT_MAX == component_index_list[node]) {
-            bfs_queue.push(std::make_pair(node, node));
-            //mark node as read
-            component_index_list[node] = current_component;
-            p.printIncrement();
-            while(!bfs_queue.empty()) {
-                //fetch element from BFS queue
-                std::pair<NodeID, NodeID> current_queue_item = bfs_queue.front();
-                bfs_queue.pop();
-                // SimpleLogger().Write() << "sizeof queue: " << bfs_queue.size() <<
-                //  ", current_component_sizes: " <<  current_component_size <<
-                //", settled nodes: " << settledNodes++ << ", max: " << endNodes;
-                const NodeID v = current_queue_item.first;  //current node
-                const NodeID u = current_queue_item.second; //parent
-                //increment size counter of current component
-                ++current_component_size;
-                const bool is_barrier_node = (m_barrier_nodes.find(v) != m_barrier_nodes.end());
-                if(!is_barrier_node) {
-                    const NodeID to_node_of_only_restriction = CheckForEmanatingIsOnlyTurn(u, v);
-
-                    //relaxieren edge outgoing edge like below where edge-expanded graph
-                    for(
-                        EdgeIterator e2 = m_node_based_graph->BeginEdges(v);
-                        e2 < m_node_based_graph->EndEdges(v);
-                        ++e2
-                    ) {
-                        NodeIterator w = m_node_based_graph->GetTarget(e2);
-
-                        if(
-                            to_node_of_only_restriction != UINT_MAX &&
-                            w != to_node_of_only_restriction
-                        ) {
-                            //We are at an only_-restriction but not at the right turn.
-                            continue;
-                        }
-                        if( u != w ) {
-                            //only add an edge if turn is not a U-turn except
-                            //when it is at the end of a dead-end street.
-                            if (!CheckIfTurnIsRestricted(u, v, w) ) {
-                                //only add an edge if turn is not prohibited
-                                if(UINT_MAX == component_index_list[w]) {
-                                    //insert next (node, parent) only if w has
-                                    //not yet been explored
-                                    //mark node as read
-                                    component_index_list[w] = current_component;
-                                    bfs_queue.push(std::make_pair(w,v));
-                                    p.printIncrement();
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            //push size into vector
-            component_size_list.push_back(current_component_size);
-            //reset counters;
-            current_component_size = 0;
-            ++current_component;
-        }
-    }
     SimpleLogger().Write() <<
-        "identified: " << component_size_list.size() << " many components";
+        "identified: " << component_index_size.size() << " many components";
     SimpleLogger().Write() <<
         "generating edge-expanded nodes";
 
-    p.reinit(m_node_based_graph->GetNumberOfNodes());
+    Percent p(m_node_based_graph->GetNumberOfNodes());
     //loop over all edges and generate new set of nodes.
     for(
-        NodeIterator u = 0,
-            number_of_nodes = m_node_based_graph->GetNumberOfNodes();
-        u < number_of_nodes;
+        NodeIterator u = 0, end = m_node_based_graph->GetNumberOfNodes();
+        u < end;
         ++u
      ) {
         p.printIncrement();
@@ -326,8 +292,8 @@ void EdgeBasedGraphFactory::Run(
             //Note: edges that end on barrier nodes or on a turn restriction
             //may actually be in two distinct components. We choose the smallest
                 const unsigned size_of_component = std::min(
-                    component_size_list[component_index_list[u]],
-                    component_size_list[component_index_list[v]]
+                    component_index_size[component_index_list[u]],
+                    component_index_size[component_index_list[v]]
                 );
 
                 InsertEdgeBasedNode( e1, u, v, size_of_component < 1000 );
@@ -338,12 +304,11 @@ void EdgeBasedGraphFactory::Run(
     SimpleLogger().Write()
         << "Generated " << m_edge_based_node_list.size() << " nodes in " <<
         "edge-expanded graph";
-    SimpleLogger().Write() <<
-        "generating edge-expanded edges";
+    SimpleLogger().Write() << "generating edge-expanded edges";
 
-    std::vector<NodeID>().swap(component_size_list);
+    std::vector<NodeID>().swap(component_index_size);
     BOOST_ASSERT_MSG(
-        0 == component_size_list.capacity(),
+        0 == component_index_size.capacity(),
         "component size vector not deallocated"
     );
     std::vector<NodeID>().swap(component_index_list);
@@ -359,9 +324,8 @@ void EdgeBasedGraphFactory::Run(
     //linear number of turns only.
     p.reinit(m_node_based_graph->GetNumberOfNodes());
     for(
-        NodeIterator u = 0,
-            last_node = m_node_based_graph->GetNumberOfNodes();
-        u < last_node;
+        NodeIterator u = 0, end = m_node_based_graph->GetNumberOfNodes();
+        u < end;
         ++u
     ) {
         for(
@@ -371,9 +335,10 @@ void EdgeBasedGraphFactory::Run(
             ++e1
         ) {
             ++node_based_edge_counter;
-            NodeIterator v = m_node_based_graph->GetTarget(e1);
-            bool is_barrier_node = (m_barrier_nodes.find(v) != m_barrier_nodes.end());
-            NodeID to_node_of_only_restriction = CheckForEmanatingIsOnlyTurn(u, v);
+            const NodeIterator v = m_node_based_graph->GetTarget(e1);
+            const NodeID to_node_of_only_restriction = CheckForEmanatingIsOnlyTurn(u, v);
+            const bool is_barrier_node = ( m_barrier_nodes.find(v) != m_barrier_nodes.end() );
+
             for(
                 EdgeIterator e2 = m_node_based_graph->BeginEdges(v),
                     last_edge_v = m_node_based_graph->EndEdges(v);
@@ -390,83 +355,91 @@ void EdgeBasedGraphFactory::Run(
                     continue;
                 }
 
-                if(u == w && 1 != m_node_based_graph->GetOutDegree(v) ) {
+                if( is_barrier_node) {
+                    if(u != w) {
+                        ++skipped_turns_counter;
+                        continue;
+                    }
+                } else {
+                    if ( (u == w) && (m_node_based_graph->GetOutDegree(v) > 1) ) {
+                        ++skipped_turns_counter;
+                        continue;
+                    }
+                }
+
+                //only add an edge if turn is not a U-turn except when it is
+                //at the end of a dead-end street
+                if (
+                    CheckIfTurnIsRestricted(u, v, w)          &&
+                    (to_node_of_only_restriction == UINT_MAX) &&
+                    (w != to_node_of_only_restriction)
+                ) {
+                    ++skipped_turns_counter;
                     continue;
                 }
 
-                if( !is_barrier_node ) {
-                    //only add an edge if turn is not a U-turn except when it is
-                    //at the end of a dead-end street
-                    if (
-                        !CheckIfTurnIsRestricted(u, v, w) ||
-                        (to_node_of_only_restriction != UINT_MAX && w == to_node_of_only_restriction)
-                    ) { //only add an edge if turn is not prohibited
-                        const EdgeData edge_data1 = m_node_based_graph->GetEdgeData(e1);
-                        const EdgeData edge_data2 = m_node_based_graph->GetEdgeData(e2);
-                        assert(edge_data1.edgeBasedNodeID < m_node_based_graph->GetNumberOfEdges());
-                        assert(edge_data2.edgeBasedNodeID < m_node_based_graph->GetNumberOfEdges());
+                //only add an edge if turn is not prohibited
+                const EdgeData edge_data1 = m_node_based_graph->GetEdgeData(e1);
+                const EdgeData edge_data2 = m_node_based_graph->GetEdgeData(e2);
 
-                        if(!edge_data1.forward || !edge_data2.forward) {
-                            continue;
-                        }
+                BOOST_ASSERT(
+                    edge_data1.edgeBasedNodeID < m_node_based_graph->GetNumberOfEdges()
+                );
+                BOOST_ASSERT(
+                    edge_data2.edgeBasedNodeID < m_node_based_graph->GetNumberOfEdges()
+                );
+                BOOST_ASSERT(
+                    edge_data1.edgeBasedNodeID != edge_data2.edgeBasedNodeID
+                );
+                BOOST_ASSERT( edge_data1.forward );
+                BOOST_ASSERT( edge_data2.forward );
 
-                        unsigned distance = edge_data1.distance;
-                        if(m_traffic_lights.find(v) != m_traffic_lights.end()) {
-                            distance += speed_profile.trafficSignalPenalty;
-                        }
-                        const unsigned penalty =
-                            GetTurnPenalty(u, v, w, lua_state);
-                        TurnInstruction turnInstruction = AnalyzeTurn(u, v, w);
-                        if(turnInstruction == TurnInstructions.UTurn){
-                            distance += speed_profile.uTurnPenalty;
-                        }
-                        distance += penalty;
-
-                        assert(edge_data1.edgeBasedNodeID != edge_data2.edgeBasedNodeID);
-                        original_edge_data_vector.push_back(
-                            OriginalEdgeData(
-                                v,
-                                edge_data2.nameID,
-                                turnInstruction
-                            )
-                        );
-                        ++original_edges_counter;
-
-                        if(original_edge_data_vector.size() > 100000) {
-                            edge_data_file.write(
-                                (char*)&(original_edge_data_vector[0]),
-                                original_edge_data_vector.size()*sizeof(OriginalEdgeData)
-                            );
-                            original_edge_data_vector.clear();
-                        }
-
-                        m_edge_based_edge_list.push_back(
-                            EdgeBasedEdge(
-                                edge_data1.edgeBasedNodeID,
-                                edge_data2.edgeBasedNodeID,
-                                m_edge_based_edge_list.size(),
-                                distance,
-                                true,
-                                false
-                            )
-                        );
-                    } else {
-                        ++skipped_turns_counter;
-                    }
+                // the following is the core of the loop.
+                unsigned distance = edge_data1.distance;
+                if( m_traffic_lights.find(v) != m_traffic_lights.end() ) {
+                    distance += speed_profile.trafficSignalPenalty;
                 }
+                const int turn_penalty = GetTurnPenalty(u, v, w, lua_state);
+                TurnInstruction turnInstruction = AnalyzeTurn(u, v, w);
+                if(turnInstruction == TurnInstructions.UTurn){
+                    distance += speed_profile.uTurnPenalty;
+                }
+                distance += turn_penalty;
+
+                original_edge_data_vector.push_back(
+                    OriginalEdgeData(
+                        v,
+                        edge_data2.nameID,
+                        turnInstruction
+                    )
+                );
+                ++original_edges_counter;
+
+                if(original_edge_data_vector.size() > 100000) {
+                    FlushVectorToStream(
+                        edge_data_file,
+                        original_edge_data_vector
+                    );
+                }
+
+                m_edge_based_edge_list.push_back(
+                    EdgeBasedEdge(
+                        edge_data1.edgeBasedNodeID,
+                        edge_data2.edgeBasedNodeID,
+                        m_edge_based_edge_list.size(),
+                        distance,
+                        true,
+                        false
+                    )
+                );
             }
         }
         p.printIncrement();
     }
-    edge_data_file.write(
-        (char*)&(original_edge_data_vector[0]),
-        original_edge_data_vector.size()*sizeof(OriginalEdgeData)
-    );
-    edge_data_file.seekp(std::ios::beg);
-    edge_data_file.write(
-        (char*)&original_edges_counter,
-        sizeof(unsigned)
-    );
+    FlushVectorToStream( edge_data_file, original_edge_data_vector );
+
+    edge_data_file.seekp( std::ios::beg );
+    edge_data_file.write( (char*)&original_edges_counter, sizeof(unsigned) );
     edge_data_file.close();
 
     SimpleLogger().Write() <<
@@ -518,11 +491,11 @@ TurnInstruction EdgeBasedGraphFactory::AnalyzeTurn(
         return TurnInstructions.UTurn;
     }
 
-    EdgeIterator edge1 = m_node_based_graph->FindEdge(u, v);
-    EdgeIterator edge2 = m_node_based_graph->FindEdge(v, w);
+    const EdgeIterator edge1 = m_node_based_graph->FindEdge(u, v);
+    const EdgeIterator edge2 = m_node_based_graph->FindEdge(v, w);
 
-    EdgeData & data1 = m_node_based_graph->GetEdgeData(edge1);
-    EdgeData & data2 = m_node_based_graph->GetEdgeData(edge2);
+    const EdgeData & data1 = m_node_based_graph->GetEdgeData(edge1);
+    const EdgeData & data2 = m_node_based_graph->GetEdgeData(edge2);
 
     if(!data1.contraFlow && data2.contraFlow) {
     	return TurnInstructions.EnterAgainstAllowedDirection;
@@ -569,10 +542,87 @@ TurnInstruction EdgeBasedGraphFactory::AnalyzeTurn(
         m_node_info_list[v],
         m_node_info_list[w]
     );
-
     return TurnInstructions.GetTurnDirectionOfInstruction(angle);
 }
 
 unsigned EdgeBasedGraphFactory::GetNumberOfNodes() const {
     return m_node_based_graph->GetNumberOfEdges();
 }
+
+void EdgeBasedGraphFactory::BFSCompentExplorer(
+    std::vector<unsigned> & component_index_list,
+    std::vector<unsigned> & component_index_size
+) const {
+    std::queue<std::pair<NodeID, NodeID> > bfs_queue;
+    Percent p( m_node_based_graph->GetNumberOfNodes() );
+    unsigned current_component, current_component_size;
+    current_component = current_component_size = 0;
+
+    BOOST_ASSERT( component_index_list.empty() );
+    BOOST_ASSERT( component_index_size.empty() );
+
+    component_index_list.resize(
+        m_node_based_graph->GetNumberOfNodes(),
+        UINT_MAX
+    );
+
+    //put unexplorered node with parent pointer into queue
+    for( NodeID node = 0, end = m_node_based_graph->GetNumberOfNodes(); node < end; ++node) {
+        if(UINT_MAX == component_index_list[node]) {
+            bfs_queue.push(std::make_pair(node, node));
+            //mark node as read
+            component_index_list[node] = current_component;
+            p.printIncrement();
+            while(!bfs_queue.empty()) {
+                //fetch element from BFS queue
+                std::pair<NodeID, NodeID> current_queue_item = bfs_queue.front();
+                bfs_queue.pop();
+
+                const NodeID v = current_queue_item.first;  //current node
+                const NodeID u = current_queue_item.second; //parent
+                //increment size counter of current component
+                ++current_component_size;
+                const bool is_barrier_node = (m_barrier_nodes.find(v) != m_barrier_nodes.end());
+                if(!is_barrier_node) {
+                    const NodeID to_node_of_only_restriction = CheckForEmanatingIsOnlyTurn(u, v);
+
+                    for(
+                        EdgeIterator e2 = m_node_based_graph->BeginEdges(v);
+                        e2 < m_node_based_graph->EndEdges(v);
+                        ++e2
+                    ) {
+                        NodeIterator w = m_node_based_graph->GetTarget(e2);
+
+                        if(
+                            to_node_of_only_restriction != UINT_MAX &&
+                            w != to_node_of_only_restriction
+                        ) {
+                            // At an only_-restriction but not at the right turn
+                            continue;
+                        }
+                        if( u != w ) {
+                            //only add an edge if turn is not a U-turn except
+                            //when it is at the end of a dead-end street.
+                            if (!CheckIfTurnIsRestricted(u, v, w) ) {
+                                //only add an edge if turn is not prohibited
+                                if(UINT_MAX == component_index_list[w]) {
+                                    //insert next (node, parent) only if w has
+                                    //not yet been explored
+                                    //mark node as read
+                                    component_index_list[w] = current_component;
+                                    bfs_queue.push(std::make_pair(w,v));
+                                    p.printIncrement();
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            //push size into vector
+            component_index_size.push_back(current_component_size);
+            //reset counters;
+            current_component_size = 0;
+            ++current_component;
+        }
+    }
+}

Contractor/EdgeBasedGraphFactory.h

@@ -33,17 +33,20 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "../typedefs.h"
 #include "../DataStructures/DeallocatingVector.h"
 #include "../DataStructures/DynamicGraph.h"
-#include "../Extractor/ExtractorStructs.h"
+#include "../DataStructures/EdgeBasedNode.h"
 #include "../DataStructures/HashTable.h"
 #include "../DataStructures/ImportEdge.h"
-#include "../DataStructures/QueryEdge.h"
+#include "../DataStructures/OriginalEdgeData.h"
 #include "../DataStructures/Percent.h"
+#include "../DataStructures/QueryEdge.h"
+#include "../DataStructures/QueryNode.h"
 #include "../DataStructures/TurnInstructions.h"
+#include "../DataStructures/Restriction.h"
 #include "../Util/LuaUtil.h"
 #include "../Util/SimpleLogger.h"
 
-#include <boost/foreach.hpp>
-#include <boost/make_shared.hpp>
+#include "GeometryCompressor.h"
+
 #include <boost/noncopyable.hpp>
 #include <boost/shared_ptr.hpp>
 #include <boost/unordered_map.hpp>
@@ -56,51 +59,6 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 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),
@@ -124,14 +82,17 @@ public:
     );
 
     void Run(const char * originalEdgeDataFilename, lua_State *myLuaState);
+
     void GetEdgeBasedEdges( DeallocatingVector< EdgeBasedEdge >& edges );
+
     void GetEdgeBasedNodes( std::vector< EdgeBasedNode> & nodes);
-    void GetOriginalEdgeData( std::vector<OriginalEdgeData> & originalEdgeData);
+
     TurnInstruction AnalyzeTurn(
         const NodeID u,
         const NodeID v,
         const NodeID w
     ) const;
+
     int GetTurnPenalty(
         const NodeID u,
         const NodeID v,
@@ -156,15 +117,6 @@ private:
         bool contraFlow:1;
     };
 
-    struct _EdgeBasedEdgeData {
-        int distance;
-        unsigned via;
-        unsigned nameID;
-        bool forward;
-        bool backward;
-        TurnInstruction turnInstruction;
-    };
-
     unsigned m_turn_restrictions_count;
 
     typedef DynamicGraph<NodeBasedEdgeData>     NodeBasedDynamicGraph;
@@ -188,7 +140,6 @@ private:
 
     RestrictionMap                              m_restriction_map;
 
-
     NodeID CheckForEmanatingIsOnlyTurn(
         const NodeID u,
         const NodeID v
@@ -201,10 +152,21 @@ private:
     ) const;
 
     void InsertEdgeBasedNode(
-            NodeBasedDynamicGraph::EdgeIterator e1,
-            NodeBasedDynamicGraph::NodeIterator u,
-            NodeBasedDynamicGraph::NodeIterator v,
-            bool belongsToTinyComponent);
+        NodeBasedDynamicGraph::EdgeIterator e1,
+        NodeBasedDynamicGraph::NodeIterator u,
+        NodeBasedDynamicGraph::NodeIterator v,
+        bool belongsToTinyComponent
+    );
+
+    void BFSCompentExplorer(
+        std::vector<unsigned> & component_index_list,
+        std::vector<unsigned> & component_index_size
+    ) const;
+
+    void FlushVectorToStream(
+        std::ofstream & edge_data_file,
+        std::vector<OriginalEdgeData> & original_edge_data_vector
+    ) const;
 };
 
 #endif /* EDGEBASEDGRAPHFACTORY_H_ */

Contractor/GeometryCompressor.cpp

@@ -0,0 +1,94 @@
+/*
+
+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 "GeometryCompressor.h"
+
+int current_free_list_maximum = 0;
+int UniqueNumber () { return ++current_free_list_maximum; }
+
+GeometryCompressor::GeometryCompressor() {
+    m_free_list.resize(100);
+    IncreaseFreeList();
+}
+
+void GeometryCompressor::IncreaseFreeList() {
+    m_compressed_geometries.resize(m_compressed_geometries.size() + 100);
+    std::generate_n (m_free_list.rend(), 100, UniqueNumber);
+}
+
+void GeometryCompressor::AppendNodeIDsToGeomtry( NodeID node_id, NodeID contracted_node_id ) {
+    //check if node_id already has a list
+    boost::unordered_map<unsigned, unsigned>::const_iterator map_iterator;
+    map_iterator = m_node_id_to_index_map.find( node_id );
+
+    unsigned geometry_bucket_index = std::numeric_limits<unsigned>::max();
+    if( m_node_id_to_index_map.end() == map_iterator ) {
+        //if not, create one
+        if( m_free_list.empty() ) {
+            IncreaseFreeList();
+        }
+        geometry_bucket_index = m_free_list.back();
+        m_free_list.pop_back();
+    } else {
+        geometry_bucket_index = map_iterator->second;
+    }
+
+    BOOST_ASSERT( std::numeric_limits<unsigned>::max() != geometry_bucket_index );
+    BOOST_ASSERT( geometry_bucket_index < m_compressed_geometries.size() );
+
+    //append contracted_node_id to m_compressed_geometries[node_id]
+    m_compressed_geometries[geometry_bucket_index].push_back(contracted_node_id);
+
+    //append m_compressed_geometries[contracted_node_id] to m_compressed_geometries[node_id]
+    map_iterator = m_node_id_to_index_map.find(contracted_node_id);
+    if ( m_node_id_to_index_map.end() != map_iterator) {
+        const unsigned bucket_index_to_remove = map_iterator->second;
+        BOOST_ASSERT( bucket_index_to_remove < m_compressed_geometries.size() );
+
+        m_compressed_geometries[geometry_bucket_index].insert(
+            m_compressed_geometries[geometry_bucket_index].end(),
+            m_compressed_geometries[bucket_index_to_remove].begin(),
+            m_compressed_geometries[bucket_index_to_remove].end()
+        );
+        //remove m_compressed_geometries[contracted_node_id], add to free list
+        m_compressed_geometries[bucket_index_to_remove].clear();
+        m_free_list.push_back(bucket_index_to_remove);
+    }
+}
+
+void GeometryCompressor::PrintStatistics() const {
+    unsigned compressed_node_count = 0;
+    const unsigned surviving_node_count = m_compressed_geometries.size();
+
+    BOOST_FOREACH(const std::vector<unsigned> & current_vector, m_compressed_geometries) {
+        compressed_node_count += current_vector.size();
+    }
+    SimpleLogger().Write() <<
+        "surv: " << surviving_node_count <<
+        ", comp: " << compressed_node_count <<
+        ", comp ratio: " << ((float)surviving_node_count/std::max(compressed_node_count, 1u) );
+}

Contractor/GeometryCompressor.h

@@ -25,54 +25,34 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 */
 
-#ifndef SIMPLESTACK_H_
-#define SIMPLESTACK_H_
+#include "../Util/SimpleLogger.h"
+#include "../typedefs.h"
 
-#include <cassert>
+#include <boost/assert.hpp>
+#include <boost/foreach.hpp>
+#include <boost/unordered_map.hpp>
+
+#include <algorithm>
+#include <limits>
 #include <vector>
 
-template<typename StackItemT, class ContainerT = std::vector<StackItemT> >
-class SimpleStack {
+#ifndef GEOMETRY_COMPRESSOR_H
+#define GEOMETRY_COMPRESSOR_H
+
+class GeometryCompressor {
+public:
+    GeometryCompressor();
+    void AppendNodeIDsToGeomtry( NodeID node_id, NodeID contracted_node_id );
+    void PrintStatistics() const;
 
 private:
-	int last;
-	ContainerT arr;
 
-public:
-	SimpleStack() : last(-1) {
-	}
+    void IncreaseFreeList();
 
-	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);
-	}
+    std::vector<std::vector<unsigned> > m_compressed_geometries;
+    std::vector<unsigned> m_free_list;
+    boost::unordered_map<unsigned, unsigned> m_node_id_to_index_map;
 };
 
 
-#endif /* SIMPLESTACK_H_ */
+#endif //GEOMETRY_COMPRESSOR_H

Contractor/TemporaryStorage.cpp

@@ -28,113 +28,135 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "TemporaryStorage.h"
 
 TemporaryStorage::TemporaryStorage() {
-    tempDirectory = boost::filesystem::temp_directory_path();
+    temp_directory = boost::filesystem::temp_directory_path();
 }
 
 TemporaryStorage & TemporaryStorage::GetInstance(){
-    static TemporaryStorage runningInstance;
-    return runningInstance;
+    static TemporaryStorage static_instance;
+    return static_instance;
 }
 
 TemporaryStorage::~TemporaryStorage() {
-    removeAll();
+    RemoveAll();
 }
 
-void TemporaryStorage::removeAll() {
+void TemporaryStorage::RemoveAll() {
     boost::mutex::scoped_lock lock(mutex);
-    for(unsigned slot_id = 0; slot_id < vectorOfStreamDatas.size(); ++slot_id) {
-        deallocateSlot(slot_id);
+    for(unsigned slot_id = 0; slot_id < stream_data_list.size(); ++slot_id) {
+        DeallocateSlot(slot_id);
     }
-    vectorOfStreamDatas.clear();
+    stream_data_list.clear();
 }
 
-int TemporaryStorage::allocateSlot() {
+int TemporaryStorage::AllocateSlot() {
     boost::mutex::scoped_lock lock(mutex);
     try {
-        vectorOfStreamDatas.push_back(StreamData());
-        //SimpleLogger().Write() << "created new temporary file: " << vectorOfStreamDatas.back().pathToTemporaryFile;
+        stream_data_list.push_back(StreamData());
     } catch(boost::filesystem::filesystem_error & e) {
-        abort(e);
+        Abort(e);
     }
-    return vectorOfStreamDatas.size() - 1;
+    CheckIfTemporaryDeviceFull();
+    return stream_data_list.size() - 1;
 }
 
-void TemporaryStorage::deallocateSlot(int slotID) {
+void TemporaryStorage::DeallocateSlot(const int slot_id) {
     try {
-        StreamData & data = vectorOfStreamDatas[slotID];
+        StreamData & data = stream_data_list[slot_id];
         boost::mutex::scoped_lock lock(*data.readWriteMutex);
-        if(!boost::filesystem::exists(data.pathToTemporaryFile)) {
+        if(!boost::filesystem::exists(data.temp_path)) {
             return;
         }
-        if(data.streamToTemporaryFile->is_open()) {
-            data.streamToTemporaryFile->close();
+        if(data.temp_file->is_open()) {
+            data.temp_file->close();
         }
 
-        boost::filesystem::remove(data.pathToTemporaryFile);
+        boost::filesystem::remove(data.temp_path);
     } catch(boost::filesystem::filesystem_error & e) {
-        abort(e);
+        Abort(e);
     }
 }
 
-void TemporaryStorage::writeToSlot(int slotID, char * pointer, std::streamsize size) {
+void TemporaryStorage::WriteToSlot(
+    const int slot_id,
+    char * pointer,
+    const std::size_t size
+) {
     try {
-        StreamData & data = vectorOfStreamDatas[slotID];
+        StreamData & data = stream_data_list[slot_id];
+        BOOST_ASSERT(data.write_mode);
+
         boost::mutex::scoped_lock lock(*data.readWriteMutex);
         BOOST_ASSERT_MSG(
-            data.writeMode,
+            data.write_mode,
             "Writing after first read is not allowed"
         );
-        data.streamToTemporaryFile->write(pointer, size);
-    } catch(boost::filesystem::filesystem_error & e) {
-        abort(e);
-    }
-}
-void TemporaryStorage::readFromSlot(int slotID, char * pointer, std::streamsize size) {
-    try {
-        StreamData & data = vectorOfStreamDatas[slotID];
-        boost::mutex::scoped_lock lock(*data.readWriteMutex);
-        if(data.writeMode) {
-            data.writeMode = false;
-            data.streamToTemporaryFile->seekg(0, data.streamToTemporaryFile->beg);
+        if( 1073741824 < data.buffer.size() ) {
+            data.temp_file->write(&data.buffer[0], data.buffer.size());
+            // data.temp_file->write(pointer, size);
+            data.buffer.clear();
+            CheckIfTemporaryDeviceFull();
         }
-        data.streamToTemporaryFile->read(pointer, size);
+        data.buffer.insert(data.buffer.end(), pointer, pointer+size);
+
     } catch(boost::filesystem::filesystem_error & e) {
-        abort(e);
+        Abort(e);
     }
 }
-
-unsigned TemporaryStorage::getFreeBytesOnTemporaryDevice() {
-    boost::filesystem::space_info tempSpaceInfo;
+void TemporaryStorage::ReadFromSlot(
+    const int slot_id,
+    char * pointer,
+    const std::size_t size
+) {
     try {
-        tempSpaceInfo = boost::filesystem::space(tempDirectory);
+        StreamData & data = stream_data_list[slot_id];
+        boost::mutex::scoped_lock lock(*data.readWriteMutex);
+        if( data.write_mode ) {
+            data.write_mode = false;
+            data.temp_file->write(&data.buffer[0], data.buffer.size());
+            data.buffer.clear();
+            data.temp_file->seekg( data.temp_file->beg );
+            BOOST_ASSERT( data.temp_file->beg == data.temp_file->tellg() );
+        }
+        BOOST_ASSERT( !data.write_mode );
+        data.temp_file->read(pointer, size);
     } catch(boost::filesystem::filesystem_error & e) {
-        abort(e);
+        Abort(e);
     }
-    return tempSpaceInfo.available;
 }
 
-boost::filesystem::fstream::pos_type TemporaryStorage::tell(int slotID) {
+uint64_t TemporaryStorage::GetFreeBytesOnTemporaryDevice() {
+    uint64_t value = -1;
+    try {
+        boost::filesystem::path p =  boost::filesystem::temp_directory_path();
+        boost::filesystem::space_info s = boost::filesystem::space( p );
+        value = s.free;
+    } catch(boost::filesystem::filesystem_error & e) {
+        Abort(e);
+    }
+    return value;
+}
+
+void TemporaryStorage::CheckIfTemporaryDeviceFull() {
+    boost::filesystem::path p = boost::filesystem::temp_directory_path();
+    boost::filesystem::space_info s = boost::filesystem::space( p );
+    if( (1024*1024) > s.free ) {
+        throw OSRMException("temporary device is full");
+    }
+}
+
+boost::filesystem::fstream::pos_type TemporaryStorage::Tell(const int slot_id) {
     boost::filesystem::fstream::pos_type position;
     try {
-        StreamData & data = vectorOfStreamDatas[slotID];
+        StreamData & data = stream_data_list[slot_id];
         boost::mutex::scoped_lock lock(*data.readWriteMutex);
-        position = data.streamToTemporaryFile->tellp();
+        position = data.temp_file->tellp();
     } catch(boost::filesystem::filesystem_error & e) {
-        abort(e);
-   }
+        Abort(e);
+    }
     return position;
 }
 
-void TemporaryStorage::abort(boost::filesystem::filesystem_error& ) {
-    removeAll();
-}
-
-void TemporaryStorage::seek(int slotID, boost::filesystem::fstream::pos_type position) {
-    try {
-        StreamData & data = vectorOfStreamDatas[slotID];
-        boost::mutex::scoped_lock lock(*data.readWriteMutex);
-        data.streamToTemporaryFile->seekg(position);
-    } catch(boost::filesystem::filesystem_error & e) {
-        abort(e);
-    }
+void TemporaryStorage::Abort(const boost::filesystem::filesystem_error& e) {
+    RemoveAll();
+    throw OSRMException(e.what());
 }

Contractor/TemporaryStorage.h

@@ -28,46 +28,23 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef TEMPORARYSTORAGE_H_
 #define TEMPORARYSTORAGE_H_
 
-#include <vector>
-#include <fstream>
-
-#include <boost/assert.hpp>
-#include <boost/foreach.hpp>
-#include <boost/filesystem.hpp>
-#include <boost/filesystem/fstream.hpp>
-#include <boost/shared_ptr.hpp>
-#include <boost/thread/mutex.hpp>
-
+#include "../Util/BoostFileSystemFix.h"
 #include "../Util/OSRMException.h"
 #include "../Util/SimpleLogger.h"
 #include "../typedefs.h"
 
-//This is one big workaround for latest boost renaming woes.
+#include <boost/assert.hpp>
+#include <boost/foreach.hpp>
+#include <boost/integer.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/filesystem/fstream.hpp>
+#include <boost/make_shared.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/thread/mutex.hpp>
 
-#if BOOST_FILESYSTEM_VERSION < 3
-#warning Boost Installation with Filesystem3 missing, activating workaround
-#include <cstdio>
-namespace boost {
-namespace filesystem {
-inline path temp_directory_path() {
-	char * buffer;
-	buffer = tmpnam (NULL);
+#include <vector>
+#include <fstream>
 
-	return path(buffer);
-}
-
-inline path unique_path(const path&) {
-	return temp_directory_path();
-}
-
-}
-}
-
-#endif
-
-#ifndef BOOST_FILESYSTEM_VERSION
-#define BOOST_FILESYSTEM_VERSION 3
-#endif
 /**
  * This class implements a singleton file storage for temporary data.
  * temporary slots can be accessed by other objects through an int
@@ -77,49 +54,65 @@ inline path unique_path(const path&) {
  * -> Data is written in first phase and reread in second.
  */
 
-static boost::filesystem::path tempDirectory;
+static boost::filesystem::path temp_directory;
 static std::string TemporaryFilePattern("OSRM-%%%%-%%%%-%%%%");
 class TemporaryStorage {
 public:
     static TemporaryStorage & GetInstance();
     virtual ~TemporaryStorage();
 
-    int allocateSlot();
-    void deallocateSlot(int slotID);
-    void writeToSlot(int slotID, char * pointer, std::streamsize size);
-    void readFromSlot(int slotID, char * pointer, std::streamsize size);
+    int AllocateSlot();
+    void DeallocateSlot(const int slot_id);
+    void WriteToSlot(const int slot_id, char * pointer, const std::size_t size);
+    void ReadFromSlot(const int slot_id, char * pointer, const std::size_t size);
     //returns the number of free bytes
-    unsigned getFreeBytesOnTemporaryDevice();
-    boost::filesystem::fstream::pos_type tell(int slotID);
-    void seek(int slotID, boost::filesystem::fstream::pos_type);
-    void removeAll();
+    uint64_t GetFreeBytesOnTemporaryDevice();
+    boost::filesystem::fstream::pos_type Tell(const int slot_id);
+    void RemoveAll();
 private:
     TemporaryStorage();
     TemporaryStorage(TemporaryStorage const &){};
-    TemporaryStorage& operator=(TemporaryStorage const &) {
+
+    TemporaryStorage & operator=(TemporaryStorage const &) {
         return *this;
     }
-    void abort(boost::filesystem::filesystem_error& e);
+
+    void Abort(const boost::filesystem::filesystem_error& e);
+    void CheckIfTemporaryDeviceFull();
 
     struct StreamData {
-        bool writeMode;
-        boost::filesystem::path pathToTemporaryFile;
-        boost::shared_ptr<boost::filesystem::fstream> streamToTemporaryFile;
+        bool write_mode;
+        boost::filesystem::path temp_path;
+        boost::shared_ptr<boost::filesystem::fstream> temp_file;
         boost::shared_ptr<boost::mutex> readWriteMutex;
+        std::vector<char> buffer;
+
         StreamData() :
-            writeMode(true),
-            pathToTemporaryFile (boost::filesystem::unique_path(tempDirectory.append(TemporaryFilePattern.begin(), TemporaryFilePattern.end()))),
-            streamToTemporaryFile(new boost::filesystem::fstream(pathToTemporaryFile, std::ios::in | std::ios::out | std::ios::trunc | std::ios::binary)),
-            readWriteMutex(new boost::mutex)
+            write_mode(true),
+            temp_path(
+                boost::filesystem::unique_path(
+                    temp_directory.append(
+                        TemporaryFilePattern.begin(),
+                        TemporaryFilePattern.end()
+                    )
+                )
+            ),
+            temp_file(
+                new boost::filesystem::fstream(
+                    temp_path,
+                    std::ios::in|std::ios::out|std::ios::trunc|std::ios::binary
+                )
+            ),
+            readWriteMutex(boost::make_shared<boost::mutex>())
         {
-            if(streamToTemporaryFile->fail()) {
+            if( temp_file->fail() ) {
                 throw OSRMException("temporary file could not be created");
             }
         }
     };
     //vector of file streams that is used to store temporary data
-    std::vector<StreamData> vectorOfStreamDatas;
     boost::mutex mutex;
+    std::vector<StreamData> stream_data_list;
 };
 
 #endif /* TEMPORARYSTORAGE_H_ */

DataStructures/BinaryHeap.h

@@ -25,14 +25,14 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 */
 
-#ifndef BINARYHEAP_H_INCLUDED
-#define BINARYHEAP_H_INCLUDED
+#ifndef BINARY_HEAP_H
+#define BINARY_HEAP_H
 
 //Not compatible with non contiguous node ids
 
 #include <boost/unordered_map.hpp>
 
-#include <cassert>
+#include <boost/assert.hpp>
 
 #include <algorithm>
 #include <limits>
@@ -82,6 +82,9 @@ private:
 
 template< typename NodeID, typename Key >
 class UnorderedMapStorage {
+    typedef boost::unordered_map<NodeID, Key> UnorderedMapType;
+    typedef typename UnorderedMapType::iterator UnorderedMapIterator;
+    typedef typename UnorderedMapType::const_iterator UnorderedMapConstIterator;
 public:
 
 	UnorderedMapStorage( size_t ) {
@@ -89,8 +92,8 @@ public:
 		nodes.rehash(1000);
 	}
 
-    Key &operator[]( const NodeID node ) {
-    	return nodes[node];
+    Key & operator[]( const NodeID node ) {
+        return nodes[node];
     }
 
     void Clear() {
@@ -101,13 +104,13 @@ private:
     boost::unordered_map< NodeID, Key > nodes;
 };
 
-template<typename NodeID = unsigned>
-struct _SimpleHeapData {
-    NodeID parent;
-    _SimpleHeapData( NodeID p ) : parent(p) { }
-};
-
-template < typename NodeID, typename Key, typename Weight, typename Data, typename IndexStorage = ArrayStorage<NodeID, NodeID> >
+template<
+    typename NodeID,
+    typename Key,
+    typename Weight,
+    typename Data,
+    typename IndexStorage = ArrayStorage<NodeID, NodeID>
+>
 class BinaryHeap {
 private:
     BinaryHeap( const BinaryHeap& right );
@@ -117,7 +120,9 @@ public:
     typedef Data DataType;
 
     BinaryHeap( size_t maxID )
-    : nodeIndex( maxID ) {
+     :
+        nodeIndex( maxID )
+    {
         Clear();
     }
 
@@ -132,6 +137,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());
@@ -155,7 +164,7 @@ public:
     }
 
     bool WasRemoved( const NodeID node ) {
-        assert( WasInserted( node ) );
+        BOOST_ASSERT( WasInserted( node ) );
         const Key index = nodeIndex[node];
         return insertedNodes[index].key == 0;
     }
@@ -168,12 +177,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();
@@ -192,10 +201,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;
@@ -206,11 +215,13 @@ public:
 private:
     class HeapNode {
     public:
-        HeapNode() {
-        }
         HeapNode( NodeID n, Key k, Weight w, Data d )
-        : node( n ), key( k ), weight( w ), data( d ) {
-        }
+         :
+            node(n),
+            key(k),
+            weight(w),
+            data(d)
+        { }
 
         NodeID node;
         Key key;
@@ -230,14 +241,17 @@ private:
         const Key droppingIndex = heap[key].index;
         const Weight weight = heap[key].weight;
         Key nextKey = key << 1;
-        while ( nextKey < static_cast<Key>( heap.size() ) ) {
+        while( nextKey < static_cast<Key>( heap.size() ) ){
             const Key nextKeyOther = nextKey + 1;
-            if ( ( nextKeyOther < static_cast<Key> ( heap.size() ) )&& ( heap[nextKey].weight > heap[nextKeyOther].weight) )
+            if (
+                ( nextKeyOther < static_cast<Key>( heap.size() )   ) &&
+                ( heap[nextKey].weight > heap[nextKeyOther].weight )
+            ) {
                 nextKey = nextKeyOther;
-
-            if ( weight <= heap[nextKey].weight )
+            }
+            if ( weight <= heap[nextKey].weight ){
                 break;
-
+            }
             heap[key] = heap[nextKey];
             insertedNodes[heap[key].index].key = key;
             key = nextKey;
@@ -253,7 +267,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;
@@ -267,10 +281,10 @@ 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
     }
 };
 
-#endif //#ifndef BINARYHEAP_H_INCLUDED
+#endif //BINARY_HEAP_H

DataStructures/Coordinate.cpp

@@ -0,0 +1,162 @@
+/*
+
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#include <osrm/Coordinate.h>
+#include "../Util/StringUtil.h"
+
+#include <boost/assert.hpp>
+#include <cmath>
+#include <climits>
+
+FixedPointCoordinate::FixedPointCoordinate()
+ :  lat(INT_MIN),
+    lon(INT_MIN)
+{ }
+
+FixedPointCoordinate::FixedPointCoordinate(int lat, int lon)
+ :  lat(lat),
+    lon(lon)
+{ }
+
+void FixedPointCoordinate::Reset() {
+    lat = INT_MIN;
+    lon = INT_MIN;
+}
+bool FixedPointCoordinate::isSet() const {
+    return (INT_MIN != lat) && (INT_MIN != lon);
+}
+bool FixedPointCoordinate::isValid() const {
+    if(
+        lat >   90*COORDINATE_PRECISION ||
+        lat <  -90*COORDINATE_PRECISION ||
+        lon >  180*COORDINATE_PRECISION ||
+        lon < -180*COORDINATE_PRECISION
+    ) {
+        return false;
+    }
+    return true;
+}
+bool FixedPointCoordinate::operator==(const FixedPointCoordinate & other) const {
+    return lat == other.lat && lon == other.lon;
+}
+
+double FixedPointCoordinate::ApproximateDistance(
+    const int lat1,
+    const int lon1,
+    const int lat2,
+    const int lon2
+) {
+    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;
+    double lt2 = lat2/COORDINATE_PRECISION;
+    double ln2 = lon2/COORDINATE_PRECISION;
+    double dlat1=lt1*(RAD);
+
+    double dlong1=ln1*(RAD);
+    double dlat2=lt2*(RAD);
+    double dlong2=ln2*(RAD);
+
+    double dLong=dlong1-dlong2;
+    double dLat=dlat1-dlat2;
+
+    double aHarv= pow(sin(dLat/2.0),2.0)+cos(dlat1)*cos(dlat2)*pow(sin(dLong/2.),2);
+    double cHarv=2.*atan2(sqrt(aHarv),sqrt(1.0-aHarv));
+    //earth radius varies between 6,356.750-6,378.135 km (3,949.901-3,963.189mi)
+    //The IUGG value for the equatorial radius is 6378.137 km (3963.19 miles)
+    const double earth=6372797.560856;
+    double distance=earth*cHarv;
+    return distance;
+}
+
+double FixedPointCoordinate::ApproximateDistance(
+    const FixedPointCoordinate &c1,
+    const FixedPointCoordinate &c2
+) {
+    return ApproximateDistance( c1.lat, c1.lon, c2.lat, c2.lon );
+}
+
+double FixedPointCoordinate::ApproximateEuclideanDistance(
+    const FixedPointCoordinate &c1,
+    const FixedPointCoordinate &c2
+) {
+    BOOST_ASSERT(c1.lat != INT_MIN);
+    BOOST_ASSERT(c1.lon != INT_MIN);
+    BOOST_ASSERT(c2.lat != INT_MIN);
+    BOOST_ASSERT(c2.lon != INT_MIN);
+    const double RAD = 0.017453292519943295769236907684886;
+    const double lat1 = (c1.lat/COORDINATE_PRECISION)*RAD;
+    const double lon1 = (c1.lon/COORDINATE_PRECISION)*RAD;
+    const double lat2 = (c2.lat/COORDINATE_PRECISION)*RAD;
+    const double lon2 = (c2.lon/COORDINATE_PRECISION)*RAD;
+
+    const double x = (lon2-lon1) * cos((lat1+lat2)/2.);
+    const double y = (lat2-lat1);
+    const double earthRadius = 6372797.560856;
+    const double d = sqrt(x*x + y*y) * earthRadius;
+    return d;
+}
+
+void FixedPointCoordinate::convertInternalLatLonToString(
+    const int value,
+    std::string & output
+) {
+    char buffer[100];
+    buffer[11] = 0; // zero termination
+    char* string = printInt< 11, 6 >( buffer, value );
+    output = string;
+}
+
+void FixedPointCoordinate::convertInternalCoordinateToString(
+    const FixedPointCoordinate & coord,
+    std::string & output
+) {
+    std::string tmp;
+    tmp.reserve(23);
+    convertInternalLatLonToString(coord.lon, tmp);
+    output = tmp;
+    output += ",";
+    convertInternalLatLonToString(coord.lat, tmp);
+    output += tmp;
+}
+
+void FixedPointCoordinate::convertInternalReversedCoordinateToString(
+    const FixedPointCoordinate & coord,
+    std::string & output
+) {
+    std::string tmp;
+    tmp.reserve(23);
+    convertInternalLatLonToString(coord.lat, tmp);
+    output = tmp;
+    output += ",";
+    convertInternalLatLonToString(coord.lon, tmp);
+    output += tmp;
+}

DataStructures/Coordinate.h

@@ -1,170 +0,0 @@
-/*
-
-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 FIXED_POINT_COORDINATE_H_
-#define FIXED_POINT_COORDINATE_H_
-
-#include "../DataStructures/MercatorUtil.h"
-#include "../Util/StringUtil.h"
-
-#include <cassert>
-#include <cmath>
-#include <climits>
-
-#include <iostream>
-
-static const double COORDINATE_PRECISION = 1000000.;
-
-struct FixedPointCoordinate {
-    int lat;
-    int lon;
-    FixedPointCoordinate () : lat(INT_MIN), lon(INT_MIN) {}
-    explicit FixedPointCoordinate (int lat, int lon) : lat(lat) , lon(lon) {}
-
-    void Reset() {
-        lat = INT_MIN;
-        lon = INT_MIN;
-    }
-    bool isSet() const {
-        return (INT_MIN != lat) && (INT_MIN != lon);
-    }
-    inline bool isValid() const {
-        if(
-            lat >   90*COORDINATE_PRECISION ||
-            lat <  -90*COORDINATE_PRECISION ||
-            lon >  180*COORDINATE_PRECISION ||
-            lon < -180*COORDINATE_PRECISION
-        ) {
-            return false;
-        }
-        return true;
-    }
-    bool operator==(const FixedPointCoordinate & other) const {
-        return lat == other.lat && lon == other.lon;
-    }
-};
-
-inline std::ostream & operator<<(std::ostream & out, const FixedPointCoordinate & c){
-    out << "(" << c.lat << "," << c.lon << ")";
-    return out;
-}
-
-inline double ApproximateDistance( const int lat1, const int lon1, const int lat2, const int lon2 ) {
-    assert(lat1 != INT_MIN);
-    assert(lon1 != INT_MIN);
-    assert(lat2 != INT_MIN);
-    assert(lon2 != INT_MIN);
-    double RAD = 0.017453292519943295769236907684886;
-    double lt1 = lat1/COORDINATE_PRECISION;
-    double ln1 = lon1/COORDINATE_PRECISION;
-    double lt2 = lat2/COORDINATE_PRECISION;
-    double ln2 = lon2/COORDINATE_PRECISION;
-    double dlat1=lt1*(RAD);
-
-    double dlong1=ln1*(RAD);
-    double dlat2=lt2*(RAD);
-    double dlong2=ln2*(RAD);
-
-    double dLong=dlong1-dlong2;
-    double dLat=dlat1-dlat2;
-
-    double aHarv= pow(sin(dLat/2.0),2.0)+cos(dlat1)*cos(dlat2)*pow(sin(dLong/2.),2);
-    double cHarv=2.*atan2(sqrt(aHarv),sqrt(1.0-aHarv));
-    //earth's radius from wikipedia varies between 6,356.750 km — 6,378.135 km (˜3,949.901 — 3,963.189 miles)
-    //The IUGG value for the equatorial radius of the Earth is 6378.137 km (3963.19 mile)
-    const double earth=6372797.560856;//I am doing miles, just change this to radius in kilometers to get distances in km
-    double distance=earth*cHarv;
-    return distance;
-}
-
-inline double ApproximateDistance(const FixedPointCoordinate &c1, const FixedPointCoordinate &c2) {
-    return ApproximateDistance( c1.lat, c1.lon, c2.lat, c2.lon );
-}
-
-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);
-    const double RAD = 0.017453292519943295769236907684886;
-    const double lat1 = (c1.lat/COORDINATE_PRECISION)*RAD;
-    const double lon1 = (c1.lon/COORDINATE_PRECISION)*RAD;
-    const double lat2 = (c2.lat/COORDINATE_PRECISION)*RAD;
-    const double lon2 = (c2.lon/COORDINATE_PRECISION)*RAD;
-
-    const double x = (lon2-lon1) * cos((lat1+lat2)/2.);
-    const double y = (lat2-lat1);
-    const double earthRadius = 6372797.560856;
-    const double d = sqrt(x*x + y*y) * earthRadius;
-    return d;
-}
-
-static inline void convertInternalLatLonToString(const int value, std::string & output) {
-    char buffer[100];
-    buffer[11] = 0; // zero termination
-    char* string = printInt< 11, 6 >( buffer, value );
-    output = string;
-}
-
-static inline void convertInternalCoordinateToString(const FixedPointCoordinate & coord, std::string & output) {
-    std::string tmp;
-    convertInternalLatLonToString(coord.lon, tmp);
-    output = tmp;
-    output += ",";
-    convertInternalLatLonToString(coord.lat, tmp);
-    output += tmp;
-    output += " ";
-}
-static inline void convertInternalReversedCoordinateToString(const FixedPointCoordinate & coord, std::string & output) {
-    std::string tmp;
-    convertInternalLatLonToString(coord.lat, tmp);
-    output = tmp;
-    output += ",";
-    convertInternalLatLonToString(coord.lon, tmp);
-    output += tmp;
-    output += " ";
-}
-
-
-/* Get angle of line segment (A,C)->(C,B), atan2 magic, formerly cosine theorem*/
-template<class CoordinateT>
-static inline double GetAngleBetweenThreeFixedPointCoordinates (
-    const CoordinateT & A,
-    const CoordinateT & C,
-    const CoordinateT & B
-) {
-    const double v1x = (A.lon - C.lon)/COORDINATE_PRECISION;
-    const double v1y = lat2y(A.lat/COORDINATE_PRECISION) - lat2y(C.lat/COORDINATE_PRECISION);
-    const double v2x = (B.lon - C.lon)/COORDINATE_PRECISION;
-    const double v2y = lat2y(B.lat/COORDINATE_PRECISION) - lat2y(C.lat/COORDINATE_PRECISION);
-
-    double angle = (atan2(v2y,v2x) - atan2(v1y,v1x) )*180/M_PI;
-    while(angle < 0)
-        angle += 360;
-    return angle;
-}
-#endif /* FIXED_POINT_COORDINATE_H_ */

DataStructures/DeallocatingVector.h

@@ -28,7 +28,7 @@ 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>
 
@@ -48,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) {
@@ -112,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) {
@@ -182,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

@@ -41,8 +41,8 @@ template< typename EdgeDataT>
 class DynamicGraph {
     public:
         typedef EdgeDataT EdgeData;
-        typedef uint32_t NodeIterator;
-        typedef uint32_t EdgeIterator;
+        typedef unsigned NodeIterator;
+        typedef unsigned EdgeIterator;
 
         class InputEdge {
             public:
@@ -101,15 +101,15 @@ class DynamicGraph {
 
         ~DynamicGraph(){ }
 
-        uint32_t GetNumberOfNodes() const {
+        unsigned GetNumberOfNodes() const {
             return m_numNodes;
         }
 
-        uint32_t GetNumberOfEdges() const {
+        unsigned GetNumberOfEdges() const {
             return m_numEdges;
         }
 
-        uint32_t GetOutDegree( const NodeIterator n ) const {
+        unsigned GetOutDegree( const NodeIterator n ) const {
             return m_nodes[n].edges;
         }
 
@@ -117,6 +117,10 @@ class DynamicGraph {
             return NodeIterator( m_edges[e].target );
         }
 
+        void SetTarget( const EdgeIterator e, const NodeIterator n ) {
+            m_edges[e].target = n;
+        }
+
         EdgeDataT &GetEdgeData( const EdgeIterator e ) {
             return m_edges[e].data;
         }
@@ -143,7 +147,7 @@ class DynamicGraph {
                     m_edges[node.firstEdge] = m_edges[node.firstEdge + node.edges];
                 } else {
                     EdgeIterator newFirstEdge = ( EdgeIterator ) m_edges.size();
-                    uint32_t newSize = node.edges * 1.1 + 2;
+                    unsigned newSize = node.edges * 1.1 + 2;
                     EdgeIterator requiredCapacity = newSize + m_edges.size();
                     EdgeIterator oldCapacity = m_edges.capacity();
                     if ( requiredCapacity >= oldCapacity ) {
@@ -170,9 +174,12 @@ class DynamicGraph {
         //removes an edge. Invalidates edge iterators for the source node
         void DeleteEdge( const NodeIterator source, const EdgeIterator e ) {
             Node &node = m_nodes[source];
+            #pragma omp atomic
             --m_numEdges;
             --node.edges;
-            const uint32_t last = node.firstEdge + node.edges;
+            BOOST_ASSERT(UINT_MAX != node.edges);
+            const unsigned last = node.firstEdge + node.edges;
+            BOOST_ASSERT( UINT_MAX != last);
             //swap with last edge
             m_edges[e] = m_edges[last];
             makeDummy( last );
@@ -222,7 +229,7 @@ class DynamicGraph {
             //index of the first edge
             EdgeIterator firstEdge;
             //amount of edges
-            uint32_t edges;
+            unsigned edges;
         };
 
         struct Edge {

DataStructures/EdgeBasedNode.h

@@ -0,0 +1,176 @@
+#ifndef EDGE_BASED_NODE_H
+#define EDGE_BASED_NODE_H
+
+#include <cmath>
+
+#include <boost/assert.hpp>
+
+#include "../Util/MercatorUtil.h"
+#include "../typedefs.h"
+
+#include <osrm/Coordinate.h>
+
+// An EdgeBasedNode represents a node in the edge-expanded graph.
+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)
+    { }
+
+    // Computes:
+    // - the distance from the given query location to nearest point on this edge (and returns it)
+    // - the location on this edge which is nearest to the query location
+    // - the ratio ps:pq, where p and q are the end points of this edge, and s is the perpendicular foot of
+    //   the query location on the line defined by p and q.
+    double ComputePerpendicularDistance(
+        const FixedPointCoordinate& query_location,
+        FixedPointCoordinate & nearest_location,
+        double & ratio,
+        double precision = COORDINATE_PRECISION
+    ) const {
+        BOOST_ASSERT( query_location.isValid() );
+
+        const double epsilon = 1.0/precision;
+
+        if( ignoreInGrid ) {
+            return std::numeric_limits<double>::max();
+        }
+
+        // p, q : the end points of the underlying edge
+        const Point p(lat2y(lat1/COORDINATE_PRECISION), lon1/COORDINATE_PRECISION);
+        const Point q(lat2y(lat2/COORDINATE_PRECISION), lon2/COORDINATE_PRECISION);
+
+        // r : query location
+        const Point r(lat2y(query_location.lat/COORDINATE_PRECISION),
+                            query_location.lon/COORDINATE_PRECISION);
+
+        const Point foot = ComputePerpendicularFoot(p, q, r, epsilon);
+        ratio            = ComputeRatio(p, q, foot, epsilon);
+
+        BOOST_ASSERT( !std::isnan(ratio) );
+
+        nearest_location = ComputeNearestPointOnSegment(foot, ratio);
+
+        BOOST_ASSERT( nearest_location.isValid() );
+
+        // TODO: Replace with euclidean approximation when k-NN search is done
+        // const double approximated_distance = FixedPointCoordinate::ApproximateEuclideanDistance(
+        const double approximated_distance = FixedPointCoordinate::ApproximateDistance(query_location, nearest_location);
+
+        BOOST_ASSERT( 0.0 <= approximated_distance );
+        return approximated_distance;
+    }
+
+    bool operator<(const EdgeBasedNode & other) const {
+        return other.id < id;
+    }
+
+    bool operator==(const EdgeBasedNode & other) const {
+        return id == other.id;
+    }
+
+    // Returns the midpoint of the underlying edge.
+    inline FixedPointCoordinate Centroid() const {
+        return FixedPointCoordinate((lat1+lat2)/2, (lon1+lon2)/2);
+    }
+
+    NodeID id;
+
+    // The coordinates of the end-points of the underlying edge.
+    int lat1;
+    int lat2;
+    int lon1;
+    int lon2:31;
+
+    bool belongsToTinyComponent:1;
+    NodeID nameID;
+
+    // The weight of the underlying edge.
+    unsigned weight:31;
+
+    bool ignoreInGrid:1;
+
+private:
+
+    typedef std::pair<double,double> Point;
+
+    // Compute the perpendicular foot of point r on the line defined by p and q.
+    Point ComputePerpendicularFoot(const Point &p, const Point &q, const Point &r, double epsilon) const {
+
+        // the projection of r onto the line pq
+        double foot_x, foot_y;
+
+        const bool is_parallel_to_y_axis = std::abs(q.first - p.first) < epsilon;
+
+        if( is_parallel_to_y_axis ) {
+            foot_x = q.first;
+            foot_y = r.second;
+        } else {
+            // the slope of the line through (a|b) and (c|d)
+            const double m = (q.second - p.second) / (q.first - p.first);
+
+            // Projection of (x|y) onto the line joining (a|b) and (c|d).
+            foot_x = ((r.first + (m*r.second)) + (m*m*p.first - m*p.second))/(1.0 + m*m);
+            foot_y = p.second + m*(foot_x - p.first);
+        }
+
+        return Point(foot_x, foot_y);
+    }
+
+    // Compute the ratio of the line segment pr to line segment pq.
+    double ComputeRatio(const Point & p, const Point & q, const Point & r, double epsilon) const {
+
+        const bool is_parallel_to_x_axis = std::abs(q.second-p.second) < epsilon;
+        const bool is_parallel_to_y_axis = std::abs(q.first -p.first ) < epsilon;
+
+        double ratio;
+
+        if( !is_parallel_to_y_axis ) {
+            ratio = (r.first - p.first)/(q.first - p.first);
+        } else if( !is_parallel_to_x_axis ) {
+            ratio = (r.second - p.second)/(q.second - p.second);
+        } else {
+            // (a|b) and (c|d) are essentially the same point
+            // by convention, we set the ratio to 0 in this case
+            //ratio = ((lat2 == query_location.lat) && (lon2 == query_location.lon)) ? 1. : 0.;
+            ratio = 0.0;
+        }
+
+        // Round to integer if the ratio is close to 0 or 1.
+        if( std::abs(ratio) <= epsilon ) {
+            ratio = 0.0;
+        } else if( std::abs(ratio-1.0) <= epsilon ) {
+            ratio = 1.0;
+        }
+
+        return ratio;
+    }
+
+    // Computes the point on the segment pq which is nearest to a point r = p + lambda * (q-p).
+    // p and q are the end points of the underlying edge.
+    FixedPointCoordinate ComputeNearestPointOnSegment(const Point & r, double lambda) const {
+
+        if( lambda <= 0.0 ) {
+            return FixedPointCoordinate(lat1, lon1);
+        } else if( lambda >= 1.0 ) {
+            return FixedPointCoordinate(lat2, lon2);
+        }
+
+        // r lies between p and q
+        return  FixedPointCoordinate(
+                    y2lat(r.first)*COORDINATE_PRECISION,
+                    r.second*COORDINATE_PRECISION
+                );
+    }
+
+};
+
+#endif //EDGE_BASED_NODE_H

DataStructures/HashTable.h

@@ -25,43 +25,44 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 */
 
-#ifndef HASHTABLE_H_
-#define HASHTABLE_H_
+#ifndef HASH_TABLE_H
+#define HASH_TABLE_H
 
 #include <boost/ref.hpp>
 #include <boost/unordered_map.hpp>
 
-template<typename keyT, typename valueT>
-class HashTable : public boost::unordered_map<keyT, valueT> {
+template<typename KeyT, typename ValueT>
+class HashTable : public boost::unordered_map<KeyT, ValueT> {
 private:
-    typedef boost::unordered_map<keyT, valueT> super;
+    typedef boost::unordered_map<KeyT, ValueT> super;
 public:
+    static ValueT default_value;
+
     HashTable() : super() { }
 
     HashTable(const unsigned size) : super(size) { }
 
-    HashTable &operator=(const HashTable &other) {
-        super::operator = (other);
-        return *this;
+    inline void Add( KeyT const & key, ValueT const & value) {
+        super::emplace(std::make_pair(key, value));
     }
 
-    inline void Add(const keyT& key, const valueT& value){
-        super::insert(std::make_pair(key, value));
-    }
-
-    inline valueT Find(const keyT& key) const {
-        if(super::find(key) == super::end()) {
-            return valueT();
+    inline const ValueT Find(KeyT const & key) const {
+        typename super::const_iterator iter = super::find(key);
+        if( iter == super::end() ) {
+            return boost::cref(default_value);
         }
-        return boost::ref(super::find(key)->second);
+        return boost::cref(iter->second);
     }
 
-    inline bool Holds(const keyT& key) const {
-        if(super::find(key) == super::end()) {
+    inline bool Holds( KeyT const & key) const {
+        if( super::find(key) == super::end() ) {
             return false;
         }
         return true;
     }
 };
 
-#endif /* HASHTABLE_H_ */
+template<typename KeyT, typename ValueT>
+ValueT HashTable<KeyT, ValueT>::default_value;
+
+#endif /* HASH_TABLE_H */

DataStructures/HilbertValue.cpp

@@ -0,0 +1,88 @@
+/*
+
+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 "HilbertValue.h"
+
+uint64_t HilbertCode::operator() (
+    const FixedPointCoordinate & current_coordinate
+) const {
+    unsigned location[2];
+    location[0] = current_coordinate.lat+( 90*COORDINATE_PRECISION);
+    location[1] = current_coordinate.lon+(180*COORDINATE_PRECISION);
+
+    TransposeCoordinate(location);
+    return BitInterleaving(location[0], location[1]);
+}
+
+uint64_t HilbertCode::BitInterleaving(const uint32_t latitude, const uint32_t longitude) const
+{
+    uint64_t result = 0;
+    for(int8_t index = 31; index >= 0; --index){
+        result |= (latitude >> index) & 1;
+        result <<= 1;
+        result |= (longitude >> index) & 1;
+        if(0 != index){
+            result <<= 1;
+        }
+    }
+    return result;
+}
+
+void HilbertCode::TransposeCoordinate( uint32_t * X) const
+{
+    uint32_t M = 1 << (32-1), P, Q, t;
+    int i;
+    // Inverse undo
+    for( Q = M; Q > 1; Q >>= 1 ) {
+        P=Q-1;
+        for( i = 0; i < 2; ++i ) {
+
+            const bool condition = (X[i] & Q);
+            if( condition ) {
+                X[0] ^= P; // invert
+            } else {
+                t = (X[0]^X[i]) & P;
+                X[0] ^= t;
+                X[i] ^= t;
+            }
+        } // exchange
+    }
+    // Gray encode
+    for( i = 1; i < 2; ++i ) {
+        X[i] ^= X[i-1];
+    }
+    t=0;
+    for( Q = M; Q > 1; Q >>= 1 ) {
+        const bool condition = (X[2-1] & Q);
+        if( condition ) {
+            t ^= Q-1;
+        }
+    } //check if this for loop is wrong
+    for( i = 0; i < 2; ++i ) {
+        X[i] ^= t;
+    }
+}

DataStructures/HilbertValue.h

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

DataStructures/ImportNode.h

@@ -32,15 +32,31 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #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;
@@ -49,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/NodeInformationHelpDesk.h

@@ -1,218 +0,0 @@
-/*
-
-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 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 & ram_index_filename,
-        const std::string & mem_index_filename,
-        const std::string & nodes_filename,
-        const std::string & edges_filename,
-        const unsigned m_number_of_nodes,
-        const unsigned m_check_sum
-    ) :
-        m_number_of_nodes(m_number_of_nodes),
-        m_check_sum(m_check_sum)
-    {
-        if ( ram_index_filename.empty() ) {
-            throw OSRMException("no ram index file name in server ini");
-        }
-        if ( mem_index_filename.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");
-        }
-
-        m_ro_rtree_ptr = new StaticRTree<RTreeLeaf>(
-            ram_index_filename,
-            mem_index_filename
-        );
-        BOOST_ASSERT_MSG(
-            0 == m_coordinate_list.size(),
-            "Coordinate vector not empty"
-        );
-
-        LoadNodesAndEdges(nodes_filename, edges_filename);
-    }
-
-	~NodeInformationHelpDesk() {
-		delete m_ro_rtree_ptr;
-	}
-
-    inline FixedPointCoordinate GetCoordinateOfNode(const unsigned id) const {
-        const NodeID node = m_via_node_list.at(id);
-        return m_coordinate_list.at(node);
-    }
-
-	inline unsigned GetNameIndexFromEdgeID(const unsigned id) const {
-	    return m_name_ID_list.at(id);
-	}
-
-    inline TurnInstruction GetTurnInstructionForEdgeID(const unsigned id) const {
-        return m_turn_instruction_list.at(id);
-    }
-
-    inline NodeID GetNumberOfNodes() const {
-        return m_number_of_nodes;
-    }
-
-    inline bool LocateClosestEndPointForCoordinate(
-            const FixedPointCoordinate& input_coordinate,
-            FixedPointCoordinate& result,
-            const unsigned zoom_level = 18
-    ) const {
-        bool found_node = m_ro_rtree_ptr->LocateClosestEndPointForCoordinate(
-                            input_coordinate,
-                            result, zoom_level
-                          );
-        return found_node;
-    }
-
-    inline bool FindPhantomNodeForCoordinate(
-            const FixedPointCoordinate & input_coordinate,
-            PhantomNode & resulting_phantom_node,
-            const unsigned zoom_level
-    ) const {
-        return m_ro_rtree_ptr->FindPhantomNodeForCoordinate(
-                input_coordinate,
-                resulting_phantom_node,
-                zoom_level
-        );
-    }
-
-	inline unsigned GetCheckSum() const {
-	    return m_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 current_node;
-        while(!nodes_input_stream.eof()) {
-            nodes_input_stream.read((char *)&current_node, sizeof(NodeInfo));
-            m_coordinate_list.push_back(
-                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";
-        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();
-        SimpleLogger().Write(logDEBUG)
-            << "Loaded " << number_of_edges << " orig edges";
-        SimpleLogger().Write(logDEBUG)
-            << "Opening NN indices";
-    }
-
-	std::vector<FixedPointCoordinate>  m_coordinate_list;
-	std::vector<NodeID>                m_via_node_list;
-	std::vector<unsigned>              m_name_ID_list;
-	std::vector<TurnInstruction>       m_turn_instruction_list;
-
-	StaticRTree<EdgeBasedGraphFactory::EdgeBasedNode> * m_ro_rtree_ptr;
-	const unsigned m_number_of_nodes;
-	const unsigned m_check_sum;
-};
-
-#endif /*NODEINFORMATIONHELPDESK_H_*/

DataStructures/OriginalEdgeData.h

@@ -0,0 +1,58 @@
+/*
+
+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 ORIGINAL_EDGE_DATA_H
+#define ORIGINAL_EDGE_DATA_H
+
+#include "TurnInstructions.h"
+#include "../typedefs.h"
+
+#include <climits>
+
+struct OriginalEdgeData{
+    explicit OriginalEdgeData(
+        NodeID via_node,
+        unsigned name_id,
+        TurnInstruction turn_instruction
+    ) :
+        via_node(via_node),
+        name_id(name_id),
+        turn_instruction(turn_instruction)
+    { }
+
+    OriginalEdgeData() :
+        via_node(UINT_MAX),
+        name_id(UINT_MAX),
+        turn_instruction(UCHAR_MAX)
+    { }
+
+    NodeID via_node;
+    unsigned name_id;
+    TurnInstruction turn_instruction;
+};
+
+#endif //ORIGINAL_EDGE_DATA_H

DataStructures/PhantomNodes.h

@@ -28,7 +28,9 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef PHANTOMNODES_H_
 #define PHANTOMNODES_H_
 
-#include "Coordinate.h"
+#include <osrm/Coordinate.h>
+
+#include "../typedefs.h"
 
 struct PhantomNode {
     PhantomNode() :
@@ -99,10 +101,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

@@ -28,32 +28,19 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef QUERYEDGE_H_
 #define QUERYEDGE_H_
 
-#include "TurnInstructions.h"
 #include "../typedefs.h"
 
 #include <climits>
 
-struct OriginalEdgeData{
-    explicit OriginalEdgeData(
-        NodeID viaNode,
-        unsigned nameID,
-        TurnInstruction turnInstruction
-    ) : viaNode(viaNode), nameID(nameID), turnInstruction(turnInstruction) {}
-    OriginalEdgeData() : viaNode(UINT_MAX), nameID(UINT_MAX), turnInstruction(UCHAR_MAX) {}
-    NodeID viaNode;
-    unsigned nameID;
-    TurnInstruction turnInstruction;
-};
-
 struct QueryEdge {
     NodeID source;
     NodeID target;
     struct EdgeData {
         NodeID id:31;
-        bool shortcut:1;
-        int distance:30;
-        bool forward:1;
-        bool backward:1;
+        bool   shortcut:1;
+        int    distance:30;
+        bool   forward:1;
+        bool   backward:1;
     } data;
 
     bool operator<( const QueryEdge& right ) const {
@@ -64,9 +51,14 @@ struct QueryEdge {
     }
 
     bool operator== ( const QueryEdge& right ) const {
-        return ( source == right.source && target == right.target && data.distance == right.data.distance &&
-                data.shortcut == right.data.shortcut && data.forward == right.data.forward && data.backward == right.data.backward
-                && data.id == right.data.id
+        return (
+            source == right.source               &&
+            target == right.target               &&
+            data.distance == right.data.distance &&
+            data.shortcut == right.data.shortcut &&
+            data.forward == right.data.forward   &&
+            data.backward == right.data.backward &&
+            data.id == right.data.id
         );
     }
 };

DataStructures/QueryNode.h

@@ -28,9 +28,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef _NODE_COORDS_H
 #define _NODE_COORDS_H
 
-#include "Coordinate.h"
 #include "../typedefs.h"
 
+#include <osrm/Coordinate.h>
+
 #include <boost/assert.hpp>
 
 #include <cstddef>

DataStructures/RawRouteData.h

@@ -28,29 +28,53 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef RAWROUTEDATA_H_
 #define RAWROUTEDATA_H_
 
-#include "../DataStructures/Coordinate.h"
 #include "../DataStructures/PhantomNodes.h"
 #include "../typedefs.h"
 
+#include <osrm/Coordinate.h>
+
+#include <limits>
+
 #include <vector>
 
-struct _PathData {
-    _PathData(NodeID no, unsigned na, unsigned tu, unsigned dur) : node(no), nameID(na), durationOfSegment(dur), turnInstruction(tu) { }
+struct PathData {
+    PathData() :
+        node(UINT_MAX),
+        name_id(UINT_MAX),
+        durationOfSegment(UINT_MAX),
+        turnInstruction(UCHAR_MAX)
+    { }
+
+    PathData(
+        NodeID no,
+        unsigned na,
+        unsigned tu,
+        unsigned dur
+    ) :
+        node(no),
+        name_id(na),
+        durationOfSegment(dur),
+        turnInstruction(tu)
+    { }
     NodeID node;
-    unsigned nameID;
+    unsigned name_id;
     unsigned durationOfSegment;
     short turnInstruction;
 };
 
 struct RawRouteData {
-    std::vector< _PathData > computedShortestPath;
-    std::vector< _PathData > computedAlternativePath;
+    std::vector< std::vector<PathData> > unpacked_path_segments;
+    std::vector< PathData > unpacked_alternative;
     std::vector< PhantomNodes > segmentEndCoordinates;
     std::vector< FixedPointCoordinate > rawViaNodeCoordinates;
     unsigned checkSum;
     int lengthOfShortestPath;
     int lengthOfAlternativePath;
-    RawRouteData() : checkSum(UINT_MAX), lengthOfShortestPath(INT_MAX), lengthOfAlternativePath(INT_MAX) {}
+    RawRouteData() :
+        checkSum(UINT_MAX),
+        lengthOfShortestPath(INT_MAX),
+        lengthOfAlternativePath(INT_MAX)
+    { }
 };
 
 #endif /* RAWROUTEDATA_H_ */

DataStructures/Restriction.h

@@ -73,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,
@@ -91,7 +91,7 @@ struct _RawRestrictionContainer {
     {
         restriction.viaNode = vn;
     }
-    _RawRestrictionContainer(
+    InputRestrictionContainer(
         bool isOnly = false
     ) :
         fromWay(UINT_MAX),
@@ -101,37 +101,48 @@ 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 {
+    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 {
+    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,91 +0,0 @@
-/*
-
-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 "SearchEngine.h"
-
-SearchEngine::SearchEngine( QueryObjectsStorage * query_objects ) :
-    _queryData(query_objects),
-    shortestPath(_queryData),
-    alternativePaths(_queryData)
-{}
-
-SearchEngine::~SearchEngine() {}
-
-void SearchEngine::GetCoordinatesForNodeID(
-    NodeID id,
-    FixedPointCoordinate& result
-) const {
-        result = _queryData.nodeHelpDesk->GetCoordinateOfNode(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 {
-    std::string result;
-    _queryData.query_objects->GetName(nameID, result);
-    return HTMLEntitize(result);
-}
-
-SearchEngineHeapPtr SearchEngineData::forwardHeap;
-SearchEngineHeapPtr SearchEngineData::backwardHeap;
-
-SearchEngineHeapPtr SearchEngineData::forwardHeap2;
-SearchEngineHeapPtr SearchEngineData::backwardHeap2;
-
-SearchEngineHeapPtr SearchEngineData::forwardHeap3;
-SearchEngineHeapPtr SearchEngineData::backwardHeap3;

DataStructures/SearchEngine.h

@@ -25,48 +25,44 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 */
 
-#ifndef SEARCHENGINE_H_
-#define SEARCHENGINE_H_
+#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 "../Server/DataStructures/QueryObjectsStorage.h"
 
 #include "../Util/StringUtil.h"
 #include "../typedefs.h"
 
+#include <osrm/Coordinate.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( QueryObjectsStorage * query_objects );
-	~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

@@ -27,41 +27,65 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "SearchEngineData.h"
 
-void SearchEngineData::InitializeOrClearFirstThreadLocalStorage() {
-    if(!forwardHeap.get()) {
-        forwardHeap.reset(new QueryHeap(nodeHelpDesk->GetNumberOfNodes()));
-    } else {
+void SearchEngineData::InitializeOrClearFirstThreadLocalStorage(const unsigned number_of_nodes)
+{
+    if (forwardHeap.get())
+    {
         forwardHeap->Clear();
     }
-    if(!backwardHeap.get()) {
-        backwardHeap.reset(new QueryHeap(nodeHelpDesk->GetNumberOfNodes()));
-    } else {
+    else
+    {
+        forwardHeap.reset(new QueryHeap(number_of_nodes));
+    }
+
+    if (backwardHeap.get())
+    {
         backwardHeap->Clear();
     }
+    else
+    {
+        backwardHeap.reset(new QueryHeap(number_of_nodes));
+    }
 }
 
-void SearchEngineData::InitializeOrClearSecondThreadLocalStorage() {
-    if(!forwardHeap2.get()) {
-        forwardHeap2.reset(new QueryHeap(nodeHelpDesk->GetNumberOfNodes()));
-    } else {
+void SearchEngineData::InitializeOrClearSecondThreadLocalStorage(const unsigned number_of_nodes)
+{
+    if (forwardHeap2.get())
+    {
         forwardHeap2->Clear();
     }
-    if(!backwardHeap2.get()) {
-        backwardHeap2.reset(new QueryHeap(nodeHelpDesk->GetNumberOfNodes()));
-     } else {
+    else
+    {
+        forwardHeap2.reset(new QueryHeap(number_of_nodes));
+    }
+
+    if (backwardHeap2.get())
+    {
         backwardHeap2->Clear();
     }
+    else
+    {
+        backwardHeap2.reset(new QueryHeap(number_of_nodes));
+    }
 }
 
-void SearchEngineData::InitializeOrClearThirdThreadLocalStorage() {
-    if(!forwardHeap3.get()) {
-        forwardHeap3.reset(new QueryHeap(nodeHelpDesk->GetNumberOfNodes()));
-    } else {
+void SearchEngineData::InitializeOrClearThirdThreadLocalStorage(const unsigned number_of_nodes)
+{
+    if (forwardHeap3.get())
+    {
         forwardHeap3->Clear();
     }
-    if(!backwardHeap3.get()) {
-        backwardHeap3.reset(new QueryHeap(nodeHelpDesk->GetNumberOfNodes()));
-    } else {
+    else
+    {
+        forwardHeap3.reset(new QueryHeap(number_of_nodes));
+    }
+
+    if (backwardHeap3.get())
+    {
         backwardHeap3->Clear();
     }
+    else
+    {
+        backwardHeap3.reset(new QueryHeap(number_of_nodes));
+    }
 }

DataStructures/SearchEngineData.h

@@ -25,10 +25,12 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 */
 
+#ifndef SEARCH_ENGINE_DATA_H
+#define SEARCH_ENGINE_DATA_H
+
 #include "BinaryHeap.h"
 #include "QueryEdge.h"
 #include "StaticGraph.h"
-#include "../Server/DataStructures/QueryObjectsStorage.h"
 
 #include "../typedefs.h"
 
@@ -41,23 +43,12 @@ 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(QueryObjectsStorage * query_objects)
-     :
-        query_objects(query_objects),
-        graph(query_objects->graph),
-        nodeHelpDesk(query_objects->nodeHelpDesk)
-    {}
-
-    const QueryObjectsStorage       * query_objects;
-    const QueryGraph                * graph;
-    const NodeInformationHelpDesk   * nodeHelpDesk;
+    typedef BinaryHeap< NodeID, NodeID, int, _HeapData, UnorderedMapStorage<NodeID, int> > QueryHeap;
+    typedef boost::thread_specific_ptr<QueryHeap> SearchEngineHeapPtr;
 
     static SearchEngineHeapPtr forwardHeap;
     static SearchEngineHeapPtr backwardHeap;
@@ -66,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

@@ -28,24 +28,54 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef SEGMENTINFORMATION_H_
 #define SEGMENTINFORMATION_H_
 
-#include "Coordinate.h"
 #include "TurnInstructions.h"
+
 #include "../typedefs.h"
 
-#include <climits>
+#include <osrm/Coordinate.h>
 
+// Struct fits everything in one cache line
 struct SegmentInformation {
     FixedPointCoordinate location;
-    NodeID nameID;
-    double length;
+    NodeID name_id;
     unsigned duration;
-    double bearing;
-    TurnInstruction turnInstruction;
+    double length;
+    short bearing; //more than enough [0..3600] fits into 12 bits
+    TurnInstruction turn_instruction;
     bool necessary;
-    SegmentInformation(const FixedPointCoordinate & loc, const NodeID nam, const double len, const unsigned dur, const TurnInstruction tInstr, const bool nec) :
-            location(loc), nameID(nam), length(len), duration(dur), bearing(0.), turnInstruction(tInstr), necessary(nec) {}
-    SegmentInformation(const FixedPointCoordinate & loc, const NodeID nam, const double len, const unsigned dur, const TurnInstruction tInstr) :
-        location(loc), nameID(nam), length(len), duration(dur), bearing(0.), turnInstruction(tInstr), necessary(tInstr != 0) {}
+
+    explicit SegmentInformation(
+        const FixedPointCoordinate & location,
+        const NodeID name_id,
+        const unsigned duration,
+        const double length,
+        const TurnInstruction turn_instruction,
+        const bool necessary
+    ) :
+        location(location),
+        name_id(name_id),
+        duration(duration),
+        length(length),
+        bearing(0),
+        turn_instruction(turn_instruction),
+        necessary(necessary)
+    { }
+
+    explicit SegmentInformation(
+        const FixedPointCoordinate & location,
+        const NodeID name_id,
+        const unsigned duration,
+        const double length,
+        const TurnInstruction turn_instruction
+    ) :
+        location(location),
+        name_id(name_id),
+        duration(duration),
+        length(length),
+        bearing(0),
+        turn_instruction(turn_instruction),
+        necessary(turn_instruction != 0)
+    { }
 };
 
 #endif /* SEGMENTINFORMATION_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/StaticGraph.h

@@ -29,13 +29,14 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #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;
@@ -47,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;
         }
     };
@@ -89,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) {
@@ -136,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++ ) {
@@ -174,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;
     }
@@ -194,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

@@ -30,7 +30,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef STATICKDTREE_H_INCLUDED
 #define STATICKDTREE_H_INCLUDED
 
-#include <cassert>
+#include <boost/assert.hpp>
 #include <vector>
 #include <algorithm>
 #include <stack>
@@ -100,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 ) {
@@ -209,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

@@ -28,16 +28,20 @@ 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 "PhantomNodes.h"
+#include "SharedMemoryFactory.h"
+#include "SharedMemoryVectorWrapper.h"
+
+#include "../Util/MercatorUtil.h"
 #include "../Util/OSRMException.h"
 #include "../Util/SimpleLogger.h"
 #include "../Util/TimingUtil.h"
 #include "../typedefs.h"
 
+#include <osrm/Coordinate.h>
+
 #include <boost/assert.hpp>
 #include <boost/bind.hpp>
 #include <boost/foreach.hpp>
@@ -48,6 +52,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <boost/range/algorithm_ext/erase.hpp>
 #include <boost/noncopyable.hpp>
 #include <boost/thread.hpp>
+#include <boost/type_traits.hpp>
 
 #include <algorithm>
 #include <limits>
@@ -63,9 +68,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),
@@ -120,10 +125,10 @@ private:
             FixedPointCoordinate lower_left (other.min_lat, other.min_lon);
 
             return (
-                    Contains(upper_left)
-                    || Contains(upper_right)
-                    || Contains(lower_right)
-                    || Contains(lower_left)
+                    Contains(upper_left ) ||
+                    Contains(upper_right) ||
+                    Contains(lower_right) ||
+                    Contains(lower_left )
             );
         }
 
@@ -136,7 +141,7 @@ private:
             double min_dist = std::numeric_limits<double>::max();
             min_dist = std::min(
                     min_dist,
-                    ApproximateDistance(
+                    FixedPointCoordinate::ApproximateDistance(
                             location.lat,
                             location.lon,
                             max_lat,
@@ -145,7 +150,7 @@ private:
             );
             min_dist = std::min(
                     min_dist,
-                    ApproximateDistance(
+                    FixedPointCoordinate::ApproximateDistance(
                             location.lat,
                             location.lon,
                             max_lat,
@@ -154,7 +159,7 @@ private:
             );
             min_dist = std::min(
                     min_dist,
-                    ApproximateDistance(
+                    FixedPointCoordinate::ApproximateDistance(
                             location.lat,
                             location.lon,
                             min_lat,
@@ -163,7 +168,7 @@ private:
             );
             min_dist = std::min(
                     min_dist,
-                    ApproximateDistance(
+                    FixedPointCoordinate::ApproximateDistance(
                             location.lat,
                             location.lon,
                             min_lat,
@@ -184,32 +189,32 @@ private:
             min_max_dist = std::min(
                     min_max_dist,
                     std::max(
-                            ApproximateDistance(location, upper_left ),
-                            ApproximateDistance(location, upper_right)
+                        FixedPointCoordinate::ApproximateDistance(location, upper_left ),
+                        FixedPointCoordinate::ApproximateDistance(location, upper_right)
                     )
             );
 
             min_max_dist = std::min(
                     min_max_dist,
                     std::max(
-                            ApproximateDistance(location, upper_right),
-                            ApproximateDistance(location, lower_right)
+                        FixedPointCoordinate::ApproximateDistance(location, upper_right),
+                        FixedPointCoordinate::ApproximateDistance(location, lower_right)
                     )
             );
 
             min_max_dist = std::min(
                     min_max_dist,
                     std::max(
-                            ApproximateDistance(location, lower_right),
-                            ApproximateDistance(location, lower_left )
+                        FixedPointCoordinate::ApproximateDistance(location, lower_right),
+                        FixedPointCoordinate::ApproximateDistance(location, lower_left )
                     )
             );
 
             min_max_dist = std::min(
                     min_max_dist,
                     std::max(
-                            ApproximateDistance(location, lower_left ),
-                            ApproximateDistance(location, upper_left )
+                        FixedPointCoordinate::ApproximateDistance(location, lower_left ),
+                        FixedPointCoordinate::ApproximateDistance(location, upper_left )
                     )
             );
             return min_max_dist;
@@ -237,6 +242,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,
@@ -259,14 +274,6 @@ 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,
@@ -280,7 +287,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;
@@ -301,6 +308,8 @@ public:
         double time1 = get_timestamp();
         std::vector<WrappedInputElement> input_wrapper_vector(m_element_count);
 
+        HilbertCode get_hilbert_number;
+
         //generate auxiliary vector of hilbert-values
 #pragma omp parallel for schedule(guided)
         for(uint64_t element_counter = 0; element_counter < m_element_count; ++element_counter) {
@@ -310,10 +319,10 @@ public:
             FixedPointCoordinate current_centroid = current_element.Centroid();
             current_centroid.lat = COORDINATE_PRECISION*lat2y(current_centroid.lat/COORDINATE_PRECISION);
 
-            uint64_t current_hilbert_value = HilbertCode::GetHilbertNumberForCoordinate(current_centroid);
+            uint64_t current_hilbert_value = get_hilbert_number(current_centroid);
             input_wrapper_vector[element_counter].m_hilbert_value = current_hilbert_value;
-
         }
+
         //open leaf file
         boost::filesystem::ofstream leaf_node_file(leaf_node_filename, std::ios::binary);
         leaf_node_file.write((char*) &m_element_count, sizeof(uint64_t));
@@ -328,6 +337,7 @@ public:
 
             LeafNode current_leaf;
             TreeNode current_node;
+        //SimpleLogger().Write() << "reading " << tree_size << " tree nodes in " << (sizeof(TreeNode)*tree_size) << " bytes";
             for(uint32_t current_element_index = 0; RTREE_LEAF_NODE_SIZE > current_element_index; ++current_element_index) {
                 if(m_element_count > (processed_objects_count + current_element_index)) {
                     uint32_t index_of_next_object = input_wrapper_vector[processed_objects_count + current_element_index].m_array_index;
@@ -385,6 +395,7 @@ public:
 
         //reverse and renumber tree to have root at index 0
         std::reverse(m_search_tree.begin(), m_search_tree.end());
+
 #pragma omp parallel for schedule(guided)
         for(uint32_t i = 0; i < m_search_tree.size(); ++i) {
             TreeNode & current_tree_node = m_search_tree[i];
@@ -414,11 +425,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,13 +440,11 @@ public:
 
         uint32_t tree_size = 0;
         tree_node_file.read((char*)&tree_size, sizeof(uint32_t));
-        //SimpleLogger().Write() << "reading " << tree_size << " tree nodes in " << (sizeof(TreeNode)*tree_size) << " bytes";
+
         m_search_tree.resize(tree_size);
         tree_node_file.read((char*)&m_search_tree[0], sizeof(TreeNode)*tree_size);
         tree_node_file.close();
-
         //open leaf node file and store thread specific pointer
-        boost::filesystem::path leaf_file(leaf_filename);
         if ( !boost::filesystem::exists( leaf_file ) ) {
             throw OSRMException("mem index file does not exist");
         }
@@ -451,6 +459,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,
@@ -495,12 +531,10 @@ public:
                         }
 
                         double current_ratio = 0.;
-                        double current_perpendicular_distance = ComputePerpendicularDistance(
+                        double current_perpendicular_distance = current_edge.ComputePerpendicularDistance(
                                                                                              input_coordinate,
-                                                                                             FixedPointCoordinate(current_edge.lat1, current_edge.lon1),
-                                                                                             FixedPointCoordinate(current_edge.lat2, current_edge.lon2),
                                                                                              nearest,
-                                                                                             &current_ratio
+                                                                                             current_ratio
                                                                                              );
 
                         if(
@@ -525,7 +559,7 @@ public:
                         } else if(
                                   DoubleEpsilonCompare(current_perpendicular_distance, min_dist) &&
                                   1 == abs(current_edge.id - result_phantom_node.edgeBasedNode )
-                                  && CoordinatesAreEquivalent(
+                                  && EdgesAreEquivalent(
                                                               current_start_coordinate,
                                                               FixedPointCoordinate(
                                                                           current_edge.lat1,
@@ -644,11 +678,8 @@ public:
                         ) {
                             continue;
                         }
-                        if(current_edge.isIgnored()) {
-                            continue;
-                        }
 
-                        double current_minimum_distance = ApproximateDistance(
+                        double current_minimum_distance = FixedPointCoordinate::ApproximateDistance(
                                 input_coordinate.lat,
                                 input_coordinate.lon,
                                 current_edge.lat1,
@@ -662,7 +693,7 @@ public:
                             found_a_nearest_edge = true;
                         }
 
-                        current_minimum_distance = ApproximateDistance(
+                        current_minimum_distance = FixedPointCoordinate::ApproximateDistance(
                                 input_coordinate.lat,
                                 input_coordinate.lon,
                                 current_edge.lat2,
@@ -705,7 +736,6 @@ public:
         return found_a_nearest_edge;
     }
 
-
     bool FindPhantomNodeForCoordinate(
             const FixedPointCoordinate & input_coordinate,
             PhantomNode & result_phantom_node,
@@ -715,7 +745,7 @@ public:
         bool ignore_tiny_components = (zoom_level <= 14);
         DataT nearest_edge;
 
-        uint32_t io_count = 0;
+        // uint32_t io_count = 0;
         uint32_t explored_tree_nodes_count = 0;
         //SimpleLogger().Write() << "searching for coordinate " << input_coordinate;
         double min_dist = std::numeric_limits<double>::max();
@@ -727,15 +757,14 @@ public:
         //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)
-        );
+        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."
         );
 
+        LeafNode current_leaf_node;
         while(!traversal_queue.empty()) {
             const QueryCandidate current_query_node = traversal_queue.top(); traversal_queue.pop();
 
@@ -745,33 +774,29 @@ public:
             if( !prune_downward && !prune_upward ) { //downward pruning
                 TreeNode & current_tree_node = m_search_tree[current_query_node.node_id];
                 if (current_tree_node.child_is_on_disk) {
-                    LeafNode current_leaf_node;
                     LoadLeafFromDisk(current_tree_node.children[0], current_leaf_node);
-                    ++io_count;
+                    // ++io_count;
                     for(uint32_t i = 0; i < current_leaf_node.object_count; ++i) {
                         DataT & current_edge = current_leaf_node.objects[i];
                         if(ignore_tiny_components && current_edge.belongsToTinyComponent) {
                             continue;
                         }
-                        if(current_edge.isIgnored()) {
-                            continue;
-                        }
 
-                       double current_ratio = 0.;
-                       double current_perpendicular_distance = ComputePerpendicularDistance(
-                                input_coordinate,
-                                FixedPointCoordinate(current_edge.lat1, current_edge.lon1),
-                                FixedPointCoordinate(current_edge.lat2, current_edge.lon2),
-                                nearest,
-                                &current_ratio
+                        double current_ratio = 0.;
+                        double current_perpendicular_distance = current_edge.ComputePerpendicularDistance(
+                            input_coordinate,
+                            nearest,
+                            current_ratio
                         );
 
+                        BOOST_ASSERT( 0. <= current_perpendicular_distance );
+
                         if(
-                                current_perpendicular_distance < min_dist
-                                && !DoubleEpsilonCompare(
-                                        current_perpendicular_distance,
-                                        min_dist
-                                )
+                            ( current_perpendicular_distance < min_dist ) &&
+                            !DoubleEpsilonCompare(
+                                current_perpendicular_distance,
+                                min_dist
+                            )
                         ) { //found a new minimum
                             min_dist = current_perpendicular_distance;
                             result_phantom_node.edgeBasedNode = current_edge.id;
@@ -785,10 +810,10 @@ public:
                             current_end_coordinate.lon = current_edge.lon2;
                             nearest_edge = current_edge;
                             found_a_nearest_edge = true;
-                        } else if(
-                                DoubleEpsilonCompare(current_perpendicular_distance, min_dist) &&
-                                1 == abs(current_edge.id - result_phantom_node.edgeBasedNode )
-                        && CoordinatesAreEquivalent(
+                        } else
+                        if( DoubleEpsilonCompare(current_perpendicular_distance, min_dist) &&
+                            ( 1 == abs(current_edge.id - result_phantom_node.edgeBasedNode ) ) &&
+                            EdgesAreEquivalent(
                                 current_start_coordinate,
                                 FixedPointCoordinate(
                                         current_edge.lat1,
@@ -822,10 +847,10 @@ public:
                         if( current_min_max_dist < min_max_dist ) {
                             min_max_dist = current_min_max_dist;
                         }
-                        if (current_min_dist > min_max_dist) {
+                        if( current_min_dist > min_max_dist ) {
                             continue;
                         }
-                        if (current_min_dist > min_dist) { //upward pruning
+                        if( current_min_dist > min_dist ) { //upward pruning
                             continue;
                         }
                         traversal_queue.push(QueryCandidate(child_id, current_min_dist));
@@ -834,17 +859,6 @@ public:
             }
         }
 
-        const double ratio = (found_a_nearest_edge ?
-            std::min(1., ApproximateDistance(current_start_coordinate,
-                result_phantom_node.location)/ApproximateDistance(current_start_coordinate, current_end_coordinate)
-                ) : 0
-            );
-        result_phantom_node.weight1 *= ratio;
-        if(INT_MAX != result_phantom_node.weight2) {
-            result_phantom_node.weight2 *= (1.-ratio);
-        }
-        result_phantom_node.ratio = ratio;
-
         //Hack to fix rounding errors and wandering via nodes.
         if(std::abs(input_coordinate.lon - result_phantom_node.location.lon) == 1) {
             result_phantom_node.location.lon = input_coordinate.lon;
@@ -853,8 +867,30 @@ public:
             result_phantom_node.location.lat = input_coordinate.lat;
         }
 
-        return found_a_nearest_edge;
+        double ratio = 0.;
 
+        if( found_a_nearest_edge) {
+            const double distance_1 = FixedPointCoordinate::ApproximateDistance(
+                current_start_coordinate,
+                result_phantom_node.location
+            );
+
+            const double distance_2 = FixedPointCoordinate::ApproximateDistance(
+                current_start_coordinate,
+                current_end_coordinate
+            );
+
+            ratio = distance_1/distance_2;
+            ratio = std::min(1., ratio);
+        }
+
+        result_phantom_node.weight1 *= ratio;
+        if(INT_MAX != result_phantom_node.weight2) {
+            result_phantom_node.weight2 *= (1.-ratio);
+        }
+        result_phantom_node.ratio = ratio;
+
+        return found_a_nearest_edge;
     }
 
 private:
@@ -879,60 +915,17 @@ private:
         thread_local_rtree_stream->read((char *)&result_node, sizeof(LeafNode));
     }
 
-    inline double ComputePerpendicularDistance(
-            const FixedPointCoordinate& inputPoint,
-            const FixedPointCoordinate& source,
-            const FixedPointCoordinate& target,
-            FixedPointCoordinate& nearest, double *r) const {
-        const double x = inputPoint.lat/COORDINATE_PRECISION;
-        const double y = inputPoint.lon/COORDINATE_PRECISION;
-        const double a = source.lat/COORDINATE_PRECISION;
-        const double b = source.lon/COORDINATE_PRECISION;
-        const double c = target.lat/COORDINATE_PRECISION;
-        const double d = target.lon/COORDINATE_PRECISION;
-        double p,q,mX,nY;
-        if(std::fabs(a-c) > std::numeric_limits<double>::epsilon() ){
-            const double m = (d-b)/(c-a); // slope
-            // Projection of (x,y) on line joining (a,b) and (c,d)
-            p = ((x + (m*y)) + (m*m*a - m*b))/(1. + m*m);
-            q = b + m*(p - a);
-        } else {
-            p = c;
-            q = y;
-        }
-        nY = (d*p - c*q)/(a*d - b*c);
-        mX = (p - nY*a)/c;// These values are actually n/m+n and m/m+n , we need
-        // not calculate the explicit values of m an n as we
-        // are just interested in the ratio
-        if(std::isnan(mX)) {
-            *r = (target == inputPoint) ? 1. : 0.;
-        } else {
-            *r = mX;
-        }
-        if(*r<=0.){
-            nearest.lat = source.lat;
-            nearest.lon = source.lon;
-            return ((b - y)*(b - y) + (a - x)*(a - x));
-//            return std::sqrt(((b - y)*(b - y) + (a - x)*(a - x)));
-        } else if(*r >= 1.){
-            nearest.lat = target.lat;
-            nearest.lon = target.lon;
-            return ((d - y)*(d - y) + (c - x)*(c - x));
-//            return std::sqrt(((d - y)*(d - y) + (c - x)*(c - x)));
-        }
-        // point lies in between
-        nearest.lat = p*COORDINATE_PRECISION;
-        nearest.lon = q*COORDINATE_PRECISION;
-//        return std::sqrt((p-x)*(p-x) + (q-y)*(q-y));
-        return (p-x)*(p-x) + (q-y)*(q-y);
-    }
-
-    inline bool CoordinatesAreEquivalent(const FixedPointCoordinate & a, const FixedPointCoordinate & b, const FixedPointCoordinate & c, const FixedPointCoordinate & d) const {
+    inline bool EdgesAreEquivalent(
+        const FixedPointCoordinate & a,
+        const FixedPointCoordinate & b,
+        const FixedPointCoordinate & c,
+        const FixedPointCoordinate & d
+    ) const {
         return (a == b && c == d) || (a == c && b == d) || (a == d && b == c);
     }
 
     inline bool DoubleEpsilonCompare(const double d1, const double d2) const {
-        return (std::fabs(d1 - d2) < std::numeric_limits<double>::epsilon() );
+        return (std::abs(d1 - d2) < std::numeric_limits<double>::epsilon() );
     }
 
 };

Descriptors/BaseDescriptor.h

@@ -28,36 +28,41 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef BASE_DESCRIPTOR_H_
 #define BASE_DESCRIPTOR_H_
 
-#include "../DataStructures/HashTable.h"
 #include "../DataStructures/PhantomNodes.h"
 #include "../DataStructures/RawRouteData.h"
-#include "../DataStructures/SearchEngine.h"
-#include "../Server/BasicDatastructures.h"
-#include "../Util/StringUtil.h"
 #include "../typedefs.h"
 
-#include <cassert>
-#include <cmath>
-#include <cstdio>
+#include <osrm/Reply.h>
 
 #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(
+        const RawRouteData & rawRoute,
+        const PhantomNodes & phantomNodes,
+        DataFacadeT * facade,
+        http::Reply & reply
+    ) = 0;
+    virtual void SetConfig(const DescriptorConfig & config) = 0;
 };
 
 #endif /* BASE_DESCRIPTOR_H_ */

Descriptors/DescriptionFactory.cpp

@@ -43,178 +43,101 @@ double DescriptionFactory::GetBearing(
     const FixedPointCoordinate & A,
     const FixedPointCoordinate & B
 ) const {
-    double deltaLong = DegreeToRadian(B.lon/COORDINATE_PRECISION - A.lon/COORDINATE_PRECISION);
+    double delta_long = 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(delta_long) * cos(lat2);
+    const double x = cos(lat1) * sin(lat2) - sin(lat1) * cos(lat2) * cos(delta_long);
     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 & start) {
+    start_phantom = start;
+    AppendSegment(
+        start.location,
+        PathData(0, start.nodeBasedEdgeNameID, 10, start.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 & target) {
+    target_phantom = target;
+    pathDescription.push_back(
+        SegmentInformation(
+            target.location,
+            target.nodeBasedEdgeNameID,
+            0,
+            target.weight1,
+            0,
+            true
+        )
+    );
 }
 
-void DescriptionFactory::AppendSegment(const FixedPointCoordinate & coordinate, const _PathData & data ) {
-    if(1 == pathDescription.size() && pathDescription.back().location == coordinate) {
-        pathDescription.back().nameID = data.nameID;
+void DescriptionFactory::AppendSegment(
+    const FixedPointCoordinate & coordinate,
+    const PathData & data
+) {
+    if(
+        ( 1 == pathDescription.size())                  &&
+        ( pathDescription.back().location == coordinate)
+    ) {
+        pathDescription.back().name_id = data.name_id;
     } else {
-        pathDescription.push_back(SegmentInformation(coordinate, data.nameID, 0, data.durationOfSegment, data.turnInstruction) );
+        pathDescription.push_back(
+            SegmentInformation(
+                coordinate,
+                data.name_id,
+                data.durationOfSegment,
+                0,
+                data.turnInstruction
+            )
+        );
     }
 }
 
-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(std::numeric_limits<double>::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(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;
-            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::BuildRouteSummary(
+    const double distance,
+    const unsigned time
+) {
+    summary.startName = start_phantom.nodeBasedEdgeNameID;
+    summary.destName = target_phantom.nodeBasedEdgeNameID;
     summary.BuildDurationAndLengthStrings(distance, time);
 }

Descriptors/DescriptionFactory.h

@@ -30,13 +30,15 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #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 <osrm/Coordinate.h>
+
 #include <limits>
 #include <vector>
 
@@ -44,24 +46,33 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  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;
-            intToString(travelTime, durationString);
+            int travel_time = time/10;
+            intToString(std::max(travel_time, 1), durationString);
         }
     } summary;
 
@@ -72,14 +83,131 @@ public:
     DescriptionFactory();
     virtual ~DescriptionFactory();
     double GetBearing(const FixedPointCoordinate& C, const FixedPointCoordinate& B) const;
-    void AppendEncodedPolylineString(std::string &output);
-    void AppendUnencodedPolylineString(std::string &output);
-    void AppendSegment(const FixedPointCoordinate & coordinate, const _PathData & data);
+    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;
+        }
+
+        /** starts at index 1 */
+        pathDescription[0].length = 0;
+        for(unsigned i = 1; i < pathDescription.size(); ++i) {
+            pathDescription[i].length = FixedPointCoordinate::ApproximateEuclideanDistance(pathDescription[i-1].location, pathDescription[i].location);
+        }
+
+        // std::string string0 = facade->GetEscapedNameForNameID(pathDescription[0].name_id);
+        // 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].name_id);
+    //        if(TurnInstructionsClass::GoStraight == pathDescription[i].turn_instruction) {
+    //            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].name_id = pathDescription[i].name_id;
+    //                pathDescription[i].turn_instruction = 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].name_id = pathDescription[i-1].name_id;
+    //                pathDescription[i].turn_instruction = TurnInstructionsClass::NoTurn;
+    //            }
+    //        }
+    //        if (TurnInstructionsClass::NoTurn != pathDescription[i].turn_instruction) {
+    //            lastTurn = i;
+    //        }
+    //        string0 = string1;
+    //    }
+
+        double lengthOfSegment = 0;
+        unsigned durationOfSegment = 0;
+        unsigned indexOfSegmentBegin = 0;
+
+        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].turn_instruction) {
+                BOOST_ASSERT(pathDescription[i].necessary);
+                lengthOfSegment = 0;
+                durationOfSegment = 0;
+                indexOfSegmentBegin = i;
+            }
+        }
+
+        //Post-processing to remove empty or nearly empty path segments
+        if(std::numeric_limits<double>::epsilon() > pathDescription.back().length) {
+            if(pathDescription.size() > 2){
+                pathDescription.pop_back();
+                pathDescription.back().necessary = true;
+                pathDescription.back().turn_instruction = TurnInstructions.NoTurn;
+                target_phantom.nodeBasedEdgeNameID = (pathDescription.end()-2)->name_id;
+            }
+        } else {
+            pathDescription[indexOfSegmentBegin].duration *= (1.-target_phantom.ratio);
+        }
+        if(std::numeric_limits<double>::epsilon() > pathDescription[0].length) {
+            if(pathDescription.size() > 2) {
+                pathDescription.erase(pathDescription.begin());
+                pathDescription[0].turn_instruction = TurnInstructions.HeadOn;
+                pathDescription[0].necessary = true;
+                start_phantom.nodeBasedEdgeNameID = pathDescription[0].name_id;
+            }
+        } 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*10;
+            }
+        }
+        return;
+    }
 };
 
 #endif /* DESCRIPTIONFACTORY_H_ */

Descriptors/GPXDescriptor.h

@@ -32,42 +32,75 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #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(
+        const RawRouteData &raw_route,
+        const PhantomNodes &phantom_node_list,
+        DataFacadeT * facade,
+        http::Reply & reply
+    ) {
+        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 =  (raw_route.lengthOfShortestPath != INT_MAX) &&
+                            (raw_route.unpacked_path_segments[0].size());
+        if( found_route ) {
+            FixedPointCoordinate::convertInternalLatLonToString(
+                phantom_node_list.startPhantom.location.lat,
+                tmp
+            );
+            reply.content.push_back("<rtept lat=\"" + tmp + "\" ");
+            FixedPointCoordinate::convertInternalLatLonToString(
+                phantom_node_list.startPhantom.location.lon,
+                tmp
+            );
+            reply.content.push_back("lon=\"" + tmp + "\"></rtept>");
 
-            BOOST_FOREACH(const _PathData & pathData, rawRoute.computedShortestPath) {
-                sEngine.GetCoordinatesForNodeID(pathData.node, current);
+            for(unsigned i=0; i < raw_route.unpacked_path_segments.size(); ++i){
+                BOOST_FOREACH(
+                    const PathData & pathData,
+                    raw_route.unpacked_path_segments[i]
+                ) {
+                    current = facade->GetCoordinateOfNode(pathData.node);
 
-                convertInternalLatLonToString(current.lat, tmp);
-                reply.content += "<rtept lat=\"" + tmp + "\" ";
-                convertInternalLatLonToString(current.lon, tmp);
-                reply.content += "lon=\"" + tmp + "\"></rtept>";
+                    FixedPointCoordinate::convertInternalLatLonToString(current.lat, tmp);
+                    reply.content.push_back("<rtept lat=\"" + tmp + "\" ");
+                    FixedPointCoordinate::convertInternalLatLonToString(current.lon, tmp);
+                    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>";
+            // Add the via point or the end coordinate
+            FixedPointCoordinate::convertInternalLatLonToString(
+                phantom_node_list.targetPhantom.location.lat,
+                tmp
+            );
+            reply.content.push_back("<rtept lat=\"" + tmp + "\" ");
+            FixedPointCoordinate::convertInternalLatLonToString(
+                phantom_node_list.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

@@ -41,32 +41,35 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <algorithm>
 
-class JSONDescriptor : public BaseDescriptor{
+template<class DataFacadeT>
+class JSONDescriptor : public BaseDescriptor<DataFacadeT> {
 private:
-    _DescriptorConfig config;
-    DescriptionFactory descriptionFactory;
-    DescriptionFactory alternateDescriptionFactory;
+    DataFacadeT * facade;
+    DescriptorConfig config;
+    DescriptionFactory description_factory;
+    DescriptionFactory alternate_descriptionFactory;
     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;
+    std::vector<unsigned> shortest_leg_end_indices, alternative_leg_end_indices;
 
     struct RouteNames {
         std::string shortestPathName1;
@@ -76,207 +79,295 @@ private:
     };
 
 public:
-    JSONDescriptor() : numberOfEnteredRestrictedAreas(0) {}
-    void SetConfig(const _DescriptorConfig & c) { config = c; }
+    JSONDescriptor() :
+        facade(NULL),
+        entered_restricted_area_count(0)
+    {
+        shortest_leg_end_indices.push_back(0);
+        alternative_leg_end_indices.push_back(0);
+    }
 
-    void Run(http::Reply & reply, const RawRouteData &rawRoute, PhantomNodes &phantomNodes, SearchEngine &sEngine) {
+    void SetConfig(const DescriptorConfig & c) { config = c; }
 
-        WriteHeaderToOutput(reply.content);
+    int DescribeLeg(
+        const std::vector<PathData> & route_leg,
+        const PhantomNodes & leg_phantoms
+    ) {
+        int added_element_count = 0;
+        //Get all the coordinates for the computed route
+        FixedPointCoordinate current_coordinate;
+        BOOST_FOREACH(const PathData & path_data, route_leg) {
+            current_coordinate = facade->GetCoordinateOfNode(path_data.node);
+            description_factory.AppendSegment(current_coordinate, path_data );
+            ++added_element_count;
+        }
+        // description_factory.SetEndSegment( leg_phantoms.targetPhantom );
+        ++added_element_count;
+        BOOST_ASSERT( (int)(route_leg.size() + 1) == added_element_count );
+        return added_element_count;
+    }
 
-        if(rawRoute.lengthOfShortestPath != INT_MAX) {
-            descriptionFactory.SetStartSegment(phantomNodes.startPhantom);
-            reply.content += "0,"
-                    "\"status_message\": \"Found route between points\",";
+    void Run(
+        const RawRouteData & raw_route,
+        const PhantomNodes & phantom_nodes,
+        // TODO: move facade initalization to c'tor
+        DataFacadeT * f,
+        http::Reply & reply
+    ) {
+        facade = f;
+        reply.content.push_back(
+            "{\"status\":"
+        );
 
-            //Get all the coordinates for the computed route
-            BOOST_FOREACH(const _PathData & pathData, rawRoute.computedShortestPath) {
-                sEngine.GetCoordinatesForNodeID(pathData.node, current);
-                descriptionFactory.AppendSegment(current, pathData );
-            }
-            descriptionFactory.SetEndSegment(phantomNodes.targetPhantom);
-        } else {
+        if(INT_MAX == raw_route.lengthOfShortestPath) {
             //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\"}"
+            );
+            return;
         }
 
-        descriptionFactory.Run(sEngine, config.z);
-        reply.content += "\"route_geometry\": ";
+        description_factory.SetStartSegment(phantom_nodes.startPhantom);
+        reply.content.push_back("0,"
+                "\"status_message\": \"Found route between points\",");
+
+        BOOST_ASSERT( raw_route.unpacked_path_segments.size() == raw_route.segmentEndCoordinates.size() );
+        for( unsigned i = 0; i < raw_route.unpacked_path_segments.size(); ++i ) {
+            const int added_segments = DescribeLeg(
+                raw_route.unpacked_path_segments[i],
+                raw_route.segmentEndCoordinates[i]
+            );
+            BOOST_ASSERT( 0 < added_segments );
+            shortest_leg_end_indices.push_back(
+                added_segments + shortest_leg_end_indices.back()
+            );
+        }
+        description_factory.SetEndSegment(phantom_nodes.targetPhantom);
+        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\": [");
         if(config.instructions) {
-            BuildTextualDescription(descriptionFactory, reply, rawRoute.lengthOfShortestPath, sEngine, shortestSegments);
-        } else {
-            BOOST_FOREACH(const SegmentInformation & segment, descriptionFactory.pathDescription) {
-                TurnInstruction currentInstruction = segment.turnInstruction & TurnInstructions.InverseAccessRestrictionFlag;
-                numberOfEnteredRestrictedAreas += (currentInstruction != segment.turnInstruction);
-            }
+            BuildTextualDescription(
+                description_factory,
+                reply,
+                raw_route.lengthOfShortestPath,
+                facade,
+                shortest_path_segments
+            );
         }
-        reply.content += "],";
-        descriptionFactory.BuildRouteSummary(descriptionFactory.entireLength, rawRoute.lengthOfShortestPath - ( numberOfEnteredRestrictedAreas*TurnInstructions.AccessRestrictionPenalty));
+        reply.content.push_back("],");
+        description_factory.BuildRouteSummary(
+            description_factory.entireLength,
+            raw_route.lengthOfShortestPath
+        );
 
-        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.lengthOfAlternativePath != INT_MAX) {
+            alternate_descriptionFactory.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.unpacked_alternative) {
+                current = facade->GetCoordinateOfNode(path_data.node);
+                alternate_descriptionFactory.AppendSegment(current, path_data );
             }
-            alternateDescriptionFactory.SetEndSegment(phantomNodes.targetPhantom);
+            alternate_descriptionFactory.SetEndSegment(phantom_nodes.targetPhantom);
         }
-        alternateDescriptionFactory.Run(sEngine, config.z);
+        alternate_descriptionFactory.Run(facade, config.zoom_level);
 
-        //give an array of alternative routes
-        reply.content += "\"alternative_geometries\": [";
-        if(config.geometry && INT_MAX != rawRoute.lengthOfAlternativePath) {
+        // //give an array of alternative routes
+        reply.content.push_back("\"alternative_geometries\": [");
+        if(config.geometry && INT_MAX != raw_route.lengthOfAlternativePath) {
             //Generate the linestrings for each alternative
-            alternateDescriptionFactory.AppendEncodedPolylineString(reply.content, config.encodeGeometry);
+            alternate_descriptionFactory.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\":[");
+        if(INT_MAX != raw_route.lengthOfAlternativePath) {
+            reply.content.push_back("[");
             //Generate instructions for each alternative
             if(config.instructions) {
-                BuildTextualDescription(alternateDescriptionFactory, reply, rawRoute.lengthOfAlternativePath, sEngine, alternativeSegments);
-            } else {
-                BOOST_FOREACH(const SegmentInformation & segment, alternateDescriptionFactory.pathDescription) {
-                	TurnInstruction currentInstruction = segment.turnInstruction & TurnInstructions.InverseAccessRestrictionFlag;
-                    numberOfEnteredRestrictedAreas += (currentInstruction != segment.turnInstruction);
-                }
+                BuildTextualDescription(
+                    alternate_descriptionFactory,
+                    reply,
+                    raw_route.lengthOfAlternativePath,
+                    facade,
+                    alternative_path_segments
+                );
             }
-            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.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 += "}";
+            alternate_descriptionFactory.BuildRouteSummary(
+                alternate_descriptionFactory.entireLength,
+                raw_route.lengthOfAlternativePath
+            );
+            reply.content.push_back("{");
+            reply.content.push_back("\"total_distance\":");
+            reply.content.push_back(
+                alternate_descriptionFactory.summary.lengthString
+            );
+            reply.content.push_back(","
+                    "\"total_time\":");
+            reply.content.push_back(
+                alternate_descriptionFactory.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
+        // //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\":[";
-        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);
-                else
-                    convertInternalReversedCoordinateToString(rawRoute.rawViaNodeCoordinates[i], tmp);
+        reply.content.push_back("\"via_points\":[");
 
-                reply.content += tmp;
-                reply.content += "],";
-            }
-            reply.content += "[";
-            if(rawRoute.segmentEndCoordinates.back().startPhantom.location.isSet())
-                convertInternalReversedCoordinateToString(rawRoute.segmentEndCoordinates.back().targetPhantom.location, tmp);
-            else
-                convertInternalReversedCoordinateToString(rawRoute.rawViaNodeCoordinates.back(), tmp);
-            reply.content += tmp;
-            reply.content += "]";
+        BOOST_ASSERT( !raw_route.segmentEndCoordinates.empty() );
+
+        std::string tmp;
+        FixedPointCoordinate::convertInternalReversedCoordinateToString(
+            raw_route.segmentEndCoordinates.front().startPhantom.location,
+            tmp
+        );
+        reply.content.push_back("[");
+        reply.content.push_back(tmp);
+        reply.content.push_back("]");
+
+        BOOST_FOREACH(const PhantomNodes & nodes, raw_route.segmentEndCoordinates) {
+            tmp.clear();
+            FixedPointCoordinate::convertInternalReversedCoordinateToString(
+                nodes.targetPhantom.location,
+                tmp
+            );
+            reply.content.push_back(",[");
+            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("\"via_indices\":[");
+        BOOST_FOREACH(const unsigned index, shortest_leg_end_indices) {
+            tmp.clear();
+            intToString(index, tmp);
+            reply.content.push_back(tmp);
+            if( index != shortest_leg_end_indices.back() ) {
+                reply.content.push_back(",");
+            }
+        }
+        reply.content.push_back("],\"alternative_indices\":[");
+        if(INT_MAX != raw_route.lengthOfAlternativePath) {
+            reply.content.push_back("0,");
+            tmp.clear();
+            intToString(alternate_descriptionFactory.pathDescription.size(), tmp);
+            reply.content.push_back(tmp);
+        }
+
+        reply.content.push_back("],");
+        reply.content.push_back("\"hint_data\": {");
+        reply.content.push_back("\"checksum\":");
+        intToString(raw_route.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.segmentEndCoordinates.size(); ++i) {
+            reply.content.push_back("\"");
+            EncodeObjectToBase64(raw_route.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.segmentEndCoordinates.back().targetPhantom, hint);
+        reply.content.push_back("\"");
+        reply.content.push_back(hint);
+        reply.content.push_back("\"]");
+        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 ) {
@@ -284,11 +375,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 ) {
@@ -301,104 +392,119 @@ 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 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.turn_instruction & TurnInstructions.InverseAccessRestrictionFlag;
+            entered_restricted_area_count += (current_instruction != segment.turn_instruction);
+            if(TurnInstructions.TurnIsNecessary( current_instruction) ) {
+                if(TurnInstructions.EnterRoundAbout == current_instruction) {
+                    roundAbout.name_id = segment.name_id;
+                    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.name_id));
+                    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 += "\",";
-                    intToString(round(segment.bearing), tmpBearing);
-                    reply.content += tmpBearing;
-                    reply.content += "]";
+                    reply.content.push_back(tmpLength);
+                    reply.content.push_back("m\",\"");
+                    double bearing_value = round(segment.bearing/10.);
+                    reply.content.push_back(Azimuth::Get(bearing_value));
+                    reply.content.push_back("\",");
+                    intToString(bearing_value, tmpBearing);
+                    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.name_id,
+                            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("]");
         }
     }
-
 };
+
 #endif /* JSON_DESCRIPTOR_H_ */

Extractor/BaseParser.cpp

@@ -26,22 +26,37 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 #include "BaseParser.h"
+#include "ExtractionWay.h"
+#include "ScriptingEnvironment.h"
 
-BaseParser::BaseParser(ExtractorCallbacks* ec, ScriptingEnvironment& se) :
-extractor_callbacks(ec), scriptingEnvironment(se), luaState(NULL), use_turn_restrictions(true) {
-    luaState = se.getLuaStateForThreadID(0);
+#include "../DataStructures/ImportNode.h"
+#include "../Util/LuaUtil.h"
+#include "../Util/OSRMException.h"
+#include "../Util/SimpleLogger.h"
+
+#include <boost/algorithm/string.hpp>
+#include <boost/algorithm/string/regex.hpp>
+#include <boost/foreach.hpp>
+#include <boost/regex.hpp>
+
+BaseParser::BaseParser(
+    ExtractorCallbacks   * extractor_callbacks,
+    ScriptingEnvironment & scripting_environment
+) : extractor_callbacks(extractor_callbacks),
+    lua_state(scripting_environment.getLuaStateForThreadID(0)),
+    scripting_environment(scripting_environment),
+    use_turn_restrictions(true)
+{
     ReadUseRestrictionsSetting();
     ReadRestrictionExceptions();
 }
 
 void BaseParser::ReadUseRestrictionsSetting() {
-    if( 0 != luaL_dostring( luaState, "return use_turn_restrictions\n") ) {
-        throw OSRMException(
-            /*lua_tostring( luaState, -1 ) + */"ERROR occured in scripting block"
-        );
+    if( 0 != luaL_dostring( lua_state, "return use_turn_restrictions\n") ) {
+        throw OSRMException("ERROR occured in scripting block");
     }
-    if( lua_isboolean( luaState, -1) ) {
-        use_turn_restrictions = lua_toboolean(luaState, -1);
+    if( lua_isboolean( lua_state, -1) ) {
+        use_turn_restrictions = lua_toboolean(lua_state, -1);
     }
     if( use_turn_restrictions ) {
         SimpleLogger().Write() << "Using turn restrictions";
@@ -51,16 +66,18 @@ void BaseParser::ReadUseRestrictionsSetting() {
 }
 
 void BaseParser::ReadRestrictionExceptions() {
-    if(lua_function_exists(luaState, "get_exceptions" )) {
+    if(lua_function_exists(lua_state, "get_exceptions" )) {
         //get list of turn restriction exceptions
         luabind::call_function<void>(
-            luaState,
+            lua_state,
             "get_exceptions",
             boost::ref(restriction_exceptions)
         );
-        SimpleLogger().Write() << "Found " << restriction_exceptions.size() << " exceptions to turn restriction";
+        const unsigned exception_count = restriction_exceptions.size();
+        SimpleLogger().Write() <<
+            "Found " << exception_count << " exceptions to turn restrictions:";
         BOOST_FOREACH(const std::string & str, restriction_exceptions) {
-            SimpleLogger().Write() << "   " << str;
+            SimpleLogger().Write() << "  " << str;
         }
     } else {
         SimpleLogger().Write() << "Found no exceptions to turn restrictions";
@@ -74,20 +91,32 @@ void BaseParser::report_errors(lua_State *L, const int status) const {
     }
 }
 
-void BaseParser::ParseNodeInLua(ImportNode& n, lua_State* localLuaState) {
-    luabind::call_function<void>( localLuaState, "node_function", boost::ref(n) );
+void BaseParser::ParseNodeInLua(ImportNode& n, lua_State* local_lua_state) {
+    luabind::call_function<void>(
+        local_lua_state,
+        "node_function",
+        boost::ref(n)
+    );
 }
 
-void BaseParser::ParseWayInLua(ExtractionWay& w, lua_State* localLuaState) {
-    luabind::call_function<void>( localLuaState, "way_function", boost::ref(w) );
+void BaseParser::ParseWayInLua(ExtractionWay& w, lua_State* local_lua_state) {
+    luabind::call_function<void>(
+        local_lua_state,
+        "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]
+    // a) the list of modes in the except tag of the restriction
+    //    (except_tag_string), eg: except=bus;bicycle
+    // b) the lua profile defines a hierachy of modes,
+    //    eg: [access, vehicle, bicycle]
 
-    if( "" == except_tag_string ) {
+    if( except_tag_string.empty() ) {
         return false;
     }
 
@@ -95,8 +124,14 @@ bool BaseParser::ShouldIgnoreRestriction(const std::string & except_tag_string)
     //only a few exceptions are actually defined.
     std::vector<std::string> exceptions;
     boost::algorithm::split_regex(exceptions, except_tag_string, boost::regex("[;][ ]*"));
-    BOOST_FOREACH(std::string& str, exceptions) {
-        if( restriction_exceptions.end() != std::find(restriction_exceptions.begin(), restriction_exceptions.end(), str) ) {
+    BOOST_FOREACH(std::string& current_string, exceptions) {
+        std::vector<std::string>::const_iterator string_iterator;
+        string_iterator = std::find(
+            restriction_exceptions.begin(),
+            restriction_exceptions.end(),
+            current_string
+        );
+        if( restriction_exceptions.end() != string_iterator ) {
             return true;
         }
     }

Extractor/BaseParser.h

@@ -28,11 +28,6 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef BASEPARSER_H_
 #define BASEPARSER_H_
 
-#include "ExtractorCallbacks.h"
-#include "ScriptingEnvironment.h"
-#include "../Util/OSRMException.h"
-#include "../Util/SimpleLogger.h"
-
 extern "C" {
     #include <lua.h>
     #include <lauxlib.h>
@@ -40,29 +35,40 @@ extern "C" {
 }
 
 #include <boost/noncopyable.hpp>
+#include <string>
+#include <vector>
+
+class ExtractorCallbacks;
+class ScriptingEnvironment;
+struct ExtractionWay;
+struct ImportNode;
 
 class BaseParser : boost::noncopyable {
 public:
-    BaseParser(ExtractorCallbacks* ec, ScriptingEnvironment& se);
+    BaseParser(
+        ExtractorCallbacks * extractor_callbacks,
+        ScriptingEnvironment & scripting_environment
+    );
     virtual ~BaseParser() {}
     virtual bool ReadHeader() = 0;
     virtual bool Parse() = 0;
 
-    virtual void ParseNodeInLua(ImportNode& n, lua_State* luaStateForThread);
-    virtual void ParseWayInLua(ExtractionWay& n, lua_State* luaStateForThread);
-    virtual void report_errors(lua_State *L, const int status) const;
+    virtual void ParseNodeInLua(ImportNode & n, lua_State* thread_lua_state);
+    virtual void ParseWayInLua(ExtractionWay & n, lua_State* thread_lua_state);
+    virtual void report_errors(lua_State * lua_state, const int status) const;
 
 protected:
     virtual void ReadUseRestrictionsSetting();
     virtual void ReadRestrictionExceptions();
-    virtual bool ShouldIgnoreRestriction(const std::string& except_tag_string) const;
+    virtual bool ShouldIgnoreRestriction(
+        const std::string & except_tag_string
+    ) const;
 
-    ExtractorCallbacks* extractor_callbacks;
-    ScriptingEnvironment& scriptingEnvironment;
-    lua_State* luaState;
+    ExtractorCallbacks     * extractor_callbacks;
+    lua_State              * lua_state;
+    ScriptingEnvironment   & scripting_environment;
     std::vector<std::string> restriction_exceptions;
     bool use_turn_restrictions;
-
 };
 
 #endif /* BASEPARSER_H_ */

Extractor/ExtractionContainers.cpp

@@ -26,267 +26,382 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 #include "ExtractionContainers.h"
+#include "ExtractionWay.h"
+#include "../Util/SimpleLogger.h"
+#include "../Util/TimingUtil.h"
 
-void ExtractionContainers::PrepareData(const std::string & output_file_name, const std::string restrictionsFileName, const unsigned amountOfRAM) {
+#include <boost/assert.hpp>
+#include <boost/foreach.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/filesystem/fstream.hpp>
+
+#include <stxxl/sort>
+
+ExtractionContainers::ExtractionContainers() {
+    //Check if stxxl can be instantiated
+    stxxl::vector<unsigned> dummy_vector;
+    name_list.push_back("");
+}
+
+ExtractionContainers::~ExtractionContainers() {
+    used_node_id_list.clear();
+    all_nodes_list.clear();
+    all_edges_list.clear();
+    name_list.clear();
+    restrictions_list.clear();
+    way_start_end_id_list.clear();
+}
+
+void ExtractionContainers::PrepareData(
+    const std::string & output_file_name,
+    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
+                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));
+        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(
-            restrictionsIT = restrictionsVector.begin();
-            restrictionsIT != restrictionsVector.end();
-            ++restrictionsIT
+            restrictions_iterator = restrictions_list.begin();
+            restrictions_iterator != restrictions_list.end();
+            ++restrictions_iterator
         ) {
             if(
-                UINT_MAX != restrictionsIT->restriction.fromNode &&
-                UINT_MAX != restrictionsIT->restriction.toNode
+                UINT_MAX != restrictions_iterator->restriction.fromNode &&
+                UINT_MAX != restrictions_iterator->restriction.toNode
             ) {
-                restrictionsOutstream.write((char *)&(restrictionsIT->restriction), sizeof(TurnRestriction));
+                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 = FixedPointCoordinate::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();
 
@@ -297,32 +412,46 @@ void ExtractionContainers::PrepareData(const std::string & output_file_name, con
             std::ios::binary
         );
 
-        const unsigned number_of_ways = name_list.size()+1;
-        name_file_stream.write((char *)&(number_of_ways), sizeof(unsigned));
+        //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 & str, name_list) {
+        BOOST_FOREACH(const std::string & temp_string, name_list) {
             name_file_stream.write(
                 (char *)&(name_lengths_prefix_sum),
                 sizeof(unsigned)
             );
-            name_lengths_prefix_sum += strlen(str.c_str());
+            name_lengths_prefix_sum += temp_string.length();
         }
+        //duplicate on purpose!
         name_file_stream.write(
             (char *)&(name_lengths_prefix_sum),
             sizeof(unsigned)
         );
-        //duplicate on purpose!
-        name_file_stream.write((char *)&(name_lengths_prefix_sum), sizeof(unsigned));
-        BOOST_FOREACH(const std::string & str, name_list) {
-            const unsigned lengthOfRawString = strlen(str.c_str());
-            name_file_stream.write(str.c_str(), lengthOfRawString);
+
+        //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);
         }
 
         name_file_stream.close();
         std::cout << "ok, after " << get_timestamp() - time << "s" << std::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;

Extractor/ExtractionContainers.h

@@ -28,53 +28,37 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef EXTRACTIONCONTAINERS_H_
 #define EXTRACTIONCONTAINERS_H_
 
+#include "InternalExtractorEdge.h"
 #include "ExtractorStructs.h"
-#include "../Util/SimpleLogger.h"
-#include "../Util/TimingUtil.h"
+#include "../DataStructures/Restriction.h"
 #include "../Util/UUID.h"
 
-#include <boost/foreach.hpp>
-#include <boost/filesystem.hpp>
-#include <boost/filesystem/fstream.hpp>
-#include <stxxl.h>
+#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                               usedNodeIDs;
-    STXXLNodeVector                                 allNodes;
-    STXXLEdgeVector                                 allEdges;
+    STXXLNodeIDVector                               used_node_id_list;
+    STXXLNodeVector                                 all_nodes_list;
+    STXXLEdgeVector                                 all_edges_list;
     STXXLStringVector                               name_list;
-    STXXLRestrictionsVector                         restrictionsVector;
-    STXXLWayIDStartEndVector                        wayStartEndVector;
+    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;
-        name_list.push_back("");
-    }
+    ExtractionContainers();
 
-    virtual ~ExtractionContainers() {
-        usedNodeIDs.clear();
-        allNodes.clear();
-        allEdges.clear();
-        name_list.clear();
-        restrictionsVector.clear();
-        wayStartEndVector.clear();
-    }
+    virtual ~ExtractionContainers();
 
     void PrepareData(
         const std::string & output_file_name,
-        const std::string restrictionsFileName,
-        const unsigned amountOfRAM
+        const std::string & restrictions_file_name
     );
 };
 

Extractor/ExtractionWay.h

@@ -0,0 +1,78 @@
+/*
+
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef EXTRACTION_WAY_H
+#define EXTRACTION_WAY_H
+
+#include "../DataStructures/HashTable.h"
+#include "../typedefs.h"
+
+#include <string>
+#include <vector>
+
+struct ExtractionWay {
+    ExtractionWay() {
+        Clear();
+    }
+
+    inline void Clear(){
+        id = UINT_MAX;
+        nameID = UINT_MAX;
+        path.clear();
+        keyVals.clear();
+        direction = ExtractionWay::notSure;
+        speed = -1;
+        backward_speed = -1;
+        duration = -1;
+        type = -1;
+        access = true;
+        roundabout = false;
+        isAccessRestricted = false;
+        ignoreInGrid = false;
+    }
+
+    enum Directions {
+        notSure = 0, oneway, bidirectional, opposite
+    };
+    unsigned id;
+    unsigned nameID;
+    double speed;
+    double backward_speed;
+    double duration;
+    Directions direction;
+    std::string name;
+    short type;
+    bool access;
+    bool roundabout;
+    bool isAccessRestricted;
+    bool ignoreInGrid;
+    std::vector< NodeID > path;
+    HashTable<std::string, std::string> keyVals;
+};
+
+
+#endif //EXTRACTION_WAY_H

Extractor/ExtractorCallbacks.cpp

@@ -25,25 +25,50 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 */
 
+#include "ExtractionContainers.h"
+#include "ExtractionHelperFunctions.h"
+#include "ExtractionWay.h"
 #include "ExtractorCallbacks.h"
 
-ExtractorCallbacks::ExtractorCallbacks() {externalMemory = NULL; stringMap = NULL; }
-ExtractorCallbacks::ExtractorCallbacks(ExtractionContainers * ext, StringMap * strMap) {
-    externalMemory = ext;
-    stringMap = strMap;
-}
+#include "../DataStructures/Restriction.h"
+#include "../Util/SimpleLogger.h"
+
+#include <osrm/Coordinate.h>
+
+#include <cfloat>
+
+#include <boost/algorithm/string.hpp>
+#include <boost/algorithm/string/regex.hpp>
+#include <boost/regex.hpp>
+
+#include <string>
+#include <vector>
+
+ExtractorCallbacks::ExtractorCallbacks()
+ :
+    stringMap(NULL),
+    externalMemory(NULL)
+{ }
+
+ExtractorCallbacks::ExtractorCallbacks(
+    ExtractionContainers * ext,
+    StringMap * strMap
+) :
+    stringMap(strMap),
+    externalMemory(ext)
+{ }
 
 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;
 }
 
@@ -62,14 +87,14 @@ void ExtractorCallbacks::wayFunction(ExtractionWay &parsed_way) {
             parsed_way.speed = parsed_way.duration/(parsed_way.path.size()-1);
         }
 
-        if(std::numeric_limits<double>::epsilon() >= fabs(-1. - parsed_way.speed)){
+        if(std::numeric_limits<double>::epsilon() >= std::abs(-1. - parsed_way.speed)){
             SimpleLogger().Write(logDEBUG) <<
                 "found way with bogus speed, id: " << parsed_way.id;
             return;
         }
 
         //Get the unique identifier for the street name
-        const StringMap::const_iterator string_map_iterator = stringMap->find(parsed_way.name);
+        const StringMap::const_iterator & string_map_iterator = stringMap->find(parsed_way.name);
         if(stringMap->end() == string_map_iterator) {
             parsed_way.nameID = externalMemory->name_list.size();
             externalMemory->name_list.push_back(parsed_way.name);
@@ -86,7 +111,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,
@@ -99,17 +124,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,
@@ -124,7 +149,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

@@ -28,36 +28,37 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef EXTRACTORCALLBACKS_H_
 #define EXTRACTORCALLBACKS_H_
 
-#include "ExtractionContainers.h"
-#include "ExtractionHelperFunctions.h"
 #include "ExtractorStructs.h"
+#include "../typedefs.h"
 
-#include "../DataStructures/Coordinate.h"
-
-#include <cfloat>
-
-#include <boost/algorithm/string.hpp>
-#include <boost/algorithm/string/regex.hpp>
-#include <boost/regex.hpp>
-
+#include <boost/unordered_map.hpp>
 #include <string>
-#include <vector>
+
+class ExtractionContainers;
+struct ExtractionWay;
+struct InputRestrictionContainer;
+
+typedef boost::unordered_map<std::string, NodeID> StringMap;
 
 class ExtractorCallbacks{
 private:
+
     StringMap * stringMap;
     ExtractionContainers * externalMemory;
 
     ExtractorCallbacks();
 public:
-    explicit ExtractorCallbacks(ExtractionContainers * ext, StringMap * strMap);
+    explicit ExtractorCallbacks(
+        ExtractionContainers * ext,
+        StringMap * strMap
+    );
 
     ~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

@@ -28,64 +28,12 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef EXTRACTORSTRUCTS_H_
 #define EXTRACTORSTRUCTS_H_
 
-#include "../DataStructures/Coordinate.h"
 #include "../DataStructures/HashTable.h"
 #include "../DataStructures/ImportNode.h"
-#include "../DataStructures/QueryNode.h"
-#include "../DataStructures/Restriction.h"
 #include "../typedefs.h"
 
-#include <boost/algorithm/string.hpp>
-#include <boost/algorithm/string/regex.hpp>
-#include <boost/regex.hpp>
-#include <boost/unordered_map.hpp>
-
-#include <climits>
 #include <string>
 
-typedef boost::unordered_map<std::string, NodeID > StringMap;
-typedef boost::unordered_map<std::string, std::pair<int, short> > StringToIntPairMap;
-
-struct ExtractionWay {
-    ExtractionWay() {
-		Clear();
-    }
-
-	inline void Clear(){
-		id = UINT_MAX;
-		nameID = UINT_MAX;
-		path.clear();
-		keyVals.clear();
-        direction = ExtractionWay::notSure;
-        speed = -1;
-        backward_speed = -1;
-        duration = -1;
-        type = -1;
-        access = true;
-        roundabout = false;
-        isAccessRestricted = false;
-        ignoreInGrid = false;
-    }
-
-    enum Directions {
-        notSure = 0, oneway, bidirectional, opposite
-    };
-    Directions direction;
-    unsigned id;
-    unsigned nameID;
-    std::string name;
-    double speed;
-    double backward_speed;
-    double duration;
-    short type;
-    bool access;
-    bool roundabout;
-    bool isAccessRestricted;
-    bool ignoreInGrid;
-    std::vector< NodeID > path;
-    HashTable<std::string, std::string> keyVals;
-};
-
 struct ExtractorRelation {
     ExtractorRelation() : type(unknown){}
     enum {
@@ -94,49 +42,34 @@ struct ExtractorRelation {
     HashTable<std::string, std::string> keyVals;
 };
 
-struct InternalExtractorEdge {
-    InternalExtractorEdge() : start(0), target(0), type(0), direction(0), speed(0), nameID(0), isRoundabout(false), ignoreInGrid(false), isDurationSet(false), isAccessRestricted(false), isContraFlow(false) {};
-    InternalExtractorEdge(NodeID s, NodeID t) : start(s), target(t), type(0), direction(0), speed(0), nameID(0), isRoundabout(false), ignoreInGrid(false), isDurationSet(false), isAccessRestricted(false), isContraFlow(false) { }
-    InternalExtractorEdge(NodeID s, NodeID t, short tp, short d, double sp): start(s), target(t), type(tp), direction(d), speed(sp), nameID(0), isRoundabout(false), ignoreInGrid(false), isDurationSet(false), isAccessRestricted(false), isContraFlow(false) { }
-    InternalExtractorEdge(NodeID s, NodeID t, short tp, short d, double sp, unsigned nid, bool isra, bool iing, bool ids, bool iar): start(s), target(t), type(tp), direction(d), speed(sp), nameID(nid), isRoundabout(isra), ignoreInGrid(iing), isDurationSet(ids), isAccessRestricted(iar), isContraFlow(false) {
-        assert(0 <= type);
-    }
-    InternalExtractorEdge(NodeID s, NodeID t, short tp, short d, double sp, unsigned nid, bool isra, bool iing, bool ids, bool iar, bool icf): start(s), target(t), type(tp), direction(d), speed(sp), nameID(nid), isRoundabout(isra), ignoreInGrid(iing), isDurationSet(ids), isAccessRestricted(iar), isContraFlow(icf) {
-        assert(0 <= type);
-    }
-    NodeID start;
-    NodeID target;
-    short type;
-    short direction;
-    double speed;
-    unsigned nameID;
-    bool isRoundabout;
-    bool ignoreInGrid;
-    bool isDurationSet;
-    bool isAccessRestricted;
-    bool isContraFlow;
-
-    FixedPointCoordinate startCoord;
-    FixedPointCoordinate targetCoord;
-
-    static InternalExtractorEdge min_value() {
-        return InternalExtractorEdge(0,0);
-    }
-    static InternalExtractorEdge max_value() {
-        return InternalExtractorEdge((std::numeric_limits<unsigned>::max)(), (std::numeric_limits<unsigned>::max)());
-    }
-};
-
-
-
 struct _WayIDStartAndEndEdge {
     unsigned wayID;
     NodeID firstStart;
     NodeID firstTarget;
     NodeID lastStart;
     NodeID lastTarget;
-    _WayIDStartAndEndEdge() : wayID(UINT_MAX), firstStart(UINT_MAX), firstTarget(UINT_MAX), lastStart(UINT_MAX), lastTarget(UINT_MAX) {}
-    _WayIDStartAndEndEdge(unsigned w, NodeID fs, NodeID ft, NodeID ls, NodeID lt) :  wayID(w), firstStart(fs), firstTarget(ft), lastStart(ls), lastTarget(lt) {}
+    _WayIDStartAndEndEdge()
+     :
+        wayID(UINT_MAX),
+        firstStart(UINT_MAX),
+        firstTarget(UINT_MAX),
+        lastStart(UINT_MAX),
+        lastTarget(UINT_MAX)
+    { }
+
+    explicit _WayIDStartAndEndEdge(
+        unsigned w,
+        NodeID fs,
+        NodeID ft,
+        NodeID ls,
+        NodeID lt
+    ) :
+        wayID(w),
+        firstStart(fs),
+        firstTarget(ft),
+        lastStart(ls),
+        lastTarget(lt)
+    { }
 
     static _WayIDStartAndEndEdge min_value() {
         return _WayIDStartAndEndEdge((std::numeric_limits<unsigned>::min)(), (std::numeric_limits<unsigned>::min)(), (std::numeric_limits<unsigned>::min)(), (std::numeric_limits<unsigned>::min)(), (std::numeric_limits<unsigned>::min)());
@@ -146,9 +79,12 @@ struct _WayIDStartAndEndEdge {
     }
 };
 
-struct CmpWayByID : public std::binary_function<_WayIDStartAndEndEdge, _WayIDStartAndEndEdge, bool> {
+struct CmpWayByID {
     typedef _WayIDStartAndEndEdge value_type;
-    bool operator ()  (const _WayIDStartAndEndEdge & a, const _WayIDStartAndEndEdge & b) const {
+    bool operator ()(
+        const _WayIDStartAndEndEdge & a,
+        const _WayIDStartAndEndEdge & b
+    ) const {
         return a.wayID < b.wayID;
     }
     value_type max_value() {
@@ -159,9 +95,12 @@ struct CmpWayByID : public std::binary_function<_WayIDStartAndEndEdge, _WayIDSta
     }
 };
 
-struct Cmp : public std::binary_function<NodeID, NodeID, bool> {
+struct Cmp {
     typedef NodeID value_type;
-    bool operator ()  (const NodeID a, const NodeID b) const {
+    bool operator ()(
+        const NodeID a,
+        const NodeID b
+    ) const {
         return a < b;
     }
     value_type max_value() {
@@ -172,57 +111,20 @@ 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 {
+    typedef ExternalMemoryNode value_type;
+    bool operator () (
+        const ExternalMemoryNode & a,
+        const ExternalMemoryNode & b
+    ) const {
         return a.id < b.id;
     }
     value_type max_value()  {
-        return _Node::max_value();
+        return ExternalMemoryNode::max_value();
     }
     value_type min_value() {
-        return _Node::min_value();
+        return ExternalMemoryNode::min_value();
     }
 };
 
-struct CmpEdgeByStartID : public std::binary_function<InternalExtractorEdge, InternalExtractorEdge, bool> {
-    typedef InternalExtractorEdge value_type;
-    bool operator ()  (const InternalExtractorEdge & a, const InternalExtractorEdge & b) const {
-        return a.start < b.start;
-    }
-    value_type max_value() {
-        return InternalExtractorEdge::max_value();
-    }
-    value_type min_value() {
-        return InternalExtractorEdge::min_value();
-    }
-};
-
-struct CmpEdgeByTargetID : public std::binary_function<InternalExtractorEdge, InternalExtractorEdge, bool> {
-    typedef InternalExtractorEdge value_type;
-    bool operator ()  (const InternalExtractorEdge & a, const InternalExtractorEdge & b) const {
-        return a.target < b.target;
-    }
-    value_type max_value() {
-        return InternalExtractorEdge::max_value();
-    }
-    value_type min_value() {
-        return InternalExtractorEdge::min_value();
-    }
-};
-
-inline std::string GetRandomString() {
-    char s[128];
-    static const char alphanum[] =
-            "0123456789"
-            "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-            "abcdefghijklmnopqrstuvwxyz";
-
-    for (int i = 0; i < 127; ++i) {
-        s[i] = alphanum[rand() % (sizeof(alphanum) - 1)];
-    }
-    s[127] = 0;
-    return std::string(s);
-}
-
 #endif /* EXTRACTORSTRUCTS_H_ */

Extractor/InternalExtractorEdge.h

@@ -0,0 +1,207 @@
+/*
+
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef INTERNAL_EXTRACTOR_EDGE_H
+#define INTERNAL_EXTRACTOR_EDGE_H
+
+#include <osrm/Coordinate.h>
+
+#include "../typedefs.h"
+
+#include <boost/assert.hpp>
+
+struct InternalExtractorEdge {
+    InternalExtractorEdge()
+     :
+        start(0),
+        target(0),
+        type(0),
+        direction(0),
+        speed(0),
+        nameID(0),
+        isRoundabout(false),
+        ignoreInGrid(false),
+        isDurationSet(false),
+        isAccessRestricted(false),
+        isContraFlow(false)
+    { }
+
+    explicit InternalExtractorEdge(NodeID start, NodeID target)
+     :
+        start(start),
+        target(target),
+        type(0),
+        direction(0),
+        speed(0),
+        nameID(0),
+        isRoundabout(false),
+        ignoreInGrid(false),
+        isDurationSet(false),
+        isAccessRestricted(false),
+        isContraFlow(false)
+    { }
+
+    explicit InternalExtractorEdge(
+        NodeID start,
+        NodeID target,
+        short type,
+        short d,
+        double speed
+    ) :
+        start(start),
+        target(target),
+        type(type),
+        direction(d),
+        speed(speed),
+        nameID(0),
+        isRoundabout(false),
+        ignoreInGrid(false),
+        isDurationSet(false),
+        isAccessRestricted(false),
+        isContraFlow(false)
+    { }
+
+    explicit InternalExtractorEdge(
+        NodeID start,
+        NodeID target,
+        short type,
+        short direction,
+        double speed,
+        unsigned nameID,
+        bool isRoundabout,
+        bool ignoreInGrid,
+        bool isDurationSet,
+        bool isAccressRestricted
+    ) :
+        start(start),
+        target(target),
+        type(type),
+        direction(direction),
+        speed(speed),
+        nameID(nameID),
+        isRoundabout(isRoundabout),
+        ignoreInGrid(ignoreInGrid),
+        isDurationSet(isDurationSet),
+        isAccessRestricted(isAccressRestricted),
+        isContraFlow(false)
+    {
+        BOOST_ASSERT(0 <= type);
+    }
+
+    explicit InternalExtractorEdge(
+        NodeID start,
+        NodeID target,
+        short type,
+        short direction,
+        double speed,
+        unsigned nameID,
+        bool isRoundabout,
+        bool ignoreInGrid,
+        bool isDurationSet,
+        bool isAccressRestricted,
+        bool isContraFlow
+    ) :
+        start(start),
+        target(target),
+        type(type),
+        direction(direction),
+        speed(speed),
+        nameID(nameID),
+        isRoundabout(isRoundabout),
+        ignoreInGrid(ignoreInGrid),
+        isDurationSet(isDurationSet),
+        isAccessRestricted(isAccressRestricted),
+        isContraFlow(isContraFlow)
+    {
+        BOOST_ASSERT(0 <= type);
+    }
+
+    // necessary static util functions for stxxl's sorting
+    static InternalExtractorEdge min_value() {
+        return InternalExtractorEdge(0,0);
+    }
+    static InternalExtractorEdge max_value() {
+        return InternalExtractorEdge(
+            std::numeric_limits<unsigned>::max(),
+            std::numeric_limits<unsigned>::max()
+        );
+    }
+
+    NodeID start;
+    NodeID target;
+    short type;
+    short direction;
+    double speed;
+    unsigned nameID;
+    bool isRoundabout;
+    bool ignoreInGrid;
+    bool isDurationSet;
+    bool isAccessRestricted;
+    bool isContraFlow;
+
+    FixedPointCoordinate startCoord;
+    FixedPointCoordinate targetCoord;
+};
+
+struct CmpEdgeByStartID {
+    typedef InternalExtractorEdge value_type;
+    bool operator ()(
+        const InternalExtractorEdge & a,
+        const InternalExtractorEdge & b
+    ) const {
+        return a.start < b.start;
+    }
+
+    value_type max_value() {
+        return InternalExtractorEdge::max_value();
+    }
+
+    value_type min_value() {
+        return InternalExtractorEdge::min_value();
+    }
+};
+
+struct CmpEdgeByTargetID {
+    typedef InternalExtractorEdge value_type;
+
+    bool operator ()(
+        const InternalExtractorEdge & a,
+        const InternalExtractorEdge & b
+    ) const {
+        return a.target < b.target;
+    }
+
+    value_type max_value() {
+        return InternalExtractorEdge::max_value();
+    }
+
+    value_type min_value() {
+        return InternalExtractorEdge::min_value();
+    }
+};
+
+#endif //INTERNAL_EXTRACTOR_EDGE_H

Extractor/PBFParser.cpp

@@ -27,21 +27,45 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "PBFParser.h"
 
-PBFParser::PBFParser(const char * fileName, ExtractorCallbacks* ec, ScriptingEnvironment& se) : BaseParser( ec, se ) {
+#include "ExtractionWay.h"
+#include "ExtractorCallbacks.h"
+#include "ScriptingEnvironment.h"
+
+#include "../DataStructures/HashTable.h"
+#include "../DataStructures/Restriction.h"
+#include "../Util/MachineInfo.h"
+#include "../Util/OpenMPWrapper.h"
+#include "../Util/OSRMException.h"
+#include "../Util/SimpleLogger.h"
+#include "../typedefs.h"
+
+#include <osrm/Coordinate.h>
+
+#include <boost/foreach.hpp>
+#include <boost/make_shared.hpp>
+#include <boost/ref.hpp>
+
+#include <zlib.h>
+
+PBFParser::PBFParser(
+	const char * fileName,
+	ExtractorCallbacks * extractor_callbacks,
+	ScriptingEnvironment& scripting_environment
+) : BaseParser( extractor_callbacks, scripting_environment ) {
 	GOOGLE_PROTOBUF_VERIFY_VERSION;
 	//TODO: What is the bottleneck here? Filling the queue or reading the stuff from disk?
 	//NOTE: With Lua scripting, it is parsing the stuff. I/O is virtually for free.
-	threadDataQueue = boost::make_shared<ConcurrentQueue<_ThreadData*> >( 2500 ); /* Max 2500 items in queue, hardcoded. */
+
+	// Max 2500 items in queue, hardcoded.
+	threadDataQueue = boost::make_shared<ConcurrentQueue<_ThreadData*> >( 2500 );
 	input.open(fileName, std::ios::in | std::ios::binary);
 
 	if (!input) {
 		throw OSRMException("pbf file not found.");
 	}
 
-#ifndef NDEBUG
 	blockCount = 0;
 	groupCount = 0;
-#endif
 }
 
 PBFParser::~PBFParser() {
@@ -50,18 +74,17 @@ PBFParser::~PBFParser() {
 	}
 
 	// Clean up any leftover ThreadData objects in the queue
-	_ThreadData* td;
-	while (threadDataQueue->try_pop(td)) {
-		delete td;
+	_ThreadData* thread_data;
+	while (threadDataQueue->try_pop(thread_data))
+	{
+		delete thread_data;
 	}
 	google::protobuf::ShutdownProtobufLibrary();
 
-#ifndef NDEBUG
 	SimpleLogger().Write(logDEBUG) <<
 		"parsed " << blockCount <<
 		" blocks from pbf with " << groupCount <<
 		" groups";
-#endif
 }
 
 inline bool PBFParser::ReadHeader() {
@@ -194,12 +217,15 @@ inline void PBFParser::parseDenseNode(_ThreadData * threadData) {
 
 #pragma omp parallel for schedule ( guided )
 	for(int i = 0; i < number_of_nodes; ++i) {
-	    ImportNode &n = extracted_nodes_vector[i];
-	    ParseNodeInLua( n, scriptingEnvironment.getLuaStateForThreadID(omp_get_thread_num()) );
+	    ImportNode & import_node = extracted_nodes_vector[i];
+	    ParseNodeInLua(
+	    	import_node,
+	    	scripting_environment.getLuaStateForThreadID(omp_get_thread_num())
+	    );
 	}
 
-	BOOST_FOREACH(const ImportNode &n, extracted_nodes_vector) {
-	    extractor_callbacks->nodeFunction(n);
+	BOOST_FOREACH(const ImportNode &import_node, extracted_nodes_vector) {
+	    extractor_callbacks->nodeFunction(import_node);
 	}
 }
 
@@ -232,12 +258,12 @@ inline void PBFParser::parseRelation(_ThreadData * threadData) {
 					break;
 				}
 			}
-			if ("restriction" == key) {
-				if(val.find("only_") == 0) {
-					isOnlyRestriction = true;
-				}
+			if ( ("restriction" == key) && (val.find("only_") == 0) )
+			{
+				isOnlyRestriction = true;
 			}
-			if ("except" == key) {
+			if ("except" == key)
+			{
 				except_tag_string = val;
 			}
 		}
@@ -248,7 +274,7 @@ inline void PBFParser::parseRelation(_ThreadData * threadData) {
 
 		if(isRestriction) {
 			int64_t lastRef = 0;
-			_RawRestrictionContainer currentRestrictionContainer(isOnlyRestriction);
+			InputRestrictionContainer currentRestrictionContainer(isOnlyRestriction);
 			for(
 				int rolesIndex = 0, last_role =  inputRelation.roles_sid_size();
 				rolesIndex < last_role;
@@ -326,18 +352,23 @@ inline void PBFParser::parseWay(_ThreadData * threadData) {
 
 #pragma omp parallel for schedule ( guided )
 	for(int i = 0; i < number_of_ways; ++i) {
-	    ExtractionWay & w = parsed_way_vector[i];
-		if(2 > w.path.size()) {
+	    ExtractionWay & extraction_way = parsed_way_vector[i];
+		if (2 > extraction_way.path.size())
+		{
         	continue;
     	}
-	    ParseWayInLua( w, scriptingEnvironment.getLuaStateForThreadID( omp_get_thread_num()) );
+	    ParseWayInLua(
+	    	extraction_way,
+	    	scripting_environment.getLuaStateForThreadID( omp_get_thread_num())
+	   	);
 	}
 
-	BOOST_FOREACH(ExtractionWay & w, parsed_way_vector) {
-		if(2 > w.path.size()) {
+	BOOST_FOREACH(ExtractionWay & extraction_way, parsed_way_vector) {
+		if (2 > extraction_way.path.size())
+		{
         	continue;
     	}
-	    extractor_callbacks->wayFunction(w);
+	    extractor_callbacks->wayFunction(extraction_way);
 	}
 }
 
@@ -365,9 +396,7 @@ inline void PBFParser::loadGroup(_ThreadData * threadData) {
 }
 
 inline void PBFParser::loadBlock(_ThreadData * threadData) {
-#ifndef NDEBUG
 	++blockCount;
-#endif
 	threadData->currentGroupID = 0;
 	threadData->currentEntityID = 0;
 }

Extractor/PBFParser.h

@@ -29,24 +29,14 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define PBFPARSER_H_
 
 #include "BaseParser.h"
-
-#include "../DataStructures/Coordinate.h"
-#include "../DataStructures/HashTable.h"
 #include "../DataStructures/ConcurrentQueue.h"
-#include "../Util/MachineInfo.h"
-#include "../Util/OpenMPWrapper.h"
-#include "../Util/OSRMException.h"
-#include "../Util/SimpleLogger.h"
-#include "../typedefs.h"
 
 #include <boost/shared_ptr.hpp>
-#include <boost/make_shared.hpp>
-#include <boost/ref.hpp>
 
 #include <osmpbf/fileformat.pb.h>
 #include <osmpbf/osmformat.pb.h>
 
-#include <zlib.h>
+#include <fstream>
 
 class PBFParser : public BaseParser {
 
@@ -73,7 +63,11 @@ class PBFParser : public BaseParser {
     };
 
 public:
-    PBFParser(const char * fileName, ExtractorCallbacks* ec, ScriptingEnvironment& se);
+    PBFParser(
+        const char * fileName,
+        ExtractorCallbacks* ec,
+        ScriptingEnvironment& se
+    );
     virtual ~PBFParser();
 
     inline bool ReadHeader();
@@ -99,11 +93,8 @@ private:
     static const int MAX_BLOB_HEADER_SIZE = 64 * 1024;
     static const int MAX_BLOB_SIZE = 32 * 1024 * 1024;
 
-#ifndef NDEBUG
-    /* counting the number of read blocks and groups */
     unsigned groupCount;
     unsigned blockCount;
-#endif
 
     std::fstream input;     // the input stream to parse
     boost::shared_ptr<ConcurrentQueue < _ThreadData* > > threadDataQueue;

Extractor/ScriptingEnvironment.cpp

@@ -27,6 +27,15 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "ScriptingEnvironment.h"
 
+#include "ExtractionHelperFunctions.h"
+#include "ExtractionWay.h"
+#include "../DataStructures/ImportNode.h"
+#include "../Util/LuaUtil.h"
+#include "../Util/OpenMPWrapper.h"
+#include "../Util/OSRMException.h"
+#include "../Util/SimpleLogger.h"
+#include "../typedefs.h"
+
 ScriptingEnvironment::ScriptingEnvironment() {}
 ScriptingEnvironment::ScriptingEnvironment(const char * fileName) {
 	SimpleLogger().Write() << "Using script " << fileName;
@@ -66,7 +75,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)
@@ -75,6 +84,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)
@@ -94,9 +104,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

@@ -28,17 +28,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef SCRIPTINGENVIRONMENT_H_
 #define SCRIPTINGENVIRONMENT_H_
 
-#include "ExtractionHelperFunctions.h"
-#include "ExtractorStructs.h"
-#include "../DataStructures/ImportNode.h"
-#include "../Util/LuaUtil.h"
-#include "../Util/OpenMPWrapper.h"
-#include "../Util/OSRMException.h"
-#include "../Util/SimpleLogger.h"
-#include "../typedefs.h"
-
 #include <vector>
 
+struct lua_State;
+
 class ScriptingEnvironment {
 public:
     ScriptingEnvironment();

Extractor/XMLParser.cpp

@@ -27,16 +27,20 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "XMLParser.h"
 
-#include "ExtractorStructs.h"
+#include "ExtractionWay.h"
 #include "../DataStructures/HashTable.h"
+#include "../DataStructures/ImportNode.h"
 #include "../DataStructures/InputReaderFactory.h"
+#include "../DataStructures/Restriction.h"
+#include "../Util/SimpleLogger.h"
+#include "../Util/StringUtil.h"
+#include "../typedefs.h"
+
+#include <osrm/Coordinate.h>
 
 #include <boost/ref.hpp>
 
 XMLParser::XMLParser(const char * filename, ExtractorCallbacks* ec, ScriptingEnvironment& se) : BaseParser(ec, se) {
-	SimpleLogger().Write(logWARNING) <<
-		"Parsing plain .osm/.osm.bz2 is deprecated. Switch to .pbf";
-
 	inputReader = inputReaderFactory(filename);
 }
 
@@ -59,7 +63,7 @@ bool XMLParser::Parse() {
 
 		if ( xmlStrEqual( currentName, ( const xmlChar* ) "node" ) == 1 ) {
 			ImportNode n = _ReadXMLNode();
-			ParseNodeInLua( n, luaState );
+			ParseNodeInLua( n, lua_state );
 			extractor_callbacks->nodeFunction(n);
 //			if(!extractor_callbacks->nodeFunction(n))
 //				std::cerr << "[XMLParser] dense node not parsed" << std::endl;
@@ -67,14 +71,14 @@ bool XMLParser::Parse() {
 
 		if ( xmlStrEqual( currentName, ( const xmlChar* ) "way" ) == 1 ) {
 			ExtractionWay way = _ReadXMLWay( );
-			ParseWayInLua( way, luaState );
+			ParseWayInLua( way, lua_state );
 			extractor_callbacks->wayFunction(way);
 //			if(!extractor_callbacks->wayFunction(way))
 //				std::cerr << "[PBFParser] way not parsed" << std::endl;
 		}
 		if( use_turn_restrictions ) {
 			if ( xmlStrEqual( currentName, ( const xmlChar* ) "relation" ) == 1 ) {
-				_RawRestrictionContainer r = _ReadXMLRestriction();
+				InputRestrictionContainer r = _ReadXMLRestriction();
 				if(r.fromWay != UINT_MAX) {
 					if(!extractor_callbacks->restrictionFunction(r)) {
 						std::cerr << "[XMLParser] restriction not parsed" << std::endl;
@@ -87,8 +91,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

@@ -28,23 +28,24 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef XMLPARSER_H_
 #define XMLPARSER_H_
 
+#include "ExtractorCallbacks.h"
 #include "BaseParser.h"
-#include "../DataStructures/Coordinate.h"
-#include "../Util/SimpleLogger.h"
-#include "../Util/StringUtil.h"
-#include "../typedefs.h"
 
 #include <libxml/xmlreader.h>
 
 
 class XMLParser : public BaseParser {
 public:
-    XMLParser(const char* filename, ExtractorCallbacks* ec, ScriptingEnvironment& se);
+    XMLParser(
+        const char* filename,
+        ExtractorCallbacks* ec,
+        ScriptingEnvironment& se
+    );
     bool ReadHeader();
     bool Parse();
 
 private:
-    _RawRestrictionContainer _ReadXMLRestriction();
+    InputRestrictionContainer _ReadXMLRestriction();
     ExtractionWay _ReadXMLWay();
     ImportNode _ReadXMLNode();
     xmlTextReaderPtr inputReader;

Include/osrm/Coordinate.h

@@ -0,0 +1,84 @@
+/*
+
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef FIXED_POINT_COORDINATE_H_
+#define FIXED_POINT_COORDINATE_H_
+
+#include <iostream>
+
+static const double COORDINATE_PRECISION = 1000000.;
+
+struct FixedPointCoordinate {
+    int lat;
+    int lon;
+
+    FixedPointCoordinate();
+    explicit FixedPointCoordinate (int lat, int lon);
+    void Reset();
+    bool isSet() const;
+    bool isValid() const;
+    bool operator==(const FixedPointCoordinate & other) const;
+
+    static double ApproximateDistance(
+        const int lat1,
+        const int lon1,
+        const int lat2,
+        const int lon2
+    );
+
+    static double ApproximateDistance(
+        const FixedPointCoordinate & c1,
+        const FixedPointCoordinate & c2
+    );
+
+    static double ApproximateEuclideanDistance(
+        const FixedPointCoordinate & c1,
+        const FixedPointCoordinate & c2
+    );
+
+    static void convertInternalLatLonToString(
+        const int value,
+        std::string & output
+    );
+
+    static void convertInternalCoordinateToString(
+        const FixedPointCoordinate & coord,
+        std::string & output
+    );
+
+    static void convertInternalReversedCoordinateToString(
+        const FixedPointCoordinate & coord,
+        std::string & output
+    );
+};
+
+inline std::ostream & operator<<(std::ostream & out, const FixedPointCoordinate & c){
+    out << "(" << c.lat << "," << c.lon << ")";
+    return out;
+}
+
+#endif /* FIXED_POINT_COORDINATE_H_ */

Include/osrm/Header.h

@@ -25,33 +25,21 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 */
 
-#ifndef BRESENHAM_H_
-#define BRESENHAM_H_
+#ifndef HTTP_HEADER_H
+#define HTTP_HEADER_H
 
-#include <cmath>
-#include <vector>
+#include <string>
 
-typedef std::pair<unsigned, unsigned> BresenhamPixel;
+namespace http {
 
-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;
+    struct Header {
+        std::string name;
+        std::string value;
+        void Clear() {
+            name.clear();
+            value.clear();
         }
-        if(e2 < dx) {
-            err+= dx;
-            y0 += sy;
-        }
-    }
+    };
 }
 
-#endif /* BRESENHAM_H_ */
+#endif //HTTP_HEADER_H

Include/osrm/Reply.h

@@ -0,0 +1,73 @@
+/*
+
+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 REPLY_H
+#define REPLY_H
+
+#include "Header.h"
+
+#include <boost/asio.hpp>
+
+#include <vector>
+
+namespace http {
+
+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' };
+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";
+
+class Reply {
+public:
+    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::vector<std::string> content;
+    static Reply StockReply(status_type status);
+    void setSize(const unsigned size);
+    void SetUncompressedSize();
+
+    Reply();
+private:
+    static std::string ToString(Reply::status_type status);
+    boost::asio::const_buffer ToBuffer(Reply::status_type status);
+};
+
+}
+
+#endif //REPLY_H

Include/osrm/RouteParameters.h

@@ -28,8 +28,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef ROUTE_PARAMETERS_H
 #define ROUTE_PARAMETERS_H
 
-#include "../../DataStructures/Coordinate.h"
-#include "../../DataStructures/HashTable.h"
+#include <osrm/Coordinate.h>
 
 #include <boost/fusion/container/vector.hpp>
 #include <boost/fusion/sequence/intrinsic.hpp>
@@ -46,7 +45,9 @@ struct RouteParameters {
         geometry(true),
         compression(true),
         deprecatedAPI(false),
-        checkSum(-1) {}
+        checkSum(-1)
+    { }
+
     short zoomLevel;
     bool printInstructions;
     bool alternateRoute;
@@ -60,10 +61,9 @@ struct RouteParameters {
     std::string language;
     std::vector<std::string> hints;
     std::vector<FixedPointCoordinate> coordinates;
-    typedef HashTable<std::string, std::string>::const_iterator OptionsIterator;
 
     void setZoomLevel(const short i) {
-        if (18 > i && 0 < i) {
+        if (18 >= i && 0 <= i) {
             zoomLevel = i;
         }
     }
@@ -97,8 +97,10 @@ struct RouteParameters {
     }
 
     void addHint(const std::string & s) {
-        hints.resize(coordinates.size());
-        hints.back() = s;
+        hints.resize( coordinates.size() );
+        if( !hints.empty() ) {
+            hints.back() = s;
+        }
     }
 
     void setLanguage(const std::string & s) {

Include/osrm/ServerPaths.h

@@ -0,0 +1,38 @@
+/*
+
+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 SERVER_PATH_H
+#define SERVER_PATH_H
+
+#include <boost/unordered_map.hpp>
+#include <boost/filesystem.hpp>
+
+#include <string>
+
+typedef boost::unordered_map<const std::string, boost::filesystem::path> ServerPaths;
+
+#endif //SERVER_PATH_H

Library/OSRM.cpp

@@ -1,64 +0,0 @@
-/*
-
-Copyright (c) 2013, Project OSRM, Dennis Luxen, others
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
-Redistributions of source code must retain the above copyright notice, this list
-of conditions and the following disclaimer.
-Redistributions in binary form must reproduce the above copyright notice, this
-list of conditions and the following disclaimer in the documentation and/or
-other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-*/
-
-#include "OSRM.h"
-#include <boost/foreach.hpp>
-
-
-OSRM::OSRM(boost::unordered_map<const std::string,boost::filesystem::path>& paths) {
-    objects = new QueryObjectsStorage( paths );
-    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) {
-        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.find(plugin->GetDescriptor())->second;
-    }
-    pluginMap.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) {
-        reply.status = http::Reply::ok;
-        iter->second->HandleRequest(route_parameters, reply );
-    } else {
-        reply = http::Reply::stockReply(http::Reply::badRequest);
-    }
-}

Library/OSRM.h

@@ -28,38 +28,24 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef OSRM_H
 #define OSRM_H
 
-#include "OSRM.h"
+#include <boost/scoped_ptr.hpp>
 
-#include "../Plugins/BasePlugin.h"
-#include "../Plugins/HelloWorldPlugin.h"
-#include "../Plugins/LocatePlugin.h"
-#include "../Plugins/NearestPlugin.h"
-#include "../Plugins/TimestampPlugin.h"
-#include "../Plugins/ViaRoutePlugin.h"
-#include "../Server/DataStructures/RouteParameters.h"
-#include "../Util/InputFileUtil.h"
-#include "../Util/OSRMException.h"
-#include "../Util/ProgramOptions.h"
-#include "../Util/SimpleLogger.h"
-#include "../Server/BasicDatastructures.h"
+#include <osrm/Reply.h>
+#include <osrm/RouteParameters.h>
+#include <osrm/ServerPaths.h>
 
-#include <boost/assert.hpp>
-#include <boost/filesystem.hpp>
-#include <boost/noncopyable.hpp>
-#include <boost/thread.hpp>
+class OSRM_impl;
 
-#include <vector>
-
-class OSRM : boost::noncopyable {
-    typedef boost::unordered_map<std::string, BasePlugin *> PluginMap;
-    QueryObjectsStorage * objects;
+class OSRM {
+private:
+    OSRM_impl * OSRM_pimpl_;
 public:
-    OSRM(boost::unordered_map<const std::string,boost::filesystem::path>& paths);
+    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;
 };
 
-#endif //OSRM_H
+#endif // OSRM_H

Library/OSRM_impl.cpp

@@ -0,0 +1,167 @@
+/*
+
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#include "OSRM.h"
+#include "OSRM_impl.h"
+
+#include "../Plugins/HelloWorldPlugin.h"
+#include "../Plugins/LocatePlugin.h"
+#include "../Plugins/NearestPlugin.h"
+#include "../Plugins/TimestampPlugin.h"
+#include "../Plugins/ViaRoutePlugin.h"
+
+#include "../Server/DataStructures/BaseDataFacade.h"
+#include "../Server/DataStructures/InternalDataFacade.h"
+#include "../Server/DataStructures/SharedBarriers.h"
+#include "../Server/DataStructures/SharedDataFacade.h"
+
+#include <boost/assert.hpp>
+
+OSRM_impl::OSRM_impl( const ServerPaths & server_paths, const bool use_shared_memory )
+ :
+    use_shared_memory(use_shared_memory)
+{
+    if (use_shared_memory)
+    {
+        barrier = new SharedBarriers();
+        query_data_facade = new SharedDataFacade<QueryEdge::EdgeData>( );
+    }
+    else
+    {
+        query_data_facade = new InternalDataFacade<QueryEdge::EdgeData>(
+            server_paths
+        );
+    }
+
+    //The following plugins handle all requests.
+    RegisterPlugin(
+        new HelloWorldPlugin()
+    );
+    RegisterPlugin(
+        new LocatePlugin<BaseDataFacade<QueryEdge::EdgeData> >(
+            query_data_facade
+        )
+    );
+    RegisterPlugin(
+        new NearestPlugin<BaseDataFacade<QueryEdge::EdgeData> >(
+            query_data_facade
+        )
+    );
+    RegisterPlugin(
+        new TimestampPlugin<BaseDataFacade<QueryEdge::EdgeData> >(
+            query_data_facade
+        )
+    );
+    RegisterPlugin(
+        new ViaRoutePlugin<BaseDataFacade<QueryEdge::EdgeData> >(
+            query_data_facade
+        )
+    );
+}
+
+OSRM_impl::~OSRM_impl() {
+    BOOST_FOREACH(PluginMap::value_type & plugin_pointer, plugin_map) {
+        delete plugin_pointer.second;
+    }
+    if( use_shared_memory ) {
+        delete barrier;
+    }
+}
+
+void OSRM_impl::RegisterPlugin(BasePlugin * plugin) {
+    SimpleLogger().Write()  << "loaded plugin: " << plugin->GetDescriptor();
+    if( plugin_map.find(plugin->GetDescriptor()) != plugin_map.end() ) {
+        delete plugin_map.find(plugin->GetDescriptor())->second;
+    }
+    plugin_map.emplace(plugin->GetDescriptor(), plugin);
+}
+
+void OSRM_impl::RunQuery(RouteParameters & route_parameters, http::Reply & reply) {
+    const PluginMap::const_iterator & iter = plugin_map.find(
+        route_parameters.service
+    );
+
+    if(plugin_map.end() != iter) {
+        reply.status = http::Reply::ok;
+        if( use_shared_memory ) {
+            // lock update pending
+            boost::interprocess::scoped_lock<
+                boost::interprocess::named_mutex
+            > pending_lock(barrier->pending_update_mutex);
+
+            // lock query
+            boost::interprocess::scoped_lock<
+                boost::interprocess::named_mutex
+            > query_lock(barrier->query_mutex);
+
+            // unlock update pending
+            pending_lock.unlock();
+
+            // increment query count
+            ++(barrier->number_of_queries);
+
+            (static_cast<SharedDataFacade<QueryEdge::EdgeData>* >(query_data_facade))->CheckAndReloadFacade();
+        }
+
+        iter->second->HandleRequest(route_parameters, reply );
+        if( use_shared_memory ) {
+            // lock query
+            boost::interprocess::scoped_lock<
+                boost::interprocess::named_mutex
+            > query_lock(barrier->query_mutex);
+
+            // decrement query count
+            --(barrier->number_of_queries);
+            BOOST_ASSERT_MSG(
+                0 <= barrier->number_of_queries,
+                "invalid number of queries"
+            );
+
+            // notify all processes that were waiting for this condition
+            if (0 == barrier->number_of_queries) {
+                barrier->no_running_queries_condition.notify_all();
+            }
+        }
+    } else {
+        reply = http::Reply::StockReply(http::Reply::badRequest);
+    }
+}
+
+// proxy code for compilation firewall
+
+OSRM::OSRM(
+    const ServerPaths & paths,
+    const bool use_shared_memory
+) : OSRM_pimpl_(new OSRM_impl(paths, use_shared_memory)) { }
+
+OSRM::~OSRM() {
+    delete OSRM_pimpl_;
+}
+
+void OSRM::RunQuery(RouteParameters & route_parameters, http::Reply & reply) {
+    OSRM_pimpl_->RunQuery(route_parameters, reply);
+}

Library/OSRM_impl.h

@@ -0,0 +1,65 @@
+/*
+
+Copyright (c) 2013, Project OSRM, Dennis Luxen, others
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef OSRM_IMPL_H
+#define OSRM_IMPL_H
+
+#include <osrm/Reply.h>
+#include <osrm/RouteParameters.h>
+#include <osrm/ServerPaths.h>
+
+#include "../DataStructures/QueryEdge.h"
+#include "../Plugins/BasePlugin.h"
+#include "../Util/ProgramOptions.h"
+
+#include <boost/noncopyable.hpp>
+
+struct SharedBarriers;
+template<class EdgeDataT>
+class BaseDataFacade;
+
+class OSRM_impl : boost::noncopyable {
+private:
+    typedef boost::unordered_map<std::string, BasePlugin *> PluginMap;
+public:
+    OSRM_impl(
+        const ServerPaths & paths,
+        const bool use_shared_memory
+    );
+    virtual ~OSRM_impl();
+    void RunQuery(RouteParameters & route_parameters, http::Reply & reply);
+
+private:
+    void RegisterPlugin(BasePlugin * plugin);
+    PluginMap plugin_map;
+    bool use_shared_memory;
+    SharedBarriers * barrier;
+    //base class pointer to the objects
+    BaseDataFacade<QueryEdge::EdgeData> * query_data_facade;
+};
+
+#endif //OSRM_IMPL_H

Plugins/BasePlugin.h

@@ -28,9 +28,9 @@ 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 <osrm/Coordinate.h>
+#include <osrm/Reply.h>
+#include <osrm/RouteParameters.h>
 
 #include <string>
 #include <vector>

Plugins/HelloWorldPlugin.h

@@ -29,10 +29,13 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #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() { }
@@ -40,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

@@ -29,27 +29,31 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #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;
         }
 
@@ -58,35 +62,37 @@ 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->LocateClosestEndPointForCoordinate(routeParameters.coordinates[0], result)) {
-            reply.content += ("\"status\":207,");
-            reply.content += ("\"mapped_coordinate\":[]");
+        reply.content.push_back ("{");
+        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\":");
-            convertInternalLatLonToString(result.lat, tmp);
-            reply.content += "[";
-            reply.content += tmp;
-            convertInternalLatLonToString(result.lon, tmp);
-            reply.content += ",";
-            reply.content += tmp;
-            reply.content += "]";
+            reply.content.push_back ("\"status\":0,");
+            reply.content.push_back ("\"mapped_coordinate\":");
+            FixedPointCoordinate::convertInternalLatLonToString(result.lat, tmp);
+            reply.content.push_back("[");
+            reply.content.push_back(tmp);
+            FixedPointCoordinate::convertInternalLatLonToString(result.lon, tmp);
+            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("}");
         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";
@@ -98,14 +104,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

@@ -25,43 +25,48 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 */
 
-#ifndef NearestPlugin_H_
-#define NearestPlugin_H_
+#ifndef NEAREST_PLUGIN_H
+#define NEAREST_PLUGIN_H
 
 #include "BasePlugin.h"
-
-#include "../DataStructures/NodeInformationHelpDesk.h"
-#include "../Server/DataStructures/QueryObjectsStorage.h"
+#include "../DataStructures/PhantomNodes.h"
 #include "../Util/StringUtil.h"
 
+#include <boost/unordered_map.hpp>
+
 /*
  * 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 )
      :
-        m_query_objects(objects),
+        facade(facade),
         descriptor_string("nearest")
     {
-        descriptorTable.insert(std::make_pair(""    , 0)); //default descriptor
-        descriptorTable.insert(std::make_pair("json", 1));
+        descriptorTable.emplace("",     0); //default descriptor
+        descriptorTable.emplace("json", 1);
     }
     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);
+        if( !checkCoord(routeParameters.coordinates[0]) ) {
+            reply = http::Reply::StockReply(http::Reply::badRequest);
             return;
         }
-        NodeInformationHelpDesk * nodeHelpDesk = m_query_objects->nodeHelpDesk;
-        //query to helpdesk
+
         PhantomNode result;
-        nodeHelpDesk->FindPhantomNodeForCoordinate(
+        facade->FindPhantomNodeForCoordinate(
             routeParameters.coordinates[0],
             result,
             routeParameters.zoomLevel
@@ -71,40 +76,34 @@ 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.push_back("{\"status\":");
         if(UINT_MAX != result.edgeBasedNode) {
-            reply.content += "0,";
+            reply.content.push_back("0,");
         } else {
-            reply.content += "207,";
+            reply.content.push_back("207,");
         }
-        reply.content += ("\"mapped_coordinate\":");
-        reply.content += "[";
+        reply.content.push_back("\"mapped_coordinate\":[");
         if(UINT_MAX != result.edgeBasedNode) {
-            convertInternalLatLonToString(result.location.lat, temp_string);
-            reply.content += temp_string;
-            convertInternalLatLonToString(result.location.lon, temp_string);
-            reply.content += ",";
-            reply.content += temp_string;
+            FixedPointCoordinate::convertInternalLatLonToString(result.location.lat, temp_string);
+            reply.content.push_back(temp_string);
+            FixedPointCoordinate::convertInternalLatLonToString(result.location.lon, temp_string);
+            reply.content.push_back(",");
+            reply.content.push_back(temp_string);
         }
-        reply.content += "],";
-        reply.content += "\"name\":\"";
+        reply.content.push_back("],\"name\":\"");
         if(UINT_MAX != result.edgeBasedNode) {
-            m_query_objects->GetName(result.nodeBasedEdgeNameID, temp_string);
-            reply.content += temp_string;
+            facade->GetName(result.nodeBasedEdgeNameID, temp_string);
+            reply.content.push_back(temp_string);
         }
-        reply.content += "\"";
-        reply.content += ",\"transactionId\":\"OSRM Routing Engine JSON Nearest (v0.3)\"";
-        reply.content += ("}");
+        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";
@@ -116,14 +115,18 @@ public:
             reply.headers[2].value = "attachment; filename=\"location.json\"";
         }
         reply.headers[0].name = "Content-Length";
-        intToString(reply.content.size(), temp_string);
+        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:
-    QueryObjectsStorage * m_query_objects;
-    HashTable<std::string, unsigned> descriptorTable;
+    DataFacadeT * facade;
+    boost::unordered_map<std::string, unsigned> descriptorTable;
     std::string descriptor_string;
 };
 
-#endif /* NearestPlugin_H_ */
+#endif /* NEAREST_PLUGIN_H */

Plugins/TimestampPlugin.h

@@ -30,10 +30,11 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #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) {
@@ -41,23 +42,21 @@ 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("\"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("}");
         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";
@@ -68,12 +67,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

@@ -32,12 +32,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "../Algorithms/ObjectToBase64.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"
 
@@ -48,49 +46,48 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <string>
 #include <vector>
 
+template<class DataFacadeT>
 class ViaRoutePlugin : public BasePlugin {
 private:
-    NodeInformationHelpDesk * nodeHelpDesk;
-    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)
      :
-        // objects(objects),
-        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(objects);
-
-        // descriptorTable.emplace(""    , 0);
         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();
-        bool checksumOK = (routeParameters.checkSum == rawRoute.checkSum);
+        rawRoute.checkSum = facade->GetCheckSum();
+        const 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]);
@@ -100,88 +97,101 @@ 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
+            );
         }
 
+        PhantomNodes segmentPhantomNodes;
         for(unsigned i = 0; i < phantomNodeVector.size()-1; ++i) {
-            PhantomNodes segmentPhantomNodes;
             segmentPhantomNodes.startPhantom = phantomNodeVector[i];
             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;
+        DescriptorConfig descriptorConfig;
 
         unsigned descriptorType = 0;
         if(descriptorTable.find(routeParameters.outputFormat) != descriptorTable.end() ) {
             descriptorType = descriptorTable.find(routeParameters.outputFormat)->second;
         }
-        descriptorConfig.z = routeParameters.zoomLevel;
+        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(rawRoute, phantomNodes, facade, reply);
         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";
@@ -202,7 +212,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";
@@ -221,6 +231,7 @@ public:
     }
 private:
     std::string descriptor_string;
+    DataFacadeT * facade;
 };
 
 

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'
 

RoutingAlgorithms/AlternativePathRouting.h

@@ -29,6 +29,9 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define ALTERNATIVEROUTES_H_
 
 #include "BasicRoutingInterface.h"
+#include "../DataStructures/SearchEngineData.h"
+
+#include <boost/foreach.hpp>
 #include <boost/unordered_map.hpp>
 #include <cmath>
 #include <vector>
@@ -37,15 +40,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;
@@ -53,66 +61,130 @@ 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;
 
@@ -142,12 +214,19 @@ public:
         		approximated_reverse_sharing[v] = reverse_heap1.GetKey(u);
         	} else {
         		//sharing (s) = sharing (t)
-        		approximated_reverse_sharing[v] = approximated_reverse_sharing[u];
+                boost::unordered_map<NodeID, int>::const_iterator rev_iterator = approximated_reverse_sharing.find(u);
+                const int rev_sharing = (rev_iterator != approximated_reverse_sharing.end()) ? rev_iterator->second : 0;
+        		approximated_reverse_sharing[v] = rev_sharing;
         	}
         }
         std::vector<NodeID> nodes_that_passed_preselection;
-        BOOST_FOREACH(const NodeID node, viaNodeCandidates) {
-            int approximated_sharing = approximated_forward_sharing[node] + approximated_reverse_sharing[node];
+        BOOST_FOREACH(const NodeID node, via_node_candidate_list) {
+            boost::unordered_map<NodeID, int>::const_iterator fwd_iterator = approximated_forward_sharing.find(node);
+            const int fwd_sharing = (fwd_iterator != approximated_forward_sharing.end()) ? fwd_iterator->second : 0;
+            boost::unordered_map<NodeID, int>::const_iterator rev_iterator = approximated_reverse_sharing.find(node);
+            const int rev_sharing = (rev_iterator != approximated_reverse_sharing.end()) ? rev_iterator->second : 0;
+
+            int approximated_sharing = fwd_sharing + rev_sharing;
             int approximated_length = forward_heap1.GetKey(node)+reverse_heap1.GetKey(node);
             bool lengthPassed = (approximated_length < upper_bound_to_shortest_path_distance*(1+VIAPATH_EPSILON));
             bool sharingPassed = (approximated_sharing <= upper_bound_to_shortest_path_distance*VIAPATH_GAMMA);
@@ -185,26 +264,28 @@ 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;
+            raw_route_data.unpacked_path_segments.resize(1);
+            super::UnpackPath(packedShortestPath, raw_route_data.unpacked_path_segments[0]);
+            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.unpacked_alternative);
+            raw_route_data.lengthOfAlternativePath = lengthOfViaPath;
         } else {
-            rawRouteData.lengthOfAlternativePath = INT_MAX;
+            raw_route_data.lengthOfAlternativePath = INT_MAX;
         }
     }
 
 private:
     //unpack <s,..,v,..,t> by exploring search spaces from v
     inline void retrievePackedViaPath(QueryHeap & _forwardHeap1, QueryHeap & _backwardHeap1, QueryHeap & _forwardHeap2, QueryHeap & _backwardHeap2,
-            const NodeID s_v_middle, const NodeID v_t_middle, std::vector<_PathData> & unpackedPath) {
+            const NodeID s_v_middle, const NodeID v_t_middle, std::vector<PathData> & unpackedPath) {
         //unpack [s,v)
         std::vector<NodeID> packed_s_v_path, packed_v_t_path;
         super::RetrievePackedPathFromHeap(_forwardHeap1, _backwardHeap2, s_v_middle, packed_s_v_path);
@@ -219,12 +300,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;
@@ -233,19 +316,19 @@ private:
         std::vector<NodeID> partiallyUnpackedViaPath;
 
         NodeID s_v_middle = UINT_MAX;
-        int upperBoundFor_s_v_Path = INT_MAX;//compute path <s,..,v> by reusing forward search from s
+        int upperBoundFor_s_vPath = INT_MAX;//compute path <s,..,v> by reusing forward search from s
         newBackwardHeap.Insert(via_node, 0, via_node);
         while (0 < newBackwardHeap.Size()) {
-            super::RoutingStep(newBackwardHeap, existingForwardHeap, &s_v_middle, &upperBoundFor_s_v_Path, 2 * offset, false);
+            super::RoutingStep(newBackwardHeap, existingForwardHeap, &s_v_middle, &upperBoundFor_s_vPath, 2 * offset, false);
         }
         //compute path <v,..,t> by reusing backward search from node t
         NodeID v_t_middle = UINT_MAX;
-        int upperBoundFor_v_t_Path = INT_MAX;
+        int upperBoundFor_v_tPath = INT_MAX;
         newForwardHeap.Insert(via_node, 0, via_node);
         while (0 < newForwardHeap.Size() ) {
-            super::RoutingStep(newForwardHeap, existingBackwardHeap, &v_t_middle, &upperBoundFor_v_t_Path, 2 * offset, true);
+            super::RoutingStep(newForwardHeap, existingBackwardHeap, &v_t_middle, &upperBoundFor_v_tPath, 2 * offset, true);
         }
-        *real_length_of_via_path = upperBoundFor_s_v_Path + upperBoundFor_v_t_Path;
+        *real_length_of_via_path = upperBoundFor_s_vPath + upperBoundFor_v_tPath;
 
         if(UINT_MAX == s_v_middle || UINT_MAX == v_t_middle)
             return;
@@ -258,8 +341,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);
@@ -270,8 +353,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
@@ -279,8 +362,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);
@@ -294,8 +377,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;
             }
@@ -315,8 +398,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;
         }
 
@@ -324,8 +407,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;
@@ -363,12 +446,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 );
@@ -397,28 +480,28 @@ private:
         std::vector < NodeID > packed_v_t_path;
 
         *s_v_middle = UINT_MAX;
-        int upperBoundFor_s_v_Path = INT_MAX;
+        int upperBoundFor_s_vPath = INT_MAX;
         //compute path <s,..,v> by reusing forward search from s
         newBackwardHeap.Insert(candidate.node, 0, candidate.node);
         while (newBackwardHeap.Size() > 0) {
-            super::RoutingStep(newBackwardHeap, existingForwardHeap, s_v_middle, &upperBoundFor_s_v_Path, 2*offset, false);
+            super::RoutingStep(newBackwardHeap, existingForwardHeap, s_v_middle, &upperBoundFor_s_vPath, 2*offset, false);
         }
 
-        if(INT_MAX == upperBoundFor_s_v_Path)
+        if(INT_MAX == upperBoundFor_s_vPath)
             return false;
 
         //compute path <v,..,t> by reusing backward search from t
         *v_t_middle = UINT_MAX;
-        int upperBoundFor_v_t_Path = INT_MAX;
+        int upperBoundFor_v_tPath = INT_MAX;
         newForwardHeap.Insert(candidate.node, 0, candidate.node);
         while (newForwardHeap.Size() > 0) {
-            super::RoutingStep(newForwardHeap, existingBackwardHeap, v_t_middle, &upperBoundFor_v_t_Path, 2*offset, true);
+            super::RoutingStep(newForwardHeap, existingBackwardHeap, v_t_middle, &upperBoundFor_v_tPath, 2*offset, true);
         }
 
-        if(INT_MAX == upperBoundFor_v_t_Path)
+        if(INT_MAX == upperBoundFor_v_tPath)
             return false;
 
-        *lengthOfViaPath = upperBoundFor_s_v_Path + upperBoundFor_v_t_Path;
+        *lengthOfViaPath = upperBoundFor_s_vPath + upperBoundFor_v_tPath;
 
         //retrieve packed paths
         super::RetrievePackedPathFromHeap(existingForwardHeap, newBackwardHeap, *s_v_middle, packed_s_v_path);
@@ -438,8 +521,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 {
@@ -451,15 +534,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) {
@@ -475,12 +558,12 @@ private:
             }
         }
 
-        int lengthOfPathT_Test_Path = unpackedUntilDistance;
+        int lengthOfPathT_TestPath = unpackedUntilDistance;
         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 {
@@ -492,15 +575,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));
@@ -515,12 +598,14 @@ private:
             }
         }
 
-        lengthOfPathT_Test_Path += unpackedUntilDistance;
+        lengthOfPathT_TestPath += 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);
@@ -534,7 +619,7 @@ private:
                 super::RoutingStep(backward_heap3, forward_heap3, &middle, &_upperBound, offset, false);
             }
         }
-        return (_upperBound <= lengthOfPathT_Test_Path);
+        return (_upperBound <= lengthOfPathT_TestPath);
     }
 };
 

RoutingAlgorithms/BasicRoutingInterface.h

@@ -29,135 +29,180 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #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(
+                BOOST_ASSERT_MSG(!ed.shortcut, "edge must be a shortcut");
+                unpacked_path.push_back(
+                    PathData(
                         ed.id,
-                        _queryData.nodeHelpDesk->GetNameIndexFromEdgeID(ed.id),
-                        _queryData.nodeHelpDesk->GetTurnInstructionForEdgeID(ed.id),
+                        facade->GetNameIndexFromEdgeID(ed.id),
+                        facade->GetTurnInstructionForEdgeID(ed.id),
                         ed.distance
                     )
                 );
@@ -165,74 +210,112 @@ public:
         }
     }
 
-    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

@@ -28,176 +28,338 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef SHORTESTPATHROUTING_H_
 #define SHORTESTPATHROUTING_H_
 
-#include "BasicRoutingInterface.h"
+#include <boost/assert.hpp>
+#include <boost/foreach.hpp>
+
+#include "BasicRoutingInterface.h"
+#include "../DataStructures/SearchEngineData.h"
+#include "../typedefs.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()(
+        const 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<std::vector<NodeID> > packed_legs1(phantom_nodes_vector.size());
+        std::vector<std::vector<NodeID> > packed_legs2(phantom_nodes_vector.size());
 
-        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);
 
+        int current_leg = 0;
         //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, distance1-phantomNodePair.startPhantom.weight1, phantomNodePair.startPhantom.edgeBasedNode);
-                // INFO("fw1: " << phantomNodePair.startPhantom.edgeBasedNode << "´, w: " << -phantomNodePair.startPhantom.weight1);
-                forward_heap2.Insert(phantomNodePair.startPhantom.edgeBasedNode, distance1-phantomNodePair.startPhantom.weight1, phantomNodePair.startPhantom.edgeBasedNode);
-                // INFO("fw2: " << phantomNodePair.startPhantom.edgeBasedNode << "´, w: " << -phantomNodePair.startPhantom.weight1);
-           }
-            if(phantomNodePair.startPhantom.isBidirected() && searchFrom2ndStartNode) {
-                forward_heap1.Insert(phantomNodePair.startPhantom.edgeBasedNode+1, distance2-phantomNodePair.startPhantom.weight2, phantomNodePair.startPhantom.edgeBasedNode+1);
-                // INFO("fw1: " << phantomNodePair.startPhantom.edgeBasedNode+1 << "´, w: " << -phantomNodePair.startPhantom.weight2);
-                forward_heap2.Insert(phantomNodePair.startPhantom.edgeBasedNode+1, distance2-phantomNodePair.startPhantom.weight2, phantomNodePair.startPhantom.edgeBasedNode+1);
-                // INFO("fw2: " << phantomNodePair.startPhantom.edgeBasedNode+1 << "´, w: " << -phantomNodePair.startPhantom.weight2);
+            if(search_from_1st_node) {
+                forward_heap1.Insert(
+                    phantom_node_pair.startPhantom.edgeBasedNode,
+                    distance1-phantom_node_pair.startPhantom.weight1,
+                    phantom_node_pair.startPhantom.edgeBasedNode
+                );
+                forward_heap2.Insert(
+                    phantom_node_pair.startPhantom.edgeBasedNode,
+                    distance1-phantom_node_pair.startPhantom.weight1,
+                    phantom_node_pair.startPhantom.edgeBasedNode
+                );
+            }
+            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
+                );
+                forward_heap2.Insert(
+                    phantom_node_pair.startPhantom.edgeBasedNode+1,
+                    distance2-phantom_node_pair.startPhantom.weight2,
+                    phantom_node_pair.startPhantom.edgeBasedNode+1
+                );
             }
 
             //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 );
-           }
-            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_heap2.Insert(
+                    phantom_node_pair.targetPhantom.edgeBasedNode+1,
+                    phantom_node_pair.targetPhantom.weight2,
+                    phantom_node_pair.targetPhantom.edgeBasedNode+1
+                );
+            }
+
+            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_leg1;
+            std::vector<NodeID> temporary_packed_leg2;
+
+            BOOST_ASSERT( (unsigned)current_leg < packed_legs1.size() );
+            BOOST_ASSERT( (unsigned)current_leg < packed_legs2.size() );
+
+            if(INT_MAX != local_upper_bound1) {
+                super::RetrievePackedPathFromHeap(
+                    forward_heap1,
+                    reverse_heap1,
+                    middle1,
+                    temporary_packed_leg1
+                );
             }
 
-            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_leg2
+                );
             }
 
             //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_leg1.empty() ) {
+                temporary_packed_leg1.insert(
+                    temporary_packed_leg1.end(),
+                    temporary_packed_leg2.begin(),
+                    temporary_packed_leg2.end()
+                );
+                local_upper_bound1 = local_upper_bound2;
             }
-            if(0 == temporaryPackedPath2.size()) {
-                temporaryPackedPath2.insert(temporaryPackedPath2.end(), temporaryPackedPath1.begin(), temporaryPackedPath1.end());
-                _localUpperbound2 = _localUpperbound1;
+            if( temporary_packed_leg2.empty() ) {
+                temporary_packed_leg2.insert(
+                    temporary_packed_leg2.end(),
+                    temporary_packed_leg1.begin(),
+                    temporary_packed_leg1.end()
+                );
+                local_upper_bound2 = local_upper_bound1;
             }
 
-            assert(0 < temporaryPackedPath1.size() && 0 < temporaryPackedPath2.size());
+            // SimpleLogger().Write() << "fetched packed paths";
 
-            //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());
-                    } else {
-                        packedPath1.clear();
-                        packedPath1.insert(packedPath1.end(), packedPath2.begin(), packedPath2.end());
-                    }
-                } else  {
-                    //packed paths 1 and 2 may need to switch.
-                    if(*(packedPath1.end()-1) != *(temporaryPackedPath1.begin())) {
-                        packedPath1.swap(packedPath2);
-                        std::swap(distance1, distance2);
+            BOOST_ASSERT_MSG(
+                !temporary_packed_leg1.empty() ||
+                !temporary_packed_leg2.empty(),
+                "tempory packed paths empty"
+            );
+
+            BOOST_ASSERT(
+                (0 == current_leg) || !packed_legs1[current_leg-1].empty()
+            );
+            BOOST_ASSERT(
+                (0 == current_leg) || !packed_legs2[current_leg-1].empty()
+            );
+
+            if( 0 < current_leg ) {
+                const NodeID end_id_of_segment1 = packed_legs1[current_leg-1].back();
+                const NodeID end_id_of_segment2 = packed_legs2[current_leg-1].back();
+                BOOST_ASSERT( !temporary_packed_leg1.empty() );
+                const NodeID start_id_of_leg1 = temporary_packed_leg1.front();
+                const NodeID start_id_of_leg2 = temporary_packed_leg2.front();
+                if( ( end_id_of_segment1 != start_id_of_leg1 ) &&
+                    ( end_id_of_segment2 != start_id_of_leg2 )
+                ) {
+                    std::swap(temporary_packed_leg1, temporary_packed_leg2);
+                    std::swap(local_upper_bound1, local_upper_bound2);
+                }
+            }
+
+            // remove one path if both legs end at the same segment
+            if( 0 < current_leg ) {
+                const NodeID start_id_of_leg1 = temporary_packed_leg1.front();
+                const NodeID start_id_of_leg2 = temporary_packed_leg2.front();
+                if(
+                    start_id_of_leg1 == start_id_of_leg2
+                ) {
+                    const NodeID last_id_of_packed_legs1 = packed_legs1[current_leg-1].back();
+                    const NodeID last_id_of_packed_legs2 = packed_legs2[current_leg-1].back();
+                    if( start_id_of_leg1 != last_id_of_packed_legs1 ) {
+                        packed_legs1 = packed_legs2;
+                        BOOST_ASSERT(
+                            start_id_of_leg1 == temporary_packed_leg1.front()
+                        );
+                    } else
+                    if( start_id_of_leg2 != last_id_of_packed_legs2 ) {
+                        packed_legs2 = packed_legs1;
+                        BOOST_ASSERT(
+                            start_id_of_leg2 == temporary_packed_leg2.front()
+                        );
                     }
                 }
             }
-            packedPath1.insert(packedPath1.end(), temporaryPackedPath1.begin(), temporaryPackedPath1.end());
-            packedPath2.insert(packedPath2.end(), temporaryPackedPath2.begin(), temporaryPackedPath2.end());
+            BOOST_ASSERT(
+                packed_legs1.size() == packed_legs2.size()
+            );
 
-            if( (packedPath1.back() == packedPath2.back()) && phantomNodePair.targetPhantom.isBidirected() ) {
+            packed_legs1[current_leg].insert(
+                packed_legs1[current_leg].end(),
+                temporary_packed_leg1.begin(),
+                temporary_packed_leg1.end()
+            );
+            BOOST_ASSERT(packed_legs1[current_leg].size() == temporary_packed_leg1.size() );
+            packed_legs2[current_leg].insert(
+                packed_legs2[current_leg].end(),
+                temporary_packed_leg2.begin(),
+                temporary_packed_leg2.end()
+            );
+            BOOST_ASSERT(packed_legs2[current_leg].size() == temporary_packed_leg2.size() );
 
-                NodeID lastNodeID = packedPath2.back();
-                searchFrom1stStartNode &= !(lastNodeID == phantomNodePair.targetPhantom.edgeBasedNode+1);
-                searchFrom2ndStartNode &= !(lastNodeID == phantomNodePair.targetPhantom.edgeBasedNode);
+            if(
+                (packed_legs1[current_leg].back() == packed_legs2[current_leg].back()) &&
+                phantom_node_pair.targetPhantom.isBidirected()
+            ) {
+                const NodeID last_node_id = packed_legs2[current_leg].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);
+                BOOST_ASSERT( search_from_1st_node != search_from_2nd_node );
             }
 
-            distance1 = _localUpperbound1;
-            distance2 = _localUpperbound2;
+            distance1 = local_upper_bound1;
+            distance2 = local_upper_bound2;
+            ++current_leg;
         }
 
-        if(distance1 > distance2){
-            std::swap(packedPath1, packedPath2);
+        if( distance1 > distance2 ) {
+            std::swap( packed_legs1, packed_legs2 );
         }
-        remove_consecutive_duplicates_from_vector(packedPath1);
-        super::UnpackPath(packedPath1, rawRouteData.computedShortestPath);
-        rawRouteData.lengthOfShortestPath = std::min(distance1, distance2);
-        return;
+        raw_route_data.unpacked_path_segments.resize( packed_legs1.size() );
+        for(unsigned i = 0; i < packed_legs1.size(); ++i){
+            BOOST_ASSERT(packed_legs1.size() == raw_route_data.unpacked_path_segments.size() );
+            super::UnpackPath(
+                packed_legs1[i],
+                raw_route_data.unpacked_path_segments[i]
+            );
+        }
+        raw_route_data.lengthOfShortestPath = std::min(distance1, distance2);
     }
 };
 

Server/APIGrammar.h

@@ -42,7 +42,7 @@ struct APIGrammar : qi::grammar<Iterator> {
 
         zoom        = (-qi::lit('&')) >> qi::lit('z')            >> '=' >> qi::short_[boost::bind(&HandlerT::setZoomLevel, handler, ::_1)];
         output      = (-qi::lit('&')) >> qi::lit("output")       >> '=' >> string[boost::bind(&HandlerT::setOutputFormat, handler, ::_1)];
-        jsonp       = (-qi::lit('&')) >> qi::lit("jsonp")        >> '=' >> stringwithDot[boost::bind(&HandlerT::setJSONpParameter, handler, ::_1)];
+        jsonp       = (-qi::lit('&')) >> qi::lit("jsonp")        >> '=' >> stringwithPercent[boost::bind(&HandlerT::setJSONpParameter, handler, ::_1)];
         checksum    = (-qi::lit('&')) >> qi::lit("checksum")     >> '=' >> qi::int_[boost::bind(&HandlerT::setChecksum, handler, ::_1)];
         instruction = (-qi::lit('&')) >> qi::lit("instructions") >> '=' >> qi::bool_[boost::bind(&HandlerT::setInstructionFlag, handler, ::_1)];
         geometry    = (-qi::lit('&')) >> qi::lit("geometry")     >> '=' >> qi::bool_[boost::bind(&HandlerT::setGeometryFlag, handler, ::_1)];
@@ -53,16 +53,17 @@ struct APIGrammar : qi::grammar<Iterator> {
         alt_route   = (-qi::lit('&')) >> qi::lit("alt")          >> '=' >> qi::bool_[boost::bind(&HandlerT::setAlternateRouteFlag, handler, ::_1)];
         old_API     = (-qi::lit('&')) >> qi::lit("geomformat")   >> '=' >> string[boost::bind(&HandlerT::setDeprecatedAPIFlag, handler, ::_1)];
 
-        string        = +(qi::char_("a-zA-Z"));
-        stringwithDot = +(qi::char_("a-zA-Z0-9_.-"));
+        string            = +(qi::char_("a-zA-Z"));
+        stringwithDot     = +(qi::char_("a-zA-Z0-9_.-"));
+        stringwithPercent = +(qi::char_("a-zA-Z0-9_.-") | qi::char_('[') | qi::char_(']') | (qi::char_('%') >> qi::char_("0-9A-Z") >> qi::char_("0-9A-Z") ));
     }
+
     qi::rule<Iterator> api_call, query;
     qi::rule<Iterator, std::string()> service, zoom, output, string, jsonp, checksum, location, hint,
-                                      stringwithDot, language, instruction, geometry,
+                                      stringwithDot, stringwithPercent, language, instruction, geometry,
                                       cmp, alt_route, old_API;
 
     HandlerT * handler;
 };
 
-
 #endif /* APIGRAMMAR_H_ */

Server/BasicDatastructures.h

@@ -1,167 +0,0 @@
-/*
-
-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
-
-#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];
-        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.cpp

@@ -0,0 +1,240 @@
+/*
+
+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 "Connection.h"
+#include "RequestHandler.h"
+#include "RequestParser.h"
+
+#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 <string>
+#include <vector>
+
+namespace http {
+
+Connection::Connection(
+    boost::asio::io_service& io_service,
+    RequestHandler& handler
+) :
+    strand(io_service),
+    TCP_socket(io_service),
+    request_handler(handler),
+    request_parser(new RequestParser())
+{ }
+
+Connection::~Connection() {
+    delete request_parser;
+}
+
+boost::asio::ip::tcp::socket& Connection::socket() {
+    return TCP_socket;
+}
+
+/// Start the first asynchronous operation for the connection.
+void Connection::start() {
+    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)
+        )
+    );
+}
+
+void Connection::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) = request_parser->Parse(
+            request,
+            incoming_data_buffer.data(),
+            incoming_data_buffer.data() + bytes_transferred,
+            &compression_type
+        );
+
+        if( result ) {
+            request.endpoint = TCP_socket.remote_endpoint().address();
+            request_handler.handle_request(request, reply);
+
+            Header compression_header;
+            std::vector<char> compressed_output;
+            std::vector<boost::asio::const_buffer> output_buffer;
+            switch(compression_type) {
+            case deflateRFC1951:
+                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:
+                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:
+                reply.SetUncompressedSize();
+                output_buffer = reply.toBuffers();
+                boost::asio::async_write(
+                    TCP_socket,
+                    output_buffer,
+                    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(
+                TCP_socket,
+                reply.toBuffers(),
+                strand.wrap(
+                    boost::bind(
+                        &Connection::handle_write,
+                        this->shared_from_this(),
+                        boost::asio::placeholders::error
+                    )
+                )
+            );
+        } else {
+            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 Connection::handle_write(const boost::system::error_code& e) {
+    if (!e) {
+        // Initiate graceful connection closure.
+        boost::system::error_code ignoredEC;
+        TCP_socket.shutdown(
+            boost::asio::ip::tcp::socket::shutdown_both,
+            ignoredEC
+        );
+    }
+}
+
+void Connection::compressBufferCollection(
+    std::vector<std::string> uncompressed_data,
+    CompressionType compression_type,
+    std::vector<char> & compressed_data
+) {
+    boost::iostreams::gzip_params compression_parameters;
+
+    compression_parameters.level = boost::iostreams::zlib::best_speed;
+    if ( deflateRFC1951 == compression_type ) {
+        compression_parameters.noheader = true;
+    }
+
+    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;
+    }
+
+    compressing_stream.reset();
+}
+}

Server/Connection.h

@@ -28,24 +28,25 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef CONNECTION_H
 #define CONNECTION_H
 
-#include "BasicDatastructures.h"
-#include "RequestHandler.h"
-#include "RequestParser.h"
+#include "Http/CompressionType.h"
+#include "Http/Request.h"
+
+#include <osrm/Reply.h>
 
 #include <boost/array.hpp>
 #include <boost/asio.hpp>
-#include <boost/assert.hpp>
-#include <boost/bind.hpp>
 #include <boost/enable_shared_from_this.hpp>
 #include <boost/noncopyable.hpp>
-#include <boost/shared_ptr.hpp>
-
-#include <zlib.h>
 
+#include <string>
 #include <vector>
 
+class RequestHandler;
+
 namespace http {
 
+class RequestParser;
+
 /// Represents a single connection from a client.
 class Connection : 	public boost::enable_shared_from_this<Connection>,
 					private boost::noncopyable {
@@ -53,235 +54,36 @@ public:
 	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 TCP_socket;
-	}
+	~Connection();
+
+	boost::asio::ip::tcp::socket& socket();
 
 	/// Start the first asynchronous operation for the connection.
-	void start() {
-	    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)
-	    	)
-	    );
-	}
+	void start();
 
 private:
 	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) = request_parser.Parse(
-				request,
-				incoming_data_buffer.data(),
-				incoming_data_buffer.data() + bytes_transferred,
-				&compression_type
-			);
-
-			if( result ) {
-				request.endpoint = TCP_socket.remote_endpoint().address();
-				request_handler.handle_request(request, reply);
-
-				Header compression_header;
-				std::vector<unsigned char> compressed_output;
-				std::vector<boost::asio::const_buffer> output_buffer;
-				switch(compression_type) {
-				case deflateRFC1951:
-					compression_header.name = "Content-Encoding";
-					compression_header.value = "deflate";
-					reply.headers.insert(
-						reply.headers.begin(),
-						compression_header
-					);
-					compressCharArray(
-						reply.content.c_str(),
-						reply.content.length(),
-						compressed_output,
-						compression_type
-					);
-					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:
-					compression_header.name = "Content-Encoding";
-					compression_header.value = "gzip";
-					reply.headers.insert(
-						reply.headers.begin(),
-						compression_header
-					);
-					compressCharArray(
-						reply.content.c_str(),
-						reply.content.length(),
-						compressed_output,
-						compression_type
-					);
-					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(
-						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(
-					TCP_socket,
-					reply.toBuffers(),
-					strand.wrap(
-						boost::bind(
-							&Connection::handle_write,
-							this->shared_from_this(),
-							boost::asio::placeholders::error
-						)
-					)
-				);
-			} else {
-				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 handle_write(const boost::system::error_code& e) {
-		if (!e) {
-			// Initiate graceful connection closure.
-			boost::system::error_code ignoredEC;
-			TCP_socket.shutdown(
-				boost::asio::ip::tcp::socket::shutdown_both,
-				ignoredEC
-			);
-		}
-	}
+	void handle_write(const boost::system::error_code& e);
 
-	// 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);
-	}
+	void compressBufferCollection(
+		std::vector<std::string> uncompressed_data,
+		CompressionType compression_type,
+	   	std::vector<char> & compressed_data
+   	);
 
 	boost::asio::io_service::strand strand;
 	boost::asio::ip::tcp::socket TCP_socket;
 	RequestHandler& request_handler;
 	boost::array<char, 8192> incoming_data_buffer;
 	Request request;
-	RequestParser request_parser;
+	RequestParser * request_parser;
 	Reply reply;
 };
 

Server/DataStructures/BaseDataFacade.h

@@ -0,0 +1,123 @@
+/*
+
+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/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 <osrm/Coordinate.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 EscapeJSONString(temporary_string);
+    }
+
+    virtual std::string GetTimestamp() const = 0;
+};
+
+#endif // QUERY_DATA_FACADE_H

Server/DataStructures/InternalDataFacade.h

@@ -0,0 +1,397 @@
+/*
+
+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/OriginalEdgeData.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/ProgramOptions.h"
+#include "../../Util/SimpleLogger.h"
+
+#include <osrm/Coordinate.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.via_node;
+            m_name_ID_list[i]  = current_edge_data.name_id;
+            m_turn_instruction_list[i] = current_edge_data.turn_instruction;
+        }
+        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,183 +0,0 @@
-/*
-
-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 "QueryObjectsStorage.h"
-
-QueryObjectsStorage::QueryObjectsStorage( const ServerPaths & paths ) {
-	if( paths.find("hsgrdata") == paths.end() ) {
-		throw OSRMException("no hsgr file given in ini file");
-	}
-	if( paths.find("ramindex") == paths.end() ) {
-		throw OSRMException("no ram index file given in ini file");
-	}
-	if( paths.find("fileindex") == paths.end() ) {
-		throw OSRMException("no mem index file given in ini file");
-	}
-	if( paths.find("nodesdata") == paths.end() ) {
-		throw OSRMException("no nodes file given in ini file");
-	}
-	if( paths.find("edgesdata") == paths.end() ) {
-		throw OSRMException("no edges file given in ini file");
-	}
-	if( paths.find("namesdata") == paths.end() ) {
-		throw OSRMException("no names file given in ini file");
-	}
-
-	SimpleLogger().Write() << "loading graph data";
-	//Deserialize road network graph
-
-	ServerPaths::const_iterator paths_iterator = paths.find("hsgrdata");
-	BOOST_ASSERT(paths.end() != paths_iterator);
-	const std::string & hsgr_data_string = paths_iterator->second.string();
-
-	std::vector< QueryGraph::_StrNode> node_list;
-	std::vector< QueryGraph::_StrEdge> edge_list;
-	const int number_of_nodes = readHSGRFromStream(
-		hsgr_data_string,
-		node_list,
-		edge_list,
-		&check_sum
-	);
-
-	SimpleLogger().Write() << "Data checksum is " << check_sum;
-	graph = new QueryGraph(node_list, edge_list);
-	BOOST_ASSERT(0 == node_list.size());
-	BOOST_ASSERT(0 == edge_list.size());
-
-	paths_iterator = paths.find("timestamp");
-
-	if(paths.end() != paths_iterator) {
-	    SimpleLogger().Write() << "Loading Timestamp";
-    	const std::string & timestamp_string = paths_iterator->second.string();
-
-	    boost::filesystem::ifstream time_stamp_instream(timestamp_string);
-	    if( !time_stamp_instream.good() ) {
-	        SimpleLogger().Write(logWARNING) << timestamp_string << " not found";
-	    }
-
-	    getline(time_stamp_instream, timestamp);
-	    time_stamp_instream.close();
-	}
-	if(!timestamp.length()) {
-	    timestamp = "n/a";
-	}
-	if(25 < timestamp.length()) {
-	    timestamp.resize(25);
-	}
-    SimpleLogger().Write() << "Loading auxiliary information";
-
-    paths_iterator = paths.find("ramindex");
-    BOOST_ASSERT(paths.end() != paths_iterator);
-    const std::string & ram_index_string = paths_iterator->second.string();
-	paths_iterator = paths.find("fileindex");
-    BOOST_ASSERT(paths.end() != paths_iterator);
-	const std::string & file_index_string = paths_iterator->second.string();
-	paths_iterator = paths.find("nodesdata");
-    BOOST_ASSERT(paths.end() != paths_iterator);
-	const std::string & nodes_data_string = paths_iterator->second.string();
-	paths_iterator = paths.find("edgesdata");
-    BOOST_ASSERT(paths.end() != paths_iterator);
-	const std::string & edges_data_string = paths_iterator->second.string();
-
-    //Init nearest neighbor data structure
-	nodeHelpDesk = new NodeInformationHelpDesk(
-		ram_index_string,
-		file_index_string,
-		nodes_data_string,
-		edges_data_string,
-		number_of_nodes,
-		check_sum
-	);
-
-	//deserialize street name list
-	SimpleLogger().Write() << "Loading names index";
-
-	paths_iterator = paths.find("namesdata");
-    BOOST_ASSERT(paths.end() != paths_iterator);
-	const std::string & names_data_string = paths_iterator->second.string();
-    if ( !boost::filesystem::exists( paths_iterator->second ) ) {
-        throw OSRMException("names file does not exist");
-    }
-    if ( 0 == boost::filesystem::file_size( paths_iterator->second ) ) {
-        throw OSRMException("names file is empty");
-    }
-
-	boost::filesystem::ifstream name_stream(names_data_string, std::ios::binary);
-	unsigned size = 0;
-	name_stream.read((char *)&size, sizeof(unsigned));
-	BOOST_ASSERT_MSG(0 != size, "name file broken");
-
-	m_name_begin_indices.resize(size);
-	name_stream.read((char*)&m_name_begin_indices[0], size*sizeof(unsigned));
-	name_stream.read((char *)&size, sizeof(unsigned));
-	BOOST_ASSERT_MSG(0 != size, "name file broken");
-
-	m_names_char_list.resize(size+1); //+1 is sentinel/dummy element
-	name_stream.read((char *)&m_names_char_list[0], size*sizeof(char));
-	BOOST_ASSERT_MSG(0 != m_names_char_list.size(), "could not load any names");
-
-	name_stream.close();
-	SimpleLogger().Write() << "All query data structures loaded";
-}
-
-void QueryObjectsStorage::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()
-	);
-}
-
-QueryObjectsStorage::~QueryObjectsStorage() {
-	delete graph;
-	delete nodeHelpDesk;
-}

Server/DataStructures/QueryObjectsStorage.h

@@ -1,64 +0,0 @@
-/*
-
-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 QUERYOBJECTSSTORAGE_H_
-#define QUERYOBJECTSSTORAGE_H_
-
-#include "../../Util/GraphLoader.h"
-#include "../../Util/OSRMException.h"
-#include "../../Util/ProgramOptions.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<char>                           m_names_char_list;
-    std::vector<unsigned>                       m_name_begin_indices;
-    QueryGraph                                * graph;
-    std::string                                 timestamp;
-    unsigned                                    check_sum;
-
-    void GetName( const unsigned name_id, std::string & result ) const;
-
-    QueryObjectsStorage( const ServerPaths & paths );
-    ~QueryObjectsStorage();
-};
-
-#endif /* QUERYOBJECTSSTORAGE_H_ */

Server/DataStructures/SharedBarriers.h

@@ -0,0 +1,72 @@
+/*
+
+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_BARRIER_H
+#define SHARED_BARRIER_H
+
+#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;
+};
+
+#endif //SHARED_BARRIER_H

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_ 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"
+        );
+        const unsigned begin_index = m_name_begin_indices[name_id];
+        const 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,230 @@
+/*
+
+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/QueryEdge.h"
+#include "../../DataStructures/StaticGraph.h"
+#include "../../DataStructures/StaticRTree.h"
+#include "../../DataStructures/TurnInstructions.h"
+
+#include "../../typedefs.h"
+
+#include <osrm/Coordinate.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

@@ -24,12 +24,18 @@ ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 */
-#include <cstdlib>
 
-int main( int argc, char* argv[] ) {
-	size_t size = sizeof(void*);
-	if ( 4 == size ) {
-		return 0;
-	}
-	return 1;
-}
+#ifndef BASIC_DATASTRUCTURES_H
+#define BASIC_DATASTRUCTURES_H
+
+namespace http {
+
+enum CompressionType {
+    noCompression,
+    gzipRFC1952,
+    deflateRFC1951
+};
+
+} // namespace http
+
+#endif //BASIC_DATASTRUCTURES_H

Server/Http/Reply.cpp

@@ -0,0 +1,135 @@
+/*
+
+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 <boost/foreach.hpp>
+
+#include <osrm/Reply.h>
+
+#include "../../Util/StringUtil.h"
+
+namespace http {
+
+void Reply::setSize(const unsigned size) {
+    BOOST_FOREACH ( Header& h,  headers) {
+        if("Content-Length" == h.name) {
+            std::string sizeString;
+            intToString(size,h.value);
+        }
+    }
+}
+
+// Sets the size of the uncompressed output.
+void Reply::SetUncompressedSize()
+{
+    unsigned uncompressed_size = 0;
+    BOOST_FOREACH ( const std::string & current_line, content)
+    {
+        uncompressed_size += current_line.size();
+    }
+    setSize(uncompressed_size);
+}
+
+
+std::vector<boost::asio::const_buffer> Reply::toBuffers(){
+    std::vector<boost::asio::const_buffer> buffers;
+    buffers.push_back(ToBuffer(status));
+    BOOST_FOREACH(const Header & h, headers) {
+        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));
+    BOOST_FOREACH(const std::string & line, content) {
+        buffers.push_back(boost::asio::buffer(line));
+    }
+    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];
+        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.clear();
+    rep.content.push_back( 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;
+}
+
+std::string Reply::ToString(Reply::status_type status) {
+    if (Reply::ok == status)
+    {
+        return okHTML;
+    }
+    if (Reply::badRequest == status)
+    {
+        return badRequestHTML;
+    }
+    return internalServerErrorHTML;
+}
+
+boost::asio::const_buffer Reply::ToBuffer(Reply::status_type status) {
+    if (Reply::ok == status)
+    {
+        return boost::asio::buffer(okString);
+    }
+    if (Reply::internalServerError == status)
+    {
+        return boost::asio::buffer(internalServerErrorString);
+    }
+    return boost::asio::buffer(badRequestString);
+}
+
+
+Reply::Reply() : status(ok) {
+
+}
+
+}

Server/Http/Request.h

@@ -0,0 +1,48 @@
+/*
+
+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 REQUEST_H
+#define REQUEST_H
+
+#include "../../Util/StringUtil.h"
+
+#include <boost/asio.hpp>
+
+#include <string>
+
+namespace http {
+
+struct Request {
+	std::string uri;
+	std::string referrer;
+	std::string agent;
+	boost::asio::ip::address endpoint;
+};
+
+} // namespace http
+
+#endif //REQUEST_H

Server/RequestHandler.cpp

@@ -0,0 +1,113 @@
+/*
+
+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 "APIGrammar.h"
+#include "RequestHandler.h"
+
+#include "../Library/OSRM.h"
+#include "../Util/SimpleLogger.h"
+#include "../Util/StringUtil.h"
+#include "../typedefs.h"
+
+#include <osrm/RouteParameters.h>
+
+#include <boost/foreach.hpp>
+
+#include <algorithm>
+#include <iostream>
+
+RequestHandler::RequestHandler() : routing_machine(NULL) { }
+
+void RequestHandler::handle_request(const http::Request& req, http::Reply& rep){
+    //parse command
+    try {
+        std::string request;
+        URIDecode(req.uri, request);
+
+        time_t ltime;
+        struct tm *Tm;
+
+        ltime=time(NULL);
+        Tm=localtime(&ltime);
+
+        SimpleLogger().Write() <<
+            (Tm->tm_mday < 10 ? "0" : "" )  << Tm->tm_mday    << "-" <<
+            (Tm->tm_mon+1 < 10 ? "0" : "" ) << (Tm->tm_mon+1) << "-" <<
+            1900+Tm->tm_year << " " << (Tm->tm_hour < 10 ? "0" : "" ) <<
+            Tm->tm_hour << ":" << (Tm->tm_min < 10 ? "0" : "" ) <<
+            Tm->tm_min << ":" << (Tm->tm_sec < 10 ? "0" : "" ) <<
+            Tm->tm_sec << " " << req.endpoint.to_string() << " " <<
+            req.referrer << ( 0 == req.referrer.length() ? "- " :" ") <<
+            req.agent << ( 0 == req.agent.length() ? "- " :" ") << request;
+
+        RouteParameters route_parameters;
+        APIGrammarParser api_parser(&route_parameters);
+
+        std::string::iterator it = request.begin();
+        const bool result = boost::spirit::qi::parse(
+            it,
+            request.end(),
+            api_parser
+        );
+
+        if ( !result || (it != request.end()) ) {
+            rep = http::Reply::StockReply(http::Reply::badRequest);
+            const int position = std::distance(request.begin(), it);
+            std::string tmp_position_string;
+            intToString(position, tmp_position_string);
+            rep.content.push_back(
+                "Input seems to be malformed close to position "
+                "<br><pre>"
+            );
+            rep.content.push_back( request );
+            rep.content.push_back(tmp_position_string);
+            rep.content.push_back("<br>");
+            const unsigned end = std::distance(request.begin(), it);
+            for(unsigned i = 0; i < end; ++i) {
+                rep.content.push_back("&nbsp;");
+            }
+            rep.content.push_back("^<br></pre>");
+        } else {
+            //parsing done, lets call the right plugin to handle the request
+            BOOST_ASSERT_MSG(
+                routing_machine != NULL,
+                "pointer not init'ed"
+            );
+            routing_machine->RunQuery(route_parameters, rep);
+            return;
+        }
+    } catch(const std::exception& e) {
+        rep = http::Reply::StockReply(http::Reply::internalServerError);
+        SimpleLogger().Write(logWARNING) <<
+            "[server error] code: " << e.what() << ", uri: " << req.uri;
+        return;
+    }
+}
+
+void RequestHandler::RegisterRoutingMachine(OSRM * osrm) {
+    routing_machine = osrm;
+}

Server/RequestHandler.h

@@ -28,93 +28,28 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef REQUEST_HANDLER_H
 #define REQUEST_HANDLER_H
 
-#include "APIGrammar.h"
-#include "BasicDatastructures.h"
-#include "DataStructures/RouteParameters.h"
-#include "../Library/OSRM.h"
-#include "../Util/SimpleLogger.h"
-#include "../Util/StringUtil.h"
-#include "../typedefs.h"
+#include "Http/Request.h"
+
+#include <osrm/Reply.h>
 
-#include <boost/foreach.hpp>
 #include <boost/noncopyable.hpp>
 
-#include <algorithm>
-#include <iostream>
-#include <iterator>
 #include <string>
 
+template <typename Iterator, class HandlerT>
+struct APIGrammar;
+struct RouteParameters;
+class OSRM;
+
 class RequestHandler : private boost::noncopyable {
+
 public:
     typedef APIGrammar<std::string::iterator, RouteParameters> APIGrammarParser;
-    explicit RequestHandler() : routing_machine(NULL) { }
 
-    void handle_request(const http::Request& req, http::Reply& rep){
-        //parse command
-        try {
-            std::string request(req.uri);
+    RequestHandler();
 
-            time_t ltime;
-            struct tm *Tm;
-
-            ltime=time(NULL);
-            Tm=localtime(&ltime);
-
-            SimpleLogger().Write() <<
-                (Tm->tm_mday < 10 ? "0" : "" )  << Tm->tm_mday    << "-" <<
-                (Tm->tm_mon+1 < 10 ? "0" : "" ) << (Tm->tm_mon+1) << "-" <<
-                1900+Tm->tm_year << " " << (Tm->tm_hour < 10 ? "0" : "" ) <<
-                Tm->tm_hour << ":" << (Tm->tm_min < 10 ? "0" : "" ) <<
-                Tm->tm_min << ":" << (Tm->tm_sec < 10 ? "0" : "" ) <<
-                Tm->tm_sec << " " << req.endpoint.to_string() << " " <<
-                req.referrer << ( 0 == req.referrer.length() ? "- " :" ") <<
-                req.agent << ( 0 == req.agent.length() ? "- " :" ") << req.uri;
-
-            RouteParameters routeParameters;
-            APIGrammarParser apiParser(&routeParameters);
-
-            std::string::iterator it = request.begin();
-            const bool result = boost::spirit::qi::parse(
-                it,
-                request.end(),
-                apiParser
-            );
-
-            if ( !result || (it != request.end()) ) {
-                rep = http::Reply::stockReply(http::Reply::badRequest);
-                const int position = std::distance(request.begin(), it);
-                std::string tmp_position_string;
-                intToString(position, tmp_position_string);
-                rep.content += "Input seems to be malformed close to position ";
-                rep.content += "<br><pre>";
-                rep.content += request;
-                rep.content += tmp_position_string;
-                rep.content += "<br>";
-                const unsigned end = std::distance(request.begin(), it);
-                for(unsigned i = 0; i < end; ++i) {
-                    rep.content += "&nbsp;";
-                }
-                rep.content += "^<br></pre>";
-            } else {
-                //parsing done, lets call the right plugin to handle the request
-                BOOST_ASSERT_MSG(
-                    routing_machine != NULL,
-                    "pointer not init'ed"
-                );
-                routing_machine->RunQuery(routeParameters, rep);
-                return;
-            }
-        } catch(std::exception& e) {
-            rep = http::Reply::stockReply(http::Reply::internalServerError);
-            SimpleLogger().Write(logWARNING) <<
-                "[server error] code: " << e.what() << ", uri: " << req.uri;
-            return;
-        }
-    };
-
-    void RegisterRoutingMachine(OSRM * osrm) {
-        routing_machine = osrm;
-    }
+    void handle_request(const http::Request& req, http::Reply& rep);
+    void RegisterRoutingMachine(OSRM * osrm);
 
 private:
     OSRM * routing_machine;

Server/RequestParser.cpp

@@ -0,0 +1,271 @@
+/*
+
+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 "Http/Request.h"
+#include "RequestParser.h"
+
+namespace http {
+
+RequestParser::RequestParser() : state_(method_start) { }
+
+void RequestParser::Reset() { state_ = method_start; }
+
+boost::tuple<boost::tribool, char*> RequestParser::Parse(
+    Request& req,
+    char* begin,
+    char* end,
+    http::CompressionType * compressionType
+) {
+    while (begin != end) {
+        boost::tribool result = consume(req, *begin++, compressionType);
+        if (result || !result){
+            return boost::make_tuple(result, begin);
+        }
+    }
+    boost::tribool result = boost::indeterminate;
+    return boost::make_tuple(result, begin);
+}
+
+boost::tribool RequestParser::consume(
+    Request& req, char input,
+    http::CompressionType * compressionType
+) {
+    switch (state_) {
+    case method_start:
+        if (!isChar(input) || isCTL(input) || isTSpecial(input)) {
+            return false;
+        } else {
+            state_ = method;
+            return boost::indeterminate;
+        }
+    case method:
+        if (input == ' ') {
+            state_ = uri;
+            return boost::indeterminate;
+        } else if (!isChar(input) || isCTL(input) || isTSpecial(input)) {
+            return false;
+        } else {
+            return boost::indeterminate;
+        }
+    case uri_start:
+        if (isCTL(input)) {
+            return false;
+        } else {
+            state_ = uri;
+            req.uri.push_back(input);
+            return boost::indeterminate;
+        }
+    case uri:
+        if (input == ' ') {
+            state_ = http_version_h;
+            return boost::indeterminate;
+        } else if (isCTL(input)) {
+            return false;
+        } else {
+            req.uri.push_back(input);
+            return boost::indeterminate;
+        }
+    case http_version_h:
+        if (input == 'H') {
+            state_ = http_version_t_1;
+            return boost::indeterminate;
+        } else {
+            return false;
+        }
+    case http_version_t_1:
+        if (input == 'T') {
+            state_ = http_version_t_2;
+            return boost::indeterminate;
+        } else {
+            return false;
+        }
+    case http_version_t_2:
+        if (input == 'T') {
+            state_ = http_version_p;
+            return boost::indeterminate;
+        } else {
+            return false;
+        }
+    case http_version_p:
+        if (input == 'P') {
+            state_ = http_version_slash;
+            return boost::indeterminate;
+        } else {
+            return false;
+        }
+    case http_version_slash:
+        if (input == '/') {
+            state_ = http_version_major_start;
+            return boost::indeterminate;
+        } else {
+            return false;
+        }
+    case http_version_major_start:
+        if (isDigit(input)) {
+            state_ = http_version_major;
+            return boost::indeterminate;
+        } else {
+            return false;
+        }
+    case http_version_major:
+        if (input == '.') {
+            state_ = http_version_minor_start;
+            return boost::indeterminate;
+        } else if (isDigit(input)) {
+            return boost::indeterminate;
+        } else {
+            return false;
+        }
+    case http_version_minor_start:
+        if (isDigit(input)) {
+            state_ = http_version_minor;
+            return boost::indeterminate;
+        } else {
+            return false;
+        }
+    case http_version_minor:
+        if (input == '\r') {
+            state_ = expecting_newline_1;
+            return boost::indeterminate;
+        } else if (isDigit(input)) {
+            return boost::indeterminate;
+        }
+        else {
+            return false;
+        }
+    case expecting_newline_1:
+        if (input == '\n') {
+            state_ = header_line_start;
+            return boost::indeterminate;
+        } else {
+            return false;
+        }
+    case header_line_start:
+        if(header.name == "Accept-Encoding") {
+            /* giving gzip precedence over deflate */
+            if(header.value.find("deflate") != std::string::npos)
+                *compressionType = deflateRFC1951;
+            if(header.value.find("gzip") != std::string::npos)
+                *compressionType = gzipRFC1952;
+        }
+
+        if("Referer" == header.name)
+            req.referrer = header.value;
+
+        if("User-Agent" == header.name)
+            req.agent = header.value;
+
+        if (input == '\r') {
+            state_ = expecting_newline_3;
+            return boost::indeterminate;
+        } else if (!isChar(input) || isCTL(input) || isTSpecial(input)) {
+            return false;
+        } else {
+            state_ = header_name;
+            header.Clear();
+            header.name.push_back(input);
+            return boost::indeterminate;
+        }
+    case header_lws:
+        if (input == '\r') {
+            state_ = expecting_newline_2;
+            return boost::indeterminate;
+        } else if (input == ' ' || input == '\t') {
+            return boost::indeterminate;
+        }
+        else if (isCTL(input)) {
+            return false;
+        } else {
+            state_ = header_value;
+            return boost::indeterminate;
+        }
+    case header_name:
+        if (input == ':') {
+            state_ = space_before_header_value;
+            return boost::indeterminate;
+        } else if (!isChar(input) || isCTL(input) || isTSpecial(input)) {
+            return false;
+        } else {
+            header.name.push_back(input);
+            return boost::indeterminate;
+        }
+    case space_before_header_value:
+        if (input == ' ') {
+            state_ = header_value;
+            return boost::indeterminate;
+        } else {
+            return false;
+        }
+    case header_value:
+        if (input == '\r') {
+            state_ = expecting_newline_2;
+            return boost::indeterminate;
+        } else if (isCTL(input)) {
+            return false;
+        } else {
+            header.value.push_back(input);
+            return boost::indeterminate;
+        }
+    case expecting_newline_2:
+        if (input == '\n') {
+            state_ = header_line_start;
+            return boost::indeterminate;
+        } else {
+            return false;
+        }
+    case expecting_newline_3:
+        return (input == '\n');
+    default:
+        return false;
+    }
+}
+
+inline bool RequestParser::isChar(int c) {
+    return c >= 0 && c <= 127;
+}
+
+inline bool RequestParser::isCTL(int c) {
+    return (c >= 0 && c <= 31) || (c == 127);
+}
+
+inline bool RequestParser::isTSpecial(int c) {
+    switch (c) {
+    case '(': case ')': case '<': case '>': case '@':
+    case ',': case ';': case ':': case '\\': case '"':
+    case '/': case '[': case ']': case '?': case '=':
+    case '{': case '}': case ' ': case '\t':
+        return true;
+    default:
+        return false;
+    }
+}
+
+inline bool RequestParser::isDigit(int c) {
+    return c >= '0' && c <= '9';
+}
+
+}