unsync 0.2.0

Unsynchronized synchronization primitives for async Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

use core::mem;
use core::ptr;
use core::task;

#[cfg(feature = "std")]
pub(crate) fn abort() -> ! {
    std::process::abort()
}

#[cfg(not(feature = "std"))]
pub(crate) fn abort() -> ! {
    loop {}
}

/// Increment `value` assuming that an overflow is unlikely. Calls [`abort`] on
/// overflows.
#[cfg(feature = "alloc")]
pub(crate) fn checked_increment(value: usize) -> usize {
    if value == usize::MAX {
        abort()
    }

    value + 1
}

/// Create a no-op context which can be used for testing.
pub fn noop_cx() -> task::Context<'static> {
    const VTABLE: task::RawWakerVTable = task::RawWakerVTable::new(
        // clone
        |_| RAW,
        // wake
        |_| {},
        // wake_by_ref
        |_| {},
        // drop
        |_| {},
    );

    const RAW: task::RawWaker = task::RawWaker::new(ptr::null(), &VTABLE);

    // `Waker::from_raw` is unfortunately not `const fn` so it can't be used
    // SAFETY: `Waker` is `#[repr(transparent)]` over `RawWaker`
    static WAKER: task::Waker = unsafe { mem::transmute::<task::RawWaker, task::Waker>(RAW) };

    task::Context::from_waker(&WAKER)
}