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
61
62
63
64
65
66
67
68
69
70
71
72
use std::fmt;
use std::path::Path;

use heim_common::prelude::*;
use heim_common::units::{Information, Ratio};

use crate::sys;

/// Disk usage statistics.
#[derive(heim_derive::ImplWrap)]
pub struct Usage(sys::Usage);

impl Usage {
    /// Returns total information amount available in partition.
    pub fn total(&self) -> Information {
        self.as_ref().total()
    }

    /// Returns used information amount used in partition.
    pub fn used(&self) -> Information {
        self.as_ref().used()
    }

    /// Returns free information about used in partition.
    pub fn free(&self) -> Information {
        self.as_ref().free()
    }

    pub fn ratio(&self) -> Ratio {
        self.as_ref().ratio()
    }
}

impl fmt::Debug for Usage {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.debug_struct("Usage")
            .field("total", &self.total())
            .field("used", &self.used())
            .field("free", &self.free())
            .field("ratio", &self.ratio())
            .finish()
    }
}

/// Returns disk [Usage] statistics about the partition which contains the given `path`.
///
/// ## Examples
///
/// ```rust
/// # #![feature(async_await, futures_api)]
/// #
/// # use heim_common::Result;
/// # use heim_disk::usage;
/// #
/// #[cfg(unix)]
/// static USAGE_PATH: &'static str = "/";
/// #[cfg(windows)]
/// static USAGE_PATH: &'static str = "C:\\";
///
/// # #[runtime::main]
/// # async fn main() -> Result<()> {
/// let usage = usage(USAGE_PATH).await?;
/// dbg!(usage);
/// #    Ok(())
/// # }
/// ```
pub fn usage<T>(path: T) -> impl Future<Output = Result<Usage>>
where
    T: AsRef<Path>,
{
    sys::usage(path).map(|res| res.map(Into::into))
}