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
73
74
75
76
77
78
79
80
81
82
83
84
85
86

use std::fmt;

use heim_common::prelude::*;

use crate::{sys, Arch};

/// Host system information.
///
/// ## Provided information
///
/// For example, for Linux host command `uname -a` returns the following line:
/// ```bash
/// $ uname -a
/// Linux tardis 5.0.5-arch1-1-ARCH #1 SMP PREEMPT Wed Mar 27 17:53:10 UTC 2019 x86_64 GNU/Linux
/// ```
///
/// Information in this struct for the same host will look like this:
/// ```text
/// Platform {
///    system: "Linux",
///    release: "5.0.5-arch1-1-ARCH",
///    version: "#1 SMP PREEMPT Wed Mar 27 17:53:10 UTC 2019",
///    hostname: "tardis",
///    architecture: X86_64,
/// }
/// ```
///
/// Windows example:
/// ```text
/// Platform {
///     system: "Windows",
///     release: "10",
///     version: "17763",
///     hostname: "WINDEV1905EVAL",
///     architecture: X86_64,
/// }
/// ```
pub struct Platform(sys::Platform);

wrap!(Platform, sys::Platform);

impl Platform {
    /// Returns system name.
    pub fn system(&self) -> &str {
        self.as_ref().system()
    }

    /// Returns system release.
    pub fn release(&self) -> &str {
        self.as_ref().release()
    }

    /// Returns system version.
    pub fn version(&self) -> &str {
        self.as_ref().version()
    }

    /// Returns system hostname.
    pub fn hostname(&self) -> &str {
        self.as_ref().hostname()
    }

    /// Returns system architecture.
    pub fn architecture(&self) -> Arch {
        self.as_ref().architecture()
    }
}

impl fmt::Debug for Platform {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.debug_struct("Platform")
            .field("system", &self.system())
            .field("release", &self.release())
            .field("version", &self.version())
            .field("hostname", &self.hostname())
            .field("architecture", &self.architecture())
            .finish()
    }
}

/// Returns [Platform] information.
///
/// [Platform]: ./struct.Platform.html
pub async fn platform() -> Result<Platform> {
    sys::platform().await.map(Into::into)
}