aboutsummaryrefslogtreecommitdiff
path: root/src/yellow/red.rs
blob: c3d6c5f4f2a002111e2f2d181c0c84ecb877ad19 (plain)
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
use std::{ptr, sync::RwLock};
use {yellow::GreenNode, TextUnit};

#[derive(Debug)]
pub(crate) struct RedNode {
    green: GreenNode,
    parent: Option<ParentData>,
    children: RwLock<Box<[Option<RedNode>]>>,
}

#[derive(Debug)]
struct ParentData {
    parent: ptr::NonNull<RedNode>,
    start_offset: TextUnit,
    index_in_parent: usize,
}

impl RedNode {
    pub fn new_root(green: GreenNode) -> RedNode {
        RedNode::new(green, None)
    }

    fn new_child(
        green: GreenNode,
        parent: ptr::NonNull<RedNode>,
        start_offset: TextUnit,
        index_in_parent: usize,
    ) -> RedNode {
        let parent_data = ParentData {
            parent,
            start_offset,
            index_in_parent,
        };
        RedNode::new(green, Some(parent_data))
    }

    fn new(green: GreenNode, parent: Option<ParentData>) -> RedNode {
        let n_children = green.children().len();
        let children = (0..n_children)
            .map(|_| None)
            .collect::<Vec<_>>()
            .into_boxed_slice();
        RedNode {
            green,
            parent,
            children: RwLock::new(children),
        }
    }

    pub(crate) fn green(&self) -> &GreenNode {
        &self.green
    }

    pub(crate) fn start_offset(&self) -> TextUnit {
        match &self.parent {
            None => 0.into(),
            Some(p) => p.start_offset,
        }
    }

    pub(crate) fn n_children(&self) -> usize {
        self.green.children().len()
    }

    pub(crate) fn get_child(&self, idx: usize) -> Option<ptr::NonNull<RedNode>> {
        if idx >= self.n_children() {
            return None;
        }
        match &self.children.read().unwrap()[idx] {
            Some(child) => return Some(child.into()),
            None => (),
        }
        let mut children = self.children.write().unwrap();
        if children[idx].is_none() {
            let green_children = self.green.children();
            let start_offset = self.start_offset()
                + green_children[..idx]
                    .iter()
                    .map(|x| x.text_len())
                    .sum::<TextUnit>();
            let child =
                RedNode::new_child(green_children[idx].clone(), self.into(), start_offset, idx);
            children[idx] = Some(child)
        }
        Some(children[idx].as_ref().unwrap().into())
    }

    pub(crate) fn parent(&self) -> Option<ptr::NonNull<RedNode>> {
        Some(self.parent.as_ref()?.parent)
    }
    pub(crate) fn index_in_parent(&self) -> Option<usize> {
        Some(self.parent.as_ref()?.index_in_parent)
    }
}