Function deserialize

size-parser/src/lib.rs:333–413

Deserialize a memory size from a human-readable string into any numeric type

(deserializer: D)

    /// Deserialize a memory size from a human-readable string into any numeric type
    pub fn deserialize<'de, D, T>(deserializer: D) -> Result<T, D::Error>
    where
        D: Deserializer<'de>,
        T: TryFrom<u64>,
        T::Error: std::fmt::Display,
    {
        use serde::de::Visitor;
        use std::fmt;

        struct MemorySizeVisitor<T>(std::marker::PhantomData<T>);

        impl<T> Visitor<'_> for MemorySizeVisitor<T>
        where
            T: TryFrom<u64>,
            T::Error: std::fmt::Display,
        {
            type Value = T;

            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("a memory size string or number")
            }

            fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
            where
                E: Error,
            {
                let bytes = MemorySize::parse(value)
                    .map(|size| size.bytes())
                    .map_err(E::custom)?;

                T::try_from(bytes)
                    .map_err(|e| E::custom(format!("memory size conversion error: {}", e)))
            }

            fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
            where
                E: Error,
            {
                T::try_from(value)
                    .map_err(|e| E::custom(format!("memory size conversion error: {}", e)))
            }

            fn visit_u32<E>(self, value: u32) -> Result<Self::Value, E>
            where
                E: Error,
            {
                T::try_from(value as u64)
                    .map_err(|e| E::custom(format!("memory size conversion error: {}", e)))
            }

            fn visit_i32<E>(self, value: i32) -> Result<Self::Value, E>
            where
                E: Error,
            {
                if value < 0 {
                    return Err(E::custom("memory size cannot be negative"));
                }
                T::try_from(value as u64)