Struct zng::var::ContextualizedVar

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

Represents a variable that delays initialization until the first usage.

Usage that initializes the variable are all AnyVar and Var<T> methods except read_only, downgrade and boxed. The variable re-initializes when the ContextInitHandle::current is different on usage.

This variable is used in the Var::map and other mapping methods to support mapping from ContextVar<T>.

let wgt = MyWgt! {
    my_property = MY_CTX_VAR.map(|&b| !b);
};

In the example above the mapping var will bind with the MY_CTX_VAR context inside the property node, not the context at the moment the widget is instantiated.

Clone

Note that a clone of this variable may call the init closure again for the same context, the inited actual var is only reused if it is already inited when clone is called and clone is called on the same context.

Implementations

impl<T> ContextualizedVar<T>

where T: VarValue,

pub fn new<V>( init: impl Fn() -> V + Send + Sync + 'static, ) -> ContextualizedVar<T>

where V: Var<T>,

New with initialization function.

The init closure will be called on the first usage of the var, once after the var is cloned and any time a parent contextualized var is initializing.

pub fn new_value( init: impl Fn() -> T + Send + Sync + 'static, ) -> ContextualizedVar<T>

New with initialization function that produces a value.

The init closure will be called on the first usage of the var, once after the var is cloned and any time a parent contextualized var is initializing.

pub fn borrow_init( &self, ) -> MappedRwLockReadGuard<'_, RawRwLock, Box<dyn VarBoxed<T>>>

Borrow/initialize the actual var.

pub fn into_init(self) -> Box<dyn VarBoxed<T>>

Unwraps the initialized actual var or initializes it now.

Trait Implementations

impl<T> AnyVar for ContextualizedVar<T>

where T: VarValue,

fn clone_any(&self) -> Box<dyn AnyVar>

Clone the variable into a type erased box.

fn as_any(&self) -> &(dyn Any + 'static)

Access to dyn Any methods.

fn as_unboxed_any(&self) -> &(dyn Any + 'static)

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

fn double_boxed_any(self: Box<ContextualizedVar<T>>) -> 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 + 'static)))

Visit the current value of the variable.

fn with_new_any( &self, read: &mut dyn FnMut(&(dyn AnyVarValue + 'static)), ) -> 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 + Sync + Send>, ) -> 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) -> Box<dyn AnyVar>

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

fn downgrade_any(&self) -> Box<dyn AnyWeakVar>

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) -> Box<dyn VarBoxed<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 + Sync + Send>) -> VarHandle

Keep other alive until the handle or self are dropped.

impl<T> Clone for ContextualizedVar<T>

where T: VarValue,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> IntoVar<T> for ContextualizedVar<T>

where T: VarValue,

type Var = ContextualizedVar<T>

Variable type that will wrap the T value.

fn into_var(self) -> <ContextualizedVar<T> as IntoVar<T>>::Var

Converts the source value into a var.

fn into_boxed_var(self) -> Box<dyn VarBoxed<T>>

where Self: Sized,

Converts into BoxedVar<T>.

impl<T> Var<T> for ContextualizedVar<T>

where T: VarValue,

type ReadOnly = ReadOnlyVar<T, ContextualizedVar<T>>

Output of Var::read_only.

type ActualVar = Box<dyn VarBoxed<T>>

Output of Var::actual_var.

type Downgrade = WeakContextualizedVar<T>

Output of Var::downgrade.

type Map<O: VarValue> = ContextualizedVar<O>

Output of Var::map.

type MapBidi<O: VarValue> = ContextualizedVar<O>

Output of Var::map_bidi.

type FlatMap<O: VarValue, V: Var<O>> = ContextualizedVar<O>

Output of Var::flat_map.

type FilterMap<O: VarValue> = ContextualizedVar<O>

Output of Var::filter_map.

type FilterMapBidi<O: VarValue> = ContextualizedVar<O>

Output of Var::filter_map_bidi.

type MapRef<O: VarValue> = MapRef<T, O, ContextualizedVar<T>>

Output of Var::map_ref.

type MapRefBidi<O: VarValue> = MapRefBidi<T, O, ContextualizedVar<T>>

Output of Var::map_ref_bidi.

type Easing = ContextualizedVar<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 actual_var(self) -> <ContextualizedVar<T> as Var<T>>::ActualVar

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

fn downgrade(&self) -> <ContextualizedVar<T> as Var<T>>::Downgrade

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) -> <ContextualizedVar<T> as Var<T>>::ReadOnly

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

fn map<O, M>(&self, map: M) -> <ContextualizedVar<T> as Var<T>>::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, ) -> <ContextualizedVar<T> as Var<T>>::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, ) -> <ContextualizedVar<T> as Var<T>>::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, ) -> <ContextualizedVar<T> as Var<T>>::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, ) -> <ContextualizedVar<T> as Var<T>>::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) -> <ContextualizedVar<T> as Var<T>>::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, ) -> <ContextualizedVar<T> as Var<T>>::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, ) -> <ContextualizedVar<T> as Var<T>>::Easing

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

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

fn easing_with<F, SE>( &self, duration: Duration, easing: F, sampler: SE, ) -> <ContextualizedVar<T> as Var<T>>::Easing

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

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

fn boxed(self) -> Box<dyn VarBoxed<T>>

where Self: Sized,

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

fn boxed_any(self) -> Box<dyn AnyVar>

where Self: Sized,

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

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) -> Factor + 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.