Struct aper::data_structures::List

pub struct List<T: StateMachine + PartialEq> { /* private fields */ }

Represents a list of items, similar to a Vec, but designed to be robust to concurrent modifications from multiple users.

Implementations

impl<T: StateMachine + PartialEq> List<T>

pub fn new() -> List<T>

pub fn get_location(&self, position: &ListPosition) -> ZenoIndex

pub fn insert_between( &self, id1: &Uuid, id2: &Uuid, value: T ) -> OperationWithId<T>

pub fn append(&self, value: T) -> OperationWithId<T>

Construct an OperationWithId representing appending the given object to this list.

pub fn prepend(&self, value: T) -> OperationWithId<T>

Construct a OperationWithId representing prepending the given object to this list.

pub fn insert(&self, location: ZenoIndex, value: T) -> OperationWithId<T>

Construct a OperationWithId representing inserting the given object at the given location in this list.

pub fn delete(&self, id: Uuid) -> ListOperation<T>

Construct a ListOperation representing deleting the object given (by id) in this list.

pub fn move_item(&self, id: Uuid, new_location: ZenoIndex) -> ListOperation<T>

Construct a ListOperation representing moving an object already in this list to the given location in the list.

pub fn map_item( &self, id: Uuid, fun: impl FnOnce(&T) -> <T as StateMachine>::Transition ) -> <Self as StateMachine>::Transition

pub fn iter(&self) -> impl Iterator<Item = ListItem<'_, T>>

Returns an iterator over ListItem views into this list.

Trait Implementations

impl<T: Clone + StateMachine + PartialEq> Clone for List<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + StateMachine + PartialEq> Debug for List<T>

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

Formats the value using the given formatter.

impl<T: StateMachine + PartialEq> Default for List<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T: StateMachine + PartialEq> Deserialize<'de> for List<T>

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: PartialEq + StateMachine + PartialEq> PartialEq for List<T>

fn eq(&self, other: &List<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: StateMachine + PartialEq> Serialize for List<T>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: StateMachine + PartialEq> StateMachine for List<T>

type Transition = ListOperation<T>

The StateMachine::Transition type associates another type with this state machine as its transitions.

type Conflict = ListConflict<T>

fn apply( &self, transition_event: &Self::Transition ) -> Result<Self, ListConflict<T>>

Update the state machine according to the given [Transition]. This method must be deterministic: calling it on a clone of the state with a clone of the [Transition] must result in the same state, even at a different time and on a different machine. This is the requirement that allows Aper to keep the state in sync across multiple machines.

impl<T: StateMachine + PartialEq> StructuralPartialEq for List<T>