Struct Node 

pub struct Node<N>(/* private fields */)
where
    N: NodeInfo;

A b-tree node storing leaves at the bottom, and with info retained at each node. It is implemented with atomic reference counting and copy-on-write semantics, so an immutable clone is a very cheap operation, and nodes can be shared across threads. Even so, it is designed to be updated in place, with efficiency similar to a mutable data structure, using uniqueness of reference count to detect when this operation is safe.

When the leaf is a string, this is a rope data structure (a persistent rope in functional programming jargon). However, it is not restricted to strings, and it is expected to be the basis for a number of data structures useful for text processing.

Implementations

impl Node<BreaksInfo>

pub fn new_no_break(len: usize) -> Node<BreaksInfo>

impl Node<RopeInfo>

pub fn edit_str<T>(&mut self, iv: T, new: &str)

where T: IntervalBounds,

👎Deprecated since 0.3.0:

Use Rope::edit instead

Edit the string, replacing the byte range [start..end] with new.

Time complexity: O(log n)

pub fn slice<T>(&self, iv: T) -> Node<RopeInfo>

where T: IntervalBounds,

Returns a new Rope with the contents of the provided range.

pub fn is_codepoint_boundary(&self, offset: usize) -> bool

Determine whether offset lies on a codepoint boundary.

pub fn prev_codepoint_offset(&self, offset: usize) -> Option<usize>

Return the offset of the codepoint before offset.

pub fn next_codepoint_offset(&self, offset: usize) -> Option<usize>

Return the offset of the codepoint after offset.

pub fn at_or_next_codepoint_boundary(&self, offset: usize) -> Option<usize>

Returns offset if it lies on a codepoint boundary. Otherwise returns the codepoint after offset.

pub fn at_or_prev_codepoint_boundary(&self, offset: usize) -> Option<usize>

Returns offset if it lies on a codepoint boundary. Otherwise returns the codepoint before offset.

pub fn prev_grapheme_offset(&self, offset: usize) -> Option<usize>

pub fn next_grapheme_offset(&self, offset: usize) -> Option<usize>

pub fn line_of_offset(&self, offset: usize) -> usize

Return the line number corresponding to the byte index offset.

The line number is 0-based, thus this is equivalent to the count of newlines in the slice up to offset.

Time complexity: O(log n)

Panics

This function will panic if offset > self.len(). Callers are expected to validate their input.

pub fn offset_of_line(&self, line: usize) -> usize

Return the byte offset corresponding to the line number line. If line is equal to one plus the current number of lines, this returns the offset of the end of the rope. Arguments higher than this will panic.

The line number is 0-based.

Time complexity: O(log n)

Panics

This function will panic if line > self.measure::<LinesMetric>() + 1. Callers are expected to validate their input.

pub fn iter_chunks<T>(&self, range: T) -> ChunkIter<'_>

where T: IntervalBounds,

Returns an iterator over chunks of the rope.

Each chunk is a &str slice borrowed from the rope’s storage. The size of the chunks is indeterminate but for large strings will generally be in the range of 511-1024 bytes.

The empty string will yield a single empty slice. In all other cases, the slices will be nonempty.

Time complexity: technically O(n log n), but the constant factor is so tiny it is effectively O(n). This iterator does not allocate.

pub fn lines_raw<T>(&self, range: T) -> LinesRaw<'_>

where T: IntervalBounds,

An iterator over the raw lines. The lines, except the last, include the terminating newline.

The return type is a Cow<str>, and in most cases the lines are slices borrowed from the rope.

pub fn lines<T>(&self, range: T) -> Lines<'_>

where T: IntervalBounds,

An iterator over the lines of a rope.

Lines are ended with either Unix (\n) or MS-DOS (\r\n) style line endings. The line ending is stripped from the resulting string. The final line ending is optional.

The return type is a Cow<str>, and in most cases the lines are slices borrowed from the rope.

The semantics are intended to match str::lines().

pub fn byte_at(&self, offset: usize) -> u8

pub fn slice_to_cow<T>(&self, range: T) -> Cow<'_, str>

where T: IntervalBounds,

impl<T> Node<SpansInfo<T>>

where T: Clone,

pub fn transform<N>( &self, base_start: usize, base_end: usize, xform: &mut Transformer<'_, N>, ) -> Node<SpansInfo<T>>

where N: NodeInfo,

Perform operational transformation on a spans object intended to be edited into a sequence at the given offset.

pub fn merge<F, O>( &self, other: &Node<SpansInfo<T>>, f: F, ) -> Node<SpansInfo<O>>

where F: FnMut(&T, Option<&T>) -> O, O: Clone,

Creates a new Spans instance by merging spans from other with self, using a closure to transform values.

New spans are created from non-overlapping regions of existing spans, and by combining overlapping regions into new spans. In all cases, new values are generated by calling a closure that transforms the value of the existing span or spans.

Panics

Panics if self and other have different lengths.

pub fn iter(&self) -> SpanIter<'_, T>

pub fn iter_chunks<I>(&self, range: I) -> SpanIter<'_, T>

where I: IntervalBounds,

pub fn apply_shape<M>(&mut self, delta: &Delta<M>)

where M: NodeInfo,

Applies a generic delta to self, inserting empty spans for any added regions.

This is intended to be used to keep spans up to date with a Rope as edits occur.

pub fn delete_after(&mut self, interval: Interval)

Deletes all spans that intersect with interval and that come after.

impl<N> Node<N>

where N: NodeInfo,

pub fn from_leaf(l: <N as NodeInfo>::L) -> Node<N>

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn info(&self) -> &N

pub fn ptr_eq(&self, other: &Node<N>) -> bool

Returns true if these two Nodes share the same underlying data.

This is principally intended to be used by the druid crate, without needing to actually add a feature and implement druid’s Data trait.

pub fn concat(rope1: Node<N>, rope2: Node<N>) -> Node<N>

pub fn measure<M>(&self) -> usize

where M: Metric<N>,

pub fn subseq<T>(&self, iv: T) -> Node<N>

where T: IntervalBounds,

pub fn edit<T, IV>(&mut self, iv: IV, new: T)

where T: Into<Node<N>>, IV: IntervalBounds,

pub fn count_unit<U, C>(&self, m: U) -> usize

where C: UnitConverter<N, U>, U: PartialOrd + Sub<Output = U>,

Given the measured units, how many base units are there

pub fn measure_unit<U, C>(&self, base: usize) -> U

where C: UnitConverter<N, U>, U: Default + Add<Output = U>,

Measure the tree given the base units

pub fn convert<U1, C1, U2, C2>(&self, m1: U1) -> U2

where C1: UnitConverter<N, U1>, C2: UnitConverter<N, U2>, U1: PartialOrd + Sub<Output = U1>, U2: Default + Add<Output = U2>,

Convert the measured units between converters

pub fn convert_metrics<M1, M2>(&self, m1: usize) -> usize

where M1: Metric<N>, M2: Metric<N>,

impl<N> Node<N>

where N: DefaultMetric,

pub fn count<M>(&self, offset: usize) -> usize

where M: Metric<N>,

Measures the length of the text bounded by DefaultMetric::measure(offset) with another metric.

Examples

use crate::xi_rope::{Rope, LinesMetric};

// the default metric of Rope is BaseMetric (aka number of bytes)
let my_rope = Rope::from("first line \n second line \n");

// count the number of lines in my_rope
let num_lines = my_rope.count::<LinesMetric>(my_rope.len());
assert_eq!(2, num_lines);

pub fn count_base_units<M>(&self, offset: usize) -> usize

where M: Metric<N>,

Measures the length of the text bounded by M::measure(offset) with the default metric.

Examples

use crate::xi_rope::{Rope, LinesMetric};

// the default metric of Rope is BaseMetric (aka number of bytes)
let my_rope = Rope::from("first line \n second line \n");

// get the byte offset of the line at index 1
let byte_offset = my_rope.count_base_units::<LinesMetric>(1);
assert_eq!(12, byte_offset);

Trait Implementations

impl Add for Node<RopeInfo>

type Output = Node<RopeInfo>

The resulting type after applying the + operator.

fn add(self, rhs: Node<RopeInfo>) -> Node<RopeInfo>

Performs the + operation.

impl<N> Clone for Node<N>

where N: Clone + NodeInfo,

fn clone(&self) -> Node<N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Node<RopeInfo>

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

Formats the value using the given formatter.

impl<T> Debug for Node<SpansInfo<T>>

where T: Clone + Debug,

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

Formats the value using the given formatter.

impl<N> Default for Node<N>

where N: NodeInfo,

fn default() -> Node<N>

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Node<RopeInfo>

fn deserialize<D>( deserializer: D, ) -> Result<Node<RopeInfo>, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Node<RopeInfo>

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

Formats the value using the given formatter.

impl<'a> From<&'a Node<RopeInfo>> for RopeTextRef<'a>

fn from(text: &'a Node<RopeInfo>) -> RopeTextRef<'a>

Converts to this type from the input type.

impl From<Node<RopeInfo>> for RopeTextVal

fn from(text: Node<RopeInfo>) -> RopeTextVal

Converts to this type from the input type.

impl<T> From<T> for Node<RopeInfo>

where T: AsRef<str>,

fn from(s: T) -> Node<RopeInfo>

Converts to this type from the input type.

impl FromStr for Node<RopeInfo>

type Err = Infallible

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Node<RopeInfo>, <Node<RopeInfo> as FromStr>::Err>

Parses a string s to return a value of this type.

impl RopeText for Node<RopeInfo>

fn text(&self) -> &Node<RopeInfo>

fn len(&self) -> usize

fn is_empty(&self) -> bool

fn last_line(&self) -> usize

The last line of the held rope

fn offset_of_line(&self, line: usize) -> usize

Get the offset into the rope of the start of the given line. If the line it out of bounds, then the last offset (the len) is returned.

fn offset_line_end(&self, offset: usize, caret: bool) -> usize

fn line_of_offset(&self, offset: usize) -> usize

fn offset_to_line_col(&self, offset: usize) -> (usize, usize)

fn offset_of_line_col(&self, line: usize, col: usize) -> usize

Get the offset for a specific line and column.

fn line_end_col(&self, line: usize, caret: bool) -> usize

fn line_end_offset(&self, line: usize, caret: bool) -> usize

Get the offset of the end of the line. The caret decides whether it is after the last character, or before it. If the line is out of bounds, then the last offset (the len) is returned.

fn line_content(&self, line: usize) -> Cow<'_, str>

Returns the content of the given line. Includes the line ending if it exists. (-> the last line won’t have a line ending) Lines past the end of the document will return an empty string.

fn prev_grapheme_offset( &self, offset: usize, count: usize, limit: usize, ) -> usize

Get the offset of the previous grapheme cluster.

fn next_grapheme_offset( &self, offset: usize, count: usize, limit: usize, ) -> usize

fn prev_code_boundary(&self, offset: usize) -> usize

fn next_code_boundary(&self, offset: usize) -> usize

fn select_word(&self, offset: usize) -> (usize, usize)

Return the previous and end boundaries of the word under cursor.

fn first_non_blank_character_on_line(&self, line: usize) -> usize

Returns the offset of the first non-blank character on the given line. If the line is one past the last line, then the offset at the end of the rope is returned. If the line is further past that, then it defaults to the last line.

fn indent_on_line(&self, line: usize) -> String

fn slice_to_cow(&self, range: Range<usize>) -> Cow<'_, str>

Get the content of the rope as a Cow string, for ‘nice’ ranges (small, and at the right offsets) this will be a reference to the rope’s data. Otherwise, it allocates a new string. You should be somewhat wary of requesting large parts of the rope, as it will allocate a new string since it isn’t contiguous in memory for large chunks.

fn char_indices_iter<'a, T>( &'a self, range: T, ) -> CharIndicesJoin<CharIndices<'a>, Map<ChunkIter<'a>, fn(&str) -> CharIndices<'_>>>

where T: IntervalBounds,

Iterate over (utf8_offset, char) values in the given range. This uses iter_chunks and so does not allocate, compared to Self::slice_to_cow which can

fn num_lines(&self) -> usize

The number of lines in the file

fn line_len(&self, line: usize) -> usize

The length of the given line

fn is_line_whitespace(&self, line: usize) -> bool

Returns true if the given line contains no non-whitespace characters.

fn move_left(&self, offset: usize, mode: Mode, count: usize) -> usize

fn move_right(&self, offset: usize, mode: Mode, count: usize) -> usize

fn find_nth_paragraph<F>( &self, offset: usize, count: usize, find_next: F, ) -> usize

where F: FnMut(&mut ParagraphCursor<'_>) -> Option<usize>,

fn move_n_paragraphs_forward(&self, offset: usize, count: usize) -> usize

fn move_n_paragraphs_backward(&self, offset: usize, count: usize) -> usize

fn find_nth_word<F>(&self, offset: usize, count: usize, find_next: F) -> usize

where F: FnMut(&mut WordCursor<'_>) -> Option<usize>,

Find the nth (count) word starting at offset in either direction depending on find_next.

fn move_n_words_forward(&self, offset: usize, count: usize) -> usize

fn move_n_wordends_forward( &self, offset: usize, count: usize, inserting: bool, ) -> usize

fn move_n_words_backward( &self, offset: usize, count: usize, mode: Mode, ) -> usize

fn move_word_backward_deletion(&self, offset: usize) -> usize

impl Serialize for Node<RopeInfo>

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.