Struct yrs::StickyIndex

pub struct StickyIndex {
    pub assoc: Assoc,
    /* private fields */
}

A sticky index is based on the Yjs model and is not affected by document changes. E.g. If you place a sticky index before a certain character, it will always point to this character. If you place a sticky index at the end of a type, it will always point to the end of the type.

A numeric position is often unsuited for user selections, because it does not change when content is inserted before or after.

Insert(0, 'x')('a.bc') = 'xa.bc' Where . is the relative position.

Example:

use yrs::{Assoc, Doc, IndexedSequence, Text, Transact};

let doc = Doc::new();
let txt = doc.get_or_insert_text("text");
let mut txn = doc.transact_mut();
txt.insert(&mut txn, 0, "abc"); // => 'abc'

// create position tracker (marked as . in the comments)
let pos = txt.sticky_index(&mut txn, 2, Assoc::After).unwrap(); // => 'ab.c'

// modify text
txt.insert(&mut txn, 1, "def"); // => 'adefb.c'
txt.remove_range(&mut txn, 4, 1); // => 'adef.c'

// get current offset index within the containing collection
let a = pos.get_offset(&txn).unwrap();
assert_eq!(a.index, 4);

Fields

assoc: Assoc

If true - associate to the right block. Otherwise, associate to the left one.

Implementations

impl StickyIndex

pub fn new(scope: IndexScope, assoc: Assoc) -> Self

pub fn from_id(id: ID, assoc: Assoc) -> Self

pub fn from_type<T, B>(_txn: &T, branch: &B, assoc: Assoc) -> Self

where T: ReadTxn, B: AsRef<Branch>,

pub fn scope(&self) -> &IndexScope

pub fn id(&self) -> Option<&ID>

Returns an ID of the block position which is used as a reference to keep track the location of current StickyIndex even in face of changes performed by different peers.

Returns None if current StickyIndex has been created on an empty shared collection (in that case there’s no block that we can refer to).

pub fn get_offset<T: ReadTxn>(&self, txn: &T) -> Option<Offset>

Maps current StickyIndex onto Offset which points to shared collection and a human-readable index in that collection.

That index is only valid at the current point in time - if i.e. another update from remote peer has been applied, it may have changed relative index position that StickyIndex points to, so that Offset’s index will no longer point to the same place.

Examples

use yrs::{Assoc, Doc, IndexedSequence, Text, Transact};

let doc = Doc::new();
let text = doc.get_or_insert_text("text");
let mut txn = doc.transact_mut();

text.insert(&mut txn, 0, "hello world");

const INDEX: u32 = 4;

// set perma index at position before letter 'o' => "hell.o world"
let pos = text.sticky_index(&mut txn, INDEX, Assoc::After).unwrap();
let off = pos.get_offset(&txn).unwrap();
assert_eq!(off.index, INDEX);

// perma index will maintain it's position before letter 'o' even if another update
// shifted it's index inside of the text
text.insert(&mut txn, 1, "(see)"); // => "h(see)ell.o world" where . is perma index position
let off2 = pos.get_offset(&txn).unwrap();
assert_ne!(off2.index, off.index); // offset index changed due to new insert above

pub fn at<T: ReadTxn>( txn: &T, branch: BranchPtr, index: u32, assoc: Assoc ) -> Option<Self>

Trait Implementations

impl Clone for StickyIndex

fn clone(&self) -> StickyIndex

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for StickyIndex

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

Formats the value using the given formatter.

impl Decode for StickyIndex

fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, Error>

fn decode_v1(data: &[u8]) -> Result<Self, Error>

Helper function for decoding 1st version of lib0 encoding.

fn decode_v2(data: &[u8]) -> Result<Self, Error>

Helper function for decoding 2nd version of lib0 encoding.

impl<'de> Deserialize<'de> for StickyIndex

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for StickyIndex

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

Formats the value using the given formatter.

impl Encode for StickyIndex

fn encode<E: Encoder>(&self, encoder: &mut E)

fn encode_v1(&self) -> Vec<u8>

Helper function for encoding 1st version of lib0 encoding.

fn encode_v2(&self) -> Vec<u8>

Helper function for encoding 1st version of lib0 encoding.

impl Hash for StickyIndex

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 Ord for StickyIndex

fn cmp(&self, other: &StickyIndex) -> 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 + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for StickyIndex

fn eq(&self, other: &StickyIndex) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd for StickyIndex

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

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

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl Serialize for StickyIndex

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for StickyIndex

impl StructuralPartialEq for StickyIndex