Struct kaolinite::row::Row

pub struct Row {
    pub text: Vec<char>,
    pub indices: Vec<usize>,
    pub modified: bool,
    pub info: *mut FileInfo,
}

A struct that contains all the basic tools necessary to manage rows in a document

Fields

text: Vec<char>

All the characters within the row

indices: Vec<usize>

Corresponding display widths for each character

modified: bool

A tool for determining if the row has been edited

use kaolinite::row::Row;
let mut row = Row::new("Hello");
assert_eq!(row.modified, false);
row.insert(5, ", world!");
assert_eq!(row.modified, true);
row.modified = false;
assert_eq!(row.modified, false);

This is ideal for optimisation

info: *mut FileInfo

Holds a reference to file information

Implementations

impl Row

pub fn new<S: Into<String>>(raw: S) -> Self

Create a new row from raw text

pub fn link(self, link: *mut FileInfo) -> Self

This method provides a neat way to link a row to a file info You usually don’t need to use this method yourself It is used by Document to link it’s FileInfo struct to each Row for configuration purposes

pub fn insert<S: Into<String>>(
    &mut self,
    start: usize,
    text: S
) -> Result<Status>

Insert text at a position

Errors

Will return Err if start is out of range of the row

pub fn remove<R>(&mut self, range: R) -> Result<Status> where
    R: RangeBounds<usize>, 

Remove text in a range

Errors

Will return Err if range is out of range of the row

pub fn split(&self, idx: usize) -> Result<(Row, Row)>

Splits this row into two separate rows

Errors

Will return Err if idx is out of range of the row

pub fn splice(&mut self, row: Row) -> Row

Joins this row with another row

pub fn words(&self) -> Vec<usize>

Retrieve the indices of word boundaries

// Opening a file,
use kaolinite::document::Document;
let mut doc = Document::new();
// Imagine if test.txt were `The quick brown fox`
doc.open("test.txt").expect("Failed to open file");
// This would get the word boundaries of the first row: [0, 4, 10, 16, 19]
println!("{:?}", doc.row(0).words());

pub fn render(&self, range: RangeFrom<usize>) -> String

Render part of the row When trying to render X axis offset, this is the ideal function to use

"He好llo好" // 0..
"e好llo好"  // 1..
"好llo好"   // 2..
" llo好"    // 3..
"llo好"     // 4..
"lo好"      // 5..
"o好"       // 6..
"好"        // 7..
" "         // 8..
""          // 9..

This also handles double width characters by inserting whitespace when half of the character is off the screen

pub fn render_full(&self) -> String

Render the entire row, with tabs converted into spaces

pub fn render_raw(&self) -> String

Render this row as is, with no tab interference

pub fn len(&self) -> usize

Find the character length of this row

pub fn is_empty(&self) -> bool

Determine if the row is empty

pub fn width(&self) -> usize

Find the display width of this row

pub fn get_char_ptr(&self, x: usize) -> usize

Calculate the character pointer from a display index

pub fn get_tab_width(&self) -> usize

Retrieve the tab width from the document info

Trait Implementations

impl Clone for Row

fn clone(&self) -> Row

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Row

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

Formats the value using the given formatter.

impl PartialEq<Row> for Row

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl StructuralPartialEq for Row