Rename coro::facade to coro::default_executor

dobord · dobord · commit 8df6ed8c32cf · 2025-03-24T17:08:33.000+03:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -91,7 +91,7 @@ set(LIBCORO_SOURCE_FILES
     include/coro/coro.hpp
     include/coro/condition_variable.hpp src/condition_variable.cpp
     include/coro/event.hpp src/event.cpp
-    include/coro/facade.hpp src/facade.cpp
+    include/coro/default_executor.hpp src/default_executor.cpp
     include/coro/generator.hpp
     include/coro/latch.hpp
     include/coro/mutex.hpp src/mutex.cpp
diff --git a/README.md b/README.md
@@ -801,7 +801,7 @@ struct Params
 
 int main()
 {
-    auto*                         scheduler = coro::facade::instance();
+    auto*                         scheduler = coro::default_executor::instance();
     std::vector<coro::task<void>> tasks{};
     auto                          params = std::make_shared<Params>();
     params->max_value                    = 20;
diff --git a/examples/coro_condition_variable.cpp b/examples/coro_condition_variable.cpp
@@ -89,7 +89,7 @@ struct Params
 
 int main()
 {
-    auto*                         scheduler = coro::facade::instance();
+    auto*                         scheduler = coro::default_executor::instance();
     std::vector<coro::task<void>> tasks{};
     auto                          params = std::make_shared<Params>();
     params->max_value                    = 20;
diff --git a/include/coro/condition_variable.hpp b/include/coro/condition_variable.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "coro/facade.hpp"
+#include "coro/default_executor.hpp"
 #ifdef LIBCORO_FEATURE_NETWORKING
     #include "coro/io_scheduler.hpp"
 #else
@@ -156,7 +156,7 @@ class strategy_based_on_io_scheduler
 
 public:
     explicit strategy_based_on_io_scheduler(
-        std::shared_ptr<io_scheduler> io_scheduler = coro::facade::instance()->get_io_scheduler());
+        std::shared_ptr<io_scheduler> io_scheduler = coro::default_executor::instance()->get_io_scheduler());
 
     ~strategy_based_on_io_scheduler();
 
diff --git a/include/coro/coro.hpp b/include/coro/coro.hpp
@@ -30,8 +30,8 @@
 #endif
 
 #include "coro/condition_variable.hpp"
+#include "coro/default_executor.hpp"
 #include "coro/event.hpp"
-#include "coro/facade.hpp"
 #include "coro/generator.hpp"
 #include "coro/latch.hpp"
 #include "coro/mutex.hpp"
diff --git a/include/coro/default_executor.hpp b/include/coro/default_executor.hpp
@@ -10,19 +10,19 @@ namespace coro
 {
 
 /**
- * Facade for universal access to default scheduler or default thread pool.
- * This facade supports the concept of coro::concepts::executor.
+ * Default executor for universal access to default scheduler or default thread pool.
+ * This coro::default_executor supports the concept of coro::concepts::executor.
  */
-class facade
+class default_executor
 {
 public:
-    facade();
+    default_executor();
 
     /**
-     * Getting a single instance of facade per process
-     * @return single instance of facade
+     * Getting a single instance of default_executor per process
+     * @return single instance of default_executor
      */
-    static facade* instance();
+    static default_executor* instance();
 
 #ifdef LIBCORO_FEATURE_NETWORKING
     [[nodiscard]] auto schedule() -> coro::io_scheduler::schedule_operation;
@@ -54,7 +54,7 @@ class facade
 
 #ifdef LIBCORO_FEATURE_NETWORKING
     /**
-     * Set up default coro::io_scheduler::options before constructing a single instance of the facade
+     * Set up default coro::io_scheduler::options before constructing a single instance of the default_executor
      * @param io_scheduler_options io_scheduler options
      */
     static void set_io_scheduler_options(io_scheduler::options io_scheduler_options);
@@ -65,7 +65,7 @@ class facade
     std::shared_ptr<io_scheduler> get_io_scheduler();
 #else
     /**
-     * Set up default coro::thread_pool::options before constructing a single instance of the facade
+     * Set up default coro::thread_pool::options before constructing a single instance of the default_executor
      * @param thread_pool_options thread_pool options
      */
     static void set_thread_pool_options(thread_pool::options thread_pool_options);
diff --git a/src/default_executor.cpp b/src/default_executor.cpp
@@ -1,28 +1,28 @@
-#include "coro/facade.hpp"
+#include "coro/default_executor.hpp"
 #include <atomic>
 #include <memory>
 
-static std::atomic<coro::facade*> s_facade = {nullptr};
+static std::atomic<coro::default_executor*> s_facade = {nullptr};
 
 #ifdef LIBCORO_FEATURE_NETWORKING
-coro::io_scheduler::options coro::facade::s_io_scheduler_options;
+coro::io_scheduler::options coro::default_executor::s_io_scheduler_options;
 #else
 coro::thread_pool::options coro::facade::s_thread_pool_options;
 #endif
 
-coro::facade* coro::facade::instance()
+coro::default_executor* coro::default_executor::instance()
 {
     auto* result = s_facade.load(std::memory_order::acquire);
     if (!result)
     {
-        auto ptr = std::make_unique<facade>();
+        auto ptr = std::make_unique<default_executor>();
         if (s_facade.compare_exchange_strong(result, ptr.get(), std::memory_order::release, std::memory_order::acquire))
             result = ptr.release();
     }
     return result;
 }
 
-coro::facade::facade()
+coro::default_executor::default_executor()
 {
 #ifdef LIBCORO_FEATURE_NETWORKING
     m_io_scheduler = io_scheduler::make_shared(s_io_scheduler_options);
@@ -31,7 +31,7 @@ coro::facade::facade()
 #endif
 }
 
-bool coro::facade::spawn(coro::task<void>&& task) noexcept
+bool coro::default_executor::spawn(coro::task<void>&& task) noexcept
 {
 #ifdef LIBCORO_FEATURE_NETWORKING
     return m_io_scheduler->spawn(std::move(task));
@@ -40,7 +40,7 @@ bool coro::facade::spawn(coro::task<void>&& task) noexcept
 #endif
 }
 
-bool coro::facade::resume(std::coroutine_handle<> handle)
+bool coro::default_executor::resume(std::coroutine_handle<> handle)
 {
 #ifdef LIBCORO_FEATURE_NETWORKING
     return m_io_scheduler->resume(handle);
@@ -49,7 +49,7 @@ bool coro::facade::resume(std::coroutine_handle<> handle)
 #endif
 }
 
-std::size_t coro::facade::size()
+std::size_t coro::default_executor::size()
 {
 #ifdef LIBCORO_FEATURE_NETWORKING
     return m_io_scheduler->size();
@@ -58,7 +58,7 @@ std::size_t coro::facade::size()
 #endif
 }
 
-bool coro::facade::empty()
+bool coro::default_executor::empty()
 {
 #ifdef LIBCORO_FEATURE_NETWORKING
     return m_io_scheduler->empty();
@@ -67,7 +67,7 @@ bool coro::facade::empty()
 #endif
 }
 
-void coro::facade::shutdown()
+void coro::default_executor::shutdown()
 {
 #ifdef LIBCORO_FEATURE_NETWORKING
     m_io_scheduler->shutdown();
@@ -77,7 +77,7 @@ void coro::facade::shutdown()
 }
 
 #ifdef LIBCORO_FEATURE_NETWORKING
-auto coro::facade::schedule() -> coro::io_scheduler::schedule_operation
+auto coro::default_executor::schedule() -> coro::io_scheduler::schedule_operation
 {
     return m_io_scheduler->schedule();
 }
@@ -90,12 +90,12 @@ auto coro::facade::schedule() -> coro::thread_pool::operation
 
 #ifdef LIBCORO_FEATURE_NETWORKING
 
-void coro::facade::set_io_scheduler_options(io_scheduler::options io_scheduler_options)
+void coro::default_executor::set_io_scheduler_options(io_scheduler::options io_scheduler_options)
 {
     s_io_scheduler_options = io_scheduler_options;
 }
 
-std::shared_ptr<coro::io_scheduler> coro::facade::get_io_scheduler()
+std::shared_ptr<coro::io_scheduler> coro::default_executor::get_io_scheduler()
 {
     return m_io_scheduler;
 }
diff --git a/test/test_condition_variable.cpp b/test/test_condition_variable.cpp
@@ -15,7 +15,7 @@ TEST_CASE("condition_variable single waiter", "[condition_variable]")
 
     std::cout << "condition_variable single waiter" << std::endl;
 
-    auto                     sched = coro::facade::instance()->get_io_scheduler();
+    auto                     sched = coro::default_executor::instance()->get_io_scheduler();
     coro::mutex              m;
     coro::condition_variable cv;
 
@@ -106,7 +106,7 @@ TEST_CASE("condition_variable one notifier and one waiter", "[condition_variable
 
     struct BaseParams
     {
-        std::shared_ptr<coro::io_scheduler> sched = coro::facade::instance()->get_io_scheduler();
+        std::shared_ptr<coro::io_scheduler> sched = coro::default_executor::instance()->get_io_scheduler();
         coro::mutex                         m;
         coro::condition_variable            cv{sched};
     };
@@ -156,7 +156,7 @@ TEST_CASE("condition_variable notify_all", "[condition_variable]")
 
     struct BaseParams
     {
-        std::shared_ptr<coro::io_scheduler> sched = coro::facade::instance()->get_io_scheduler();
+        std::shared_ptr<coro::io_scheduler> sched = coro::default_executor::instance()->get_io_scheduler();
         ;
         coro::mutex              m;
         coro::condition_variable cv{sched};
@@ -209,7 +209,7 @@ TEST_CASE("condition_variable for thread-safe-queue between producers and consum
 
     struct BaseParams
     {
-        coro::facade*            sched = coro::facade::instance();
+        coro::default_executor*  sched = coro::default_executor::instance();
         coro::mutex              m;
         coro::condition_variable cv;
         std::atomic_bool         cancel{false};

Original file line number	Diff line number	Diff line change
`@@ -801,7 +801,7 @@ struct Params`
`801`	`801`
`802`	`802`	`int main()`
`803`	`803`	`{`
`804`		`- auto* scheduler = coro::facade::instance();`
	`804`	`+ auto* scheduler = coro::default_executor::instance();`
`805`	`805`	`std::vector<coro::task<void>> tasks{};`
`806`	`806`	`auto params = std::make_shared<Params>();`
`807`	`807`	`params->max_value = 20;`
Original file line number	Diff line number	Diff line change
`@@ -89,7 +89,7 @@ struct Params`
`89`	`89`
`90`	`90`	`int main()`
`91`	`91`	`{`
`92`		`- auto* scheduler = coro::facade::instance();`
	`92`	`+ auto* scheduler = coro::default_executor::instance();`
`93`	`93`	`std::vector<coro::task<void>> tasks{};`
`94`	`94`	`auto params = std::make_shared<Params>();`
`95`	`95`	`params->max_value = 20;`
Original file line number	Diff line number	Diff line change
`@@ -1,28 +1,28 @@`
`1`		`-#include "coro/facade.hpp"`
	`1`	`+#include "coro/default_executor.hpp"`
`2`	`2`	`#include <atomic>`
`3`	`3`	`#include <memory>`
`4`	`4`
`5`		`-static std::atomic<coro::facade*> s_facade = {nullptr};`
	`5`	`+static std::atomic<coro::default_executor*> s_facade = {nullptr};`
`6`	`6`
`7`	`7`	`#ifdef LIBCORO_FEATURE_NETWORKING`
`8`		`-coro::io_scheduler::options coro::facade::s_io_scheduler_options;`
	`8`	`+coro::io_scheduler::options coro::default_executor::s_io_scheduler_options;`
`9`	`9`	`#else`
`10`	`10`	`coro::thread_pool::options coro::facade::s_thread_pool_options;`
`11`	`11`	`#endif`
`12`	`12`
`13`		`-coro::facade* coro::facade::instance()`
	`13`	`+coro::default_executor* coro::default_executor::instance()`
`14`	`14`	`{`
`15`	`15`	`auto* result = s_facade.load(std::memory_order::acquire);`
`16`	`16`	`if (!result)`
`17`	`17`	`{`
`18`		`- auto ptr = std::make_unique<facade>();`
	`18`	`+ auto ptr = std::make_unique<default_executor>();`
`19`	`19`	`if (s_facade.compare_exchange_strong(result, ptr.get(), std::memory_order::release, std::memory_order::acquire))`
`20`	`20`	`result = ptr.release();`
`21`	`21`	`}`
`22`	`22`	`return result;`
`23`	`23`	`}`
`24`	`24`
`25`		`-coro::facade::facade()`
	`25`	`+coro::default_executor::default_executor()`
`26`	`26`	`{`
`27`	`27`	`#ifdef LIBCORO_FEATURE_NETWORKING`
`28`	`28`	`m_io_scheduler = io_scheduler::make_shared(s_io_scheduler_options);`
`@@ -31,7 +31,7 @@ coro::facade::facade()`
`31`	`31`	`#endif`
`32`	`32`	`}`
`33`	`33`
`34`		`-bool coro::facade::spawn(coro::task<void>&& task) noexcept`
	`34`	`+bool coro::default_executor::spawn(coro::task<void>&& task) noexcept`
`35`	`35`	`{`
`36`	`36`	`#ifdef LIBCORO_FEATURE_NETWORKING`
`37`	`37`	`return m_io_scheduler->spawn(std::move(task));`
`@@ -40,7 +40,7 @@ bool coro::facade::spawn(coro::task<void>&& task) noexcept`
`40`	`40`	`#endif`
`41`	`41`	`}`
`42`	`42`
`43`		`-bool coro::facade::resume(std::coroutine_handle<> handle)`
	`43`	`+bool coro::default_executor::resume(std::coroutine_handle<> handle)`
`44`	`44`	`{`
`45`	`45`	`#ifdef LIBCORO_FEATURE_NETWORKING`
`46`	`46`	`return m_io_scheduler->resume(handle);`
`@@ -49,7 +49,7 @@ bool coro::facade::resume(std::coroutine_handle<> handle)`
`49`	`49`	`#endif`
`50`	`50`	`}`
`51`	`51`
`52`		`-std::size_t coro::facade::size()`
	`52`	`+std::size_t coro::default_executor::size()`
`53`	`53`	`{`
`54`	`54`	`#ifdef LIBCORO_FEATURE_NETWORKING`
`55`	`55`	`return m_io_scheduler->size();`
`@@ -58,7 +58,7 @@ std::size_t coro::facade::size()`
`58`	`58`	`#endif`
`59`	`59`	`}`
`60`	`60`
`61`		`-bool coro::facade::empty()`
	`61`	`+bool coro::default_executor::empty()`
`62`	`62`	`{`
`63`	`63`	`#ifdef LIBCORO_FEATURE_NETWORKING`
`64`	`64`	`return m_io_scheduler->empty();`
`@@ -67,7 +67,7 @@ bool coro::facade::empty()`
`67`	`67`	`#endif`
`68`	`68`	`}`
`69`	`69`
`70`		`-void coro::facade::shutdown()`
	`70`	`+void coro::default_executor::shutdown()`
`71`	`71`	`{`
`72`	`72`	`#ifdef LIBCORO_FEATURE_NETWORKING`
`73`	`73`	`m_io_scheduler->shutdown();`
`@@ -77,7 +77,7 @@ void coro::facade::shutdown()`
`77`	`77`	`}`
`78`	`78`
`79`	`79`	`#ifdef LIBCORO_FEATURE_NETWORKING`
`80`		`-auto coro::facade::schedule() -> coro::io_scheduler::schedule_operation`
	`80`	`+auto coro::default_executor::schedule() -> coro::io_scheduler::schedule_operation`
`81`	`81`	`{`
`82`	`82`	`return m_io_scheduler->schedule();`
`83`	`83`	`}`
`@@ -90,12 +90,12 @@ auto coro::facade::schedule() -> coro::thread_pool::operation`
`90`	`90`
`91`	`91`	`#ifdef LIBCORO_FEATURE_NETWORKING`
`92`	`92`
`93`		`-void coro::facade::set_io_scheduler_options(io_scheduler::options io_scheduler_options)`
	`93`	`+void coro::default_executor::set_io_scheduler_options(io_scheduler::options io_scheduler_options)`
`94`	`94`	`{`
`95`	`95`	`s_io_scheduler_options = io_scheduler_options;`
`96`	`96`	`}`
`97`	`97`
`98`		`-std::shared_ptr<coro::io_scheduler> coro::facade::get_io_scheduler()`
	`98`	`+std::shared_ptr<coro::io_scheduler> coro::default_executor::get_io_scheduler()`
`99`	`99`	`{`
`100`	`100`	`return m_io_scheduler;`
`101`	`101`	`}`