clang-format C++ sources

1 files changed, 226 insertions, 157 deletions

diff --git a/server/src/api.cpp b/server/src/api.cpp
index b3c8e31..a6eef23 100644
--- a/server/src/api.cpp
+++ b/server/src/api.cpp
@@ -17,190 +17,259 @@ import :trace;
 
 namespace {
 
-  namespace chrono = std::chrono;
-  namespace json = boost::json;
-  namespace views = std::views;
+namespace chrono = std::chrono;
+namespace json = boost::json;
+namespace views = std::views;
 
-} // namespace <anonymous>
+} // namespace
 
 namespace routemon::api {
 
-  auto json_value_from_point(geo::point const& p) -> json::value {
-    return json::array{bgeo::get<1>(p), bgeo::get<0>(p)};
-  }
-  auto json_value_from_linestring(geo::linestring const& ls) -> json::value {
-    json::array a;
-    for (auto const& p : ls)
-      a.push_back(json_value_from_point(p));
-    return a;
-  }
-  auto json_value_from_linestrings(std::vector<geo::linestring> const& lss) -> json::value {
-    json::array a;
-    for (auto const& ls : lss)
-      a.push_back(json_value_from_linestring(ls));
-    return a;
-  }
+auto json_value_from_point(geo::point const& p) -> json::value
+{
+  return json::array{bgeo::get<1>(p), bgeo::get<0>(p)};
+}
 
-  auto tag_invoke(json::value_from_tag, json::value& jv, relevant_road_closure const& clo) -> void {
-    jv = json::object{
+auto json_value_from_linestring(geo::linestring const& ls) -> json::value
+{
+  json::array a;
+  for (auto const& p : ls)
+    a.push_back(json_value_from_point(p));
+  return a;
+}
+
+auto json_value_from_linestrings(std::vector<geo::linestring> const& lss)
+    -> json::value
+{
+  json::array a;
+  for (auto const& ls : lss)
+    a.push_back(json_value_from_linestring(ls));
+  return a;
+}
+
+auto tag_invoke(
+    json::value_from_tag, json::value& jv, relevant_road_closure const& clo)
+    -> void
+{
+  jv = json::object{
       {"relevant_lss", json_value_from_linestrings(clo.relevant_lss)},
-    };
-  }
-  auto tag_invoke(json::value_from_tag, json::value& jv, relevant_situation const& sit) -> void {
-    jv = json::object{
-      {"id",                     json::value_from(sit.id)},
-      {"location",               sit.location ? json_value_from_point(*sit.location) : nullptr},
-      {"comments",               json::value_from(sit.comments)},
+  };
+}
+
+auto tag_invoke(
+    json::value_from_tag, json::value& jv, relevant_situation const& sit)
+    -> void
+{
+  jv = json::object{
+      {"id", json::value_from(sit.id)},
+      {"location",
+       sit.location ? json_value_from_point(*sit.location) : nullptr},
+      {"comments", json::value_from(sit.comments)},
       {"relevant_road_closures", json::value_from(sit.relevant_road_closures)},
-    };
-  }
-  auto tag_invoke(json::value_from_tag, json::value& jv, track_segment const& seg) -> void {
-    jv = json::object{
+  };
+}
+
+auto tag_invoke(json::value_from_tag, json::value& jv, track_segment const& seg)
+    -> void
+{
+  jv = json::object{
       {"points", json_value_from_linestring(seg.points)},
-    };
-  }
-  auto tag_invoke(json::value_from_tag, json::value& jv, track const& track) -> void {
-    jv = json::object{
+  };
+}
+
+auto tag_invoke(json::value_from_tag, json::value& jv, track const& track)
+    -> void
+{
+  jv = json::object{
       {"segments", json::value_from(track.segments)},
-    };
-  }
-  auto tag_invoke(json::value_from_tag, json::value& jv, process_gpx_result const& res) -> void {
-    jv = json::object{
-      {"tracks",              json::value_from(res.tracks)},
+  };
+}
+
+auto tag_invoke(
+    json::value_from_tag, json::value& jv, process_gpx_result const& res)
+    -> void
+{
+  jv = json::object{
+      {"tracks", json::value_from(res.tracks)},
       {"relevant_situations", json::value_from(res.relevant_situations)},
-    };
-  }
-  auto tag_invoke(json::value_from_tag, json::value& jv, sysinfo const& info) -> void {
-    jv = json::object{
-      {"using_publication_of", std::format("{:%FT%TZ}", info.using_publication_of)},
-    };
-  }
+  };
+}
 
-  handler::handler(log::logger const& l, datex2::situation_publication pub)
-    : l_{l.sub("handler")}, pub_{std::move(pub)}
+auto tag_invoke(json::value_from_tag, json::value& jv, sysinfo const& info)
+    -> void
+{
+  jv = json::object{
+      {"using_publication_of",
+       std::format("{:%FT%TZ}", info.using_publication_of)},
+  };
+}
+
+handler::handler(log::logger const& l, datex2::situation_publication pub)
+  : l_{l.sub("handler")}, pub_{std::move(pub)}
+{
+  l_.info("Building indices");
+  auto const before_build = chrono::steady_clock::now();
+  for (auto const& sit : pub_.situations)
   {
-    l_.info("Building indices");
-    auto const before_build = chrono::steady_clock::now();
-    for (auto const& sit : pub_.situations) {
-      for (auto const& rc : sit->road_closures) {
-        for (auto const& ls : rc->relevant_line_strings) {
-          auto box = geo::box{};
-          bgeo::envelope(*ls, box);
-          lse_index_.insert(std::make_tuple(box, ls, rc));
-        }
-        for (auto p : rc->relevant_points) {
-          p_index_.insert(std::make_pair(p, rc));
-        }
+    for (auto const& rc : sit->road_closures)
+    {
+      for (auto const& ls : rc->relevant_line_strings)
+      {
+        auto box = geo::box{};
+        bgeo::envelope(*ls, box);
+        lse_index_.insert(std::make_tuple(box, ls, rc));
+      }
+      for (auto p : rc->relevant_points)
+      {
+        p_index_.insert(std::make_pair(p, rc));
       }
     }
-    auto const after_build = chrono::steady_clock::now();
-    auto const dur_build = chrono::duration_cast<chrono::milliseconds>(after_build - before_build);
-    l_.info("Indices built in {}", dur_build);
-    l_.info("LSE index size: {}", lse_index_.size());
-    l_.info("Point index size: {}", p_index_.size());
   }
+  auto const after_build = chrono::steady_clock::now();
+  auto const dur_build =
+      chrono::duration_cast<chrono::milliseconds>(after_build - before_build);
+  l_.info("Indices built in {}", dur_build);
+  l_.info("LSE index size: {}", lse_index_.size());
+  l_.info("Point index size: {}", p_index_.size());
+}
 
-  auto handler::process_gpx(gpx::file&& gpx_file) -> std::optional<process_gpx_result> {
-    auto const now = chrono::utc_clock::now();
-    auto const relevant = std::initializer_list<time::period>{time::period{now - chrono::days(7), now + chrono::days(7)}};
-    auto const check_periods = time::period_seq{relevant.begin(), relevant.end()};
+auto handler::process_gpx(gpx::file&& gpx_file)
+    -> std::optional<process_gpx_result>
+{
+  auto const now = chrono::utc_clock::now();
+  auto const relevant = std::initializer_list<time::period>{
+      time::period{now - chrono::days(7), now + chrono::days(7)}
+  };
+  auto const check_periods = time::period_seq{relevant.begin(), relevant.end()};
 
-    auto splits_with_overlap_segments = std::vector<geo::linestring>{};
-    for (auto const& track : gpx_file.tracks)
-      for (auto const& seg : track.segments)
-        geo::split_linestring_with_overlap_segments(seg.waypoints, 5000 /* meters max total dist until a new split is forced */,
-                                                    splits_with_overlap_segments);
-    auto const before_query = chrono::steady_clock::now();
+  auto splits_with_overlap_segments = std::vector<geo::linestring>{};
+  for (auto const& track : gpx_file.tracks)
+    for (auto const& seg : track.segments)
+      geo::split_linestring_with_overlap_segments(
+          seg.waypoints,
+          5000 /* meters max total dist until a new split is forced */,
+          splits_with_overlap_segments);
+  auto const before_query = chrono::steady_clock::now();
 
-    l_.debug("Querying for relevant situations");
-    auto relevant_road_closures = std::unordered_set<std::shared_ptr<datex2::road_closure>>{};
-    auto ls_checked = 0uz;
-    auto p_checked = 0uz;
-    auto i = 0;
-    for (geo::linestring const& part : splits_with_overlap_segments) {
-      l_.debug("Checking part [{}/{}]", ++i, splits_with_overlap_segments.size());
+  l_.debug("Querying for relevant situations");
+  auto relevant_road_closures =
+      std::unordered_set<std::shared_ptr<datex2::road_closure>>{};
+  auto ls_checked = 0uz;
+  auto p_checked = 0uz;
+  auto i = 0;
+  for (geo::linestring const& part : splits_with_overlap_segments)
+  {
+    l_.debug("Checking part [{}/{}]", ++i, splits_with_overlap_segments.size());
 
-      auto part_box = geo::box{};
-      bgeo::envelope(part, part_box);
+    auto part_box = geo::box{};
+    bgeo::envelope(part, part_box);
 
-      for (auto it = lse_index_.qbegin(bgeo::index::intersects(part_box)); it != lse_index_.qend(); it++) {
-        // Cannot use structured bindings here, as boost::geometry::get interferes with ADL.
-        // It is a candidate as the namespace boost::geometry is part of the associated namespace set,
-        // which happens because geo::linestring ≡ boost::geometry::model::linestring<geo::point> is part
-        // of the whole tuple type (lse_index_value) that is the value_type of the iterator.
-        std::shared_ptr<geo::linestring> const& ls = std::get<1>(*it);
-        std::shared_ptr<datex2::road_closure> const& rc = std::get<2>(*it);
-        if (rc->validity && rc->validity->intersect(check_periods).periods().empty())
-          continue;
-        if (bgeo::distance(*ls, part, geo::vincenty_strategy{}) < 5.0)
-          relevant_road_closures.emplace(rc);
-        ls_checked++;
-      }
-      for (auto it = p_index_.qbegin(bgeo::index::intersects(part_box)); it != p_index_.qend(); it++) {
-        // Cannot use structured bindings here for the same reason as above.
-        geo::point const& p = std::get<0>(*it);
-        std::shared_ptr<datex2::road_closure> const& rc = std::get<1>(*it);
-        if (rc->validity && rc->validity->intersect(check_periods).periods().empty())
-          continue;
-        if (bgeo::distance(p, part, geo::vincenty_strategy{}) < 5.0)
-          relevant_road_closures.emplace(rc);
-        p_checked++;
-      }
+    for (auto it = lse_index_.qbegin(bgeo::index::intersects(part_box));
+         it != lse_index_.qend(); it++)
+    {
+      // Cannot use structured bindings here, as boost::geometry::get
+      // interferes with ADL. It is a candidate as the namespace
+      // boost::geometry is part of the associated namespace set, which
+      // happens because geo::linestring ≡
+      // boost::geometry::model::linestring<geo::point> is part of the
+      // whole tuple type (lse_index_value) that is the value_type of the
+      // iterator.
+      std::shared_ptr<geo::linestring> const& ls = std::get<1>(*it);
+      std::shared_ptr<datex2::road_closure> const& rc = std::get<2>(*it);
+      if (rc->validity
+          && rc->validity->intersect(check_periods).periods().empty())
+        continue;
+      if (bgeo::distance(*ls, part, geo::vincenty_strategy{}) < 5.0)
+        relevant_road_closures.emplace(rc);
+      ls_checked++;
+    }
+    for (auto it = p_index_.qbegin(bgeo::index::intersects(part_box));
+         it != p_index_.qend(); it++)
+    {
+      // Cannot use structured bindings here for the same reason as above.
+      geo::point const& p = std::get<0>(*it);
+      std::shared_ptr<datex2::road_closure> const& rc = std::get<1>(*it);
+      if (rc->validity
+          && rc->validity->intersect(check_periods).periods().empty())
+        continue;
+      if (bgeo::distance(p, part, geo::vincenty_strategy{}) < 5.0)
+        relevant_road_closures.emplace(rc);
+      p_checked++;
     }
+  }
 
-    auto const after_query = chrono::steady_clock::now();
-    l_.debug("Done (checked {} line string(s) and {} point(s)) in {}",
-              ls_checked, p_checked, chrono::duration_cast<chrono::milliseconds>(after_query - before_query));
+  auto const after_query = chrono::steady_clock::now();
+  l_.debug(
+      "Done (checked {} line string(s) and {} point(s)) in {}", ls_checked,
+      p_checked,
+      chrono::duration_cast<chrono::milliseconds>(after_query - before_query));
 
-    auto relevant_situations = std::unordered_set<std::shared_ptr<datex2::situation>>{};
-    for (auto const& rc : relevant_road_closures)
-      relevant_situations.emplace(rc->parent);
+  auto relevant_situations =
+      std::unordered_set<std::shared_ptr<datex2::situation>>{};
+  for (auto const& rc : relevant_road_closures)
+    relevant_situations.emplace(rc->parent);
 
-    l_.debug("Identified {} relevant road closure(s), part of {} unique situation(s)",
-              relevant_road_closures.size(), relevant_situations.size());
-    for (auto const& sit : relevant_situations)
-      l_.debug("Relevant situation: {}", sit->id);
+  l_.debug(
+      "Identified {} relevant road closure(s), part of {} unique "
+      "situation(s)",
+      relevant_road_closures.size(), relevant_situations.size());
+  for (auto const& sit : relevant_situations)
+    l_.debug("Relevant situation: {}", sit->id);
 
-    return process_gpx_result{
+  return process_gpx_result{
       .tracks = gpx_file.tracks
-      | views::transform([](auto const& trk) -> track {
-        return {
-          .segments = trk.segments
-          | views::transform([](auto const& seg) -> track_segment {
-            return {.points = seg.waypoints};
-          })
-          | std::ranges::to<std::vector<track_segment>>(),
-        };
-      })
-      | std::ranges::to<std::vector<track>>(),
-      .relevant_situations = relevant_situations
-      | views::transform([&](std::shared_ptr<datex2::situation> sit) -> relevant_situation {
-        return {
-          .id       = sit->id,
-          .location = sit->location,
-          .comments = sit->comments,
-          .relevant_road_closures = relevant_road_closures
-          | views::filter([&](std::shared_ptr<datex2::road_closure> const& rc) -> bool {
-            return std::shared_ptr{rc->parent} == sit;
-          })
-          | views::transform([](std::shared_ptr<datex2::road_closure> const& rc) -> relevant_road_closure {
-            return {
-              .relevant_lss = rc->relevant_line_strings
-              | views::transform([](auto const& lsp) -> geo::linestring {
-                return *lsp;
+                | views::transform(
+                    [](auto const& trk) -> track
+                    {
+                      return {
+                          .segments =
+                              trk.segments
+                              | views::transform(
+                                  [](auto const& seg) -> track_segment
+                                  { return {.points = seg.waypoints}; })
+                              | std::ranges::to<std::vector<track_segment>>(),
+                      };
+                    })
+                | std::ranges::to<std::vector<track>>(),
+      .relevant_situations =
+          relevant_situations
+          | views::transform(
+              [&](std::shared_ptr<datex2::situation> sit) -> relevant_situation
+              {
+                return {
+                    .id = sit->id,
+                    .location = sit->location,
+                    .comments = sit->comments,
+                    .relevant_road_closures =
+                        relevant_road_closures
+                        | views::filter(
+                            [&](std::shared_ptr<datex2::road_closure> const& rc)
+                                -> bool
+                            { return std::shared_ptr{rc->parent} == sit; })
+                        | views::transform(
+                            [](std::shared_ptr<datex2::road_closure> const& rc)
+                                -> relevant_road_closure
+                            {
+                              return {
+                                  .relevant_lss =
+                                      rc->relevant_line_strings
+                                      | views::transform(
+                                          [](auto const& lsp) -> geo::linestring
+                                          { return *lsp; })
+                                      | std::ranges::to<
+                                          std::vector<geo::linestring>>(),
+                              };
+                            })
+                        | std::ranges::to<std::vector<relevant_road_closure>>(),
+                };
               })
-              | std::ranges::to<std::vector<geo::linestring>>(),
-            };
-          })
-          | std::ranges::to<std::vector<relevant_road_closure>>(),
-        };
-      })
-      | std::ranges::to<std::vector<relevant_situation>>(),
-    };
-  }
+          | std::ranges::to<std::vector<relevant_situation>>(),
+  };
+}
 
-  auto handler::sysinfo() -> struct sysinfo {
-    return {.using_publication_of = pub_.publication_time};
-  }
+auto handler::sysinfo() -> struct sysinfo
+{
+  return {.using_publication_of = pub_.publication_time};
+}
 
 } // namespace routemon::api