use std::default::Default;
use std::io::{Result,Write};
use std::vec::Vec;
pub enum NewlineType {
UnixStyle,
WindowsStyle,
Custom(String)
}
pub struct SimpleCsvWriterOptions {
pub delimiter: char,
pub text_enclosure: char,
pub newline_type: NewlineType
}
impl Default for SimpleCsvWriterOptions {
fn default() -> SimpleCsvWriterOptions {
SimpleCsvWriterOptions {
delimiter: ',',
text_enclosure: '"',
newline_type: NewlineType::UnixStyle
}
}
}
pub struct SimpleCsvWriter<W: Write> {
options: SimpleCsvWriterOptions,
writer: W,
row_written: bool
}
impl<W: Write> SimpleCsvWriter<W> {
pub fn new(writer: W) -> SimpleCsvWriter<W>{
SimpleCsvWriter::with_options(writer, Default::default())
}
pub fn with_options(writer: W, options: SimpleCsvWriterOptions) -> SimpleCsvWriter<W> {
SimpleCsvWriter {
options: options,
writer: writer,
row_written: false
}
}
pub fn as_inner(self) -> W {
self.writer
}
pub fn write(&mut self, row: &[String]) -> Result<()> {
let delimiter = self.options.delimiter;
let text_enclosure = self.options.text_enclosure;
let mut col_number = 0usize;
if self.row_written {
match self.options.newline_type {
NewlineType::UnixStyle => {
try!(self.writer.write_all(b"\n"));
},
NewlineType::WindowsStyle => {
try!(self.writer.write_all(b"\r\n"));
},
NewlineType::Custom(ref newline_str) => {
try!(self.writer.write_all(newline_str.as_bytes()));
}
}
}
for column in row.iter() {
if col_number != 0 {
try!(write!(&mut self.writer,"{}",delimiter));
}
let mut is_quoted = false;
let mut char_iterator = column.char_indices();
let mut char_option = char_iterator.next();
while let Some((byte_index, c)) = char_option {
match is_quoted {
false => {
if c == text_enclosure || c == delimiter || c == '\n' || c == '\r'{
is_quoted = true;
try!(write!(&mut self.writer,"{}",text_enclosure));
try!(self.writer.write_all(column[..byte_index].as_bytes()));
continue;
}
},
true => {
match c {
_ if c == text_enclosure => {
try!(write!(&mut self.writer,"{}",c));
try!(write!(&mut self.writer,"{}",c));
},
_ => {
try!(write!(&mut self.writer,"{}",c));
}
}
}
}
char_option = char_iterator.next();
}
match is_quoted {
false => {
try!(self.writer.write_all(column.as_bytes()));
},
true => {
try!(write!(&mut self.writer,"{}",text_enclosure));
}
}
col_number += 1;
}
self.row_written = true;
Ok(())
}
pub fn write_all(&mut self, rows: &[Vec<String>]) -> Result<()> {
for row in rows.iter() {
try!(self.write(&*row));
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn writer_write_all_test() {
let mut vec = Vec::new();
let mut writer = SimpleCsvWriter::new(vec);
let _ = writer.write_all(&vec![
vec!["1".to_string(),"2".to_string(),"3".to_string()],
vec!["4".to_string(),"5".to_string(),"6".to_string()]]);
vec = writer.as_inner();
let test_string = "1,2,3\n4,5,6";
assert_eq!(vec, test_string.as_bytes());
}
#[test]
fn writer_quote_test() {
let mut vec = Vec::new();
let mut writer = SimpleCsvWriter::new(vec);
let _ = writer.write(&vec!["1".to_string(),"2\"".to_string(),"3".to_string()]);
let _ = writer.write(&vec!["4".to_string(),"\"5".to_string(),"6".to_string()]);
vec = writer.as_inner();
let test_string = "1,\"2\"\"\",3\n4,\"\"\"5\",6";
assert_eq!(vec, test_string.as_bytes());
}
#[test]
fn writer_delimiter_test() {
let mut vec = Vec::new();
let mut writer = SimpleCsvWriter::new(vec);
let _ = writer.write(&vec!["1".to_string(),"2,".to_string(),"3".to_string()]);
let _ = writer.write(&vec!["4".to_string(),",5".to_string(),"6".to_string()]);
vec = writer.as_inner();
let test_string = "1,\"2,\",3\n4,\",5\",6";
assert_eq!(vec, test_string.as_bytes());
}
#[test]
fn writer_newline_test() {
let mut vec = Vec::new();
let mut writer = SimpleCsvWriter::new(vec);
let _ = writer.write(&vec!["1".to_string(),"2\n".to_string(),"3".to_string()]);
let _ = writer.write(&vec!["4".to_string(),",5".to_string(),"6".to_string()]);
vec = writer.as_inner();
let test_string = "1,\"2\n\",3\n4,\",5\",6";
assert_eq!(vec, test_string.as_bytes());
}
}
#[cfg(feature="nightly")]
#[cfg(test)]
mod bench {
extern crate test;
use super::*;
use self::test::Bencher;
#[bench]
fn writer_bench_throughput(b: &mut test::Bencher) {
let num_rows = 10000;
let seed_vec = vec!["1".to_string(),"\"2".to_string(),"3".to_string()];
let mut expected_output = Vec::new();
let mut tmp_writer = SimpleCsvWriter::new(expected_output);
let _ = tmp_writer.write(&seed_vec);
expected_output = tmp_writer.as_inner();
let total_bytes = expected_output.len() * num_rows;
let mut test_vec = Vec::with_capacity(num_rows);
for _ in (0..num_rows) {
test_vec.push(seed_vec.clone());
}
b.bytes = total_bytes as u64;
b.iter(|| {
let r = &test_vec;
let output = Vec::with_capacity(total_bytes);
let mut writer = SimpleCsvWriter::new(output);
let _ = writer.write_all(r);
});
}
#[bench]
fn writer_bench_throughput_long_columns(b: &mut test::Bencher) {
let num_rows = 10000;
let seed_vec = vec!["111111111111111111111111111111111111111".to_string(),
"\"2222222222222222222222222222222222222222222222222".to_string(),
"33333333333333333333333333333333333333333333333".to_string()];
let mut expected_output = Vec::new();
let mut tmp_writer = SimpleCsvWriter::new(expected_output);
let _ = tmp_writer.write(&seed_vec);
expected_output = tmp_writer.as_inner();
let total_bytes = expected_output.len() * num_rows;
let mut test_vec = Vec::with_capacity(num_rows);
for _ in (0..num_rows) {
test_vec.push(seed_vec.clone());
}
b.bytes = total_bytes as u64;
b.iter(|| {
let r = &test_vec;
let output = Vec::with_capacity(total_bytes);
let mut writer = SimpleCsvWriter::new(output);
let _ = writer.write_all(r);
});
}
}