o3 0.34.2

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

use std::mem;

use crate::depot::queue::group::map::{BranchTag, Link, Node, Tag, mask};

pub(in crate::depot::queue::group) struct Branch {
    pub(in crate::depot::queue::group::map) mask: mask::Mask,
    children: (Link, Link),
}

impl Branch {
    pub(in crate::depot::queue::group::map) fn insert(
        parent: Option<&mut Self>,
        root: &mut Link,
        mask: mask::Mask,
        branch: Node<BranchTag>,
        owner: Node<Tag>,
        key: u64,
    ) -> Self {
        let link = Link::Branch(branch);
        let old = match parent {
            Some(parent) => mem::replace(parent.child_mut(key), link),
            None => mem::replace(root, link),
        };
        let added = Link::Owner(owner);
        let children = if mask.contains(key) {
            (old, added)
        } else {
            (added, old)
        };
        Self { mask, children }
    }
    pub(in crate::depot::queue::group::map) fn child(&self, key: u64) -> &Link {
        if self.mask.contains(key) {
            &self.children.1
        } else {
            &self.children.0
        }
    }
    pub(in crate::depot::queue::group::map) fn collapse(&mut self, key: u64, target: &mut Link) {
        let sibling = if self.mask.contains(key) {
            &mut self.children.0
        } else {
            &mut self.children.1
        };
        mem::swap(sibling, target);
    }
    pub(in crate::depot::queue::group::map) fn child_mut(&mut self, key: u64) -> &mut Link {
        if self.mask.contains(key) {
            &mut self.children.1
        } else {
            &mut self.children.0
        }
    }
    pub(in crate::depot::queue::group::map) fn sibling(self, key: u64) -> Link {
        if self.mask.contains(key) {
            self.children.0
        } else {
            self.children.1
        }
    }
}

const _: () = assert!(mem::size_of::<Branch>() == 3 * mem::size_of::<usize>());