1#![allow(unknown_lints)]
2use serde::{
3 de::{DeserializeSeed, Deserializer, Error, SeqAccess, Visitor},
4 ser::{Serialize, SerializeTupleStruct, Serializer},
5};
6use static_assertions::assert_impl_all;
7use std::fmt::{Display, Write};
8
9use crate::{
10 signature_parser::SignatureParser, value::SignatureSeed, value_display_fmt, DynamicDeserialize,
11 DynamicType, OwnedValue, Signature, Value,
12};
13
14/// Use this to efficiently build a [`Structure`].
15///
16/// [`Structure`]: struct.Structure.html
17#[derive(Debug, Default, PartialEq)]
18pub struct StructureBuilder<'a>(Vec<Value<'a>>);
19
20assert_impl_all!(StructureBuilder<'_>: Send, Sync, Unpin);
21
22impl<'a> StructureBuilder<'a> {
23 /// Create a new `StructureBuilder`.
24 ///
25 /// Same as `StructureBuilder::default()`.
26 pub fn new() -> Self {
27 Self::default()
28 }
29
30 /// Append `field` to `self`.
31 ///
32 /// This method returns `Self` so that you can use the builder pattern to create a complex
33 /// structure.
34 #[must_use]
35 pub fn add_field<T>(self, field: T) -> Self
36 where
37 T: DynamicType + Into<Value<'a>>,
38 {
39 self.append_field(Value::new(field))
40 }
41
42 /// Append `field` to `self`.
43 ///
44 /// Identical to `add_field`, except the field must be in the form of a `Value`.
45 #[must_use]
46 pub fn append_field<'e: 'a>(mut self, field: Value<'e>) -> Self {
47 self.0.push(field);
48
49 self
50 }
51
52 /// Append `field` to `self`.
53 ///
54 /// Identical to `add_field`, except it makes changes in-place.
55 pub fn push_field<T>(&mut self, field: T)
56 where
57 T: DynamicType + Into<Value<'a>>,
58 {
59 self.push_value(Value::new(field))
60 }
61
62 /// Append `field` to `self`.
63 ///
64 /// Identical to `append_field`, except it makes changes in-place.
65 pub fn push_value<'e: 'a>(&mut self, field: Value<'e>) {
66 self.0.push(field)
67 }
68
69 /// Build the `Structure`.
70 ///
71 /// [`Structure`]: struct.Structure.html
72 pub fn build(self) -> Structure<'a> {
73 let signature = create_signature_from_fields(&self.0);
74
75 Structure {
76 fields: self.0,
77 signature,
78 }
79 }
80
81 /// Same as `build` except Signature is provided.
82 pub(crate) fn build_with_signature<'s: 'a>(self, signature: Signature<'s>) -> Structure<'a> {
83 Structure {
84 fields: self.0,
85 signature,
86 }
87 }
88}
89
90/// Use this to deserialize a [`Structure`].
91///
92/// [`Structure`]: struct.Structure.html
93#[derive(Debug, Clone, PartialEq, Eq)]
94pub struct StructureSeed<'a>(Signature<'a>);
95
96assert_impl_all!(StructureSeed<'_>: Send, Sync, Unpin);
97
98impl<'a> StructureSeed<'a> {
99 /// Create a new `StructureSeed`
100 ///
101 /// The given signature must be a valid structure signature.
102 #[must_use]
103 pub fn new_unchecked(signature: Signature<'a>) -> Self {
104 StructureSeed(signature)
105 }
106}
107
108impl<'a> TryFrom<Signature<'a>> for StructureSeed<'a> {
109 type Error = zvariant::Error;
110
111 fn try_from(signature: Signature<'a>) -> Result<Self, zvariant::Error> {
112 if signature.starts_with(zvariant::STRUCT_SIG_START_CHAR) {
113 Ok(StructureSeed(signature))
114 } else {
115 Err(zvariant::Error::IncorrectType)
116 }
117 }
118}
119
120impl<'de> DeserializeSeed<'de> for StructureSeed<'de> {
121 type Value = Structure<'de>;
122 fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
123 where
124 D: Deserializer<'de>,
125 {
126 deserializer.deserialize_seq(visitor:StructureVisitor { signature: self.0 })
127 }
128}
129
130#[derive(Debug, Clone, PartialEq, Eq)]
131struct StructureVisitor<'a> {
132 signature: Signature<'a>,
133}
134
135impl<'de> Visitor<'de> for StructureVisitor<'de> {
136 type Value = Structure<'de>;
137
138 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
139 formatter.write_str(data:"a Structure value")
140 }
141
142 fn visit_seq<V>(self, visitor: V) -> Result<Structure<'de>, V::Error>
143 where
144 V: SeqAccess<'de>,
145 {
146 SignatureSeed {
147 signature: self.signature,
148 }
149 .visit_struct(visitor)
150 }
151}
152
153/// A helper type to wrap structs in [`Value`].
154///
155/// API is provided to convert from, and to tuples.
156///
157/// [`Value`]: enum.Value.html
158#[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
159pub struct Structure<'a> {
160 fields: Vec<Value<'a>>,
161 signature: Signature<'a>,
162}
163
164assert_impl_all!(Structure<'_>: Send, Sync, Unpin);
165
166impl<'a> Structure<'a> {
167 /// Get a reference to all the fields of `self`.
168 pub fn fields(&self) -> &[Value<'a>] {
169 &self.fields
170 }
171
172 /// Converts `self` to a `Vec` containing all its fields.
173 pub fn into_fields(self) -> Vec<Value<'a>> {
174 self.fields
175 }
176
177 /// Get the signature of this `Structure`.
178 ///
179 /// NB: This method potentially allocates and copies. Use [`full_signature`] if you'd like to
180 /// avoid that.
181 ///
182 /// [`full_signature`]: #method.full_signature
183 pub fn signature(&self) -> Signature<'static> {
184 self.signature.to_owned()
185 }
186
187 /// Get the signature of this `Structure`.
188 pub fn full_signature(&self) -> &Signature<'_> {
189 &self.signature
190 }
191
192 pub(crate) fn try_to_owned(&self) -> crate::Result<Structure<'static>> {
193 Ok(Structure {
194 fields: self
195 .fields
196 .iter()
197 .map(|v| v.try_to_owned().map(Into::into))
198 .collect::<crate::Result<_>>()?,
199 signature: self.signature.to_owned(),
200 })
201 }
202
203 /// Attempt to clone `self`.
204 pub fn try_clone(&self) -> Result<Self, crate::Error> {
205 let fields = self
206 .fields
207 .iter()
208 .map(|v| v.try_clone())
209 .collect::<crate::Result<Vec<_>>>()?;
210
211 Ok(Self {
212 fields,
213 signature: self.signature.clone(),
214 })
215 }
216}
217
218impl Display for Structure<'_> {
219 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
220 structure_display_fmt(self, f, type_annotate:true)
221 }
222}
223
224pub(crate) fn structure_display_fmt(
225 structure: &Structure<'_>,
226 f: &mut std::fmt::Formatter<'_>,
227 type_annotate: bool,
228) -> std::fmt::Result {
229 f.write_char('(')?;
230
231 let fields: &[Value<'_>] = structure.fields();
232
233 match fields.len() {
234 0 => {}
235 1 => {
236 value_display_fmt(&fields[0], f, type_annotate)?;
237 f.write_char(',')?;
238 }
239 _ => {
240 for (i: usize, field: &Value<'_>) in fields.iter().enumerate() {
241 value_display_fmt(value:field, f, type_annotate)?;
242
243 if i + 1 < fields.len() {
244 f.write_str(data:", ")?;
245 }
246 }
247 }
248 }
249
250 f.write_char(')')
251}
252
253impl<'a> Default for Structure<'a> {
254 fn default() -> Self {
255 let signature: Signature<'_> = Signature::from_static_str_unchecked(signature:"()");
256
257 Self {
258 fields: vec![],
259 signature,
260 }
261 }
262}
263
264impl<'a> DynamicType for Structure<'a> {
265 fn dynamic_signature(&self) -> Signature<'_> {
266 self.signature.as_ref()
267 }
268}
269
270impl<'a> DynamicType for StructureSeed<'a> {
271 fn dynamic_signature(&self) -> Signature<'_> {
272 self.0.as_ref()
273 }
274}
275
276impl<'a> DynamicDeserialize<'a> for Structure<'a> {
277 type Deserializer = StructureSeed<'a>;
278
279 fn deserializer_for_signature<S>(signature: S) -> zvariant::Result<Self::Deserializer>
280 where
281 S: TryInto<Signature<'a>>,
282 S::Error: Into<zvariant::Error>,
283 {
284 let mut signature = signature.try_into().map_err(Into::into)?;
285 if !signature.starts_with(zvariant::STRUCT_SIG_START_CHAR) {
286 // This is certainly not a valid struct signature
287 signature = format!("({signature})").try_into()?;
288 return signature.try_into();
289 }
290
291 // The signature might be something like "(i)u(i)" - we need to parse it to check.
292 let mut parser = SignatureParser::new(signature.as_ref());
293 parser.parse_next_signature()?;
294 if !parser.done() {
295 // more than one element - we must wrap it
296 signature = format!("({signature})").try_into()?;
297 }
298 signature.try_into()
299 }
300}
301
302impl<'a> Serialize for Structure<'a> {
303 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
304 where
305 S: Serializer,
306 {
307 let mut structure: ::SerializeTupleStruct =
308 serializer.serialize_tuple_struct(name:"zvariant::Structure", self.fields.len())?;
309 for field: &Value<'a> in &self.fields {
310 field.serialize_value_as_tuple_struct_field(&mut structure)?;
311 }
312 structure.end()
313 }
314}
315
316macro_rules! tuple_impls {
317 ($($len:expr => ($($n:tt $name:ident)+))+) => {
318 $(
319 impl<'a, $($name),+> From<($($name),+,)> for Structure<'a>
320 where
321 $($name: DynamicType + Into<Value<'a>>,)+
322 {
323 #[inline]
324 fn from(value: ($($name),+,)) -> Self {
325 StructureBuilder::new()
326 $(
327 .add_field(value. $n)
328 )+
329 .build()
330 }
331 }
332
333 impl<'a, E, $($name),+> TryFrom<Structure<'a>> for ($($name),+,)
334 where
335 $($name: TryFrom<Value<'a>, Error = E>,)+
336 crate::Error: From<E>,
337
338 {
339 type Error = crate::Error;
340
341 fn try_from(mut s: Structure<'a>) -> core::result::Result<Self, Self::Error> {
342 Ok((
343 $(
344 $name::try_from(s.fields.remove(0))?,
345 )+
346 ))
347 }
348 }
349
350 impl<'a, E, $($name),+> TryFrom<Value<'a>> for ($($name),+,)
351 where
352 $($name: TryFrom<Value<'a>, Error = E>,)+
353 crate::Error: From<E>,
354
355 {
356 type Error = crate::Error;
357
358 fn try_from(v: Value<'a>) -> core::result::Result<Self, Self::Error> {
359 Self::try_from(Structure::try_from(v)?)
360 }
361 }
362
363 impl<E, $($name),+> TryFrom<OwnedValue> for ($($name),+,)
364 where
365 $($name: TryFrom<Value<'static>, Error = E>,)+
366 crate::Error: From<E>,
367
368 {
369 type Error = crate::Error;
370
371 fn try_from(v: OwnedValue) -> core::result::Result<Self, Self::Error> {
372 Self::try_from(Value::from(v))
373 }
374 }
375 )+
376 }
377}
378
379tuple_impls! {
380 1 => (0 T0)
381 2 => (0 T0 1 T1)
382 3 => (0 T0 1 T1 2 T2)
383 4 => (0 T0 1 T1 2 T2 3 T3)
384 5 => (0 T0 1 T1 2 T2 3 T3 4 T4)
385 6 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5)
386 7 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6)
387 8 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7)
388 9 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8)
389 10 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9)
390 11 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10)
391 12 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11)
392 13 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12)
393 14 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13)
394 15 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13 14 T14)
395 16 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13 14 T14 15 T15)
396}
397
398fn create_signature_from_fields(fields: &[Value<'_>]) -> Signature<'static> {
399 let mut signature: String = String::with_capacity(255);
400 signature.push(ch:'(');
401 for field: &Value<'_> in fields {
402 signature.push_str(&field.value_signature());
403 }
404 signature.push(ch:')');
405
406 Signature::from_string_unchecked(signature)
407}
408
409/// Owned [`Structure`]
410#[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
411pub struct OwnedStructure(pub Structure<'static>);
412
413/// Use this to deserialize an [`OwnedStructure`].
414#[derive(Debug, Clone, PartialEq, Eq)]
415pub struct OwnedStructureSeed(Signature<'static>);
416
417impl DynamicType for OwnedStructure {
418 fn dynamic_signature(&self) -> Signature<'_> {
419 self.0.dynamic_signature()
420 }
421}
422
423impl DynamicType for OwnedStructureSeed {
424 fn dynamic_signature(&self) -> Signature<'_> {
425 self.0.clone()
426 }
427}
428
429impl<'de> DynamicDeserialize<'de> for OwnedStructure {
430 type Deserializer = OwnedStructureSeed;
431
432 fn deserializer_for_signature<S>(signature: S) -> zvariant::Result<Self::Deserializer>
433 where
434 S: TryInto<Signature<'de>>,
435 S::Error: Into<zvariant::Error>,
436 {
437 Structure::deserializer_for_signature(signature)
438 .map(|StructureSeed(s: Signature<'_>)| OwnedStructureSeed(s.to_owned()))
439 }
440}
441
442impl<'de> DeserializeSeed<'de> for OwnedStructureSeed {
443 type Value = OwnedStructure;
444 fn deserialize<D: Deserializer<'de>>(self, deserializer: D) -> Result<Self::Value, D::Error> {
445 deserializer
446 .deserialize_seq(StructureVisitor { signature: self.0 })
447 .and_then(|s: Structure<'_>| match s.try_to_owned() {
448 Ok(s: Structure<'static>) => Ok(OwnedStructure(s)),
449 Err(e: Error) => Err(D::Error::custom(msg:e)),
450 })
451 }
452}
453
454impl Serialize for OwnedStructure {
455 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
456 where
457 S: Serializer,
458 {
459 self.0.serialize(serializer)
460 }
461}
462