Stub

lightproc/src/lib.rs

@@ -0,0 +1,5 @@
+mod lightproc;
+mod proc_handle;
+mod proc_data;
+mod proc_vtable;
+mod state;

lightproc/src/lightproc.rs

@@ -0,0 +1,4 @@
+
+pub struct LightProc {
+
+}

lightproc/src/proc_data.rs

@@ -0,0 +1,12 @@
+use std::task::Waker;
+use std::cell::UnsafeCell;
+use proc_vtable::ProcVTable;
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+pub(crate) struct ProcData {
+    pub(crate) state: AtomicUsize,
+
+    pub(crate) awaiter: UnsafeCell<Option<Waker>>,
+
+    pub(crate) vtable: &'static ProcVTable,
+}

lightproc/src/proc_handle.rs

@@ -0,0 +1,24 @@
+use std::ptr::NonNull;
+use std::marker::PhantomData as marker;
+
+pub struct ProcHandle<R, T> {
+    raw_proc: NonNull<()>,
+    _private: marker<(R, T)>
+}
+
+unsafe impl<R, T> Send for ProcHandle<R, T> {}
+unsafe impl<R, T> Sync for ProcHandle<R, T> {}
+
+impl<R, T> Unpin for ProcHandle<R, T> {}
+
+impl<R, T> ProcHandle<R, T> {
+    /// Cancels the task.
+    ///
+    /// If the task has already completed, calling this method will have no effect.
+    ///
+    /// When a task is cancelled, its future cannot be polled again and will be dropped instead.
+    pub fn cancel(&self) {
+        let ptr = self.raw_proc.as_ptr();
+        unimplemented!()
+    }
+}

lightproc/src/proc_vtable.rs

@@ -0,0 +1,8 @@
+use std::task::RawWakerVTable;
+
+pub(crate) struct ProcVTable {
+    /// The raw waker vtable.
+    pub(crate) raw_waker: RawWakerVTable,
+
+    pub(crate) schedule: unsafe fn(*const ()),
+}