Struct SignalVec 

pub struct SignalVec<T: 'static> { /* private fields */ }

A reactive Vec. This is more effective than using a Signal<Vec> because it allows fine grained reactivity within the Vec.

Implementations

impl<T: 'static> SignalVec<T>

pub fn new() -> Self

Create a new empty SignalVec.

pub fn with_values(values: Vec<T>) -> Self

Create a new SignalVec with existing values from a Vec.

pub fn changes(&self) -> &Rc<RefCell<Vec<VecDiff<T>>>>

Get the current pending changes that will be applied to the SignalVec.

pub fn inner_signal(&self) -> &Signal<RefCell<Vec<T>>>

Returns the inner backing Signal used to store the data. This method should used with care as unintentionally modifying the Vec will not trigger any updates and cause potential future problems.

pub fn replace(&self, values: Vec<T>)

pub fn insert(&self, index: usize, value: T)

pub fn update(&self, index: usize, value: T)

pub fn remove(&self, index: usize)

pub fn swap(&self, index1: usize, index2: usize)

pub fn push(&self, value: T)

pub fn pop(&self)

pub fn clear(&self)

pub fn map<U: Clone>(&self, f: impl Fn(&T) -> U + 'static) -> SignalVec<U>

Creates a derived SignalVec.

Example

use maple_core::prelude::*;

let my_vec = SignalVec::with_values(vec![1, 2, 3]);
let squared = my_vec.map(|x| *x * *x);

assert_eq!(*squared.inner_signal().get().borrow(), vec![1, 4, 9]);

my_vec.push(4);
assert_eq!(*squared.inner_signal().get().borrow(), vec![1, 4, 9, 16]);

my_vec.swap(0, 1);
assert_eq!(*squared.inner_signal().get().borrow(), vec![4, 1, 9, 16]);

impl SignalVec<TemplateResult>

pub fn template_list(&self) -> TemplateList

Create a TemplateList from the SignalVec.

impl<T: 'static + Clone> SignalVec<T>

pub fn to_vec(&self) -> Vec<T>

Create a Vec from a SignalVec. The returned Vec is cloned from the data which requires T to be Clone.

Example

use maple_core::prelude::*;

let signal = SignalVec::with_values(vec![1, 2, 3]);
assert_eq!(signal.to_vec(), vec![1, 2, 3]);

Trait Implementations

impl<T: 'static> Clone for SignalVec<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: 'static> Default for SignalVec<T>

fn default() -> Self

Returns the “default value” for a type.

impl From<SignalVec<TemplateResult>> for TemplateList

fn from(templates: SignalVec<TemplateResult>) -> Self

Converts to this type from the input type.