clang-format

Author: dietmarkuehl

include/beman/execution/detail/async_scope_token.hpp

@@ -13,30 +13,29 @@
 // ----------------------------------------------------------------------------
 
 namespace beman::execution::detail {
-    struct token_test_env {};
-
-    struct token_test_sender {
-        using sender_concept = ::beman::execution::sender_t;
-        auto get_completion_signatures(::beman::execution::detail::token_test_env) const noexcept {
-            return ::beman::execution::completion_signatures<>{};
-        }
-    };
-    static_assert(::beman::execution::sender<::beman::execution::detail::token_test_sender>);
-    static_assert(::beman::execution::sender_in<::beman::execution::detail::token_test_sender, ::beman::execution::detail::token_test_env>);
-}
+struct token_test_env {};
+
+struct token_test_sender {
+    using sender_concept = ::beman::execution::sender_t;
+    auto get_completion_signatures(::beman::execution::detail::token_test_env) const noexcept {
+        return ::beman::execution::completion_signatures<>{};
+    }
+};
+static_assert(::beman::execution::sender<::beman::execution::detail::token_test_sender>);
+static_assert(::beman::execution::sender_in<::beman::execution::detail::token_test_sender,
+                                            ::beman::execution::detail::token_test_env>);
+} // namespace beman::execution::detail
 
 namespace beman::execution {
-    template <typename Token>
-    concept async_scope_token
-        = ::std::copyable<Token>
-        && requires(Token token) {
-            { token.try_associate() } -> ::std::same_as<bool>;
-            { token.disassociate() } noexcept;
-            { token.wrap(::std::declval<::beman::execution::detail::token_test_sender>()) }
-                -> ::beman::execution::sender_in<::beman::execution::detail::token_test_env>;
-        }
-        ;
-}
+template <typename Token>
+concept async_scope_token = ::std::copyable<Token> && requires(Token token) {
+    { token.try_associate() } -> ::std::same_as<bool>;
+    { token.disassociate() } noexcept;
+    {
+        token.wrap(::std::declval<::beman::execution::detail::token_test_sender>())
+    } -> ::beman::execution::sender_in<::beman::execution::detail::token_test_env>;
+};
+} // namespace beman::execution
 
 // ----------------------------------------------------------------------------
 

include/beman/execution/detail/nest.hpp

@@ -10,13 +10,12 @@
 // ----------------------------------------------------------------------------
 
 namespace beman::execution {
-    struct nest_t {
-        template <::beman::execution::sender Sender, ::beman::execution::async_scope_token Token>
-        auto operator()(Sender&&, Token&&) const {
-        }
-    };
-    inline constexpr nest_t nest{};
-}
+struct nest_t {
+    template <::beman::execution::sender Sender, ::beman::execution::async_scope_token Token>
+    auto operator()(Sender&&, Token&&) const {}
+};
+inline constexpr nest_t nest{};
+} // namespace beman::execution
 
 // ----------------------------------------------------------------------------
 

tests/beman/execution/exec-nest.test.cpp

@@ -8,18 +8,18 @@
 // ----------------------------------------------------------------------------
 
 namespace {
-    struct sender {
-        using sender_concept = test_std::sender_t;
-    };
-    static_assert(test_std::sender<sender>);
-    static_assert(test_std::sender<sender&>);
-    static_assert(test_std::sender<sender const&>);
-}
+struct sender {
+    using sender_concept = test_std::sender_t;
+};
+static_assert(test_std::sender<sender>);
+static_assert(test_std::sender<sender&>);
+static_assert(test_std::sender<const sender&>);
+} // namespace
 
 TEST(exec_nest) {
-    static_assert(std::same_as<test_std::nest_t const, decltype(test_std::nest)>);
+    static_assert(std::same_as<const test_std::nest_t, decltype(test_std::nest)>);
 
     sender sndr{};
-    int token{};
-    //test_std::nest(sndr, token);
+    int    token{};
+    // test_std::nest(sndr, token);
 }

tests/beman/execution/exec-scope-concepts.test.cpp

@@ -13,47 +13,48 @@
 // ----------------------------------------------------------------------------
 
 namespace {
-    struct sender {
-        using sender_concept = test_std::sender_t;
-    };
-    static_assert(test_std::sender<sender>);
+struct sender {
+    using sender_concept = test_std::sender_t;
+};
+static_assert(test_std::sender<sender>);
 
-    struct copyable {};
-    static_assert(std::copyable<copyable>);
-    struct non_copyable {
-        non_copyable() = default;
-        non_copyable(non_copyable const&) = delete;
-    };
-    static_assert(not std::copyable<non_copyable>);
+struct copyable {};
+static_assert(std::copyable<copyable>);
+struct non_copyable {
+    non_copyable()                    = default;
+    non_copyable(const non_copyable&) = delete;
+};
+static_assert(not std::copyable<non_copyable>);
 
-    struct empty {};
+struct empty {};
 
-    template <test_std::sender S>
-    struct wrap {
-        using sender_concept = test_std::sender_t;
-        std::remove_cvref_t<S> sndr;
-        template <typename E>
-        auto get_completion_signatures(E const& e) const noexcept {
-            return test_std::get_completion_signatures(sndr, e);
-        }
-    };
-    static_assert(test_std::sender<wrap<sender>>);
+template <test_std::sender S>
+struct wrap {
+    using sender_concept = test_std::sender_t;
+    std::remove_cvref_t<S> sndr;
+    template <typename E>
+    auto get_completion_signatures(const E& e) const noexcept {
+        return test_std::get_completion_signatures(sndr, e);
+    }
+};
+static_assert(test_std::sender<wrap<sender>>);
 
-    template <test_std::sender>
-    struct bad {
-        using sender_concept = test_std::sender_t;
-    };
+template <test_std::sender>
+struct bad {
+    using sender_concept = test_std::sender_t;
+};
 
-
-    template <typename Mem, typename Bool, bool Noexcept, template <test_std::sender> class Wrap>
-    struct token {
-        Mem mem{};
-        auto try_associate() -> Bool { return {}; }
-        auto disassociate() noexcept(Noexcept) -> void {}
-        template <test_std::sender Sender>
-        auto wrap(Sender&& sndr) -> Wrap<Sender> { return Wrap<Sender>(std::forward<Sender>(sndr)); }
-    };
-}
+template <typename Mem, typename Bool, bool Noexcept, template <test_std::sender> class Wrap>
+struct token {
+    Mem  mem{};
+    auto try_associate() -> Bool { return {}; }
+    auto disassociate() noexcept(Noexcept) -> void {}
+    template <test_std::sender Sender>
+    auto wrap(Sender&& sndr) -> Wrap<Sender> {
+        return Wrap<Sender>(std::forward<Sender>(sndr));
+    }
+};
+} // namespace
 
 TEST(exec_scope_concepts) {
     static_assert(test_std::async_scope_token<token<copyable, bool, true, wrap>>);