Type Alias freya::prelude::SyncSignal

pub type SyncSignal<T> = Signal<T, SyncStorage>;

A signal that can safely shared between threads.

Aliased Type

struct SyncSignal<T> { /* private fields */ }

Implementations

impl<T, S> Signal<T, S>where T: 'static, S: Storage<SignalData<T>>,

pub fn new_maybe_sync(value: T) -> Signal<T, S>

Creates a new Signal. Signals are a Copy state management solution with automatic dependency tracking.

pub fn new_maybe_sync_in_scope(value: T, owner: ScopeId) -> Signal<T, S>

Create a new signal with a custom owner scope. The signal will be dropped when the owner scope is dropped instead of the current scope.

pub fn origin_scope(&self) -> ScopeId

Get the scope the signal was created in.

pub fn map<O>( self, f: impl Fn(&T) -> &O + 'static ) -> MappedSignal<<S as AnyStorage>::Ref<O>>

Map the signal to a new type.

pub fn id(&self) -> GenerationalBoxId

Get the generational id of the signal.

Trait Implementations

impl<T, S> Writable<T> for Signal<T, S>where T: 'static, S: Storage<SignalData<T>>,

type Mut<R: 'static + ?Sized> = Write<R, S>

The type of the reference.

fn map_mut<I, U, F>( ref_: <Signal<T, S> as Writable<T>>::Mut<I>, f: F ) -> <Signal<T, S> as Writable<T>>::Mut<U>where U: 'static + ?Sized, F: FnOnce(&mut I) -> &mut U,

Map the reference to a new type.

fn try_map_mut<I, U, F>( ref_: <Signal<T, S> as Writable<T>>::Mut<I>, f: F ) -> Option<<Signal<T, S> as Writable<T>>::Mut<U>>where I: 'static, U: 'static + ?Sized, F: FnOnce(&mut I) -> Option<&mut U>,

Try to map the reference to a new type.

fn try_write( &self ) -> Result<<Signal<T, S> as Writable<T>>::Mut<T>, BorrowMutError>

Try to get a mutable reference to the value. If the value has been dropped, this will panic.

fn write(&self) -> Self::Mut<T>

Get a mutable reference to the value. If the value has been dropped, this will panic.

fn with_mut<O>(&self, f: impl FnOnce(&mut T) -> O) -> O

Run a function with a mutable reference to the value. If the value has been dropped, this will panic.

fn set(&mut self, value: T)

Set the value of the signal. This will trigger an update on all subscribers.

fn index_mut<I>(&self, index: I) -> Self::Mut<<T as Index<I>>::Output>where T: IndexMut<I>,

Index into the inner value and return a reference to the result.

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

Replace the value in the Signal, returning the old value.

impl<T, S> Clone for Signal<T, S>where T: 'static, S: Storage<SignalData<T>>,

fn clone(&self) -> Signal<T, S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, S> Default for Signal<T, S>where T: Default + 'static, S: Storage<SignalData<T>>,

fn default() -> Signal<T, S>

Returns the “default value” for a type.

impl<T, S> AddAssign<T> for Signal<T, S>where T: Add<Output = T> + Copy + 'static, S: Storage<SignalData<T>>,

fn add_assign(&mut self, rhs: T)

Performs the += operation.

impl<T, S> DivAssign<T> for Signal<T, S>where T: Div<Output = T> + Copy + 'static, S: Storage<SignalData<T>>,

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<T, S> Deref for Signal<T, S>where T: Clone, S: Storage<SignalData<T>> + 'static,

Allow calling a signal with signal() syntax

Currently only limited to copy types, though could probably specialize for string/arc/rc

type Target = dyn Fn() -> T

The resulting type after dereferencing.

fn deref(&self) -> &<Signal<T, S> as Deref>::Target

Dereferences the value.

impl<T, S> MulAssign<T> for Signal<T, S>where T: Mul<Output = T> + Copy + 'static, S: Storage<SignalData<T>>,

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T, S> Display for Signal<T, S>where T: Display + 'static, S: Storage<SignalData<T>>,

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

Formats the value using the given formatter.

impl<T, S> PartialEq for Signal<T, S>where T: 'static, S: Storage<SignalData<T>>,

fn eq(&self, other: &Signal<T, S>) -> bool

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

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

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

impl<T, S> PartialEq<T> for Signal<T, S>where T: PartialEq + 'static, S: Storage<SignalData<T>>,

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

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

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

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

impl<T, S> Div<T> for Signal<T, S>where T: Div<Output = T> + Copy + 'static, S: Storage<SignalData<T>>,

type Output = T

The resulting type after applying the / operator.

fn div(self, rhs: T) -> <Signal<T, S> as Div<T>>::Output

Performs the / operation.

impl<T, S> Readable<T> for Signal<T, S>where S: Storage<SignalData<T>>,

fn read(&self) -> <S as AnyStorage>::Ref<T>

Get the current value of the signal. This will subscribe the current scope to the signal. If you would like to read the signal without subscribing to it, you can use Self::peek instead.

If the signal has been dropped, this will panic.

fn peek(&self) -> <S as AnyStorage>::Ref<T>

Get the current value of the signal. Unlike read, this will not subscribe the current scope to the signal which can cause parts of your UI to not update.

If the signal has been dropped, this will panic.

type Ref<R: 'static + ?Sized> = <S as AnyStorage>::Ref<R>

The type of the reference.

fn map_ref<I, U, F>( ref_: <Signal<T, S> as Readable<T>>::Ref<I>, f: F ) -> <Signal<T, S> as Readable<T>>::Ref<U>where F: FnOnce(&I) -> &U, U: ?Sized,

Map the reference to a new type.

fn try_map_ref<I, U, F>( ref_: <Signal<T, S> as Readable<T>>::Ref<I>, f: F ) -> Option<<Signal<T, S> as Readable<T>>::Ref<U>>where F: FnOnce(&I) -> Option<&U>, U: ?Sized,

Try to map the reference to a new type.

fn with<O>(&self, f: impl FnOnce(&T) -> O) -> O

Run a function with a reference to the value. If the value has been dropped, this will panic.

fn with_peek<O>(&self, f: impl FnOnce(&T) -> O) -> O

Run a function with a reference to the value. If the value has been dropped, this will panic.

fn index<I>(&self, index: I) -> Self::Ref<<T as Index<I>>::Output>where T: Index<I>,

Index into the inner value and return a reference to the result. If the value has been dropped or the index is invalid, this will panic.

impl<T, S> Debug for Signal<T, S>where T: Debug + 'static, S: Storage<SignalData<T>>,

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

Formats the value using the given formatter.

impl<T, S> SubAssign<T> for Signal<T, S>where T: Sub<Output = T> + Copy + 'static, S: Storage<SignalData<T>>,

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.

impl<T, S> Sub<T> for Signal<T, S>where T: Sub<Output = T> + Copy + 'static, S: Storage<SignalData<T>>,

type Output = T

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> <Signal<T, S> as Sub<T>>::Output

Performs the - operation.

impl<T, S> Mul<T> for Signal<T, S>where T: Mul<Output = T> + Copy + 'static, S: Storage<SignalData<T>>,

type Output = T

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> <Signal<T, S> as Mul<T>>::Output

Performs the * operation.

impl<T, S> Copy for Signal<T, S>where T: 'static, S: Storage<SignalData<T>>,

impl<T, S> Add<T> for Signal<T, S>where T: Add<Output = T> + Copy + 'static, S: Storage<SignalData<T>>,

type Output = T

The resulting type after applying the + operator.

fn add(self, rhs: T) -> <Signal<T, S> as Add<T>>::Output

Performs the + operation.