extended access handling

This adds a few more configuration options for a more flexible access
tag handling:

accessTags -
  replaces accessTag and is an ordered list of access tags to take into
  account. The first tag in the list found will determine the access.
  This allows to model OSM's access hierarchy where a more specific
  access tag might override a more general one.
accessForbiddenKeys -
  unordered list of values that disallow access (similar to
  accessRestrictionKeys). Replaces hardcoded values in extractor.
accessForbiddenDefault -
  unordered list of highway types where access is forbidden unless an
  explicit positiv access tag is given. Replaces the current track
  hack.

DataStructures/ExtractorCallBacks.h

@@ -148,12 +148,9 @@ public:
         std::string junction( w.keyVals.Find("junction") );
         std::string route( w.keyVals.Find("route") );
         int maxspeed( parseMaxspeed(w.keyVals.Find("maxspeed")) );
-        std::string access( w.keyVals.Find("access") );
-        std::string accessTag( w.keyVals.Find(settings.accessTag) );
         std::string man_made( w.keyVals.Find("man_made") );
         std::string barrier( w.keyVals.Find("barrier") );
         std::string oneway( w.keyVals.Find("oneway"));
-        std::string onewayClass( w.keyVals.Find("oneway:"+settings.accessTag));
         std::string cycleway( w.keyVals.Find("cycleway"));
         std::string duration ( w.keyVals.Find("duration"));
         std::string service (w.keyVals.Find("service"));
@@ -191,8 +188,28 @@ public:
             }
         }
 
+        //determine the access value
+        std::string access;
+        std::string onewayClass;
+        std::string accessTag;
+        BOOST_FOREACH(std::string & s, settings.accessTags) {
+            access = std::string(w.keyVals.Find(s));
+            if(0 < access.size()) {
+                accessTag = s;
+                onewayClass = std::string(w.keyVals.Find("oneway:"+access));
+                break;
+            }
+        }
+
+        if(0 < access.size()) {
+            // handle ways with default access = no
+            if(settings.accessForbiddenDefault.find(access) != settings.accessForbiddenDefault.end()) {
+                access = std::string("no");
+            }
+        }
+
         //Is the highway tag listed as usable way?
-        if(("track" == highway && ("yes" == access || "yes" == accessTag)) || ("track" != highway && (0 < settings[highway] || "yes" == accessTag || "designated" == accessTag) )) {
+        if(0 < settings[highway] || "yes" == access || "designated" == access) {
             if(!w.isDurationSet) {
                 if(0 < settings[highway]) {
                     if(0 < maxspeed)
@@ -217,7 +234,7 @@ public:
             //Okay, do we have access to that way?
             if(0 < access.size()) { //fastest way to check for non-empty string
                 //If access is forbidden, we don't want to route there.
-                if(access == "no" || access == "agricultural" || access == "forestry" || access == "delivery") { //Todo: this is still hard coded
+                if(settings.accessForbiddenKeys.find(access) != settings.accessForbiddenKeys.end()) {
                     w.access = false;
                 }
                 if(settings.accessRestrictionKeys.find(access) != settings.accessRestrictionKeys.end()) {
@@ -231,7 +248,7 @@ public:
                 }
             }
 
-            if("no" == accessTag) {
+            if("no" == access) {
                 return true;
             }
 
@@ -244,7 +261,7 @@ public:
                     w.direction = _Way::opposite;
                 } else if( oneway == "no" || oneway == "0" || oneway == "false" ) {
                     w.direction = _Way::bidirectional;
-                } else if( settings.accessTag == "bicycle" && (cycleway == "opposite" || cycleway == "opposite_track" || cycleway == "opposite_lane") ) {
+                } else if( accessTag == "bicycle" && (cycleway == "opposite" || cycleway == "opposite_track" || cycleway == "opposite_lane") ) {
                     w.direction = _Way::bidirectional;
                 } else if( oneway == "-1") {
                     w.direction  = _Way::opposite;

DataStructures/ExtractorStructs.h

@@ -270,7 +270,7 @@ struct CmpWayByID : public std::binary_function<_WayIDStartAndEndEdge, _WayIDSta
 };
 
 struct Settings {
-    Settings() : obeyBollards(true), obeyOneways(true), useRestrictions(true), ignoreAreas(false), accessTag("motorcar"), defaultSpeed(30), takeMinimumOfSpeeds(false), excludeFromGrid("ferry") {}
+    Settings() : obeyBollards(true), obeyOneways(true), useRestrictions(true), ignoreAreas(false), defaultSpeed(30), takeMinimumOfSpeeds(false), excludeFromGrid("ferry") {}
     StringToIntPairMap speedProfile;
     int operator[](const std::string & param) const {
         if(speedProfile.find(param) == speedProfile.end())
@@ -294,12 +294,14 @@ struct Settings {
     bool obeyOneways;
     bool useRestrictions;
     bool ignoreAreas;
-    std::string accessTag;
+    std::vector<std::string> accessTags;
     int defaultSpeed;
     bool takeMinimumOfSpeeds;
     std::string excludeFromGrid;
     boost::unordered_map<std::string, bool> accessRestrictedService;
     boost::unordered_map<std::string, bool> accessRestrictionKeys;
+    boost::unordered_map<std::string, bool> accessForbiddenKeys;
+    boost::unordered_map<std::string, bool> accessForbiddenDefault;
 };
 
 struct Cmp : public std::binary_function<NodeID, NodeID, bool> {

extractor.cpp

@@ -137,8 +137,10 @@ int main (int argc, char *argv[]) {
             } else if(name == "useRestrictions") {
                 if(value == "no")
                     settings.useRestrictions = false;
-            } else if(name == "accessTag") {
+            } else if(name == "accessTags") {
-                settings.accessTag = value;
+                std::vector<std::string> tokens;
+                stringSplit(value, ',', tokens);
+                settings.accessTags = tokens;
             } else if(name == "excludeFromGrid") {
                 settings.excludeFromGrid = value;
             } else if(name == "defaultSpeed") {
@@ -166,6 +168,24 @@ int main (int argc, char *argv[]) {
                     INFO("adding " << s << " to accessRestrictionKeys");
                     settings.accessRestrictionKeys.insert(std::make_pair(s, true));
                 }
+            } else if( name == "accessForbiddenKeys") {
+                //split value at commas
+                std::vector<std::string> tokens;
+                stringSplit(value, ',', tokens);
+                //put each value into map
+                BOOST_FOREACH(std::string & s, tokens) {
+                    INFO("adding " << s << " to accessForbiddenKeys");
+                    settings.accessForbiddenKeys.insert(std::make_pair(s, true));
+                }
+            } else if( name == "accessForbiddenDefault") {
+                //split value at commas
+                std::vector<std::string> tokens;
+                stringSplit(value, ',', tokens);
+                //put each value into map
+                BOOST_FOREACH(std::string & s, tokens) {
+                    INFO("adding " << s << " to accessForbiddenDefault");
+                    settings.accessForbiddenDefault.insert(std::make_pair(s, true));
+                }
             }
             settings.speedProfile[name] = std::make_pair(std::atoi(value.c_str()), settings.speedProfile.size() );
         }