118 lines
3.7 KiB
Rust
118 lines
3.7 KiB
Rust
use crate::enums::Address;
|
|
use std::fs::OpenOptions;
|
|
use std::io;
|
|
use std::io::Write;
|
|
|
|
pub struct Buffer {
|
|
has_changed: bool,
|
|
buffer: Vec<Result<String, io::Error>>,
|
|
current_line: usize,
|
|
file_name: String,
|
|
}
|
|
|
|
impl Buffer {
|
|
pub fn new(file_name: &str, buffer: Vec<Result<String, io::Error>>) -> Self {
|
|
let tmp = buffer.len().saturating_sub(1);
|
|
Self {
|
|
has_changed: false,
|
|
buffer,
|
|
current_line: tmp,
|
|
file_name: String::from(file_name),
|
|
}
|
|
}
|
|
|
|
pub fn is_modified(&self) -> bool {
|
|
self.has_changed
|
|
}
|
|
|
|
// Return the actual line of the buffer
|
|
pub fn line(&self) -> usize {
|
|
self.current_line
|
|
}
|
|
|
|
// change la ligne actuelle
|
|
pub fn change_line(&mut self, new: usize) {
|
|
// TODO check si > len
|
|
self.current_line = new;
|
|
}
|
|
|
|
pub fn save(&mut self) {
|
|
if let Ok(mut file) = OpenOptions::new().write(true).open(&self.file_name) {
|
|
let mut tmp = String::new();
|
|
for line in self.buffer.iter().flatten() {
|
|
tmp.push_str(line);
|
|
tmp.push('\n');
|
|
}
|
|
|
|
if let Err(e) = file.write(tmp.as_bytes()) {
|
|
panic!("{}", e);
|
|
}
|
|
|
|
self.has_changed = false;
|
|
}
|
|
}
|
|
|
|
pub fn append(&mut self, addr: Address, lines: Vec<String>) {
|
|
self.has_changed = true;
|
|
match addr {
|
|
Address::Actual => self.append_buffer(self.current_line, lines),
|
|
Address::Line(l) => self.append_buffer(l, lines),
|
|
Address::Last => self.append_buffer(self.buffer.len(), lines),
|
|
_ => (),
|
|
}
|
|
}
|
|
|
|
fn append_buffer(&mut self, line: usize, lines: Vec<String>) {
|
|
for (i, l) in lines.iter().enumerate() {
|
|
self.buffer.insert(i + line, Ok(l.to_string()));
|
|
self.current_line = i + line;
|
|
}
|
|
}
|
|
|
|
pub fn print(&mut self, addr: Address, print_numbers: bool) {
|
|
let last_line = self.buffer.len();
|
|
match addr {
|
|
Address::Actual => self.print_line(self.current_line, print_numbers),
|
|
Address::Line(l) => self.print_line(l.saturating_sub(1), print_numbers),
|
|
Address::Last => self.print_line(last_line, print_numbers),
|
|
Address::All => self.print_range(0, last_line, print_numbers),
|
|
Address::FromTo(a, b) => self.print_range(a, b, print_numbers),
|
|
Address::FromStartTo(a) => self.print_range(0, a, print_numbers),
|
|
Address::FromToEnd(a) => self.print_range(a, last_line, print_numbers),
|
|
Address::FromActTo(a) => self.print_range(self.current_line, a, print_numbers),
|
|
Address::FromActToEnd => self.print_range(self.current_line, last_line, print_numbers),
|
|
Address::Null => println!("nul !"),
|
|
}
|
|
}
|
|
|
|
// affiche une ligne
|
|
fn print_line(&mut self, nb: usize, print_numbers: bool) {
|
|
if nb >= self.buffer.len() {
|
|
println!("?");
|
|
} else if let Ok(line) = &self.buffer[nb] {
|
|
self.current_line = nb;
|
|
|
|
if print_numbers {
|
|
println!("{}\t{}", nb + 1, line);
|
|
} else {
|
|
println!("{}", line);
|
|
}
|
|
} else {
|
|
println!("?");
|
|
}
|
|
}
|
|
|
|
// affiche plusieurs lignes
|
|
fn print_range(&mut self, first: usize, last: usize, print_numbers: bool) {
|
|
let len = self.buffer.len();
|
|
// anti idiot, vraiment utile vu que les adresses gères déjà ça ?
|
|
if len > 0 && (first <= len && last <= len && first <= last) {
|
|
for i in first..last {
|
|
self.print_line(i, print_numbers);
|
|
}
|
|
} else {
|
|
println!("?");
|
|
}
|
|
}
|
|
}
|