pipecircuit 0.0.10

Correct. Robust. Fast. Portable.
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

use core::{cell::Cell, ops::Range};

use super::LeaseStatus;

#[must_use = "byte leases recycle their extent when dropped unless explicitly retained"]
pub struct ByteLease<'pool> {
    pub(super) slot: usize,
    pub(super) generation: u64,
    pub(super) range: Range<usize>,
    pub(super) status: &'pool Cell<LeaseStatus>,
    pub(super) next: &'pool Cell<Option<usize>>,
    pub(super) released_lease_head: &'pool Cell<Option<usize>>,
    pub(super) storage: &'pool mut [u8],
    pub(super) recycle_on_drop: bool,
}

impl ByteLease<'_> {
    pub fn byte_capacity(&self) -> usize {
        self.storage.len()
    }

    pub fn bytes(&self) -> &[u8] {
        self.storage
    }

    pub fn bytes_mut(&mut self) -> &mut [u8] {
        self.storage
    }

    pub fn retain(mut self) -> RetainedByteLease {
        self.recycle_on_drop = false;
        RetainedByteLease {
            slot: self.slot,
            generation: self.generation,
            range: self.range.clone(),
        }
    }
}

impl Drop for ByteLease<'_> {
    fn drop(&mut self) {
        if self.recycle_on_drop && self.status.get() == LeaseStatus::Leased {
            self.next.set(self.released_lease_head.get());
            self.status.set(LeaseStatus::Released);
            self.released_lease_head.set(Some(self.slot));
        }
    }
}

#[derive(Debug, Eq, PartialEq)]
#[must_use = "retained byte leases must be resumed or recycled"]
pub struct RetainedByteLease {
    pub(super) slot: usize,
    pub(super) generation: u64,
    pub(super) range: Range<usize>,
}

impl RetainedByteLease {
    pub fn byte_capacity(&self) -> usize {
        self.range.len()
    }
}