Struct sycamore_state_core::RcCollectionSignal

pub struct RcCollectionSignal<T> { /* private fields */ }

Wrapper type for RcSignal<Vec<RcSignal<T>>>

Base type for the #[collection] attribute when using State derive macro

Implementations

impl<T> RcCollectionSignal<T>

pub fn new(inner: impl IntoIterator<Item = T>) -> RcCollectionSignal<T>

Create new RcCollection from an iterator

impl<T> RcCollectionSignal<T>

pub fn push(&self, value: T)

Push new value into collection

let collection = RcCollectionSignal::new(vec![1,2,3,4]);
collection.push(8);

pub fn position<F: Fn(&T) -> bool>(&self, f: F) -> Option<usize>

Get position of value in collection

let collection = RcCollectionSignal::new(vec![1,2,3,4]);
let value = collection.find(|a| *a == 3);

pub fn find<F: Fn(&T) -> bool>(&self, f: F) -> Option<Rc<T>>

Find value in collection

let collection = RcCollectionSignal::new(vec![1,2,3,4]);
let value = collection.find(|a| *a == 3);

pub fn remove(&self, index: usize) -> Rc<T>

Remove value from collection by index

let collection = RcCollectionSignal::new(vec![1,2,3,4]);
let value = collection.remove(2);

pub fn remove_where<F: Fn(&T) -> bool>(&self, f: F) -> Option<Rc<T>>

Remove value from collection with predicate

let collection = RcCollectionSignal::new(vec![1,2,3,4]);
let value = collection.remove_where(|a| *a == 3);

Methods from Deref<Target = Signal<Vec<RcSignal<T>>>>

pub fn set(&self, value: T)

Set the current value of the state.

This will notify and update any effects and memos that depend on this value.

Example

let state = create_signal(cx, 0);
assert_eq!(*state.get(), 0);

state.set(1);
assert_eq!(*state.get(), 1);

pub fn set_fn<F>(&self, f: F)where F: Fn(&T) -> T,

Set the value of the state using a function that receives the current value.

This will notify and update any effects and memos that depend on this value.

Example

let state = create_signal(cx, 0);
assert_eq!(*state.get(), 0);

state.set_fn(|n| n + 1);
assert_eq!(*state.get(), 1);

pub fn set_rc(&self, value: Rc<T>)

Set the current value of the state wrapped in a Rc. Unlike [Signal::set()], this method accepts the value wrapped in a Rc because the underlying storage is already using Rc, thus preventing an unnecessary clone.

This will notify and update any effects and memos that depend on this value.

Example

let state = create_signal(cx, 0);
assert_eq!(*state.get(), 0);

state.set_rc(Rc::new(1));
assert_eq!(*state.get(), 1);

pub fn set_silent(&self, value: T)

Set the current value of the state without triggering subscribers.

Make sure you know what you are doing because this can make state inconsistent.

pub fn set_fn_silent<F>(&self, f: F)where F: Fn(&T) -> T,

Set the value of the state using a function that receives the current value without triggering subscribers.

Make sure you know what you are doing because this can make state inconsistent.

pub fn set_rc_silent(&self, value: Rc<T>)

Set the current value of the state wrapped in a Rc without triggering subscribers.

See the documentation for [Signal::set_rc()] for more information.

Make sure you know what you are doing because this can make state inconsistent.

pub fn split(&self) -> (impl Fn() + Copy, impl Fn(T) + Copy)

Split a signal into getter and setter handles.

Example

let (state, set_state) = create_signal(cx, 0).split();
assert_eq!(*state(), 0);

set_state(1);
assert_eq!(*state(), 1);

pub fn trigger_subscribers(&self)

Calls all the subscribers without modifying the state. This can be useful when using patterns such as inner mutability where the state updated will not be automatically triggered. In the general case, however, it is preferable to use [Signal::set()] instead.

This will also re-compute all the subscribers of this signal by calling all the dependency callbacks.

pub fn modify(&self) -> Modify<'_, T>

Return a mutable handle to make it easier to mutate the inner value. This requires the inner type to implement Clone.

Example

let state = create_signal(cx, "Hello ".to_string());
state.modify().push_str("World!");
assert_eq!(*state.get(), "Hello World!");

pub fn take(&self) -> Rc<T>

Take the current value out and replace it with the default value.

This will notify and update any effects and memos that depend on this value.

pub fn take_silent(&self) -> Rc<T>

Take the current value out and replace it with the default value without triggering subscribers.

Make sure you know what you are doing because this can make state inconsistent.

Methods from Deref<Target = ReadSignal<T>>

pub fn get(&self) -> Rc<T>

Get the current value of the state. When called inside a reactive scope, calling this will add itself to the scope’s dependencies.

Example

let state = create_signal(cx, 0);
assert_eq!(*state.get(), 0);

state.set(1);
assert_eq!(*state.get(), 1);

pub fn get_untracked(&self) -> Rc<T>

Get the current value of the state, without tracking this as a dependency if inside a reactive context.

Example

let state = create_signal(cx, 1);
let double = create_memo(cx, || *state.get_untracked() * 2);
assert_eq!(*double.get(), 2);

state.set(2);
// double value should still be old value because state was untracked
assert_eq!(*double.get(), 2);

pub fn map<'a, U>( &'a self, cx: BoundedScope<'a, 'a>, f: impl FnMut(&T) -> U + 'a ) -> &'a ReadSignal<U>where U: 'static,

Creates a mapped [ReadSignal]. This is equivalent to using [create_memo].

Example

let state = create_signal(cx, 1);
let double = state.map(cx, |&x| x * 2);
assert_eq!(*double.get(), 2);

state.set(2);
assert_eq!(*double.get(), 4);

pub fn track(&self)

When called inside a reactive scope, calling this will add itself to the scope’s dependencies.

To both track and get the value of the signal, use [ReadSignal::get] instead.

Trait Implementations

impl<T: Clone> Clone for RcCollectionSignal<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for RcCollectionSignal<T>

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

Formats the value using the given formatter.

impl<T> Deref for RcCollectionSignal<T>

type Target = Signal<Vec<RcSignal<T>, Global>>

The resulting type after dereferencing.

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

Dereferences the value.

impl<T: PartialEq> PartialEq<RcCollectionSignal<T>> for RcCollectionSignal<T>

fn eq(&self, other: &RcCollectionSignal<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: Eq> Eq for RcCollectionSignal<T>

impl<T> StructuralEq for RcCollectionSignal<T>

impl<T> StructuralPartialEq for RcCollectionSignal<T>