Struct MappedMutSignal

pub struct MappedMutSignal<O: ?Sized, V, F = fn(&<V as Readable>::Target) -> &O, FMut = fn(&mut <V as Readable>::Target) -> &mut O> { /* private fields */ }

A read only signal that has been mapped to a new type.

Implementations

impl<V, O, F, FMut> MappedMutSignal<O, V, F, FMut>

where O: ?Sized,

pub fn new(value: V, map_fn: F, map_fn_mut: FMut) -> Self

Create a new mapped signal.

Trait Implementations

impl<T: Add<Output = T> + Copy + 'static, V, F, FMut> Add<T> for MappedMutSignal<T, V, F, FMut>

where V: Writable<Target: 'static>, F: Fn(&V::Target) -> &T, FMut: Fn(&mut V::Target) -> &mut T,

type Output = T

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Self::Output

Performs the + operation.

impl<T: Add<Output = T> + Copy + 'static, V, F, FMut> AddAssign<T> for MappedMutSignal<T, V, F, FMut>

where V: Writable<Target: 'static>, F: Fn(&V::Target) -> &T, FMut: Fn(&mut V::Target) -> &mut T,

fn add_assign(&mut self, rhs: T)

Performs the += operation.

impl<V, O, F, FMut> Clone for MappedMutSignal<O, V, F, FMut>

where V: Clone, F: Clone, FMut: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + 'static, V, F, FMut> Debug for MappedMutSignal<T, V, F, FMut>

where V: Readable<Target: 'static>, F: Fn(&V::Target) -> &T,

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

Formats the value using the given formatter.

impl<V, O, F, FMut> Deref for MappedMutSignal<O, V, F, FMut>

where O: Clone + 'static, V: Readable + 'static, V::Target: 'static, F: Fn(&V::Target) -> &O + 'static, FMut: 'static,

Allow calling a signal with signal() syntax

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

type Target = dyn Fn() -> O

The resulting type after dereferencing.

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

Dereferences the value.

impl<T: Display + 'static, V, F, FMut> Display for MappedMutSignal<T, V, F, FMut>

where V: Readable<Target: 'static>, F: Fn(&V::Target) -> &T,

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

Formats the value using the given formatter.

impl<T: Div<Output = T> + Copy + 'static, V, F, FMut> Div<T> for MappedMutSignal<T, V, F, FMut>

where V: Writable<Target: 'static>, F: Fn(&V::Target) -> &T, FMut: Fn(&mut V::Target) -> &mut T,

type Output = T

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Self::Output

Performs the / operation.

impl<T: Div<Output = T> + Copy + 'static, V, F, FMut> DivAssign<T> for MappedMutSignal<T, V, F, FMut>

where V: Writable<Target: 'static>, F: Fn(&V::Target) -> &T, FMut: Fn(&mut V::Target) -> &mut T,

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<V, O, F, FMut> From<MappedMutSignal<O, V, F, FMut>> for ReadSignal<O>

where O: ?Sized + 'static, V: Readable<Storage = UnsyncStorage> + 'static, F: Fn(&V::Target) -> &O + 'static, FMut: 'static,

fn from(value: MappedMutSignal<O, V, F, FMut>) -> Self

Converts to this type from the input type.

impl<V, O, F, FMut> From<MappedMutSignal<O, V, F, FMut>> for WriteSignal<O>

where O: ?Sized + 'static, V: Writable<Storage = UnsyncStorage> + 'static, F: Fn(&V::Target) -> &O + 'static, FMut: Fn(&mut V::Target) -> &mut O + 'static,

fn from(value: MappedMutSignal<O, V, F, FMut>) -> Self

Converts to this type from the input type.

impl<V, O, F, FMut> IntoAttributeValue for MappedMutSignal<O, V, F, FMut>

where O: Clone + IntoAttributeValue + 'static, V: Readable, V::Target: 'static, F: Fn(&V::Target) -> &O,

fn into_value(self) -> AttributeValue

Convert into an attribute value

impl<T: Mul<Output = T> + Copy + 'static, V, F, FMut> Mul<T> for MappedMutSignal<T, V, F, FMut>

where V: Writable<Target: 'static>, F: Fn(&V::Target) -> &T, FMut: Fn(&mut V::Target) -> &mut T,

type Output = T

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Self::Output

Performs the * operation.

impl<T: Mul<Output = T> + Copy + 'static, V, F, FMut> MulAssign<T> for MappedMutSignal<T, V, F, FMut>

where V: Writable<Target: 'static>, F: Fn(&V::Target) -> &T, FMut: Fn(&mut V::Target) -> &mut T,

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T: PartialEq + 'static, V, F, FMut> PartialEq<T> for MappedMutSignal<T, V, F, FMut>

where V: Readable<Target: 'static>, F: Fn(&V::Target) -> &T,

fn eq(&self, other: &T) -> 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<V, O, F, FMut> PartialEq for MappedMutSignal<O, V, F, FMut>

where O: ?Sized, V: Readable + PartialEq, F: PartialEq, FMut: PartialEq,

fn eq(&self, other: &Self) -> 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<V, O, F, FMut> Readable for MappedMutSignal<O, V, F, FMut>

where O: ?Sized, V: Readable, V::Target: 'static, F: Fn(&V::Target) -> &O,

type Target = O

The target type of the reference.

type Storage = <V as Readable>::Storage

The type of the storage this readable uses.

fn try_read_unchecked(&self) -> Result<ReadableRef<'static, Self>, BorrowError>

where O: 'static,

Try to get a reference to the value without checking the lifetime. This will subscribe the current scope to the signal.

fn try_peek_unchecked(&self) -> BorrowResult<ReadableRef<'static, Self>>

where O: 'static,

Try to peek the current value of the signal without subscribing to updates. If the value has been dropped, this will return an error.

fn subscribers(&self) -> Subscribers

where O: 'static,

Get the underlying subscriber list for this readable. This is used to track when the value changes and notify subscribers.

impl<T: Sub<Output = T> + Copy + 'static, V, F, FMut> Sub<T> for MappedMutSignal<T, V, F, FMut>

where V: Writable<Target: 'static>, F: Fn(&V::Target) -> &T, FMut: Fn(&mut V::Target) -> &mut T,

type Output = T

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Self::Output

Performs the - operation.

impl<T: Sub<Output = T> + Copy + 'static, V, F, FMut> SubAssign<T> for MappedMutSignal<T, V, F, FMut>

where V: Writable<Target: 'static>, F: Fn(&V::Target) -> &T, FMut: Fn(&mut V::Target) -> &mut T,

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.

impl<V, O, F, FMut> Writable for MappedMutSignal<O, V, F, FMut>

where O: ?Sized, V: Writable, V::Target: 'static, F: Fn(&V::Target) -> &O, FMut: Fn(&mut V::Target) -> &mut O,

type WriteMetadata = <V as Writable>::WriteMetadata

Additional data associated with the write reference.

fn try_write_unchecked( &self, ) -> Result<WritableRef<'static, Self>, BorrowMutError>

Try to get a mutable reference to the value without checking the lifetime. This will update any subscribers.

impl<V, O, F, FMut> Copy for MappedMutSignal<O, V, F, FMut>

where V: Copy, F: Copy, FMut: Copy,