rust_eureka/request/
register.rs

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

rust_eureka/request/
register.rs
