computer-transfer 0.3.2

Packs and unpacks file trees for transfers between the host and the computer.
Documentation 
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

//! Packing and unpacking of files and folders for transfers between the host and the computer.
//!
//! Both sides speak tar. Packing and unpacking are synchronous, so callers run them with
//! `spawn_blocking` and connect them to async streams with the types in [`pipe`].

mod pack;
pub mod pipe;
mod rules;
mod unpack;

use std::fmt;

pub use pack::{Packed, pack, root_name};
pub use rules::Platform;
pub use unpack::{Unpacked, check_destination, unpack};

/// What a transfer did before it stopped.
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct Progress {
    pub files: u64,
    pub folders: u64,
    pub bytes: u64,
}

/// A transfer that stopped, with how far it got.
#[derive(Debug)]
pub struct Failure {
    pub message: String,
    pub progress: Progress,
}

impl Failure {
    pub(crate) fn new(message: impl Into<String>, progress: Progress) -> Self {
        Self {
            message: message.into(),
            progress,
        }
    }
}

impl fmt::Display for Failure {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let Progress {
            files,
            folders,
            bytes,
        } = self.progress;
        if files == 0 && folders == 0 && bytes == 0 {
            write!(f, "{}. Nothing was copied.", self.message)
        } else {
            write!(
                f,
                "{}. Before it stopped, {files} files, {folders} folders and {bytes} bytes were copied.",
                self.message
            )
        }
    }
}

impl std::error::Error for Failure {}