ringbuffer 0.16.0

A fixed-size 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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

extern crate alloc;

use alloc::collections::{LinkedList, VecDeque};
use alloc::string::ToString;
use core::ops::Deref;
use ringbuffer::RingBuffer;
use ringbuffer::{AllocRingBuffer, ConstGenericRingBuffer, GrowableAllocRingBuffer};
use std::vec;

macro_rules! convert_test {
    ($name: ident: $from: expr => $to: ty) => {
        #[test]
        fn $name() {
            let a = $from;

            let mut b: $to = a.into();
            assert_eq!(b.to_vec(), vec!['1', '2']);
            b.enqueue('3');
            assert_eq!(b, b);
        }
    };
}

macro_rules! convert_tests {
    (
        [$($name: ident: $from: expr),* $(,)?]
        => $to: ty
    ) => {
        $(
            convert_test!($name: $from => $to);
        )*
    };
}

convert_tests!(
    [
        alloc_from_vec: vec!['1', '2'],
        alloc_from_ll: {let mut l = LinkedList::new(); l.push_back('1'); l.push_back('2'); l},
        alloc_from_vd: {let mut l = VecDeque::new(); l.push_back('1'); l.push_back('2'); l},
        alloc_from_str: "12".to_string(),
        alloc_from_str_slice: "12",
        alloc_from_slice: {let a: &[char] = &['1', '2']; a},
        alloc_from_const_slice: {let a: &[char; 2] = &['1', '2']; a},
        alloc_from_arr: {let a: [char; 2] = ['1', '2']; a},

        alloc_from_cgrb: { ConstGenericRingBuffer::from(['1', '2'])},
        alloc_from_garb: { GrowableAllocRingBuffer::from(['1', '2'])},
    ] => AllocRingBuffer::<_>
);

convert_tests!(
    [
        growable_alloc_from_vec: vec!['1', '2'],
        growable_alloc_from_ll: {let mut l = LinkedList::new(); l.push_back('1'); l.push_back('2'); l},
        growable_alloc_from_vd: {let mut l = VecDeque::new(); l.push_back('1'); l.push_back('2'); l},
        growable_alloc_from_str: "12".to_string(),
        growable_alloc_from_str_slice: "12",
        growable_alloc_from_slice: {let a: &[char] = &['1', '2']; a},
        growable_alloc_from_const_slice: {let a: &[char; 2] = &['1', '2']; a},
        growable_alloc_from_arr: {let a: [char; 2] = ['1', '2']; a},

        growable_alloc_from_cgrb: { ConstGenericRingBuffer::from(['1', '2'])},
        growable_alloc_from_arb: { AllocRingBuffer::from(['1', '2'])},
    ] => GrowableAllocRingBuffer::<_>
);

convert_tests!(
    [
        const_from_vec: vec!['1', '2'],
        const_from_ll: {let mut l = LinkedList::new(); l.push_back('1'); l.push_back('2'); l},
        const_from_vd: {let mut l = VecDeque::new(); l.push_back('1'); l.push_back('2'); l},
        const_from_str: "12".to_string(),
        const_from_str_slice: "12",
        const_from_slice: {let a: &[char] = &['1', '2']; a},
        const_from_const_slice: {let a: &[char; 2] = &['1', '2']; a},
        const_from_arr: {let a: [char; 2] = ['1', '2']; a},

        const_from_garb: { GrowableAllocRingBuffer::from(['1', '2'])},
        const_from_arb: { AllocRingBuffer::from(['1', '2'])},
    ] => ConstGenericRingBuffer::<_, 2>
);

#[test]
fn test_extra_conversions_growable() {
    let a: &mut [i32; 2] = &mut [1, 2];
    let a = GrowableAllocRingBuffer::from(a);
    assert_eq!(a.to_vec(), vec![1, 2]);

    let a: &mut [i32] = &mut [1, 2];
    let a = GrowableAllocRingBuffer::from(a);
    assert_eq!(a.to_vec(), vec![1, 2]);

    let mut b = VecDeque::<i32>::new();
    b.push_back(1);
    b.push_back(2);
    assert_eq!(a.deref(), &b);
    assert_eq!(a.as_ref(), &b);
}

#[test]
fn test_extra_conversions_alloc() {
    let a: &mut [i32; 2] = &mut [1, 2];
    let a = AllocRingBuffer::from(a);
    assert_eq!(a.to_vec(), vec![1, 2]);

    let a: &mut [i32] = &mut [1, 2];
    let a = AllocRingBuffer::from(a);
    assert_eq!(a.to_vec(), vec![1, 2]);
}

#[test]
fn test_extra_conversions_const() {
    let a: &mut [i32; 2] = &mut [1, 2];
    let a = ConstGenericRingBuffer::<_, 2>::from(a);
    assert_eq!(a.to_vec(), vec![1, 2]);

    let a: &mut [i32] = &mut [1, 2];
    let a = ConstGenericRingBuffer::<_, 2>::from(a);
    assert_eq!(a.to_vec(), vec![1, 2]);
}

#[test]
fn test_const_generic_new_parameter() {
    // Can we specify size only on the method?
    let mut a = ConstGenericRingBuffer::new::<2>();
    let _ = a.enqueue(5);

    // Can we specify size in both positions?
    let mut a = ConstGenericRingBuffer::<i32, 50>::new::<50>();
    let _ = a.enqueue(5);

    // Can we specify size only on the struct?
    let mut a = ConstGenericRingBuffer::<i32, 50>::new();
    let _ = a.enqueue(5);
}