Struct Bytes

Source

pub struct Bytes { /* private fields */ }

Implementations§

Source §

impl Bytes

Source

pub fn len(&self) -> Point

The Point at the end of the text

Source

pub fn is_empty(&self) -> bool

Whether or not there are any characters in Bytes

§Note

This does not check for tags, so with a Tag::GhostText, there could actually be a “string” of characters on the Text, it just wouldn’t be considered real “text”.

Source

pub fn char_at(&self, p: Point) -> Option<char>

The char at the Point’s position

Source

pub fn buffers(&self, range: impl TextRange) -> Buffers<'_> ⓘ

An Iterator over the bytes in a given range

If the range is fully or partially out of bounds, one or both of the slices might be empty.

Source

pub fn strs(&self, range: impl TextRange) -> Strs<'_> ⓘ

An Iterator over the &strs of the Text

§Note

The reason why this function returns two strings is that the contents of the text are stored in a GapBuffer, which works with two strings.

If you want to iterate over them, you can do the following:

let bytes = text.bytes();
bytes.strs((p0, p1)).flat_map(str::chars);

Do note that you should avoid iterators like str::lines, as they will separate the line that is partially owned by each &str:

let broken_up_line = [
    "This is line 1, business as usual.\nThis is line 2, but it",
    "is broken into two separate strings.\nSo 4 lines would be counted, \
     instead of 3",
];

§`TextRange` behavior:

If you give a single usize/Point, it will be interpreted as a range from.

If you want the two full &strs, see strs

Source

pub fn lines( &mut self, range: impl TextRange, ) -> impl DoubleEndedIterator<Item = (usize, &str)> + '_

Returns an iterator over the lines in a given range

The lines are inclusive, that is, it will iterate over the whole line, not just the parts within the range.

§NOTE

The reason why this requires mutable access is because we may need to move the GapBuffer’s gap in order to make the range contiguous for proper iteration.

Source

pub fn point_at(&self, b: usize) -> Point

The Point corresponding to the byte position, 0 indexed

If the byte position would fall in between two characters (because the first one comprises more than one byte), the first character is chosen as the Point where the byte is located.

§Panics

Will panic if b is greater than the length of the text

Source

pub fn point_at_char(&self, c: usize) -> Point

The Point associated with the cth char

§Panics

Will panic if c is greater than the number of chars in the text.

Source

pub fn point_at_line(&self, l: usize) -> Point

The Point where the lth line starts, 0 indexed

If l == number_of_lines, returns the last point of the text.

§Panics

Will panic if the number l is greater than the number of lines on the text

Source

pub fn points_of_line(&self, l: usize) -> [Point; 2]

The start and end Points for the lth line

If l == number_of_lines, these points will be the same.

§Panics

Will panic if the number l is greater than the number of lines on the text

Source

pub fn last_point(&self) -> Option<Point>

The last Point associated with a char

This will give the Point of the last char of the text. The difference between this method and len is that it will return a Point one position earlier than it. If the text is completely empty, it will return None.

Source

pub fn chars_fwd(&self, p: Point) -> impl Iterator<Item = (Point, char)> + '_

A forward iterator of the chars of Bytes

Each char will be accompanied by a Point, which is the position where said character starts, e.g. Point::default() for the first character

Source

pub fn chars_rev(&self, p: Point) -> impl Iterator<Item = (Point, char)> + '_

A reverse iterator of the chars in Bytes

Each char will be accompanied by a Point, which is the position where said character starts, e.g. Point::default() for the first character

Source

pub fn contiguous(&mut self, range: impl TextRange) -> &str

Gets a single &str from a given range

This is the equivalent of calling Bytes::make_contiguous and Bytes::get_contiguous. While this takes less space in code, calling the other two functions means that you won’t be mutably borrowing the Bytes anymore, so if that matters to you, you should do that.

Source