razel 0.5.7

a command executor with caching for data processing pipelines
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

use std::fmt::{Debug, Display, Formatter};
use std::hash::{Hash, Hasher};
use std::marker::PhantomData;
use std::ops;
use std::slice::Iter;

/// u32 should be enough
type ArenaIdType = u32;

/// ArenaId types are checked at runtime to match the type of the Arena (newtype idiom).
pub struct ArenaId<T>(ArenaIdType, PhantomData<T>);

impl<T> Clone for ArenaId<T> {
    fn clone(&self) -> Self {
        *self
    }
}

impl<T> Copy for ArenaId<T> {}

impl<T> Debug for ArenaId<T> {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.0)
    }
}

impl<T> Display for ArenaId<T> {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.0)
    }
}

impl<T> Eq for ArenaId<T> {}

impl<T> Hash for ArenaId<T> {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.0.hash(state);
    }
}

impl<T> PartialEq for ArenaId<T> {
    fn eq(&self, other: &Self) -> bool {
        self.0 == other.0
    }
}

/// Id based arena for graph data structures.
pub struct Arena<T> {
    items: Vec<T>,
}

impl<T> Arena<T> {
    /// Add an item and return its id.
    pub fn alloc(&mut self, item: T) -> ArenaId<T> {
        let id = self.next_id();
        self.items.push(item);
        id
    }

    /// Provide an id for the next item, add the item and return the id.
    pub fn alloc_with_id(&mut self, f: impl FnOnce(ArenaId<T>) -> T) -> ArenaId<T> {
        let id = self.next_id();
        self.items.push(f(id));
        id
    }

    pub fn get(&self, id: ArenaId<T>) -> Option<&T> {
        self.items.get(id.0 as usize)
    }

    pub fn get_mut(&mut self, id: ArenaId<T>) -> Option<&mut T> {
        self.items.get_mut(id.0 as usize)
    }

    pub fn first_id(&self) -> ArenaId<T> {
        ArenaId(0 as ArenaIdType, PhantomData)
    }

    /// Iteration w/o borrowing, use first_id() as starting point
    pub fn get_and_inc_id(&self, id: &mut ArenaId<T>) -> Option<&T> {
        match self.items.get(id.0 as usize) {
            Some(x) => {
                id.0 += 1;
                Some(x)
            }
            _ => None,
        }
    }

    pub fn is_empty(&self) -> bool {
        self.items.is_empty()
    }

    pub fn len(&self) -> usize {
        self.items.len()
    }

    pub fn iter(&self) -> Iter<'_, T> {
        self.items.iter()
    }

    pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, T> {
        self.items.iter_mut()
    }

    fn next_id(&self) -> ArenaId<T> {
        ArenaId(self.items.len() as ArenaIdType, PhantomData)
    }
}

impl<T> Default for Arena<T> {
    fn default() -> Self {
        Self { items: vec![] }
    }
}

impl<T> ops::Index<ArenaId<T>> for Arena<T> {
    type Output = T;

    fn index(&self, id: ArenaId<T>) -> &T {
        &self.items[id.0 as usize]
    }
}

impl<T> ops::IndexMut<ArenaId<T>> for Arena<T> {
    fn index_mut(&mut self, id: ArenaId<T>) -> &mut T {
        &mut self.items[id.0 as usize]
    }
}