o3 0.20.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

use std::marker;

use map::priority;

use crate::{alloc, depot::map};

type Fields<K, V, P> = alloc::raw::Tail<
    alloc::raw::Tail<
        <map::raw::Layout<u32> as alloc::raw::Recipe>::Fields,
        priority::Node<K, V, P>,
    >,
    u32,
>;

pub(in crate::depot::map::priority) struct Layout<K, V, P> {
    pub(in crate::depot::map::priority) bundle: alloc::raw::Bundle<Fields<K, V, P>>,
    pub(in crate::depot::map::priority) buckets: usize,
    pub(in crate::depot::map::priority) plan: priority::Plan<K, P, V>,
}

impl<K, V, P: Ord> Layout<K, V, P> {
    pub(in crate::depot::map::priority) fn try_plan(
        plan: map::Plan,
    ) -> Result<Self, crate::alloc::Overflow> {
        let capacity = plan.capacity();
        let table = map::raw::Layout::<u32>::try_plan(plan)?;
        let buckets = table.buckets();
        let shape = table.shape();
        let bundle = alloc::raw::Recipe::try_build(Self::recipe(table, capacity.get()))?;
        Ok(Self {
            bundle,
            buckets,
            plan: priority::Plan {
                table: shape,
                shape: marker::PhantomData,
            },
        })
    }

    pub(in crate::depot::map::priority) fn from_plan(plan: priority::Plan<K, P, V>) -> Self {
        let capacity = plan.capacity().get();
        let table = plan.table.layout();
        let buckets = table.buckets();
        // SAFETY: the value-bound plan proves this exact extension.
        let bundle = unsafe { alloc::raw::Recipe::build(Self::recipe(table, capacity)) };
        Self {
            bundle,
            buckets,
            plan,
        }
    }

    fn recipe(
        table: map::raw::Layout<u32>,
        capacity: usize,
    ) -> impl alloc::raw::Recipe<Fields = Fields<K, V, P>> {
        use alloc::raw::Recipe as _;

        alloc::raw::Recipe::tail::<priority::Node<K, V, P>>(table, capacity).tail::<u32>(capacity)
    }
}