remove direction field from ExtractionWay

Extractor/ExtractionWay.h

@@ -45,7 +45,6 @@ struct ExtractionWay
         nameID = INVALID_NAMEID;
         path.clear();
         keyVals.Clear();
-        direction = ExtractionWay::notSure;
         speed = -1;
         backward_speed = -1;
         duration = -1;
@@ -64,6 +63,45 @@ struct ExtractionWay
       bidirectional,
       opposite };
     
+    inline void set_direction(const Directions m)
+    {
+        if (Directions::oneway == m )
+        {
+            travel_mode = TravelMode::Default;
+            backward_travel_mode = TravelMode::None;
+        }
+        else if (Directions::opposite == m )
+        {
+          travel_mode = TravelMode::None;
+          backward_travel_mode = TravelMode::Default;
+        }
+        else if (Directions::bidirectional == m )
+        {
+          travel_mode = TravelMode::Default;
+          backward_travel_mode = TravelMode::Default;
+        }
+    }
+
+    inline const Directions get_direction()
+    {
+        if (TravelMode::None != travel_mode && TravelMode::None != backward_travel_mode )
+        {
+            return Directions::bidirectional;
+        }
+        else if (TravelMode::None != travel_mode )
+        {
+            return Directions::oneway;
+        }
+        else if (TravelMode::None != backward_travel_mode )
+        {
+            return Directions::opposite;
+        }
+        else
+        {
+            return Directions::notSure;
+        }
+    }
+
     inline void set_mode(const TravelMode m) { travel_mode = m; }
     inline const TravelMode get_mode() { return travel_mode; }
     inline void set_backward_mode(const TravelMode m) { backward_travel_mode = m; }
@@ -74,7 +112,6 @@ struct ExtractionWay
     double speed;
     double backward_speed;
     double duration;
-    Directions direction;
     std::string name;
     short type;
     bool access;

Extractor/ExtractorCallbacks.cpp

@@ -106,27 +106,16 @@ void ExtractorCallbacks::ProcessWay(ExtractionWay &parsed_way)
         parsed_way.nameID = string_map_iterator->second;
     }
 
-    if (0 == parsed_way.travel_mode )
+    if (TravelMode::None == parsed_way.travel_mode)
-    {
-        parsed_way.direction = ExtractionWay::opposite;
-    }
-
-    if (0 == parsed_way.backward_travel_mode )
-    {
-        parsed_way.direction = ExtractionWay::oneway;
-    }
-
-    if (ExtractionWay::opposite == parsed_way.direction)
     {
         std::reverse(parsed_way.path.begin(), parsed_way.path.end());
-        parsed_way.direction = ExtractionWay::oneway;
         parsed_way.travel_mode = parsed_way.backward_travel_mode;
         parsed_way.backward_travel_mode = TravelMode::None;
     }
 
     const bool split_edge =
-      (parsed_way.speed>0) && (parsed_way.travel_mode>0) &&
+      (parsed_way.speed>0) && (TravelMode::None != parsed_way.travel_mode) &&
-      (TravelMode::None != parsed_way.backward_speed) && (TravelMode::None != parsed_way.backward_travel_mode) &&
+      (parsed_way.backward_speed>0) && (TravelMode::None != parsed_way.backward_travel_mode) &&
       ((parsed_way.speed != parsed_way.backward_speed) ||
       (parsed_way.travel_mode != parsed_way.backward_travel_mode));
 
@@ -137,7 +126,8 @@ void ExtractorCallbacks::ProcessWay(ExtractionWay &parsed_way)
             parsed_way.path[n],
             parsed_way.path[n + 1],
             parsed_way.type,
-            (split_edge ? ExtractionWay::oneway : parsed_way.direction),
+            ((split_edge || TravelMode::None == parsed_way.backward_travel_mode) ? ExtractionWay::oneway
+                                                                                 : ExtractionWay::bidirectional),
             parsed_way.speed,
             parsed_way.nameID,
             parsed_way.roundabout,

Extractor/ScriptingEnvironment.cpp

@@ -85,7 +85,7 @@ void ScriptingEnvironment::initLuaState(lua_State* lua_state)
         .def_readwrite("is_access_restricted", &ExtractionWay::isAccessRestricted)
         .def_readwrite("ignore_in_grid", &ExtractionWay::ignoreInGrid)
         .def_readwrite("tags", &ExtractionWay::keyVals)
-        .def_readwrite("direction", &ExtractionWay::direction)
+        .property("direction", &ExtractionWay::get_direction, &ExtractionWay::set_direction)
         .property("mode", &ExtractionWay::get_mode, &ExtractionWay::set_mode)
         .property("backward_mode", &ExtractionWay::get_backward_mode, &ExtractionWay::set_backward_mode)
         .enum_("constants")[

profiles/bicycle.lua

@@ -225,7 +225,6 @@ function way_function (way)
     -- ferries (doesn't cover routes tagged using relations)
     way.mode = mode_ferry
     way.backward_mode = mode_ferry
-    way.direction = Way.bidirectional
     way.ignore_in_grid = true
     if durationIsValid(duration) then
       way.duration = math.max( 1, parseDuration(duration) )
@@ -248,7 +247,6 @@ function way_function (way)
     if access and access_tag_whitelist[access] then
       way.speed = railway_speeds[railway]
       way.backward_speed = railway_speeds[railway]
-      way.direction = Way.bidirectional
     end
   elseif amenity and amenity_speeds[amenity] then
     -- parking areas