Format again

1 files changed, 72 insertions, 72 deletions

diff --git a/server/src/xml.cppm b/server/src/xml.cppm
index ff27c5c..0c319e6 100644
--- a/server/src/xml.cppm
+++ b/server/src/xml.cppm
@@ -66,7 +66,7 @@ public:
   };
 
   inline explicit attribute_view_iterator(
-      std::string_view default_ns_uri, char const* const* attrs)
+    std::string_view default_ns_uri, char const* const* attrs)
     : default_ns_uri_{default_ns_uri}, attrs_{attrs}
   {
   }
@@ -105,7 +105,7 @@ class attribute_view : std::ranges::view_base
 
 public:
   inline explicit attribute_view(
-      std::string_view default_ns_uri, char const** attrs)
+    std::string_view default_ns_uri, char const** attrs)
     : default_ns_uri_{default_ns_uri},
       attrs_{const_cast<char const* const*>(attrs)}
   {
@@ -122,7 +122,7 @@ public:
   }
 
   inline auto lookup(qname_view want)
-      -> std::optional<util::not_null<util::lazy_zstring_view>>
+    -> std::optional<util::not_null<util::lazy_zstring_view>>
   {
     for (auto const& [name, v] : *this)
     {
@@ -200,8 +200,8 @@ struct eof_event
 };
 
 using event = std::variant<
-    start_element_event, end_element_event, character_data_event,
-    processing_instructions_event, xml_decl_event, eof_event>;
+  start_element_event, end_element_event, character_data_event,
+  processing_instructions_event, xml_decl_event, eof_event>;
 
 template <class T>
 concept event_type = requires(event ev) { std::get<T>(ev); };
@@ -237,7 +237,7 @@ public:
   }
 
   [[nodiscard]] inline auto continuation() const
-      -> std::coroutine_handle<promise_base>
+    -> std::coroutine_handle<promise_base>
   {
     return continuation_;
   }
@@ -285,11 +285,11 @@ class executor
           s != XML_STATUS_OK)
       {
         ex_ = std::make_exception_ptr(
-            std::runtime_error{"unexpected error when stopping XML parser"});
+          std::runtime_error{"unexpected error when stopping XML parser"});
         return;
       }
       ex_ = std::make_exception_ptr(
-          std::runtime_error{"parser did not consume entire XML document"});
+        std::runtime_error{"parser did not consume entire XML document"});
       return;
     }
     continuation_.resume();
@@ -302,74 +302,74 @@ class executor
 
   static auto
   handle_start_element(void* ctx, char const* name, char const** attrs) noexcept
-      -> void
+    -> void
   {
     auto qname = detail::split_name(name);
     static_cast<executor*>(ctx)->try_handle_event(
-        start_element_event{
-            .name = qname,
-            .attrs = attribute_view{qname.ns_uri, attrs},
-        });
+      start_element_event{
+        .name = qname,
+        .attrs = attribute_view{qname.ns_uri, attrs},
+      });
   }
 
   static auto handle_end_element(void* ctx, char const* name) noexcept -> void
   {
     static_cast<executor*>(ctx)->try_handle_event(
-        end_element_event{
-            .name = detail::split_name(name),
-        });
+      end_element_event{
+        .name = detail::split_name(name),
+      });
   }
 
   static auto handle_character_data(void* ctx, char const* s, int len) noexcept
-      -> void
+    -> void
   {
     static_cast<executor*>(ctx)->try_handle_event(
-        character_data_event{
-            .data = std::string_view{s, static_cast<std::size_t>(len)},
-        });
+      character_data_event{
+        .data = std::string_view{s, static_cast<std::size_t>(len)},
+      });
   }
 
   static auto handle_processing_instructions(
-      void* ctx, char const* target, char const* data) noexcept -> void
+    void* ctx, char const* target, char const* data) noexcept -> void
   {
     static_cast<executor*>(ctx)->try_handle_event(
-        processing_instructions_event{
-            .target = util::lazy_zstring_view{target},
-            .data = util::lazy_zstring_view{data},
-        });
+      processing_instructions_event{
+        .target = util::lazy_zstring_view{target},
+        .data = util::lazy_zstring_view{data},
+      });
   }
 
   static auto handle_external_entity_ref(
-      XML_Parser, char const* /* context */, char const* /* base */,
-      char const* /* system_id */, char const* /* public_id */) noexcept -> int
+    XML_Parser, char const* /* context */, char const* /* base */,
+    char const* /* system_id */, char const* /* public_id */) noexcept -> int
   {
     return XML_STATUS_ERROR;
   }
 
   static auto handle_start_namespace_decl(
-      void* ctx, char const* prefix, char const* uri) noexcept -> void
+    void* ctx, char const* prefix, char const* uri) noexcept -> void
   {
     if (prefix)
     {
       static_cast<executor*>(ctx)
-          ->namespaces_[std::string_view{prefix}]
-          .emplace_back(uri);
+        ->namespaces_[std::string_view{prefix}]
+        .emplace_back(uri);
     }
     else
     {
       static_cast<executor*>(ctx)->default_namespace_.push_back(
-          uri ? std::make_optional<std::string>(uri) : std::nullopt);
+        uri ? std::make_optional<std::string>(uri) : std::nullopt);
     }
   }
 
   static auto handle_end_namespace_decl(void* ctx, char const* prefix) noexcept
-      -> void
+    -> void
   {
     if (prefix)
     {
       static_cast<executor*>(ctx)
-          ->namespaces_[std::string_view{prefix}]
-          .pop_back();
+        ->namespaces_[std::string_view{prefix}]
+        .pop_back();
     }
     else
     {
@@ -378,16 +378,16 @@ class executor
   }
 
   static auto handle_xml_decl(
-      void* ctx, char const* version, char const* encoding,
-      int standalone) noexcept -> void
+    void* ctx, char const* version, char const* encoding,
+    int standalone) noexcept -> void
   {
     static_cast<executor*>(ctx)->try_handle_event(
-        xml_decl_event{
-            .version = util::lazy_zstring_view{version},
-            .encoding = util::lazy_zstring_view{encoding},
-            .standalone = standalone < 0 ? std::nullopt
-                                         : std::make_optional(standalone > 0),
-        });
+      xml_decl_event{
+        .version = util::lazy_zstring_view{version},
+        .encoding = util::lazy_zstring_view{encoding},
+        .standalone =
+          standalone < 0 ? std::nullopt : std::make_optional(standalone > 0),
+      });
   }
 
   inline auto advance_flag() -> bool { return advance_; }
@@ -431,7 +431,7 @@ public:
   inline auto event() const -> std::optional<event> const& { return ev_; }
 
   inline auto resolve_namespace(std::string_view prefix)
-      -> std::optional<std::string_view>
+    -> std::optional<std::string_view>
   {
     if (auto it = namespaces_.find(prefix);
         it != namespaces_.end() && !it->second.empty())
@@ -442,8 +442,8 @@ public:
   [[nodiscard]] inline auto position() -> position
   {
     return {
-        .line = XML_GetCurrentLineNumber(p_),
-        .col = XML_GetCurrentColumnNumber(p_),
+      .line = XML_GetCurrentLineNumber(p_),
+      .col = XML_GetCurrentColumnNumber(p_),
     };
   }
 
@@ -573,7 +573,7 @@ public:
         return false;
       }
       auto await_suspend(std::coroutine_handle<promise<T>> h)
-          -> std::coroutine_handle<>
+        -> std::coroutine_handle<>
       {
         // Passed coroutine handle will be the same as
         // parser<T>::handle_type::from_promise(*this)
@@ -621,13 +621,13 @@ using parser_result_t = T::result_type;
 
 template <class T, class... Args>
 concept parser_invocable =
-    std::invocable<T, Args...>
-    && parser_of<std::invoke_result_t<T, Args...>, unconstrained>;
+  std::invocable<T, Args...>
+  && parser_of<std::invoke_result_t<T, Args...>, unconstrained>;
 
 template <class Fn, class... Args>
   requires parser_invocable<Fn, Args...>
 using parser_invoke_result_t =
-    parser_result_t<std::invoke_result_t<Fn, Args...>>;
+  parser_result_t<std::invoke_result_t<Fn, Args...>>;
 
 template <event_type T>
 auto expect_event(executor_ref e) -> parser<T>
@@ -637,28 +637,28 @@ auto expect_event(executor_ref e) -> parser<T>
   {
     auto pos = e->position();
     throw std::runtime_error{std::format(
-        "at {}:{}: unexpected event type, have {}", pos.line, pos.col,
-        ev.index())};
+      "at {}:{}: unexpected event type, have {}", pos.line, pos.col,
+      ev.index())};
   }
   e->set_advance_flag();
   co_return std::get<T>(ev);
 }
 
 inline auto expect_start_element(executor_ref e, qname_view want)
-    -> parser<attribute_view>
+  -> parser<attribute_view>
 {
   auto ev = co_await expect_event<start_element_event>(e);
   if (ev.name != want)
   {
     auto pos = e->position();
     throw std::runtime_error{std::format(
-        "at {}:{}: unexpected element started", pos.line, pos.col)};
+      "at {}:{}: unexpected element started", pos.line, pos.col)};
   }
   co_return ev.attrs;
 }
 
 inline auto allow_start_element(executor_ref e, qname_view want)
-    -> parser<std::optional<attribute_view>>
+  -> parser<std::optional<attribute_view>>
 {
   auto ev = co_await current_event(e);
   if (auto const* pev = std::get_if<start_element_event>(&ev))
@@ -707,9 +707,9 @@ inline auto ignore_whitespace(executor_ref e) -> parser<void>
 }
 
 auto expect_element(
-    executor_ref e, qname_view want,
-    parser_invocable<executor_ref, attribute_view> auto p)
-    -> parser<parser_invoke_result_t<decltype(p), executor_ref, attribute_view>>
+  executor_ref e, qname_view want,
+  parser_invocable<executor_ref, attribute_view> auto p)
+  -> parser<parser_invoke_result_t<decltype(p), executor_ref, attribute_view>>
 {
   co_await ignore_whitespace(e);
   auto attrs = co_await expect_start_element(e, want);
@@ -717,14 +717,14 @@ auto expect_element(
   co_await expect_end_element(e, want);
   co_await ignore_whitespace(e);
   co_return std::forward<
-      parser_invoke_result_t<decltype(p), executor_ref, attribute_view>>(res);
+    parser_invoke_result_t<decltype(p), executor_ref, attribute_view>>(res);
 }
 
 auto allow_element(
-    executor_ref e, qname_view want,
-    parser_invocable<executor_ref, attribute_view> auto p)
-    -> parser<std::optional<
-        parser_invoke_result_t<decltype(p), executor_ref, attribute_view>>>
+  executor_ref e, qname_view want,
+  parser_invocable<executor_ref, attribute_view> auto p)
+  -> parser<std::optional<
+    parser_invoke_result_t<decltype(p), executor_ref, attribute_view>>>
 {
   co_await ignore_whitespace(e);
   if (auto mattrs = co_await allow_start_element(e, want))
@@ -733,18 +733,18 @@ auto allow_element(
     co_await expect_end_element(e, want);
     co_await ignore_whitespace(e);
     co_return std::make_optional(
-        std::forward<
-            parser_invoke_result_t<decltype(p), executor_ref, attribute_view>>(
-            res));
+      std::forward<
+        parser_invoke_result_t<decltype(p), executor_ref, attribute_view>>(
+        res));
   }
   co_return std::nullopt;
 }
 
 auto allow_element(
-    executor_ref e, qname_view want,
-    parser_invocable<executor_ref, attribute_view> auto p) -> parser<bool>
+  executor_ref e, qname_view want,
+  parser_invocable<executor_ref, attribute_view> auto p) -> parser<bool>
   requires std::is_void_v<
-      parser_invoke_result_t<decltype(p), executor_ref, attribute_view>>
+    parser_invoke_result_t<decltype(p), executor_ref, attribute_view>>
 {
   co_await ignore_whitespace(e);
   if (auto mattrs = co_await allow_start_element(e, want))
@@ -759,7 +759,7 @@ auto allow_element(
 
 inline auto
 ignore_contents(executor_ref e, std::optional<qname_view> muntil = std::nullopt)
-    -> parser<void>
+  -> parser<void>
 {
   std::size_t depth = 0;
   while (true)
@@ -791,7 +791,7 @@ ignore_contents(executor_ref e, std::optional<qname_view> muntil = std::nullopt)
   }
 }
 inline auto ignore_element_contents(executor_ref e, attribute_view)
-    -> parser<void>
+  -> parser<void>
 {
   co_await ignore_contents(e);
 }
@@ -814,7 +814,7 @@ inline auto read_string(executor_ref e) -> parser<std::string>
   }
 }
 inline auto read_string_contents(executor_ref e, attribute_view)
-    -> parser<std::string>
+  -> parser<std::string>
 {
   co_return co_await read_string(e);
 }
@@ -823,7 +823,7 @@ template <auto f>
 auto hohalo()
 {
   return []<class... Args>(
-             Args&&... args) -> std::invoke_result_t<decltype(f), Args...>
+           Args&&... args) -> std::invoke_result_t<decltype(f), Args...>
   { co_return co_await f(std::forward<Args>(args)...); };
 }