Struct Nested 

#[repr(transparent)]
pub struct Nested<S> {
    pub id: ID,
    /* private fields */
}

A logical reference used to represent a shared collection nested within another one. Unlike Root-level types which cannot be deleted and exist eternally, Nested collections can be added (therefore don’t exist prior their instantiation) and deleted (so that any SharedRef values referencing them become unsafe and can point to objects that no longer exists!).

Use Nested::get in order to materialize current nested logical reference into shared ref type.

Example

use yrs::{Doc, Map, Nested, SharedRef, TextPrelim, TextRef, Transact, WriteTxn};

let doc = Doc::new();
let mut txn = doc.transact_mut();
let root = txn.get_or_insert_map("root"); // root-level collection
let text = root.insert(&mut txn, "nested", TextPrelim::new("")); // nested collection

// convert nested TextRef into logical pointer
let nested: Nested<TextRef> = text.hook().into_nested().unwrap();

// logical reference can be used to retrieve accessible TextRef when its alive
assert_eq!(nested.get(&txn), Some(text));

// delete nested collection
root.remove(&mut txn, "nested");

// logical reference cannot resolve shared collections that have been deleted already
assert_eq!(nested.get(&txn), None);

Fields

id: ID

Implementations

impl<S> Nested<S>

pub fn new(id: ID) -> Self

impl<S: SharedRef> Nested<S>

pub fn get<T: ReadTxn>(&self, txn: &T) -> Option<S>

If current Nested logical reference points to an instantiated and not-deleted shared collection, a reference to that collection will be returned. If the referenced collection has been deleted or was not yet present in current transaction scope i.e. due to missing update, a None will be returned.

Trait Implementations

impl<S: Clone> Clone for Nested<S>

fn clone(&self) -> Nested<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Debug> Debug for Nested<S>

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

Formats the value using the given formatter.

impl<S> From<Nested<S>> for Hook<S>

fn from(nested: Nested<S>) -> Self

Converts to this type from the input type.

impl<S: Hash> Hash for Nested<S>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<S> Into<BranchID> for Nested<S>

fn into(self) -> BranchID

Converts this type into the (usually inferred) input type.

impl<S: Ord> Ord for Nested<S>

fn cmp(&self, other: &Nested<S>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<S: PartialEq> PartialEq for Nested<S>

fn eq(&self, other: &Nested<S>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<S: PartialOrd> PartialOrd for Nested<S>

fn partial_cmp(&self, other: &Nested<S>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<S: Eq> Eq for Nested<S>

impl<S> StructuralPartialEq for Nested<S>