add async-global-executor implementation of Executor

Author: Keruspe

Cargo.lock

@@ -14,12 +14,19 @@ rust-version = "1.85.0"
 
 [features]
 default = ["tokio"]
+async-global-executor = ["dep:async-global-executor"]
 smol = ["dep:smol"]
 tokio = ["dep:tokio"]
 
 [dependencies]
 async-trait = "^0.1.89"
 
+[dependencies.async-global-executor]
+version = "^3.1"
+optional = true
+default-features = false
+features = ["async-io"]
+
 [dependencies.smol]
 version = "^2.0"
 optional = true

Cargo.toml

@@ -0,0 +1,78 @@
+//! async-global-executor implementation of async runtime definition traits
+
+use crate::executor::{Executor, Task};
+use alloc::boxed::Box;
+use async_trait::async_trait;
+use core::{
+    future::Future,
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+/// Dummy object implementing executor-trait common interfaces on top of async-global-executor
+#[derive(Debug, Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub struct AsyncGlobalExecutor;
+
+struct AGETask<T>(Option<async_global_executor::Task<T>>);
+
+impl Executor for AsyncGlobalExecutor {
+    fn block_on<T>(&self, f: Pin<Box<dyn Future<Output = T>>>) -> T {
+        async_global_executor::block_on(f)
+    }
+
+    fn spawn<T: Send + 'static>(
+        &self,
+        f: impl Future<Output = T> + Send + 'static,
+    ) -> impl Task<T> {
+        AGETask(Some(async_global_executor::spawn(f)))
+    }
+
+    fn spawn_blocking<F: FnOnce() -> T + Send + 'static, T: Send + 'static>(
+        &self,
+        f: F,
+    ) -> impl Task<T> {
+        AGETask(Some(async_global_executor::spawn_blocking(f)))
+    }
+}
+
+#[async_trait(?Send)]
+impl<T> Task<T> for AGETask<T> {
+    async fn cancel(&mut self) -> Option<T> {
+        self.0.take()?.cancel().await
+    }
+}
+
+impl<T> Drop for AGETask<T> {
+    fn drop(&mut self) {
+        if let Some(task) = self.0.take() {
+            task.detach();
+        }
+    }
+}
+
+impl<T> Future for AGETask<T> {
+    type Output = T;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        Pin::new(self.0.as_mut().expect("task canceled")).poll(cx)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use alloc::string::String;
+
+    #[test]
+    fn dyn_compat() {
+        struct Test {
+            _executor: Box<dyn Executor>,
+            _task: Box<dyn Task<String>>,
+        }
+
+        let _ = Test {
+            _executor: Box::new(AsyncGlobalExecutor::default()),
+            _task: Box::new(AGETask(None)),
+        };
+    }
+}

src/async_global_executor.rs

@@ -9,6 +9,9 @@ extern crate core;
 
 pub mod executor;
 
+#[cfg(feature = "async-global-executor")]
+pub mod async_global_executor;
+
 #[cfg(feature = "smol")]
 pub mod smol;