Enum loro_delta::DeltaItem

pub enum DeltaItem<V, Attr> {
    Retain {
        len: usize,
        attr: Attr,
    },
    Replace {
        value: V,
        attr: Attr,
        delete: usize,
    },
}

Variants

Retain

Fields

len: usize

attr: Attr

Replace

This is the combined of a delete and an insert.

They are two separate operations in the original Quill Delta format. But the order of two neighboring delete and insert operations can be swapped without changing the result. So Quill requires that the insert always comes before the delete. So it creates room for invalid deltas by the type system. Using Replace is a way to avoid this.

Fields

value: V

attr: Attr

delete: usize

Implementations

impl<V: DeltaValue, Attr> DeltaItem<V, Attr>

pub fn delta_len(&self) -> usize

The real length of the item in the delta

pub fn data_len(&self) -> usize

pub fn new_insert(value: V, attr: Attr) -> Self

impl<V: DeltaValue, Attr: Default> DeltaItem<V, Attr>

pub fn new_delete(len: usize) -> Self

impl<V, Attr> DeltaItem<V, Attr>

pub fn as_retain_mut(&mut self) -> Option<(&mut usize, &mut Attr)>

Optionally returns mutable references to the inner fields if this is a DeltaItem::Retain, otherwise None

pub fn as_retain(&self) -> Option<(&usize, &Attr)>

Optionally returns references to the inner fields if this is a DeltaItem::Retain, otherwise None

pub fn into_retain(self) -> Result<(usize, Attr), Self>

Returns the inner fields if this is a DeltaItem::Retain, otherwise returns back the enum in the Err case of the result

pub fn as_replace_mut(&mut self) -> Option<(&mut V, &mut Attr, &mut usize)>

Optionally returns mutable references to the inner fields if this is a DeltaItem::Replace, otherwise None

pub fn as_replace(&self) -> Option<(&V, &Attr, &usize)>

Optionally returns references to the inner fields if this is a DeltaItem::Replace, otherwise None

pub fn into_replace(self) -> Result<(V, Attr, usize), Self>

Returns the inner fields if this is a DeltaItem::Replace, otherwise returns back the enum in the Err case of the result

Trait Implementations

impl<V: DeltaValue, Attr: Clone> CanRemove for DeltaItem<V, Attr>

fn can_remove(&self) -> bool

impl<V: Clone, Attr: Clone> Clone for DeltaItem<V, Attr>

fn clone(&self) -> DeltaItem<V, Attr>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<V: Debug, Attr: Debug> Debug for DeltaItem<V, Attr>

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

Formats the value using the given formatter.

impl<V: DeltaValue, Attr: DeltaAttr> Default for DeltaItem<V, Attr>

fn default() -> Self

Returns the “default value” for a type.

impl<V: DeltaValue, Attr> HasLength for DeltaItem<V, Attr>

fn rle_len(&self) -> usize

This would treat the len of the Delete as 0

impl<V: Mergeable, Attr: PartialEq> Mergeable for DeltaItem<V, Attr>

fn can_merge(&self, rhs: &Self) -> bool

Whether self can merge rhs with self on the left.

fn merge_right(&mut self, rhs: &Self)

fn merge_left(&mut self, left: &Self)

impl<V: PartialEq, Attr: PartialEq> PartialEq for DeltaItem<V, Attr>

fn eq(&self, other: &DeltaItem<V, Attr>) -> 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<V: DeltaValue, Attr: DeltaAttr> Sliceable for DeltaItem<V, Attr>

fn slice_(&mut self, range: impl RangeBounds<usize>)

slice in-place

fn update_with_split( &mut self, range: impl RangeBounds<usize>, f: impl FnOnce(&mut Self) ) -> (Option<Self>, Option<Self>)

Update the slice in the given range. This method may split self into two or three parts. If so, it will make self the leftmost part and return the next split parts.

Example

If self.rle_len() == 10, self.update(1..5) will split self into three parts and update the middle part. It returns the middle and the right part.

fn _slice(&self, range: Range<usize>) -> Self

fn split(&mut self, pos: usize) -> Self

fn slice(&self, range: impl RangeBounds<usize>) -> Self

impl<V: DeltaValue, Attr: Clone + PartialEq + Debug> TryInsert for DeltaItem<V, Attr>

fn try_insert(&mut self, pos: usize, elem: Self) -> Result<(), Self>

where Self: Sized,

impl<V: DeltaValue, Attr: DeltaAttr> DeltaValue for DeltaItem<V, Attr>

impl<V: Eq, Attr: Eq> Eq for DeltaItem<V, Attr>

impl<V, Attr> StructuralPartialEq for DeltaItem<V, Attr>