Struct Transfer 

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

Monitors the progress of a transfer from a reader to a writer.

Implementations

impl<R, W> Transfer<R, W>

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

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

Creates and starts a new 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);

Examples found in repository

examples/copy.rs (line 13)

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

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

Consumes the Transfer, 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::Transfer;
use std::fs::File;
let reader = File::open("file1.txt")?;
let writer = File::create("file2.txt")?;
let transfer = Transfer::new(reader, writer);
let (reader, writer) = transfer.finish()?;

Examples found in repository

examples/copy.rs (line 22)

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

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 Transfer<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> Display for Transfer<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.