Struct suzy::watch::Watched

pub struct Watched<T> where
    T: ?Sized,  { /* fields omitted */ }

This represents some value which will be interesting to watch. Watcher functions that reference this value will be re-run when this value changes.

Implementations

impl<T> Watched<T>

pub fn new(value: T) -> Watched<T>

Create a new watched value.

pub fn into_inner(self) -> T

Consumes the Watched, returning the wrapped value

pub fn replace(&mut self, value: T) -> T

Replaces the wrapped value with a new one, returning the old value, without deinitializing either one.

impl<T> Watched<T> where
    T: ?Sized, 

pub fn get_unwatched(this: &Watched<T>) -> &T

Get a referenced to the wrapped value, without binding the current watch closure.

impl<T> Watched<T> where
    T: Default, 

pub fn take(&mut self) -> T

Takes the wrapped value, leaving Default::default() in its place.

impl<T> Watched<T> where
    T: PartialEq<T>, 

pub fn set_if_neq(wrapper: &mut Watched<T>, value: T)

This function provides a way to set a value for a watched value only if is has changed. This is useful for cases where setting a value would otherwise cause an infinite loop.

Examples

The following example uses the watch system to keep two variables in sync. This would normally cause an infinite loop as each update of one would cause the other one to re-evaluate. However using set_if_neq allows it to detect that the value is the same and stop propogating.

#[derive(Default)]
struct KeepBalanced {
    left: Watched<i32>,
    right: Watched<i32>,
}
impl WatcherInit for KeepBalanced {
    fn init(watcher: &mut WatcherMeta<Self>) {
        watcher.watch(|root| {
            Watched::set_if_neq(&mut root.left, *root.right);
        });
        watcher.watch(|root| {
            Watched::set_if_neq(&mut root.right, *root.left);
        });
    }
}
fn main() {
    let mut ctx = WatchContext::new();
    ctx.set_frame_limit(Some(100));
    ctx.with(|| {
        let obj = WatchContext::allow_watcher_access((), |()| {
            let mut obj = Watcher::<KeepBalanced>::new();
            *obj.data_mut().left = 68;
            obj
        });
        WatchContext::update_current();
        WatchContext::allow_watcher_access(obj, |obj| {
            assert_eq!(*obj.data().right, 68);
        });
    });
}

Trait Implementations

impl<'a, T, U> Add<U> for &'a Watched<T> where
    T: ?Sized,
    &'a T: Add<U>, 

type Output = <&'a T as Add<U>>::Output

The resulting type after applying the + operator.

pub fn add(self, other: U) -> <&'a T as Add<U>>::Output

Performs the + operation.

impl<T, U> Add<U> for Watched<T> where
    T: Add<U>, 

type Output = <T as Add<U>>::Output

The resulting type after applying the + operator.

pub fn add(self, other: U) -> <T as Add<U>>::Output

Performs the + operation.

impl<T, U> AddAssign<U> for Watched<T> where
    T: AddAssign<U> + ?Sized, 

pub fn add_assign(&mut self, rhs: U)

Performs the += operation.

impl<'a, T, U> BitAnd<U> for &'a Watched<T> where
    T: ?Sized,
    &'a T: BitAnd<U>, 

type Output = <&'a T as BitAnd<U>>::Output

The resulting type after applying the & operator.

pub fn bitand(self, other: U) -> <&'a T as BitAnd<U>>::Output

Performs the & operation.

impl<T, U> BitAnd<U> for Watched<T> where
    T: BitAnd<U>, 

type Output = <T as BitAnd<U>>::Output

The resulting type after applying the & operator.

pub fn bitand(self, other: U) -> <T as BitAnd<U>>::Output

Performs the & operation.

impl<T, U> BitAndAssign<U> for Watched<T> where
    T: BitAndAssign<U> + ?Sized, 

pub fn bitand_assign(&mut self, rhs: U)

Performs the &= operation.

impl<T, U> BitOr<U> for Watched<T> where
    T: BitOr<U>, 

type Output = <T as BitOr<U>>::Output

The resulting type after applying the | operator.

pub fn bitor(self, other: U) -> <T as BitOr<U>>::Output

Performs the | operation.

impl<'a, T, U> BitOr<U> for &'a Watched<T> where
    T: ?Sized,
    &'a T: BitOr<U>, 

type Output = <&'a T as BitOr<U>>::Output

The resulting type after applying the | operator.

pub fn bitor(self, other: U) -> <&'a T as BitOr<U>>::Output

Performs the | operation.

impl<T, U> BitOrAssign<U> for Watched<T> where
    T: BitOrAssign<U> + ?Sized, 

pub fn bitor_assign(&mut self, rhs: U)

Performs the |= operation.

impl<T, U> BitXor<U> for Watched<T> where
    T: BitXor<U>, 

type Output = <T as BitXor<U>>::Output

The resulting type after applying the ^ operator.

pub fn bitxor(self, other: U) -> <T as BitXor<U>>::Output

Performs the ^ operation.

impl<'a, T, U> BitXor<U> for &'a Watched<T> where
    T: ?Sized,
    &'a T: BitXor<U>, 

type Output = <&'a T as BitXor<U>>::Output

The resulting type after applying the ^ operator.

pub fn bitxor(self, other: U) -> <&'a T as BitXor<U>>::Output

Performs the ^ operation.

impl<T, U> BitXorAssign<U> for Watched<T> where
    T: BitXorAssign<U> + ?Sized, 

pub fn bitxor_assign(&mut self, rhs: U)

Performs the ^= operation.

impl<T> Clone for Watched<T> where
    T: Clone, 

pub fn clone(&self) -> Watched<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Watched<T> where
    T: Debug + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<T> Default for Watched<T> where
    T: Default, 

pub fn default() -> Watched<T>

Returns the “default value” for a type.

impl<T> Deref for Watched<T> where
    T: ?Sized, 

type Target = T

The resulting type after dereferencing.

pub fn deref(&self) -> &T

Dereferences the value.

impl<T> DerefMut for Watched<T> where
    T: ?Sized, 

pub fn deref_mut(&mut self) -> &mut T

Mutably dereferences the value.

impl<T> Display for Watched<T> where
    T: Display + ?Sized, 

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'a, T, U> Div<U> for &'a Watched<T> where
    T: ?Sized,
    &'a T: Div<U>, 

type Output = <&'a T as Div<U>>::Output

The resulting type after applying the / operator.

pub fn div(self, other: U) -> <&'a T as Div<U>>::Output

Performs the / operation.

impl<T, U> Div<U> for Watched<T> where
    T: Div<U>, 

type Output = <T as Div<U>>::Output

The resulting type after applying the / operator.

pub fn div(self, other: U) -> <T as Div<U>>::Output

Performs the / operation.

impl<T, U> DivAssign<U> for Watched<T> where
    T: DivAssign<U> + ?Sized, 

pub fn div_assign(&mut self, rhs: U)

Performs the /= operation.

impl<T, U> Mul<U> for Watched<T> where
    T: Mul<U>, 

type Output = <T as Mul<U>>::Output

The resulting type after applying the * operator.

pub fn mul(self, other: U) -> <T as Mul<U>>::Output

Performs the * operation.

impl<'a, T, U> Mul<U> for &'a Watched<T> where
    T: ?Sized,
    &'a T: Mul<U>, 

type Output = <&'a T as Mul<U>>::Output

The resulting type after applying the * operator.

pub fn mul(self, other: U) -> <&'a T as Mul<U>>::Output

Performs the * operation.

impl<T, U> MulAssign<U> for Watched<T> where
    T: MulAssign<U> + ?Sized, 

pub fn mul_assign(&mut self, rhs: U)

Performs the *= operation.

impl<'a, T> Neg for &'a Watched<T> where
    T: ?Sized,
    &'a T: Neg, 

type Output = <&'a T as Neg>::Output

The resulting type after applying the - operator.

pub fn neg(self) -> <&'a T as Neg>::Output

Performs the unary - operation.

impl<T> Neg for Watched<T> where
    T: Neg, 

type Output = <T as Neg>::Output

The resulting type after applying the - operator.

pub fn neg(self) -> <T as Neg>::Output

Performs the unary - operation.

impl<'a, T> Not for &'a Watched<T> where
    T: ?Sized,
    &'a T: Not, 

type Output = <&'a T as Not>::Output

The resulting type after applying the ! operator.

pub fn not(self) -> <&'a T as Not>::Output

Performs the unary ! operation.

impl<T> Not for Watched<T> where
    T: Not, 

type Output = <T as Not>::Output

The resulting type after applying the ! operator.

pub fn not(self) -> <T as Not>::Output

Performs the unary ! operation.

impl<T, U> PartialEq<U> for Watched<T> where
    T: PartialEq<U> + ?Sized,
    U: ?Sized, 

pub fn eq(&self, other: &U) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl<T, U> PartialOrd<U> for Watched<T> where
    T: PartialOrd<U> + ?Sized,
    U: ?Sized, 

pub fn partial_cmp(&self, other: &U) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

pub fn lt(&self, other: &U) -> bool

This method tests less than (for self and other) and is used by the < operator.

pub fn le(&self, other: &U) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

pub fn ge(&self, other: &U) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

pub fn gt(&self, other: &U) -> bool

This method tests greater than (for self and other) and is used by the > operator.

impl<T, U> Rem<U> for Watched<T> where
    T: Rem<U>, 

type Output = <T as Rem<U>>::Output

The resulting type after applying the % operator.

pub fn rem(self, other: U) -> <T as Rem<U>>::Output

Performs the % operation.

impl<'a, T, U> Rem<U> for &'a Watched<T> where
    T: ?Sized,
    &'a T: Rem<U>, 

type Output = <&'a T as Rem<U>>::Output

The resulting type after applying the % operator.

pub fn rem(self, other: U) -> <&'a T as Rem<U>>::Output

Performs the % operation.

impl<T, U> RemAssign<U> for Watched<T> where
    T: RemAssign<U> + ?Sized, 

pub fn rem_assign(&mut self, rhs: U)

Performs the %= operation.

impl<T, U> Shl<U> for Watched<T> where
    T: Shl<U>, 

type Output = <T as Shl<U>>::Output

The resulting type after applying the << operator.

pub fn shl(self, other: U) -> <T as Shl<U>>::Output

Performs the << operation.

impl<'a, T, U> Shl<U> for &'a Watched<T> where
    T: ?Sized,
    &'a T: Shl<U>, 

type Output = <&'a T as Shl<U>>::Output

The resulting type after applying the << operator.

pub fn shl(self, other: U) -> <&'a T as Shl<U>>::Output

Performs the << operation.

impl<T, U> ShlAssign<U> for Watched<T> where
    T: ShlAssign<U> + ?Sized, 

pub fn shl_assign(&mut self, rhs: U)

Performs the <<= operation.

impl<T, U> Shr<U> for Watched<T> where
    T: Shr<U>, 

type Output = <T as Shr<U>>::Output

The resulting type after applying the >> operator.

pub fn shr(self, other: U) -> <T as Shr<U>>::Output

Performs the >> operation.

impl<'a, T, U> Shr<U> for &'a Watched<T> where
    T: ?Sized,
    &'a T: Shr<U>, 

type Output = <&'a T as Shr<U>>::Output

The resulting type after applying the >> operator.

pub fn shr(self, other: U) -> <&'a T as Shr<U>>::Output

Performs the >> operation.

impl<T, U> ShrAssign<U> for Watched<T> where
    T: ShrAssign<U> + ?Sized, 

pub fn shr_assign(&mut self, rhs: U)

Performs the >>= operation.

impl<T, U> Sub<U> for Watched<T> where
    T: Sub<U>, 

type Output = <T as Sub<U>>::Output

The resulting type after applying the - operator.

pub fn sub(self, other: U) -> <T as Sub<U>>::Output

Performs the - operation.

impl<'a, T, U> Sub<U> for &'a Watched<T> where
    T: ?Sized,
    &'a T: Sub<U>, 

type Output = <&'a T as Sub<U>>::Output

The resulting type after applying the - operator.

pub fn sub(self, other: U) -> <&'a T as Sub<U>>::Output

Performs the - operation.

impl<T, U> SubAssign<U> for Watched<T> where
    T: SubAssign<U> + ?Sized, 

pub fn sub_assign(&mut self, rhs: U)

Performs the -= operation.