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

use serde::{Deserialize, Serialize};
use std::fmt;

/// Represents a sequence number used within a gate stream.
#[repr(transparent)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct SequenceNumber(u64);

impl fmt::Display for SequenceNumber {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.0)
    }
}

impl SequenceNumber {
    /// Returns true if receiving this sequence number in a `Success` message
    /// acknowledges the given other sequence number.
    pub fn acknowledges(self, other: SequenceNumber) -> bool {
        self.0 >= other.0
    }

    /// Returns true if this sequence number comes after the given sequence
    /// number. Every sequence number comes after `SequenceNumber::none()`,
    /// except for `SequenceNumber::none()` which never comes after anything.
    pub fn after(self, other: SequenceNumber) -> bool {
        self.0 > other.0
    }

    /// Returns the sequence number that comes before this one.
    pub fn preceding(self) -> SequenceNumber {
        if self.0 == 0 {
            SequenceNumber(0)
        } else {
            SequenceNumber(self.0 - 1)
        }
    }

    /// "None" value for sequence numbers, used to indicate that nothing has
    /// been transferred yet.
    pub fn none() -> SequenceNumber {
        SequenceNumber(0)
    }
}

/// Struct used to generate sequence numbers.
///
/// Sequence numbers start at 0 and count up monotonously.
pub struct SequenceNumberGenerator {
    counter: std::ops::RangeFrom<u64>,
    previous: SequenceNumber,
}

impl Default for SequenceNumberGenerator {
    fn default() -> Self {
        Self::new()
    }
}

impl SequenceNumberGenerator {
    /// Constructs a new sequence number generator.
    pub fn new() -> SequenceNumberGenerator {
        SequenceNumberGenerator {
            counter: (1..),
            previous: SequenceNumber::none(),
        }
    }

    /// Acquires the next sequence number.
    pub fn get_next(&mut self) -> SequenceNumber {
        let next = SequenceNumber((&mut self.counter).next().unwrap());
        self.previous = next;
        next
    }

    /// Returns the previously acquired sequence number.
    pub fn get_previous(&self) -> SequenceNumber {
        self.previous
    }
}

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

    #[test]
    fn construct_generator() {
        let mut s1 = SequenceNumberGenerator::default();
        let mut s2 = SequenceNumberGenerator::new();
        assert_eq!(s1.get_next(), s2.get_next());
    }

    #[test]
    fn gets() {
        let mut s = SequenceNumberGenerator::default();
        assert_eq!(s.get_previous(), SequenceNumber(0));
        assert_eq!(s.get_previous(), SequenceNumber(0));
        assert_eq!(s.get_next(), SequenceNumber(1));
        assert_eq!(s.get_next(), SequenceNumber(2));
        assert_eq!(s.get_previous(), SequenceNumber(2));
        assert_eq!(s.get_next(), SequenceNumber(3));
        assert_eq!(s.get_previous(), SequenceNumber(3));
    }

    #[test]
    fn seqs() {
        let mut s = SequenceNumberGenerator::default();
        let sn = s.get_previous();

        assert_eq!(sn.preceding(), SequenceNumber(0));
        assert!(!sn.after(SequenceNumber(0)));
        assert!(!sn.after(SequenceNumber(1)));
        assert!(sn.acknowledges(SequenceNumber(0)));
        assert!(!sn.acknowledges(SequenceNumber(1)));

        let sn = s.get_next();
        assert_eq!(sn.preceding(), SequenceNumber(0));
        assert!(sn.after(SequenceNumber(0)));
        assert!(!sn.after(SequenceNumber(1)));
        assert!(sn.acknowledges(SequenceNumber(0)));
        assert!(sn.acknowledges(SequenceNumber(1)));

        let sn = s.get_next();
        assert_eq!(sn.preceding(), SequenceNumber(1));
        assert!(sn.after(SequenceNumber(0)));
        assert!(sn.after(SequenceNumber(1)));
        assert!(!sn.after(SequenceNumber(2)));
        assert!(sn.acknowledges(SequenceNumber(0)));
        assert!(sn.acknowledges(SequenceNumber(1)));
        assert!(sn.acknowledges(SequenceNumber(2)));
        assert!(!sn.acknowledges(SequenceNumber(3)));
    }

    #[test]
    fn display() {
        assert_eq!(SequenceNumber(123).to_string(), "123");
    }

}