Struct transfer_progress::SizedTransfer[−][src]

pub struct SizedTransfer<R, W> where
    R: Read + Send + 'static,
    W: Write + Send + 'static,  { /* fields omitted */ }

Expand description

Monitors the progress of a transfer with a known size.

Implementations

[src]

impl<R, W> SizedTransfer<R, W> where
R: Read + Send + 'static,
W: Write + Send + 'static,

[src]

pub fn new(reader: R, writer: W, size: u64) -> Self

Creates and starts a new SizedTransfer.

Example

use transfer_progress::SizedTransfer;
use std::fs::File;
use std::io::Read;
let reader = File::open("file1.txt")?.take(1024); // Bytes
let writer = File::create("file2.txt")?;
let transfer = SizedTransfer::new(reader, writer, 1024);

[src]

pub fn finish(self) -> Result<(R, W)>

Consumes the SizedTransfer, blocking until the transfer is complete.

If the transfer was successful, returns Ok(reader, writer), otherwise returns the error.

If the transfer is already complete, returns immediately.

Example

use transfer_progress::SizedTransfer;
use std::fs::File;
use std::io::Read;
let reader = File::open("file1.txt")?.take(1024); // Bytes
let writer = File::create("file2.txt")?;
let transfer = SizedTransfer::new(reader, writer, 1024);
let (reader, writer) = transfer.finish()?;

[src]

pub fn fraction_transferred(&self) -> f64

Returns a fraction between 0.0 and 1.0 representing the state of the transfer.

Example

use transfer_progress::SizedTransfer;
use std::fs::File;
use std::io::Read;
let reader = File::open("file1.txt")?.take(1024); // Bytes
let writer = File::create("file2.txt")?;
let transfer = SizedTransfer::new(reader, writer, 1024);
while !transfer.is_complete() {
println!("Transfer is {:.0}% complete", transfer.fraction_transferred() * 100.0);
std::thread::sleep(std::time::Duration::from_secs(1));
}

[src]

pub fn eta(&self) -> Option<Duration>

Returns the approximate remaining time until this transfer completes. Returns None if this cannot be calculated (I.E. no bytes have been transferred yet, so a speed cannot be determined).

Example

use transfer_progress::SizedTransfer;
use std::fs::File;
use std::io::Read;
let reader = File::open("file1.txt")?.take(1024); // Bytes
let writer = File::create("file2.txt")?;
let transfer = SizedTransfer::new(reader, writer, 1024);
while !transfer.is_complete() {
if let Some(eta) = transfer.eta() {
println!("Transfer will complete in approximately {:?}", eta);
} else {
println!("Transfer completion time is unknown");
}
std::thread::sleep(std::time::Duration::from_secs(1));
}

Methods from Deref<Target = Transfer<R, W>>

[src]

pub fn is_complete(&self) -> bool

Tests if the transfer is complete

Example

use transfer_progress::Transfer;
use std::fs::File;
let reader = File::open("file1.txt")?;
let writer = File::create("file2.txt")?;
let transfer = Transfer::new(reader, writer);
while !transfer.is_complete() {
println!("Not complete yet");
std::thread::sleep(std::time::Duration::from_secs(1));
}
println!("Complete!");

[src]

pub fn transferred(&self) -> u64

Returns the number of bytes transferred thus far between the reader and the writer.

Example

use transfer_progress::Transfer;
use std::fs::File;
let reader = File::open("file1.txt")?;
let writer = File::create("file2.txt")?;
let transfer = Transfer::new(reader, writer);
while !transfer.is_complete() {
println!("{} bytes transferred so far", transfer.transferred());
std::thread::sleep(std::time::Duration::from_secs(1));
}
println!("Complete!");

[src]

pub fn running_time(&self) -> Duration

Returns the elapsed time since the transfer started.

Example

use transfer_progress::Transfer;
use std::fs::File;
let reader = File::open("file1.txt")?;
let writer = File::create("file2.txt")?;
let transfer = Transfer::new(reader, writer);
while !transfer.is_complete() {}
println!("Transfer took {:?}", transfer.running_time());

[src]

pub fn speed(&self) -> u64

Returns the average speed, in bytes per second, of the transfer.

Example

use transfer_progress::Transfer;
use std::fs::File;
let reader = File::open("file1.txt")?;
let writer = File::create("file2.txt")?;
let transfer = Transfer::new(reader, writer);
while !transfer.is_complete() {
println!("{}B/s", transfer.speed());
std::thread::sleep(std::time::Duration::from_secs(1));
}