Merge pull request #60 from beman-project/clang-format

clang-formated the code

Author: dietmarkuehl

examples/allocator.cpp

@@ -8,94 +8,69 @@
 
 namespace ex = beman::execution26;
 
-namespace
-{
-    template <std::size_t Size>
-    struct inline_resource
-        : std::pmr::memory_resource
-    {
-        char const* name;
-        inline_resource(char const* name): name(name) {}
-        std::byte  buffer[Size];
-        std::byte* next{+this->buffer};
+namespace {
+template <std::size_t Size>
+struct inline_resource : std::pmr::memory_resource {
+    const char* name;
+    inline_resource(const char* name) : name(name) {}
+    std::byte  buffer[Size];
+    std::byte* next{+this->buffer};
 
-        void* do_allocate(std::size_t size, std::size_t) override {
-            std::cout << "allocating from=" << this->name << ", size=" << size << "\n";
-            if (size <= std::size_t(std::distance(next, std::end(buffer)))) {
-                std::byte* rc{this->next};
-                this->next += size;
-                return rc;
-            }
-            return nullptr;
+    void* do_allocate(std::size_t size, std::size_t) override {
+        std::cout << "allocating from=" << this->name << ", size=" << size << "\n";
+        if (size <= std::size_t(std::distance(next, std::end(buffer)))) {
+            std::byte* rc{this->next};
+            this->next += size;
+            return rc;
         }
-        void do_deallocate(void*, std::size_t, std::size_t) override {
-        }
-        bool do_is_equal(std::pmr::memory_resource const& other) const noexcept override {
-            return this == &other;
-        }
-    };
+        return nullptr;
+    }
+    void do_deallocate(void*, std::size_t, std::size_t) override {}
+    bool do_is_equal(const std::pmr::memory_resource& other) const noexcept override { return this == &other; }
+};
 
-    template <typename Fun>
-    struct allocator_aware_fun
-    {
-        using allocator_type = std::pmr::polymorphic_allocator<>;
+template <typename Fun>
+struct allocator_aware_fun {
+    using allocator_type = std::pmr::polymorphic_allocator<>;
 
-        std::remove_cvref_t<Fun> fun;
-        allocator_type           allocator{};
+    std::remove_cvref_t<Fun> fun;
+    allocator_type           allocator{};
 
-        template <typename F>
-            requires std::same_as<std::remove_cvref_t<F>, std::remove_cvref_t<Fun>>
-        allocator_aware_fun(F&& fun): fun(std::forward<F>(fun)) {}
-        allocator_aware_fun(allocator_aware_fun const& other, allocator_type allocator = {})
-            : fun(other.fun)
-            , allocator(allocator)
-        {
-        }
-        allocator_aware_fun(allocator_aware_fun&& other)
-            : fun(std::move(other.fun))
-            , allocator(other.allocator)
-        {
-        }
-        allocator_aware_fun(allocator_aware_fun&& other, allocator_type allocator)
-            : fun(std::move(other.fun))
-            , allocator(allocator)
-        {
-        }
+    template <typename F>
+        requires std::same_as<std::remove_cvref_t<F>, std::remove_cvref_t<Fun>>
+    allocator_aware_fun(F&& fun) : fun(std::forward<F>(fun)) {}
+    allocator_aware_fun(const allocator_aware_fun& other, allocator_type allocator = {})
+        : fun(other.fun), allocator(allocator) {}
+    allocator_aware_fun(allocator_aware_fun&& other) : fun(std::move(other.fun)), allocator(other.allocator) {}
+    allocator_aware_fun(allocator_aware_fun&& other, allocator_type allocator)
+        : fun(std::move(other.fun)), allocator(allocator) {}
 
-        template <typename... Args>
-        auto operator()(Args&&... args) noexcept
-        {
-            return this->fun(this->allocator, std::forward<Args>(args)...);
-        }
-    };
-    template <typename Fun>
-    allocator_aware_fun(Fun&& fun) -> allocator_aware_fun<Fun>;
+    template <typename... Args>
+    auto operator()(Args&&... args) noexcept {
+        return this->fun(this->allocator, std::forward<Args>(args)...);
+    }
+};
+template <typename Fun>
+allocator_aware_fun(Fun&& fun) -> allocator_aware_fun<Fun>;
 
-    struct allocator_env
-    {
-        std::pmr::polymorphic_allocator<> allocator{};
-        auto query(ex::get_allocator_t) const noexcept -> std::pmr::polymorphic_allocator<> {
-            return this->allocator;
-        }
-    };
-}
+struct allocator_env {
+    std::pmr::polymorphic_allocator<> allocator{};
+    auto query(ex::get_allocator_t) const noexcept -> std::pmr::polymorphic_allocator<> { return this->allocator; }
+};
+} // namespace
 
-auto main() -> int
-{
-    int values[] = { 1, 2, 3 };
-    auto s{
-        ex::just(std::span(values))
-        | ex::let_value(allocator_aware_fun([](auto alloc, std::span<int> v){
-                return ex::just(std::pmr::vector<int>(v.begin(), v.end(), alloc));
-            }))
-        | ex::then([](auto&& v) noexcept {
-            for (auto x: v){ std::cout << x << ", "; }
-            std::cout << "\n";
-        })
-    };
+auto main() -> int {
+    int  values[] = {1, 2, 3};
+    auto s{ex::just(std::span(values)) | ex::let_value(allocator_aware_fun([](auto alloc, std::span<int> v) {
+               return ex::just(std::pmr::vector<int>(v.begin(), v.end(), alloc));
+           })) |
+           ex::then([](auto&& v) noexcept {
+               for (auto x : v) {
+                   std::cout << x << ", ";
+               }
+               std::cout << "\n";
+           })};
 
     inline_resource<1024> state_resource("state");
-    ex::sync_wait(
-        ex::detail::write_env(std::move(s), allocator_env{&state_resource})
-    );
+    ex::sync_wait(ex::detail::write_env(std::move(s), allocator_env{&state_resource}));
 }

examples/stop_token.cpp

@@ -46,63 +46,53 @@ namespace exec = beman::execution26;
 // - std::print isn't available everywhere, yet. Let's try a simple
 //   placeholder.
 static ::std::mutex io_lock;
-void print(std::string_view text, auto&&...)
-{
-    std::lock_guard     guard(io_lock);
+void                print(std::string_view text, auto&&...) {
+    std::lock_guard guard(io_lock);
     ::std::cout << text;
 }
 
 template <typename Token>
-auto active(Token token) -> void
-{
+auto active(Token token) -> void {
     auto i{0ull};
-    while (not token.stop_requested())
-    {
+    while (not token.stop_requested()) {
         // do work
         ++i;
     }
-    print("active thread done: {}\n" , i);
+    print("active thread done: {}\n", i);
 }
 
 template <typename Token, typename Callback>
-struct stop_callback_for_t
-{
+struct stop_callback_for_t {
     exec::stop_callback_for_t<Token, Callback> cb;
-    stop_callback_for_t(Token const& token, Callback callback)
-        : cb(token, callback)
-    {
-    }
+    stop_callback_for_t(const Token& token, Callback callback) : cb(token, callback) {}
 };
 
 #ifdef __cpp_lib_latch
 template <typename Token>
-auto inactive(Token token) -> void
-{
+auto inactive(Token token) -> void {
     ::std::latch        latch(1);
-    stop_callback_for_t cb(token, [&latch]{ latch.count_down(); });
+    stop_callback_for_t cb(token, [&latch] { latch.count_down(); });
 
     latch.wait();
     print("inactive thread done (latch)\n");
 }
 #else
 template <typename Token>
-auto inactive(Token token) -> void
-{
+auto inactive(Token token) -> void {
     ::std::condition_variable cond;
-    stop_callback_for_t cb(token, [&cond]{ cond.notify_one(); });
+    stop_callback_for_t       cb(token, [&cond] { cond.notify_one(); });
 
-    ::std::mutex lock;
+    ::std::mutex       lock;
     ::std::unique_lock guard(lock);
-    cond.wait(guard, [token]{ return token.stop_requested(); });
+    cond.wait(guard, [token] { return token.stop_requested(); });
     print("inactive thread done (condition_variable)\n");
 }
 #endif
 
-auto main() -> int
-{
+auto main() -> int {
     exec::stop_source source;
-    ::std::thread act([token = source.get_token()] { active(token); });
-    ::std::thread inact([token = source.get_token()] { inactive(token); });
+    ::std::thread     act([token = source.get_token()] { active(token); });
+    ::std::thread     inact([token = source.get_token()] { inactive(token); });
 
     print("threads started\n");
     source.request_stop();

examples/stopping.cpp

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 // The example shows a bit of how cancellation works:
-// It creates work with a sender injecting a stop token 
+// It creates work with a sender injecting a stop token
 // which gets started in a thread. To stop this thread
 // the corresponding stop source is requested to stop.
 
@@ -18,34 +18,26 @@ namespace ex = beman::execution26;
 
 // ----------------------------------------------------------------------------
 
-struct env
-{
+struct env {
     ex::inplace_stop_token token;
 
-    env(ex::inplace_stop_token token): token(token) {}
+    env(ex::inplace_stop_token token) : token(token) {}
 
-    auto query(ex::get_stop_token_t const&) const noexcept {
-        return this->token;
-    }
+    auto query(const ex::get_stop_token_t&) const noexcept { return this->token; }
 };
 
 template <typename Sender>
-struct inject_cancel_sender
-{
+struct inject_cancel_sender {
     using sender_concept = ex::sender_t;
 
-
     template <typename Receiver>
-    struct receiver
-    {
+    struct receiver {
         using receiver_concept = ex::receiver_t;
 
         std::remove_cvref_t<Receiver> inner_receiver;
         ex::inplace_stop_token        token{};
 
-        auto get_env() const noexcept -> env {
-            return {this->token};
-        }
+        auto get_env() const noexcept -> env { return {this->token}; }
 
         template <typename... T>
         auto set_value(T&&... t) noexcept -> void {
@@ -55,18 +47,16 @@ struct inject_cancel_sender
         auto set_error(E&& e) noexcept -> void {
             ex::set_error(std::move(inner_receiver), std::forward<E>(e));
         }
-        auto set_stopped() noexcept -> void {
-            ex::set_stopped(std::move(inner_receiver));
-        }
+        auto set_stopped() noexcept -> void { ex::set_stopped(std::move(inner_receiver)); }
     };
 
     template <typename E>
-    auto get_completion_signatures(E const&) {
+    auto get_completion_signatures(const E&) {
         return ex::get_completion_signatures(this->sender, env{ex::inplace_stop_token{}});
     }
 
     ex::inplace_stop_token token{};
-    Sender sender;
+    Sender                 sender;
 
     template <typename Receiver>
     auto connect(Receiver&& recv) && {
@@ -77,37 +67,29 @@ struct inject_cancel_sender
 template <typename S>
 inject_cancel_sender(ex::inplace_stop_token, S&&) -> inject_cancel_sender<std::decay_t<S>>;
 
-struct receiver
-{
+struct receiver {
     using receiver_concept = ex::receiver_t;
     auto set_value(auto&&...) noexcept -> void {}
     auto set_error(auto&&) noexcept -> void {}
     auto set_stopped() noexcept -> void {}
 };
 
-int main()
-{
+int main() {
     ex::inplace_stop_source source;
 
-    std::thread t([token=source.get_token()]{
+    std::thread t([token = source.get_token()] {
         ex::sync_wait(
-            inject_cancel_sender{token,
-                ex::read_env(ex::get_stop_token)
-                | ex::then([](ex::inplace_stop_token tok){
-                    while (not tok.stop_requested())
-                    {
-                        std::cout << "sleeping\n";
-                        std::this_thread::sleep_for(1s);
-                    }
-                })
-            });
-        }
-    );
+            inject_cancel_sender{token, ex::read_env(ex::get_stop_token) | ex::then([](ex::inplace_stop_token tok) {
+                                            while (not tok.stop_requested()) {
+                                                std::cout << "sleeping\n";
+                                                std::this_thread::sleep_for(1s);
+                                            }
+                                        })});
+    });
 
     std::cin.get();
     std::cout << "requesting stop\n";
     source.request_stop();
 
     t.join();
 }
-