diff --git a/serde/src/private/macros.rs b/serde/src/private/macros.rs index cefe0a9d..a25de638 100644 --- a/serde/src/private/macros.rs +++ b/serde/src/private/macros.rs @@ -1,3 +1,27 @@ +#[doc(hidden)] +#[macro_export] +macro_rules! __private_serialize { + () => { + trait Serialize { + fn serialize(&self, serializer: S) -> Result + where + S: $crate::Serializer; + } + }; +} + +#[doc(hidden)] +#[macro_export] +macro_rules! __private_deserialize { + () => { + trait Deserialize<'de>: Sized { + fn deserialize(deserializer: D) -> Result + where + D: $crate::Deserializer<'de>; + } + }; +} + /// Used only by Serde doc tests. Not public API. #[doc(hidden)] #[macro_export] diff --git a/serde/src/ser/mod.rs b/serde/src/ser/mod.rs index e3684200..6ec41edd 100644 --- a/serde/src/ser/mod.rs +++ b/serde/src/ser/mod.rs @@ -346,6 +346,25 @@ pub trait Serializer: Sized { type SerializeStructVariant: SerializeStructVariant; /// Serialize a `bool` value. + /// + /// ```rust + /// # #[macro_use] + /// # extern crate serde; + /// # + /// # use serde::Serializer; + /// # + /// # __private_serialize!(); + /// # + /// impl Serialize for bool { + /// fn serialize(&self, serializer: S) -> Result + /// where S: Serializer + /// { + /// serializer.serialize_bool(*self) + /// } + /// } + /// # + /// # fn main() {} + /// ``` fn serialize_bool(self, v: bool) -> Result; /// Serialize an `i8` value. @@ -353,6 +372,25 @@ pub trait Serializer: Sized { /// If the format does not differentiate between `i8` and `i64`, a /// reasonable implementation would be to cast the value to `i64` and /// forward to `serialize_i64`. + /// + /// ```rust + /// # #[macro_use] + /// # extern crate serde; + /// # + /// # use serde::Serializer; + /// # + /// # __private_serialize!(); + /// # + /// impl Serialize for i8 { + /// fn serialize(&self, serializer: S) -> Result + /// where S: Serializer + /// { + /// serializer.serialize_i8(*self) + /// } + /// } + /// # + /// # fn main() {} + /// ``` fn serialize_i8(self, v: i8) -> Result; /// Serialize an `i16` value. @@ -360,6 +398,25 @@ pub trait Serializer: Sized { /// If the format does not differentiate between `i16` and `i64`, a /// reasonable implementation would be to cast the value to `i64` and /// forward to `serialize_i64`. + /// + /// ```rust + /// # #[macro_use] + /// # extern crate serde; + /// # + /// # use serde::Serializer; + /// # + /// # __private_serialize!(); + /// # + /// impl Serialize for i16 { + /// fn serialize(&self, serializer: S) -> Result + /// where S: Serializer + /// { + /// serializer.serialize_i16(*self) + /// } + /// } + /// # + /// # fn main() {} + /// ``` fn serialize_i16(self, v: i16) -> Result; /// Serialize an `i32` value. @@ -367,9 +424,47 @@ pub trait Serializer: Sized { /// If the format does not differentiate between `i32` and `i64`, a /// reasonable implementation would be to cast the value to `i64` and /// forward to `serialize_i64`. + /// + /// ```rust + /// # #[macro_use] + /// # extern crate serde; + /// # + /// # use serde::Serializer; + /// # + /// # __private_serialize!(); + /// # + /// impl Serialize for i32 { + /// fn serialize(&self, serializer: S) -> Result + /// where S: Serializer + /// { + /// serializer.serialize_i32(*self) + /// } + /// } + /// # + /// # fn main() {} + /// ``` fn serialize_i32(self, v: i32) -> Result; /// Serialize an `i64` value. + /// + /// ```rust + /// # #[macro_use] + /// # extern crate serde; + /// # + /// # use serde::Serializer; + /// # + /// # __private_serialize!(); + /// # + /// impl Serialize for i64 { + /// fn serialize(&self, serializer: S) -> Result + /// where S: Serializer + /// { + /// serializer.serialize_i64(*self) + /// } + /// } + /// # + /// # fn main() {} + /// ``` fn serialize_i64(self, v: i64) -> Result; /// Serialize a `u8` value. @@ -377,6 +472,25 @@ pub trait Serializer: Sized { /// If the format does not differentiate between `u8` and `u64`, a /// reasonable implementation would be to cast the value to `u64` and /// forward to `serialize_u64`. + /// + /// ```rust + /// # #[macro_use] + /// # extern crate serde; + /// # + /// # use serde::Serializer; + /// # + /// # __private_serialize!(); + /// # + /// impl Serialize for u8 { + /// fn serialize(&self, serializer: S) -> Result + /// where S: Serializer + /// { + /// serializer.serialize_u8(*self) + /// } + /// } + /// # + /// # fn main() {} + /// ``` fn serialize_u8(self, v: u8) -> Result; /// Serialize a `u16` value. @@ -384,6 +498,25 @@ pub trait Serializer: Sized { /// If the format does not differentiate between `u16` and `u64`, a /// reasonable implementation would be to cast the value to `u64` and /// forward to `serialize_u64`. + /// + /// ```rust + /// # #[macro_use] + /// # extern crate serde; + /// # + /// # use serde::Serializer; + /// # + /// # __private_serialize!(); + /// # + /// impl Serialize for u16 { + /// fn serialize(&self, serializer: S) -> Result + /// where S: Serializer + /// { + /// serializer.serialize_u16(*self) + /// } + /// } + /// # + /// # fn main() {} + /// ``` fn serialize_u16(self, v: u16) -> Result; /// Serialize a `u32` value. @@ -391,9 +524,47 @@ pub trait Serializer: Sized { /// If the format does not differentiate between `u32` and `u64`, a /// reasonable implementation would be to cast the value to `u64` and /// forward to `serialize_u64`. + /// + /// ```rust + /// # #[macro_use] + /// # extern crate serde; + /// # + /// # use serde::Serializer; + /// # + /// # __private_serialize!(); + /// # + /// impl Serialize for u32 { + /// fn serialize(&self, serializer: S) -> Result + /// where S: Serializer + /// { + /// serializer.serialize_u32(*self) + /// } + /// } + /// # + /// # fn main() {} + /// ``` fn serialize_u32(self, v: u32) -> Result; /// Serialize a `u64` value. + /// + /// ```rust + /// # #[macro_use] + /// # extern crate serde; + /// # + /// # use serde::Serializer; + /// # + /// # __private_serialize!(); + /// # + /// impl Serialize for u64 { + /// fn serialize(&self, serializer: S) -> Result + /// where S: Serializer + /// { + /// serializer.serialize_u64(*self) + /// } + /// } + /// # + /// # fn main() {} + /// ``` fn serialize_u64(self, v: u64) -> Result; /// Serialize an `f32` value. @@ -401,18 +572,94 @@ pub trait Serializer: Sized { /// If the format does not differentiate between `f32` and `f64`, a /// reasonable implementation would be to cast the value to `f64` and /// forward to `serialize_f64`. + /// + /// ```rust + /// # #[macro_use] + /// # extern crate serde; + /// # + /// # use serde::Serializer; + /// # + /// # __private_serialize!(); + /// # + /// impl Serialize for f32 { + /// fn serialize(&self, serializer: S) -> Result + /// where S: Serializer + /// { + /// serializer.serialize_f32(*self) + /// } + /// } + /// # + /// # fn main() {} + /// ``` fn serialize_f32(self, v: f32) -> Result; /// Serialize an `f64` value. + /// + /// ```rust + /// # #[macro_use] + /// # extern crate serde; + /// # + /// # use serde::Serializer; + /// # + /// # __private_serialize!(); + /// # + /// impl Serialize for f64 { + /// fn serialize(&self, serializer: S) -> Result + /// where S: Serializer + /// { + /// serializer.serialize_f64(*self) + /// } + /// } + /// # + /// # fn main() {} + /// ``` fn serialize_f64(self, v: f64) -> Result; /// Serialize a character. /// /// If the format does not support characters, it is reasonable to serialize /// it as a single element `str` or a `u32`. + /// + /// ```rust + /// # #[macro_use] + /// # extern crate serde; + /// # + /// # use serde::Serializer; + /// # + /// # __private_serialize!(); + /// # + /// impl Serialize for char { + /// fn serialize(&self, serializer: S) -> Result + /// where S: Serializer + /// { + /// serializer.serialize_char(*self) + /// } + /// } + /// # + /// # fn main() {} + /// ``` fn serialize_char(self, v: char) -> Result; /// Serialize a `&str`. + /// + /// ```rust + /// # #[macro_use] + /// # extern crate serde; + /// # + /// # use serde::Serializer; + /// # + /// # __private_serialize!(); + /// # + /// impl Serialize for str { + /// fn serialize(&self, serializer: S) -> Result + /// where S: Serializer + /// { + /// serializer.serialize_str(self) + /// } + /// } + /// # + /// # fn main() {} + /// ``` fn serialize_str(self, value: &str) -> Result; /// Serialize a chunk of raw byte data.