orx-concurrent-iter 3.3.0

A thread-safe and ergonomic concurrent iterator trait and efficient lock-free implementations.
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

use super::as_raw_slice::AsRawSlice;

/// Raw representation of a slice defined by a pointer and length.
///
/// All elements in the slice are assumed to be initialized.
pub struct RawSlice<T> {
    ptr: *const T,
    len: usize,
}

impl<'a, T> From<&'a [T]> for RawSlice<T> {
    fn from(value: &'a [T]) -> Self {
        Self {
            ptr: value.as_ptr(),
            len: value.len(),
        }
    }
}

impl<T> RawSlice<T> {
    pub(super) fn new(ptr: *const T, len: usize) -> Self {
        Self { ptr, len }
    }
}

impl<T> AsRawSlice<T> for RawSlice<T> {
    fn ptr(&self) -> *const T {
        self.ptr
    }

    fn length(&self) -> usize {
        self.len
    }

    fn raw_slice(&self, begin: usize, len: usize) -> RawSlice<T> {
        debug_assert!(begin + len <= self.len);
        let ptr = unsafe { self.ptr.add(begin) };
        Self::new(ptr, len)
    }
}