#[derive(Clone)]
pub struct Substitution {
pub pattern: Vec<u8>,
pub replacement: Vec<u8>,
pub nth: usize,
pub global: bool,
}
struct Line {
text: String,
marked: bool,
}
pub struct Buffer {
lines: Vec<Line>,
first_mark: usize,
current: usize, modified: bool,
filename: Option<String>,
last_subst: Option<Substitution>,
}
impl Buffer {
pub fn new() -> Self {
Self {
lines: Vec::new(),
first_mark: 0,
current: 0,
modified: false,
filename: None,
last_subst: None,
}
}
pub fn len(&self) -> usize {
self.lines.len()
}
pub fn is_empty(&self) -> bool {
self.lines.is_empty()
}
pub fn current(&self) -> usize {
self.current
}
pub fn set_current(&mut self, n: usize) {
self.current = n;
}
pub fn append_after(&mut self, after: usize, line: String) {
self.lines.insert(
after,
Line {
text: line,
marked: false,
},
);
self.current = after + 1;
self.modified = true;
}
pub fn line(&self, n: usize) -> Option<&str> {
if n == 0 || n > self.lines.len() {
None
} else {
Some(self.lines[n - 1].text.as_str())
}
}
pub fn is_modified(&self) -> bool {
self.modified
}
pub fn mark_saved(&mut self) {
self.modified = false;
}
pub fn filename(&self) -> Option<&str> {
self.filename.as_deref()
}
pub fn set_filename(&mut self, name: String) {
self.filename = Some(name);
}
pub fn replace_line(&mut self, n: usize, content: String) {
self.lines[n - 1].text = content;
self.modified = true;
}
pub fn last_subst(&self) -> Option<&Substitution> {
self.last_subst.as_ref()
}
pub fn set_last_subst(&mut self, subst: Substitution) {
self.last_subst = Some(subst);
}
pub fn delete_range(&mut self, start: usize, end: usize) {
self.lines.drain((start - 1)..end);
self.first_mark = self.first_mark.min(start - 1);
self.modified = true;
if self.lines.is_empty() {
self.current = 0;
} else if start <= self.lines.len() {
self.current = start;
} else {
self.current = self.lines.len();
}
}
pub fn move_range(&mut self, start: usize, end: usize, after: usize) -> usize {
let block: Vec<Line> = self.lines.drain((start - 1)..end).collect();
let count = block.len();
let at = if after > end { after - count } else { after };
if block.iter().any(|l| l.marked) || after > end {
self.first_mark = self.first_mark.min(at.min(start - 1));
}
self.lines.splice(at..at, block);
self.modified = true;
at + 1
}
pub fn set_mark(&mut self, n: usize, marked: bool) {
self.lines[n - 1].marked = marked;
if marked {
self.first_mark = self.first_mark.min(n - 1);
}
}
pub fn take_mark(&mut self) -> Option<usize> {
let found = self.lines[self.first_mark..].iter().position(|l| l.marked);
match found {
Some(offset) => {
let i = self.first_mark + offset;
self.lines[i].marked = false;
self.first_mark = i + 1;
Some(i + 1)
}
None => {
self.first_mark = self.lines.len();
None
}
}
}
pub fn clear_marks(&mut self) {
for line in &mut self.lines {
line.marked = false;
}
self.first_mark = self.lines.len();
}
}