Format again

1 files changed, 74 insertions, 81 deletions

diff --git a/server/src/api.cpp b/server/src/api.cpp
index a6eef23..73dee32 100644
--- a/server/src/api.cpp
+++ b/server/src/api.cpp
@@ -39,7 +39,7 @@ auto json_value_from_linestring(geo::linestring const& ls) -> json::value
 }
 
 auto json_value_from_linestrings(std::vector<geo::linestring> const& lss)
-    -> json::value
+  -> json::value
 {
   json::array a;
   for (auto const& ls : lss)
@@ -48,59 +48,56 @@ auto json_value_from_linestrings(std::vector<geo::linestring> const& lss)
 }
 
 auto tag_invoke(
-    json::value_from_tag, json::value& jv, relevant_road_closure const& clo)
-    -> void
+  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)},
+    {"relevant_lss", json_value_from_linestrings(clo.relevant_lss)},
   };
 }
 
 auto tag_invoke(
-    json::value_from_tag, json::value& jv, relevant_situation const& sit)
-    -> void
+  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)},
+    {"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
+  -> void
 {
   jv = json::object{
-      {"points", json_value_from_linestring(seg.points)},
+    {"points", json_value_from_linestring(seg.points)},
   };
 }
 
 auto tag_invoke(json::value_from_tag, json::value& jv, track const& track)
-    -> void
+  -> void
 {
   jv = json::object{
-      {"segments", json::value_from(track.segments)},
+    {"segments", json::value_from(track.segments)},
   };
 }
 
 auto tag_invoke(
-    json::value_from_tag, json::value& jv, process_gpx_result const& res)
-    -> void
+  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)},
+    {"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
+  -> void
 {
   jv = json::object{
-      {"using_publication_of",
-       std::format("{:%FT%TZ}", info.using_publication_of)},
+    {"using_publication_of",
+     std::format("{:%FT%TZ}", info.using_publication_of)},
   };
 }
 
@@ -127,18 +124,18 @@ handler::handler(log::logger const& l, datex2::situation_publication pub)
   }
   auto const after_build = chrono::steady_clock::now();
   auto const dur_build =
-      chrono::duration_cast<chrono::milliseconds>(after_build - before_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>
+  -> 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)}
+    time::period{now - chrono::days(7), now + chrono::days(7)}
   };
   auto const check_periods = time::period_seq{relevant.begin(), relevant.end()};
 
@@ -146,14 +143,14 @@ auto handler::process_gpx(gpx::file&& gpx_file)
   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);
+        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>>{};
+    std::unordered_set<std::shared_ptr<datex2::road_closure>>{};
   auto ls_checked = 0uz;
   auto p_checked = 0uz;
   auto i = 0;
@@ -200,70 +197,66 @@ auto handler::process_gpx(gpx::file&& gpx_file)
 
   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));
+    "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>>{};
+    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());
+    "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{
-      .tracks = gpx_file.tracks
-                | views::transform(
-                    [](auto const& trk) -> track
-                    {
-                      return {
-                          .segments =
-                              trk.segments
-                              | views::transform(
+    .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; })
-                                      | 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<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<relevant_situation>>(),
   };
 }