Struct SizedTransfer 

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

Monitors the progress of a transfer with a known size.

Implementations

impl<R, W> SizedTransfer<R, W>

where R: Read + Send + 'static, W: Write + Send + 'static,

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);

Examples found in repository

examples/sized_copy.rs (line 16)

fn main() -> io::Result<()> {
    let reader = File::open("/dev/urandom")?.take(DATA_TO_TRANSFER);
    let writer = io::sink();

    // Create the transfer monitor
    let transfer = SizedTransfer::new(reader, writer, DATA_TO_TRANSFER);

    while !transfer.is_complete() {
        std::thread::sleep(std::time::Duration::from_secs(1));
        // {:#} makes Transfer use SI units (MiB instead of MB)
        println!("{:#}", transfer);
    }

    // Catch any errors and retrieve the reader and writer
    let (_reader, _writer) = transfer.finish()?;
    Ok(())
}

pub fn size(&self) -> u64

Returns the total size (in bytes) of the transfer, as specified when calling new.

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);
assert_eq!(transfer.size(), 1024);

pub fn remaining(&self) -> u64

Returns the number of bytes remaining.

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!("{} bytes remaining", transfer.remaining());
std::thread::sleep(std::time::Duration::from_secs(1));
}

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()?;

Examples found in repository

examples/sized_copy.rs (line 25)

fn main() -> io::Result<()> {
    let reader = File::open("/dev/urandom")?.take(DATA_TO_TRANSFER);
    let writer = io::sink();

    // Create the transfer monitor
    let transfer = SizedTransfer::new(reader, writer, DATA_TO_TRANSFER);

    while !transfer.is_complete() {
        std::thread::sleep(std::time::Duration::from_secs(1));
        // {:#} makes Transfer use SI units (MiB instead of MB)
        println!("{:#}", transfer);
    }

    // Catch any errors and retrieve the reader and writer
    let (_reader, _writer) = transfer.finish()?;
    Ok(())
}

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));
}

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>>

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!");

Examples found in repository

examples/copy.rs (line 15)

fn main() -> io::Result<()> {
    let reader = File::open("/dev/urandom")?.take(1024 * 1024 * 1024); // 1 GiB
    let writer = io::sink();

    // Create the transfer monitor
    let transfer = Transfer::new(reader, writer);

    while !transfer.is_complete() {
        std::thread::sleep(std::time::Duration::from_secs(1));
        // {:#} makes Transfer use SI units (MiB instead of MB)
        println!("{:#}", transfer);
    }

    // Catch any errors and retrieve the reader and writer
    let (_reader, _writer) = transfer.finish()?;
    Ok(())
}

examples/sized_copy.rs (line 18)

fn main() -> io::Result<()> {
    let reader = File::open("/dev/urandom")?.take(DATA_TO_TRANSFER);
    let writer = io::sink();

    // Create the transfer monitor
    let transfer = SizedTransfer::new(reader, writer, DATA_TO_TRANSFER);

    while !transfer.is_complete() {
        std::thread::sleep(std::time::Duration::from_secs(1));
        // {:#} makes Transfer use SI units (MiB instead of MB)
        println!("{:#}", transfer);
    }

    // Catch any errors and retrieve the reader and writer
    let (_reader, _writer) = transfer.finish()?;
    Ok(())
}

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!");

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());

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));
}

Trait Implementations

impl<R, W> Debug for SizedTransfer<R, W>

where R: Read + Send + 'static, W: Write + Send + 'static,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<R, W> Deref for SizedTransfer<R, W>

where R: Read + Send + 'static, W: Write + Send + 'static,

type Target = Transfer<R, W>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<R, W> Display for SizedTransfer<R, W>

where R: Read + Send + 'static, W: Write + Send + 'static,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.