Struct MutableOption

pub struct MutableOption<T>(/* private fields */);

Implementations

impl<T> MutableOption<T>

pub fn new(value: Option<T>) -> MutableOption<T>

pub fn new_some(value: T) -> MutableOption<T>

pub fn new_default() -> MutableOption<T>

where T: Default,

pub fn is_none(&self) -> bool

pub fn is_some(&self) -> bool

pub fn take(self) -> Option<T>

pub fn take_if_value(&self, value: &T) -> Option<T>

where T: PartialEq,

pub fn as_mutable(&self) -> Mutable<Option<T>>

pub fn map<F>(&self, f: impl FnOnce(&T) -> F) -> Option<F>

pub fn map_or<U>(&self, f: impl FnOnce(&T) -> U, default: U) -> U

pub fn map_or_else<U, D>(&self, f: impl FnOnce(&T) -> U, default: D) -> U

where D: FnOnce() -> U,

pub fn map_or_default<U>(&self, f: impl FnOnce(&T) -> U) -> U

where U: Default,

pub fn and_then<U>(&self, f: impl FnOnce(&T) -> Option<U>) -> Option<U>

pub fn signal_some_default(&self) -> impl Signal<Item = T> + use<T>

where T: Default + Copy,

pub fn signal_cloned_some_default(&self) -> impl Signal<Item = T> + use<T>

where T: Default + Clone,

pub fn signal_map<F, U>( &self, f: F, ) -> impl Signal<Item = Option<U>> + use<T, F, U>

where F: FnMut(Option<&T>) -> Option<U>,

pub fn signal_map_some<F, U>( &self, f: F, ) -> impl Signal<Item = Option<U>> + use<T, F, U>

where F: FnMut(&T) -> U,

pub fn signal_and_then_some<F, U>( &self, f: F, ) -> impl Signal<Item = Option<U>> + use<T, F, U>

where F: FnMut(&T) -> Option<U>,

pub fn signal_and_then_some_or<F, U>( &self, f: F, default: U, ) -> impl Signal<Item = U> + use<T, F, U>

where F: FnMut(&T) -> Option<U>, U: Clone,

pub fn signal_and_then_some_or_else<F, D, U>( &self, f: F, default: D, ) -> impl Signal<Item = U> + use<T, F, D, U>

where F: FnMut(&T) -> Option<U>, D: FnOnce() -> U + Clone,

pub fn signal_map_some_or<F, U>( &self, f: F, default: U, ) -> impl Signal<Item = U> + use<T, F, U>

where F: FnMut(&T) -> U, U: Clone,

pub fn signal_map_some_or_else<F, D, U>( &self, f: F, default: D, ) -> impl Signal<Item = U> + use<T, F, D, U>

where F: FnMut(&T) -> U, D: FnOnce() -> U + Clone,

pub fn signal_map_some_default<F, U>( &self, f: F, ) -> impl Signal<Item = U> + use<T, F, U>

where F: FnMut(&T) -> U, U: Default,

Methods from Deref<Target = Mutable<Option<T>>>

pub fn read_only(&self) -> ReadOnlyMutable<A>

pub fn replace(&self, value: A) -> A

pub fn replace_with<F>(&self, f: F) -> A

where F: FnOnce(&mut A) -> A,

pub fn swap(&self, other: &Mutable<A>)

pub fn set(&self, value: A)

pub fn set_if<F>(&self, value: A, f: F)

where F: FnOnce(&A, &A) -> bool,

pub fn lock_mut(&self) -> MutableLockMut<'_, A>

pub fn set_neq(&self, value: A)

Methods from Deref<Target = ReadOnlyMutable<A>>

pub fn lock_ref(&self) -> MutableLockRef<'_, A>

pub fn signal_ref<B, F>(&self, f: F) -> MutableSignalRef<A, F>

where F: FnMut(&A) -> B,

pub fn get(&self) -> A

pub fn signal(&self) -> MutableSignal<A>

pub fn get_cloned(&self) -> A

pub fn signal_cloned(&self) -> MutableSignalCloned<A>

Trait Implementations

impl<T> Clone for MutableOption<T>

fn clone(&self) -> MutableOption<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for MutableOption<T>

where T: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<T> Default for MutableOption<T>

fn default() -> MutableOption<T>

Returns the “default value” for a type.

impl<T> Deref for MutableOption<T>

type Target = Mutable<Option<T>>

The resulting type after dereferencing.

fn deref(&self) -> &<MutableOption<T> as Deref>::Target

Dereferences the value.

impl<E, MV> From<&EntityStore<E, MV>> for MutableOption<E>

where E: Clone,

fn from(store: &EntityStore<E, MV>) -> Self

Converts to this type from the input type.