serde valuable wip

lib.rs

#[allow(unused_variables, unreachable_code)]
mod random {
    use serde::{
        Serialize, Serializer,
        ser::{
            SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant, SerializeTuple,
            SerializeTupleStruct, SerializeTupleVariant,
        },
    };
    use valuable::StructDef;

    pub struct Json<T>(pub T);

    impl<T: Serialize> valuable::Valuable for Json<T> {
        fn as_value(&self) -> valuable::Value<'_> {
            unimplemented!();
            valuable::Value::Unit
        }

        fn visit(&self, visit: &mut dyn valuable::Visit) {}
    }

    pub struct ValuableSerializer;

    impl<'a> Serializer for &'a mut ValuableSerializer {
        type Error = serde_json::Error;
        type Ok = ();
        type SerializeMap = Self;
        type SerializeSeq = Self;
        type SerializeStruct = Self;
        type SerializeStructVariant = Self;
        type SerializeTuple = Self;
        type SerializeTupleStruct = Self;
        type SerializeTupleVariant = Self;

        fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
            unimplemented!();
            Ok(())
        }

        fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
            unimplemented!();
            Ok(())
        }
        fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
            unimplemented!();
            Ok(())
        }
        fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
            unimplemented!();
            Ok(())
        }
        fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
            unimplemented!();
            Ok(())
        }
        fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
            unimplemented!();
            Ok(())
        }

        fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
            unimplemented!();
            Ok(())
        }
        fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
            unimplemented!();
            Ok(())
        }
        fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
            unimplemented!();
            Ok(())
        }
        fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
            unimplemented!();
            Ok(())
        }
        fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
            unimplemented!();
            Ok(())
        }

        fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
            unimplemented!();
            Ok(())
        }
        fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
            unimplemented!();
            Ok(())
        }

        fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
            unimplemented!();
            Ok(())
        }
        fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
            unimplemented!();
            Ok(())
        }

        fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
            unimplemented!();
            Ok(())
        }

        fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
            unimplemented!();
            Ok(())
        }
        fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
        where
            T: ?Sized + Serialize,
        {
            unimplemented!();
            Ok(())
        }

        fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
            unimplemented!();
            Ok(())
        }
        fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, Self::Error> {
            unimplemented!();
            Ok(())
        }
        fn serialize_unit_variant(
            self,
            name: &'static str,
            variant_index: u32,
            variant: &'static str,
        ) -> Result<Self::Ok, Self::Error> {
            unimplemented!();
            Ok(())
        }

        fn serialize_newtype_struct<T>(
            self,
            name: &'static str,
            value: &T,
        ) -> Result<Self::Ok, Self::Error>
        where
            T: ?Sized + Serialize,
        {
            unimplemented!();
            Ok(())
        }
        fn serialize_newtype_variant<T>(
            self,
            name: &'static str,
            variant_index: u32,
            variant: &'static str,
            value: &T,
        ) -> Result<Self::Ok, Self::Error>
        where
            T: ?Sized + Serialize,
        {
            unimplemented!();
            Ok(())
        }

        fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
            unimplemented!();
            Ok(self)
        }

        fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
            unimplemented!();
            Ok(self)
        }
        fn serialize_tuple_struct(
            self,
            name: &'static str,
            len: usize,
        ) -> Result<Self::SerializeTupleStruct, Self::Error> {
            unimplemented!();
            Ok(self)
        }
        fn serialize_tuple_variant(
            self,
            name: &'static str,
            variant_index: u32,
            variant: &'static str,
            len: usize,
        ) -> Result<Self::SerializeTupleVariant, Self::Error> {
            unimplemented!();
            Ok(self)
        }

        fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
            unimplemented!();
            Ok(self)
        }

        fn serialize_struct(
            self,
            name: &'static str,
            len: usize,
        ) -> Result<Self::SerializeStruct, Self::Error> {
            Ok(self)
        }
        fn serialize_struct_variant(
            self,
            name: &'static str,
            variant_index: u32,
            variant: &'static str,
            len: usize,
        ) -> Result<Self::SerializeStructVariant, Self::Error> {
            unimplemented!();
            Ok(self)
        }
    }

    pub struct ValuableMapSerializer;

    impl SerializeMap for ValuableSerializer {
        type Ok = ();
        type Error = serde_json::Error;

        fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
        where
            T: ?Sized + Serialize,
        {
            unimplemented!();
            Ok(())
        }

        fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
        where
            T: ?Sized + Serialize,
        {
            unimplemented!();
            Ok(())
        }

        // optional
        fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<(), Self::Error>
        where
            K: ?Sized + Serialize,
            V: ?Sized + Serialize,
        {
            unimplemented!();
            Ok(())
        }

        fn end(self) -> Result<Self::Ok, Self::Error> {
            unimplemented!();
            Ok(())
        }
    }

    impl SerializeSeq for ValuableSerializer {
        type Ok = ();
        type Error = serde_json::Error;

        fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
        where
            T: ?Sized + Serialize,
        {
            unimplemented!();
            Ok(())
        }

        fn end(self) -> Result<Self::Ok, Self::Error> {
            unimplemented!();
            Ok(())
        }
    }

    struct ValuableStructSerializer<'a> {}

    impl SerializeStruct for ValuableSerializer {
        type Ok = ();
        type Error = serde_json::Error;

        fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
        where
            T: ?Sized + Serialize,
        {
            unimplemented!();
            Ok(())
        }

        //optional
        fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error> {
            unimplemented!();
            Ok(())
        }

        fn end(self) -> Result<Self::Ok, Self::Error> {
            unimplemented!();
            Ok(())
        }
    }

    impl SerializeStructVariant for ValuableSerializer {
        type Ok = ();
        type Error = serde_json::Error;

        fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
        where
            T: ?Sized + Serialize,
        {
            unimplemented!();
            Ok(())
        }

        // optional
        fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error> {
            unimplemented!();
            Ok(())
        }

        fn end(self) -> Result<Self::Ok, Self::Error> {
            unimplemented!();
            Ok(())
        }
    }

    impl SerializeTuple for ValuableSerializer {
        type Ok = ();
        type Error = serde_json::Error;

        fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
        where
            T: ?Sized + Serialize,
        {
            unimplemented!();
            Ok(())
        }

        fn end(self) -> Result<Self::Ok, Self::Error> {
            unimplemented!();
            Ok(())
        }
    }

    impl SerializeTupleStruct for ValuableSerializer {
        type Ok = ();
        type Error = serde_json::Error;

        fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
        where
            T: ?Sized + Serialize,
        {
            unimplemented!();
            Ok(())
        }

        fn end(self) -> Result<Self::Ok, Self::Error> {
            unimplemented!();
            Ok(())
        }
    }

    impl SerializeTupleVariant for ValuableSerializer {
        type Ok = ();
        type Error = serde_json::Error;

        fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
        where
            T: ?Sized + Serialize,
        {
            unimplemented!();
            Ok(())
        }

        fn end(self) -> Result<Self::Ok, Self::Error> {
            unimplemented!();
            Ok(())
        }
    }

    #[derive(Debug, Serialize)]
    struct MyStruct {
        value: u8,
    }

    #[test]
    fn my_test() {
        let value = MyStruct { value: 42 };
        let mut serializer = ValuableSerializer;
        value.serialize(serializer);
    }
}
pub mod tmp {
    #[derive(valuable::Valuable)]
    struct MyStruct {
        value: u8,
    }
}