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

use super::*;
use bytes::{BufMut, BytesMut};
use std::cmp::Ordering;
use std::fmt;

/// Version number of the RSocket protocol.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Version {
    major: u16,
    minor: u16,
}

impl Version {
    /// Builds the protocol version with the given `major` and `minor` number.
    pub fn new(major: u16, minor: u16) -> Self {
        Version { major, minor }
    }

    /// Returns the `major` number of this version.
    pub fn major(self) -> u16 {
        self.major
    }

    /// Returns the `minor` number of this version.
    pub fn minor(self) -> u16 {
        self.minor
    }
}

impl Encode for Version {
    fn encode(&self, buf: &mut BytesMut) {
        buf.put_u16(self.major);
        buf.put_u16(self.minor);
    }

    fn len(&self) -> usize {
        4
    }
}

impl Ord for Version {
    fn cmp(&self, other: &Self) -> Ordering {
        let cmp_major = self.major.cmp(&other.major);
        if cmp_major != Ordering::Equal {
            return cmp_major;
        }
        self.minor.cmp(&other.minor)
    }
}

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

impl fmt::Display for Version {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}.{}", self.major, self.minor)
    }
}

impl Default for Version {
    fn default() -> Version {
        Version::new(1, 0)
    }
}