se bincode;
use std::fmt;
use serde::{Deserialize, Serialize, Serializer};
use serde::ser::SerializeStruct;
use serde::de::{Deserializer, MapAccess, Visitor};

fn main() {
    let p = Point {
        x: b"foo".to_vec(),
        y: b"bar".to_vec(),
    };

    let serialized = serde_cbor::to_vec(&p).unwrap();
    let deserialized: Point = serde_cbor::from_slice(&serialized).unwrap();
    assert_eq!(p, deserialized);

    let serialized = bincode::serialize(&p).unwrap();
    let _: Point = bincode::deserialize(&serialized).expect("bincode deserialization failed");
}

#[derive(Debug, PartialEq)]
struct Point {
    x: Vec<u8>,
    y: Vec<u8>,
}

impl Serialize for Point {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut state = serializer.serialize_struct("Point", 2)?;
        state.serialize_field("x", &self.x)?;
        state.serialize_field("y", &self.y)?;
        state.end()
    }
}

impl<'de> Deserialize<'de> for Point {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        let fields = &["x", "y"];
        deserializer.deserialize_struct("Point", fields, PointVisitor)
    }
}

struct PointVisitor;

impl<'de> Visitor<'de> for PointVisitor {
    type Value = Point;

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

    fn visit_map<E: MapAccess<'de>>(self, mut map: E) -> Result<Point, E::Error> {
        let mut x = vec![];
        let mut y = vec![];

        while let Some(ref key) = map.next_key::<String>()? {
            let v = map.next_value::<Vec<u8>>()?;
            if key == "x" {
                x = v
            } else if key == "y" {
                y = v
            } else {
                panic!("Serialization failed!")
            }
        }

        Ok(Point { x, y })
    }
}