workspace: move crates under crates

io-uring/src/pending_result.rs

@@ -1,120 +0,0 @@
-use {
-    jay_utils::{numcell::NumCell, oserror::OsError, ptr_ext::PtrExt, stack::Stack},
-    std::{
-        cell::Cell,
-        future::Future,
-        pin::Pin,
-        rc::{Rc, Weak},
-        task::{Context, Poll, Waker},
-    },
-    uapi::c,
-};
-
-#[derive(Default)]
-pub struct PendingResults {
-    data: Rc<PendingResultsData>,
-}
-
-impl PendingResults {
-    pub fn acquire(&self) -> PendingResult {
-        let pr = self.data.unused.pop().unwrap_or_else(|| {
-            Box::into_raw(Box::new(PendingResultData {
-                rc: NumCell::new(0),
-                base: Rc::downgrade(&self.data),
-                waker: Cell::new(None),
-                res: Cell::new(None),
-            }))
-        });
-        unsafe {
-            let prr = pr.deref();
-            debug_assert_eq!(prr.rc.get(), 0);
-            prr.rc.fetch_add(1);
-            PendingResult { pr }
-        }
-    }
-}
-
-#[derive(Default)]
-struct PendingResultsData {
-    unused: Stack<*mut PendingResultData>,
-}
-
-impl Drop for PendingResultsData {
-    fn drop(&mut self) {
-        while let Some(pr) = self.unused.pop() {
-            unsafe {
-                drop(Box::from_raw(pr));
-            }
-        }
-    }
-}
-
-struct PendingResultData {
-    rc: NumCell<u32>,
-    base: Weak<PendingResultsData>,
-    waker: Cell<Option<Waker>>,
-    res: Cell<Option<i32>>,
-}
-
-pub struct PendingResult {
-    pr: *mut PendingResultData,
-}
-
-impl PendingResult {
-    pub fn complete(&self, res: i32) {
-        unsafe {
-            let pr = self.pr.deref();
-            pr.res.set(Some(res));
-            if let Some(waker) = pr.waker.take() {
-                waker.wake();
-            }
-        }
-    }
-}
-
-impl Drop for PendingResult {
-    fn drop(&mut self) {
-        {
-            let pr = unsafe { self.pr.deref() };
-            if pr.rc.fetch_sub(1) != 1 {
-                return;
-            }
-            if let Some(base) = pr.base.upgrade() {
-                pr.waker.set(None);
-                pr.res.set(None);
-                base.unused.push(self.pr);
-                return;
-            }
-        }
-        unsafe {
-            drop(Box::from_raw(self.pr));
-        }
-    }
-}
-
-impl Clone for PendingResult {
-    fn clone(&self) -> Self {
-        let pr = unsafe { self.pr.deref() };
-        pr.rc.fetch_add(1);
-        Self { pr: self.pr }
-    }
-}
-
-impl Future for PendingResult {
-    type Output = Result<i32, OsError>;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let pr = unsafe { self.pr.deref() };
-        if let Some(res) = pr.res.take() {
-            let res = if res < 0 {
-                Err(OsError::from(-res as c::c_int))
-            } else {
-                Ok(res)
-            };
-            Poll::Ready(res)
-        } else {
-            pr.waker.set(Some(cx.waker().clone()));
-            Poll::Pending
-        }
-    }
-}