aggligator 0.12.1

Aggregates multiple links (TCP, WebSocket, USB or similar) into one connection having their combined bandwidth and provides resiliency against failure of individual links, allowing failover and roaming between networks in user space.
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

//! Sequence numbering.

use std::{
    cmp::Ordering,
    fmt,
    ops::{Add, AddAssign, Sub, SubAssign},
};

/// A 32-bit sequence number that wraps around.
///
/// The difference between the lowest and highest used sequence number
/// must not exceed [Self::USABLE_INTERVAL].
#[derive(Default, Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub(crate) struct Seq(pub u32);

impl Seq {
    /// Zero.
    pub const ZERO: Self = Self(0);

    /// Minus one.
    pub const MINUS_ONE: Self = Self(0u32.wrapping_sub(1));

    const ONE_QUARTER: u32 = u32::MAX / 4;
    const THREE_QUARTERS: u32 = Self::ONE_QUARTER * 3;

    /// Useable interval.
    pub const USABLE_INTERVAL: i32 = 65_536;
}

const _: () = assert!(Seq::USABLE_INTERVAL as u32 <= Seq::ONE_QUARTER);

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

impl From<u32> for Seq {
    fn from(v: u32) -> Self {
        Self(v)
    }
}

impl From<Seq> for u32 {
    fn from(v: Seq) -> Self {
        v.0
    }
}

impl Add<u32> for Seq {
    type Output = Self;
    fn add(self, rhs: u32) -> Self::Output {
        Self(self.0.wrapping_add(rhs))
    }
}

impl Add<i32> for Seq {
    type Output = Self;
    fn add(self, rhs: i32) -> Self::Output {
        Self(self.0.wrapping_add(rhs as u32))
    }
}

impl AddAssign<u32> for Seq {
    fn add_assign(&mut self, rhs: u32) {
        *self = *self + rhs;
    }
}

impl Sub<Seq> for Seq {
    type Output = i32;
    fn sub(self, rhs: Seq) -> Self::Output {
        self.0.wrapping_sub(rhs.0) as i32
    }
}

impl Sub<u32> for Seq {
    type Output = Self;
    fn sub(self, rhs: u32) -> Self::Output {
        Self(self.0.wrapping_sub(rhs))
    }
}

impl Sub<i32> for Seq {
    type Output = Self;
    fn sub(self, rhs: i32) -> Self::Output {
        Self(self.0.wrapping_sub(rhs as u32))
    }
}

impl SubAssign<u32> for Seq {
    fn sub_assign(&mut self, rhs: u32) {
        *self = *self - rhs;
    }
}

impl Sub<usize> for Seq {
    type Output = Self;
    fn sub(self, rhs: usize) -> Self::Output {
        let rhs: u32 = rhs.try_into().unwrap();
        self - rhs
    }
}

impl PartialOrd for Seq {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

impl Ord for Seq {
    fn cmp(&self, other: &Self) -> Ordering {
        if self.0 < Self::ONE_QUARTER && other.0 >= Self::THREE_QUARTERS {
            Ordering::Greater
        } else if other.0 < Self::ONE_QUARTER && self.0 >= Self::THREE_QUARTERS {
            Ordering::Less
        } else {
            self.0.cmp(&other.0)
        }
    }
}