pub struct Optional<T>(_);
Expand description
An optional value.
Since D-Bus doesn’t have the concept of nullability, it uses a special value (typically the
default value) as the null value. Serde has built-in support for Option
but
unfortunately that doesn’t work for us. Hence the need for this type.
The serialization and deserialization of Optional
relies on NoneValue
implementation of
the underlying type.
Methods from Deref<Target = Option<T>>
🔬 This is a nightly-only experimental API. (is_some_with
)
is_some_with
)Returns true
if the option is a Some
wrapping a value matching the predicate.
Examples
#![feature(is_some_with)]
let x: Option<u32> = Some(2);
assert_eq!(x.is_some_with(|&x| x > 1), true);
let x: Option<u32> = Some(0);
assert_eq!(x.is_some_with(|&x| x > 1), false);
let x: Option<u32> = None;
assert_eq!(x.is_some_with(|&x| x > 1), false);
Converts from &Option<T>
to Option<&T>
.
Examples
Converts an Option<String>
into an Option<usize>
, preserving
the original. The map
method takes the self
argument by value, consuming the original,
so this technique uses as_ref
to first take an Option
to a reference
to the value inside the original.
let text: Option<String> = Some("Hello, world!".to_string());
// First, cast `Option<String>` to `Option<&String>` with `as_ref`,
// then consume *that* with `map`, leaving `text` on the stack.
let text_length: Option<usize> = text.as_ref().map(|s| s.len());
println!("still can print text: {:?}", text);
Converts from &mut Option<T>
to Option<&mut T>
.
Examples
let mut x = Some(2);
match x.as_mut() {
Some(v) => *v = 42,
None => {},
}
assert_eq!(x, Some(42));
Converts from Option<T>
(or &Option<T>
) to Option<&T::Target>
.
Leaves the original Option in-place, creating a new one with a reference
to the original one, additionally coercing the contents via Deref
.
Examples
let x: Option<String> = Some("hey".to_owned());
assert_eq!(x.as_deref(), Some("hey"));
let x: Option<String> = None;
assert_eq!(x.as_deref(), None);
Converts from Option<T>
(or &mut Option<T>
) to Option<&mut T::Target>
.
Leaves the original Option
in-place, creating a new one containing a mutable reference to
the inner type’s Deref::Target
type.
Examples
let mut x: Option<String> = Some("hey".to_owned());
assert_eq!(x.as_deref_mut().map(|x| {
x.make_ascii_uppercase();
x
}), Some("HEY".to_owned().as_mut_str()));
Returns an iterator over the possibly contained value.
Examples
let x = Some(4);
assert_eq!(x.iter().next(), Some(&4));
let x: Option<u32> = None;
assert_eq!(x.iter().next(), None);
Returns a mutable iterator over the possibly contained value.
Examples
let mut x = Some(4);
match x.iter_mut().next() {
Some(v) => *v = 42,
None => {},
}
assert_eq!(x, Some(42));
let mut x: Option<u32> = None;
assert_eq!(x.iter_mut().next(), None);
Inserts value
into the option, then returns a mutable reference to it.
If the option already contains a value, the old value is dropped.
See also Option::get_or_insert
, which doesn’t update the value if
the option already contains Some
.
Example
let mut opt = None;
let val = opt.insert(1);
assert_eq!(*val, 1);
assert_eq!(opt.unwrap(), 1);
let val = opt.insert(2);
assert_eq!(*val, 2);
*val = 3;
assert_eq!(opt.unwrap(), 3);
Inserts value
into the option if it is None
, then
returns a mutable reference to the contained value.
See also Option::insert
, which updates the value even if
the option already contains Some
.
Examples
let mut x = None;
{
let y: &mut u32 = x.get_or_insert(5);
assert_eq!(y, &5);
*y = 7;
}
assert_eq!(x, Some(7));
🔬 This is a nightly-only experimental API. (option_get_or_insert_default
)
option_get_or_insert_default
)Replaces the actual value in the option by the value given in parameter,
returning the old value if present,
leaving a Some
in its place without deinitializing either one.
Examples
let mut x = Some(2);
let old = x.replace(5);
assert_eq!(x, Some(5));
assert_eq!(old, Some(2));
let mut x = None;
let old = x.replace(3);
assert_eq!(x, Some(3));
assert_eq!(old, None);
🔬 This is a nightly-only experimental API. (option_result_contains
)
option_result_contains
)Returns true
if the option is a Some
value containing the given value.
Examples
#![feature(option_result_contains)]
let x: Option<u32> = Some(2);
assert_eq!(x.contains(&2), true);
let x: Option<u32> = Some(3);
assert_eq!(x.contains(&2), false);
let x: Option<u32> = None;
assert_eq!(x.contains(&2), false);
Trait Implementations
impl<'de, T, E> Deserialize<'de> for Optional<T> where
T: Type + NoneValue + Deserialize<'de>,
<T as NoneValue>::NoneType: Deserialize<'de> + TryInto<T, Error = E> + PartialEq,
E: Display,
impl<'de, T, E> Deserialize<'de> for Optional<T> where
T: Type + NoneValue + Deserialize<'de>,
<T as NoneValue>::NoneType: Deserialize<'de> + TryInto<T, Error = E> + PartialEq,
E: Display,
Deserialize this value from the given Serde deserializer. Read more
Auto Trait Implementations
impl<T> RefUnwindSafe for Optional<T> where
T: RefUnwindSafe,
impl<T> UnwindSafe for Optional<T> where
T: UnwindSafe,
Blanket Implementations
Mutably borrows from an owned value. Read more