1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
|
use crate::point::Point;
use std::ops::{Deref, DerefMut};
use unicode_width::UnicodeWidthChar;
/// A 2D string buffer
/// where you can insert a character to any cell on the 2D grid
/// each cell can be assigned with a string
/// taking into account utf8 code which can not be char
/// including but not limited to multi-width chars
pub struct StringBuffer(Vec<Vec<char>>);
impl Deref for StringBuffer {
type Target = Vec<Vec<char>>;
fn deref(&self) -> &Self::Target {
&self.0
}
}
impl DerefMut for StringBuffer {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
impl StringBuffer {
pub(in crate) fn new() -> Self {
StringBuffer(vec![])
}
/// add rows to this buffer
fn add_rows(&mut self, n: i32) {
for _i in 0..n {
self.push(vec![]);
}
}
/// add columns to the specified row of this buffer
fn add_column(&mut self, row: usize, n: i32) {
for _i in 0..n {
self[row].push(' ');
}
}
/// x and y can also be negative
pub fn add_char(&mut self, x: i32, y: i32, ch: char) {
if x >= 0 && y >= 0 {
if ch == '\0' {
println!("skipping {}", ch);
} else {
let row_index = y as usize;
let column_index = x as usize;
let row_diff = y - self.len() as i32;
if row_diff >= 0 {
self.add_rows(row_diff + 1);
}
let column = &self[y as usize];
let column_diff = x - column.len() as i32;
if column_diff >= 0 {
self.add_column(row_index as usize, column_diff + 1);
}
self[row_index][column_index] = ch;
}
}
}
pub fn add_str(&mut self, x: i32, y: i32, s: &str) {
for (i, ch) in s.chars().enumerate() {
self.add_char(x + i as i32, y, ch);
}
}
}
impl From<&str> for StringBuffer {
fn from(s: &str) -> Self {
let mut rows = vec![];
for line in s.lines() {
let mut row = vec![];
for ch in line.chars() {
// TODO: deal with multi-width , zero width, fixed with string
row.push(ch);
if let Some(2) = ch.width() {
row.push('\0');
}
}
rows.push(row);
}
StringBuffer(rows)
}
}
impl ToString for StringBuffer {
fn to_string(&self) -> String {
let mut lines = vec![];
for row in self.iter() {
let row_contents: Vec<String> = row
.iter()
.filter(|ch| **ch != '\0')
.map(ToString::to_string)
.collect();
let line = row_contents.join("").trim_end().to_string();
lines.push(line);
}
lines.join("\n")
}
}
|
