xds-core 0.1.0

Core types, traits, and error handling for xDS control plane
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

//! Resource version tracking for xDS.
//!
//! This module provides [`ResourceVersion`], a type for tracking versions
//! of xDS resources. Versions are used to detect changes and avoid
//! sending unchanged resources.

use std::fmt;

/// Version identifier for xDS resources.
///
/// `ResourceVersion` wraps a version string and provides ordering and
/// comparison operations. An empty version represents the initial state
/// (no version received yet).
///
/// # Example
///
/// ```rust
/// use xds_core::ResourceVersion;
///
/// let v1 = ResourceVersion::new("v1");
/// let v2 = ResourceVersion::new("v2");
/// let empty = ResourceVersion::empty();
///
/// assert!(!v1.is_empty());
/// assert!(empty.is_empty());
/// assert_ne!(v1, v2);
/// ```
#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
pub struct ResourceVersion(String);

impl ResourceVersion {
    /// Create a new resource version from a string.
    #[must_use]
    pub fn new(version: impl Into<String>) -> Self {
        Self(version.into())
    }

    /// Create an empty resource version (initial state).
    #[must_use]
    pub fn empty() -> Self {
        Self(String::new())
    }

    /// Check if the version is empty (initial state).
    #[must_use]
    pub fn is_empty(&self) -> bool {
        self.0.is_empty()
    }

    /// Get the version as a string slice.
    #[must_use]
    pub fn as_str(&self) -> &str {
        &self.0
    }

    /// Consume and return the inner string.
    #[must_use]
    pub fn into_inner(self) -> String {
        self.0
    }
}

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

impl From<String> for ResourceVersion {
    fn from(s: String) -> Self {
        Self(s)
    }
}

impl From<&str> for ResourceVersion {
    fn from(s: &str) -> Self {
        Self(s.to_string())
    }
}

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

impl AsRef<str> for ResourceVersion {
    fn as_ref(&self) -> &str {
        &self.0
    }
}

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

    #[test]
    fn test_version_creation() {
        let v = ResourceVersion::new("v1");
        assert_eq!(v.as_str(), "v1");
        assert!(!v.is_empty());
    }

    #[test]
    fn test_empty_version() {
        let v = ResourceVersion::empty();
        assert!(v.is_empty());
        assert_eq!(v.as_str(), "");
    }

    #[test]
    fn test_version_equality() {
        let v1 = ResourceVersion::new("v1");
        let v1_copy = ResourceVersion::new("v1");
        let v2 = ResourceVersion::new("v2");

        assert_eq!(v1, v1_copy);
        assert_ne!(v1, v2);
    }

    #[test]
    fn test_version_from_string() {
        let v: ResourceVersion = "v1".into();
        assert_eq!(v.as_str(), "v1");

        let v: ResourceVersion = String::from("v2").into();
        assert_eq!(v.as_str(), "v2");
    }

    #[test]
    fn test_version_display() {
        let v = ResourceVersion::new("v1.2.3");
        assert_eq!(format!("{v}"), "v1.2.3");
    }
}