Struct freya::prelude::CopyValue

pub struct CopyValue<T, S = UnsyncStorage>where
    T: 'static,
    S: Storage<T>,{ /* private fields */ }

CopyValue is a wrapper around a value to make the value mutable and Copy.

It is internally backed by [generational_box::GenerationalBox].

Implementations

impl<T> CopyValue<T>where T: 'static,

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

Create a new CopyValue. The value will be stored in the current component.

Once the component this value is created in is dropped, the value will be dropped.

pub fn new_in_scope(value: T, scope: ScopeId) -> CopyValue<T>

Create a new CopyValue. The value will be stored in the given scope. When the specified scope is dropped, the value will be dropped.

impl<T, S> CopyValue<T, S>where T: 'static, S: Storage<T>,

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

Create a new CopyValue. The value will be stored in the current component.

Once the component this value is created in is dropped, the value will be dropped.

pub fn new_maybe_sync_in_scope(value: T, scope: ScopeId) -> CopyValue<T, S>

Create a new CopyValue. The value will be stored in the given scope. When the specified scope is dropped, the value will be dropped.

pub fn take(&self) -> T

Take the value out of the CopyValue, invalidating the value in the process.

pub fn origin_scope(&self) -> ScopeId

Get the scope this value was created in.

pub fn id(&self) -> GenerationalBoxId

Get the generational id of the value.

Trait Implementations

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

type Output = T

The resulting type after applying the + operator.

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

Performs the + operation.

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

fn add_assign(&mut self, rhs: T)

Performs the += operation.

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

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

Returns the “default value” for a type.

impl<T, S> Deref for CopyValue<T, S>where T: Copy, S: Storage<T>,

type Target = dyn Fn() -> T

The resulting type after dereferencing.

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

Dereferences the value.

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

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

Formats the value using the given formatter.

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

type Output = T

The resulting type after applying the / operator.

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

Performs the / operation.

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

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

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

type Output = T

The resulting type after applying the * operator.

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

Performs the * operation.

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

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T, S> PartialEq<T> for CopyValue<T, S>where T: PartialEq + 'static, S: Storage<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> PartialEq for CopyValue<T, S>where T: 'static, S: Storage<T>,

fn eq(&self, other: &CopyValue<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> Readable<T> for CopyValue<T, S>where T: 'static, S: Storage<T>,

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

The type of the reference.

fn map_ref<I, U, F>( ref_: <CopyValue<T, S> as Readable<T>>::Ref<I>, f: F ) -> <CopyValue<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_: <CopyValue<T, S> as Readable<T>>::Ref<I>, f: F ) -> Option<<CopyValue<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 try_read(&self) -> Result<<S as AnyStorage>::Ref<T>, BorrowError>

Try to get the current value of the state. If this is a signal, this will subscribe the current scope to the signal. If the value has been dropped, this will panic.

fn peek(&self) -> <CopyValue<T, S> as Readable<T>>::Ref<T>

Get the current value of the state without subscribing to updates. If the value has been dropped, this will panic.

fn read(&self) -> Self::Ref<T>

Get the current value of the state. If this is a signal, this will subscribe the current scope to the signal. If the value has been dropped, this will panic.

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> Sub<T> for CopyValue<T, S>where T: Sub<Output = T> + Copy + 'static, S: Storage<T>,

type Output = T

The resulting type after applying the - operator.

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

Performs the - operation.

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

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.

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

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

The type of the reference.

fn map_mut<I, U, F>( mut_: <CopyValue<T, S> as Writable<T>>::Mut<I>, f: F ) -> <CopyValue<T, S> as Writable<T>>::Mut<U>where F: FnOnce(&mut I) -> &mut U, U: ?Sized,

Map the reference to a new type.

fn try_map_mut<I, U, F>( mut_: <CopyValue<T, S> as Writable<T>>::Mut<I>, f: F ) -> Option<<CopyValue<T, S> as Writable<T>>::Mut<U>>where F: FnOnce(&mut I) -> Option<&mut U>, U: ?Sized,

Try to map the reference to a new type.

fn try_write( &self ) -> Result<<CopyValue<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(&mut self) -> <CopyValue<T, S> as Writable<T>>::Mut<T>

Get 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 with_mut<O>(&mut 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 index_mut<I>(&mut 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(&mut self, value: T) -> T

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

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

impl<T, S> Eq for CopyValue<T, S>where T: 'static, S: Storage<T>,