Enum persistent_rope::Rope

pub enum Rope {
    Node(usize, Arc<Rope>, Arc<Rope>),
    Leaf(Arc<String>),
}

Variants

Node(usize, Arc<Rope>, Arc<Rope>)

Leaf(Arc<String>)

Implementations

impl Rope

pub fn new() -> Self

Examples

use persistent_rope::Rope;
let rope = Rope::new();
assert_eq!(&rope, "");

pub fn len(&self) -> usize

Examples

use persistent_rope::Rope;
let rope = Rope::from("Hello, world!");
assert_eq!(rope.len(), 13);

pub fn bytes_len(&self) -> usize

Examples

use persistent_rope::Rope;
let rope = Rope::from("Hello, world!");
assert_eq!(rope.bytes_len(), 13);

pub fn chars_len(&self) -> usize

Examples

use persistent_rope::Rope;
let rope = Rope::from("長さ");
assert_eq!(rope.chars_len(), 2);

pub fn is_empty(&self) -> bool

Examples

use persistent_rope::Rope;
let rope = Rope::from("Hello, world!");
assert!(!rope.is_empty());

pub fn height(&self) -> usize

Examples

use persistent_rope::Rope;
let a = Rope::from("Hello");
let b = a.insert_at_byte(5, ", world!");
assert_eq!(b.height(), 2);

pub fn count_lines(&self) -> usize

Examples

use persistent_rope::Rope;
let a = Rope::from("Hello,\n");
let b = a.insert_at_byte(5, "world!\n");
assert_eq!(b.count_lines(), 2);

pub fn insert_at_byte<T>(&self, index: usize, value: T) -> Rope where
    T: Into<Rope>, 

Examples

use persistent_rope::Rope;
let rope = Rope::from("Helloworld!");
assert_eq!(&rope.insert_at_byte(5, ", "), "Hello, world!");

pub fn insert<T>(&self, index: usize, value: T) -> Rope where
    T: Into<Rope>, 

Examples

use persistent_rope::Rope;
let rope = Rope::from("長さ");
assert_eq!(&rope.insert(1, ", "), "長, さ");

pub fn insert_range_byte<T>(&self, range: Range<usize>, value: T) -> Rope where
    T: Into<Rope>, 

Examples

use persistent_rope::Rope;
let rope = Rope::from("Hello world");
assert_eq!(&rope.insert_range_byte(5..6, ", "), "Hello, world");
assert_eq!(&rope.insert_range_byte(0..0, "!"), "!Hello world");
assert_eq!(&rope.insert_range_byte(11..11, "!"), "Hello world!");

pub fn insert_range<T>(&self, range: Range<usize>, value: T) -> Rope where
    T: Into<Rope>, 

Examples

use persistent_rope::Rope;
let rope = Rope::from("長 さ");
assert_eq!(&rope.insert_range(1..2, ", "), "長, さ");
assert_eq!(&rope.insert_range(0..0, "!"), "!長 さ");
assert_eq!(&rope.insert_range(3..3, "!"), "長 さ!");

pub fn insert_char_at_byte(&self, index: usize, ch: char) -> Rope

Examples

use persistent_rope::Rope;
let a = Rope::from("Hello").concat(" world");
let b = a.insert_char_at_byte(5, ',');
let c = b.insert_char_at_byte(12, '!');
assert_eq!(&b, "Hello, world");
assert_eq!(&c, "Hello, world!");

pub fn insert_char(&self, index: usize, ch: char) -> Rope

Examples

use persistent_rope::Rope;
let a = Rope::from("長").concat("さ");
let b = a.insert_char(1, ',');
let c = b.insert_char(3, '!');
assert_eq!(&b, "長,さ");
assert_eq!(&c, "長,さ!");

pub fn remove_range_byte(&self, range: Range<usize>) -> Rope

Examples

use persistent_rope::Rope;
let rope = Rope::from("Hello, world!");
assert_eq!(&rope.remove_range_byte(5..13), "Hello");

pub fn remove_range(&self, range: Range<usize>) -> Rope

Examples

use persistent_rope::Rope;
let rope = Rope::from("長 さ");
assert_eq!(&rope.remove_range(1..2), "長さ");

pub fn remove_at_byte(&self, index: usize) -> Rope

Examples

use persistent_rope::Rope;
let rope = Rope::from("Hello, world!");
assert_eq!(&rope.remove_at_byte(12), "Hello, world");
assert_eq!(&rope.remove_at_byte(5), "Hello world!");

pub fn remove(&self, index: usize) -> Rope

Examples

use persistent_rope::Rope;
let rope = Rope::from("長さ");
assert_eq!(&rope.remove(0), "さ");
assert_eq!(&rope.remove(1), "長");

pub fn split_at_byte(&self, index: usize) -> (Rope, Rope)

Examples

use persistent_rope::Rope;

let rope = Rope::from("Hello, world!");
let (left, right) = rope.split_at_byte(7);
assert_eq!(&left, "Hello, ");
assert_eq!(&right, "world!");

let rope = Rope::new();
let (left, right) = rope.split_at_byte(0);
assert_eq!(&left, "");
assert_eq!(&right, "");

pub fn split(&self, index: usize) -> (Rope, Rope)

Examples

use persistent_rope::Rope;

let rope = Rope::from("長さ");
let (left, right) = rope.split(1);
assert_eq!(&left, "長");
assert_eq!(&right, "さ");

pub fn concat<T>(&self, value: T) -> Rope where
    T: Into<Rope>, 

Examples

use persistent_rope::Rope;
let left = Rope::from("Hello, ");
let right = Rope::from("world!");
assert_eq!(&left.concat(right), "Hello, world!");

pub fn concat_char(&self, ch: char) -> Rope

Examples

use persistent_rope::Rope;
let rope = Rope::from("Hello").concat(", world");
println!("{:?}", rope);
assert_eq!(&rope.concat_char('!'), "Hello, world!");

pub fn char_at(&self, index: usize) -> Option<char>

Examples

use persistent_rope::Rope;
let rope = Rope::from("長").concat(", さ!");
assert_eq!(rope.char_at(0), Some('長'));
assert_eq!(rope.char_at(1), Some(','));
assert_eq!(rope.char_at(2), Some(' '));
assert_eq!(rope.char_at(3), Some('さ'));
assert_eq!(rope.char_at(4), Some('!'));

pub fn chunks(&self) -> Chunks

Examples

use persistent_rope::Rope;
let rope = Rope::from("Hello").concat(", world!");
assert_eq!(rope.chunks().collect::<Vec<&String>>(), ["Hello", ", world!"].to_vec());

pub fn bytes(&self) -> Bytes

Examples

use persistent_rope::Rope;
let rope = Rope::from("Hello");
assert_eq!(rope.bytes().collect::<Vec<u8>>(), [72, 101, 108, 108, 111].to_vec());

pub fn chars(&self) -> Chars

Examples

use persistent_rope::Rope;
let rope = Rope::from("Hello");
assert_eq!(rope.chars().collect::<Vec<char>>(), ['H', 'e', 'l', 'l', 'o'].to_vec());

pub fn lines(&self) -> Lines

Examples

use persistent_rope::Rope;
let rope = Rope::from("Hello\n world!");
let lines = rope.lines().collect::<Vec<String>>();
assert_eq!(lines.get(0), Some(&String::from("Hello")));
assert_eq!(lines.get(1), Some(&String::from(" world!")));

pub fn iter(&self) -> Chars

Trait Implementations

impl<T> Add<T> for Rope where
    T: Into<Rope>, 

type Output = Rope

The resulting type after applying the + operator.

fn add(self, other: T) -> Self::Output

Examples

use persistent_rope::Rope;
let a = Rope::from("Hello");
let b = Rope::from(", world!");
assert_eq!(a.clone() + b, "Hello, world!");
assert_eq!(a + ", world!", "Hello, world!");

impl<'a, T> Add<T> for &'a Rope where
    T: Into<Rope>, 

type Output = Rope

The resulting type after applying the + operator.

fn add(self, other: T) -> Self::Output

Examples

use persistent_rope::Rope;
let a = Rope::from("Hello");
let b = Rope::from(", world!");
assert_eq!(&a + &b, "Hello, world!");
assert_eq!(&a + b.clone(), "Hello, world!");
assert_eq!(a.clone() + &b, "Hello, world!");

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

Formats the value using the given formatter.

impl Eq for Rope

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

fn from(rope: &'a Arc<Rope>) -> Rope

Performs the conversion.

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

fn from(rope: &'a Rope) -> Bytes<'a>

Performs the conversion.

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

fn from(rope: &'a Rope) -> Chars<'a>

Performs the conversion.

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

fn from(rope: &'a Rope) -> Self

Performs the conversion.

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

fn from(rope: &'a Rope) -> Lines<'a>

Performs the conversion.

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

fn from(rope: &'a Rope) -> Rope

Performs the conversion.

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

fn from(string: &'a String) -> Self

Performs the conversion.

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

fn from(string: &'a str) -> Self

Performs the conversion.

impl From<Arc<Rope>> for Rope

fn from(arc: Arc<Rope>) -> Rope

Performs the conversion.

impl From<String> for Rope

fn from(string: String) -> Self

Performs the conversion.

impl From<char> for Rope

fn from(ch: char) -> Self

Performs the conversion.

impl Hash for Rope

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, 

Feeds a slice of this type into the given [Hasher].

impl Into<String> for Rope

fn into(self) -> String

Performs the conversion.

impl<'a> IntoIterator for &'a Rope

type Item = char

The type of the elements being iterated over.

type IntoIter = Chars<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl Ord for Rope

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

This method returns an [Ordering] between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

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

fn eq(&self, other: &&'a str) -> bool

Examples

use persistent_rope::Rope;
let rope = Rope::from("Hello, world!");
assert_eq!(&rope, "Hello, world!");
assert_ne!(&rope, "Hello!");

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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: &Rope) -> bool

This method tests for !=.

impl PartialEq<String> for Rope

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

Examples

use persistent_rope::Rope;
let rope = Rope::from("Hello, world!");
assert_eq!(&rope, &String::from("Hello, world!"));
assert_ne!(&rope, &String::from("Hello!"));

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<str> for Rope

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

Examples

use persistent_rope::Rope;
let rope = Rope::from("Hello, world!");
assert_eq!(rope, "Hello, world!");
assert_ne!(rope, "Hello!");

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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: &Rope) -> bool

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

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

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

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

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

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

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

impl Send for Rope

impl StructuralEq for Rope

impl StructuralPartialEq for Rope

impl Sync for Rope

impl ToString for Rope

fn to_string(&self) -> String

Examples

use persistent_rope::Rope;
let rope = Rope::from("Hello, world!");
assert_eq!(rope.to_string(), "Hello, world!");