Lines Matching full:serializer
4 //! [`Serializer`].
8 //! - **A type that implements `Serializer` is a data format** that can
30 //! # The Serializer trait
32 //! [`Serializer`] implementations are provided by third-party crates, for
101 //! [`Serializer`]: crate::Serializer
133 /// errors belonging to the `Serializer` against which they are
161 /// use serde::ser::{self, Serialize, Serializer};
164 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
166 /// S: Serializer,
169 /// Some(s) => serializer.serialize_str(s),
226 /// Serialize this value into the given Serde serializer.
232 /// use serde::ser::{Serialize, SerializeStruct, Serializer};
242 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
244 /// S: Serializer,
246 /// let mut s = serializer.serialize_struct("Person", 3)?;
256 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> in serialize()
258 S: Serializer; in serialize() argument
267 /// of 29 possible types. Each method of the `Serializer` trait corresponds to
271 /// invoking exactly one of the `Serializer` methods.
326 /// JSON or Postcard. This is not a requirement of the `Serializer` trait, and
328 /// is the `serde_json::value::Serializer` (distinct from the main `serde_json`
329 /// serializer) that produces a `serde_json::Value` data structure in memory as
337 /// a basic JSON `Serializer`.
340 pub trait Serializer: Sized { interface
341 /// The output type produced by this `Serializer` during successful
344 /// contained within the `Serializer` instance. Serializers that build
399 /// # use serde::Serializer;
404 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
406 /// S: Serializer,
408 /// serializer.serialize_bool(*self)
421 /// # use serde::Serializer;
426 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
428 /// S: Serializer,
430 /// serializer.serialize_i8(*self)
443 /// # use serde::Serializer;
448 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
450 /// S: Serializer,
452 /// serializer.serialize_i16(*self)
465 /// # use serde::Serializer;
470 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
472 /// S: Serializer,
474 /// serializer.serialize_i32(*self)
483 /// # use serde::Serializer;
488 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
490 /// S: Serializer,
492 /// serializer.serialize_i64(*self)
501 /// # use serde::Serializer;
506 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
508 /// S: Serializer,
510 /// serializer.serialize_i128(*self)
528 /// # use serde::Serializer;
533 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
535 /// S: Serializer,
537 /// serializer.serialize_u8(*self)
550 /// # use serde::Serializer;
555 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
557 /// S: Serializer,
559 /// serializer.serialize_u16(*self)
572 /// # use serde::Serializer;
577 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
579 /// S: Serializer,
581 /// serializer.serialize_u32(*self)
590 /// # use serde::Serializer;
595 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
597 /// S: Serializer,
599 /// serializer.serialize_u64(*self)
608 /// # use serde::Serializer;
613 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
615 /// S: Serializer,
617 /// serializer.serialize_u128(*self)
635 /// # use serde::Serializer;
640 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
642 /// S: Serializer,
644 /// serializer.serialize_f32(*self)
653 /// # use serde::Serializer;
658 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
660 /// S: Serializer,
662 /// serializer.serialize_f64(*self)
674 /// # use serde::Serializer;
679 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
681 /// S: Serializer,
683 /// serializer.serialize_char(*self)
692 /// # use serde::Serializer;
697 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
699 /// S: Serializer,
701 /// serializer.serialize_str(self)
716 /// # use serde::ser::{Serializer, SerializeSeq};
721 /// # impl Serializer for MySerializer {
745 /// # use serde::{Serialize, Serializer};
758 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
760 /// S: Serializer,
763 /// Some(ref value) => serializer.serialize_some(value),
764 /// None => serializer.serialize_none(),
778 /// # use serde::{Serialize, Serializer};
791 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
793 /// S: Serializer,
796 /// Some(ref value) => serializer.serialize_some(value),
797 /// None => serializer.serialize_none(),
813 /// # use serde::Serializer;
818 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
820 /// S: Serializer,
822 /// serializer.serialize_unit()
833 /// use serde::{Serialize, Serializer};
838 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
840 /// S: Serializer,
842 /// serializer.serialize_unit_struct("Nothing")
855 /// use serde::{Serialize, Serializer};
863 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
865 /// S: Serializer,
868 /// E::A => serializer.serialize_unit_variant("E", 0, "A"),
869 /// E::B => serializer.serialize_unit_variant("E", 1, "B"),
888 /// use serde::{Serialize, Serializer};
893 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
895 /// S: Serializer,
897 /// serializer.serialize_newtype_struct("Millimeters", &self.0)
916 /// use serde::{Serialize, Serializer};
924 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
926 /// S: Serializer,
929 /// E::M(ref s) => serializer.serialize_newtype_variant("E", 0, "M", s),
930 /// E::N(n) => serializer.serialize_newtype_variant("E", 1, "N", &n),
973 /// use serde::ser::{Serialize, SerializeSeq, Serializer};
979 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
981 /// S: Serializer,
983 /// let mut seq = serializer.serialize_seq(Some(self.len()))?;
999 /// use serde::ser::{Serialize, SerializeTuple, Serializer};
1015 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1017 /// S: Serializer,
1019 /// let mut tup = serializer.serialize_tuple(3)?;
1029 /// use serde::ser::{Serialize, SerializeTuple, Serializer};
1035 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1037 /// S: Serializer,
1039 /// let mut seq = serializer.serialize_tuple(VRAM_SIZE)?;
1057 /// use serde::ser::{Serialize, SerializeTupleStruct, Serializer};
1062 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1064 /// S: Serializer,
1066 /// let mut ts = serializer.serialize_tuple_struct("Rgb", 3)?;
1089 /// use serde::ser::{Serialize, SerializeTupleVariant, Serializer};
1097 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1099 /// S: Serializer,
1103 /// let mut tv = serializer.serialize_tuple_variant("E", 0, "T", 2)?;
1109 /// let mut tv = serializer.serialize_tuple_variant("E", 1, "U", 3)?;
1154 /// use serde::ser::{Serialize, SerializeMap, Serializer};
1161 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1163 /// S: Serializer,
1165 /// let mut map = serializer.serialize_map(Some(self.len()))?;
1184 /// use serde::ser::{Serialize, SerializeStruct, Serializer};
1193 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1195 /// S: Serializer,
1197 /// let mut rgb = serializer.serialize_struct("Rgb", 3)?;
1222 /// use serde::ser::{Serialize, SerializeStructVariant, Serializer};
1229 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1231 /// S: Serializer,
1239 /// let mut sv = serializer.serialize_struct_variant("E", 0, "S", 3)?;
1264 /// use serde::{Serialize, Serializer};
1271 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1273 /// S: Serializer,
1275 /// serializer.collect_seq(self.data.iter().map(|x| x + 1))
1287 let mut serializer = tri!(self.serialize_seq(iterator_len_hint(&iter))); in collect_seq() localVariable
1288 tri!(iter.try_for_each(|item| serializer.serialize_element(&item))); in collect_seq()
1289 serializer.end() in collect_seq()
1299 /// use serde::{Serialize, Serializer};
1308 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1310 /// S: Serializer,
1312 /// serializer.collect_map(self.keys.iter().map(|k| (k, ())))
1325 let mut serializer = tri!(self.serialize_map(iterator_len_hint(&iter))); in collect_map() localVariable
1326 tri!(iter.try_for_each(|(key, value)| serializer.serialize_entry(&key, &value))); in collect_map()
1327 serializer.end() in collect_map()
1344 /// use serde::{Serialize, Serializer};
1347 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1349 /// S: Serializer,
1351 /// serializer.collect_str(&format_args!("{:?}{:?}", self.naive_local(), self.offset()))
1379 /// use serde::{Serialize, Serializer};
1382 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1384 /// S: Serializer,
1386 /// serializer.collect_str(&format_args!("{:?}{:?}", self.naive_local(), self.offset()))
1419 /// use serde::{Serialize, Serializer};
1422 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1424 /// S: Serializer,
1426 /// if serializer.is_human_readable() {
1428 /// self.to_string().serialize(serializer)
1431 /// self.seconds_since_epoch().serialize(serializer)
1449 /// Returned from `Serializer::serialize_seq`.
1472 /// use serde::ser::{Serialize, SerializeSeq, Serializer};
1478 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1480 /// S: Serializer,
1482 /// let mut seq = serializer.serialize_seq(Some(self.len()))?;
1498 /// Must match the `Ok` type of our `Serializer`.
1501 /// Must match the `Error` type of our `Serializer`.
1513 /// Returned from `Serializer::serialize_tuple`.
1518 /// use serde::ser::{Serialize, SerializeTuple, Serializer};
1534 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1536 /// S: Serializer,
1538 /// let mut tup = serializer.serialize_tuple(3)?;
1566 /// use serde::ser::{Serialize, SerializeTuple, Serializer};
1578 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1580 /// S: Serializer,
1582 /// let mut seq = serializer.serialize_tuple(16)?;
1598 /// Must match the `Ok` type of our `Serializer`.
1601 /// Must match the `Error` type of our `Serializer`.
1613 /// Returned from `Serializer::serialize_tuple_struct`.
1618 /// use serde::ser::{Serialize, SerializeTupleStruct, Serializer};
1623 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1625 /// S: Serializer,
1627 /// let mut ts = serializer.serialize_tuple_struct("Rgb", 3)?;
1643 /// Must match the `Ok` type of our `Serializer`.
1646 /// Must match the `Error` type of our `Serializer`.
1658 /// Returned from `Serializer::serialize_tuple_variant`.
1663 /// use serde::ser::{Serialize, SerializeTupleVariant, Serializer};
1671 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1673 /// S: Serializer,
1677 /// let mut tv = serializer.serialize_tuple_variant("E", 0, "T", 2)?;
1683 /// let mut tv = serializer.serialize_tuple_variant("E", 1, "U", 3)?;
1701 /// Must match the `Ok` type of our `Serializer`.
1704 /// Must match the `Error` type of our `Serializer`.
1716 /// Returned from `Serializer::serialize_map`.
1740 /// use serde::ser::{Serialize, SerializeMap, Serializer};
1747 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1749 /// S: Serializer,
1751 /// let mut map = serializer.serialize_map(Some(self.len()))?;
1767 /// Must match the `Ok` type of our `Serializer`.
1770 /// Must match the `Error` type of our `Serializer`.
1823 /// Returned from `Serializer::serialize_struct`.
1828 /// use serde::ser::{Serialize, SerializeStruct, Serializer};
1837 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1839 /// S: Serializer,
1841 /// let mut rgb = serializer.serialize_struct("Rgb", 3)?;
1857 /// Must match the `Ok` type of our `Serializer`.
1860 /// Must match the `Error` type of our `Serializer`.
1881 /// Returned from `Serializer::serialize_struct_variant`.
1886 /// use serde::ser::{Serialize, SerializeStructVariant, Serializer};
1893 /// fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1895 /// S: Serializer,
1903 /// let mut sv = serializer.serialize_struct_variant("E", 0, "S", 3)?;
1921 /// Must match the `Ok` type of our `Serializer`.
1924 /// Must match the `Error` type of our `Serializer`.