pipecircuit 0.0.22

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

use core::num::NonZeroUsize;

use super::{ByteLease, BytePool, BytePoolInconsistency};

#[must_use = "byte-pool reservations must be materialized or released"]
pub struct ByteLeaseReservation<'pool> {
    pub(super) pool: &'pool mut BytePool,
    pub(super) slot: usize,
    pub(super) extent_index: usize,
    pub(super) reserved_maximum: NonZeroUsize,
}

impl<'pool> ByteLeaseReservation<'pool> {
    pub const fn reserved_maximum(&self) -> NonZeroUsize {
        self.reserved_maximum
    }

    pub fn materialize(self, requested: NonZeroUsize) -> BytePoolMaterializeOutcome<'pool> {
        if requested > self.reserved_maximum {
            return BytePoolMaterializeOutcome::ReservationExceeded {
                requested,
                reserved_maximum: self.reserved_maximum,
            };
        }
        match self
            .pool
            .materialize(self.slot, self.extent_index, requested)
        {
            Ok(lease) => BytePoolMaterializeOutcome::Leased(lease),
            Err(reason) => BytePoolMaterializeOutcome::Inconsistent { requested, reason },
        }
    }
}

#[must_use = "byte-pool reserve outcomes must be handled"]
pub enum BytePoolReserveOutcome<'pool> {
    Reserved(ByteLeaseReservation<'pool>),
    Exhausted {
        requested_maximum: NonZeroUsize,
    },
    LeaseCapacityReached {
        requested_maximum: NonZeroUsize,
    },
    LeaseIdentitiesExhausted {
        requested_maximum: NonZeroUsize,
    },
    Inconsistent {
        requested_maximum: NonZeroUsize,
        reason: BytePoolInconsistency,
    },
}

#[must_use = "byte-pool materialization outcomes must be handled"]
pub enum BytePoolMaterializeOutcome<'pool> {
    Leased(ByteLease<'pool>),
    ReservationExceeded {
        requested: NonZeroUsize,
        reserved_maximum: NonZeroUsize,
    },
    Inconsistent {
        requested: NonZeroUsize,
        reason: BytePoolInconsistency,
    },
}