Struct crdts::list::List

pub struct List<T, A: Ord> { /* fields omitted */ }

As described in the module documentation:

A List is a CRDT for storing sequences of data (Strings, ordered lists). It provides an efficient view of the stored sequence, with fast index, insertion and deletion operations.

Implementations

impl<T, A: Ord + Clone> List<T, A>

pub fn new() -> Self

Create an empty List

pub fn insert_index(&self, ix: usize, val: T, actor: A) -> Op<T, A>

Generate an op to insert the given element at the given index. If ix is greater than the length of the List then it is appended to the end.

pub fn append(&self, c: T, actor: A) -> Op<T, A>

Create an op to insert an element at the end of the sequence.

pub fn delete_index(&self, ix: usize, actor: A) -> Option<Op<T, A>>

Create an op to delete the element at the given index.

Returns None if ix is out of bounds, i.e. ix > self.len().

pub fn len(&self) -> usize

Get the length of the List.

pub fn is_empty(&self) -> bool

Check if the List is empty.

pub fn read<'a, C: FromIterator<&'a T>>(&'a self) -> C

Read the List into a container of your choice

use crdts::{List, CmRDT};

let mut list = List::new();
list.apply(list.append('a', 'A'));
list.apply(list.append('b', 'A'));
list.apply(list.append('c', 'A'));
assert_eq!(list.read::<String>(), "abc");

pub fn read_into<C: FromIterator<T>>(self) -> C

Read the List into a container of your choice, consuming it.

use crdts::{List, CmRDT};

let mut list = List::new();
list.apply(list.append(1, 'A'));
list.apply(list.append(2, 'A'));
list.apply(list.append(3, 'A'));
assert_eq!(list.read_into::<Vec<_>>(), vec![1, 2, 3]);

pub fn iter(&self) -> impl Iterator<Item = &T>

Get the elements represented by the List.

pub fn iter_entries(&self) -> impl Iterator<Item = (&Identifier<OrdDot<A>>, &T)>

Get each elements identifier and value from the List.

pub fn position(&self, ix: usize) -> Option<&T>

Get an element at a position in the sequence represented by the List.

pub fn get(&self, id: &Identifier<OrdDot<A>>) -> Option<&T>

Finds an element by its Identifier.

pub fn first(&self) -> Option<&T>

Get first element of the sequence represented by the List.

pub fn first_entry(&self) -> Option<(&Identifier<OrdDot<A>>, &T)>

Get the first Entry of the sequence represented by the List.

pub fn last(&self) -> Option<&T>

Get last element of the sequence represented by the List.

pub fn last_entry(&self) -> Option<(&Identifier<OrdDot<A>>, &T)>

Get the last Entry of the sequence represented by the List.

Trait Implementations

impl<T: Clone, A: Clone + Ord> Clone for List<T, A>

fn clone(&self) -> List<T, A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, A: Ord + Clone + Debug> CmRDT for List<T, A>

fn apply(&mut self, op: Self::Op)

Apply an operation to an List instance.

If the operation is an insert and the identifier is already present in the List instance the result is a no-op

If the operation is a delete and the identifier is not present in the List instance the result is a no-op

type Op = Op<T, A>

Op defines a mutation to the CRDT. As long as Op’s from one actor are replayed in exactly the same order they were generated by that actor, the CRDT will converge. In other words, we must have a total ordering on each actors operations, while requiring only a partial order over all ops. E.g.

type Validation = DotRange<A>

The validation error returned by validate_op.

fn validate_op(&self, op: &Self::Op) -> Result<(), Self::Validation>

Some CRDT’s have stricter requirements on how they must be used. To avoid violating these requirements, CRDT’s provide an interface to optionally validate op’s before they are applied.

impl<T: Debug, A: Debug + Ord> Debug for List<T, A>

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

Formats the value using the given formatter.

impl<T, A: Ord> Default for List<T, A>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T, A: Ord> Deserialize<'de> for List<T, A> where
    T: Deserialize<'de>,
    A: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<T: Hash, A: Hash + Ord> Hash for List<T, A>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<T: PartialEq, A: PartialEq + Ord> PartialEq<List<T, A>> for List<T, A>

fn eq(&self, other: &List<T, A>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &List<T, A>) -> bool

This method tests for !=.

impl<T, A: Ord> Serialize for List<T, A> where
    T: Serialize,
    A: Serialize, 

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl<T: Eq, A: Eq + Ord> Eq for List<T, A>

impl<T, A: Ord> StructuralEq for List<T, A>

impl<T, A: Ord> StructuralPartialEq for List<T, A>