Initial vendor packages
Signed-off-by: Valentin Popov <valentin@popov.link>
This commit is contained in:
26
vendor/flate2/examples/compress_file.rs
vendored
Normal file
26
vendor/flate2/examples/compress_file.rs
vendored
Normal file
@ -0,0 +1,26 @@
|
||||
use flate2::write::GzEncoder;
|
||||
use flate2::Compression;
|
||||
use std::env::args;
|
||||
use std::fs::File;
|
||||
use std::io::copy;
|
||||
use std::io::BufReader;
|
||||
use std::time::Instant;
|
||||
|
||||
fn main() {
|
||||
if args().len() != 3 {
|
||||
eprintln!("Usage: ./compress_file `source` `target`");
|
||||
return;
|
||||
}
|
||||
let mut input = BufReader::new(File::open(args().nth(1).unwrap()).unwrap());
|
||||
let output = File::create(args().nth(2).unwrap()).unwrap();
|
||||
let mut encoder = GzEncoder::new(output, Compression::default());
|
||||
let start = Instant::now();
|
||||
copy(&mut input, &mut encoder).unwrap();
|
||||
let output = encoder.finish().unwrap();
|
||||
println!(
|
||||
"Source len: {:?}",
|
||||
input.get_ref().metadata().unwrap().len()
|
||||
);
|
||||
println!("Target len: {:?}", output.metadata().unwrap().len());
|
||||
println!("Elapsed: {:?}", start.elapsed());
|
||||
}
|
23
vendor/flate2/examples/decompress_file.rs
vendored
Normal file
23
vendor/flate2/examples/decompress_file.rs
vendored
Normal file
@ -0,0 +1,23 @@
|
||||
use flate2::bufread;
|
||||
use std::env::args;
|
||||
use std::fs::File;
|
||||
use std::io::copy;
|
||||
use std::io::BufReader;
|
||||
use std::time::Instant;
|
||||
|
||||
fn main() {
|
||||
// E.g. `cargo run --example decompress_file examples/hello_world.txt.gz hello_world.txt`
|
||||
if args().len() != 3 {
|
||||
eprintln!("Usage: ./decompress_file `source` `target`");
|
||||
return;
|
||||
}
|
||||
let input = BufReader::new(File::open(args().nth(1).unwrap()).unwrap());
|
||||
let mut output = File::create(args().nth(2).unwrap()).unwrap();
|
||||
let source_len = input.get_ref().metadata().unwrap().len();
|
||||
let start = Instant::now();
|
||||
let mut decoder = bufread::GzDecoder::new(input);
|
||||
copy(&mut decoder, &mut output).unwrap();
|
||||
println!("Source len: {:?}", source_len);
|
||||
println!("Target len: {:?}", output.metadata().unwrap().len());
|
||||
println!("Elapsed: {:?}", start.elapsed());
|
||||
}
|
22
vendor/flate2/examples/deflatedecoder-bufread.rs
vendored
Normal file
22
vendor/flate2/examples/deflatedecoder-bufread.rs
vendored
Normal file
@ -0,0 +1,22 @@
|
||||
use flate2::bufread::DeflateDecoder;
|
||||
use flate2::write::DeflateEncoder;
|
||||
use flate2::Compression;
|
||||
use std::io;
|
||||
use std::io::prelude::*;
|
||||
|
||||
// Compress a sample string and print it after transformation.
|
||||
fn main() {
|
||||
let mut e = DeflateEncoder::new(Vec::new(), Compression::default());
|
||||
e.write_all(b"Hello World").unwrap();
|
||||
let bytes = e.finish().unwrap();
|
||||
println!("{}", decode_reader(bytes).unwrap());
|
||||
}
|
||||
|
||||
// Uncompresses a Deflate Encoded vector of bytes and returns a string or error
|
||||
// Here &[u8] implements Read
|
||||
fn decode_reader(bytes: Vec<u8>) -> io::Result<String> {
|
||||
let mut deflater = DeflateDecoder::new(&bytes[..]);
|
||||
let mut s = String::new();
|
||||
deflater.read_to_string(&mut s)?;
|
||||
Ok(s)
|
||||
}
|
22
vendor/flate2/examples/deflatedecoder-read.rs
vendored
Normal file
22
vendor/flate2/examples/deflatedecoder-read.rs
vendored
Normal file
@ -0,0 +1,22 @@
|
||||
use flate2::read::DeflateDecoder;
|
||||
use flate2::write::DeflateEncoder;
|
||||
use flate2::Compression;
|
||||
use std::io;
|
||||
use std::io::prelude::*;
|
||||
|
||||
// Compress a sample string and print it after transformation.
|
||||
fn main() {
|
||||
let mut e = DeflateEncoder::new(Vec::new(), Compression::default());
|
||||
e.write_all(b"Hello World").unwrap();
|
||||
let bytes = e.finish().unwrap();
|
||||
println!("{}", decode_reader(bytes).unwrap());
|
||||
}
|
||||
|
||||
// Uncompresses a Deflate Encoded vector of bytes and returns a string or error
|
||||
// Here &[u8] implements Read
|
||||
fn decode_reader(bytes: Vec<u8>) -> io::Result<String> {
|
||||
let mut deflater = DeflateDecoder::new(&bytes[..]);
|
||||
let mut s = String::new();
|
||||
deflater.read_to_string(&mut s)?;
|
||||
Ok(s)
|
||||
}
|
24
vendor/flate2/examples/deflatedecoder-write.rs
vendored
Normal file
24
vendor/flate2/examples/deflatedecoder-write.rs
vendored
Normal file
@ -0,0 +1,24 @@
|
||||
use flate2::write::DeflateDecoder;
|
||||
use flate2::write::DeflateEncoder;
|
||||
use flate2::Compression;
|
||||
use std::io;
|
||||
use std::io::prelude::*;
|
||||
|
||||
// Compress a sample string and print it after transformation.
|
||||
fn main() {
|
||||
let mut e = DeflateEncoder::new(Vec::new(), Compression::default());
|
||||
e.write_all(b"Hello World").unwrap();
|
||||
let bytes = e.finish().unwrap();
|
||||
println!("{}", decode_reader(bytes).unwrap());
|
||||
}
|
||||
|
||||
// Uncompresses a Deflate Encoded vector of bytes and returns a string or error
|
||||
// Here Vec<u8> implements Write
|
||||
fn decode_reader(bytes: Vec<u8>) -> io::Result<String> {
|
||||
let mut writer = Vec::new();
|
||||
let mut deflater = DeflateDecoder::new(writer);
|
||||
deflater.write_all(&bytes[..])?;
|
||||
writer = deflater.finish()?;
|
||||
let return_string = String::from_utf8(writer).expect("String parsing error");
|
||||
Ok(return_string)
|
||||
}
|
22
vendor/flate2/examples/deflateencoder-bufread.rs
vendored
Normal file
22
vendor/flate2/examples/deflateencoder-bufread.rs
vendored
Normal file
@ -0,0 +1,22 @@
|
||||
use flate2::bufread::DeflateEncoder;
|
||||
use flate2::Compression;
|
||||
use std::fs::File;
|
||||
use std::io;
|
||||
use std::io::prelude::*;
|
||||
use std::io::BufReader;
|
||||
|
||||
// Open file and debug print the contents compressed with Deflate
|
||||
fn main() {
|
||||
println!("{:?}", open_hello_world().unwrap());
|
||||
}
|
||||
|
||||
// Opens sample file, compresses the contents and returns a Vector or error
|
||||
// File wrapped in a BufReader implements Bufread
|
||||
fn open_hello_world() -> io::Result<Vec<u8>> {
|
||||
let f = File::open("examples/hello_world.txt")?;
|
||||
let b = BufReader::new(f);
|
||||
let mut deflater = DeflateEncoder::new(b, Compression::fast());
|
||||
let mut buffer = Vec::new();
|
||||
deflater.read_to_end(&mut buffer)?;
|
||||
Ok(buffer)
|
||||
}
|
18
vendor/flate2/examples/deflateencoder-read.rs
vendored
Normal file
18
vendor/flate2/examples/deflateencoder-read.rs
vendored
Normal file
@ -0,0 +1,18 @@
|
||||
use flate2::read::DeflateEncoder;
|
||||
use flate2::Compression;
|
||||
use std::io;
|
||||
use std::io::prelude::*;
|
||||
|
||||
// Print the Deflate compressed representation of hello world
|
||||
fn main() {
|
||||
println!("{:?}", deflateencoder_read_hello_world().unwrap());
|
||||
}
|
||||
|
||||
// Return a vector containing the Deflate compressed version of hello world
|
||||
fn deflateencoder_read_hello_world() -> io::Result<Vec<u8>> {
|
||||
let mut result = Vec::new();
|
||||
let c = b"hello world";
|
||||
let mut deflater = DeflateEncoder::new(&c[..], Compression::fast());
|
||||
deflater.read_to_end(&mut result)?;
|
||||
Ok(result)
|
||||
}
|
10
vendor/flate2/examples/deflateencoder-write.rs
vendored
Normal file
10
vendor/flate2/examples/deflateencoder-write.rs
vendored
Normal file
@ -0,0 +1,10 @@
|
||||
use flate2::write::DeflateEncoder;
|
||||
use flate2::Compression;
|
||||
use std::io::prelude::*;
|
||||
|
||||
// Vec<u8> implements Write to print the compressed bytes of sample string
|
||||
fn main() {
|
||||
let mut e = DeflateEncoder::new(Vec::new(), Compression::default());
|
||||
e.write_all(b"Hello World").unwrap();
|
||||
println!("{:?}", e.finish().unwrap());
|
||||
}
|
22
vendor/flate2/examples/gzbuilder.rs
vendored
Normal file
22
vendor/flate2/examples/gzbuilder.rs
vendored
Normal file
@ -0,0 +1,22 @@
|
||||
use flate2::Compression;
|
||||
use flate2::GzBuilder;
|
||||
use std::fs::File;
|
||||
use std::io;
|
||||
use std::io::prelude::*;
|
||||
|
||||
// Compresses content of a text file into a gzip file
|
||||
fn main() {
|
||||
sample_builder().unwrap();
|
||||
}
|
||||
|
||||
// GzBuilder opens a file and writes a sample string using Builder pattern
|
||||
fn sample_builder() -> Result<(), io::Error> {
|
||||
let f = File::create("examples/hello_world.txt.gz")?;
|
||||
let mut gz = GzBuilder::new()
|
||||
.filename("hello_world.txt")
|
||||
.comment("test file, please delete")
|
||||
.write(f, Compression::default());
|
||||
gz.write_all(b"hello world")?;
|
||||
gz.finish()?;
|
||||
Ok(())
|
||||
}
|
21
vendor/flate2/examples/gzdecoder-bufread.rs
vendored
Normal file
21
vendor/flate2/examples/gzdecoder-bufread.rs
vendored
Normal file
@ -0,0 +1,21 @@
|
||||
use flate2::write::GzEncoder;
|
||||
use flate2::{bufread, Compression};
|
||||
use std::io;
|
||||
use std::io::prelude::*;
|
||||
|
||||
// Compress a sample string and print it after transformation.
|
||||
fn main() {
|
||||
let mut e = GzEncoder::new(Vec::new(), Compression::default());
|
||||
e.write_all(b"Hello World").unwrap();
|
||||
let bytes = e.finish().unwrap();
|
||||
println!("{}", decode_reader(bytes).unwrap());
|
||||
}
|
||||
|
||||
// Uncompresses a Gz Encoded vector of bytes and returns a string or error
|
||||
// Here &[u8] implements BufRead
|
||||
fn decode_reader(bytes: Vec<u8>) -> io::Result<String> {
|
||||
let mut gz = bufread::GzDecoder::new(&bytes[..]);
|
||||
let mut s = String::new();
|
||||
gz.read_to_string(&mut s)?;
|
||||
Ok(s)
|
||||
}
|
21
vendor/flate2/examples/gzdecoder-read.rs
vendored
Normal file
21
vendor/flate2/examples/gzdecoder-read.rs
vendored
Normal file
@ -0,0 +1,21 @@
|
||||
use flate2::write::GzEncoder;
|
||||
use flate2::{read, Compression};
|
||||
use std::io;
|
||||
use std::io::prelude::*;
|
||||
|
||||
// Compress a sample string and print it after transformation.
|
||||
fn main() {
|
||||
let mut e = GzEncoder::new(Vec::new(), Compression::default());
|
||||
e.write_all(b"Hello World").unwrap();
|
||||
let bytes = e.finish().unwrap();
|
||||
println!("{}", decode_reader(bytes).unwrap());
|
||||
}
|
||||
|
||||
// Uncompresses a Gz Encoded vector of bytes and returns a string or error
|
||||
// Here &[u8] implements Read
|
||||
fn decode_reader(bytes: Vec<u8>) -> io::Result<String> {
|
||||
let mut gz = read::GzDecoder::new(&bytes[..]);
|
||||
let mut s = String::new();
|
||||
gz.read_to_string(&mut s)?;
|
||||
Ok(s)
|
||||
}
|
24
vendor/flate2/examples/gzdecoder-write.rs
vendored
Normal file
24
vendor/flate2/examples/gzdecoder-write.rs
vendored
Normal file
@ -0,0 +1,24 @@
|
||||
use flate2::write::{GzDecoder, GzEncoder};
|
||||
use flate2::Compression;
|
||||
use std::io;
|
||||
use std::io::prelude::*;
|
||||
|
||||
// Compress a sample string and print it after transformation.
|
||||
fn main() {
|
||||
let mut e = GzEncoder::new(Vec::new(), Compression::default());
|
||||
e.write_all(b"Hello World").unwrap();
|
||||
let bytes = e.finish().unwrap();
|
||||
println!("{}", decode_writer(bytes).unwrap());
|
||||
}
|
||||
|
||||
// Uncompresses a Gz Encoded vector of bytes and returns a string or error
|
||||
// Here &[u8] implements Read
|
||||
fn decode_writer(bytes: Vec<u8>) -> io::Result<String> {
|
||||
let mut writer = Vec::new();
|
||||
let mut decoder = GzDecoder::new(writer);
|
||||
decoder.write_all(&bytes[..])?;
|
||||
decoder.try_finish()?;
|
||||
writer = decoder.finish()?;
|
||||
let return_string = String::from_utf8(writer).expect("String parsing error");
|
||||
Ok(return_string)
|
||||
}
|
22
vendor/flate2/examples/gzencoder-bufread.rs
vendored
Normal file
22
vendor/flate2/examples/gzencoder-bufread.rs
vendored
Normal file
@ -0,0 +1,22 @@
|
||||
use flate2::bufread::GzEncoder;
|
||||
use flate2::Compression;
|
||||
use std::fs::File;
|
||||
use std::io;
|
||||
use std::io::prelude::*;
|
||||
use std::io::BufReader;
|
||||
|
||||
// Open file and debug print the contents compressed with gzip
|
||||
fn main() {
|
||||
println!("{:?}", open_hello_world().unwrap());
|
||||
}
|
||||
|
||||
// Opens sample file, compresses the contents and returns a Vector or error
|
||||
// File wrapped in a BufReader implements Bufread
|
||||
fn open_hello_world() -> io::Result<Vec<u8>> {
|
||||
let f = File::open("examples/hello_world.txt")?;
|
||||
let b = BufReader::new(f);
|
||||
let mut gz = GzEncoder::new(b, Compression::fast());
|
||||
let mut buffer = Vec::new();
|
||||
gz.read_to_end(&mut buffer)?;
|
||||
Ok(buffer)
|
||||
}
|
18
vendor/flate2/examples/gzencoder-read.rs
vendored
Normal file
18
vendor/flate2/examples/gzencoder-read.rs
vendored
Normal file
@ -0,0 +1,18 @@
|
||||
use flate2::read::GzEncoder;
|
||||
use flate2::Compression;
|
||||
use std::io;
|
||||
use std::io::prelude::*;
|
||||
|
||||
// Print the GZ compressed representation of hello world
|
||||
fn main() {
|
||||
println!("{:?}", gzencoder_read_hello_world().unwrap());
|
||||
}
|
||||
|
||||
// Return a vector containing the GZ compressed version of hello world
|
||||
fn gzencoder_read_hello_world() -> io::Result<Vec<u8>> {
|
||||
let mut result = Vec::new();
|
||||
let c = b"hello world";
|
||||
let mut z = GzEncoder::new(&c[..], Compression::fast());
|
||||
z.read_to_end(&mut result)?;
|
||||
Ok(result)
|
||||
}
|
10
vendor/flate2/examples/gzencoder-write.rs
vendored
Normal file
10
vendor/flate2/examples/gzencoder-write.rs
vendored
Normal file
@ -0,0 +1,10 @@
|
||||
use flate2::write::GzEncoder;
|
||||
use flate2::Compression;
|
||||
use std::io::prelude::*;
|
||||
|
||||
// Vec<u8> implements Write to print the compressed bytes of sample string
|
||||
fn main() {
|
||||
let mut e = GzEncoder::new(Vec::new(), Compression::default());
|
||||
e.write_all(b"Hello World").unwrap();
|
||||
println!("{:?}", e.finish().unwrap());
|
||||
}
|
22
vendor/flate2/examples/gzmultidecoder-bufread.rs
vendored
Normal file
22
vendor/flate2/examples/gzmultidecoder-bufread.rs
vendored
Normal file
@ -0,0 +1,22 @@
|
||||
use flate2::bufread::MultiGzDecoder;
|
||||
use flate2::write::GzEncoder;
|
||||
use flate2::Compression;
|
||||
use std::io;
|
||||
use std::io::prelude::*;
|
||||
|
||||
// Compress a sample string and print it after transformation.
|
||||
fn main() {
|
||||
let mut e = GzEncoder::new(Vec::new(), Compression::default());
|
||||
e.write_all(b"Hello World").unwrap();
|
||||
let bytes = e.finish().unwrap();
|
||||
println!("{}", decode_reader(bytes).unwrap());
|
||||
}
|
||||
|
||||
// Uncompresses a Gz Encoded vector of bytes and returns a string or error
|
||||
// Here &[u8] implements BufRead
|
||||
fn decode_reader(bytes: Vec<u8>) -> io::Result<String> {
|
||||
let mut gz = MultiGzDecoder::new(&bytes[..]);
|
||||
let mut s = String::new();
|
||||
gz.read_to_string(&mut s)?;
|
||||
Ok(s)
|
||||
}
|
22
vendor/flate2/examples/gzmultidecoder-read.rs
vendored
Normal file
22
vendor/flate2/examples/gzmultidecoder-read.rs
vendored
Normal file
@ -0,0 +1,22 @@
|
||||
use flate2::read::MultiGzDecoder;
|
||||
use flate2::write::GzEncoder;
|
||||
use flate2::Compression;
|
||||
use std::io;
|
||||
use std::io::prelude::*;
|
||||
|
||||
// Compress a sample string and print it after transformation.
|
||||
fn main() {
|
||||
let mut e = GzEncoder::new(Vec::new(), Compression::default());
|
||||
e.write_all(b"Hello World").unwrap();
|
||||
let bytes = e.finish().unwrap();
|
||||
println!("{}", decode_reader(bytes).unwrap());
|
||||
}
|
||||
|
||||
// Uncompresses a Gz Encoded vector of bytes and returns a string or error
|
||||
// Here &[u8] implements Read
|
||||
fn decode_reader(bytes: Vec<u8>) -> io::Result<String> {
|
||||
let mut gz = MultiGzDecoder::new(&bytes[..]);
|
||||
let mut s = String::new();
|
||||
gz.read_to_string(&mut s)?;
|
||||
Ok(s)
|
||||
}
|
1
vendor/flate2/examples/hello_world.txt
vendored
Normal file
1
vendor/flate2/examples/hello_world.txt
vendored
Normal file
@ -0,0 +1 @@
|
||||
Hello World
|
BIN
vendor/flate2/examples/hello_world.txt.gz
vendored
Normal file
BIN
vendor/flate2/examples/hello_world.txt.gz
vendored
Normal file
Binary file not shown.
22
vendor/flate2/examples/zlibdecoder-bufread.rs
vendored
Normal file
22
vendor/flate2/examples/zlibdecoder-bufread.rs
vendored
Normal file
@ -0,0 +1,22 @@
|
||||
use flate2::bufread::ZlibDecoder;
|
||||
use flate2::write::ZlibEncoder;
|
||||
use flate2::Compression;
|
||||
use std::io;
|
||||
use std::io::prelude::*;
|
||||
|
||||
// Compress a sample string and print it after transformation.
|
||||
fn main() {
|
||||
let mut e = ZlibEncoder::new(Vec::new(), Compression::default());
|
||||
e.write_all(b"Hello World").unwrap();
|
||||
let bytes = e.finish().unwrap();
|
||||
println!("{}", decode_bufreader(bytes).unwrap());
|
||||
}
|
||||
|
||||
// Uncompresses a Zlib Encoded vector of bytes and returns a string or error
|
||||
// Here &[u8] implements BufRead
|
||||
fn decode_bufreader(bytes: Vec<u8>) -> io::Result<String> {
|
||||
let mut z = ZlibDecoder::new(&bytes[..]);
|
||||
let mut s = String::new();
|
||||
z.read_to_string(&mut s)?;
|
||||
Ok(s)
|
||||
}
|
22
vendor/flate2/examples/zlibdecoder-read.rs
vendored
Normal file
22
vendor/flate2/examples/zlibdecoder-read.rs
vendored
Normal file
@ -0,0 +1,22 @@
|
||||
use flate2::read::ZlibDecoder;
|
||||
use flate2::write::ZlibEncoder;
|
||||
use flate2::Compression;
|
||||
use std::io;
|
||||
use std::io::prelude::*;
|
||||
|
||||
// Compress a sample string and print it after transformation.
|
||||
fn main() {
|
||||
let mut e = ZlibEncoder::new(Vec::new(), Compression::default());
|
||||
e.write_all(b"Hello World").unwrap();
|
||||
let bytes = e.finish().unwrap();
|
||||
println!("{}", decode_reader(bytes).unwrap());
|
||||
}
|
||||
|
||||
// Uncompresses a Zlib Encoded vector of bytes and returns a string or error
|
||||
// Here &[u8] implements Read
|
||||
fn decode_reader(bytes: Vec<u8>) -> io::Result<String> {
|
||||
let mut z = ZlibDecoder::new(&bytes[..]);
|
||||
let mut s = String::new();
|
||||
z.read_to_string(&mut s)?;
|
||||
Ok(s)
|
||||
}
|
24
vendor/flate2/examples/zlibdecoder-write.rs
vendored
Normal file
24
vendor/flate2/examples/zlibdecoder-write.rs
vendored
Normal file
@ -0,0 +1,24 @@
|
||||
use flate2::write::ZlibDecoder;
|
||||
use flate2::write::ZlibEncoder;
|
||||
use flate2::Compression;
|
||||
use std::io;
|
||||
use std::io::prelude::*;
|
||||
|
||||
// Compress a sample string and print it after transformation.
|
||||
fn main() {
|
||||
let mut e = ZlibEncoder::new(Vec::new(), Compression::default());
|
||||
e.write_all(b"Hello World").unwrap();
|
||||
let bytes = e.finish().unwrap();
|
||||
println!("{}", decode_reader(bytes).unwrap());
|
||||
}
|
||||
|
||||
// Uncompresses a Zlib Encoded vector of bytes and returns a string or error
|
||||
// Here Vec<u8> implements Write
|
||||
fn decode_reader(bytes: Vec<u8>) -> io::Result<String> {
|
||||
let mut writer = Vec::new();
|
||||
let mut z = ZlibDecoder::new(writer);
|
||||
z.write_all(&bytes[..])?;
|
||||
writer = z.finish()?;
|
||||
let return_string = String::from_utf8(writer).expect("String parsing error");
|
||||
Ok(return_string)
|
||||
}
|
22
vendor/flate2/examples/zlibencoder-bufread.rs
vendored
Normal file
22
vendor/flate2/examples/zlibencoder-bufread.rs
vendored
Normal file
@ -0,0 +1,22 @@
|
||||
use flate2::bufread::ZlibEncoder;
|
||||
use flate2::Compression;
|
||||
use std::fs::File;
|
||||
use std::io;
|
||||
use std::io::prelude::*;
|
||||
use std::io::BufReader;
|
||||
|
||||
// Open file and debug print the contents compressed with zlib
|
||||
fn main() {
|
||||
println!("{:?}", open_hello_world().unwrap());
|
||||
}
|
||||
|
||||
// Opens sample file, compresses the contents and returns a Vector or error
|
||||
// File wrapped in a BufReader implements Bufread
|
||||
fn open_hello_world() -> io::Result<Vec<u8>> {
|
||||
let f = File::open("examples/hello_world.txt")?;
|
||||
let b = BufReader::new(f);
|
||||
let mut z = ZlibEncoder::new(b, Compression::fast());
|
||||
let mut buffer = Vec::new();
|
||||
z.read_to_end(&mut buffer)?;
|
||||
Ok(buffer)
|
||||
}
|
19
vendor/flate2/examples/zlibencoder-read.rs
vendored
Normal file
19
vendor/flate2/examples/zlibencoder-read.rs
vendored
Normal file
@ -0,0 +1,19 @@
|
||||
use flate2::read::ZlibEncoder;
|
||||
use flate2::Compression;
|
||||
use std::fs::File;
|
||||
use std::io::prelude::*;
|
||||
|
||||
// Open file and debug print the compressed contents
|
||||
fn main() {
|
||||
println!("{:?}", open_hello_world().unwrap());
|
||||
}
|
||||
|
||||
// Opens sample file, compresses the contents and returns a Vector or error
|
||||
// File implements Read
|
||||
fn open_hello_world() -> std::io::Result<Vec<u8>> {
|
||||
let f = File::open("examples/hello_world.txt")?;
|
||||
let mut z = ZlibEncoder::new(f, Compression::fast());
|
||||
let mut result = Vec::new();
|
||||
z.read_to_end(&mut result)?;
|
||||
Ok(result)
|
||||
}
|
10
vendor/flate2/examples/zlibencoder-write.rs
vendored
Normal file
10
vendor/flate2/examples/zlibencoder-write.rs
vendored
Normal file
@ -0,0 +1,10 @@
|
||||
use flate2::write::ZlibEncoder;
|
||||
use flate2::Compression;
|
||||
use std::io::prelude::*;
|
||||
|
||||
// Vec<u8> implements Write to print the compressed bytes of sample string
|
||||
fn main() {
|
||||
let mut e = ZlibEncoder::new(Vec::new(), Compression::default());
|
||||
e.write_all(b"Hello World").unwrap();
|
||||
println!("{:?}", e.finish().unwrap());
|
||||
}
|
Reference in New Issue
Block a user