Struct RGAList 

pub struct RGAList<T: Clone + PartialEq> {
    nodes: HashMap<ListId, ListNode<T>>,
    children: HashMap<ListId, Vec<ListId>>,
    replica_id: String,
    seq: u64,
    pending_delta: Option<RGAListDelta<T>>,
}

Replicated Growable Array - an ordered list CRDT.

Supports insert, delete, and move operations with deterministic conflict resolution.

Fields

nodes: HashMap<ListId, ListNode<T>>

All nodes indexed by their ID.

children: HashMap<ListId, Vec<ListId>>

Children of each node (for ordering). Maps origin -> list of children sorted by ID.

replica_id: String

The replica ID for this instance.

seq: u64

Sequence counter for generating IDs.

pending_delta: Option<RGAListDelta<T>>

Pending delta for replication.

Implementations

impl<T: Clone + PartialEq> RGAList<T>

pub fn new(replica_id: impl Into<String>) -> Self

Create a new empty RGA list.

pub fn replica_id(&self) -> &str

Get the replica ID.

fn next_id(&mut self) -> ListId

Generate a new unique ID.

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

Insert a value at the given index.

pub fn insert_after(&mut self, origin: &ListId, value: T)

Insert a value after the given origin ID.

pub fn push_front(&mut self, value: T)

Insert at the beginning.

pub fn push_back(&mut self, value: T)

Insert at the end.

pub fn delete(&mut self, index: usize) -> Option<T>

Delete the element at the given index.

pub fn delete_by_id(&mut self, id: &ListId) -> Option<T>

Delete an element by its ID.

pub fn move_element(&mut self, from: usize, to: usize) -> bool

Move an element from one index to another.

pub fn get(&self, index: usize) -> Option<&T>

Get the element at the given index.

pub fn get_mut(&mut self, index: usize) -> Option<&mut T>

Get a mutable reference to the element at the given index.

pub fn len(&self) -> usize

Get the number of non-deleted elements.

pub fn is_empty(&self) -> bool

Check if the list is empty.

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

Iterate over values in order.

pub fn iter_indexed(&self) -> impl Iterator<Item = (usize, &T)>

Iterate over (index, value) pairs.

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

Convert to a Vec.

fn id_at_index(&self, index: usize) -> Option<ListId>

Get the ID at a given visible index.

pub fn index_of_id(&self, id: &ListId) -> Option<usize>

Get the visible index for an ID.

fn iter_nodes(&self) -> impl Iterator<Item = &ListNode<T>>

Iterate over all nodes in order (including tombstones).

fn integrate_node(&mut self, node: ListNode<T>)

Integrate a node into the list.

pub fn take_delta(&mut self) -> Option<RGAListDelta<T>>

Take the pending delta.

pub fn apply_delta(&mut self, delta: &RGAListDelta<T>)

Apply a delta from another replica.

Trait Implementations

impl<T: Clone + Clone + PartialEq> Clone for RGAList<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Clone + PartialEq> Debug for RGAList<T>

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

Formats the value using the given formatter.

impl<T: Clone + PartialEq> Default for RGAList<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for RGAList<T>

where T: Deserialize<'de> + Default + Clone + PartialEq,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Clone + PartialEq> Lattice for RGAList<T>

fn bottom() -> Self

The bottom element (identity for join)

fn join(&self, other: &Self) -> Self

Join operation (least upper bound) Must be commutative, associative, and idempotent

fn partial_cmp_lattice(&self, other: &Self) -> Option<Ordering>

Partial order derived from join: a ≤ b iff a ⊔ b = b

fn leq(&self, other: &Self) -> bool

Check if self ≤ other in the lattice order

fn join_assign(&mut self, other: &Self)

Join-assign: self = self ⊔ other

impl<T: Clone + PartialEq> PartialEq for RGAList<T>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Serialize for RGAList<T>

where T: Serialize + Clone + PartialEq,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.