bms-rs 1.0.0

The BMS format parser.
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

use std::fmt::Debug;
use std::str::FromStr;

/// Type alias for the error type of a `FromStr` implementation.
type ParseError<T> = <T as FromStr>::Err;

/// A wrapper that preserves the original string representation of a value.
/// The value is stored as a Result to preserve parsing errors.
pub struct StringValue<T: FromStr>
where
    ParseError<T>: Debug + Clone + PartialEq + Eq,
{
    raw: String,
    value: Result<T, ParseError<T>>,
}

impl<T> StringValue<T>
where
    T: FromStr,
    ParseError<T>: Debug + Clone + PartialEq + Eq,
{
    /// Creates a `StringValue` from a value, generating a string representation.
    pub fn from_value(value: T) -> Self
    where
        T: ToString,
    {
        Self {
            raw: value.to_string(),
            value: Ok(value),
        }
    }

    /// Creates a `StringValue` from a raw string.
    #[must_use]
    pub fn new(raw: impl Into<String>) -> Self {
        let raw = raw.into();
        let value = T::from_str(&raw);
        Self { raw, value }
    }

    /// Returns a reference to the parsed value.
    pub const fn value(&self) -> &Result<T, ParseError<T>> {
        &self.value
    }

    /// Returns a reference to the raw string.
    pub fn raw(&self) -> &str {
        &self.raw
    }
}

// Implement Debug manually
impl<T: Debug + FromStr> Debug for StringValue<T>
where
    ParseError<T>: Debug + Clone + PartialEq + Eq,
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("StringValue")
            .field("raw", &self.raw)
            .field("value", &self.value)
            .finish()
    }
}

// Implement Clone manually
impl<T: FromStr + Clone> Clone for StringValue<T>
where
    ParseError<T>: Debug + Clone + PartialEq + Eq,
{
    fn clone(&self) -> Self {
        Self {
            raw: self.raw.clone(),
            value: self.value.clone(),
        }
    }
}

// Implement PartialEq manually
impl<T: FromStr + PartialEq> PartialEq for StringValue<T>
where
    ParseError<T>: Debug + Clone + PartialEq + Eq,
{
    fn eq(&self, other: &Self) -> bool {
        self.raw == other.raw && self.value == other.value
    }
}

// Implement Eq manually - only when T implements Eq
impl<T: FromStr + Eq> Eq for StringValue<T> where ParseError<T>: Debug + Clone + PartialEq + Eq {}

impl<T> AsRef<Result<T, ParseError<T>>> for StringValue<T>
where
    T: FromStr,
    ParseError<T>: Debug + Clone + PartialEq + Eq,
{
    fn as_ref(&self) -> &Result<T, ParseError<T>> {
        &self.value
    }
}

impl<T: std::fmt::Display + FromStr> std::fmt::Display for StringValue<T>
where
    ParseError<T>: Debug + Clone + PartialEq + Eq,
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        // Display the raw string representation
        std::fmt::Display::fmt(&self.raw, f)
    }
}

// Serde support - manually implement
#[cfg(feature = "serde")]
impl<T: FromStr> serde::Serialize for StringValue<T>
where
    ParseError<T>: Debug + Clone + PartialEq + Eq,
{
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        self.raw.serialize(serializer)
    }
}

#[cfg(feature = "serde")]
impl<'de, T: FromStr> serde::Deserialize<'de> for StringValue<T>
where
    ParseError<T>: Debug + Clone + PartialEq + Eq,
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let raw = String::deserialize(deserializer)?;
        Ok(Self::new(raw))
    }
}