postage 0.5.0

An async channel library
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

use super::{CHANNEL_TEST_ITERATIONS, CHANNEL_TEST_SENDERS};

pub fn capacity_iter() -> impl Iterator<Item = usize> {
    (1..6).map(|i| 2usize.pow(i))
}

// TODO: iterators over channel sender/receiver counts, channel sizes
pub struct MessageIter<I> {
    sender: usize,
    iter: I,
}

impl<I> Iterator for MessageIter<I>
where
    I: Iterator<Item = usize>,
{
    type Item = Message;

    fn next(&mut self) -> Option<Self::Item> {
        self.iter.next().map(|index| Message {
            sender: self.sender,
            index,
        })
    }
}

#[derive(PartialEq, Clone, Debug)]
pub struct Message {
    sender: usize,
    index: usize,
}

impl Default for Message {
    fn default() -> Self {
        Self {
            sender: 0,
            index: 0,
        }
    }
}

impl Message {
    pub fn new_iter(sender: usize) -> impl Iterator<Item = Message> {
        MessageIter {
            sender,
            iter: (0..CHANNEL_TEST_ITERATIONS),
        }
    }

    pub fn new_multi_sender(sender: usize) -> impl Iterator<Item = Message> {
        let messages = CHANNEL_TEST_ITERATIONS / CHANNEL_TEST_SENDERS;
        MessageIter {
            sender,
            iter: (0..messages),
        }
    }
}

pub struct Channels {
    channels: Vec<Channel>,
}

impl Channels {
    pub fn new(senders: usize) -> Self {
        let mut channels = Vec::with_capacity(senders);
        for i in 0..senders {
            channels.push(Channel::new(i));
        }
        Self { channels }
    }

    pub fn allow_skips(mut self) -> Self {
        for channel in self.channels.iter_mut() {
            channel.allow_skips = true;
        }

        self
    }

    #[track_caller]
    pub fn assert_message(&mut self, message: &Message) {
        self.channels[message.sender].assert_message(message);
    }
}

pub struct Channel {
    sender: usize,
    current_index: usize,
    allow_skips: bool,
}

impl Channel {
    pub fn new(sender: usize) -> Self {
        Self {
            sender,
            current_index: 0,
            allow_skips: false,
        }
    }

    pub fn allow_skips(mut self) -> Self {
        self.allow_skips = true;
        self
    }

    #[track_caller]
    pub fn assert_message(&mut self, message: &Message) {
        if self.allow_skips {
            assert_eq!(self.sender, message.sender);
            if message.index < self.current_index {
                panic!(
                    "for sender {}, expected message >= {}, found {}",
                    self.sender, self.current_index, message.index
                );
            }

            self.current_index = message.index;
            return;
        }

        assert_eq!(
            (self.sender, self.current_index),
            (message.sender, message.index)
        );
        self.current_index += 1;
    }
}