Split embassy-time from embassy-executor.

1 files changed, 0 insertions, 84 deletions

diff --git a/embassy-executor/src/executor/arch/std.rs b/embassy-executor/src/executor/arch/std.rs
deleted file mode 100644
index b93ab8a79..000000000
--- a/embassy-executor/src/executor/arch/std.rs
+++ /dev/null
@@ -1,84 +0,0 @@
-use std::marker::PhantomData;
-use std::sync::{Condvar, Mutex};
-
-use super::{raw, Spawner};
-
-/// Single-threaded std-based executor.
-pub struct Executor {
-    inner: raw::Executor,
-    not_send: PhantomData<*mut ()>,
-    signaler: &'static Signaler,
-}
-
-impl Executor {
-    /// Create a new Executor.
-    pub fn new() -> Self {
-        let signaler = &*Box::leak(Box::new(Signaler::new()));
-        Self {
-            inner: raw::Executor::new(
-                |p| unsafe {
-                    let s = &*(p as *const () as *const Signaler);
-                    s.signal()
-                },
-                signaler as *const _ as _,
-            ),
-            not_send: PhantomData,
-            signaler,
-        }
-    }
-
-    /// Run the executor.
-    ///
-    /// The `init` closure is called with a [`Spawner`] that spawns tasks on
-    /// this executor. Use it to spawn the initial task(s). After `init` returns,
-    /// the executor starts running the tasks.
-    ///
-    /// To spawn more tasks later, you may keep copies of the [`Spawner`] (it is `Copy`),
-    /// for example by passing it as an argument to the initial tasks.
-    ///
-    /// This function requires `&'static mut self`. This means you have to store the
-    /// Executor instance in a place where it'll live forever and grants you mutable
-    /// access. There's a few ways to do this:
-    ///
-    /// - a [Forever](crate::util::Forever) (safe)
-    /// - a `static mut` (unsafe)
-    /// - a local variable in a function you know never returns (like `fn main() -> !`), upgrading its lifetime with `transmute`. (unsafe)
-    ///
-    /// This function never returns.
-    pub fn run(&'static mut self, init: impl FnOnce(Spawner)) -> ! {
-        init(self.inner.spawner());
-
-        loop {
-            unsafe { self.inner.poll() };
-            self.signaler.wait()
-        }
-    }
-}
-
-struct Signaler {
-    mutex: Mutex<bool>,
-    condvar: Condvar,
-}
-
-impl Signaler {
-    fn new() -> Self {
-        Self {
-            mutex: Mutex::new(false),
-            condvar: Condvar::new(),
-        }
-    }
-
-    fn wait(&self) {
-        let mut signaled = self.mutex.lock().unwrap();
-        while !*signaled {
-            signaled = self.condvar.wait(signaled).unwrap();
-        }
-        *signaled = false;
-    }
-
-    fn signal(&self) {
-        let mut signaled = self.mutex.lock().unwrap();
-        *signaled = true;
-        self.condvar.notify_one();
-    }
-}