Type Alias ResponseVar

pub type ResponseVar<T> = ReadOnlyVar<Response<T>, ArcVar<Response<T>>>;

Variable used to listen to a one time signal that an async operation has completed.

Use response_var or response_done_var to init.

Aliased Type

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

Implementations

impl<T: VarValue> ResponseVar<T>

pub fn with_rsp<R>(&self, read: impl FnOnce(&T) -> R) -> Option<R>

Visit the response, if present.

pub fn with_new_rsp<R>(&self, read: impl FnOnce(&T) -> R) -> Option<R>

Visit the response, if present and new.

pub fn is_done(&self) -> bool

If the response is received.

pub fn is_waiting(&self) -> bool

If the response is not received yet.

pub fn rsp(&self) -> Option<T>

Clone the response value, if present.

pub async fn wait_rsp(&self) -> T

Returns a future that awaits until a response is received and then returns a clone.

pub async fn wait_into_rsp(self) -> T

Returns a future that awaits until a response is received and then returns it.

Will clone the value if the variable is shared.

Note that ResponseVar<T> implements IntoFuture so you can also just .await the variable.

pub async fn wait_done(&self)

Returns a future that awaits until a response is received.

pub fn rsp_new(&self) -> Option<T>

Clone the response, if present and new.

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

Into response, if received.

Clones if the variable is has more than one strong reference.

pub fn map_rsp<O, I, M>(&self, waiting_value: I, map: M) -> impl Var<O>

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

Map the response value using map, if the variable is awaiting a response uses the waiting_value first.

pub fn map_response<O, M>(&self, map: M) -> ResponseVar<O>

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

Map to another response variable.

Trait Implementations

impl<T: VarValue> IntoFuture for ResponseVar<T>

type Output = T

The output that the future will produce on completion.

type IntoFuture = Pin<Box<dyn Future<Output = T> + Send + Sync>>

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.

impl<T: VarValue, V: Var<T>> AnyVar for ReadOnlyVar<T, V>

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, _: 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, V: Var<T>> Clone for ReadOnlyVar<T, V>

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, V: Var<T>> IntoVar<T> for ReadOnlyVar<T, V>

type Var = ReadOnlyVar<T, V>

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, V: Var<T>> Var<T> for ReadOnlyVar<T, V>

type ReadOnly = ReadOnlyVar<T, V>

Output of Var::read_only.

type ActualVar = <<V as Var<T>>::ActualVar as Var<T>>::ReadOnly

Output of Var::actual_var.

type Downgrade = WeakReadOnlyVar<T, <V as Var<T>>::Downgrade>

Output of Var::downgrade.

type Map<O: VarValue> = <V as Var<T>>::Map<O>

Output of Var::map.

type MapBidi<O: VarValue> = <V as Var<T>>::Map<O>

Output of Var::map_bidi.

type FlatMap<O: VarValue, VF: Var<O>> = <V as Var<T>>::FlatMap<O, VF>

Output of Var::flat_map.

type FilterMap<O: VarValue> = <V as Var<T>>::FilterMap<O>

Output of Var::filter_map.

type FilterMapBidi<O: VarValue> = <V as Var<T>>::FilterMap<O>

Output of Var::filter_map_bidi.

type MapRef<O: VarValue> = <V as Var<T>>::MapRef<O>

Output of Var::map_ref.

type MapRefBidi<O: VarValue> = <V as Var<T>>::MapRef<O>

Output of Var::map_ref_bidi.

type Easing = <<V as Var<T>>::Easing as Var<T>>::ReadOnly

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, _: F) -> Result<(), VarIsReadOnlyError>

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

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

fn boxed(self) -> BoxedVar<T>

where Self: Sized,

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

fn actual_var(self) -> Self::ActualVar

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

fn downgrade(&self) -> Self::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) -> 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, _: 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, VF, M>(&self, map: M) -> Self::FlatMap<O, VF>

where O: VarValue, VF: Var<O>, M: FnMut(&T) -> VF + 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, _: 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, _: 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 boxed_any(self) -> BoxedAnyVar

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_txt(&self) -> Txt

where T: Display,

Gets the value as a display Txt.

fn get_string(&self) -> String

where T: Display,

Gets the value as a display String.

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 map_to_txt(&self) -> Self::Map<Txt>

where T: ToTxt,

Creates a map that converts from T to Txt using ToTxt.

fn map_to_string(&self) -> Self::Map<String>

where T: ToString,

Create a map that converts from T to String using ToString.

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 filter_parse<O, I>(&self, fallback: I) -> Self::FilterMap<O>

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

Create a filter_map that tries to convert from T to O using FromStr.

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 set_ease<S, E, F>( &self, start_value: S, end_value: E, duration: Duration, easing: F, ) -> AnimationHandle

where T: Transitionable, S: Into<T>, E: Into<T>, F: Fn(EasingTime) -> EasingStep + Send + 'static,

Schedule an easing transition from the start_value to end_value.

fn set_ease_oci<S, E, F>( &self, start_value: S, end_value: E, duration: Duration, easing: F, ) -> AnimationHandle

where T: Transitionable, S: Into<T>, E: Into<T>, F: Fn(EasingTime) -> EasingStep + Send + 'static,

Oscillate between start_value to end_value with an easing transition.

fn set_ease_with<S, E, F, Sa>( &self, start_value: S, end_value: E, duration: Duration, easing: F, sampler: Sa, ) -> AnimationHandle

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

Schedule an easing transition from the start_value to end_value using a custom value sampler.

fn set_ease_oci_with<S, E, F, Sa>( &self, start_value: S, end_value: E, duration: Duration, easing: F, sampler: Sa, ) -> AnimationHandle

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

Oscillate between start_value to end_value with an easing transition using a custom value sampler.

fn ease<E, F>( &self, new_value: E, duration: Duration, easing: F, ) -> AnimationHandle

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

Schedule an easing transition from the current value to new_value.

fn ease_oci<E, F>( &self, new_value: E, duration: Duration, easing: F, ) -> AnimationHandle

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

Oscillate between the current value and new_value with an easing transition.

fn ease_with<E, F, S>( &self, new_value: E, duration: Duration, easing: F, sampler: S, ) -> AnimationHandle

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

Schedule an easing transition from the current value to new_value using a custom value sampler.

fn ease_oci_with<E, F, S>( &self, new_value: E, duration: Duration, easing: F, sampler: S, ) -> AnimationHandle

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

Oscillate between the current value and new_value with an easing transition and a custom value sampler.

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

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

Schedule a keyframed transition animation for the variable, starting from the first key.

fn set_ease_keyed_with<F, S>( &self, keys: Vec<(Factor, T)>, duration: Duration, easing: F, sampler: S, ) -> AnimationHandle

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

Schedule a keyframed transition animation for the variable, starting from the first key, using a custom value sampler.

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

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

Schedule a keyframed transition animation for the variable, starting from the current value.

fn ease_keyed_with<F, S>( &self, keys: Vec<(Factor, T)>, duration: Duration, easing: F, sampler: S, ) -> AnimationHandle

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

Schedule a keyframed transition animation for the variable, starting from the current value, using a custom value sampler.

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 chase<N, F>( &self, first_target: N, duration: Duration, easing: F, ) -> ChaseAnimation<T>

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

Starts an easing animation that chases a target value that can be changed using the ChaseAnimation<T> handle.

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

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

fn display(&self) -> VarDisplay<'_, T, Self>

where T: Display,

Returns a wrapper that implements fmt::Display 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.