clasz routing search filter

include/nigiri/routing/clasz_mask.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <cinttypes>
+#include <limits>
+
+#include "nigiri/types.h"
+
+namespace nigiri::routing {
+
+using clasz_mask_t = std::uint16_t;
+
+constexpr inline clasz_mask_t all_clasz_allowed() {
+  return std::numeric_limits<clasz_mask_t>::max();
+}
+
+constexpr inline clasz_mask_t to_mask(clasz const c) {
+  auto const c_as_int = static_cast<std::underlying_type_t<clasz>>(c);
+  return (1U << c_as_int);
+}
+
+constexpr inline bool is_allowed(clasz_mask_t const mask, clasz const c) {
+  auto const c_as_mask = to_mask(c);
+  return (mask & c_as_mask) == c_as_mask;
+}
+
+inline std::string to_str(clasz_mask_t const x) {
+  auto s = std::string{};
+  s += ", x=" + std::to_string(x);
+  for (auto i = std::underlying_type_t<clasz>(0U);
+       i != sizeof(clasz_mask_t) * 8; ++i) {
+    auto const allowed = is_allowed(x, clasz{i});
+    s = std::string{allowed ? '1' : '0'} + s;
+  }
+  return s;
+}
+
+}  // namespace nigiri::routing

include/nigiri/routing/query.h

@@ -1,11 +1,13 @@
 #pragma once
 
 #include <cinttypes>
+#include <limits>
 #include <variant>
 #include <vector>
 
 #include "nigiri/common/interval.h"
 #include "nigiri/footpath.h"
+#include "nigiri/routing/clasz_mask.h"
 #include "nigiri/routing/limits.h"
 #include "nigiri/routing/location_match_mode.h"
 #include "nigiri/types.h"
@@ -45,6 +47,7 @@ struct query {
   bool extend_interval_earlier_{false};
   bool extend_interval_later_{false};
   profile_idx_t prf_idx_{0};
+  clasz_mask_t allowed_claszes_{all_clasz_allowed()};
 };
 
 }  // namespace nigiri::routing

include/nigiri/routing/raptor/raptor.h

@@ -55,7 +55,8 @@ struct raptor {
          std::vector<bool>& is_dest,
          std::vector<std::uint16_t>& dist_to_dest,
          std::vector<std::uint16_t>& lb,
-         day_idx_t const base)
+         day_idx_t const base,
+         clasz_mask_t const allowed_claszes)
       : tt_{tt},
         rtt_{rtt},
         state_{state},
@@ -66,7 +67,8 @@ struct raptor {
         n_days_{tt_.internal_interval_days().size().count()},
         n_locations_{tt_.n_locations()},
         n_routes_{tt.n_routes()},
-        n_rt_transports_{Rt ? rtt->n_rt_transports() : 0U} {
+        n_rt_transports_{Rt ? rtt->n_rt_transports() : 0U},
+        allowed_claszes_{allowed_claszes} {
     state_.resize(n_locations_, n_routes_, n_rt_transports_);
     utl::fill(time_at_dest_, kInvalid);
     state_.round_times_.reset(kInvalid);
@@ -145,19 +147,64 @@ struct raptor {
       utl::fill(state_.station_mark_, false);
 
       any_marked = false;
-      for (auto r_id = 0U; r_id != n_routes_; ++r_id) {
-        if (state_.route_mark_[r_id]) {
-          ++stats_.n_routes_visited_;
-          trace("┊ ├k={} updating route {}\n", k, r_id);
-          any_marked |= update_route(k, route_idx_t{r_id});
+      if (allowed_claszes_ == all_clasz_allowed()) {
+        for (auto r_id = 0U; r_id != n_routes_; ++r_id) {
+          if (state_.route_mark_[r_id]) {
+            ++stats_.n_routes_visited_;
+            trace("┊ ├k={} updating route {}\n", k, r_id);
+            any_marked |= update_route(k, route_idx_t{r_id});
+          }
+        }
+      } else {
+        for (auto r_id = 0U; r_id != n_routes_; ++r_id) {
+          if (state_.route_mark_[r_id] &&
+              is_allowed(allowed_claszes_,
+                         tt_.route_clasz_[route_idx_t{r_id}])) {
+            ++stats_.n_routes_visited_;
+            trace("┊ ├k={} updating route {}\n", k, r_id);
+            any_marked |= update_route(k, route_idx_t{r_id});
+          } else if (state_.route_mark_[r_id] &&
+                     !is_allowed(allowed_claszes_,
+                                 tt_.route_clasz_[route_idx_t{r_id}])) {
+            trace(
+                "┊ ├k={} updating route {}: not allowed [allowed={}, "
+                "route_clasz={}]\n",
+                k, r_id, to_str(allowed_claszes_),
+                to_str(to_mask(tt_.route_clasz_[route_idx_t{r_id}])));
+          }
         }
       }
       if constexpr (Rt) {
-        for (auto rt_t = 0U; rt_t != n_rt_transports_; ++rt_t) {
-          if (state_.rt_transport_mark_[rt_t]) {
-            ++stats_.n_routes_visited_;
-            trace("┊ ├k={} updating rt transport {}\n", k, rt_t);
-            any_marked |= update_rt_transport(k, rt_transport_idx_t{rt_t});
+        if (allowed_claszes_ == all_clasz_allowed()) {
+          for (auto rt_t = 0U; rt_t != n_rt_transports_; ++rt_t) {
+            if (state_.rt_transport_mark_[rt_t]) {
+              ++stats_.n_routes_visited_;
+              trace("┊ ├k={} updating rt transport {}\n", k, rt_t);
+              any_marked |= update_rt_transport(k, rt_transport_idx_t{rt_t});
+            }
+          }
+        } else {
+          for (auto rt_t = 0U; rt_t != n_rt_transports_; ++rt_t) {
+            if (state_.rt_transport_mark_[rt_t] &&
+                is_allowed(allowed_claszes_,
+                           rtt_->rt_transport_section_clasz_[rt_transport_idx_t{
+                               rt_t}][0])) {
+              ++stats_.n_routes_visited_;
+              trace("┊ ├k={} updating rt transport {}\n", k, rt_t);
+              any_marked |= update_rt_transport(k, rt_transport_idx_t{rt_t});
+            } else if (state_.rt_transport_mark_[rt_t] &&
+                       !is_allowed(
+                           allowed_claszes_,
+                           rtt_->rt_transport_section_clasz_[rt_transport_idx_t{
+                               rt_t}][0])) {
+              trace(
+                  "┊ ├k={} updating rt transport {}: not allowed [allowed={}, "
+                  "route_clasz={}]\n",
+                  k, rt_t, to_str(allowed_claszes_),
+                  to_str(to_mask(
+                      rtt_->rt_transport_section_clasz_[rt_transport_idx_t{
+                          rt_t}][0])));
+            }
           }
         }
       }
@@ -687,6 +734,7 @@ struct raptor {
   int n_days_;
   raptor_stats stats_;
   std::uint32_t n_locations_, n_routes_, n_rt_transports_;
+  clasz_mask_t allowed_claszes_;
 };
 
 }  // namespace nigiri::routing

include/nigiri/routing/search.h

@@ -55,7 +55,7 @@ struct search {
   static constexpr auto const kFwd = (SearchDir == direction::kForward);
   static constexpr auto const kBwd = (SearchDir == direction::kBackward);
 
-  Algo init(algo_state_t& algo_state) {
+  Algo init(clasz_mask_t const allowed_claszes, algo_state_t& algo_state) {
     stats_.fastest_direct_ =
         static_cast<std::uint64_t>(fastest_direct_.count());
 
@@ -102,7 +102,8 @@ struct search {
         state_.travel_time_lower_bound_,
         day_idx_t{std::chrono::duration_cast<date::days>(
                       search_interval_.from_ - tt_.internal_interval().from_)
-                      .count()}};
+                      .count()},
+        allowed_claszes};
   }
 
   search(timetable const& tt,
@@ -125,7 +126,7 @@ struct search {
                 }},
             q_.start_time_)},
         fastest_direct_{get_fastest_direct(tt_, q_, SearchDir)},
-        algo_{init(algo_state)},
+        algo_{init(q_.allowed_claszes_, algo_state)},
         timeout_(timeout) {}
 
   routing_result<algo_stats_t> execute() {

include/nigiri/timetable.h

@@ -163,12 +163,16 @@ struct timetable {
   route_idx_t register_route(
       std::basic_string<stop::value_type> const& stop_seq,
       std::basic_string<clasz> const& clasz_sections) {
+    assert(!stop_seq.empty() && stop_seq.size() % 2U == 0U);
+    assert(!clasz_sections.empty());
+
     auto const idx = route_location_seq_.size();
     route_transport_ranges_.emplace_back(
         transport_idx_t{transport_traffic_days_.size()},
         transport_idx_t::invalid());
     route_location_seq_.emplace_back(stop_seq);
     route_section_clasz_.emplace_back(clasz_sections);
+    route_clasz_.emplace_back(clasz_sections[0]);
     return route_idx_t{idx};
   }
 
@@ -376,6 +380,9 @@ struct timetable {
   // Route -> list of stops
   vecvec<route_idx_t, stop::value_type> route_location_seq_;
 
+  // Route -> clasz
+  vector_map<route_idx_t, clasz> route_clasz_;
+
   // Route -> clasz per section
   vecvec<route_idx_t, clasz> route_section_clasz_;
 

include/nigiri/types.h

@@ -326,15 +326,6 @@ inline std::ostream& operator<<(std::ostream& out,
 
 }  // namespace std::chrono
 
-template <>
-struct fmt::formatter<nigiri::duration_t> : ostream_formatter {};
-
-template <>
-struct fmt::formatter<nigiri::unixtime_t> : ostream_formatter {};
-
-template <>
-struct fmt::formatter<nigiri::debug> : ostream_formatter {};
-
 #include <iostream>
 
 namespace nigiri {
@@ -431,3 +422,15 @@ inline local_time to_local_time(timezone const& tz, unixtime_t const t) {
 }
 
 }  // namespace nigiri
+
+template <>
+struct fmt::formatter<nigiri::duration_t> : ostream_formatter {};
+
+template <>
+struct fmt::formatter<nigiri::unixtime_t> : ostream_formatter {};
+
+template <>
+struct fmt::formatter<nigiri::debug> : ostream_formatter {};
+
+template <>
+struct fmt::formatter<nigiri::delta> : ostream_formatter {};

test/raptor_search.cc

@@ -57,15 +57,17 @@ pareto_set<routing::journey> raptor_search(timetable const& tt,
                                            std::string_view from,
                                            std::string_view to,
                                            routing::start_time_t time,
-                                           direction const search_dir) {
+                                           direction const search_dir,
+                                           routing::clasz_mask_t const mask) {
   auto const src = source_idx_t{0};
   auto q = routing::query{
       .start_time_ = time,
       .start_ = {{tt.locations_.location_id_to_idx_.at({from, src}), 0_minutes,
                   0U}},
       .destination_ = {{tt.locations_.location_id_to_idx_.at({to, src}),
                         0_minutes, 0U}},
-      .prf_idx_ = 0};
+      .prf_idx_ = 0,
+      .allowed_claszes_ = mask};
   return raptor_search(tt, rtt, std::move(q), search_dir);
 }
 
@@ -74,9 +76,10 @@ pareto_set<routing::journey> raptor_search(timetable const& tt,
                                            std::string_view from,
                                            std::string_view to,
                                            std::string_view time,
-                                           direction const search_dir) {
+                                           direction const search_dir,
+                                           routing::clasz_mask_t mask) {
   return raptor_search(tt, rtt, from, to, parse_time(time, "%Y-%m-%d %H:%M %Z"),
-                       search_dir);
+                       search_dir, mask);
 }
 
 pareto_set<routing::journey> raptor_intermodal_search(

test/raptor_search.h

@@ -9,19 +9,23 @@ struct rt_timetable;
 
 namespace nigiri::test {
 
-pareto_set<routing::journey> raptor_search(timetable const&,
-                                           rt_timetable const*,
-                                           std::string_view from,
-                                           std::string_view to,
-                                           std::string_view time,
-                                           direction = direction::kForward);
+pareto_set<routing::journey> raptor_search(
+    timetable const&,
+    rt_timetable const*,
+    std::string_view from,
+    std::string_view to,
+    std::string_view time,
+    direction = direction::kForward,
+    routing::clasz_mask_t mask = routing::all_clasz_allowed());
 
-pareto_set<routing::journey> raptor_search(timetable const&,
-                                           rt_timetable const*,
-                                           std::string_view from,
-                                           std::string_view to,
-                                           routing::start_time_t,
-                                           direction = direction::kForward);
+pareto_set<routing::journey> raptor_search(
+    timetable const&,
+    rt_timetable const*,
+    std::string_view from,
+    std::string_view to,
+    routing::start_time_t,
+    direction = direction::kForward,
+    routing::clasz_mask_t mask = routing::all_clasz_allowed());
 
 pareto_set<routing::journey> raptor_search(timetable const&,
                                            rt_timetable const*,