Struct Owned

pub struct Owned<T> { /* private fields */ }

A unique, reactive value.

This type is useful for situations where a value is owned by exactly one type but needs to have reactivity through Source/Destination.

A Dynamic utilizes a Arc + [Mutex] to support updating its values from multiple threads. This type utilizes a RefCell, preventing it from being shared between multiple threads.

Implementations

impl<T> Owned<T>

pub fn new(value: T) -> Self

Returns a new reactive value.

pub fn borrow(&self) -> OwnedRef<'_, T>

Borrows the contents of this value with read-only access.

pub fn borrow_mut(&mut self) -> OwnedMut<'_, T>

Borrows the contents of this value with exclusive access.

When the returned type is accessed through DerefMut, all associated reactive callbacks will be invoked upon dropping the returned OwnedMut.

pub fn into_inner(self) -> T

Returns the contained value.

Trait Implementations

impl<T: Default> Default for Owned<T>

fn default() -> Owned<T>

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for Owned<T>

where T: Deserialize<'de>,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Destination<T> for Owned<T>

where T: 'static,

fn try_map_mut<R>( &self, map: impl FnOnce(Mutable<'_, T>) -> R, ) -> Result<R, DeadlockError>

Maps the contents with exclusive access. Before returning from this function, all observers will be notified that the contents have been updated.

fn map_mut<R>(&self, map: impl FnOnce(Mutable<'_, T>) -> R) -> R

Maps the contents with exclusive access. Before returning from this function, all observers will be notified that the contents have been updated.

fn try_replace(&self, new_value: T) -> Result<T, ReplaceError<T>>

where T: PartialEq,

Replaces the contents with new_value if new_value is different than the currently stored value. If the value is updated, the previous contents are returned.

fn replace(&self, new_value: T) -> Option<T>

where T: PartialEq,

Replaces the contents with new_value, returning the previous contents. Before returning from this function, all observers will be notified that the contents have been updated.

fn set(&self, new_value: T)

where T: PartialEq,

Stores new_value in this dynamic. Before returning from this function, all observers will be notified that the contents have been updated.

fn try_compare_swap( &self, expected_current: &T, new_value: T, ) -> Result<T, TryCompareSwapError<T>>

where T: Clone + PartialEq,

Replaces the current value with new_value if the current value is equal to expected_current.

fn compare_swap(&self, expected_current: &T, new_value: T) -> Result<T, T>

where T: Clone + PartialEq,

Replaces the current value with new_value if the current value is equal to expected_current.

fn toggle(&self) -> T

where T: Not<Output = T> + Clone,

Updates the value to the result of invoking Not on the current value. This function returns the new value.

fn take(&self) -> T

where Self: Source<T>, T: Default,

Returns the currently stored value, replacing the current contents with T::default().

fn take_if_not_default(&self) -> Option<T>

where T: Default + PartialEq,

Checks if the currently stored value is different than T::default(), and if so, returns Some(self.take()).

impl<T> From<Owned<T>> for ReadOnly<T>

fn from(value: Owned<T>) -> Self

Converts to this type from the input type.

impl<T> IntoReadOnly<T> for Owned<T>

fn into_read_only(self) -> ReadOnly<T>

Returns self as a ReadOnly.

impl<T> Serialize for Owned<T>

where T: Serialize,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Source<T> for Owned<T>

fn try_map_generational<R>( &self, map: impl FnOnce(DynamicGuard<'_, T, true>) -> R, ) -> Result<R, DeadlockError>

Maps the contents with read-only access, providing access to the value’s Generation.

fn on_change_try<F>(&self, on_change: F) -> CallbackHandle

where T: Send + 'static, F: FnMut() -> Result<(), CallbackDisconnected> + Send + 'static,

Executes on_change when the contents of this dynamic are updated.

fn for_each_subsequent_generational_try<F>(&self, for_each: F) -> CallbackHandle

where T: Send + 'static, F: for<'a> FnMut(DynamicGuard<'a, T, true>) -> Result<(), CallbackDisconnected> + Send + 'static,

Attaches for_each to this value so that it is invoked each time the source’s contents are updated.

fn for_each_subsequent_generational_cloned_try<F>( &self, for_each: F, ) -> CallbackHandle

where T: Clone + Send + 'static, F: FnMut(GenerationalValue<T>) -> Result<(), CallbackDisconnected> + Send + 'static,

Invokes for_each with the current contents and each time this source’s contents are updated.

fn map_generational<R>( &self, map: impl FnOnce(DynamicGuard<'_, T, true>) -> R, ) -> R

Maps the contents with read-only access, providing access to the value’s Generation.

fn generation(&self) -> Generation

Returns the current generation of the value.

fn map_ref<R>(&self, map: impl FnOnce(&T) -> R) -> R

Maps the contents with read-only access.

fn get(&self) -> T

where T: Clone,

Returns a clone of the currently contained value.

fn try_map_ref<R>(&self, map: impl FnOnce(&T) -> R) -> Result<R, DeadlockError>

Maps the contents with read-only access.

fn try_get(&self) -> Result<T, DeadlockError>

where T: Clone,

Returns a clone of the currently contained value.

fn on_change<F>(&self, on_change: F) -> CallbackHandle

where T: Send + 'static, F: FnMut() + Send + 'static,

Executes on_change when the contents of this dynamic are updated.

fn for_each_subsequent_generational<F>(&self, for_each: F) -> CallbackHandle

where T: Send + 'static, F: for<'a> FnMut(DynamicGuard<'_, T, true>) + Send + 'static,

Attaches for_each to this value so that it is invoked each time the source’s contents are updated.

fn for_each_subsequent_try<F>(&self, for_each: F) -> CallbackHandle

where T: Send + 'static, F: for<'a> FnMut(&'a T) -> Result<(), CallbackDisconnected> + Send + 'static,

Attaches for_each to this value so that it is invoked each time the source’s contents are updated.

fn for_each_subsequent<F>(&self, for_each: F) -> CallbackHandle

where T: Send + 'static, F: for<'a> FnMut(&'a T) + Send + 'static,

Attaches for_each to this value so that it is invoked each time the source’s contents are updated.

fn for_each_generational_try<F>(&self, for_each: F) -> CallbackHandle

where T: Send + 'static, F: for<'a> FnMut(DynamicGuard<'_, T, true>) -> Result<(), CallbackDisconnected> + Send + 'static,

Invokes for_each with the current contents and each time this source’s contents are updated.

fn for_each_generational<F>(&self, for_each: F) -> CallbackHandle

where T: Send + 'static, F: for<'a> FnMut(DynamicGuard<'_, T, true>) + Send + 'static,

Invokes for_each with the current contents and each time this source’s contents are updated.

fn for_each_try<F>(&self, for_each: F) -> CallbackHandle

where T: Send + 'static, F: for<'a> FnMut(&'a T) -> Result<(), CallbackDisconnected> + Send + 'static,

Invokes for_each with the current contents and each time this source’s contents are updated.

fn for_each<F>(&self, for_each: F) -> CallbackHandle

where T: Send + 'static, F: for<'a> FnMut(&'a T) + Send + 'static,

Invokes for_each with the current contents and each time this source’s contents are updated.

fn for_each_generational_cloned_try<F>(&self, for_each: F) -> CallbackHandle

where T: Clone + Send + 'static, F: FnMut(GenerationalValue<T>) -> Result<(), CallbackDisconnected> + Send + 'static,

Invokes for_each with the current contents and each time this source’s contents are updated.

fn for_each_cloned_try<F>(&self, for_each: F) -> CallbackHandle

where T: Clone + Send + 'static, F: FnMut(T) -> Result<(), CallbackDisconnected> + Send + 'static,

Invokes for_each with the current contents and each time this source’s contents are updated.

fn for_each_subsequent_cloned_try<F>(&self, for_each: F) -> CallbackHandle

where T: Clone + Send + 'static, F: FnMut(T) -> Result<(), CallbackDisconnected> + Send + 'static,

Invokes for_each each time this source’s contents are updated.

fn for_each_subsequent_cloned<F>(&self, for_each: F) -> CallbackHandle

where T: Clone + Send + 'static, F: FnMut(T) + Send + 'static,

Invokes for_each each time this source’s contents are updated.

fn for_each_cloned<F>(&self, for_each: F) -> CallbackHandle

where T: Clone + Send + 'static, F: FnMut(T) + Send + 'static,

Invokes for_each with the current contents and each time this source’s contents are updated.

fn for_each_notify(&self, notify: impl Into<Notify<T>>) -> CallbackHandle

where T: Unpin + Clone + Send + 'static,

Notifies notify with a clone of the current contents each time this source’s contents are updated.

fn for_each_try_notify(&self, notify: impl Into<Notify<T>>) -> CallbackHandle

where T: Unpin + Clone + Send + 'static,

Notifies notify with a clone of the current contents each time this source’s contents are updated, disconnecting the callback if the target is disconnected.

fn debounced_every(&self, period: Duration) -> Dynamic<T>

where T: PartialEq + Clone + Send + Sync + 'static,

Returns a new dynamic that contains the updated contents of this dynamic at most once every period.

fn debounced_with_delay(&self, period: Duration) -> Dynamic<T>

where T: PartialEq + Clone + Send + Sync + 'static,

Returns a new dynamic that contains the updated contents of this dynamic delayed by period. Each time this value is updated, the delay is reset.

fn map_each_generational<R, F>(&self, map: F) -> Dynamic<R>

where T: Send + 'static, F: for<'a> FnMut(DynamicGuard<'a, T, true>) -> R + Send + 'static, R: PartialEq + Send + 'static,

Creates a new dynamic value that contains the result of invoking map each time this value is changed.

fn map_each<R, F>(&self, map: F) -> Dynamic<R>

where T: Send + 'static, F: for<'a> FnMut(&'a T) -> R + Send + 'static, R: PartialEq + Send + 'static,

Creates a new dynamic value that contains the result of invoking map each time this value is changed.

fn map_each_cloned<R, F>(&self, map: F) -> Dynamic<R>

where T: Clone + Send + 'static, F: FnMut(T) -> R + Send + 'static, R: PartialEq + Send + 'static,

Creates a new dynamic value that contains the result of invoking map each time this value is changed.

fn weak_clone(&self) -> Dynamic<T>

where T: Clone + Send + 'static,

Returns a new Dynamic that contains a clone of each value from self.

fn map_each_into<U>(&self) -> Dynamic<U>

where U: PartialEq + From<T> + Send + 'static, T: Clone + Send + 'static,

Returns a new dynamic that is updated using U::from(T.clone()) each time self is updated.

fn map_each_to<U>(&self) -> Dynamic<U>

where U: PartialEq + for<'a> From<&'a T> + Send + 'static, T: Clone + Send + 'static,

Returns a new dynamic that is updated using U::from(&T) each time self is updated.

impl<'s, T, U> Unwrapped<U> for &'s Owned<T>

where for<'a> &'a T: IntoOption<&'a U>, T: Send + 'static, U: Clone + Send + 'static,

type Value<'a> = &'a U

The value type provided to the for each functions.

fn unwrapped_or_else(self, initial: impl FnOnce() -> U) -> Dynamic<U>

Returns a dynamic that is updated with the unwrapped contents of thie source.

fn for_each_unwrapped_try<ForEach>(self, for_each: ForEach) -> CallbackHandle

where ForEach: for<'a> FnMut(Self::Value<'a>) -> Result<(), CallbackDisconnected> + Send + 'static,

Invokes for_each when self is updated with a value that can be unwrapped.

fn unwrapped(self) -> Dynamic<T>

where T: Default,

Returns a dynamic that is updated with the unwrapped contents of thie source.

fn for_each_unwrapped<ForEach>(self, for_each: ForEach) -> CallbackHandle

where ForEach: for<'a> FnMut(Self::Value<'a>) + Send + 'static,

Invokes for_each when self is updated with a value that can be unwrapped.