aldrin_core/serializer/
struct_.rs

1use super::Serializer;
2use crate::buf_ext::BufMutExt;
3use crate::tags::Tag;
4use crate::{AsUnknownFields, Serialize, SerializeError, UnknownFieldsRef, ValueKind};
5use bytes::BytesMut;
6
7#[derive(Debug)]
8pub struct Struct1Serializer<'a> {
9    buf: &'a mut BytesMut,
10    num_fields: u32,
11    depth: u8,
12}
13
14impl<'a> Struct1Serializer<'a> {
15    pub(super) fn new(
16        buf: &'a mut BytesMut,
17        num_fields: usize,
18        depth: u8,
19    ) -> Result<Self, SerializeError> {
20        if num_fields <= u32::MAX as usize {
21            buf.put_discriminant_u8(ValueKind::Struct1);
22            buf.put_varint_u32_le(num_fields as u32);
23
24            Ok(Self {
25                buf,
26                num_fields: num_fields as u32,
27                depth,
28            })
29        } else {
30            Err(SerializeError::Overflow)
31        }
32    }
33
34    pub(super) fn with_unknown_fields<T>(
35        buf: &'a mut BytesMut,
36        num_fields: usize,
37        unknown_fields: T,
38        depth: u8,
39    ) -> Result<Self, SerializeError>
40    where
41        T: AsUnknownFields,
42        T::FieldsIter: ExactSizeIterator,
43    {
44        let unknown_fields = unknown_fields.fields();
45        let mut this = Self::new(buf, num_fields + unknown_fields.len(), depth)?;
46        this.serialize_unknown_fields(UnknownFieldsRef(unknown_fields))?;
47        Ok(this)
48    }
49
50    pub fn remaining_fields(&self) -> usize {
51        self.num_fields as usize
52    }
53
54    pub fn requires_additional_fields(&self) -> bool {
55        self.num_fields > 0
56    }
57
58    pub fn serialize<T: Tag>(
59        &mut self,
60        id: impl Into<u32>,
61        value: impl Serialize<T>,
62    ) -> Result<&mut Self, SerializeError> {
63        if self.num_fields > 0 {
64            self.num_fields -= 1;
65
66            self.buf.put_varint_u32_le(id.into());
67
68            let serializer = Serializer::new(self.buf, self.depth)?;
69            serializer.serialize(value)?;
70
71            Ok(self)
72        } else {
73            Err(SerializeError::TooManyElements)
74        }
75    }
76
77    pub fn serialize_if_some<T: Tag>(
78        &mut self,
79        id: impl Into<u32>,
80        value: impl Serialize<T>,
81    ) -> Result<&mut Self, SerializeError> {
82        if value.serializes_as_some() {
83            self.serialize(id, value)
84        } else {
85            Ok(self)
86        }
87    }
88
89    pub fn serialize_unknown_fields(
90        &mut self,
91        unknown_fields: impl AsUnknownFields,
92    ) -> Result<&mut Self, SerializeError> {
93        for (id, value) in unknown_fields.fields() {
94            if self.num_fields == 0 {
95                return Err(SerializeError::TooManyElements);
96            }
97
98            self.num_fields -= 1;
99            self.buf.put_varint_u32_le(id);
100
101            let serializer = Serializer::new(self.buf, self.depth)?;
102            serializer.serialize(value)?;
103        }
104
105        Ok(self)
106    }
107
108    pub fn finish(self) -> Result<(), SerializeError> {
109        if self.num_fields == 0 {
110            Ok(())
111        } else {
112            Err(SerializeError::TooFewElements)
113        }
114    }
115}
116
117#[derive(Debug)]
118pub struct Struct2Serializer<'a> {
119    buf: &'a mut BytesMut,
120    depth: u8,
121}
122
123impl<'a> Struct2Serializer<'a> {
124    pub(super) fn new(buf: &'a mut BytesMut, depth: u8) -> Result<Self, SerializeError> {
125        buf.put_discriminant_u8(ValueKind::Struct2);
126        Ok(Self { buf, depth })
127    }
128
129    pub(super) fn with_unknown_fields(
130        buf: &'a mut BytesMut,
131        unknown_fields: impl AsUnknownFields,
132        depth: u8,
133    ) -> Result<Self, SerializeError> {
134        let mut this = Self::new(buf, depth)?;
135        this.serialize_unknown_fields(unknown_fields)?;
136        Ok(this)
137    }
138
139    pub fn serialize<T: Tag>(
140        &mut self,
141        id: impl Into<u32>,
142        value: impl Serialize<T>,
143    ) -> Result<&mut Self, SerializeError> {
144        self.buf.put_discriminant_u8(ValueKind::Some);
145        self.buf.put_varint_u32_le(id.into());
146
147        let serializer = Serializer::new(self.buf, self.depth)?;
148        serializer.serialize(value)?;
149
150        Ok(self)
151    }
152
153    pub fn serialize_if_some<T: Tag>(
154        &mut self,
155        id: impl Into<u32>,
156        value: impl Serialize<T>,
157    ) -> Result<&mut Self, SerializeError> {
158        if value.serializes_as_some() {
159            self.serialize(id, value)
160        } else {
161            Ok(self)
162        }
163    }
164
165    pub fn serialize_unknown_fields(
166        &mut self,
167        unknown_fields: impl AsUnknownFields,
168    ) -> Result<&mut Self, SerializeError> {
169        for (id, value) in unknown_fields.fields() {
170            self.serialize(id, value)?;
171        }
172
173        Ok(self)
174    }
175
176    pub fn finish(self) -> Result<(), SerializeError> {
177        self.buf.put_discriminant_u8(ValueKind::None);
178        Ok(())
179    }
180}
aldrin_core/serializer/struct_.rs

aldrin_core/serializer/
struct_.rs
