add split_edge flag in extracted ways

include/extractor/extraction_way.hpp

@@ -60,15 +60,9 @@ struct ExtractionWay
         road_classification = guidance::RoadClassification();
         backward_restricted = false;
         forward_restricted = false;
+        split_edges = false;
     }
 
-    // These accessors exists because it's not possible to take the address of a bitfield,
-    // and LUA therefore cannot read/write the mode attributes directly.
-    void set_forward_mode(const TravelMode m) { forward_travel_mode = m; }
-    TravelMode get_forward_mode() const { return forward_travel_mode; }
-    void set_backward_mode(const TravelMode m) { backward_travel_mode = m; }
-    TravelMode get_backward_mode() const { return backward_travel_mode; }
-
     // wrappers to allow assigning nil (nullptr) to string values
     void SetName(const char *value) { detail::maybeSetString(name, value); }
     const char *GetName() const { return name.c_str(); }
@@ -105,14 +99,15 @@ struct ExtractionWay
     std::string destinations;
     std::string turn_lanes_forward;
     std::string turn_lanes_backward;
-    bool roundabout;
+    guidance::RoadClassification road_classification;
-    bool circular;
-    bool is_startpoint;
-    bool backward_restricted;
-    bool forward_restricted;
     TravelMode forward_travel_mode : 4;
     TravelMode backward_travel_mode : 4;
-    guidance::RoadClassification road_classification;
+    bool roundabout : 1;
+    bool circular : 1;
+    bool is_startpoint : 1;
+    bool forward_restricted : 1;
+    bool backward_restricted : 1;
+    bool split_edges : 1;
 };
 }
 }

profiles/rasterbot.lua

@@ -19,6 +19,7 @@ function way_function (way, result)
 
   result.forward_speed = 15
   result.backward_speed = 15
+  result.split_edges = true
 end
 
 function source_function ()

src/extractor/extractor_callbacks.cpp

@@ -323,11 +323,12 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, const Extracti
         (parsed_way.backward_travel_mode != TRAVEL_MODE_INACCESSIBLE);
 
     // split an edge into two edges if forwards/backwards behavior differ
-    const bool split_edge = in_forward_direction && in_backward_direction &&
+    const bool split_edge =
-                            ((parsed_way.forward_rate != parsed_way.backward_rate) ||
+        in_forward_direction && in_backward_direction &&
-                             (parsed_way.forward_speed != parsed_way.backward_speed) ||
+        (parsed_way.split_edges || (parsed_way.forward_rate != parsed_way.backward_rate) ||
-                             (parsed_way.forward_travel_mode != parsed_way.backward_travel_mode) ||
+         (parsed_way.forward_speed != parsed_way.backward_speed) ||
-                             (turn_lane_id_forward != turn_lane_id_backward));
+         (parsed_way.forward_travel_mode != parsed_way.backward_travel_mode) ||
+         (turn_lane_id_forward != turn_lane_id_backward));
 
     if (in_forward_direction)
     { // add (forward) segments or (forward,backward) for non-split edges in backward direction

src/extractor/scripting_environment_lua.cpp

@@ -330,12 +330,6 @@ void Sol2ScriptingEnvironment::InitContext(LuaScriptingContext &context)
         sol::property(&ExtractionWay::GetTurnLanesForward, &ExtractionWay::SetTurnLanesForward),
         "turn_lanes_backward",
         sol::property(&ExtractionWay::GetTurnLanesBackward, &ExtractionWay::SetTurnLanesBackward),
-        "roundabout",
-        &ExtractionWay::roundabout,
-        "circular",
-        &ExtractionWay::circular,
-        "is_startpoint",
-        &ExtractionWay::is_startpoint,
         "duration",
         &ExtractionWay::duration,
         "weight",
@@ -343,13 +337,29 @@ void Sol2ScriptingEnvironment::InitContext(LuaScriptingContext &context)
         "road_classification",
         &ExtractionWay::road_classification,
         "forward_mode",
-        sol::property(&ExtractionWay::get_forward_mode, &ExtractionWay::set_forward_mode),
+        sol::property([](const ExtractionWay &way) { return way.forward_travel_mode; },
+                      [](ExtractionWay &way, TravelMode mode) { way.forward_travel_mode = mode; }),
         "backward_mode",
-        sol::property(&ExtractionWay::get_backward_mode, &ExtractionWay::set_backward_mode),
+        sol::property([](const ExtractionWay &way) { return way.backward_travel_mode; },
+                      [](ExtractionWay &way, TravelMode mode) { way.backward_travel_mode = mode; }),
+        "roundabout",
+        sol::property([](const ExtractionWay &way) { return way.roundabout; },
+                      [](ExtractionWay &way, bool flag) { way.roundabout = flag; }),
+        "circular",
+        sol::property([](const ExtractionWay &way) { return way.circular; },
+                      [](ExtractionWay &way, bool flag) { way.circular = flag; }),
+        "is_startpoint",
+        sol::property([](const ExtractionWay &way) { return way.is_startpoint; },
+                      [](ExtractionWay &way, bool flag) { way.is_startpoint = flag; }),
         "forward_restricted",
-        &ExtractionWay::forward_restricted,
+        sol::property([](const ExtractionWay &way) { return way.forward_restricted; },
+                      [](ExtractionWay &way, bool flag) { way.forward_restricted = flag; }),
         "backward_restricted",
-        &ExtractionWay::backward_restricted);
+        sol::property([](const ExtractionWay &way) { return way.backward_restricted; },
+                      [](ExtractionWay &way, bool flag) { way.backward_restricted = flag; }),
+        "split_edges",
+        sol::property([](const ExtractionWay &way) { return way.split_edges; },
+                      [](ExtractionWay &way, bool flag) { way.split_edges = flag; }));
 
     context.state.new_usertype<ExtractionSegment>("ExtractionSegment",
                                                   "source",