sysd-manager-base 2.18.0

Base crate for sysd-manager providing common utilities and types.
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
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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use gettextrs::pgettext;
use glib::value::ToValue;
use strum::EnumIter;
use tracing::warn;

#[derive(
    Debug, Copy, Clone, PartialEq, Eq, glib::Enum, Default, EnumIter, Hash, Ord, PartialOrd,
)]
#[enum_type(name = "UnitDBusLevel")]
pub enum UnitDBusLevel {
    #[default]
    #[enum_value(name = "system", nick = "System")]
    System = 0,
    #[enum_value(name = "user", nick = "User Session")]
    UserSession = 1,
    #[enum_value(name = "both", nick = "System & User")]
    Both = 2,
}

impl UnitDBusLevel {
    pub fn short(&self) -> &str {
        match self {
            UnitDBusLevel::System => "s",
            UnitDBusLevel::UserSession => "u",
            UnitDBusLevel::Both => "b",
        }
    }

    pub fn normalize(&self) -> Self {
        match self {
            UnitDBusLevel::Both => UnitDBusLevel::System,
            bus => *bus,
        }
    }

    pub fn user_session(&self) -> bool {
        matches!(self, UnitDBusLevel::UserSession)
    }

    pub fn as_str(&self) -> &'static str {
        let level_value: &glib::EnumValue = self.to_value().get().expect("it's an enum");
        level_value.name()
    }

    //used in browser table
    pub fn label(&self) -> &'static str {
        self.as_str()
    }

    pub fn nice_label(&self) -> String {
        match self {
            //menu option
            UnitDBusLevel::UserSession => pgettext("dbus", "User Session"),
            //menu option
            _ => pgettext("dbus", "System"),
        }
    }

    pub fn from_short(suffix: &str) -> Self {
        match suffix {
            "s" => UnitDBusLevel::System,
            "u" => UnitDBusLevel::UserSession,
            "b" => UnitDBusLevel::Both,
            _ => UnitDBusLevel::System,
        }
    }

    pub fn tooltip_info(&self) -> Option<&str> {
        None
    }

    pub fn value(&self) -> i32 {
        let level_value: &glib::EnumValue = self.to_value().get().expect("it's an enum");
        level_value.value()
    }

    pub fn index(&self) -> u8 {
        match self {
            UnitDBusLevel::System => 0,
            UnitDBusLevel::UserSession => 1,
            UnitDBusLevel::Both => 2,
        }
    }
}

impl From<u8> for UnitDBusLevel {
    fn from(level: u8) -> Self {
        match level {
            0 => UnitDBusLevel::System,
            1 => UnitDBusLevel::UserSession,
            2 => UnitDBusLevel::Both,
            _ => UnitDBusLevel::UserSession,
        }
    }
}

impl From<u32> for UnitDBusLevel {
    fn from(level: u32) -> Self {
        (level as u8).into()
    }
}

impl From<&str> for UnitDBusLevel {
    fn from(level: &str) -> Self {
        match level {
            "user" => UnitDBusLevel::UserSession,
            "system" => UnitDBusLevel::System,
            "both" => UnitDBusLevel::Both,
            _ => {
                warn!("Unit dbus Level not found {level:?}");
                UnitDBusLevel::default()
            }
        }
    }
}

impl From<String> for UnitDBusLevel {
    fn from(level: String) -> Self {
        level.as_str().into()
    }
}