Struct WriteableReactiveValue 

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

Reactive value that is explicitly set, rather than being derived from a stream.

Examples

use epoxy_streams::ReactiveValue;

let writeable_value = ReactiveValue::new(5);
assert_eq!(*writeable_value.get(), 5);

writeable_value.set(50);
assert_eq!(*writeable_value.get(), 50);

Implementations

impl<T> WriteableReactiveValue<T>

where T: 'static,

pub fn set(&self, value: T)

Sets the value of the ReactiveValue, using a mutex to ensure thread safety.

Note: use set_rc if your new value is already an Arc, as this will prevent the value from being unnecessarily copied.

Examples found in repository

examples/reactive_scores.rs (line 30)

fn main() {
    let player_1_points = epoxy::ReactiveValue::new(4);
    let player_1_multiplier = epoxy::ReactiveValue::new(1.0_f32);

    let player_2_points = epoxy::ReactiveValue::new(5);
    let player_2_multiplier = epoxy::ReactiveValue::new(1.0_f32);

    let player_1_score = computed!(*player_1_points as f32 * player_1_multiplier);
    let player_2_score = computed!(*player_2_points as f32 * player_2_multiplier);

    let winner = computed! {
        if (player_1_score == player_2_score) {
            "Tie"
        } else if (player_1_score > player_2_score) {
            "Player 1"
        } else {
            "Player 2"
        }
    };

    assert_eq!(*player_1_score.get(), 4_f32);
    assert_eq!(*player_2_score.get(), 5_f32);
    assert_eq!(*winner.get(), "Player 2");

    player_1_multiplier.set(2.5_f32);

    assert_eq!(*player_1_score.get(), 10_f32);
    assert_eq!(*player_2_score.get(), 5_f32);
    assert_eq!(*winner.get(), "Player 1");

    player_2_points.set(9);

    assert_eq!(*player_1_score.get(), 10_f32);
    assert_eq!(*player_2_score.get(), 9_f32);
    assert_eq!(*winner.get(), "Player 1");

    player_2_points.set(10);

    assert_eq!(*player_1_score.get(), 10_f32);
    assert_eq!(*player_2_score.get(), 10_f32);
    assert_eq!(*winner.get(), "Tie");
}

pub fn set_rc(&self, value: Arc<T>)

Sets the value of the ReactiveValue, using a mutex to ensure thread safety.

pub fn as_readonly(&self) -> ReadonlyReactiveValue<T>

Returns a ReadonlyReactiveValue whose value matches this one. This is helpful when exposing ReactiveValues to public APIs, so that the consumer cannot alter the state of your component.

Trait Implementations

impl<T> Clone for WriteableReactiveValue<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> ReactiveValue<T> for WriteableReactiveValue<T>

fn as_stream(&self) -> Stream<T>

Returns a Stream that represents the changing value over time. Use this function to subscribe to changes in the ReactiveValue.ReadonlyReactiveValue

fn get(&self) -> Arc<T>

Returns the current value of the ReactiveValue.