1 use core::str; 2 use std::{convert::TryFrom, marker::PhantomData}; 3 4 use serde::{ 5 de::{ 6 Deserialize, DeserializeSeed, Deserializer, Error, MapAccess, SeqAccess, Unexpected, 7 Visitor, 8 }, 9 ser::{Serialize, SerializeSeq, SerializeStruct, SerializeTupleStruct, Serializer}, 10 }; 11 use static_assertions::assert_impl_all; 12 13 #[cfg(feature = "gvariant")] 14 use crate::Maybe; 15 use crate::{ 16 signature_parser::SignatureParser, utils::*, Array, Basic, Dict, DynamicType, Fd, ObjectPath, 17 OwnedValue, Signature, Str, Structure, StructureBuilder, Type, 18 }; 19 20 /// A generic container, in the form of an enum that holds exactly one value of any of the other 21 /// types. 22 /// 23 /// Note that this type corresponds to the `VARIANT` data type defined by the [D-Bus specification] 24 /// and as such, its encoding is not the same as that of the enclosed value. 25 /// 26 /// # Examples 27 /// 28 /// ``` 29 /// use std::convert::TryFrom; 30 /// use zvariant::{from_slice, to_bytes, EncodingContext, Value}; 31 /// 32 /// // Create a Value from an i16 33 /// let v = Value::new(i16::max_value()); 34 /// 35 /// // Encode it 36 /// let ctxt = EncodingContext::<byteorder::LE>::new_dbus(0); 37 /// let encoding = to_bytes(ctxt, &v).unwrap(); 38 /// 39 /// // Decode it back 40 /// let v: Value = from_slice(&encoding, ctxt).unwrap(); 41 /// 42 /// // Check everything is as expected 43 /// assert_eq!(i16::try_from(&v).unwrap(), i16::max_value()); 44 /// ``` 45 /// 46 /// Now let's try a more complicated example: 47 /// 48 /// ``` 49 /// use std::convert::TryFrom; 50 /// use zvariant::{from_slice, to_bytes, EncodingContext}; 51 /// use zvariant::{Structure, Value, Str}; 52 /// 53 /// // Create a Value from a tuple this time 54 /// let v = Value::new((i16::max_value(), "hello", true)); 55 /// 56 /// // Same drill as previous example 57 /// let ctxt = EncodingContext::<byteorder::LE>::new_dbus(0); 58 /// let encoding = to_bytes(ctxt, &v).unwrap(); 59 /// let v: Value = from_slice(&encoding, ctxt).unwrap(); 60 /// 61 /// // Check everything is as expected 62 /// let s = Structure::try_from(v).unwrap(); 63 /// assert_eq!( 64 /// <(i16, Str, bool)>::try_from(s).unwrap(), 65 /// (i16::max_value(), Str::from("hello"), true), 66 /// ); 67 /// ``` 68 /// 69 /// [D-Bus specification]: https://dbus.freedesktop.org/doc/dbus-specification.html#container-types 70 #[derive(Debug, Clone, PartialEq)] 71 pub enum Value<'a> { 72 // Simple types 73 U8(u8), 74 Bool(bool), 75 I16(i16), 76 U16(u16), 77 I32(i32), 78 U32(u32), 79 I64(i64), 80 U64(u64), 81 F64(f64), 82 Str(Str<'a>), 83 Signature(Signature<'a>), 84 ObjectPath(ObjectPath<'a>), 85 Value(Box<Value<'a>>), 86 87 // Container types 88 Array(Array<'a>), 89 Dict(Dict<'a, 'a>), 90 Structure(Structure<'a>), 91 #[cfg(feature = "gvariant")] 92 Maybe(Maybe<'a>), 93 94 Fd(Fd), 95 } 96 97 assert_impl_all!(Value<'_>: Send, Sync, Unpin); 98 99 macro_rules! serialize_value { 100 ($self:ident $serializer:ident.$method:ident $($first_arg:expr)*) => { 101 match $self { 102 Value::U8(value) => $serializer.$method($($first_arg,)* value), 103 Value::Bool(value) => $serializer.$method($($first_arg,)* value), 104 Value::I16(value) => $serializer.$method($($first_arg,)* value), 105 Value::U16(value) => $serializer.$method($($first_arg,)* value), 106 Value::I32(value) => $serializer.$method($($first_arg,)* value), 107 Value::U32(value) => $serializer.$method($($first_arg,)* value), 108 Value::I64(value) => $serializer.$method($($first_arg,)* value), 109 Value::U64(value) => $serializer.$method($($first_arg,)* value), 110 Value::F64(value) => $serializer.$method($($first_arg,)* value), 111 Value::Str(value) => $serializer.$method($($first_arg,)* value), 112 Value::Signature(value) => $serializer.$method($($first_arg,)* value), 113 Value::ObjectPath(value) => $serializer.$method($($first_arg,)* value), 114 Value::Value(value) => $serializer.$method($($first_arg,)* value), 115 116 // Container types 117 Value::Array(value) => $serializer.$method($($first_arg,)* value), 118 Value::Dict(value) => $serializer.$method($($first_arg,)* value), 119 Value::Structure(value) => $serializer.$method($($first_arg,)* value), 120 #[cfg(feature = "gvariant")] 121 Value::Maybe(value) => $serializer.$method($($first_arg,)* value), 122 123 Value::Fd(value) => $serializer.$method($($first_arg,)* value), 124 } 125 } 126 } 127 128 impl<'a> Value<'a> { 129 /// Make a [`Value`] for a given value. 130 /// 131 /// In general, you can use [`Into`] trait on basic types, except 132 /// when you explicitly need to wrap [`Value`] itself, in which 133 /// case this constructor comes handy. 134 /// 135 /// # Examples 136 /// 137 /// ``` 138 /// use zvariant::Value; 139 /// 140 /// let s = Value::new("hello"); 141 /// let u: Value = 51.into(); 142 /// assert_ne!(s, u); 143 /// ``` 144 /// 145 /// [`Value`]: enum.Value.html 146 /// [`Into`]: https://doc.rust-lang.org/std/convert/trait.Into.html new<T>(value: T) -> Self where T: Into<Self> + DynamicType,147 pub fn new<T>(value: T) -> Self 148 where 149 T: Into<Self> + DynamicType, 150 { 151 // With specialization, we wouldn't have this 152 if value.dynamic_signature() == VARIANT_SIGNATURE_STR { 153 Self::Value(Box::new(value.into())) 154 } else { 155 value.into() 156 } 157 } 158 to_owned(&self) -> Value<'static>159 pub(crate) fn to_owned(&self) -> Value<'static> { 160 match self { 161 Value::U8(v) => Value::U8(*v), 162 Value::Bool(v) => Value::Bool(*v), 163 Value::I16(v) => Value::I16(*v), 164 Value::U16(v) => Value::U16(*v), 165 Value::I32(v) => Value::I32(*v), 166 Value::U32(v) => Value::U32(*v), 167 Value::I64(v) => Value::I64(*v), 168 Value::U64(v) => Value::U64(*v), 169 Value::F64(v) => Value::F64(*v), 170 Value::Str(v) => Value::Str(v.to_owned()), 171 Value::Signature(v) => Value::Signature(v.to_owned()), 172 Value::ObjectPath(v) => Value::ObjectPath(v.to_owned()), 173 Value::Value(v) => { 174 let o = OwnedValue::from(&**v); 175 Value::Value(Box::new(o.into_inner())) 176 } 177 178 Value::Array(v) => Value::Array(v.to_owned()), 179 Value::Dict(v) => Value::Dict(v.to_owned()), 180 Value::Structure(v) => Value::Structure(v.to_owned()), 181 #[cfg(feature = "gvariant")] 182 Value::Maybe(v) => Value::Maybe(v.to_owned()), 183 Value::Fd(v) => Value::Fd(*v), 184 } 185 } 186 187 /// Get the signature of the enclosed value. value_signature(&self) -> Signature<'_>188 pub fn value_signature(&self) -> Signature<'_> { 189 match self { 190 Value::U8(_) => u8::signature(), 191 Value::Bool(_) => bool::signature(), 192 Value::I16(_) => i16::signature(), 193 Value::U16(_) => u16::signature(), 194 Value::I32(_) => i32::signature(), 195 Value::U32(_) => u32::signature(), 196 Value::I64(_) => i64::signature(), 197 Value::U64(_) => u64::signature(), 198 Value::F64(_) => f64::signature(), 199 Value::Str(_) => <&str>::signature(), 200 Value::Signature(_) => Signature::signature(), 201 Value::ObjectPath(_) => ObjectPath::signature(), 202 Value::Value(_) => Signature::from_static_str_unchecked("v"), 203 204 // Container types 205 Value::Array(value) => value.full_signature().clone(), 206 Value::Dict(value) => value.full_signature().clone(), 207 Value::Structure(value) => value.full_signature().clone(), 208 #[cfg(feature = "gvariant")] 209 Value::Maybe(value) => value.full_signature().clone(), 210 211 Value::Fd(_) => Fd::signature(), 212 } 213 } 214 serialize_value_as_struct_field<S>( &self, name: &'static str, serializer: &mut S, ) -> Result<(), S::Error> where S: SerializeStruct,215 pub(crate) fn serialize_value_as_struct_field<S>( 216 &self, 217 name: &'static str, 218 serializer: &mut S, 219 ) -> Result<(), S::Error> 220 where 221 S: SerializeStruct, 222 { 223 serialize_value!(self serializer.serialize_field name) 224 } 225 serialize_value_as_tuple_struct_field<S>( &self, serializer: &mut S, ) -> Result<(), S::Error> where S: SerializeTupleStruct,226 pub(crate) fn serialize_value_as_tuple_struct_field<S>( 227 &self, 228 serializer: &mut S, 229 ) -> Result<(), S::Error> 230 where 231 S: SerializeTupleStruct, 232 { 233 serialize_value!(self serializer.serialize_field) 234 } 235 236 // Really crappy that we need to do this separately for struct and seq cases. :( serialize_value_as_seq_element<S>( &self, serializer: &mut S, ) -> Result<(), S::Error> where S: SerializeSeq,237 pub(crate) fn serialize_value_as_seq_element<S>( 238 &self, 239 serializer: &mut S, 240 ) -> Result<(), S::Error> 241 where 242 S: SerializeSeq, 243 { 244 serialize_value!(self serializer.serialize_element) 245 } 246 247 #[cfg(feature = "gvariant")] serialize_value_as_some<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,248 pub(crate) fn serialize_value_as_some<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 249 where 250 S: Serializer, 251 { 252 serialize_value!(self serializer.serialize_some) 253 } 254 255 /// Try to get the underlying type `T`. 256 /// 257 /// Note that [`TryFrom<Value>`] is implemented for various types, and it's usually best to use 258 /// that instead. However, in generic code where you also want to unwrap [`Value::Value`], 259 /// you should use this function (because [`TryFrom<Value>`] can not be implemented for `Value` 260 /// itself as [`From<Value>`] is implicitly implemented for `Value`). 261 /// 262 /// # Examples 263 /// 264 /// ``` 265 /// use std::convert::TryFrom; 266 /// use zvariant::{Result, Value}; 267 /// 268 /// fn value_vec_to_type_vec<'a, T>(values: Vec<Value<'a>>) -> Result<Vec<T>> 269 /// where 270 /// T: TryFrom<Value<'a>>, 271 /// { 272 /// let mut res = vec![]; 273 /// for value in values.into_iter() { 274 /// res.push(value.downcast().unwrap()); 275 /// } 276 /// 277 /// Ok(res) 278 /// } 279 /// 280 /// // Let's try u32 values first 281 /// let v = vec![Value::U32(42), Value::U32(43)]; 282 /// let v = value_vec_to_type_vec::<u32>(v).unwrap(); 283 /// assert_eq!(v[0], 42); 284 /// assert_eq!(v[1], 43); 285 /// 286 /// // Now try Value values 287 /// let v = vec![Value::new(Value::U32(42)), Value::new(Value::U32(43))]; 288 /// let v = value_vec_to_type_vec::<Value>(v).unwrap(); 289 /// assert_eq!(v[0], Value::U32(42)); 290 /// assert_eq!(v[1], Value::U32(43)); 291 /// ``` 292 /// 293 /// [`Value::Value`]: enum.Value.html#variant.Value 294 /// [`TryFrom<Value>`]: https://doc.rust-lang.org/std/convert/trait.TryFrom.html 295 /// [`From<Value>`]: https://doc.rust-lang.org/std/convert/trait.From.html downcast<T: ?Sized>(self) -> Option<T> where T: TryFrom<Value<'a>>,296 pub fn downcast<T: ?Sized>(self) -> Option<T> 297 where 298 T: TryFrom<Value<'a>>, 299 { 300 if let Value::Value(v) = self { 301 T::try_from(*v).ok() 302 } else { 303 T::try_from(self).ok() 304 } 305 } 306 307 /// Try to get a reference to the underlying type `T`. 308 /// 309 /// Same as [`downcast`] except it doesn't consume `self` and get a reference to the underlying 310 /// value. 311 /// 312 /// # Examples 313 /// 314 /// ``` 315 /// use std::convert::TryFrom; 316 /// use zvariant::{Result, Value}; 317 /// 318 /// fn value_vec_to_type_vec<'a, T>(values: &'a Vec<Value<'a>>) -> Result<Vec<&'a T>> 319 /// where 320 /// &'a T: TryFrom<&'a Value<'a>>, 321 /// { 322 /// let mut res = vec![]; 323 /// for value in values.into_iter() { 324 /// res.push(value.downcast_ref().unwrap()); 325 /// } 326 /// 327 /// Ok(res) 328 /// } 329 /// 330 /// // Let's try u32 values first 331 /// let v = vec![Value::U32(42), Value::U32(43)]; 332 /// let v = value_vec_to_type_vec::<u32>(&v).unwrap(); 333 /// assert_eq!(*v[0], 42); 334 /// assert_eq!(*v[1], 43); 335 /// 336 /// // Now try Value values 337 /// let v = vec![Value::new(Value::U32(42)), Value::new(Value::U32(43))]; 338 /// let v = value_vec_to_type_vec::<Value>(&v).unwrap(); 339 /// assert_eq!(*v[0], Value::U32(42)); 340 /// assert_eq!(*v[1], Value::U32(43)); 341 /// ``` 342 /// 343 /// [`downcast`]: enum.Value.html#method.downcast downcast_ref<T>(&'a self) -> Option<&'a T> where T: ?Sized, &'a T: TryFrom<&'a Value<'a>>,344 pub fn downcast_ref<T>(&'a self) -> Option<&'a T> 345 where 346 T: ?Sized, 347 &'a T: TryFrom<&'a Value<'a>>, 348 { 349 if let Value::Value(v) = self { 350 <&T>::try_from(v).ok() 351 } else { 352 <&T>::try_from(self).ok() 353 } 354 } 355 } 356 357 impl<'a> Serialize for Value<'a> { serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,358 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> 359 where 360 S: Serializer, 361 { 362 // Serializer implementation needs to ensure padding isn't added for Value. 363 let mut structure = serializer.serialize_struct("zvariant::Value", 2)?; 364 365 let signature = self.value_signature(); 366 structure.serialize_field("zvariant::Value::Signature", &signature)?; 367 368 self.serialize_value_as_struct_field("zvariant::Value::Value", &mut structure)?; 369 370 structure.end() 371 } 372 } 373 374 impl<'de: 'a, 'a> Deserialize<'de> for Value<'a> { deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,375 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> 376 where 377 D: Deserializer<'de>, 378 { 379 let visitor = ValueVisitor; 380 381 deserializer.deserialize_any(visitor) 382 } 383 } 384 385 // Note that the Visitor implementations don't check for validity of the 386 // signature. That's left to the Deserialize implementation of Signature 387 // itself. 388 389 struct ValueVisitor; 390 391 impl<'de> Visitor<'de> for ValueVisitor { 392 type Value = Value<'de>; 393 expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result394 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 395 formatter.write_str("a Value") 396 } 397 398 #[inline] visit_seq<V>(self, mut visitor: V) -> Result<Value<'de>, V::Error> where V: SeqAccess<'de>,399 fn visit_seq<V>(self, mut visitor: V) -> Result<Value<'de>, V::Error> 400 where 401 V: SeqAccess<'de>, 402 { 403 let signature = visitor.next_element::<Signature<'_>>()?.ok_or_else(|| { 404 Error::invalid_value(Unexpected::Other("nothing"), &"a Value signature") 405 })?; 406 let seed = ValueSeed::<Value<'_>> { 407 signature, 408 phantom: PhantomData, 409 }; 410 411 visitor 412 .next_element_seed(seed)? 413 .ok_or_else(|| Error::invalid_value(Unexpected::Other("nothing"), &"a Value value")) 414 } 415 visit_map<V>(self, mut visitor: V) -> Result<Value<'de>, V::Error> where V: MapAccess<'de>,416 fn visit_map<V>(self, mut visitor: V) -> Result<Value<'de>, V::Error> 417 where 418 V: MapAccess<'de>, 419 { 420 let (_, signature) = visitor 421 .next_entry::<&str, Signature<'_>>()? 422 .ok_or_else(|| { 423 Error::invalid_value(Unexpected::Other("nothing"), &"a Value signature") 424 })?; 425 let _ = visitor.next_key::<&str>()?; 426 427 let seed = ValueSeed::<Value<'_>> { 428 signature, 429 phantom: PhantomData, 430 }; 431 visitor.next_value_seed(seed) 432 } 433 } 434 435 pub(crate) struct SignatureSeed<'de> { 436 pub signature: Signature<'de>, 437 } 438 439 impl<'de> SignatureSeed<'de> { 440 #[inline] visit_array<V>(self, mut visitor: V) -> Result<Array<'de>, V::Error> where V: SeqAccess<'de>,441 pub(crate) fn visit_array<V>(self, mut visitor: V) -> Result<Array<'de>, V::Error> 442 where 443 V: SeqAccess<'de>, 444 { 445 let element_signature = self.signature.slice(1..); 446 let mut array = Array::new_full_signature(self.signature.clone()); 447 448 while let Some(elem) = visitor.next_element_seed(ValueSeed::<Value<'_>> { 449 signature: element_signature.clone(), 450 phantom: PhantomData, 451 })? { 452 elem.value_signature(); 453 array.append(elem).map_err(Error::custom)?; 454 } 455 456 Ok(array) 457 } 458 459 #[inline] visit_struct<V>(self, mut visitor: V) -> Result<Structure<'de>, V::Error> where V: SeqAccess<'de>,460 pub(crate) fn visit_struct<V>(self, mut visitor: V) -> Result<Structure<'de>, V::Error> 461 where 462 V: SeqAccess<'de>, 463 { 464 let mut i = 1; 465 let signature_end = self.signature.len() - 1; 466 let mut builder = StructureBuilder::new(); 467 while i < signature_end { 468 let fields_signature = self.signature.slice(i..signature_end); 469 let parser = SignatureParser::new(fields_signature.clone()); 470 let len = parser.next_signature().map_err(Error::custom)?.len(); 471 let field_signature = fields_signature.slice(0..len); 472 i += field_signature.len(); 473 474 if let Some(field) = visitor.next_element_seed(ValueSeed::<Value<'_>> { 475 signature: field_signature, 476 phantom: PhantomData, 477 })? { 478 builder = builder.append_field(field); 479 } 480 } 481 Ok(builder.build_with_signature(self.signature)) 482 } 483 } 484 485 impl<'de, T> From<ValueSeed<'de, T>> for SignatureSeed<'de> { from(seed: ValueSeed<'de, T>) -> Self486 fn from(seed: ValueSeed<'de, T>) -> Self { 487 SignatureSeed { 488 signature: seed.signature, 489 } 490 } 491 } 492 493 struct ValueSeed<'de, T> { 494 signature: Signature<'de>, 495 phantom: PhantomData<T>, 496 } 497 498 impl<'de, T> ValueSeed<'de, T> 499 where 500 T: Deserialize<'de>, 501 { 502 #[inline] visit_array<V>(self, visitor: V) -> Result<Value<'de>, V::Error> where V: SeqAccess<'de>,503 fn visit_array<V>(self, visitor: V) -> Result<Value<'de>, V::Error> 504 where 505 V: SeqAccess<'de>, 506 { 507 SignatureSeed::from(self) 508 .visit_array(visitor) 509 .map(Value::Array) 510 } 511 512 #[inline] visit_struct<V>(self, visitor: V) -> Result<Value<'de>, V::Error> where V: SeqAccess<'de>,513 fn visit_struct<V>(self, visitor: V) -> Result<Value<'de>, V::Error> 514 where 515 V: SeqAccess<'de>, 516 { 517 SignatureSeed::from(self) 518 .visit_struct(visitor) 519 .map(Value::Structure) 520 } 521 522 #[inline] visit_variant<V>(self, visitor: V) -> Result<Value<'de>, V::Error> where V: SeqAccess<'de>,523 fn visit_variant<V>(self, visitor: V) -> Result<Value<'de>, V::Error> 524 where 525 V: SeqAccess<'de>, 526 { 527 ValueVisitor 528 .visit_seq(visitor) 529 .map(|v| Value::Value(Box::new(v))) 530 } 531 } 532 533 macro_rules! value_seed_basic_method { 534 ($name:ident, $type:ty) => { 535 #[inline] 536 fn $name<E>(self, value: $type) -> Result<Value<'de>, E> 537 where 538 E: serde::de::Error, 539 { 540 Ok(value.into()) 541 } 542 }; 543 } 544 545 macro_rules! value_seed_str_method { 546 ($name:ident, $type:ty, $constructor:ident) => { 547 #[inline] 548 fn $name<E>(self, value: $type) -> Result<Value<'de>, E> 549 where 550 E: serde::de::Error, 551 { 552 match self.signature.as_str() { 553 <&str>::SIGNATURE_STR => Ok(Value::Str(Str::from(value))), 554 Signature::SIGNATURE_STR => Ok(Value::Signature(Signature::$constructor(value))), 555 ObjectPath::SIGNATURE_STR => Ok(Value::ObjectPath(ObjectPath::$constructor(value))), 556 _ => { 557 let expected = format!( 558 "`{}`, `{}` or `{}`", 559 <&str>::SIGNATURE_STR, 560 Signature::SIGNATURE_STR, 561 ObjectPath::SIGNATURE_STR, 562 ); 563 Err(Error::invalid_type( 564 Unexpected::Str(self.signature.as_str()), 565 &expected.as_str(), 566 )) 567 } 568 } 569 } 570 }; 571 } 572 573 impl<'de, T> Visitor<'de> for ValueSeed<'de, T> 574 where 575 T: Deserialize<'de>, 576 { 577 type Value = Value<'de>; 578 expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result579 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 580 formatter.write_str("a Value value") 581 } 582 583 value_seed_basic_method!(visit_bool, bool); 584 value_seed_basic_method!(visit_i16, i16); 585 value_seed_basic_method!(visit_i64, i64); 586 value_seed_basic_method!(visit_u8, u8); 587 value_seed_basic_method!(visit_u16, u16); 588 value_seed_basic_method!(visit_u32, u32); 589 value_seed_basic_method!(visit_u64, u64); 590 value_seed_basic_method!(visit_f64, f64); 591 592 #[inline] visit_i32<E>(self, value: i32) -> Result<Value<'de>, E> where E: serde::de::Error,593 fn visit_i32<E>(self, value: i32) -> Result<Value<'de>, E> 594 where 595 E: serde::de::Error, 596 { 597 let v = match self.signature.as_bytes().first().ok_or_else(|| { 598 Error::invalid_value( 599 Unexpected::Other("nothing"), 600 &"i32 or fd signature character", 601 ) 602 })? { 603 b'h' => Fd::from(value).into(), 604 _ => value.into(), 605 }; 606 607 Ok(v) 608 } 609 610 #[inline] visit_str<E>(self, value: &str) -> Result<Value<'de>, E> where E: serde::de::Error,611 fn visit_str<E>(self, value: &str) -> Result<Value<'de>, E> 612 where 613 E: serde::de::Error, 614 { 615 self.visit_string(String::from(value)) 616 } 617 618 value_seed_str_method!(visit_borrowed_str, &'de str, from_str_unchecked); 619 620 #[inline] visit_seq<V>(self, visitor: V) -> Result<Value<'de>, V::Error> where V: SeqAccess<'de>,621 fn visit_seq<V>(self, visitor: V) -> Result<Value<'de>, V::Error> 622 where 623 V: SeqAccess<'de>, 624 { 625 match self.signature.as_bytes().first().ok_or_else(|| { 626 Error::invalid_value( 627 Unexpected::Other("nothing"), 628 &"Array or Struct signature character", 629 ) 630 })? { 631 // For some reason rustc doesn't like us using ARRAY_SIGNATURE_CHAR const 632 b'a' => self.visit_array(visitor), 633 b'(' => self.visit_struct(visitor), 634 b'v' => self.visit_variant(visitor), 635 b => Err(Error::invalid_value( 636 Unexpected::Char(*b as char), 637 &"a Value signature", 638 )), 639 } 640 } 641 642 #[inline] visit_map<V>(self, mut visitor: V) -> Result<Value<'de>, V::Error> where V: MapAccess<'de>,643 fn visit_map<V>(self, mut visitor: V) -> Result<Value<'de>, V::Error> 644 where 645 V: MapAccess<'de>, 646 { 647 let key_signature = self.signature.slice(2..3); 648 let signature_end = self.signature.len() - 1; 649 let value_signature = self.signature.slice(3..signature_end); 650 let mut dict = Dict::new_full_signature(self.signature.clone()); 651 652 while let Some((key, value)) = visitor.next_entry_seed( 653 ValueSeed::<Value<'_>> { 654 signature: key_signature.clone(), 655 phantom: PhantomData, 656 }, 657 ValueSeed::<Value<'_>> { 658 signature: value_signature.clone(), 659 phantom: PhantomData, 660 }, 661 )? { 662 dict.append(key, value).map_err(Error::custom)?; 663 } 664 665 Ok(Value::Dict(dict)) 666 } 667 668 #[inline] 669 #[cfg(feature = "gvariant")] visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error> where D: Deserializer<'de>,670 fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error> 671 where 672 D: Deserializer<'de>, 673 { 674 let visitor = ValueSeed::<T> { 675 signature: self.signature.slice(1..), 676 phantom: PhantomData, 677 }; 678 679 deserializer 680 .deserialize_any(visitor) 681 .map(|v| Value::Maybe(Maybe::just_full_signature(v, self.signature))) 682 } 683 684 #[cfg(not(feature = "gvariant"))] visit_some<D>(self, _deserializer: D) -> Result<Self::Value, D::Error> where D: Deserializer<'de>,685 fn visit_some<D>(self, _deserializer: D) -> Result<Self::Value, D::Error> 686 where 687 D: Deserializer<'de>, 688 { 689 panic!("`Maybe` type is only supported for GVariant format but it's disabled"); 690 } 691 692 #[cfg(feature = "gvariant")] visit_none<E>(self) -> Result<Self::Value, E> where E: Error,693 fn visit_none<E>(self) -> Result<Self::Value, E> 694 where 695 E: Error, 696 { 697 let value = Maybe::nothing_full_signature(self.signature); 698 699 Ok(Value::Maybe(value)) 700 } 701 702 #[cfg(not(feature = "gvariant"))] visit_none<E>(self) -> Result<Self::Value, E> where E: Error,703 fn visit_none<E>(self) -> Result<Self::Value, E> 704 where 705 E: Error, 706 { 707 panic!("`Maybe` type is only supported for GVariant format but it's disabled"); 708 } 709 } 710 711 impl<'de, T> DeserializeSeed<'de> for ValueSeed<'de, T> 712 where 713 T: Deserialize<'de>, 714 { 715 type Value = Value<'de>; 716 deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error> where D: Deserializer<'de>,717 fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error> 718 where 719 D: Deserializer<'de>, 720 { 721 deserializer.deserialize_any(self) 722 } 723 } 724 725 impl<'a> Type for Value<'a> { signature() -> Signature<'static>726 fn signature() -> Signature<'static> { 727 Signature::from_static_str_unchecked(VARIANT_SIGNATURE_STR) 728 } 729 } 730