oxicode 0.2.1

A modern binary serialization library - successor to bincode
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281

//! Semantic version representation.

use core::cmp::Ordering;
use core::fmt;

/// A semantic version (major.minor.patch).
///
/// Follows the semver 2.0 specification for version comparison:
/// - Major version changes indicate breaking changes
/// - Minor version changes add functionality in a backward-compatible manner
/// - Patch version changes are backward-compatible bug fixes
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
pub struct Version {
    /// Major version - incompatible API changes
    pub major: u16,
    /// Minor version - backward-compatible functionality
    pub minor: u16,
    /// Patch version - backward-compatible bug fixes
    pub patch: u16,
}

impl Version {
    /// Create a new version.
    #[inline]
    pub const fn new(major: u16, minor: u16, patch: u16) -> Self {
        Self {
            major,
            minor,
            patch,
        }
    }

    /// Create version 0.0.0.
    #[inline]
    pub const fn zero() -> Self {
        Self::new(0, 0, 0)
    }

    /// Parse a version from "major.minor.patch" string format.
    ///
    /// Returns None if parsing fails.
    pub fn parse(s: &str) -> Option<Self> {
        let mut parts = s.split('.');
        let major: u16 = parts.next()?.parse().ok()?;
        let minor: u16 = parts.next()?.parse().ok()?;
        let patch: u16 = parts.next()?.parse().ok()?;

        // Ensure no extra parts
        if parts.next().is_some() {
            return None;
        }

        Some(Self::new(major, minor, patch))
    }

    /// Check if this version is compatible with another version.
    ///
    /// By semver rules:
    /// - Same major version (if major > 0): compatible
    /// - Major version 0: only exact minor match is compatible
    #[inline]
    pub fn is_compatible_with(&self, other: &Self) -> bool {
        if self.major == 0 && other.major == 0 {
            // Pre-1.0: minor versions may break compatibility
            self.minor == other.minor
        } else {
            // Post-1.0: same major version is compatible
            self.major == other.major
        }
    }

    /// Check if this version represents a breaking change from another.
    #[inline]
    pub fn is_breaking_change_from(&self, other: &Self) -> bool {
        if self.major == 0 && other.major == 0 {
            // Pre-1.0: any minor bump could be breaking
            self.minor != other.minor
        } else {
            // Post-1.0: major bump is breaking
            self.major != other.major
        }
    }

    /// Check if this version is a minor update from another.
    #[inline]
    pub fn is_minor_update_from(&self, other: &Self) -> bool {
        self.major == other.major && self.minor > other.minor
    }

    /// Check if this version is a patch update from another.
    #[inline]
    pub fn is_patch_update_from(&self, other: &Self) -> bool {
        self.major == other.major && self.minor == other.minor && self.patch > other.patch
    }

    /// Check if this version satisfies a minimum requirement.
    #[inline]
    pub fn satisfies(&self, minimum: &Self) -> bool {
        *self >= *minimum
    }

    /// Convert to bytes for encoding (6 bytes: 2 each for major, minor, patch).
    #[inline]
    pub fn to_bytes(self) -> [u8; 6] {
        let mut bytes = [0u8; 6];
        bytes[0..2].copy_from_slice(&self.major.to_le_bytes());
        bytes[2..4].copy_from_slice(&self.minor.to_le_bytes());
        bytes[4..6].copy_from_slice(&self.patch.to_le_bytes());
        bytes
    }

    /// Parse from bytes.
    pub fn from_bytes(bytes: &[u8]) -> Option<Self> {
        if bytes.len() < 6 {
            return None;
        }

        let major = u16::from_le_bytes([bytes[0], bytes[1]]);
        let minor = u16::from_le_bytes([bytes[2], bytes[3]]);
        let patch = u16::from_le_bytes([bytes[4], bytes[5]]);

        Some(Self::new(major, minor, patch))
    }

    /// Get the version tuple.
    #[inline]
    pub const fn tuple(self) -> (u16, u16, u16) {
        (self.major, self.minor, self.patch)
    }
}

impl Ord for Version {
    fn cmp(&self, other: &Self) -> Ordering {
        match self.major.cmp(&other.major) {
            Ordering::Equal => match self.minor.cmp(&other.minor) {
                Ordering::Equal => self.patch.cmp(&other.patch),
                ord => ord,
            },
            ord => ord,
        }
    }
}

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, self.patch)
    }
}

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

    #[cfg(feature = "alloc")]
    use alloc::format;

    #[test]
    fn test_version_new() {
        let v = Version::new(1, 2, 3);
        assert_eq!(v.major, 1);
        assert_eq!(v.minor, 2);
        assert_eq!(v.patch, 3);
    }

    #[test]
    fn test_version_parse() {
        assert_eq!(Version::parse("1.2.3"), Some(Version::new(1, 2, 3)));
        assert_eq!(Version::parse("0.0.0"), Some(Version::new(0, 0, 0)));
        assert_eq!(
            Version::parse("100.200.300"),
            Some(Version::new(100, 200, 300))
        );

        // Invalid formats
        assert_eq!(Version::parse("1.2"), None);
        assert_eq!(Version::parse("1.2.3.4"), None);
        assert_eq!(Version::parse("a.b.c"), None);
        assert_eq!(Version::parse(""), None);
    }

    #[cfg(feature = "alloc")]
    #[test]
    fn test_version_display() {
        let v = Version::new(1, 2, 3);
        assert_eq!(format!("{}", v), "1.2.3");
    }

    #[test]
    fn test_version_ordering() {
        let v1 = Version::new(1, 0, 0);
        let v2 = Version::new(1, 1, 0);
        let v3 = Version::new(1, 1, 1);
        let v4 = Version::new(2, 0, 0);

        assert!(v1 < v2);
        assert!(v2 < v3);
        assert!(v3 < v4);
        assert!(v1 < v4);
    }

    #[test]
    fn test_version_compatibility() {
        let v1 = Version::new(1, 0, 0);
        let v2 = Version::new(1, 5, 0);
        let v3 = Version::new(2, 0, 0);

        // Same major version is compatible
        assert!(v1.is_compatible_with(&v2));
        assert!(v2.is_compatible_with(&v1));

        // Different major version is not compatible
        assert!(!v1.is_compatible_with(&v3));
        assert!(!v3.is_compatible_with(&v1));
    }

    #[test]
    fn test_version_0x_compatibility() {
        // Pre-1.0 versions are stricter
        let v1 = Version::new(0, 1, 0);
        let v2 = Version::new(0, 1, 5);
        let v3 = Version::new(0, 2, 0);

        // Same minor in 0.x is compatible
        assert!(v1.is_compatible_with(&v2));

        // Different minor in 0.x is not compatible
        assert!(!v1.is_compatible_with(&v3));
    }

    #[test]
    fn test_version_bytes() {
        let v = Version::new(1, 2, 3);
        let bytes = v.to_bytes();
        let v2 = Version::from_bytes(&bytes).expect("parse failed");
        assert_eq!(v, v2);
    }

    #[test]
    fn test_breaking_change() {
        let v1 = Version::new(1, 0, 0);
        let v2 = Version::new(2, 0, 0);

        assert!(v2.is_breaking_change_from(&v1));
        assert!(!v1.is_breaking_change_from(&v1));
    }

    #[test]
    fn test_minor_update() {
        let v1 = Version::new(1, 0, 0);
        let v2 = Version::new(1, 1, 0);
        let v3 = Version::new(2, 0, 0);

        assert!(v2.is_minor_update_from(&v1));
        assert!(!v1.is_minor_update_from(&v1));
        assert!(!v3.is_minor_update_from(&v1));
    }

    #[test]
    fn test_patch_update() {
        let v1 = Version::new(1, 0, 0);
        let v2 = Version::new(1, 0, 1);

        assert!(v2.is_patch_update_from(&v1));
        assert!(!v1.is_patch_update_from(&v1));
    }

    #[test]
    fn test_satisfies() {
        let v = Version::new(1, 5, 0);
        let min = Version::new(1, 0, 0);

        assert!(v.satisfies(&min));
        assert!(!min.satisfies(&v));
    }
}