rust_eureka/request/
register.rs

1use super::Instance;
2use serde::de::{Deserialize, Deserializer, Error as DeError, MapAccess, Visitor};
3use serde::ser::{Serialize, SerializeStruct, Serializer};
4use std::fmt;
5
6const REGISTER: &str = "RegisterRequest";
7const INSTANCE: &str = "instance";
8const FIELDS: &[&str] = &[INSTANCE];
9
10#[derive(Debug, PartialEq)]
11pub struct RegisterRequest {
12    pub instance: Instance,
13}
14
15impl RegisterRequest {
16    pub fn new(instance: Instance) -> RegisterRequest {
17        RegisterRequest { instance }
18    }
19}
20
21impl Serialize for RegisterRequest {
22    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
23    where
24        S: Serializer,
25    {
26        let mut s = serializer.serialize_struct(REGISTER, 1)?;
27        s.serialize_field(INSTANCE, &self.instance)?;
28        s.end()
29    }
30}
31
32impl<'de> Deserialize<'de> for RegisterRequest {
33    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
34    where
35        D: Deserializer<'de>,
36    {
37        enum Field {
38            Instance,
39        }
40
41        impl<'de> Deserialize<'de> for Field {
42            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
43            where
44                D: Deserializer<'de>,
45            {
46                struct FieldVisitor;
47                impl<'de> Visitor<'de> for FieldVisitor {
48                    type Value = Field;
49
50                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
51                        formatter.write_str("expecting 'instance'")
52                    }
53
54                    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
55                    where
56                        E: DeError,
57                    {
58                        match v {
59                            INSTANCE => Ok(Field::Instance),
60                            _ => Err(DeError::unknown_field(v, FIELDS)),
61                        }
62                    }
63                }
64                deserializer.deserialize_identifier(FieldVisitor)
65            }
66        }
67
68        struct RegisterVisitor;
69        impl<'de> Visitor<'de> for RegisterVisitor {
70            type Value = RegisterRequest;
71
72            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
73                formatter.write_str("expecting struct Register")
74            }
75            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
76            where
77                A: MapAccess<'de>,
78            {
79                let mut maybe_instance = None;
80
81                while let Some(key) = map.next_key()? {
82                    match key {
83                        Field::Instance => {
84                            if maybe_instance.is_some() {
85                                return Err(DeError::duplicate_field(INSTANCE));
86                            }
87                            maybe_instance = Some(map.next_value()?)
88                        }
89                    }
90                }
91
92                let instance = maybe_instance.ok_or_else(|| DeError::missing_field(INSTANCE));
93                Ok(RegisterRequest::new(instance?))
94            }
95        }
96
97        deserializer.deserialize_struct(REGISTER, FIELDS, RegisterVisitor)
98    }
99}
100
101#[cfg(test)]
102mod tests {
103    use super::super::instance::tests::{build_test_instance, build_test_instance_json};
104    use super::*;
105    use serde_json;
106
107    #[test]
108    fn test_instance_serialization() {
109        let json = build_register_json();
110        let instance = build_test_instance();
111        let rr = RegisterRequest::new(instance);
112        let result = serde_json::to_string(&rr).unwrap();
113
114        //                let combined = json.chars().zip(result.chars());
115        //                for (a, b) in combined {
116        //                    print!("{}", b);
117        //                    assert_eq!(a, b);
118        //                }
119        assert_eq!(json, result);
120    }
121
122    #[test]
123    fn test_instance_deserialization() {
124        let json = build_register_json();
125        let instance = build_test_instance();
126        let rr = RegisterRequest::new(instance);
127        let result = serde_json::from_str(&json).unwrap();
128        assert_eq!(rr, result);
129    }
130
131    fn build_register_json() -> String {
132        format!("{{\"instance\":{}}}", build_test_instance_json())
133    }
134}
rust_eureka/request/register.rs

rust_eureka/request/
register.rs
