Savior

More complex custom (de-)serialization in Serde, v2

Feb 16th, 2020
635
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #![allow(clippy::zero_prefixed_literal)]
  2.  
  3. use lazy_static::lazy_static;
  4. use serde::de::{self, MapAccess, SeqAccess, Visitor};
  5. use serde::ser::SerializeSeq;
  6. use serde::{Deserialize, Deserializer, Serialize, Serializer}; // 1.4.0
  7.  
  8. use std::error::Error;
  9. use std::{cmp, fmt, marker::PhantomData};
  10.  
  11. use std::collections::HashMap as Map; // BTreeMap as Map;
  12.  
  13. lazy_static! {
  14.     static ref CSS_COLORS: Map<&'static str, (u8, u8, u8)> = [
  15.        ("indianred", (205u8, 92u8, 92u8)),
  16.        ("lightcoral", (240u8, 128u8, 128u8)),
  17.        ("salmon", (250u8, 128u8, 114u8)),
  18.        ("darksalmon", (233u8, 150u8, 122u8)),
  19.        ("lightsalmon", (255u8, 160u8, 122u8)),
  20.        ("crimson", (220u8, 20u8, 60u8)),
  21.        ("red", (255u8, 0u8, 0u8)),
  22.        ("firebrick", (178u8, 34u8, 34u8)),
  23.        ("darkred", (139u8, 0u8, 0u8)),
  24.        ("pink", (255u8, 192u8, 203u8)),
  25.        ("lightpink", (255u8, 182u8, 193u8)),
  26.        ("hotpink", (255u8, 105u8, 180u8)),
  27.        ("deeppink", (255u8, 20u8, 147u8)),
  28.        ("mediumvioletred", (199u8, 21u8, 133u8)),
  29.        ("palevioletred", (219u8, 112u8, 147u8)),
  30.        ("coral", (255u8, 127u8, 80u8)),
  31.        ("tomato", (255u8, 99u8, 71u8)),
  32.        ("orangered", (255u8, 69u8, 0u8)),
  33.        ("darkorange", (255u8, 140u8, 0u8)),
  34.        ("orange", (255u8, 165u8, 0u8)),
  35.        ("gold", (255u8, 215u8, 0u8)),
  36.        ("yellow", (255u8, 255u8, 0u8)),
  37.        ("lightyellow", (255u8, 255u8, 224u8)),
  38.        ("lemonchiffon", (255u8, 250u8, 205u8)),
  39.        ("lightgoldenrodyellow", (250u8, 250u8, 210u8)),
  40.        ("papayawhip", (255u8, 239u8, 213u8)),
  41.        ("moccasin", (255u8, 228u8, 181u8)),
  42.        ("peachpuff", (255u8, 218u8, 185u8)),
  43.        ("palegoldenrod", (238u8, 232u8, 170u8)),
  44.        ("khaki", (240u8, 230u8, 140u8)),
  45.        ("darkkhaki", (189u8, 183u8, 107u8)),
  46.        ("lavender", (230u8, 230u8, 250u8)),
  47.        ("thistle", (216u8, 191u8, 216u8)),
  48.        ("plum", (221u8, 160u8, 221u8)),
  49.        ("violet", (238u8, 130u8, 238u8)),
  50.        ("orchid", (218u8, 112u8, 214u8)),
  51.        ("fuchsia", (255u8, 0u8, 255u8)),
  52.        ("magenta", (255u8, 0u8, 255u8)),
  53.        ("mediumorchid", (186u8, 85u8, 211u8)),
  54.        ("mediumpurple", (147u8, 112u8, 219u8)),
  55.        ("blueviolet", (138u8, 43u8, 226u8)),
  56.        ("darkviolet", (148u8, 0u8, 211u8)),
  57.        ("darkorchid", (153u8, 50u8, 204u8)),
  58.        ("darkmagenta", (139u8, 0u8, 139u8)),
  59.        ("purple", (128u8, 0u8, 128u8)),
  60.        ("rebeccapurple", (102u8, 51u8, 153u8)),
  61.        ("indigo", (75u8, 0u8, 130u8)),
  62.        ("mediumslateblue", (123u8, 104u8, 238u8)),
  63.        ("slateblue", (106u8, 90u8, 205u8)),
  64.        ("darkslateblue", (72u8, 61u8, 139u8)),
  65.        ("greenyellow", (173u8, 255u8, 47u8)),
  66.        ("chartreuse", (127u8, 255u8, 0u8)),
  67.        ("lawngreen", (124u8, 252u8, 0u8)),
  68.        ("lime", (0u8, 255u8, 0u8)),
  69.        ("limegreen", (50u8, 205u8, 50u8)),
  70.        ("palegreen", (152u8, 251u8, 152u8)),
  71.        ("lightgreen", (144u8, 238u8, 144u8)),
  72.        ("mediumspringgreen", (0u8, 250u8, 154u8)),
  73.        ("springgreen", (0u8, 255u8, 127u8)),
  74.        ("mediumseagreen", (60u8, 179u8, 113u8)),
  75.        ("seagreen", (46u8, 139u8, 87u8)),
  76.        ("forestgreen", (34u8, 139u8, 34u8)),
  77.        ("green", (0u8, 128u8, 0u8)),
  78.        ("darkgreen", (0u8, 100u8, 0u8)),
  79.        ("yellowgreen", (154u8, 205u8, 50u8)),
  80.        ("olivedrab", (107u8, 142u8, 35u8)),
  81.        ("olive", (128u8, 128u8, 0u8)),
  82.        ("darkolivegreen", (85u8, 107u8, 47u8)),
  83.        ("mediumaquamarine", (102u8, 205u8, 170u8)),
  84.        ("darkseagreen", (143u8, 188u8, 143u8)),
  85.        ("lightseagreen", (32u8, 178u8, 170u8)),
  86.        ("darkcyan", (0u8, 139u8, 139u8)),
  87.        ("teal", (0u8, 128u8, 128u8)),
  88.        ("aqua", (0u8, 255u8, 255u8)),
  89.        ("cyan", (0u8, 255u8, 255u8)),
  90.        ("lightcyan", (224u8, 255u8, 255u8)),
  91.        ("paleturquoise", (175u8, 238u8, 238u8)),
  92.        ("aquamarine", (127u8, 255u8, 212u8)),
  93.        ("turquoise", (64u8, 224u8, 208u8)),
  94.        ("mediumturquoise", (72u8, 209u8, 204u8)),
  95.        ("darkturquoise", (0u8, 206u8, 209u8)),
  96.        ("cadetblue", (95u8, 158u8, 160u8)),
  97.        ("steelblue", (70u8, 130u8, 180u8)),
  98.        ("lightsteelblue", (176u8, 196u8, 222u8)),
  99.        ("powderblue", (176u8, 224u8, 230u8)),
  100.        ("lightblue", (173u8, 216u8, 230u8)),
  101.        ("skyblue", (135u8, 206u8, 235u8)),
  102.        ("lightskyblue", (135u8, 206u8, 250u8)),
  103.        ("deepskyblue", (0u8, 191u8, 255u8)),
  104.        ("dodgerblue", (30u8, 144u8, 255u8)),
  105.        ("cornflowerblue", (100u8, 149u8, 237u8)),
  106.        ("royalblue", (65u8, 105u8, 225u8)),
  107.        ("blue", (0u8, 0u8, 255u8)),
  108.        ("mediumblue", (0u8, 0u8, 205u8)),
  109.        ("darkblue", (0u8, 0u8, 139u8)),
  110.        ("navy", (0u8, 0u8, 128u8)),
  111.        ("midnightblue", (25u8, 25u8, 112u8)),
  112.        ("cornsilk", (255u8, 248u8, 220u8)),
  113.        ("blanchedalmond", (255u8, 235u8, 205u8)),
  114.        ("bisque", (255u8, 228u8, 196u8)),
  115.        ("navajowhite", (255u8, 222u8, 173u8)),
  116.        ("wheat", (245u8, 222u8, 179u8)),
  117.        ("burlywood", (222u8, 184u8, 135u8)),
  118.        ("tan", (210u8, 180u8, 140u8)),
  119.        ("rosybrown", (188u8, 143u8, 143u8)),
  120.        ("sandybrown", (244u8, 164u8, 96u8)),
  121.        ("goldenrod", (218u8, 165u8, 32u8)),
  122.        ("darkgoldenrod", (184u8, 134u8, 11u8)),
  123.        ("peru", (205u8, 133u8, 63u8)),
  124.        ("chocolate", (210u8, 105u8, 30u8)),
  125.        ("saddlebrown", (139u8, 69u8, 19u8)),
  126.        ("sienna", (160u8, 82u8, 45u8)),
  127.        ("brown", (165u8, 42u8, 42u8)),
  128.        ("maroon", (128u8, 0u8, 0u8)),
  129.        ("white", (255u8, 255u8, 255u8)),
  130.        ("snow", (255u8, 250u8, 250u8)),
  131.        ("honeydew", (240u8, 255u8, 240u8)),
  132.        ("mintcream", (245u8, 255u8, 250u8)),
  133.        ("azure", (240u8, 255u8, 255u8)),
  134.        ("aliceblue", (240u8, 248u8, 255u8)),
  135.        ("ghostwhite", (248u8, 248u8, 255u8)),
  136.        ("whitesmoke", (245u8, 245u8, 245u8)),
  137.        ("seashell", (255u8, 245u8, 238u8)),
  138.        ("beige", (245u8, 245u8, 220u8)),
  139.        ("oldlace", (253u8, 245u8, 230u8)),
  140.        ("floralwhite", (255u8, 250u8, 240u8)),
  141.        ("ivory", (255u8, 255u8, 240u8)),
  142.        ("antiquewhite", (250u8, 235u8, 215u8)),
  143.        ("linen", (250u8, 240u8, 230u8)),
  144.        ("lavenderblush", (255u8, 240u8, 245u8)),
  145.        ("mistyrose", (255u8, 228u8, 225u8)),
  146.        ("gainsboro", (220u8, 220u8, 220u8)),
  147.        ("lightgray", (211u8, 211u8, 211u8)),
  148.        ("lightgrey", (211u8, 211u8, 211u8)),
  149.        ("silver", (192u8, 192u8, 192u8)),
  150.        ("darkgray", (169u8, 169u8, 169u8)),
  151.        ("darkgrey", (169u8, 169u8, 169u8)),
  152.        ("gray", (128u8, 128u8, 128u8)),
  153.        ("grey", (128u8, 128u8, 128u8)),
  154.        ("dimgray", (105u8, 105u8, 105u8)),
  155.        ("dimgrey", (105u8, 105u8, 105u8)),
  156.        ("lightslategray", (119u8, 136u8, 153u8)),
  157.        ("lightslategrey", (119u8, 136u8, 153u8)),
  158.        ("slategray", (112u8, 128u8, 144u8)),
  159.        ("slategrey", (112u8, 128u8, 144u8)),
  160.        ("darkslategray", (47u8, 79u8, 79u8)),
  161.        ("darkslategrey", (47u8, 79u8, 79u8)),
  162.        ("black", (0u8, 0u8, 0u8)),
  163.    ]
  164.    .iter()
  165.    .copied()
  166.    .collect();
  167. }
  168.  
  169. #[derive(Debug, Deserialize, Serialize)]
  170. struct City<'a> {
  171.     name: &'a str,
  172.    location: Location,
  173.    color: Color,
  174.    #[serde(deserialize_with = "deserialize_seq_to_max")]
  175.    #[serde(rename(deserialize = "temperature"))]
  176.    max_temperature: i32,
  177. }
  178.  
  179. #[derive(Debug)]
  180. struct Location {
  181.    latitude: f64,
  182.    longitude: f64,
  183. }
  184.  
  185. #[derive(Debug)]
  186. struct Color {
  187.    red: u8,
  188.    green: u8,
  189.    blue: u8,
  190. }
  191.  
  192. impl<'de> Deserialize<'de> for Location {
  193.    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  194.    where
  195.        D: Deserializer<'de>,
  196.     {
  197.         enum Field {
  198.             Latitude,
  199.             Longitude,
  200.         };
  201.  
  202.         impl<'de> Deserialize<'de> for Field {
  203.             fn deserialize<D>(deserializer: D) -> Result<Field, D::Error>
  204.             where
  205.                 D: Deserializer<'de>,
  206.            {
  207.                struct FieldVisitor;
  208.  
  209.                impl<'de> Visitor<'de> for FieldVisitor {
  210.                    type Value = Field;
  211.  
  212.                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  213.                        formatter.write_str("`latitude` or `longitude`")
  214.                    }
  215.  
  216.                    fn visit_str<E>(self, value: &str) -> Result<Field, E>
  217.                    where
  218.                        E: de::Error,
  219.                    {
  220.                        match value {
  221.                            "latitude" | "lat" => Ok(Field::Latitude),
  222.                            "longitude" | "lng" => Ok(Field::Longitude),
  223.                            _ => Err(de::Error::unknown_field(value, FIELDS)),
  224.                        }
  225.                    }
  226.                }
  227.  
  228.                deserializer.deserialize_identifier(FieldVisitor)
  229.            }
  230.        }
  231.  
  232.        struct LocationVisitor;
  233.  
  234.        impl<'de> Visitor<'de> for LocationVisitor {
  235.            type Value = Location;
  236.  
  237.            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  238.                formatter.write_str(
  239.                    "a tuple of 2 values or a struct with fields 'latitude' and 'longitude'",
  240.                )
  241.            }
  242.  
  243.            fn visit_seq<V>(self, mut seq: V) -> Result<Location, V::Error>
  244.            where
  245.                V: SeqAccess<'de>,
  246.             {
  247.                 let latitude = seq
  248.                     .next_element()?
  249.                     .ok_or_else(|| de::Error::invalid_length(0, &self))?;
  250.                 let longitude = seq
  251.                     .next_element()?
  252.                     .ok_or_else(|| de::Error::invalid_length(1, &self))?;
  253.  
  254.                 Ok(Location {
  255.                     latitude,
  256.                     longitude,
  257.                 })
  258.             }
  259.  
  260.             fn visit_map<V>(self, mut map: V) -> Result<Location, V::Error>
  261.             where
  262.                 V: MapAccess<'de>,
  263.            {
  264.                let mut latitude = None;
  265.                let mut longitude = None;
  266.  
  267.                while let Some(key) = map.next_key()? {
  268.                    match key {
  269.                        Field::Latitude => {
  270.                            if latitude.is_some() {
  271.                                return Err(de::Error::duplicate_field("latitude"));
  272.                            }
  273.                            latitude = Some(map.next_value()?);
  274.                        }
  275.                        Field::Longitude => {
  276.                            if longitude.is_some() {
  277.                                return Err(de::Error::duplicate_field("longitude"));
  278.                            }
  279.                            longitude = Some(map.next_value()?);
  280.                        }
  281.                    }
  282.                }
  283.  
  284.                let latitude = latitude.ok_or_else(|| de::Error::missing_field("latitude"))?;
  285.                let longitude = longitude.ok_or_else(|| de::Error::missing_field("longitude"))?;
  286.                Ok(Location {
  287.                    latitude,
  288.                    longitude,
  289.                })
  290.            }
  291.        }
  292.  
  293.        const FIELDS: &[&str] = &["latitude", "longitude"];
  294.        deserializer.deserialize_struct("Location", FIELDS, LocationVisitor)
  295.    }
  296. }
  297.  
  298. impl Serialize for Location {
  299.    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  300.    where
  301.        S: Serializer,
  302.    {
  303.        let mut seq = serializer.serialize_seq(Some(2))?;
  304.        seq.serialize_element(&self.latitude)?;
  305.        seq.serialize_element(&self.longitude)?;
  306.        seq.end()
  307.    }
  308. }
  309.  
  310. impl std::str::FromStr for Color {
  311.    type Err = ();
  312.  
  313.    fn from_str(str_value: &str) -> Result<Self, Self::Err> {
  314.        let (red, green, blue) = if str_value.starts_with('#') {
  315.            let str_value = &str_value[1..];
  316.            let (red, green, blue) = match str_value.len() {
  317.                6 => {
  318.                    let parsed = u32::from_str_radix(str_value, 16).map_err(|_| ())?;
  319.  
  320.                    let red = (parsed >> 16) as u8;
  321.                    let green = (parsed >> 8) as u8;
  322.                    let blue = parsed as u8;
  323.  
  324.                    (red, green, blue)
  325.                }
  326.                3 => {
  327.                    let parsed = u32::from_str_radix(str_value, 16).map_err(|_| ())?;
  328.  
  329.                    let red = ((parsed >> 8) & 0xf) as u8;
  330.                    let green = ((parsed >> 4) & 0xf) as u8;
  331.                    let blue = (parsed & 0xf) as u8;
  332.  
  333.                    let red = (red << 4) + red;
  334.                    let green = (green << 4) + green;
  335.                    let blue = (blue << 4) + blue;
  336.  
  337.                    (red, green, blue)
  338.                }
  339.                _ => return Err(()),
  340.            };
  341.            Ok((red, green, blue))
  342.        } else {
  343.            CSS_COLORS
  344.                .get(&str_value.to_ascii_lowercase()[..])
  345.                .copied()
  346.                .ok_or_else(|| ())
  347.        }?;
  348.  
  349.        Ok(Self { red, green, blue })
  350.    }
  351. }
  352.  
  353. impl<'de> Deserialize<'de> for Color {
  354.    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  355.    where
  356.        D: Deserializer<'de>,
  357.     {
  358.         enum Field {
  359.             Red,
  360.             Green,
  361.             Blue,
  362.         };
  363.  
  364.         impl<'de> Deserialize<'de> for Field {
  365.             fn deserialize<D>(deserializer: D) -> Result<Field, D::Error>
  366.             where
  367.                 D: Deserializer<'de>,
  368.            {
  369.                struct FieldVisitor;
  370.  
  371.                impl<'de> Visitor<'de> for FieldVisitor {
  372.                    type Value = Field;
  373.  
  374.                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  375.                        formatter.write_str("`red`, `green` or `blue`")
  376.                    }
  377.  
  378.                    fn visit_str<E>(self, value: &str) -> Result<Field, E>
  379.                    where
  380.                        E: de::Error,
  381.                    {
  382.                        match value {
  383.                            "red" | "r" => Ok(Field::Red),
  384.                            "green" | "g" => Ok(Field::Green),
  385.                            "blue" | "b" => Ok(Field::Blue),
  386.                            _ => Err(de::Error::unknown_field(value, FIELDS)),
  387.                        }
  388.                    }
  389.                }
  390.  
  391.                deserializer.deserialize_identifier(FieldVisitor)
  392.            }
  393.        }
  394.  
  395.        struct ColorVisitor;
  396.  
  397.        impl<'de> Visitor<'de> for ColorVisitor {
  398.            type Value = Color;
  399.  
  400.            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  401.                formatter.write_str("a hexadecimal string, a tuple of 3 values or a struct with fields 'red', 'green' and 'blue'")
  402.            }
  403.  
  404.            fn visit_str<E>(self, value: &str) -> Result<Color, E>
  405.            where
  406.                E: de::Error,
  407.            {
  408.                value.parse().map_err(|_| {
  409.                    de::Error::custom("invalid format, expected (?:[0-9a-fA-F]{3}){1,2}")
  410.                })
  411.            }
  412.  
  413.            fn visit_seq<V>(self, mut seq: V) -> Result<Color, V::Error>
  414.            where
  415.                V: SeqAccess<'de>,
  416.             {
  417.                 let red = seq
  418.                     .next_element()?
  419.                     .ok_or_else(|| de::Error::invalid_length(0, &self))?;
  420.                 let green = seq
  421.                     .next_element()?
  422.                     .ok_or_else(|| de::Error::invalid_length(1, &self))?;
  423.                 let blue = seq
  424.                     .next_element()?
  425.                     .ok_or_else(|| de::Error::invalid_length(2, &self))?;
  426.  
  427.                 Ok(Color { red, green, blue })
  428.             }
  429.  
  430.             fn visit_map<V>(self, mut map: V) -> Result<Color, V::Error>
  431.             where
  432.                 V: MapAccess<'de>,
  433.            {
  434.                let mut red = None;
  435.                let mut green = None;
  436.                let mut blue = None;
  437.  
  438.                while let Some(key) = map.next_key()? {
  439.                    match key {
  440.                        Field::Red => {
  441.                            if red.is_some() {
  442.                                return Err(de::Error::duplicate_field("red"));
  443.                            }
  444.                            red = Some(map.next_value()?);
  445.                        }
  446.                        Field::Green => {
  447.                            if green.is_some() {
  448.                                return Err(de::Error::duplicate_field("green"));
  449.                            }
  450.                            green = Some(map.next_value()?);
  451.                        }
  452.                        Field::Blue => {
  453.                            if blue.is_some() {
  454.                                return Err(de::Error::duplicate_field("blue"));
  455.                            }
  456.                            blue = Some(map.next_value()?);
  457.                        }
  458.                    }
  459.                }
  460.  
  461.                let red = red.ok_or_else(|| de::Error::missing_field("red"))?;
  462.                let green = green.ok_or_else(|| de::Error::missing_field("green"))?;
  463.                let blue = blue.ok_or_else(|| de::Error::missing_field("blue"))?;
  464.                Ok(Color { red, green, blue })
  465.            }
  466.        }
  467.  
  468.        const FIELDS: &[&str] = &["red", "green", "blue"];
  469.        deserializer.deserialize_any(ColorVisitor)
  470.    }
  471. }
  472.  
  473. impl Serialize for Color {
  474.    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  475.    where
  476.        S: Serializer,
  477.    {
  478.        // use serde::ser::SerializeMap;
  479.  
  480.        // let mut map = serializer.serialize_map(Some(3))?;
  481.        // map.serialize_entry("r", &self.red)?;
  482.        // map.serialize_entry("g", &self.green)?;
  483.        // map.serialize_entry("b", &self.blue)?;
  484.        // map.end()
  485.  
  486.        serializer.serialize_str(&format!("rgb({}, {}, {})", self.red, self.green, self.blue))
  487.    }
  488. }
  489.  
  490. fn deserialize_seq_to_max<'de, T, D>(deserializer: D) -> Result<T, D::Error>
  491. where
  492.     T: Deserialize<'de> + Ord,
  493.    D: Deserializer<'de>,
  494. {
  495.     struct MaxVisitor<T>(PhantomData<fn() -> T>);
  496.  
  497.     impl<'de, T> Visitor<'de> for MaxVisitor<T>
  498.     where
  499.         T: Deserialize<'de> + Ord,
  500.    {
  501.        type Value = T;
  502.  
  503.        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  504.            formatter.write_str(
  505.                "either a non-empty sequence or a non-empty associative array (keys are ignored)",
  506.            )
  507.        }
  508.  
  509.        fn visit_seq<S>(self, mut seq: S) -> Result<T, S::Error>
  510.        where
  511.            S: SeqAccess<'de>,
  512.         {
  513.             let mut max = seq
  514.                 .next_element()?
  515.                 .ok_or_else(|| de::Error::custom("the sequence is empty"))?;
  516.  
  517.             while let Some(value) = seq.next_element()? {
  518.                 max = cmp::max(max, value);
  519.             }
  520.  
  521.             Ok(max)
  522.         }
  523.  
  524.         fn visit_map<M>(self, mut map: M) -> Result<T, M::Error>
  525.         where
  526.             M: MapAccess<'de>,
  527.        {
  528.            let mut max;
  529.            if map.next_key::<&'de str>()?.is_some() {
  530.                 max = map.next_value()?;
  531.             } else {
  532.                 return Err(de::Error::custom("the associative array is empty"));
  533.             }
  534.  
  535.             while let Some(_) = map.next_key::<&'de str>()? {
  536.                max = cmp::max(max, map.next_value()?);
  537.            }
  538.  
  539.            Ok(max)
  540.        }
  541.    }
  542.  
  543.    deserializer.deserialize_any(MaxVisitor(PhantomData))
  544. }
  545.  
  546. fn main() -> Result<(), Box<dyn Error>> {
  547.    let json = [
  548.        r##"{
  549.   "name": "London",
  550.   "location": [51.509865, -0.118092],
  551.   "color": "#ffffff",
  552.   "temperature": {
  553.       "2020-02-15": 13,
  554.       "2020-02-16": 14,
  555.       "2020-02-17": 10
  556.   }
  557. }"##,
  558.        r##"{
  559.   "name": "Tokyo",
  560.   "location": {
  561.       "latitude": 35.652832,
  562.       "lng": 139.839478
  563.   },
  564.   "color": "#a00",
  565.   "temperature": [17, 15, 17]
  566. }"##,
  567.        r#"{
  568.   "name": "Moscow",
  569.   "location": {
  570.       "latitude": 55.751244,
  571.       "longitude": 37.618423
  572.   },
  573.   "color": [100, 100, 100],
  574.   "temperature": [1, 1, 5]
  575. }"#,
  576.        r#"{
  577.   "name": "Hong Kong",
  578.   "location": [22.286394, 114.149139],
  579.   "color": "darkorchid",
  580.   "temperature": [14, 13, 14]
  581. }"#,
  582.        r#"{
  583.   "name": "Sydney",
  584.   "location": [-33.865143, 151.209900],
  585.   "color": "darkmagenta",
  586.   "temperature": [21, 23, 27]
  587. }"#,
  588.        r#"{
  589.   "name": "Paris",
  590.   "location": {
  591.       "lat": 48.864716,
  592.       "lng": 2.349014
  593.   },
  594.   "color": {
  595.       "red": 40,
  596.       "green": 160,
  597.       "blue": 0
  598.   },
  599.   "temperature": [15, 17, 11]
  600. }"#,
  601.    ];
  602.    println!("Source JSON: [{}]", json.join(",\n"));
  603.  
  604.    let cities: Vec<_> = json
  605.        .iter()
  606.        .filter_map(|json| {
  607.            // use std::time::Instant;
  608.  
  609.            // let now = Instant::now();
  610.            // serde_json::from_str(json)
  611.            //     .map(|v: City| (v, Instant::now() - now))
  612.            //     .ok()
  613.            serde_json::from_str::<City>(json).ok()
  614.        })
  615.        .collect();
  616.  
  617.    println!("\nDeserialized: {:#?}", cities);
  618.  
  619.    let serialized: Vec<_> = cities
  620.        .iter()
  621.        .filter_map(|city| {
  622.            // use std::time::Instant;
  623.  
  624.            // let now = Instant::now();
  625.            // serde_json::to_string_pretty(&city)
  626.            //     .map(|v| format!("({}, {:#?})", v, Instant::now() - now))
  627.            //     .ok()
  628.  
  629.            serde_json::to_string_pretty(&city).ok()
  630.        })
  631.        .collect();
  632.  
  633.    println!("\nSerialized: [{}]", serialized.join(",\n"));
  634.    Ok(())
  635. }
RAW Paste Data

Adblocker detected! Please consider disabling it...

We've detected AdBlock Plus or some other adblocking software preventing Pastebin.com from fully loading.

We don't have any obnoxious sound, or popup ads, we actively block these annoying types of ads!

Please add Pastebin.com to your ad blocker whitelist or disable your adblocking software.

×