fn fmt()

in uniffi_pipeline/src/value.rs [48:91]

• 44 lines of code
• 3 McCabe index (conditional complexity)

    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::UInt8(val) => write!(f, "{val}u8"),
            Self::Int8(val) => write!(f, "{val}i8"),
            Self::UInt16(val) => write!(f, "{val}u16"),
            Self::Int16(val) => write!(f, "{val}i16"),
            Self::UInt32(val) => write!(f, "{val}u32"),
            Self::Int32(val) => write!(f, "{val}i32"),
            Self::UInt64(val) => write!(f, "{val}u64"),
            Self::Int64(val) => write!(f, "{val}i64"),
            Self::Float32(val) => write!(f, "{val}f32"),
            Self::Float64(val) => write!(f, "{val}f64"),
            Self::String(val) => write!(f, "{val:?}"),
            Self::Bool(val) => write!(f, "{val:?}"),
            Self::Option(val) => match val {
                Some(v) => f.debug_tuple("Some").field(v).finish(),
                None => f.debug_tuple("None").finish(),
            },
            Self::Vec(values) => f.debug_list().entries(values).finish(),
            Self::Map(values) => f
                .debug_map()
                .entries(values.iter().map(|(k, v)| (k, v)))
                .finish(),
            Self::Set(values) => f.debug_set().entries(values.iter()).finish(),
            Self::Struct { type_name, fields } => {
                let mut f = f.debug_struct(type_name);
                for (name, val) in fields {
                    f.field(name, val);
                }
                f.finish()
            }
            Self::Variant {
                type_name,
                variant_name,
                fields,
            } => {
                let mut f = f.debug_struct(&format!("{type_name}::{variant_name}"));
                for (name, val) in fields {
                    f.field(name, val);
                }
                f.finish()
            }
        }
    }