Struct add_ed::buffer::VecBuffer

pub struct VecBuffer { /* private fields */ }

VecBuffer, the default Buffer implementation

It is based on storing the text in a Vector of lines. Regex functionality is imported from the Regex crate.

Implementations

impl VecBuffer

pub fn new() -> Self

Create a new empty buffer. It is considered saved while unchanged.

Trait Implementations

impl Buffer for VecBuffer

fn len(&self) -> usize

Return the number of lines stored in the buffer

fn is_empty(&self) -> bool

Return true if the buffer is empty

fn get_tag(&self, tag: char) -> Result<usize, &'static str>

Get line tagged with given letter. Not found is error

fn get_matching(
    &self,
    pattern: &str,
    curr_line: usize,
    backwards: bool
) -> Result<usize, &'static str>

Return the nearest previous/following index in the selection that contains the regex pattern

fn mark_matching(
    &mut self,
    pattern: &str,
    selection: (usize, usize),
    inverse: bool
) -> Result<(), &'static str>

Set the matched flag on all lines matching given pattern

fn get_marked(&mut self) -> Result<Option<usize>, &'static str>

Get a line with the matched flag set, clearing that line’s flag

fn tag_line(&mut self, index: usize, tag: char) -> Result<(), &'static str>

Mark a line with a letter, mark with ‘\0’ to clear

fn insert<'a>(
    &mut self,
    data: &mut dyn Iterator<Item = &'a str>,
    index: usize
) -> Result<(), &'static str>

Takes a iterator over lines in strings and inserts after given index

fn cut(&mut self, selection: (usize, usize)) -> Result<(), &'static str>

Cut the selection from the buffer, into the clipboard

fn change<'a>(
    &mut self,
    data: &mut dyn Iterator<Item = &'a str>,
    selection: (usize, usize)
) -> Result<(), &'static str>

Replace selection with input

fn mov(
    &mut self,
    selection: (usize, usize),
    index: usize
) -> Result<(), &'static str>

Move selection to immediately after index

fn mov_copy(
    &mut self,
    selection: (usize, usize),
    index: usize
) -> Result<(), &'static str>

Insert a copy of the selection immediately after index

fn join(&mut self, selection: (usize, usize)) -> Result<(), &'static str>

Join all lines in selection into one line

fn reflow(
    &mut self,
    selection: (usize, usize),
    width: usize
) -> Result<usize, &'static str>

Join all lines to one and split into lines of less than given width Returns end of selection after change

fn copy(&mut self, selection: (usize, usize)) -> Result<(), &'static str>

Copy selected lines into clipboard

fn paste(&mut self, index: usize) -> Result<usize, &'static str>

Paste the clipboard contents after given index Leave clipboard unchanged

fn search_replace(
    &mut self,
    pattern: (&str, &str),
    selection: (usize, usize),
    global: bool
) -> Result<usize, &'static str>

Perform regex search and replace on the selection changing pattern.0 to pattern.1 Should interpret escape sequences in both patterns. At minimum \n and \. If pattern is empty, should re-use stored pattern from previous s command Returns new end of selection, since it may delete or add lines Beware that it may delete the whole selection just as ‘c’

fn read_from(
    &mut self,
    path: &str,
    index: Option<usize>,
    must_exist: bool
) -> Result<usize, &'static str>

Read to the buffer from given path If index is None replaces current buffer with read lines Else inserts read lines after given index Return number of lines read

fn write_to(
    &mut self,
    selection: Option<(usize, usize)>,
    path: &str,
    append: bool
) -> Result<(), &'static str>

Write the buffer to given path

fn saved(&self) -> bool

Returns true if no changes have been made since last saving

fn undo(&mut self, steps: isize) -> Result<(), &'static str>

Undo to given numbers of snapshots back (limited by snapshots created) If negative: redo that number of snapshots instead (limited by undone snapshots) Returns error if steps move to invalid snapshot, use undo_range to get limits

fn undo_range(&self) -> Result<Range<isize>, &'static str>

Get how far forward/backward redo/undo is possible Returns range of allowed undo arguments

fn snapshot(&mut self) -> Result<(), &'static str>

Create a checkpoint to undo/redo to

fn get_selection<'a>(
    &'a self,
    selection: (usize, usize)
) -> Result<Box<dyn Iterator<Item = (char, &'a str)> + 'a>, &'static str>

Return selection as line iterator giving tag and text (‘\0’ as tag value represents absence of tag)

impl Clone for VecBuffer

fn clone(&self) -> VecBuffer

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for VecBuffer

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

Formats the value using the given formatter.

impl Default for VecBuffer

fn default() -> Self

Returns the “default value” for a type.

impl Hash for VecBuffer

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 PartialEq<VecBuffer> for VecBuffer

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

impl StructuralEq for VecBuffer

impl StructuralPartialEq for VecBuffer