sophia_turtle 0.10.0

A Rust toolkit for RDF and Linked Data - parsers and serializers for the Turtle-family of syntaxes
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
130
131
132
133
134
135
136
137
138

//! A stash is a vec of strings that does not drop its elements when they are popped,
//! in order to save allocation time when the element is reused.

use std::ops::Deref;
#[derive(Clone, Debug, Default)]
pub struct StringStash {
    vec: Vec<String>,
    len: usize,
}

impl StringStash {
    #[must_use]
    pub fn with_capacity(cap: usize) -> Self {
        Self {
            vec: Vec::with_capacity(cap),
            len: 0,
        }
    }

    pub fn push(&mut self) -> &mut String {
        self.len += 1;
        if self.len > self.vec.len() {
            debug_assert_eq!(self.len, self.vec.len() + 1);
            self.vec.push(String::with_capacity(256));
        } else {
            self.vec[self.len - 1].truncate(0);
        }
        &mut self.vec[self.len - 1]
    }

    pub fn top(&self) -> &str {
        debug_assert!(!self.is_empty());
        &self.vec[self.len - 1]
    }

    pub fn top_mut(&mut self) -> &mut String {
        debug_assert!(!self.is_empty());
        &mut self.vec[self.len - 1]
    }

    pub fn top2_mut(&mut self) -> [&mut String; 2] {
        debug_assert!(self.len() >= 2);
        let n = self.len() - 1;
        let (s1, s2) = self.vec.split_at_mut(n);
        [&mut s1[n - 1], &mut s2[0]]
    }

    pub fn pop(&mut self) {
        assert!(!self.is_empty());
        self.len -= 1;
    }

    pub fn empty(&mut self) {
        self.len = 0;
    }

    pub fn swap_top2(&mut self) {
        assert!(self.len() >= 2);
        self.vec.swap(self.len - 2, self.len - 1);
    }

    pub fn recycle(&mut self, old_idx: usize) -> usize {
        assert!(old_idx <= self.vec.len());
        debug_assert!(self.len() <= old_idx);
        let ret = self.len();
        self.vec.swap(ret, old_idx);
        self.len += 1;
        ret
    }
}

impl Deref for StringStash {
    type Target = [String];

    fn deref(&self) -> &Self::Target {
        &self.vec[..self.len]
    }
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn stash() {
        let mut s = StringStash::default();
        assert_eq!(s.len(), 0);
        assert_eq!(s.vec.len(), 0);

        s.push().push_str("foo");
        assert_eq!(s.len(), 1);
        assert_eq!(s.top(), "foo");
        assert_eq!(s.vec.len(), 1);
        assert_eq!(&s.vec[0], "foo");

        s.push().push_str("bar");
        assert_eq!(s.len(), 2);
        assert_eq!(s.top(), "bar");
        assert_eq!(s.vec.len(), 2);
        assert_eq!(&s.vec[0], "foo");
        assert_eq!(&s.vec[1], "bar");

        s.pop();
        assert_eq!(s.len(), 1);
        assert_eq!(s.top(), "foo");
        assert_eq!(s.vec.len(), 2);
        assert_eq!(&s.vec[0], "foo");
        assert_eq!(&s.vec[1], "bar");

        s.push().push_str("toto");
        assert_eq!(s.len(), 2);
        assert_eq!(s.top(), "toto");
        assert_eq!(s.top2_mut()[0], "foo");
        assert_eq!(s.top2_mut()[1], "toto");
        assert_eq!(s.vec.len(), 2);
        assert_eq!(&s.vec[0], "foo");
        assert_eq!(&s.vec[1], "toto");

        s.swap_top2();
        assert_eq!(s.vec.len(), 2);
        assert_eq!(s.top(), "foo");
        assert_eq!(&s.vec[0], "toto");
        assert_eq!(&s.vec[1], "foo");

        s.empty();
        assert_eq!(s.len(), 0);
        assert_eq!(s.vec.len(), 2);
        assert_eq!(&s.vec[0], "toto");
        assert_eq!(&s.vec[1], "foo");

        s.recycle(1);
        assert_eq!(s.len(), 1);
        assert_eq!(s.top(), "foo");
        assert_eq!(s.vec.len(), 2);
        assert_eq!(&s.vec[0], "foo");
        assert_eq!(&s.vec[1], "toto");
    }
}