Struct Hook 

pub struct Hook<S> { /* private fields */ }

A descriptor used to reference to shared collections by their unique logical identifiers, which can be either Root-level collections or shared collections Nested into each other. It can be resolved from any shared reference using SharedRef::hook.

Implementations

impl<S> Hook<S>

pub fn id(&self) -> &BranchID

Unique logical identifier of a shared collection.

impl<S> Hook<S>

where S: SharedRef,

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

where T: ReadTxn,

Returns a reference to a shared collection current hook points to, if it exists and (in case of nested collections) has not been deleted.

Example

use yrs::{Hook, Doc, Map, MapRef, 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 nested = root.insert(&mut txn, "nested", TextPrelim::new("")); // nested collection

let root_hook: Hook<MapRef> = root.hook();
let nested_hook: Hook<TextRef> = nested.hook();

// hook can be used to retrieve collection reference as long as its alive
assert_eq!(nested_hook.get(&txn), Some(nested));

// after nested collection is deleted it can no longer be referenced
root.remove(&mut txn, "nested");
assert_eq!(nested_hook.get(&txn), None, "wtf");

// descriptors work also for root types
assert_eq!(root_hook.get(&txn), Some(root));

pub fn into_nested(self) -> Option<Nested<S>>

Attempts to convert current Hook type into Nested one. Returns None if current descriptor doesn’t reference a nested shared collection.

impl<S> Hook<S>

where S: RootRef,

pub fn into_root(self) -> Option<Root<S>>

Attempts to convert current Hook type into Root one. Returns None if current descriptor doesn’t reference a root-level shared collection.

Trait Implementations

impl<S> Clone for Hook<S>

where S: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S> Debug for Hook<S>

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

Formats the value using the given formatter.

impl<'de, S> Deserialize<'de> for Hook<S>

fn deserialize<__D>( __deserializer: __D, ) -> Result<Hook<S>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<S> From<BranchID> for Hook<S>

fn from(id: BranchID) -> Hook<S>

Converts to this type from the input type.

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

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

Converts to this type from the input type.

impl<S> From<Root<S>> for Hook<S>

fn from(root: Root<S>) -> Hook<S>

Converts to this type from the input type.

impl<S> Hash for Hook<S>

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

where H: Hasher,

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 Hook<S>

fn into(self) -> BranchID

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

impl<S> PartialEq for Hook<S>

fn eq(&self, other: &Hook<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> Serialize for Hook<S>

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<S> Eq for Hook<S>