vmcircbuffer 0.0.14

Double Mapped Circular Buffer
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

use vmcircbuffer::generic::Circular;
use vmcircbuffer::generic::Metadata;
use vmcircbuffer::generic::Notifier;

struct MyNotifier;

impl Notifier for MyNotifier {
    fn arm(&mut self) {}
    fn notify(&mut self) {}
}

#[derive(Clone)]
struct Tag {
    item: usize,
    data: String,
}

struct MyMetadata {
    tags: Vec<Tag>,
}

impl Metadata for MyMetadata {
    type Item = Tag;

    fn new() -> Self {
        MyMetadata { tags: Vec::new() }
    }
    fn add_from_slice(&mut self, offset: usize, tags: &[Self::Item]) {
        for t in tags {
            let mut t = t.clone();
            t.item += offset;
            self.tags.push(t);
        }
    }
    fn get_into(&self, out: &mut Vec<Self::Item>) {
        out.clear();
        out.extend(self.tags.iter().cloned());
    }
    fn consume(&mut self, items: usize) {
        self.tags.retain(|x| x.item >= items);
        for t in self.tags.iter_mut() {
            t.item -= items;
        }
    }
}

#[test]
fn tags() {
    let mut w = Circular::with_capacity::<u32, MyNotifier, MyMetadata>(1).unwrap();

    let mut r = w.add_reader(MyNotifier, MyNotifier);

    let out = w.slice(false);
    for v in out.iter_mut() {
        *v = 123;
    }
    let len = out.len();

    let tags = vec![
        Tag {
            item: 0,
            data: String::from("first"),
        },
        Tag {
            item: 10,
            data: String::from("tenth"),
        },
    ];
    w.produce(len, &tags);

    let mut tags = Vec::new();
    let i = r.slice_with_metadata_into(false, &mut tags).unwrap();

    assert_eq!(i[0], 123);
    assert_eq!(tags.len(), 2);
    assert_eq!(tags[0].data, String::from("first"));
    assert_eq!(tags[0].item, 0);
    assert_eq!(tags[1].data, String::from("tenth"));
    assert_eq!(tags[1].item, 10);

    let i = r.slice(false).unwrap();
    assert_eq!(i[0], 123);

    r.consume(5);
    let i = r.slice_with_metadata_into(false, &mut tags).unwrap();

    assert_eq!(i[0], 123);
    assert_eq!(tags.len(), 1);
    assert_eq!(tags[0].data, String::from("tenth"));
    assert_eq!(tags[0].item, 5);
}

#[test]
fn slice_done_semantics() {
    let mut w = Circular::with_capacity::<u32, MyNotifier, MyMetadata>(1).unwrap();
    let mut r = w.add_reader(MyNotifier, MyNotifier);

    assert_eq!(r.slice(false).unwrap().len(), 0);

    let out = w.slice(false);
    out[0] = 7;
    w.produce(1, &[]);

    let input = r.slice(false).unwrap();
    assert_eq!(input, &[7]);
    r.consume(1);

    drop(w);

    assert!(r.slice(false).is_none());
}