o3 0.33.1

shared-nothing primitives
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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

use std::mem;

use crate::depot::{
    arena::{linked, linked::slots},
    capacity,
    queue::pool,
};

/// Shared access retaining one exact FIFO lane and its original owner borrow.
pub struct View<'a, T, S = (), const TRACK: bool = true> {
    store: &'a slots::Store<T>,
    slot: &'a crate::depot::raw::QueueSlot<S>,
}

impl<'a, T, S, const TRACK: bool> View<'a, T, S, TRACK> {
    pub(in crate::depot) const fn new(
        store: &'a slots::Store<T>,
        slot: &'a crate::depot::raw::QueueSlot<S>,
    ) -> Self {
        Self { store, slot }
    }

    pub const fn len(self) -> usize {
        self.count().get()
    }

    pub const fn count(self) -> capacity::Count {
        self.slot.queue.count()
    }

    pub const fn is_empty(self) -> bool {
        self.slot.queue.is_empty()
    }

    pub fn front(self) -> Option<&'a T> {
        unsafe { self.slot.queue.front(self.store) }
    }

    pub fn back(self) -> Option<&'a T> {
        unsafe { self.slot.queue.back(self.store) }
    }

    pub fn iter(self) -> linked::Iter<'a, T> {
        unsafe { self.slot.queue.iter(self.store) }
    }

    pub const fn state(self) -> &'a S {
        &self.slot.state
    }
}

/// Consumes the exclusive capability while retaining its original owner borrow.
impl<'a, T, S, const TRACK: bool> From<pool::Lane<'a, T, S, TRACK>> for View<'a, T, S, TRACK> {
    fn from(lane: pool::Lane<'a, T, S, TRACK>) -> Self {
        Self::new(lane.store, lane.slot)
    }
}

/// Reborrows the retained lane without consuming its exclusive capability.
impl<'a, T, S, const TRACK: bool> From<&'a pool::Lane<'_, T, S, TRACK>> for View<'a, T, S, TRACK> {
    fn from(lane: &'a pool::Lane<'_, T, S, TRACK>) -> Self {
        Self::new(lane.store, lane.slot)
    }
}

impl<T, S, const TRACK: bool> Clone for View<'_, T, S, TRACK> {
    fn clone(&self) -> Self {
        *self
    }
}

impl<T, S, const TRACK: bool> Copy for View<'_, T, S, TRACK> {}

const _: () = assert!(mem::size_of::<View<'static, u64>>() == 2 * mem::size_of::<usize>());