1use crate::ffi;
6use glib::{GStr, prelude::*, translate::*};
7
8#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
9#[non_exhaustive]
10#[doc(alias = "PolkitError")]
11pub enum Error {
12 #[doc(alias = "POLKIT_ERROR_FAILED")]
13 Failed,
14 #[doc(alias = "POLKIT_ERROR_CANCELLED")]
15 Cancelled,
16 #[doc(alias = "POLKIT_ERROR_NOT_SUPPORTED")]
17 NotSupported,
18 #[doc(alias = "POLKIT_ERROR_NOT_AUTHORIZED")]
19 NotAuthorized,
20 #[doc(hidden)]
21 __Unknown(i32),
22}
23
24#[doc(hidden)]
25impl IntoGlib for Error {
26 type GlibType = ffi::PolkitError;
27
28 #[inline]
29 fn into_glib(self) -> ffi::PolkitError {
30 match self {
31 Self::Failed => ffi::POLKIT_ERROR_FAILED,
32 Self::Cancelled => ffi::POLKIT_ERROR_CANCELLED,
33 Self::NotSupported => ffi::POLKIT_ERROR_NOT_SUPPORTED,
34 Self::NotAuthorized => ffi::POLKIT_ERROR_NOT_AUTHORIZED,
35 Self::__Unknown(value) => value,
36 }
37 }
38}
39
40#[doc(hidden)]
41impl FromGlib<ffi::PolkitError> for Error {
42 #[inline]
43 unsafe fn from_glib(value: ffi::PolkitError) -> Self {
44 match value {
45 ffi::POLKIT_ERROR_FAILED => Self::Failed,
46 ffi::POLKIT_ERROR_CANCELLED => Self::Cancelled,
47 ffi::POLKIT_ERROR_NOT_SUPPORTED => Self::NotSupported,
48 ffi::POLKIT_ERROR_NOT_AUTHORIZED => Self::NotAuthorized,
49 value => Self::__Unknown(value),
50 }
51 }
52}
53
54impl glib::error::ErrorDomain for Error {
55 #[inline]
56 fn domain() -> glib::Quark {
57 unsafe { from_glib(ffi::polkit_error_quark()) }
58 }
59
60 #[inline]
61 fn code(self) -> i32 {
62 self.into_glib()
63 }
64
65 #[inline]
66 #[allow(clippy::match_single_binding)]
67 fn from(code: i32) -> Option<Self> {
68 match unsafe { from_glib(code) } {
69 Self::__Unknown(_) => Some(Self::Failed),
70 value => Some(value),
71 }
72 }
73}
74
75impl StaticType for Error {
76 #[inline]
77 #[doc(alias = "polkit_error_get_type")]
78 fn static_type() -> glib::Type {
79 unsafe { from_glib(ffi::polkit_error_get_type()) }
80 }
81}
82
83impl glib::HasParamSpec for Error {
84 type ParamSpec = glib::ParamSpecEnum;
85 type SetValue = Self;
86 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
87
88 fn param_spec_builder() -> Self::BuilderFn {
89 Self::ParamSpec::builder_with_default
90 }
91}
92
93impl glib::value::ValueType for Error {
94 type Type = Self;
95}
96
97unsafe impl<'a> glib::value::FromValue<'a> for Error {
98 type Checker = glib::value::GenericValueTypeChecker<Self>;
99
100 #[inline]
101 unsafe fn from_value(value: &'a glib::Value) -> Self {
102 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
103 }
104}
105
106impl ToValue for Error {
107 #[inline]
108 fn to_value(&self) -> glib::Value {
109 let mut value = glib::Value::for_value_type::<Self>();
110 unsafe {
111 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
112 }
113 value
114 }
115
116 #[inline]
117 fn value_type(&self) -> glib::Type {
118 Self::static_type()
119 }
120}
121
122impl From<Error> for glib::Value {
123 #[inline]
124 fn from(v: Error) -> Self {
125 ToValue::to_value(&v)
126 }
127}
128
129#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
130#[non_exhaustive]
131#[doc(alias = "PolkitImplicitAuthorization")]
132pub enum ImplicitAuthorization {
133 #[doc(alias = "POLKIT_IMPLICIT_AUTHORIZATION_UNKNOWN")]
134 Unknown,
135 #[doc(alias = "POLKIT_IMPLICIT_AUTHORIZATION_NOT_AUTHORIZED")]
136 NotAuthorized,
137 #[doc(alias = "POLKIT_IMPLICIT_AUTHORIZATION_AUTHENTICATION_REQUIRED")]
138 AuthenticationRequired,
139 #[doc(alias = "POLKIT_IMPLICIT_AUTHORIZATION_ADMINISTRATOR_AUTHENTICATION_REQUIRED")]
140 AdministratorAuthenticationRequired,
141 #[doc(alias = "POLKIT_IMPLICIT_AUTHORIZATION_AUTHENTICATION_REQUIRED_RETAINED")]
142 AuthenticationRequiredRetained,
143 #[doc(alias = "POLKIT_IMPLICIT_AUTHORIZATION_ADMINISTRATOR_AUTHENTICATION_REQUIRED_RETAINED")]
144 AdministratorAuthenticationRequiredRetained,
145 #[doc(alias = "POLKIT_IMPLICIT_AUTHORIZATION_AUTHORIZED")]
146 Authorized,
147 #[doc(hidden)]
148 __Unknown(i32),
149}
150
151impl ImplicitAuthorization {
152 #[doc(alias = "polkit_implicit_authorization_from_string")]
153 pub fn from_string(string: &str) -> Option<ImplicitAuthorization> {
154 unsafe {
155 let mut out_implicit_authorization = std::mem::MaybeUninit::uninit();
156 let ret = from_glib(ffi::polkit_implicit_authorization_from_string(
157 string.to_glib_none().0,
158 out_implicit_authorization.as_mut_ptr(),
159 ));
160 if ret {
161 Some(from_glib(out_implicit_authorization.assume_init()))
162 } else {
163 None
164 }
165 }
166 }
167
168 pub fn to_str<'a>(self) -> &'a GStr {
169 unsafe {
170 GStr::from_ptr(
171 ffi::polkit_implicit_authorization_to_string(self.into_glib())
172 .as_ref()
173 .expect("polkit_implicit_authorization_to_string returned NULL"),
174 )
175 }
176 }
177}
178
179impl std::fmt::Display for ImplicitAuthorization {
180 #[inline]
181 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
182 f.write_str(self.to_str())
183 }
184}
185
186#[doc(hidden)]
187impl IntoGlib for ImplicitAuthorization {
188 type GlibType = ffi::PolkitImplicitAuthorization;
189
190 #[inline]
191 fn into_glib(self) -> ffi::PolkitImplicitAuthorization {
192 match self {
193 Self::Unknown => ffi::POLKIT_IMPLICIT_AUTHORIZATION_UNKNOWN,
194 Self::NotAuthorized => ffi::POLKIT_IMPLICIT_AUTHORIZATION_NOT_AUTHORIZED,
195 Self::AuthenticationRequired => {
196 ffi::POLKIT_IMPLICIT_AUTHORIZATION_AUTHENTICATION_REQUIRED
197 }
198 Self::AdministratorAuthenticationRequired => {
199 ffi::POLKIT_IMPLICIT_AUTHORIZATION_ADMINISTRATOR_AUTHENTICATION_REQUIRED
200 }
201 Self::AuthenticationRequiredRetained => {
202 ffi::POLKIT_IMPLICIT_AUTHORIZATION_AUTHENTICATION_REQUIRED_RETAINED
203 }
204 Self::AdministratorAuthenticationRequiredRetained => {
205 ffi::POLKIT_IMPLICIT_AUTHORIZATION_ADMINISTRATOR_AUTHENTICATION_REQUIRED_RETAINED
206 }
207 Self::Authorized => ffi::POLKIT_IMPLICIT_AUTHORIZATION_AUTHORIZED,
208 Self::__Unknown(value) => value,
209 }
210 }
211}
212
213#[doc(hidden)]
214impl FromGlib<ffi::PolkitImplicitAuthorization> for ImplicitAuthorization {
215 #[inline]
216 unsafe fn from_glib(value: ffi::PolkitImplicitAuthorization) -> Self {
217 match value {
218 ffi::POLKIT_IMPLICIT_AUTHORIZATION_UNKNOWN => Self::Unknown,
219 ffi::POLKIT_IMPLICIT_AUTHORIZATION_NOT_AUTHORIZED => Self::NotAuthorized,
220 ffi::POLKIT_IMPLICIT_AUTHORIZATION_AUTHENTICATION_REQUIRED => {
221 Self::AuthenticationRequired
222 }
223 ffi::POLKIT_IMPLICIT_AUTHORIZATION_ADMINISTRATOR_AUTHENTICATION_REQUIRED => {
224 Self::AdministratorAuthenticationRequired
225 }
226 ffi::POLKIT_IMPLICIT_AUTHORIZATION_AUTHENTICATION_REQUIRED_RETAINED => {
227 Self::AuthenticationRequiredRetained
228 }
229 ffi::POLKIT_IMPLICIT_AUTHORIZATION_ADMINISTRATOR_AUTHENTICATION_REQUIRED_RETAINED => {
230 Self::AdministratorAuthenticationRequiredRetained
231 }
232 ffi::POLKIT_IMPLICIT_AUTHORIZATION_AUTHORIZED => Self::Authorized,
233 value => Self::__Unknown(value),
234 }
235 }
236}
237
238impl StaticType for ImplicitAuthorization {
239 #[inline]
240 #[doc(alias = "polkit_implicit_authorization_get_type")]
241 fn static_type() -> glib::Type {
242 unsafe { from_glib(ffi::polkit_implicit_authorization_get_type()) }
243 }
244}
245
246impl glib::HasParamSpec for ImplicitAuthorization {
247 type ParamSpec = glib::ParamSpecEnum;
248 type SetValue = Self;
249 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
250
251 fn param_spec_builder() -> Self::BuilderFn {
252 Self::ParamSpec::builder_with_default
253 }
254}
255
256impl glib::value::ValueType for ImplicitAuthorization {
257 type Type = Self;
258}
259
260unsafe impl<'a> glib::value::FromValue<'a> for ImplicitAuthorization {
261 type Checker = glib::value::GenericValueTypeChecker<Self>;
262
263 #[inline]
264 unsafe fn from_value(value: &'a glib::Value) -> Self {
265 unsafe { from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) }
266 }
267}
268
269impl ToValue for ImplicitAuthorization {
270 #[inline]
271 fn to_value(&self) -> glib::Value {
272 let mut value = glib::Value::for_value_type::<Self>();
273 unsafe {
274 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
275 }
276 value
277 }
278
279 #[inline]
280 fn value_type(&self) -> glib::Type {
281 Self::static_type()
282 }
283}
284
285impl From<ImplicitAuthorization> for glib::Value {
286 #[inline]
287 fn from(v: ImplicitAuthorization) -> Self {
288 ToValue::to_value(&v)
289 }
290}