Enum 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<'a, T> Add<T> for &'a Rope

where T: Into<Rope>,

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!");

type Output = Rope

The resulting type after applying the + operator.

impl<T> Add<T> for Rope

where T: Into<Rope>,

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!");

type Output = Rope

The resulting type after applying the + operator.

impl Clone for Rope

fn clone(&self) -> Rope

Returns a duplicate 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<'a> From<&'a Arc<Rope>> for Rope

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

impl From<Arc<Rope>> for Rope

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

Converts to this type from the input type.

impl From<String> for Rope

fn from(string: String) -> Self

Converts to this type from the input type.

impl From<char> for Rope

fn from(ch: char) -> Self

Converts to this type from the input type.

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Into<String> for Rope

fn into(self) -> String

Converts this type into the (usually inferred) input type.

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.

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,

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!");

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

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

Examples

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

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

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

Examples

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

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

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

impl PartialEq for Rope

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd 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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

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!");

impl Eq for Rope

impl Send for Rope

impl StructuralPartialEq for Rope

impl Sync for Rope