Struct ywasm::YMap

pub struct YMap(_);

Collection used to store key-value entries in an unordered manner. Keys are always represented as UTF-8 strings. Values can be any value type supported by Yrs: JSON-like primitives as well as shared data types.

In terms of conflict resolution, Map uses logical last-write-wins principle, meaning the past updates are automatically overridden and discarded by newer ones, while concurrent updates made by different peers are resolved into a single value using document id seniority to establish order.

Implementations

impl YMap

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

Creates a new preliminary instance of a YMap 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 YMap.

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, txn: &YTransaction) -> u32

Returns a number of entries stored within this instance of YMap.

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

Converts contents of this YMap instance into a JSON representation.

pub fn set(&self, txn: &mut YTransaction, key: &str, value: JsValue)

Sets a given key-value entry within this instance of YMap. If another entry was already stored under given key, it will be overridden with new value.

pub fn delete(&mut self, txn: &mut YTransaction, key: &str)

Removes an entry identified by a given key from this instance of YMap, if such exists.

pub fn get(&self, txn: &mut YTransaction, key: &str) -> JsValue

Returns value of an entry stored under given key within this instance of YMap, or undefined if no such entry existed.

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

Returns an iterator that can be used to traverse over all entries stored within this instance of YMap. Order of entry is not specified.

Example:

import YDoc from 'ywasm'

/// document on machine A
const doc = new YDoc()
const map = doc.getMap('name')
const txn = doc.beginTransaction()
try {
    map.set(txn, 'key1', 'value1')
    map.set(txn, 'key2', true)

    for (let [key, value] of map.entries(txn)) {
        console.log(key, value)
    }
} finally {
    txn.free()
}

Trait Implementations

impl From<Map> for YMap

fn from(v: Map) -> Self

Performs the conversion.

impl From<YMap> for JsValue

fn from(value: YMap) -> Self

Performs the conversion.

impl FromWasmAbi for YMap

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 YMap

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 YMap

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 YMap

fn none() -> Self::Abi

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

impl RefFromWasmAbi for YMap

type Abi = u32

The wasm ABI type references to Self are recovered from.

type Anchor = Ref<'static, YMap>

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 YMap

type Abi = u32

Same as RefFromWasmAbi::Abi

type Anchor = RefMut<'static, YMap>

Same as RefFromWasmAbi::Anchor

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

Same as RefFromWasmAbi::ref_from_abi

impl WasmDescribe for YMap

fn describe()