Type Alias BoxedVar

pub type BoxedVar<T> = Box<dyn VarBoxed<T>>;

Represents a Var<T> boxed.

Aliased Type

struct BoxedVar<T>(/* private fields */);

Trait Implementations

impl<T: VarValue> AnyVar for BoxedVar<T>

fn clone_any(&self) -> BoxedAnyVar

Clone the variable into a type erased box.

fn as_any(&self) -> &dyn Any

Access to dyn Any methods.

fn as_unboxed_any(&self) -> &dyn Any

Access to dyn Any methods, on the underlying variable type if boxed.

fn double_boxed_any(self: Box<Self>) -> Box<dyn Any>

Access to Box<dyn Any> methods, with the BoxedVar<T> type.

fn var_type_id(&self) -> TypeId

Gets the TypeId of T in Var<T>.

fn get_any(&self) -> Box<dyn AnyVarValue>

Get a clone of the current value, with type erased.

fn with_any(&self, read: &mut dyn FnMut(&dyn AnyVarValue))

Visit the current value of the variable.

fn with_new_any(&self, read: &mut dyn FnMut(&dyn AnyVarValue)) -> bool

Visit the current value of the variable, if it is_new.

fn set_any(&self, value: Box<dyn AnyVarValue>) -> Result<(), VarIsReadOnlyError>

Schedule a new value for the variable, it will be set in the end of the current app update.

fn last_update(&self) -> VarUpdateId

Last update ID a variable was modified, if the ID is equal to VARS.update_id the variable is new.

fn is_contextual(&self) -> bool

If the variable represents different values depending on the context where they are read.

fn capabilities(&self) -> VarCapability

Flags that indicate what operations the variable is capable of in this update.

fn hook_any( &self, pos_modify_action: Box<dyn Fn(&AnyVarHookArgs<'_>) -> bool + Send + Sync>, ) -> VarHandle

Setups a callback for just after the variable value update is applied, the closure runs in the root app context, just like the modify closure. The closure can return if it is retained after each call. If you modify another variable in a hook the modification applies in the same update, variable mapping and binding is implemented using hooks.

fn hook_animation_stop( &self, handler: Box<dyn FnOnce() + Send>, ) -> Result<(), Box<dyn FnOnce() + Send>>

Register a handler to be called when the current animation stops.

fn strong_count(&self) -> usize

Gets the number of strong references to the variable.

fn weak_count(&self) -> usize

Gets the number of weak references to the variable.

fn actual_var_any(&self) -> BoxedAnyVar

Gets a clone of the represented var from ContextVar<T>, gets a clone of self for other var types.

fn downgrade_any(&self) -> BoxedAnyWeakVar

Create a weak reference to this Arc variable.

fn is_animating(&self) -> bool

If the variable current value was set by an active animation.

fn modify_importance(&self) -> usize

Gets a value that indicates the importance clearance that is needed to modify this variable.

fn var_ptr(&self) -> VarPtr<'_>

Var pointer, that can be used to identify if two variables point to the same rc or context.

fn get_debug(&self) -> Txt

Get the value as a debug Txt.

fn update(&self) -> Result<(), VarIsReadOnlyError>

Schedule a variable update, even if the value does no change.

fn map_debug(&self) -> BoxedVar<Txt>

Create a map that converts from T to a Txt debug print.

fn is_new(&self) -> bool

Gets if the last_update is the current update, meaning the variable value just changed.

fn perm(&self)

Hold the variable in memory until the app exit.

fn hold_any(&self, value: Box<dyn Any + Send + Sync>) -> VarHandle

Keep other alive until the handle or self are dropped.

impl<T: VarValue> Clone for BoxedVar<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: VarValue> IntoVar<T> for BoxedVar<T>

type Var = Box<dyn VarBoxed<T>>

Variable type that will wrap the T value.

fn into_var(self) -> Self::Var

Converts the source value into a var.

fn into_boxed_var(self) -> BoxedVar<T>

where Self: Sized,

Converts into BoxedVar<T>.

impl<T: VarValue> Var<T> for BoxedVar<T>

type ReadOnly = Box<dyn VarBoxed<T>>

Output of Var::read_only.

type ActualVar = Box<dyn VarBoxed<T>>

Output of Var::actual_var.

type Downgrade = Box<dyn WeakVarBoxed<T>>

Output of Var::downgrade.

type Map<O: VarValue> = Box<dyn VarBoxed<O>>

Output of Var::map.

type MapBidi<O: VarValue> = Box<dyn VarBoxed<O>>

Output of Var::map_bidi.

type FlatMap<O: VarValue, V: Var<O>> = Box<dyn VarBoxed<O>>

Output of Var::flat_map.

type FilterMap<O: VarValue> = Box<dyn VarBoxed<O>>

Output of Var::filter_map.

type FilterMapBidi<O: VarValue> = Box<dyn VarBoxed<O>>

Output of Var::filter_map_bidi.

type MapRef<O: VarValue> = Box<dyn VarBoxed<O>>

Output of Var::map_ref.

type MapRefBidi<O: VarValue> = Box<dyn VarBoxed<O>>

Output of Var::map_ref_bidi.

type Easing = Box<dyn VarBoxed<T>>

Output of Var::easing.

fn with<R, F>(&self, read: F) -> R

where F: FnOnce(&T) -> R,

Visit the current value of the variable.

fn modify<F>(&self, modify: F) -> Result<(), VarIsReadOnlyError>

where F: FnOnce(&mut VarModify<'_, T>) + Send + 'static,

Schedule a variable update, it will be applied on the end of the current app update.

fn boxed(self) -> BoxedVar<T>

Gets the variable as a BoxedVar<T>, does not double box.

fn boxed_any(self) -> BoxedAnyVar

where Self: Sized,

Gets the variable as a BoxedAnyVar, does not double box.

fn actual_var(self) -> BoxedVar<T>

Gets the current inner var represented by this var. This can be the same var or a context var.

fn downgrade(&self) -> BoxedWeakVar<T>

Create a weak reference to this Arc variable.

fn into_value(self) -> T

Convert this variable to the value, if possible moves the value, if it is shared clones it.

fn read_only(&self) -> Self::ReadOnly

Gets a clone of the var that is always read-only.

fn map<O, M>(&self, map: M) -> Self::Map<O>

where O: VarValue, M: FnMut(&T) -> O + Send + 'static,

Creates a var that maps from this variable.

fn map_bidi<O, M, B>(&self, map: M, map_back: B) -> Self::MapBidi<O>

where O: VarValue, M: FnMut(&T) -> O + Send + 'static, B: FnMut(&O) -> T + Send + 'static,

Create a var that maps from this variable on read and to it on write.

fn flat_map<O, V, M>(&self, map: M) -> Self::FlatMap<O, V>

where O: VarValue, V: Var<O>, M: FnMut(&T) -> V + Send + 'static,

Create a var that maps to an inner variable that is found inside the value of this variable.

fn filter_map<O, M, I>(&self, map: M, fallback: I) -> Self::FilterMap<O>

where O: VarValue, M: FnMut(&T) -> Option<O> + Send + 'static, I: Fn() -> O + Send + Sync + 'static,

Creates a ref-counted var that maps from this variable, but can retain a previous mapped value.

fn filter_map_bidi<O, M, B, I>( &self, map: M, map_back: B, fallback: I, ) -> Self::FilterMapBidi<O>

where O: VarValue, M: FnMut(&T) -> Option<O> + Send + 'static, B: FnMut(&O) -> Option<T> + Send + 'static, I: Fn() -> O + Send + Sync + 'static,

Create a var that maps from this variable on read and to it on write, mapping in both directions can skip updates, retaining the previous mapped value.

fn map_ref<O, M>(&self, map: M) -> Self::MapRef<O>

where O: VarValue, M: Fn(&T) -> &O + Send + Sync + 'static,

Create a mapping wrapper around self. The map closure is called for each value access, it must reference the value O that already exists in T.

fn map_ref_bidi<O, M, B>(&self, map: M, map_mut: B) -> Self::MapRefBidi<O>

where O: VarValue, M: Fn(&T) -> &O + Send + Sync + 'static, B: Fn(&mut T) -> &mut O + Send + Sync + 'static,

Create a mapping wrapper around self. The map closure is called for each value access, it must reference the value O that already exists in T, the map_mut closure is called for every modify request, it must do the same as map but with mutable access.

fn easing<F>(&self, duration: Duration, easing: F) -> Self::Easing

where T: Transitionable, F: Fn(EasingTime) -> EasingStep + Send + Sync + 'static,

Create a vars that ease to each new value of self.

fn easing_with<F, S>( &self, duration: Duration, easing: F, sampler: S, ) -> Self::Easing

where T: Transitionable, F: Fn(EasingTime) -> EasingStep + Send + Sync + 'static, S: Fn(&Transition<T>, EasingStep) -> T + Send + Sync + 'static,

Create a vars that ease_with to each new value of self.

fn hook( &self, pos_modify_action: impl Fn(&VarHookArgs<'_, T>) -> bool + Send + Sync + 'static, ) -> VarHandle

Setups a callback for just after the variable value update is applied, the closure runs in the root app context, just like the modify closure. The closure can return if it is retained after each call. If you modify another variable in a hook the modification applies in the same update, variable mapping and binding is implemented using hooks.

fn wait_update(&self) -> impl Future<Output = VarUpdateId> + Send + Sync

Awaits for the last_update to change.

fn wait_animation(&self) -> impl Future<Output = ()> + Send + Sync

Awaits for is_animating to change from true to false.

fn wait_value( &self, predicate: impl Fn(&T) -> bool + Send + Sync, ) -> impl Future<Output = ()> + Send + Sync

Awaits for a value that passes the predicate.

fn with_new<R, F>(&self, read: F) -> Option<R>

where F: FnOnce(&T) -> R,

Visit the current value of the variable, if it is_new.

fn get(&self) -> T

Get a clone of the current value.

fn get_into(&self, value: &mut T)

Get a clone of the current value into value.

fn get_ne(&self, value: &mut T) -> bool

Get a clone of the current value into value if the current value is not equal to it.

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

Get a clone of the current value, if it is_new.

fn get_new_into(&self, value: &mut T) -> bool

Get a clone of the current value into value if the current value is_new.

fn get_new_ne(&self, value: &mut T) -> bool

Get a clone of the current value into value if the variable value is_new and not equal to the value.

fn set<I>(&self, value: I) -> Result<(), VarIsReadOnlyError>

where I: Into<T>,

Schedule a new value for the variable, it will be set in the end of the current app update.

fn set_from<I>(&self, other: &I) -> Result<(), VarIsReadOnlyError>

where I: Var<T>,

Schedule a new value for the variable, it will be set in the end of the current app update to the updated value of other, so if the other var has already scheduled an update, the updated value will be used.

fn set_from_map<Iv, I, M>( &self, other: &I, map: M, ) -> Result<(), VarIsReadOnlyError>

where Iv: VarValue, I: Var<Iv>, M: FnOnce(&Iv) -> T + Send + 'static,

Set from other value at the time of update, mapped to the type of self.

fn cow(&self) -> ArcCowVar<T, Self>

Create a var that redirects to this variable until the first value update, then it behaves like a ArcVar<T>.

fn map_into<O>(&self) -> Self::Map<O>

where O: VarValue, T: Into<O>,

Creates a map that converts from T to O using Into<O>.

fn filter_try_into<O, I>(&self, fallback: I) -> Self::FilterMap<O>

where O: VarValue, T: TryInto<O>, I: Fn() -> O + Send + Sync + 'static,

Create a filter_map that tries to convert from T to O using TryInto<O>.

fn bind_map<T2, V2, M>(&self, other: &V2, map: M) -> VarHandle

where T2: VarValue, V2: Var<T2>, M: FnMut(&T) -> T2 + Send + 'static,

Setup a hook that assigns other with the new values of self transformed by map.

fn bind_filter_map<T2, V2, F>(&self, other: &V2, map: F) -> VarHandle

where T2: VarValue, V2: Var<T2>, F: FnMut(&T) -> Option<T2> + Send + 'static,

Setup a hook that assigns other with the new values of self transformed by map, if the closure returns a value.

fn bind_map_bidi<T2, V2, M, B>( &self, other: &V2, map: M, map_back: B, ) -> VarHandles

where T2: VarValue, V2: Var<T2>, M: FnMut(&T) -> T2 + Send + 'static, B: FnMut(&T2) -> T + Send + 'static,

Bind self to other and back without causing an infinite loop.

fn bind_filter_map_bidi<T2, V2, M, B>( &self, other: &V2, map: M, map_back: B, ) -> VarHandles

where T2: VarValue, V2: Var<T2>, M: FnMut(&T) -> Option<T2> + Send + 'static, B: FnMut(&T2) -> Option<T> + Send + 'static,

Bind self to other and back with the new values of self transformed by map and the new values of other transformed by map_back, the value is assigned in a update only if the closures returns a value.

fn bind<V2>(&self, other: &V2) -> VarHandle

where V2: Var<T>,

Setup a hook that assigns other with the new values of self.

fn set_bind<V2>(&self, other: &V2) -> VarHandle

where V2: Var<T>,

Calls other.set_from(self) and self.bind(other).

fn bind_bidi<V2>(&self, other: &V2) -> VarHandles

where V2: Var<T>,

Setup two hooks that assigns other with the new values of self and self with the new values of other.

fn trace_value<E, S>(&self, enter_value: E) -> VarHandle

where E: FnMut(&TraceValueArgs<'_, T>) -> S + Send + 'static, S: Send + 'static,

Debug helper for tracing the lifetime of a value in this variable.

fn animate<A>(&self, animate: A) -> AnimationHandle

where A: FnMut(&Animation, &mut VarModify<'_, T>) + Send + 'static,

Schedule an animation that targets this variable.

fn sequence<A>(&self, animate: A) -> VarHandle

where A: FnMut(&<<Self::ActualVar as Var<T>>::Downgrade as WeakVar<T>>::Upgrade) -> AnimationHandle + Send + 'static,

Schedule animations started by animate, the closure is called once at the start to begin, then again every time the variable stops animating.

fn step<N>(&self, new_value: N, delay: Duration) -> AnimationHandle

where N: Into<T>,

Set the variable to new_value after a delay.

fn step_oci<N>(&self, new_value: N, delay: Duration) -> AnimationHandle

where N: Into<T>,

Oscillate between the current value and new_value, every time the delay elapses the variable is set to the next value.

fn set_step_oci<V0, V1>( &self, from: V0, to: V1, delay: Duration, ) -> AnimationHandle

where V0: Into<T>, V1: Into<T>,

Oscillate between from and to, the variable is set to from to start and every time the delay elapses the variable is set to the next value.

fn steps<F>( &self, steps: Vec<(Factor, T)>, duration: Duration, easing: F, ) -> AnimationHandle

where F: Fn(EasingTime) -> EasingStep + Send + 'static,

Set the variable to a sequence of values as a time duration elapses.

fn debug(&self) -> VarDebug<'_, T, Self>

Returns a wrapper that implements fmt::Debug to write the var value.

fn hold<V>(&self, value: V) -> VarHandle

where V: Any + Send,

Keep value alive until the handle or self are dropped.