dcsv 0.3.3

Dyanmic csv reader,writer,editor
Documentation 
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
108
109
110
111
112
113

## Reader

Reader is a special struct for reading values as csv struct. Create a reader
and feed reader options to configure reading behaviours. 

Reader's default behaviour is to let double quote untouched. Because double
quote is concerned by other csv utilizing programs and could be confusing if
ced strips double quotes. This can be countered with reader option though.

```rust
let reader: Reader = Reader::new()
    .use_delimiter(';')      // Default is comma
    .use_line_delimiter('|') // Default is '\n, \r\n'
	.trim(true)
	.has_header(true)
	.ignore_newline(true)
	.consume_dquote(true)
	.custom_header(&["a","b","c"]); // Custom header overrides has_header option

// Read as virtual_data
let data = reader.data_from_stream(source.as_bytes())
    .expect("Failed to read data");
// Read as virtual_array
let array = reader.array_from_stream(source.as_bytes())
    .expect("Failed to read data");
```

## VirtualData

Virtualdata is a wrapper around hashmap records. You can set limiter to set
optional qualification logics. VirtualData is also faster in removing and
inserting data compared to virtual array.

Duplicate column is not allowed in virtual data, use virtual array instead.

```rust
use dcsv::{Reader, VirtualData, Value};
use std::fs::File;

let mut data: VirtualData = Reader::new()
    .use_delimiter(';')      // Default is comma
    .use_line_delimiter('|') // Default is '\n, \r\n'
    .data_from_stream(
        BufReader::new(
            File::open("file_name.csv")
                .expect("Failed to read file")
        )
    )
    .expect("Failed to retrieve csv value from file");

let value : Option<&Value> = data.get_cell(1,1);

data.set_row(data.get_row_count(), vec![Value::Text("abc".to_string())])
	.expect("Failed to set data into a row");

data.set_column("dead", Value::Text(String::from("false")))
	.expect("Failed to set values in column");

let (x,y) = (0,0);
data.set_cell(x, y, Value::Text(String::from("WOW")))
	.expect("Failed to set value to a given cell");

let (src, target) = (0, data.get_row_count() - 1);
data.move_row(src, target)
	.expect("Failed to relocate row");

let (src, target) = (0, data.get_column_count() - 1);
data.move_column(src, target)
	.expect("Failed to relocate a column");
```

## VirtualArray

VirtualArray is a simple wrapper around vectors of string arrays. ( Row:
Vec<Vec<String>> ). VirtualArray is faster in indexing and allows
duplicate column names.

```rust

use dcsv::{Reader, VirtualArray, Value};
use std::fs::File;

let mut data: VirtualArray = Reader::new()
    .use_delimiter(';')      // Default is comma
    .use_line_delimiter('|') // Default is '\n, \r\n'
    .array_from_stream(
        BufReader::new(
            File::open("file_name.csv")
                .expect("Failed to read file")
        )
    )
    .expect("Failed to retrieve csv value from file");

let value : Option<&Value> = data.get_cell(1,1);

data.set_row(data.get_row_count(), vec![Value::Text("abc".to_string())])
	.expect("Failed to set data into a row");

data.set_column(2, Value::Text(String::from("false")))
	.expect("Failed to set values in column");

let (x,y) = (0,0);
data.set_cell(x, y, Value::Text(String::from("WOW")))
	.expect("Failed to set value to a given cell");

let (src, target) = (0, data.get_row_count() - 1);
data.move_row(src, target)
	.expect("Failed to relocate row");

let (src, target) = (0, data.get_column_count() - 1);
data.move_column(src, target)
	.expect("Failed to relocate a column");
```