Struct ArcRwSignal

pub struct ArcRwSignal<T> {
    pub(crate) value: Arc<RwLock<T>>,
    pub(crate) inner: Arc<RwLock<SubscriberSet>>,
}

Expand description

A reference-counted signal that can be read from or written to.

A signal is a piece of data that may change over time, and notifies other code when it has changed. This is the atomic unit of reactivity, which begins all other processes of reactive updates.

This is a reference-counted signal, which is Clone but not Copy. For arena-allocated Copy signals, use RwSignal.

§Core Trait Implementations

§Reading the Value

.get() clones the current value of the signal. If you call it within an effect, it will cause that effect to subscribe to the signal, and to re-run whenever the value of the signal changes.
- .get_untracked() clones the value of the signal without reactively tracking it.
.read() returns a guard that allows accessing the value of the signal by reference. If you call it within an effect, it will cause that effect to subscribe to the signal, and to re-run whenever the value of the signal changes.
- .read_untracked() gives access to the current value of the signal without reactively tracking it.
.with() allows you to reactively access the signal’s value without cloning by applying a callback function.
- .with_untracked() allows you to access the signal’s value by applying a callback function without reactively tracking it.
.to_stream() converts the signal to an async stream of values.

§Updating the Value

.set() sets the signal to a new value.
.update() updates the value of the signal by applying a closure that takes a mutable reference.
.write() returns a guard through which the signal can be mutated, and which notifies subscribers when it is dropped.

Each of these has a related _untracked() method, which updates the signal without notifying subscribers. Untracked updates are not desirable in most cases, as they cause “tearing” between the signal’s value and its observed value. If you want a non-reactive container, used ArenaItem instead.

§Examples

let count = ArcRwSignal::new(0);

// ✅ calling the getter clones and returns the value
//    this can be `count()` on nightly
assert_eq!(count.get(), 0);

// ✅ calling the setter sets the value
//    this can be `set_count(1)` on nightly
count.set(1);
assert_eq!(count.get(), 1);

// ❌ you could call the getter within the setter
// set_count.set(count.get() + 1);

// ✅ however it's more efficient to use .update() and mutate the value in place
count.update(|count: &mut i32| *count += 1);
assert_eq!(count.get(), 2);

// ✅ you can create "derived signals" with a Fn() -> T interface
let double_count = {
  // clone before moving into the closure because we use it below
  let count = count.clone();
  move || count.get() * 2
};
count.set(0);
assert_eq!(double_count(), 0);
count.set(1);
assert_eq!(double_count(), 2);

Fields§

§value: Arc<RwLock<T>>§inner: Arc<RwLock<SubscriberSet>>

Implementations§

§

impl<T> ArcRwSignal<T>

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

Creates a new signal, taking the initial value as its argument.

pub fn read_only(&self) -> ArcReadSignal<T>

Returns a read-only handle to the signal.

pub fn write_only(&self) -> ArcWriteSignal<T>

Returns a write-only handle to the signal.

pub fn split(&self) -> (ArcReadSignal<T>, ArcWriteSignal<T>)

Splits the signal into its readable and writable halves.

pub fn unite( read: ArcReadSignal<T>, write: ArcWriteSignal<T>, ) -> Option<ArcRwSignal<T>>

Reunites the two halves of a signal. Returns None if the two signals provided were not created from the same signal.

Trait Implementations§

§

impl<V> AddAnyAttr for ArcRwSignal<V>
where V: RenderHtml + Clone + Send + Sync + 'static, <V as Render>::State: 'static, ArcRwSignal<V>: Get<Value = V>,

§

type Output<SomeNewAttr: Attribute> = ArcRwSignal<V>

The new type once the attribute has been added.

§

fn add_any_attr<NewAttr>( self, _attr: NewAttr, ) -> <ArcRwSignal<V> as AddAnyAttr>::Output<NewAttr>
where NewAttr: Attribute,

Adds an attribute to the view.

§

impl<V> AttributeValue for ArcRwSignal<V>
where V: AttributeValue + Send + Sync + Clone + 'static, <V as AttributeValue>::State: 'static, ArcRwSignal<V>: Get<Value = V>,

§

type AsyncOutput = ArcRwSignal<V>

The type once all async data have loaded.

§

type State = RenderEffect<<V as AttributeValue>::State>

The state that should be retained between building and rebuilding.

§

type Cloneable = ArcRwSignal<V>

A version of the value that can be cloned. This can be the same type, or a reference-counted type. Generally speaking, this does not need to refer to the same data, but should behave in the same way. So for example, making an event handler cloneable should probably make it reference-counted (so that a FnMut() continues mutating the same closure), but making a String cloneable does not necessarily need to make it an Arc<str>, as two different clones of a String will still have the same value.

§

type CloneableOwned = ArcRwSignal<V>

A cloneable type that is also 'static. This is used for spreading across types when the spreadable attribute needs to be owned. In some cases (&'a str to Arc<str>, etc.) the owned cloneable type has worse performance than the cloneable type, so they are separate.

§

fn html_len(&self) -> usize

An approximation of the actual length of this attribute in HTML.

§

fn to_html(self, key: &str, buf: &mut String)

Renders the attribute value to HTML.

§

fn to_template(_key: &str, _buf: &mut String)

Renders the attribute value to HTML for a <template>.

§

fn hydrate<const FROM_SERVER: bool>( self, key: &str, el: &Element, ) -> <ArcRwSignal<V> as AttributeValue>::State

Adds interactivity as necessary, given DOM nodes that were created from HTML that has either been rendered on the server, or cloned for a <template>.

§

fn build( self, el: &Element, key: &str, ) -> <ArcRwSignal<V> as AttributeValue>::State

Adds this attribute to the element during client-side rendering.

§

fn rebuild( self, key: &str, state: &mut <ArcRwSignal<V> as AttributeValue>::State, )

Applies a new value for the attribute.

§

fn into_cloneable(self) -> <ArcRwSignal<V> as AttributeValue>::Cloneable

Converts this attribute into an equivalent that can be cloned.

§

fn into_cloneable_owned( self, ) -> <ArcRwSignal<V> as AttributeValue>::CloneableOwned

Converts this attributes into an equivalent that can be cloned and is 'static.

§

fn dry_resolve(&mut self)

“Runs” the attribute without other side effects. For primitive types, this is a no-op. For reactive types, this can be used to gather data about reactivity or about asynchronous data that needs to be loaded.

§

async fn resolve(self) -> <ArcRwSignal<V> as AttributeValue>::AsyncOutput

“Resolves” this into a form that is not waiting for any asynchronous data.

§

impl<T> Clone for ArcRwSignal<T>

§

fn clone(&self) -> ArcRwSignal<T>

Returns a duplicate of the value. Read more

1.0.0 (const: unstable) · Source§

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

Performs copy-assignment from source. Read more

§

impl<T> Debug for ArcRwSignal<T>

§

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

Formats the value using the given formatter. Read more

§

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

§

fn default() -> ArcRwSignal<T>

Returns the “default value” for a type. Read more

§

impl<T> DefinedAt for ArcRwSignal<T>

§

fn defined_at(&self) -> Option<&'static Location<'static>>

Returns the location at which the signal was defined. This is usually simply None in release mode.

§

impl<'de, T> Deserialize<'de> for ArcRwSignal<T>
where T: Deserialize<'de>,

§

fn deserialize<D>( deserializer: D, ) -> Result<ArcRwSignal<T>, <D as Deserializer<'de>>::Error>
where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more

§