Lines Matching full:serialize
3 //! The two most important traits in this module are [`Serialize`] and
6 //! - **A type that implements `Serialize` is a data structure** that can be
9 //! serialize any data structure supported by Serde.
11 //! # The Serialize trait
13 //! Serde provides [`Serialize`] implementations for many Rust primitive and
18 //! automatically generate [`Serialize`] implementations for structs and enums
21 //! In rare cases it may be necessary to implement [`Serialize`] manually for
22 //! some type in your program. See the [Implementing `Serialize`] section of the
25 //! Third-party crates may provide [`Serialize`] implementations for types that
28 //! provides an implementation of [`Serialize`] for it.
38 //! # Implementations of Serialize provided by Serde
98 //! [Implementing `Serialize`]: https://serde.rs/impl-serialize.html
100 //! [`Serialize`]: crate::Serialize
132 /// Trait used by `Serialize` implementations to generically construct
143 /// Used when a [`Serialize`] implementation encounters any error
149 /// For example, a filesystem [`Path`] may refuse to serialize
161 /// use serde::ser::{self, Serialize, Serializer};
163 /// impl Serialize for Path {
164 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
177 /// [`Serialize`]: crate::Serialize
196 /// Serde provides `Serialize` implementations for many Rust primitive and
201 /// automatically generate `Serialize` implementations for structs and enums in
204 /// In rare cases it may be necessary to implement `Serialize` manually for some
205 /// type in your program. See the [Implementing `Serialize`] section of the
208 /// Third-party crates may provide `Serialize` implementations for types that
211 /// provides an implementation of `Serialize` for it.
213 /// [Implementing `Serialize`]: https://serde.rs/impl-serialize.html
221 … note = "for local types consider adding `#[derive(serde::Serialize)]` to your `{Self}` type",
225 pub trait Serialize { trait
226 /// Serialize this value into the given Serde serializer.
228 /// See the [Implementing `Serialize`] section of the manual for more
232 /// use serde::ser::{Serialize, SerializeStruct, Serializer};
240 /// // This is what #[derive(Serialize)] would generate.
241 /// impl Serialize for Person {
242 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
255 /// [Implementing `Serialize`]: https://serde.rs/impl-serialize.html
256 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> in serialize() method
263 /// A **data format** that can serialize any data structure supported by Serde.
270 /// Implementations of `Serialize` map themselves into this data model by
343 /// should set `Ok = ()` and serialize into an [`io::Write`] or buffer
396 /// Serialize a `bool` value.
403 /// impl Serialize for bool {
404 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
414 /// Serialize an `i8` value.
425 /// impl Serialize for i8 {
426 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
436 /// Serialize an `i16` value.
447 /// impl Serialize for i16 {
448 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
458 /// Serialize an `i32` value.
469 /// impl Serialize for i32 {
470 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
480 /// Serialize an `i64` value.
487 /// impl Serialize for i64 {
488 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
498 /// Serialize an `i128` value.
505 /// impl Serialize for i128 {
506 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
521 /// Serialize a `u8` value.
532 /// impl Serialize for u8 {
533 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
543 /// Serialize a `u16` value.
554 /// impl Serialize for u16 {
555 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
565 /// Serialize a `u32` value.
576 /// impl Serialize for u32 {
577 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
587 /// Serialize a `u64` value.
594 /// impl Serialize for u64 {
595 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
605 /// Serialize a `u128` value.
612 /// impl Serialize for u128 {
613 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
628 /// Serialize an `f32` value.
639 /// impl Serialize for f32 {
640 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
650 /// Serialize an `f64` value.
657 /// impl Serialize for f64 {
658 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
668 /// Serialize a character.
670 /// If the format does not support characters, it is reasonable to serialize
678 /// impl Serialize for char {
679 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
689 /// Serialize a `&str`.
696 /// impl Serialize for str {
697 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
707 /// Serialize a chunk of raw byte data.
709 /// Enables serializers to serialize byte slices more compactly or more
742 /// Serialize a [`None`] value.
745 /// # use serde::{Serialize, Serializer};
754 /// impl<T> Serialize for Option<T>
756 /// T: Serialize,
758 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
775 /// Serialize a [`Some(T)`] value.
778 /// # use serde::{Serialize, Serializer};
787 /// impl<T> Serialize for Option<T>
789 /// T: Serialize,
791 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
808 T: ?Sized + Serialize; in serialize_some() argument
810 /// Serialize a `()` value.
817 /// impl Serialize for () {
818 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
828 /// Serialize a unit struct like `struct Unit` or `PhantomData<T>`.
833 /// use serde::{Serialize, Serializer};
837 /// impl Serialize for Nothing {
838 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
848 /// Serialize a unit variant like `E::A` in `enum E { A, B }`.
855 /// use serde::{Serialize, Serializer};
862 /// impl Serialize for E {
863 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
881 /// Serialize a newtype struct like `struct Millimeters(u8)`.
885 /// be to forward to `value.serialize(self)`.
888 /// use serde::{Serialize, Serializer};
892 /// impl Serialize for Millimeters {
893 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
907 T: ?Sized + Serialize; in serialize_newtype_struct() argument
909 /// Serialize a newtype variant like `E::N` in `enum E { N(u8) }`.
916 /// use serde::{Serialize, Serializer};
923 /// impl Serialize for E {
924 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
943 T: ?Sized + Serialize; in serialize_newtype_variant() argument
945 /// Begin to serialize a variably sized sequence. This call must be
973 /// use serde::ser::{Serialize, SerializeSeq, Serializer};
975 /// impl<T> Serialize for Vec<T>
977 /// T: Serialize,
979 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
993 /// Begin to serialize a statically sized sequence whose length will be
999 /// use serde::ser::{Serialize, SerializeTuple, Serializer};
1002 /// # trait Serialize {}
1003 /// impl<A, B, C> Serialize for (A, B, C)
1009 /// # impl<A, B, C> Serialize for Tuple3<A, B, C>
1011 /// A: Serialize,
1012 /// B: Serialize,
1013 /// C: Serialize,
1015 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1029 /// use serde::ser::{Serialize, SerializeTuple, Serializer};
1034 /// impl Serialize for Vram {
1035 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1049 /// Begin to serialize a tuple struct like `struct Rgb(u8, u8, u8)`. This
1057 /// use serde::ser::{Serialize, SerializeTupleStruct, Serializer};
1061 /// impl Serialize for Rgb {
1062 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1080 /// Begin to serialize a tuple variant like `E::T` in `enum E { T(u8, u8)
1089 /// use serde::ser::{Serialize, SerializeTupleVariant, Serializer};
1096 /// impl Serialize for E {
1097 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1127 /// Begin to serialize a map. This call must be followed by zero or more
1154 /// use serde::ser::{Serialize, SerializeMap, Serializer};
1156 /// impl<K, V> Serialize for HashMap<K, V>
1158 /// K: Serialize,
1159 /// V: Serialize,
1161 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1175 /// Begin to serialize a struct like `struct Rgb { r: u8, g: u8, b: u8 }`.
1184 /// use serde::ser::{Serialize, SerializeStruct, Serializer};
1192 /// impl Serialize for Rgb {
1193 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1211 /// Begin to serialize a struct variant like `E::S` in `enum E { S { r: u8,
1222 /// use serde::ser::{Serialize, SerializeStructVariant, Serializer};
1228 /// impl Serialize for E {
1229 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1264 /// use serde::{Serialize, Serializer};
1270 /// impl Serialize for SecretlyOneHigher {
1271 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1284 <I as IntoIterator>::Item: Serialize, in collect_seq() argument
1299 /// use serde::{Serialize, Serializer};
1307 /// impl Serialize for MapToUnit {
1308 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1320 K: Serialize, in collect_map() argument
1321 V: Serialize, in collect_map() argument
1330 /// Serialize a string produced by an implementation of `Display`.
1344 /// use serde::{Serialize, Serializer};
1346 /// impl Serialize for DateTime {
1347 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1365 /// Serialize a string produced by an implementation of `Display`.
1379 /// use serde::{Serialize, Serializer};
1381 /// impl Serialize for DateTime {
1382 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1395 /// Determine whether `Serialize` implementations should serialize in
1419 /// use serde::{Serialize, Serializer};
1421 /// impl Serialize for Timestamp {
1422 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1427 /// // Serialize to a human-readable string "2015-05-15T17:01:00Z".
1428 /// self.to_string().serialize(serializer)
1430 /// // Serialize to a compact binary representation.
1431 /// self.seconds_since_epoch().serialize(serializer)
1472 /// use serde::ser::{Serialize, SerializeSeq, Serializer};
1474 /// impl<T> Serialize for Vec<T>
1476 /// T: Serialize,
1478 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1504 /// Serialize a sequence element.
1507 T: ?Sized + Serialize; in serialize_element() argument
1518 /// use serde::ser::{Serialize, SerializeTuple, Serializer};
1521 /// # trait Serialize {}
1522 /// impl<A, B, C> Serialize for (A, B, C)
1528 /// # impl<A, B, C> Serialize for Tuple3<A, B, C>
1530 /// A: Serialize,
1531 /// B: Serialize,
1532 /// C: Serialize,
1534 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1566 /// use serde::ser::{Serialize, SerializeTuple, Serializer};
1569 /// # trait Serialize {}
1570 /// impl<T> Serialize for [T; 16]
1574 /// # impl<T> Serialize for Array<T>
1576 /// T: Serialize,
1578 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1604 /// Serialize a tuple element.
1607 T: ?Sized + Serialize; in serialize_element() argument
1618 /// use serde::ser::{Serialize, SerializeTupleStruct, Serializer};
1622 /// impl Serialize for Rgb {
1623 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1649 /// Serialize a tuple struct field.
1652 T: ?Sized + Serialize; in serialize_field() argument
1663 /// use serde::ser::{Serialize, SerializeTupleVariant, Serializer};
1670 /// impl Serialize for E {
1671 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1707 /// Serialize a tuple variant field.
1710 T: ?Sized + Serialize; in serialize_field() argument
1740 /// use serde::ser::{Serialize, SerializeMap, Serializer};
1742 /// impl<K, V> Serialize for HashMap<K, V>
1744 /// K: Serialize,
1745 /// V: Serialize,
1747 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1773 /// Serialize a map key.
1775 /// If possible, `Serialize` implementations are encouraged to use
1781 T: ?Sized + Serialize; in serialize_key() argument
1783 /// Serialize a map value.
1791 T: ?Sized + Serialize; in serialize_value() argument
1793 /// Serialize a map entry consisting of a key and a value.
1795 /// Some [`Serialize`] types are not able to hold a key and value in memory
1799 /// where key and value are both available. [`Serialize`] implementations
1807 /// [`Serialize`]: crate::Serialize
1812 K: ?Sized + Serialize, in serialize_entry() argument
1813 V: ?Sized + Serialize, in serialize_entry() argument
1828 /// use serde::ser::{Serialize, SerializeStruct, Serializer};
1836 /// impl Serialize for Rgb {
1837 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1863 /// Serialize a struct field.
1866 T: ?Sized + Serialize; in serialize_field() argument
1886 /// use serde::ser::{Serialize, SerializeStructVariant, Serializer};
1892 /// impl Serialize for E {
1893 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1927 /// Serialize a struct variant field.
1930 T: ?Sized + Serialize; in serialize_field() argument