Struct UseAnimation 

pub struct UseAnimation<Animated: AnimatedValue> { /* private fields */ }

Animate your elements. Use use_animation to use this.

Implementations

impl<Animated: AnimatedValue> UseAnimation<Animated>

pub fn get(&self) -> ReadRef<'static, Animated>

Get the animated value.

pub fn start(&mut self)

Runs the animation normally.

pub fn reverse(&mut self)

Runs the animation in reverse direction.

pub fn reset(&mut self)

Reset the animation with the initial state.

pub fn finish(&mut self)

Finish the animation with the final state.

pub fn is_running(&self) -> State<bool>

pub fn has_run_yet(&self) -> State<bool>

pub fn run(&self, direction: AnimDirection)

Run the animation with a given AnimDirection

Methods from Deref<Target = State<Animated>>

pub fn read(&self) -> <UnsyncStorage as AnyStorage>::Ref<'static, T>

Read the current value and subscribe the current component to changes.

When the state value changes, any component or hook that has called read() will re-render.

Example

let count = use_state(|| 0);
let current_value = count.read();

pub fn peek(&self) -> <UnsyncStorage as AnyStorage>::Ref<'static, T>

Read the current value without subscribing to changes.

This method provides access to the current state value without registering the current component as a subscriber. The component will not re-render if the state changes.

When to Use

Use peek() when you need to read the state value for a one-off operation where reactivity is not needed, such as:

• Comparisons for conditional updates
• Debugging/logging
• Initial value checks

Example

let count = use_state(|| 0);

// Check if count is zero without subscribing
if *count.peek() == 0 {
    println!("Count is still zero");
}

// For reactive reading, use `read()` instead:
let display_text = format!("Count: {}", count.read());

Performance Note

Prefer read() over peek() unless you specifically need non-reactive access.

pub fn write_unchecked(&self) -> <UnsyncStorage as AnyStorage>::Mut<'static, T>

Get a mutable reference without requiring a mutable borrow of the State.

This is an advanced method that allows writing to the state without having mutable access to the State itself. Use with caution as it bypasses Rust’s borrow checker guarantees.

Safety Considerations

This method should only be used when you cannot obtain a mutable reference to the State but still need to modify it. Prefer write() when possible.

Trait Implementations

impl<Animated: Clone + AnimatedValue> Clone for UseAnimation<Animated>

fn clone(&self) -> UseAnimation<Animated>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Animated: AnimatedValue> Deref for UseAnimation<Animated>

type Target = State<Animated>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<Animated: PartialEq + AnimatedValue> PartialEq for UseAnimation<Animated>

fn eq(&self, other: &UseAnimation<Animated>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: AnimatedValue> Copy for UseAnimation<T>

impl<Animated: AnimatedValue> StructuralPartialEq for UseAnimation<Animated>