Struct MappedMutSignal 

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

Available on crate feature prelude only.

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, ) -> MappedMutSignal<O, V, F, FMut>

Create a new mapped signal.

Trait Implementations

impl<T, V, F, FMut> Add<T> for MappedMutSignal<T, V, F, FMut>

where T: Add<Output = T> + Copy + 'static, V: Writable, <V as Readable>::Target: 'static, F: Fn(&<V as Readable>::Target) -> &T, FMut: Fn(&mut <V as Readable>::Target) -> &mut T,

type Output = T

The resulting type after applying the + operator.

fn add(self, rhs: T) -> <MappedMutSignal<T, V, F, FMut> as Add<T>>::Output

Performs the + operation.

impl<T, V, F, FMut> AddAssign<T> for MappedMutSignal<T, V, F, FMut>

where T: Add<Output = T> + Copy + 'static, V: Writable, <V as Readable>::Target: 'static, F: Fn(&<V as Readable>::Target) -> &T, FMut: Fn(&mut <V as Readable>::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) -> MappedMutSignal<O, V, F, FMut>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, V, F, FMut> Debug for MappedMutSignal<T, V, F, FMut>

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

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

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 as Readable>::Target: 'static, F: Fn(&<V as Readable>::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) -> &<MappedMutSignal<O, V, F, FMut> as Deref>::Target

Dereferences the value.

impl<T, V, F, FMut> Display for MappedMutSignal<T, V, F, FMut>

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

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

Formats the value using the given formatter.

impl<T, V, F, FMut> Div<T> for MappedMutSignal<T, V, F, FMut>

where T: Div<Output = T> + Copy + 'static, V: Writable, <V as Readable>::Target: 'static, F: Fn(&<V as Readable>::Target) -> &T, FMut: Fn(&mut <V as Readable>::Target) -> &mut T,

type Output = T

The resulting type after applying the / operator.

fn div(self, rhs: T) -> <MappedMutSignal<T, V, F, FMut> as Div<T>>::Output

Performs the / operation.

impl<T, V, F, FMut> DivAssign<T> for MappedMutSignal<T, V, F, FMut>

where T: Div<Output = T> + Copy + 'static, V: Writable, <V as Readable>::Target: 'static, F: Fn(&<V as Readable>::Target) -> &T, FMut: Fn(&mut <V as Readable>::Target) -> &mut T,

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

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

where O: 'static + ?Sized, V: Readable<Storage = S> + 'static, F: Fn(&<V as Readable>::Target) -> &O + 'static, FMut: 'static, S: BoxedSignalStorage<O> + CreateBoxedSignalStorage<MappedMutSignal<O, V, F, FMut>>,

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

Converts to this type from the input type.

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

where O: 'static + ?Sized, V: Writable<Storage = S> + 'static, F: Fn(&<V as Readable>::Target) -> &O + 'static, FMut: Fn(&mut <V as Readable>::Target) -> &mut O + 'static, S: CreateBoxedSignalStorage<MappedMutSignal<O, V, F, FMut>> + BoxedSignalStorage<O>,

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

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 as Readable>::Target: 'static, F: Fn(&<V as Readable>::Target) -> &O,

fn into_value(self) -> AttributeValue

Convert into an attribute value

impl<T, V, F, FMut> Mul<T> for MappedMutSignal<T, V, F, FMut>

where T: Mul<Output = T> + Copy + 'static, V: Writable, <V as Readable>::Target: 'static, F: Fn(&<V as Readable>::Target) -> &T, FMut: Fn(&mut <V as Readable>::Target) -> &mut T,

type Output = T

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> <MappedMutSignal<T, V, F, FMut> as Mul<T>>::Output

Performs the * operation.

impl<T, V, F, FMut> MulAssign<T> for MappedMutSignal<T, V, F, FMut>

where T: Mul<Output = T> + Copy + 'static, V: Writable, <V as Readable>::Target: 'static, F: Fn(&<V as Readable>::Target) -> &T, FMut: Fn(&mut <V as Readable>::Target) -> &mut T,

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T, V, F, FMut> PartialEq<T> for MappedMutSignal<T, V, F, FMut>

where T: PartialEq + 'static, V: Readable, <V as Readable>::Target: 'static, F: Fn(&<V as Readable>::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 V: Readable + PartialEq, F: PartialEq, FMut: PartialEq, O: ?Sized,

fn eq(&self, other: &MappedMutSignal<O, V, F, FMut>) -> 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 V: Readable, <V as Readable>::Target: 'static, F: Fn(&<V as Readable>::Target) -> &O, O: ?Sized,

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<<<MappedMutSignal<O, V, F, FMut> as Readable>::Storage as AnyStorage>::Ref<'static, <MappedMutSignal<O, V, F, FMut> as Readable>::Target>, 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, ) -> Result<<<MappedMutSignal<O, V, F, FMut> as Readable>::Storage as AnyStorage>::Ref<'static, <MappedMutSignal<O, V, F, FMut> as Readable>::Target>, BorrowError>

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, V, F, FMut> Sub<T> for MappedMutSignal<T, V, F, FMut>

where T: Sub<Output = T> + Copy + 'static, V: Writable, <V as Readable>::Target: 'static, F: Fn(&<V as Readable>::Target) -> &T, FMut: Fn(&mut <V as Readable>::Target) -> &mut T,

type Output = T

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> <MappedMutSignal<T, V, F, FMut> as Sub<T>>::Output

Performs the - operation.

impl<T, V, F, FMut> SubAssign<T> for MappedMutSignal<T, V, F, FMut>

where T: Sub<Output = T> + Copy + 'static, V: Writable, <V as Readable>::Target: 'static, F: Fn(&<V as Readable>::Target) -> &T, FMut: Fn(&mut <V as Readable>::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 V: Writable, <V as Readable>::Target: 'static, F: Fn(&<V as Readable>::Target) -> &O, FMut: Fn(&mut <V as Readable>::Target) -> &mut O, O: ?Sized,

type WriteMetadata = <V as Writable>::WriteMetadata

Additional data associated with the write reference.

fn try_write_unchecked( &self, ) -> Result<WriteLock<'static, <MappedMutSignal<O, V, F, FMut> as Readable>::Target, <MappedMutSignal<O, V, F, FMut> as Readable>::Storage, <MappedMutSignal<O, V, F, FMut> as Writable>::WriteMetadata>, 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,