Struct ywasm::YDoc

pub struct YDoc(_);

A ywasm document type. Documents are most important units of collaborative resources management. All shared collections live within a scope of their corresponding documents. All updates are generated on per document basis (rather than individual shared type). All operations on shared collections happen via YTransaction, which lifetime is also bound to a document.

Document manages so called root types, which are top-level shared types definitions (as opposed to recursively nested types).

A basic workflow sample:

import YDoc from 'ywasm'

const doc = new YDoc()
const txn = doc.beginTransaction()
try {
    const text = txn.getText('name')
    text.push(txn, 'hello world')
    const output = text.toString(txn)
    console.log(output)
} finally {
    txn.free()
}

Implementations

impl YDoc

pub fn new(id: Option<f64>) -> Self

Creates a new ywasm document. If id parameter was passed it will be used as this document globally unique identifier (it’s up to caller to ensure that requirement). Otherwise it will be assigned a randomly generated number.

pub fn id(&self) -> f64

Gets globally unique identifier of this YDoc instance.

pub fn begin_transaction(&mut self) -> YTransaction

Returns a new transaction for this document. Ywasm shared data types execute their operations in a context of a given transaction. Each document can have only one active transaction at the time - subsequent attempts will cause exception to be thrown.

Transactions started with doc.beginTransaction can be released using transaction.free method.

Example:

import YDoc from 'ywasm'

// helper function used to simplify transaction
// create/release cycle
YDoc.prototype.transact = callback => {
    const txn = this.beginTransaction()
    try {
        return callback(txn)
    } finally {
        txn.free()
    }
}

const doc = new YDoc()
const text = doc.getText('name')
doc.transact(txn => text.insert(txn, 0, 'hello world'))

pub fn get_text(&mut self, name: &str) -> YText

Returns a YText shared data type, that’s accessible for subsequent accesses using given name.

If there was no instance with this name before, it will be created and then returned.

If there was an instance with this name, but it was of different type, it will be projected onto YText instance.

pub fn get_array(&mut self, name: &str) -> YArray

Returns a YArray shared data type, that’s accessible for subsequent accesses using given name.

If there was no instance with this name before, it will be created and then returned.

If there was an instance with this name, but it was of different type, it will be projected onto YArray instance.

pub fn get_map(&mut self, name: &str) -> YMap

Returns a YMap shared data type, that’s accessible for subsequent accesses using given name.

If there was no instance with this name before, it will be created and then returned.

If there was an instance with this name, but it was of different type, it will be projected onto YMap instance.

pub fn get_xml_element(&mut self, name: &str) -> YXmlElement

Returns a YXmlElement shared data type, that’s accessible for subsequent accesses using given name.

If there was no instance with this name before, it will be created and then returned.

If there was an instance with this name, but it was of different type, it will be projected onto YXmlElement instance.

pub fn get_xml_text(&mut self, name: &str) -> YXmlText

Returns a YXmlText shared data type, that’s accessible for subsequent accesses using given name.

If there was no instance with this name before, it will be created and then returned.

If there was an instance with this name, but it was of different type, it will be projected onto YXmlText instance.

Trait Implementations

impl From<YDoc> for JsValue

fn from(value: YDoc) -> Self

Performs the conversion.

impl FromWasmAbi for YDoc

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 YDoc

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 YDoc

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 YDoc

fn none() -> Self::Abi

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

impl RefFromWasmAbi for YDoc

type Abi = u32

The wasm ABI type references to Self are recovered from.

type Anchor = Ref<'static, YDoc>

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 YDoc

type Abi = u32

Same as RefFromWasmAbi::Abi

type Anchor = RefMut<'static, YDoc>

Same as RefFromWasmAbi::Anchor

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

Same as RefFromWasmAbi::ref_from_abi

impl WasmDescribe for YDoc

fn describe()