Struct ywasm::Array

pub struct Array(/* private fields */);

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(items: 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 get_type(&self) -> u8

pub fn id(&self) -> Result<JsValue, JsValue>

Gets unique logical identifier of this type, shared across peers collaborating on the same document.

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 alive(&self, txn: &YTransaction) -> bool

Checks if current YArray reference is alive and has not been deleted by its parent collection. This method only works on already integrated shared types and will return false is current type is preliminary (has not been integrated into document).

pub fn length(&self, txn: &ImplicitTransaction) -> Result<u32, JsValue>

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

pub fn to_json(&self, txn: &ImplicitTransaction) -> Result<JsValue, JsValue>

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

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

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

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

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

pub fn delete( &mut self, index: u32, length: Option<u32>, txn: ImplicitTransaction ) -> Result<(), JsValue>

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

pub fn move_content( &mut self, source: u32, target: u32, txn: ImplicitTransaction ) -> Result<(), JsValue>

Moves element found at source index into target index position.

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

Returns an element stored under given index.

pub fn quote( &self, lower: u32, upper: u32, lower_open: Option<bool>, upper_open: Option<bool>, txn: &ImplicitTransaction ) -> Result<YWeakLink, JsValue>

pub fn values(&self, txn: &ImplicitTransaction) -> Result<JsValue, 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()
}

pub fn observe(&self, f: Function) -> Result<Observer, JsValue>

Subscribes to all operations happening over this instance of YArray. All changes are batched and eventually triggered during transaction commit phase. Returns an Observer which, when free’d, will unsubscribe current callback.

pub fn observe_deep(&self, f: Function) -> Result<Observer, JsValue>

Subscribes to all operations happening over this Y shared type, as well as events in shared types stored within this one. All changes are batched and eventually triggered during transaction commit phase. Returns an YEventObserver which, when free’d, will unsubscribe current callback.

Trait Implementations

impl From<YArray> for JsValue

fn from(value: YArray) -> Self

Converts to this type from the input type.

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 LongRefFromWasmAbi for YArray

type Abi = u32

Same as RefFromWasmAbi::Abi

type Anchor = Ref<'static, YArray>

Same as RefFromWasmAbi::Anchor

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

Same as RefFromWasmAbi::ref_from_abi

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 TryFromJsValue for YArray

type Error = JsValue

The type returned in the event of a conversion error.

fn try_from_js_value(value: JsValue) -> Result<Self, Self::Error>

Performs the conversion.

impl VectorFromWasmAbi for YArray

type Abi = <Box<[JsValue]> as FromWasmAbi>::Abi

unsafe fn vector_from_abi(js: Self::Abi) -> Box<[YArray]>

impl VectorIntoWasmAbi for YArray

type Abi = <Box<[JsValue]> as IntoWasmAbi>::Abi

fn vector_into_abi(vector: Box<[YArray]>) -> Self::Abi

impl WasmDescribe for YArray

fn describe()

impl WasmDescribeVector for YArray

fn describe_vector()