ocpi 0.3.5

Unofficial, in progress, OCPI implementation
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

use std::{fmt, str::FromStr};

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum VersionNumber {
    V2_0,
    V2_1,
    V2_1_1,
    V2_2,
}

impl fmt::Display for VersionNumber {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Self::V2_0 => f.write_str("2.0"),
            Self::V2_1 => f.write_str("2.1"),
            Self::V2_1_1 => f.write_str("2.1.1"),
            Self::V2_2 => f.write_str("2.2"),
        }
    }
}

impl FromStr for VersionNumber {
    type Err = String;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "2.0" => Ok(Self::V2_0),
            "2.1" => Ok(Self::V2_1),
            "2.1.1" => Ok(Self::V2_1_1),
            "2.2" => Ok(Self::V2_2),

            s => Err(format!("Invalid version `{}`", s)),
        }
    }
}

impl serde::Serialize for VersionNumber {
    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        match self {
            Self::V2_0 => s.serialize_str("2.0"),
            Self::V2_1 => s.serialize_str("2.1"),
            Self::V2_1_1 => s.serialize_str("2.1.1"),
            Self::V2_2 => s.serialize_str("2.2"),
        }
    }
}

impl<'de> serde::Deserialize<'de> for VersionNumber {
    fn deserialize<D>(deserializer: D) -> Result<VersionNumber, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        deserializer.deserialize_str(crate::common::FromStrVisitor::expecting(
            "a valid OCPI version",
        ))
    }
}

#[cfg(test)]
mod tests {

    use super::*;
    #[test]
    fn test_serialize_version_number() {
        assert_eq!(
            serde_json::to_string(&VersionNumber::V2_0).expect("Serializing"),
            r#""2.0""#
        );
        assert_eq!(
            serde_json::to_string(&VersionNumber::V2_1).expect("Serializing"),
            r#""2.1""#
        );
        assert_eq!(
            serde_json::to_string(&VersionNumber::V2_1_1).expect("Serializing"),
            r#""2.1.1""#
        );
        assert_eq!(
            serde_json::to_string(&VersionNumber::V2_2).expect("Serializing"),
            r#""2.2""#
        );
    }

    #[test]
    fn test_deserialize_version_number() {
        assert_eq!(
            VersionNumber::V2_0,
            serde_json::from_str(r#""2.0""#).expect("Deserializing"),
        );
        assert_eq!(
            VersionNumber::V2_1,
            serde_json::from_str(r#""2.1""#).expect("Deserializing"),
        );

        assert_eq!(
            VersionNumber::V2_1_1,
            serde_json::from_str(r#""2.1.1""#).expect("Deserializing"),
        );
        assert_eq!(
            VersionNumber::V2_2,
            serde_json::from_str(r#""2.2""#).expect("Deserializing"),
        );
    }
}