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. For example this signal uses empty strings for null
values. 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>>§
1.0.0 · sourcepub fn as_ref(&self) -> Option<&T>
pub fn as_ref(&self) -> Option<&T>
Converts from &Option<T>
to Option<&T>
.
Examples
Calculates the length of an Option<String>
as an Option<usize>
without moving the String
. 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:?}");
1.0.0 · sourcepub fn as_mut(&mut self) -> Option<&mut T>
pub fn as_mut(&mut self) -> Option<&mut T>
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));
1.40.0 · sourcepub fn as_deref(&self) -> Option<&<T as Deref>::Target>where
T: Deref,
pub fn as_deref(&self) -> Option<&<T as Deref>::Target>where T: Deref,
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);
1.40.0 · sourcepub fn as_deref_mut(&mut self) -> Option<&mut <T as Deref>::Target>where
T: DerefMut,
pub fn as_deref_mut(&mut self) -> Option<&mut <T as Deref>::Target>where T: DerefMut,
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()));
1.0.0 · sourcepub fn iter(&self) -> Iter<'_, T>
pub fn iter(&self) -> Iter<'_, T>
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);
1.0.0 · sourcepub fn iter_mut(&mut self) -> IterMut<'_, T>
pub fn iter_mut(&mut self) -> IterMut<'_, T>
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);
1.53.0 · sourcepub fn insert(&mut self, value: T) -> &mut T
pub fn insert(&mut self, value: T) -> &mut T
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);
1.20.0 · sourcepub fn get_or_insert(&mut self, value: T) -> &mut T
pub fn get_or_insert(&mut self, value: T) -> &mut T
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));
sourcepub fn get_or_insert_default(&mut self) -> &mut Twhere
T: Default,
🔬This is a nightly-only experimental API. (option_get_or_insert_default
)
pub fn get_or_insert_default(&mut self) -> &mut Twhere T: Default,
option_get_or_insert_default
)1.20.0 · sourcepub fn get_or_insert_with<F>(&mut self, f: F) -> &mut Twhere
F: FnOnce() -> T,
pub fn get_or_insert_with<F>(&mut self, f: F) -> &mut Twhere F: FnOnce() -> T,
1.31.0 · sourcepub fn replace(&mut self, value: T) -> Option<T>
pub fn replace(&mut self, value: T) -> Option<T>
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);
sourcepub fn contains<U>(&self, x: &U) -> boolwhere
U: PartialEq<T>,
🔬This is a nightly-only experimental API. (option_result_contains
)
pub fn contains<U>(&self, x: &U) -> boolwhere U: PartialEq<T>,
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);