Struct ywasm::YArray

pub struct YArray(_);

A collection used to store data in an indexed sequence structure. This type is internally implemented as a double linked list, which may squash values inserted directly one after another into single list node upon transaction commit.

Reading a root-level type as an YArray means treating its sequence components as a list, where every countable element becomes an individual entity:

• JSON-like primitives (booleans, numbers, strings, JSON maps, arrays etc.) are counted individually.
• Text chunks inserted by Text data structure: each character becomes an element of an array.
• Embedded and binary values: they count as a single element even though they correspond of multiple bytes.

Like all Yrs shared data types, YArray is resistant to the problem of interleaving (situation when elements inserted one after another may interleave with other peers concurrent inserts after merging all updates together). In case of Yrs conflict resolution is solved by using unique document id to determine correct and consistent ordering.

Implementations

impl YArray

pub fn new(init: Option<Vec<JsValue>>) -> Self

Creates a new preliminary instance of a YArray shared data type, with its state initialized to provided parameter.

Preliminary instances can be nested into other shared data types such as YArray and YMap. Once a preliminary instance has been inserted this way, it becomes integrated into ywasm document store and cannot be nested again: attempt to do so will result in an exception.

pub fn prelim(&self) -> bool

Returns true if this is a preliminary instance of YArray.

Preliminary instances can be nested into other shared data types such as YArray and YMap. Once a preliminary instance has been inserted this way, it becomes integrated into ywasm document store and cannot be nested again: attempt to do so will result in an exception.

pub fn length(&self) -> u32

Returns a number of elements stored within this instance of YArray.

pub fn to_json(&self, txn: &YTransaction) -> JsValue

Converts an underlying contents of this YArray instance into their JSON representation.

pub fn insert(&self, txn: &mut YTransaction, index: u32, items: Vec<JsValue>)

Inserts a given range of items into this YArray instance, starting at given index.

pub fn push(&self, txn: &mut YTransaction, items: Vec<JsValue>)

Appends a range of items at the end of this YArray instance.

pub fn delete(&self, txn: &mut YTransaction, index: u32, length: u32)

Deletes a range of items of given length from current YArray instance, starting from given index.

pub fn get(&self, txn: &YTransaction, index: u32) -> Result<JsValue, JsValue>

Returns an element stored under given index.

pub fn values(&self, txn: &YTransaction) -> JsValue

Returns an iterator that can be used to traverse over the values stored withing this instance of YArray.

Example:

import YDoc from 'ywasm'

/// document on machine A
const doc = new YDoc()
const array = doc.getArray('name')
const txn = doc.beginTransaction()
try {
    array.push(txn, ['hello', 'world'])
    for (let item of array.values(txn)) {
        console.log(item)
    }
} finally {
    txn.free()
}

Trait Implementations

impl From<Array> for YArray

fn from(v: Array) -> Self

Performs the conversion.

impl From<YArray> for JsValue

fn from(value: YArray) -> Self

Performs the conversion.

impl FromWasmAbi for YArray

type Abi = u32

The wasm ABI type that this converts from when coming back out from the ABI boundary.

unsafe fn from_abi(js: u32) -> Self

Recover a Self from Self::Abi.

impl IntoWasmAbi for YArray

type Abi = u32

The wasm ABI type that this converts into when crossing the ABI boundary.

fn into_abi(self) -> u32

Convert self into Self::Abi so that it can be sent across the wasm ABI boundary.

impl OptionFromWasmAbi for YArray

fn is_none(abi: &Self::Abi) -> bool

Tests whether the argument is a “none” instance. If so it will be deserialized as None, and otherwise it will be passed to FromWasmAbi.

impl OptionIntoWasmAbi for YArray

fn none() -> Self::Abi

Returns an ABI instance indicating “none”, which JS will interpret as the None branch of this option.

impl RefFromWasmAbi for YArray

type Abi = u32

The wasm ABI type references to Self are recovered from.

type Anchor = Ref<'static, YArray>

The type that holds the reference to Self for the duration of the invocation of the function that has an &Self parameter. This is required to ensure that the lifetimes don’t persist beyond one function call, and so that they remain anonymous.

unsafe fn ref_from_abi(js: Self::Abi) -> Self::Anchor

Recover a Self::Anchor from Self::Abi.

impl RefMutFromWasmAbi for YArray

type Abi = u32

Same as RefFromWasmAbi::Abi

type Anchor = RefMut<'static, YArray>

Same as RefFromWasmAbi::Anchor

unsafe fn ref_mut_from_abi(js: Self::Abi) -> Self::Anchor

Same as RefFromWasmAbi::ref_from_abi

impl WasmDescribe for YArray

fn describe()