Struct LoroMovableList

pub struct LoroMovableList { /* private fields */ }

LoroMovableList container

It is used to model movable ordered lists.

Using a combination of insert and delete operations, one can simulate set and move operations on a List. However, this approach fails in concurrent editing scenarios. For example, if the same element is set or moved concurrently, the simulation would result in the deletion of the original element and the insertion of two new elements, which does not meet expectations.

Implementations

impl LoroMovableList

pub fn new() -> LoroMovableList

Create a new container that is detached from the document.

The edits on a detached container will not be persisted. To attach the container to the document, please insert it into an attached container.

pub fn is_attached(&self) -> bool

Whether the container is attached to a document

The edits on a detached container will not be persisted. To attach the container to the document, please insert it into an attached container.

pub fn insert(&self, pos: usize, v: impl Into<LoroValue>) -> LoroResult<()>

Insert a value at the given position.

pub fn delete(&self, pos: usize, len: usize) -> LoroResult<()>

Delete the value at the given position.

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

Get the value at the given position.

pub fn len(&self) -> usize

Get the length of the list.

pub fn is_empty(&self) -> bool

Whether the list is empty.

pub fn get_value(&self) -> LoroValue

Get the shallow value of the list.

It will not convert the state of sub-containers, but represent them as LoroValue::Container.

pub fn get_deep_value(&self) -> LoroValue

Get the deep value of the list.

It will convert the state of sub-containers into a nested JSON value.

pub fn pop(&self) -> LoroResult<Option<ValueOrContainer>>

Pop the last element of the list.

pub fn push(&self, v: impl Into<LoroValue>) -> LoroResult<()>

Push a value to the end of the list.

pub fn push_container<C: ContainerTrait>(&self, child: C) -> LoroResult<C>

Push a container to the end of the list.

pub fn set(&self, pos: usize, value: impl Into<LoroValue>) -> LoroResult<()>

Set the value at the given position.

pub fn mov(&self, from: usize, to: usize) -> LoroResult<()>

Move the value at the given position to the given position.

pub fn insert_container<C: ContainerTrait>( &self, pos: usize, child: C, ) -> LoroResult<C>

Insert a container at the given position.

pub fn set_container<C: ContainerTrait>( &self, pos: usize, child: C, ) -> LoroResult<C>

Set the container at the given position.

pub fn log_internal_state(&self)

Log the internal state of the list.

pub fn get_cursor(&self, pos: usize, side: Side) -> Option<Cursor>

Get the cursor at the given position.

Using “index” to denote cursor positions can be unstable, as positions may shift with document edits. To reliably represent a position or range within a document, it is more effective to leverage the unique ID of each item/character in a List CRDT or Text CRDT.

Loro optimizes State metadata by not storing the IDs of deleted elements. This approach complicates tracking cursors since they rely on these IDs. The solution recalculates position by replaying relevant history to update stable positions accurately. To minimize the performance impact of history replay, the system updates cursor info to reference only the IDs of currently present elements, thereby reducing the need for replay.

Example

use loro::LoroDoc;
use loro_internal::cursor::Side;

let doc = LoroDoc::new();
let list = doc.get_movable_list("list");
list.insert(0, 0).unwrap();
let cursor = list.get_cursor(0, Side::Middle).unwrap();
assert_eq!(doc.get_cursor_pos(&cursor).unwrap().current.pos, 0);
list.insert(0, 0).unwrap();
assert_eq!(doc.get_cursor_pos(&cursor).unwrap().current.pos, 1);
list.insert(0, 0).unwrap();
list.insert(0, 0).unwrap();
assert_eq!(doc.get_cursor_pos(&cursor).unwrap().current.pos, 3);
list.insert(4, 0).unwrap();
assert_eq!(doc.get_cursor_pos(&cursor).unwrap().current.pos, 3);

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

Get the elements of the list as a vector of LoroValues.

This method returns a vector containing all the elements in the list as LoroValues. It provides a convenient way to access the entire contents of the LoroMovableList as a standard Rust vector.

Returns

A Vec<LoroValue> containing all elements of the list.

Example

use loro::LoroDoc;

let doc = LoroDoc::new();
let list = doc.get_movable_list("mylist");
list.insert(0, 1).unwrap();
list.insert(1, "hello").unwrap();
list.insert(2, true).unwrap();

let vec = list.to_vec();
assert_eq!(vec.len(), 3);
assert_eq!(vec[0], 1.into());
assert_eq!(vec[1], "hello".into());
assert_eq!(vec[2], true.into());

pub fn clear(&self) -> LoroResult<()>

Delete all elements in the list.

pub fn for_each<I>(&self, f: I)

where I: FnMut(ValueOrContainer),

Iterate over the elements of the list.

pub fn get_creator_at(&self, pos: usize) -> Option<PeerID>

Get the creator of the list item at the given position.

pub fn get_last_mover_at(&self, pos: usize) -> Option<PeerID>

Get the last mover of the list item at the given position.

pub fn get_last_editor_at(&self, pos: usize) -> Option<PeerID>

Get the last editor of the list item at the given position.

Trait Implementations

impl Clone for LoroMovableList

fn clone(&self) -> LoroMovableList

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ContainerTrait for LoroMovableList

type Handler = MovableListHandler

The handler of the container.

fn id(&self) -> ContainerID

Get the ID of the container.

fn to_container(&self) -> Container

Convert the container to a Container.

fn to_handler(&self) -> Self::Handler

Convert the container to a handler.

fn from_handler(handler: Self::Handler) -> Self

Convert the handler to a container.

fn try_from_container(container: Container) -> Option<Self>

where Self: Sized,

Try to convert the container to the handler.

fn is_attached(&self) -> bool

Whether the container is attached to a document.

fn get_attached(&self) -> Option<Self>

where Self: Sized,

If a detached container is attached, this method will return its corresponding attached handler.

fn is_deleted(&self) -> bool

Whether the container is deleted.

fn doc(&self) -> Option<LoroDoc>

Get the doc of the container.

fn subscribe(&self, callback: Subscriber) -> Option<Subscription>

Subscribe to the container.

impl Debug for LoroMovableList

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

Formats the value using the given formatter.

impl Default for LoroMovableList

fn default() -> Self

Returns the “default value” for a type.