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

use heap::{Live, keyed, resident};
pub(in crate::depot) use hole::Hole;
pub(in crate::depot) use store::Store;

use crate::depot::{heap, index};

mod hole;
mod store;

unsafe impl<'a, K: crate::depot::raw::Address, P: Ord, C, I: index::Position>
    crate::depot::raw::Project<K> for (&'a mut keyed::Min<K, P, I>, C)
{
    type Output = Live<(&'a mut keyed::Min<K, P, I>, C), K>;

    unsafe fn project(self, key: K) -> Self::Output {
        unsafe { crate::depot::raw::Proof::new((self, key)) }
    }
}

unsafe impl<'a, K: crate::depot::raw::Address, P: Ord, R: Copy, C, I: index::Position>
    crate::depot::raw::Project<K> for (&'a mut resident::Min<K, P, R, I>, C)
{
    type Output = Live<(&'a mut resident::Min<K, P, R, I>, C), K>;

    unsafe fn project(self, key: K) -> Self::Output {
        unsafe { crate::depot::raw::Proof::new((self, key)) }
    }
}

/// # Safety
/// The key belongs to this owner's fixed domain, whose residents are initialized.
pub(in crate::depot::heap) unsafe fn resident<
    K: crate::depot::raw::Address,
    P: Ord,
    R: Copy,
    I: index::Position,
>(
    owner: &resident::Min<K, P, R, I>,
    key: K,
) -> &R {
    unsafe { owner.storage.values().get_unchecked(key.index()) }
}

/// # Safety
/// The key belongs to this owner's fixed domain; the exclusive loan retains its resident.
pub(in crate::depot::heap) unsafe fn resident_mut<
    K: crate::depot::raw::Address,
    P: Ord,
    R: Copy,
    I: index::Position,
>(
    owner: &mut resident::Min<K, P, R, I>,
    key: K,
) -> &mut R {
    unsafe { owner.storage.values_mut().get_unchecked_mut(key.index()) }
}

mod queue;
pub(in crate::depot) use queue::Queue;

mod source;

const _: () = {
    use std::mem;

    use heap::{hole::Step, indexed::Min};

    let word = mem::size_of::<usize>();
    assert!(mem::size_of::<heap::raw::Hole<&'static mut Min<usize>>>() == 4 * word);
    assert!(mem::size_of::<heap::Entry<&'static mut Min<usize>>>() == 2 * word);
    assert!(mem::size_of::<Step<'static, &'static mut Min<usize>>>() == 2 * word);
    assert!(mem::size_of::<Option<Step<'static, &'static mut Min<usize>>>>() == 2 * word);
};