bacon 3.23.0

background rust compiler
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

use {
    schemars::{
        JsonSchema,
        Schema,
        SchemaGenerator,
        json_schema,
    },
    serde::{
        Deserialize,
        Deserializer,
        Serialize,
        Serializer,
        de,
    },
    std::{
        borrow::Cow,
        fmt,
        ops::Mul,
        str::FromStr,
    },
};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct Volume {
    /// Volume in [0, 100]
    percent: u16, // u16 ensures we can multiply it without overflow
}
impl Default for Volume {
    fn default() -> Self {
        Self { percent: 100 }
    }
}
impl Mul for Volume {
    type Output = Self;
    fn mul(
        self,
        rhs: Self,
    ) -> Self {
        Self {
            percent: self.percent * rhs.percent / 100,
        }
    }
}
impl Volume {
    pub fn new(percent: u16) -> Self {
        Self {
            percent: percent.clamp(0, 100),
        }
    }
    /// Return the volume in [0, 100]
    pub fn as_percent(self) -> u16 {
        self.percent
    }
    /// Return the volume in [0, 1]
    pub fn as_part(self) -> f32 {
        f32::from(self.percent) / 100f32
    }
}
#[derive(Debug, Clone, PartialEq)]
pub enum ParseVolumeError {
    ValueOutOfRange,
    NotU16(String),
}
impl fmt::Display for ParseVolumeError {
    fn fmt(
        &self,
        f: &mut fmt::Formatter<'_>,
    ) -> fmt::Result {
        match self {
            Self::ValueOutOfRange => write!(f, "value out of [0-100] range"),
            Self::NotU16(s) => write!(f, "value '{s}' is not a valid integer"),
        }
    }
}
impl std::error::Error for ParseVolumeError {}

impl FromStr for Volume {
    type Err = ParseVolumeError;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let s = s.trim_end_matches('%');
        let percent: u16 = s
            .parse()
            .map_err(|_| ParseVolumeError::NotU16(s.to_string()))?;
        if percent > 100 {
            return Err(ParseVolumeError::ValueOutOfRange);
        }
        Ok(Self { percent })
    }
}
impl std::fmt::Display for Volume {
    fn fmt(
        &self,
        f: &mut std::fmt::Formatter<'_>,
    ) -> std::fmt::Result {
        write!(f, "{}%", self.percent)
    }
}
impl Serialize for Volume {
    fn serialize<S>(
        &self,
        serializer: S,
    ) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        serializer.collect_str(self)
    }
}
impl<'de> Deserialize<'de> for Volume {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        let s = String::deserialize(deserializer)?;
        Self::from_str(&s).map_err(de::Error::custom)
    }
}
impl JsonSchema for Volume {
    fn schema_name() -> Cow<'static, str> {
        "Volume".into()
    }
    fn schema_id() -> Cow<'static, str> {
        concat!(module_path!(), "::Volume").into()
    }
    fn json_schema(_gen: &mut SchemaGenerator) -> Schema {
        json_schema!({
            "type": "string",
            "description": "Volume percentage written as an integer between 0 and 100, optionally suffixed with '%'.",
        })
    }
    fn inline_schema() -> bool {
        true
    }
}