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 114 115 116 117
/*!
# Base64 Stream
To encode/decode large data with the standard Base64 encoding.
## Examples
### Encode
#### ToBase64Reader
```rust
extern crate base64_stream;
use std::io::Cursor;
use std::io::Read;
use base64_stream::ToBase64Reader;
let test_data = b"Hi there, this is a simple sentence used for testing this crate. I hope all cases are correct.".to_vec();
let mut reader = ToBase64Reader::new(Cursor::new(test_data));
let mut base64 = [0u8; 4096];
let c = reader.read(&mut base64).unwrap();
assert_eq!(b"SGkgdGhlcmUsIHRoaXMgaXMgYSBzaW1wbGUgc2VudGVuY2UgdXNlZCBmb3IgdGVzdGluZyB0aGlzIGNyYXRlLiBJIGhvcGUgYWxsIGNhc2VzIGFyZSBjb3JyZWN0Lg==".to_vec(), base64[..c].to_vec());
```
#### ToBase64Writer
```rust
extern crate base64_stream;
use std::fs::{self, File};
use std::io::Write;
use base64_stream::ToBase64Writer;
let test_data = b"Hi there, this is a simple sentence used for testing this crate. I hope all cases are correct.".as_ref();
let base64 = File::create("encode_output.txt").unwrap();
let mut writer = ToBase64Writer::new(base64);
writer.write(test_data).unwrap();
writer.flush().unwrap(); // the flush method is only used when the full base64 data has been written
drop(writer);
assert_eq!("SGkgdGhlcmUsIHRoaXMgaXMgYSBzaW1wbGUgc2VudGVuY2UgdXNlZCBmb3IgdGVzdGluZyB0aGlzIGNyYXRlLiBJIGhvcGUgYWxsIGNhc2VzIGFyZSBjb3JyZWN0Lg==", fs::read_to_string("encode_output.txt").unwrap());
```
### Decode
#### FromBase64Reader
```rust
extern crate base64_stream;
use std::io::Cursor;
use std::io::Read;
use base64_stream::FromBase64Reader;
let base64 = b"SGkgdGhlcmUsIHRoaXMgaXMgYSBzaW1wbGUgc2VudGVuY2UgdXNlZCBmb3IgdGVzdGluZyB0aGlzIGNyYXRlLiBJIGhvcGUgYWxsIGNhc2VzIGFyZSBjb3JyZWN0Lg==".to_vec();
let mut reader = FromBase64Reader::new(Cursor::new(base64));
let mut test_data = [0u8; 4096];
let c = reader.read(&mut test_data).unwrap();
assert_eq!(b"Hi there, this is a simple sentence used for testing this crate. I hope all cases are correct.".to_vec(), test_data[..c].to_vec());
```
#### FromBase64Writer
```rust
extern crate base64_stream;
use std::fs::{self, File};
use std::io::Write;
use base64_stream::FromBase64Writer;
let base64 = b"SGkgdGhlcmUsIHRoaXMgaXMgYSBzaW1wbGUgc2VudGVuY2UgdXNlZCBmb3IgdGVzdGluZyB0aGlzIGNyYXRlLiBJIGhvcGUgYWxsIGNhc2VzIGFyZSBjb3JyZWN0Lg==".as_ref();
let test_data = File::create("decode_output.txt").unwrap();
let mut writer = FromBase64Writer::new(test_data);
writer.write(base64).unwrap();
writer.flush().unwrap(); // the flush method is only used when the full base64 data has been written
assert_eq!("Hi there, this is a simple sentence used for testing this crate. I hope all cases are correct.", fs::read_to_string("decode_output.txt").unwrap());
```
*/
pub extern crate base64;
mod to_base64_reader;
mod from_base64_reader;
mod to_base64_writer;
mod from_base64_writer;
pub use to_base64_reader::ToBase64Reader;
pub use from_base64_reader::FromBase64Reader;
pub use to_base64_writer::ToBase64Writer;
pub use from_base64_writer::FromBase64Writer;