msd 0.4.0

A library for reading and writing MSD files.
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

mod variant;

use crate::de::{parse::Values, Error, Result};
use serde::de::{DeserializeSeed, EnumAccess};

pub(in crate::de) struct Access<'a, 'b> {
    values: &'a mut Values<'b>,
}

impl<'a, 'b> Access<'a, 'b> {
    pub(in crate::de) fn new(values: &'a mut Values<'b>) -> Self {
        Self { values }
    }
}

impl<'a, 'b, 'de> EnumAccess<'de> for Access<'a, 'b> {
    type Error = Error;
    type Variant = variant::Access<'a, 'b>;

    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
    where
        V: DeserializeSeed<'de>,
    {
        Ok((
            seed.deserialize(variant::Deserializer::new(self.values.next()?))?,
            variant::Access::new(self.values),
        ))
    }
}

#[cfg(test)]
mod tests {
    use super::Access;
    use crate::de::{parse::Values, Position};
    use claims::assert_ok;
    use serde::{
        de,
        de::{EnumAccess, Visitor},
        Deserialize,
    };
    use std::fmt;

    #[test]
    fn variant() {
        #[derive(Debug, PartialEq)]
        struct Variant(String);
        impl<'de> Deserialize<'de> for Variant {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
            where
                D: de::Deserializer<'de>,
            {
                struct VariantVisitor;

                impl<'de> Visitor<'de> for VariantVisitor {
                    type Value = Variant;

                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                        formatter.write_str("identifier")
                    }

                    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
                    where
                        E: de::Error,
                    {
                        Ok(Variant(value.to_owned()))
                    }
                }

                deserializer.deserialize_identifier(VariantVisitor)
            }
        }

        let mut values = Values::new(b"foo", Position::new(0, 0));
        let access = Access::new(&mut values);

        let (variant, _variant_access) = assert_ok!(access.variant::<Variant>());
        assert_eq!(variant, Variant("foo".to_string()));
    }
}