o3 0.12.0

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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

use std::{error::Error, fmt, marker::PhantomData, ptr::NonNull};

use crate::buffer;

mod core;
mod cursor;
mod frozen;
mod layout;
mod lease;
mod plan;
pub mod state;

pub use cursor::Cursor;
pub use frozen::Frozen;
pub use layout::Layout;
pub use lease::Lease;
pub use plan::Plan;

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum LayoutError {
    ZeroCapacity,
    SlotOverflow,
    CapacityOverflow,
}

impl fmt::Display for LayoutError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::ZeroCapacity => f.write_str("buffer pool capacity must be positive"),
            Self::SlotOverflow => f.write_str("buffer pool slot count overflow"),
            Self::CapacityOverflow => f.write_str("buffer pool allocation size overflow"),
        }
    }
}

impl Error for LayoutError {}

/// Selects whether a pool capacity is fixed in its type or stored in its layout.
///
/// This bound is sealed because the allocator's layout proof depends on it.
#[doc(hidden)]
pub trait Capacity: buffer::Seal {}

#[repr(transparent)]
pub struct Pool<S: state::State = state::Uninitialized, C: Capacity = RuntimeCapacity> {
    core: NonNull<core::Core>,
    marker: PhantomData<(S, C, *mut ())>,
}

impl<S: state::State> Pool<S, RuntimeCapacity> {
    pub fn from_layout(layout: Layout) -> Self {
        Self {
            core: core::Core::allocate::<S>(layout),
            marker: PhantomData,
        }
    }

    pub fn try_new(slots: usize, capacity: usize) -> Result<Self, LayoutError> {
        Ok(Self::from_layout(Layout::new(slots, capacity)?))
    }
}

impl<S: state::State, C: Capacity> Pool<S, C> {
    pub fn try_acquire(&self) -> Option<Lease<S, C>> {
        let index = core::Core::acquire(self.core)?;
        Some(Lease {
            core: self.core,
            index,
            len: 0,
            marker: PhantomData,
        })
    }

    pub fn capacity(&self) -> usize {
        core::Core::capacity(self.core)
    }

    pub fn available(&self) -> usize {
        core::Core::available(self.core)
    }
}

impl<S: state::State, const CAP: u32> Pool<S, FixedCapacity<CAP>> {
    pub fn try_with_slots(slots: usize) -> Result<Self, LayoutError> {
        let layout = Layout::new(slots, CAP as usize)?;
        Ok(Self {
            core: core::Core::allocate::<S>(layout),
            marker: PhantomData,
        })
    }

    #[must_use]
    pub fn fixed<const SLOTS: usize>() -> Self {
        let layout = Layout::fixed_capacity::<SLOTS, CAP>();
        Self {
            core: core::Core::allocate::<S>(layout),
            marker: PhantomData,
        }
    }
}

impl<C: Capacity> Pool<state::Uninitialized, C> {
    #[must_use]
    pub fn try_acquire_buffer(&self) -> Option<Cursor<C>> {
        self.try_acquire().map(Cursor::new)
    }
}

impl<S: state::State, C: Capacity> Clone for Pool<S, C> {
    fn clone(&self) -> Self {
        core::Core::retain(self.core);
        Self {
            core: self.core,
            marker: PhantomData,
        }
    }
}

impl<S: state::State, C: Capacity> Drop for Pool<S, C> {
    fn drop(&mut self) {
        core::Core::release(self.core);
    }
}

/// Selects a capacity supplied by [`Layout`] at construction time.
#[derive(Clone, Copy)]
pub struct RuntimeCapacity;

impl buffer::Seal for RuntimeCapacity {}

impl Capacity for RuntimeCapacity {}

/// Selects a capacity fixed in the pool type.
#[derive(Clone, Copy)]
pub struct FixedCapacity<const CAP: u32>;

impl<const CAP: u32> buffer::Seal for FixedCapacity<CAP> {}

impl<const CAP: u32> Capacity for FixedCapacity<CAP> {}