Struct freya::hooks::Rope

pub struct Rope { /* private fields */ }

A utf8 text rope.

The time complexity of nearly all edit and query operations on Rope are worst-case O(log N) in the length of the rope. Rope is designed to work efficiently even for huge (in the gigabytes) and pathological (all on one line) texts.

Editing Operations

The primary editing operations on Rope are insertion and removal of text. For example:

let mut rope = Rope::from_str("Hello みんなさん!");
rope.remove(6..11);
rope.insert(6, "world");

assert_eq!(rope, "Hello world!");

Query Operations

Rope provides a rich set of efficient query functions, including querying rope length in bytes/chars/lines, fetching individual chars or lines, and converting between byte/char/line indices. For example, to find the starting char index of a given line:

let rope = Rope::from_str("Hello みんなさん!\nHow are you?\nThis text has multiple lines!");

assert_eq!(rope.line_to_char(0), 0);
assert_eq!(rope.line_to_char(1), 13);
assert_eq!(rope.line_to_char(2), 26);

Slicing

You can take immutable slices of a Rope using slice():

let mut rope = Rope::from_str("Hello みんなさん!");
let middle = rope.slice(3..8);

assert_eq!(middle, "lo みん");

Cloning

Cloning Ropes is extremely cheap, running in O(1) time and taking a small constant amount of memory for the new clone, regardless of text size. This is accomplished by data sharing between Rope clones. The memory used by clones only grows incrementally as the their contents diverge due to edits. All of this is thread safe, so clones can be sent freely between threads.

The primary intended use-case for this feature is to allow asynchronous processing of Ropes. For example, saving a large document to disk in a separate thread while the user continues to perform edits.

Implementations

impl Rope

pub fn new() -> Rope

Creates an empty Rope.

pub fn from_str(text: &str) -> Rope

Creates a Rope from a string slice.

Runs in O(N) time.

pub fn from_reader<T>(reader: T) -> Result<Rope, Error>where T: Read,

Creates a Rope from the output of a reader.

This is a convenience function, and provides no specific guarantees about performance or internal implementation aside from the runtime complexity listed below.

When more precise control over IO behavior, buffering, etc. is desired, you should handle IO yourself and use [RopeBuilder] to build the Rope.

Runs in O(N) time.

Errors

• If the reader returns an error, from_reader stops and returns that error.
• If non-utf8 data is encountered, an IO error with kind InvalidData is returned.

Note: some data from the reader is likely consumed even if there is an error.

pub fn write_to<T>(&self, writer: T) -> Result<(), Error>where T: Write,

Writes the contents of the Rope to a writer.

This is a convenience function, and provides no specific guarantees about performance or internal implementation aside from the runtime complexity listed below.

When more precise control over IO behavior, buffering, etc. is desired, you should handle IO yourself and use the [Chunks] iterator to iterate through the Rope’s contents.

Runs in O(N) time.

Errors

• If the writer returns an error, write_to stops and returns that error.

Note: some data may have been written even if an error is returned.

pub fn len_bytes(&self) -> usize

Total number of bytes in the Rope.

Runs in O(1) time.

pub fn len_chars(&self) -> usize

Total number of chars in the Rope.

Runs in O(1) time.

pub fn len_lines(&self) -> usize

Total number of lines in the Rope.

Runs in O(1) time.

pub fn len_utf16_cu(&self) -> usize

Total number of utf16 code units that would be in Rope if it were encoded as utf16.

Ropey stores text internally as utf8, but sometimes it is necessary to interact with external APIs that still use utf16. This function is primarily intended for such situations, and is otherwise not very useful.

Runs in O(1) time.

pub fn capacity(&self) -> usize

Total size of the Rope’s text buffer space, in bytes.

This includes unoccupied text buffer space. You can calculate the unoccupied space with capacity() - len_bytes(). In general, there will always be some unoccupied buffer space.

Runs in O(N) time.

pub fn shrink_to_fit(&mut self)

Shrinks the Rope’s capacity to the minimum possible.

This will rarely result in capacity() == len_bytes(). Rope stores text in a sequence of fixed-capacity chunks, so an exact fit only happens for texts that are both a precise multiple of that capacity and have code point boundaries that line up exactly with the capacity boundaries.

After calling this, the difference between capacity() and len_bytes() is typically under 1KB per megabyte of text in the Rope.

NOTE: calling this on a Rope clone causes it to stop sharing all data with its other clones. In such cases you will very likely be increasing total memory usage despite shrinking the Rope’s capacity.

Runs in O(N) time, and uses O(log N) additional space during shrinking.

pub fn insert(&mut self, char_idx: usize, text: &str)

Inserts text at char index char_idx.

Runs in O(M + log N) time, where N is the length of the Rope and M is the length of text.

Panics

Panics if char_idx is out of bounds (i.e. char_idx > len_chars()).

pub fn insert_char(&mut self, char_idx: usize, ch: char)

Inserts a single char ch at char index char_idx.

Runs in O(log N) time.

Panics

Panics if char_idx is out of bounds (i.e. char_idx > len_chars()).

pub fn remove<R>(&mut self, char_range: R)where R: RangeBounds<usize>,

Removes the text in the given char index range.

Uses range syntax, e.g. 2..7, 2.., etc. The range is in char indices.

Runs in O(M + log N) time, where N is the length of the Rope and M is the length of the range being removed.

Example

let mut rope = Rope::from_str("Hello world!");
rope.remove(5..);

assert_eq!("Hello", rope);

Panics

Panics if the start of the range is greater than the end, or if the end is out of bounds (i.e. end > len_chars()).

pub fn split_off(&mut self, char_idx: usize) -> Rope

Splits the Rope at char_idx, returning the right part of the split.

Runs in O(log N) time.

Panics

Panics if char_idx is out of bounds (i.e. char_idx > len_chars()).

pub fn append(&mut self, other: Rope)

Appends a Rope to the end of this one, consuming the other Rope.

Runs in O(log N) time.

pub fn byte_to_char(&self, byte_idx: usize) -> usize

Returns the char index of the given byte.

Notes:

• If the byte is in the middle of a multi-byte char, returns the index of the char that the byte belongs to.
• byte_idx can be one-past-the-end, which will return one-past-the-end char index.

Runs in O(log N) time.

Panics

Panics if byte_idx is out of bounds (i.e. byte_idx > len_bytes()).

pub fn byte_to_line(&self, byte_idx: usize) -> usize

Returns the line index of the given byte.

Notes:

• Lines are zero-indexed. This is functionally equivalent to counting the line endings before the specified byte.
• byte_idx can be one-past-the-end, which will return the last line index.

Runs in O(log N) time.

Panics

Panics if byte_idx is out of bounds (i.e. byte_idx > len_bytes()).

pub fn char_to_byte(&self, char_idx: usize) -> usize

Returns the byte index of the given char.

Notes:

• char_idx can be one-past-the-end, which will return one-past-the-end byte index.

Runs in O(log N) time.

Panics

Panics if char_idx is out of bounds (i.e. char_idx > len_chars()).

pub fn char_to_line(&self, char_idx: usize) -> usize

Returns the line index of the given char.

Notes:

• Lines are zero-indexed. This is functionally equivalent to counting the line endings before the specified char.
• char_idx can be one-past-the-end, which will return the last line index.

Runs in O(log N) time.

Panics

Panics if char_idx is out of bounds (i.e. char_idx > len_chars()).

pub fn char_to_utf16_cu(&self, char_idx: usize) -> usize

Returns the utf16 code unit index of the given char.

Ropey stores text internally as utf8, but sometimes it is necessary to interact with external APIs that still use utf16. This function is primarily intended for such situations, and is otherwise not very useful.

Runs in O(log N) time.

Panics

Panics if char_idx is out of bounds (i.e. char_idx > len_chars()).

pub fn utf16_cu_to_char(&self, utf16_cu_idx: usize) -> usize

Returns the char index of the given utf16 code unit.

Ropey stores text internally as utf8, but sometimes it is necessary to interact with external APIs that still use utf16. This function is primarily intended for such situations, and is otherwise not very useful.

Note: if the utf16 code unit is in the middle of a char, returns the index of the char that it belongs to.

Runs in O(log N) time.

Panics

Panics if utf16_cu_idx is out of bounds (i.e. utf16_cu_idx > len_utf16_cu()).

pub fn line_to_byte(&self, line_idx: usize) -> usize

Returns the byte index of the start of the given line.

Notes:

• Lines are zero-indexed.
• line_idx can be one-past-the-end, which will return one-past-the-end byte index.

Runs in O(log N) time.

Panics

Panics if line_idx is out of bounds (i.e. line_idx > len_lines()).

pub fn line_to_char(&self, line_idx: usize) -> usize

Returns the char index of the start of the given line.

Notes:

• Lines are zero-indexed.
• line_idx can be one-past-the-end, which will return one-past-the-end char index.

Runs in O(log N) time.

Panics

Panics if line_idx is out of bounds (i.e. line_idx > len_lines()).

pub fn byte(&self, byte_idx: usize) -> u8

Returns the byte at byte_idx.

Runs in O(log N) time.

Panics

Panics if byte_idx is out of bounds (i.e. byte_idx >= len_bytes()).

pub fn char(&self, char_idx: usize) -> char

Returns the char at char_idx.

Runs in O(log N) time.

Panics

Panics if char_idx is out of bounds (i.e. char_idx >= len_chars()).

pub fn line(&self, line_idx: usize) -> RopeSlice<'_>

Returns the line at line_idx.

Note: lines are zero-indexed.

Runs in O(log N) time.

Panics

Panics if line_idx is out of bounds (i.e. line_idx >= len_lines()).

pub fn chunk_at_byte(&self, byte_idx: usize) -> (&str, usize, usize, usize)

Returns the chunk containing the given byte index.

Also returns the byte and char indices of the beginning of the chunk and the index of the line that the chunk starts on.

Note: for convenience, a one-past-the-end byte_idx returns the last chunk of the RopeSlice.

The return value is organized as (chunk, chunk_byte_idx, chunk_char_idx, chunk_line_idx).

Runs in O(log N) time.

Panics

Panics if byte_idx is out of bounds (i.e. byte_idx > len_bytes()).

pub fn chunk_at_char(&self, char_idx: usize) -> (&str, usize, usize, usize)

Returns the chunk containing the given char index.

Also returns the byte and char indices of the beginning of the chunk and the index of the line that the chunk starts on.

Note: for convenience, a one-past-the-end char_idx returns the last chunk of the RopeSlice.

The return value is organized as (chunk, chunk_byte_idx, chunk_char_idx, chunk_line_idx).

Runs in O(log N) time.

Panics

Panics if char_idx is out of bounds (i.e. char_idx > len_chars()).

pub fn chunk_at_line_break( &self, line_break_idx: usize ) -> (&str, usize, usize, usize)

Returns the chunk containing the given line break.

Also returns the byte and char indices of the beginning of the chunk and the index of the line that the chunk starts on.

Note: for convenience, both the beginning and end of the rope are considered line breaks for the purposes of indexing. For example, in the string "Hello \n world!" 0 would give the first chunk, 1 would give the chunk containing the newline character, and 2 would give the last chunk.

The return value is organized as (chunk, chunk_byte_idx, chunk_char_idx, chunk_line_idx).

Runs in O(log N) time.

Panics

Panics if line_break_idx is out of bounds (i.e. line_break_idx > len_lines()).

pub fn slice<R>(&self, char_range: R) -> RopeSlice<'_>where R: RangeBounds<usize>,

Gets an immutable slice of the Rope, using char indices.

Uses range syntax, e.g. 2..7, 2.., etc.

Example

let rope = Rope::from_str("Hello world!");
let slice = rope.slice(..5);

assert_eq!("Hello", slice);

Runs in O(log N) time.

Panics

Panics if the start of the range is greater than the end, or if the end is out of bounds (i.e. end > len_chars()).

pub fn byte_slice<R>(&self, byte_range: R) -> RopeSlice<'_>where R: RangeBounds<usize>,

Gets and immutable slice of the Rope, using byte indices.

Uses range syntax, e.g. 2..7, 2.., etc.

Runs in O(log N) time.

Panics

Panics if:

• The start of the range is greater than the end.
• The end is out of bounds (i.e. end > len_bytes()).
• The range doesn’t align with char boundaries.

pub fn bytes(&self) -> Bytes<'_>

Creates an iterator over the bytes of the Rope.

Runs in O(log N) time.

pub fn bytes_at(&self, byte_idx: usize) -> Bytes<'_>

Creates an iterator over the bytes of the Rope, starting at byte byte_idx.

If byte_idx == len_bytes() then an iterator at the end of the Rope is created (i.e. next() will return None).

Runs in O(log N) time.

Panics

Panics if byte_idx is out of bounds (i.e. byte_idx > len_bytes()).

pub fn chars(&self) -> Chars<'_>

Creates an iterator over the chars of the Rope.

Runs in O(log N) time.

pub fn chars_at(&self, char_idx: usize) -> Chars<'_>

Creates an iterator over the chars of the Rope, starting at char char_idx.

If char_idx == len_chars() then an iterator at the end of the Rope is created (i.e. next() will return None).

Runs in O(log N) time.

Panics

Panics if char_idx is out of bounds (i.e. char_idx > len_chars()).

pub fn lines(&self) -> Lines<'_>

Creates an iterator over the lines of the Rope.

Runs in O(log N) time.

pub fn lines_at(&self, line_idx: usize) -> Lines<'_>

Creates an iterator over the lines of the Rope, starting at line line_idx.

If line_idx == len_lines() then an iterator at the end of the Rope is created (i.e. next() will return None).

Runs in O(log N) time.

Panics

Panics if line_idx is out of bounds (i.e. line_idx > len_lines()).

pub fn chunks(&self) -> Chunks<'_>

Creates an iterator over the chunks of the Rope.

Runs in O(log N) time.

pub fn chunks_at_byte( &self, byte_idx: usize ) -> (Chunks<'_>, usize, usize, usize)

Creates an iterator over the chunks of the Rope, with the iterator starting at the chunk containing byte_idx.

Also returns the byte and char indices of the beginning of the first chunk to be yielded, and the index of the line that chunk starts on.

If byte_idx == len_bytes() an iterator at the end of the Rope (yielding None on a call to next()) is created.

The return value is organized as (iterator, chunk_byte_idx, chunk_char_idx, chunk_line_idx).

Runs in O(log N) time.

Panics

Panics if byte_idx is out of bounds (i.e. byte_idx > len_bytes()).

pub fn chunks_at_char( &self, char_idx: usize ) -> (Chunks<'_>, usize, usize, usize)

Creates an iterator over the chunks of the Rope, with the iterator starting at the chunk containing char_idx.

Also returns the byte and char indices of the beginning of the first chunk to be yielded, and the index of the line that chunk starts on.

If char_idx == len_chars() an iterator at the end of the Rope (yielding None on a call to next()) is created.

The return value is organized as (iterator, chunk_byte_idx, chunk_char_idx, chunk_line_idx).

Runs in O(log N) time.

Panics

Panics if char_idx is out of bounds (i.e. char_idx > len_chars()).

pub fn chunks_at_line_break( &self, line_break_idx: usize ) -> (Chunks<'_>, usize, usize, usize)

Creates an iterator over the chunks of the Rope, with the iterator starting at the chunk containing line_break_idx.

Also returns the byte and char indices of the beginning of the first chunk to be yielded, and the index of the line that chunk starts on.

Note: for convenience, both the beginning and end of the Rope are considered line breaks for the purposes of indexing. For example, in the string "Hello \n world!" 0 would create an iterator starting on the first chunk, 1 would create an iterator starting on the chunk containing the newline character, and 2 would create an iterator at the end of the Rope (yielding None on a call to next()).

The return value is organized as (iterator, chunk_byte_idx, chunk_char_idx, chunk_line_idx).

Runs in O(log N) time.

Panics

Panics if line_break_idx is out of bounds (i.e. line_break_idx > len_lines()).

pub fn is_instance(&self, other: &Rope) -> bool

Returns true if this rope and other point to precisely the same in-memory data.

This happens when one of the ropes is a clone of the other and neither have been modified since then. Because clones initially share all the same data, it can be useful to check if they still point to precisely the same memory as a way of determining whether they are both still unmodified.

Note: this is distinct from checking for equality: two ropes can have the same contents (equal) but be stored in different memory locations (not instances). Importantly, two clones that post-cloning are modified identically will not be instances anymore, even though they will have equal contents.

Runs in O(1) time.

impl Rope

Non-Panicking

The methods in this impl block provide non-panicking versions of Rope’s panicking methods. They return either Option::None or Result::Err() when their panicking counterparts would have panicked.

pub fn try_insert(&mut self, char_idx: usize, text: &str) -> Result<(), Error>

Non-panicking version of insert().

pub fn try_insert_char( &mut self, char_idx: usize, ch: char ) -> Result<(), Error>

Non-panicking version of insert_char().

pub fn try_remove<R>(&mut self, char_range: R) -> Result<(), Error>where R: RangeBounds<usize>,

Non-panicking version of remove().

pub fn try_split_off(&mut self, char_idx: usize) -> Result<Rope, Error>

Non-panicking version of split_off().

pub fn try_byte_to_char(&self, byte_idx: usize) -> Result<usize, Error>

Non-panicking version of byte_to_char().

pub fn try_byte_to_line(&self, byte_idx: usize) -> Result<usize, Error>

Non-panicking version of byte_to_line().

pub fn try_char_to_byte(&self, char_idx: usize) -> Result<usize, Error>

Non-panicking version of char_to_byte().

pub fn try_char_to_line(&self, char_idx: usize) -> Result<usize, Error>

Non-panicking version of char_to_line().

pub fn try_char_to_utf16_cu(&self, char_idx: usize) -> Result<usize, Error>

Non-panicking version of char_to_utf16_cu().

pub fn try_utf16_cu_to_char(&self, utf16_cu_idx: usize) -> Result<usize, Error>

Non-panicking version of utf16_cu_to_char().

pub fn try_line_to_byte(&self, line_idx: usize) -> Result<usize, Error>

Non-panicking version of line_to_byte().

pub fn try_line_to_char(&self, line_idx: usize) -> Result<usize, Error>

Non-panicking version of line_to_char().

pub fn get_byte(&self, byte_idx: usize) -> Option<u8>

Non-panicking version of byte().

pub fn get_char(&self, char_idx: usize) -> Option<char>

Non-panicking version of char().

pub fn get_line(&self, line_idx: usize) -> Option<RopeSlice<'_>>

Non-panicking version of line().

pub fn get_chunk_at_byte( &self, byte_idx: usize ) -> Option<(&str, usize, usize, usize)>

Non-panicking version of chunk_at_byte().

pub fn get_chunk_at_char( &self, char_idx: usize ) -> Option<(&str, usize, usize, usize)>

Non-panicking version of chunk_at_char().

pub fn get_chunk_at_line_break( &self, line_break_idx: usize ) -> Option<(&str, usize, usize, usize)>

Non-panicking version of chunk_at_line_break().

pub fn get_slice<R>(&self, char_range: R) -> Option<RopeSlice<'_>>where R: RangeBounds<usize>,

Non-panicking version of slice().

pub fn get_byte_slice<R>(&self, byte_range: R) -> Option<RopeSlice<'_>>where R: RangeBounds<usize>,

Non-panicking version of byte_slice().

pub fn get_bytes_at(&self, byte_idx: usize) -> Option<Bytes<'_>>

Non-panicking version of bytes_at().

pub fn get_chars_at(&self, char_idx: usize) -> Option<Chars<'_>>

Non-panicking version of chars_at().

pub fn get_lines_at(&self, line_idx: usize) -> Option<Lines<'_>>

Non-panicking version of lines_at().

pub fn get_chunks_at_byte( &self, byte_idx: usize ) -> Option<(Chunks<'_>, usize, usize, usize)>

Non-panicking version of chunks_at_byte().

pub fn get_chunks_at_char( &self, char_idx: usize ) -> Option<(Chunks<'_>, usize, usize, usize)>

Non-panicking version of chunks_at_char().

pub fn get_chunks_at_line_break( &self, line_break_idx: usize ) -> Option<(Chunks<'_>, usize, usize, usize)>

Non-panicking version of chunks_at_line_break().

Trait Implementations

impl Clone for Rope

fn clone(&self) -> Rope

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Rope

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

Formats the value using the given formatter.

impl Default for Rope

fn default() -> Rope

Returns the “default value” for a type.

impl Display for Rope

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

Formats the value using the given formatter.

impl<'a> From<&'a Rope> for Cow<'a, str>

Attempts to borrow the contents of the Rope, but will convert to an owned string if the contents is not contiguous in memory.

Runs in best case O(1), worst case O(N).

fn from(r: &'a Rope) -> Cow<'a, str>

Converts to this type from the input type.

impl<'a> From<&'a Rope> for String

fn from(r: &'a Rope) -> String

Converts to this type from the input type.

impl<'a> From<&'a str> for Rope

fn from(text: &'a str) -> Rope

Converts to this type from the input type.

impl<'a> From<Cow<'a, str>> for Rope

fn from(text: Cow<'a, str>) -> Rope

Converts to this type from the input type.

impl<'a> From<Rope> for Cow<'a, str>

fn from(r: Rope) -> Cow<'a, str>

Converts to this type from the input type.

impl From<Rope> for String

fn from(r: Rope) -> String

Converts to this type from the input type.

impl<'a> From<RopeSlice<'a>> for Rope

Will share data where possible.

Runs in O(log N) time.

fn from(s: RopeSlice<'a>) -> Rope

Converts to this type from the input type.

impl From<String> for Rope

fn from(text: String) -> Rope

Converts to this type from the input type.

impl<'a> FromIterator<&'a str> for Rope

fn from_iter<T>(iter: T) -> Ropewhere T: IntoIterator<Item = &'a str>,

Creates a value from an iterator.

impl<'a> FromIterator<Cow<'a, str>> for Rope

fn from_iter<T>(iter: T) -> Ropewhere T: IntoIterator<Item = Cow<'a, str>>,

Creates a value from an iterator.

impl FromIterator<String> for Rope

fn from_iter<T>(iter: T) -> Ropewhere T: IntoIterator<Item = String>,

Creates a value from an iterator.

impl Hash for Rope

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

fn cmp(&self, other: &Rope) -> Ordering

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl<'a> PartialEq<&'a str> for Rope

fn eq(&self, other: &&'a str) -> 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<'a> PartialEq<Cow<'a, str>> for Rope

fn eq(&self, other: &Cow<'a, str>) -> 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<'a> PartialEq<Rope> for &'a str

fn eq(&self, other: &Rope) -> 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<'a> PartialEq<Rope> for Cow<'a, str>

fn eq(&self, other: &Rope) -> 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 PartialEq<Rope> for Rope

fn eq(&self, other: &Rope) -> 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 PartialEq<Rope> for String

fn eq(&self, other: &Rope) -> 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 PartialEq<Rope> for str

fn eq(&self, other: &Rope) -> 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<'a> PartialEq<RopeSlice<'a>> for Rope

fn eq(&self, other: &RopeSlice<'a>) -> 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 PartialEq<String> for Rope

fn eq(&self, other: &String) -> 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 PartialEq<str> for Rope

fn eq(&self, other: &str) -> 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<Rope> for Rope

fn partial_cmp(&self, other: &Rope) -> 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 Eq for Rope