postbag/ser/
mod.rs

1use serde::Serialize;
2
3use crate::{cfg::Cfg, error::Result, ser::serializer::Serializer};
4
5pub(crate) mod serializer;
6pub(crate) mod skippable;
7
8/// Serialize a value of type `T` to a [`std::io::Write`].
9///
10/// The `CFG` parameter controls the serialization format and can be either:
11/// - [`Full`](crate::cfg::Full): Serializes struct field identifiers and enum variant identifiers as strings
12/// - [`Slim`](crate::cfg::Slim): Serializes without identifiers, using indices for enum variants
13///
14/// # Example
15///
16/// ```rust
17/// use serde::{Serialize, Deserialize};
18/// use postbag::{serialize, cfg::Full};
19///
20/// #[derive(Serialize, Deserialize, Debug, PartialEq)]
21/// struct Person {
22///     name: String,
23///     age: u32,
24/// }
25///
26/// let person = Person {
27///     name: "Alice".to_string(),
28///     age: 30,
29/// };
30///
31/// let mut buffer = Vec::new();
32/// serialize::<Full, _, _>(&mut buffer, &person).unwrap();
33/// println!("Serialized {} bytes", buffer.len());
34/// ```
35pub fn serialize<CFG, W, T>(writer: W, value: &T) -> Result<()>
36where
37    CFG: Cfg,
38    W: std::io::Write,
39    T: Serialize + ?Sized,
40{
41    let mut serializer = Serializer::<W, CFG>::new(writer);
42    value.serialize(&mut serializer)?;
43    serializer.finalize();
44    Ok(())
45}
46
47/// Serialize a value using the [`Full`](crate::cfg::Full) configuration.
48///
49/// This is a convenience function equivalent to `serialize::<Full, _, _>(writer, value)`.
50/// It serializes struct field identifiers and enum variant identifiers as strings.
51///
52/// # Example
53///
54/// ```rust
55/// use serde::{Serialize, Deserialize};
56/// use postbag::serialize_full;
57///
58/// #[derive(Serialize, Deserialize)]
59/// struct Person {
60///     name: String,
61///     age: u32,
62/// }
63///
64/// let person = Person {
65///     name: "Alice".to_string(),
66///     age: 30,
67/// };
68///
69/// let mut buffer = Vec::new();
70/// serialize_full(&mut buffer, &person).unwrap();
71/// ```
72pub fn serialize_full<W, T>(writer: W, value: &T) -> Result<()>
73where
74    W: std::io::Write,
75    T: Serialize + ?Sized,
76{
77    serialize::<crate::cfg::Full, W, T>(writer, value)
78}
79
80/// Serialize a value using the [`Slim`](crate::cfg::Slim) configuration.
81///
82/// This is a convenience function equivalent to `serialize::<Slim, _, _>(writer, value)`.
83/// It serializes without identifiers, using indices for enum variants.
84///
85/// # Example
86///
87/// ```rust
88/// use serde::{Serialize, Deserialize};
89/// use postbag::serialize_slim;
90///
91/// #[derive(Serialize, Deserialize)]
92/// struct Person {
93///     name: String,
94///     age: u32,
95/// }
96///
97/// let person = Person {
98///     name: "Alice".to_string(),
99///     age: 30,
100/// };
101///
102/// let mut buffer = Vec::new();
103/// serialize_slim(&mut buffer, &person).unwrap();
104/// ```
105pub fn serialize_slim<W, T>(writer: W, value: &T) -> Result<()>
106where
107    W: std::io::Write,
108    T: Serialize + ?Sized,
109{
110    serialize::<crate::cfg::Slim, W, T>(writer, value)
111}
112
113/// Serialize a value using the [`Full`](crate::cfg::Full) configuration and return a `Vec<u8>`.
114///
115/// This is a convenience function that creates a new `Vec<u8>` and calls `serialize_full` on it.
116/// It serializes struct field identifiers and enum variant identifiers as strings.
117///
118/// # Example
119///
120/// ```rust
121/// use serde::{Serialize, Deserialize};
122/// use postbag::to_full_vec;
123///
124/// #[derive(Serialize, Deserialize)]
125/// struct Person {
126///     name: String,
127///     age: u32,
128/// }
129///
130/// let person = Person {
131///     name: "Alice".to_string(),
132///     age: 30,
133/// };
134///
135/// let bytes = to_full_vec(&person).unwrap();
136/// println!("Serialized {} bytes", bytes.len());
137/// ```
138pub fn to_full_vec<T>(value: &T) -> Result<Vec<u8>>
139where
140    T: Serialize + ?Sized,
141{
142    let mut buffer = Vec::new();
143    serialize_full(&mut buffer, value)?;
144    Ok(buffer)
145}
146
147/// Serialize a value using the [`Slim`](crate::cfg::Slim) configuration and return a `Vec<u8>`.
148///
149/// This is a convenience function that creates a new `Vec<u8>` and calls `serialize_slim` on it.
150/// It serializes without identifiers, using indices for enum variants.
151///
152/// # Example
153///
154/// ```rust
155/// use serde::{Serialize, Deserialize};
156/// use postbag::to_slim_vec;
157///
158/// #[derive(Serialize, Deserialize)]
159/// struct Person {
160///     name: String,
161///     age: u32,
162/// }
163///
164/// let person = Person {
165///     name: "Alice".to_string(),
166///     age: 30,
167/// };
168///
169/// let bytes = to_slim_vec(&person).unwrap();
170/// println!("Serialized {} bytes", bytes.len());
171/// ```
172pub fn to_slim_vec<T>(value: &T) -> Result<Vec<u8>>
173where
174    T: Serialize + ?Sized,
175{
176    let mut buffer = Vec::new();
177    serialize_slim(&mut buffer, value)?;
178    Ok(buffer)
179}
postbag/ser/mod.rs

postbag/ser/
mod.rs
