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
|
//! Internal only utilities
use std::io::{Error, ErrorKind, Write};
use std::str;
use unicode_width::UnicodeWidthStr;
use super::format::Alignment;
#[cfg(not(windows))]
pub static NEWLINE: &'static [u8] = b"\n";
#[cfg(windows)]
pub static NEWLINE: &'static [u8] = b"\r\n";
/// Internal utility for writing data into a string
pub struct StringWriter {
string: String
}
impl StringWriter {
/// Create a new `StringWriter`
pub fn new() -> StringWriter {
return StringWriter{string: String::new()};
}
/// Return a reference to the internally written `String`
pub fn as_string(&self) -> &str {
return &self.string;
}
}
impl Write for StringWriter {
fn write(&mut self, data: &[u8]) -> Result<usize, Error> {
let string = match str::from_utf8(data) {
Ok(s) => s,
Err(e) => return Err(Error::new(ErrorKind::Other, format!("Cannot decode utf8 string : {}", e)))
};
self.string.push_str(string);
return Ok(data.len());
}
fn flush(&mut self) -> Result<(), Error> {
// Nothing to do here
return Ok(());
}
}
/// Align/fill a string and print it to `out`
pub fn print_align<T: Write+?Sized>(out: &mut T, align: Alignment, text: &str, fill: char, size: usize) -> Result<(), Error> {
let text_len = UnicodeWidthStr::width(text);
let mut nfill = if text_len < size { size - text_len } else { 0 };
let n = match align {
Alignment::LEFT => 0,
Alignment:: RIGHT => nfill,
Alignment:: CENTER => nfill/2
};
if n > 0 {
try!(out.write(&vec![fill as u8; n]));
nfill -= n;
}
try!(out.write(text.as_bytes()));
if nfill > 0 {
try!(out.write(&vec![fill as u8; nfill]));
}
return Ok(());
}
#[cfg(test)]
mod tests {
use super::*;
use format::Alignment;
use std::io::Write;
#[test]
fn string_writer() {
let mut out = StringWriter::new();
out.write("foo".as_bytes()).unwrap();
out.write(" ".as_bytes()).unwrap();
out.write("".as_bytes()).unwrap();
out.write("bar".as_bytes()).unwrap();
assert_eq!(out.as_string(), "foo bar");
}
#[test]
fn fill_align() {
let mut out = StringWriter::new();
print_align(&mut out, Alignment::RIGHT, "foo", '*', 10).unwrap();
assert_eq!(out.as_string(), "*******foo");
let mut out = StringWriter::new();
print_align(&mut out, Alignment::LEFT, "foo", '*', 10).unwrap();
assert_eq!(out.as_string(), "foo*******");
let mut out = StringWriter::new();
print_align(&mut out, Alignment::CENTER, "foo", '*', 10).unwrap();
assert_eq!(out.as_string(), "***foo****");
let mut out = StringWriter::new();
print_align(&mut out, Alignment::CENTER, "foo", '*', 1).unwrap();
assert_eq!(out.as_string(), "foo");
}
}
|
