memberlist_proto/
version.rs

1/// Delegate version
2#[derive(
3  Debug, Default, Copy, Clone, PartialEq, Eq, Hash, derive_more::IsVariant, derive_more::Display,
4)]
5#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))]
6#[non_exhaustive]
7pub enum DelegateVersion {
8  /// Version 1
9  #[default]
10  #[display("v1")]
11  V1,
12  /// Unknown version (used for forwards and backwards compatibility)
13  #[display("unknown({_0})")]
14  Unknown(u8),
15}
16
17impl From<u8> for DelegateVersion {
18  fn from(v: u8) -> Self {
19    match v {
20      1 => Self::V1,
21      val => Self::Unknown(val),
22    }
23  }
24}
25
26impl From<DelegateVersion> for u8 {
27  fn from(v: DelegateVersion) -> Self {
28    match v {
29      DelegateVersion::V1 => 1,
30      DelegateVersion::Unknown(val) => val,
31    }
32  }
33}
34
35/// Protocol version
36#[derive(
37  Debug, Default, Copy, Clone, PartialEq, Eq, Hash, derive_more::IsVariant, derive_more::Display,
38)]
39#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))]
40#[non_exhaustive]
41pub enum ProtocolVersion {
42  /// Version 1
43  #[default]
44  #[display("v1")]
45  V1,
46  /// Unknown version (used for forwards and backwards compatibility)
47  #[display("unknown({_0})")]
48  Unknown(u8),
49}
50
51impl From<u8> for ProtocolVersion {
52  fn from(v: u8) -> Self {
53    match v {
54      1 => Self::V1,
55      val => Self::Unknown(val),
56    }
57  }
58}
59
60impl From<ProtocolVersion> for u8 {
61  fn from(v: ProtocolVersion) -> Self {
62    match v {
63      ProtocolVersion::V1 => 1,
64      ProtocolVersion::Unknown(val) => val,
65    }
66  }
67}
68
69macro_rules! impl_data {
70  ($($ty:ty),+$(,)?) => {
71    $(
72      impl<'a> super::DataRef<'a, Self> for $ty {
73        fn decode(src: &'a [u8]) -> Result<(usize, Self), super::DecodeError> {
74          if src.is_empty() {
75            return Err(super::DecodeError::buffer_underflow());
76          }
77
78          Ok((1, Self::from(src[0])))
79        }
80      }
81
82      impl super::Data for $ty {
83        const WIRE_TYPE: super::WireType = super::WireType::Byte;
84
85        type Ref<'a> = Self;
86
87        fn from_ref(val: Self::Ref<'_>) -> Result<Self, super::DecodeError> {
88          Ok(val)
89        }
90
91        #[inline]
92        fn encoded_len(&self) -> usize {
93          1
94        }
95
96        #[inline]
97        fn encode(&self, buf: &mut [u8]) -> Result<usize, super::EncodeError> {
98          if buf.is_empty() {
99            return Err(super::EncodeError::insufficient_buffer(1, 0));
100          }
101
102          buf[0] = u8::from(*self);
103          Ok(1)
104        }
105      }
106    )*
107  };
108}
109
110impl_data!(DelegateVersion, ProtocolVersion);
111
112#[cfg(test)]
113mod tests {
114  use super::*;
115
116  use arbitrary::{Arbitrary, Unstructured};
117
118  #[test]
119  fn test_delegate_version() {
120    let mut buf = [0; 64];
121    rand::fill(&mut buf[..]);
122
123    let mut data = Unstructured::new(&buf);
124    let _ = DelegateVersion::arbitrary(&mut data).unwrap();
125
126    assert_eq!(u8::from(DelegateVersion::V1), 1u8);
127    assert_eq!(DelegateVersion::V1.to_string(), "v1");
128    assert_eq!(DelegateVersion::Unknown(2).to_string(), "unknown(2)");
129    assert_eq!(DelegateVersion::from(1), DelegateVersion::V1);
130    assert_eq!(DelegateVersion::from(2), DelegateVersion::Unknown(2));
131  }
132
133  #[test]
134  fn test_protocol_version() {
135    let mut buf = [0; 64];
136    rand::fill(&mut buf[..]);
137
138    let mut data = Unstructured::new(&buf);
139    let _ = ProtocolVersion::arbitrary(&mut data).unwrap();
140    assert_eq!(u8::from(ProtocolVersion::V1), 1);
141    assert_eq!(ProtocolVersion::V1.to_string(), "v1");
142    assert_eq!(ProtocolVersion::Unknown(2).to_string(), "unknown(2)");
143    assert_eq!(ProtocolVersion::from(1), ProtocolVersion::V1);
144    assert_eq!(ProtocolVersion::from(2), ProtocolVersion::Unknown(2));
145  }
146}
memberlist_proto/version.rs

memberlist_proto/
version.rs
