1use crate::ffi;
6use glib::{prelude::*, translate::*};
7
8#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
10#[non_exhaustive]
11#[doc(alias = "GBusType")]
12pub enum BusType {
13 #[doc(alias = "G_BUS_TYPE_STARTER")]
15 Starter,
16 #[doc(alias = "G_BUS_TYPE_NONE")]
18 None,
19 #[doc(alias = "G_BUS_TYPE_SYSTEM")]
21 System,
22 #[doc(alias = "G_BUS_TYPE_SESSION")]
24 Session,
25 #[doc(hidden)]
26 __Unknown(i32),
27}
28
29#[doc(hidden)]
30impl IntoGlib for BusType {
31 type GlibType = ffi::GBusType;
32
33 #[inline]
34 fn into_glib(self) -> ffi::GBusType {
35 match self {
36 Self::Starter => ffi::G_BUS_TYPE_STARTER,
37 Self::None => ffi::G_BUS_TYPE_NONE,
38 Self::System => ffi::G_BUS_TYPE_SYSTEM,
39 Self::Session => ffi::G_BUS_TYPE_SESSION,
40 Self::__Unknown(value) => value,
41 }
42 }
43}
44
45#[doc(hidden)]
46impl FromGlib<ffi::GBusType> for BusType {
47 #[inline]
48 unsafe fn from_glib(value: ffi::GBusType) -> Self {
49 match value {
50 ffi::G_BUS_TYPE_STARTER => Self::Starter,
51 ffi::G_BUS_TYPE_NONE => Self::None,
52 ffi::G_BUS_TYPE_SYSTEM => Self::System,
53 ffi::G_BUS_TYPE_SESSION => Self::Session,
54 value => Self::__Unknown(value),
55 }
56 }
57}
58
59impl StaticType for BusType {
60 #[inline]
61 #[doc(alias = "g_bus_type_get_type")]
62 fn static_type() -> glib::Type {
63 unsafe { from_glib(ffi::g_bus_type_get_type()) }
64 }
65}
66
67impl glib::HasParamSpec for BusType {
68 type ParamSpec = glib::ParamSpecEnum;
69 type SetValue = Self;
70 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
71
72 fn param_spec_builder() -> Self::BuilderFn {
73 Self::ParamSpec::builder_with_default
74 }
75}
76
77impl glib::value::ValueType for BusType {
78 type Type = Self;
79}
80
81unsafe impl<'a> glib::value::FromValue<'a> for BusType {
82 type Checker = glib::value::GenericValueTypeChecker<Self>;
83
84 #[inline]
85 unsafe fn from_value(value: &'a glib::Value) -> Self {
86 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
87 }
88}
89
90impl ToValue for BusType {
91 #[inline]
92 fn to_value(&self) -> glib::Value {
93 let mut value = glib::Value::for_value_type::<Self>();
94 unsafe {
95 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
96 }
97 value
98 }
99
100 #[inline]
101 fn value_type(&self) -> glib::Type {
102 Self::static_type()
103 }
104}
105
106impl From<BusType> for glib::Value {
107 #[inline]
108 fn from(v: BusType) -> Self {
109 ToValue::to_value(&v)
110 }
111}
112
113#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
115#[non_exhaustive]
116#[doc(alias = "GConverterResult")]
117pub enum ConverterResult {
118 #[doc(alias = "G_CONVERTER_ERROR")]
120 Error,
121 #[doc(alias = "G_CONVERTER_CONVERTED")]
123 Converted,
124 #[doc(alias = "G_CONVERTER_FINISHED")]
126 Finished,
127 #[doc(alias = "G_CONVERTER_FLUSHED")]
129 Flushed,
130 #[doc(hidden)]
131 __Unknown(i32),
132}
133
134#[doc(hidden)]
135impl IntoGlib for ConverterResult {
136 type GlibType = ffi::GConverterResult;
137
138 #[inline]
139 fn into_glib(self) -> ffi::GConverterResult {
140 match self {
141 Self::Error => ffi::G_CONVERTER_ERROR,
142 Self::Converted => ffi::G_CONVERTER_CONVERTED,
143 Self::Finished => ffi::G_CONVERTER_FINISHED,
144 Self::Flushed => ffi::G_CONVERTER_FLUSHED,
145 Self::__Unknown(value) => value,
146 }
147 }
148}
149
150#[doc(hidden)]
151impl FromGlib<ffi::GConverterResult> for ConverterResult {
152 #[inline]
153 unsafe fn from_glib(value: ffi::GConverterResult) -> Self {
154 match value {
155 ffi::G_CONVERTER_ERROR => Self::Error,
156 ffi::G_CONVERTER_CONVERTED => Self::Converted,
157 ffi::G_CONVERTER_FINISHED => Self::Finished,
158 ffi::G_CONVERTER_FLUSHED => Self::Flushed,
159 value => Self::__Unknown(value),
160 }
161 }
162}
163
164impl StaticType for ConverterResult {
165 #[inline]
166 #[doc(alias = "g_converter_result_get_type")]
167 fn static_type() -> glib::Type {
168 unsafe { from_glib(ffi::g_converter_result_get_type()) }
169 }
170}
171
172impl glib::HasParamSpec for ConverterResult {
173 type ParamSpec = glib::ParamSpecEnum;
174 type SetValue = Self;
175 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
176
177 fn param_spec_builder() -> Self::BuilderFn {
178 Self::ParamSpec::builder_with_default
179 }
180}
181
182impl glib::value::ValueType for ConverterResult {
183 type Type = Self;
184}
185
186unsafe impl<'a> glib::value::FromValue<'a> for ConverterResult {
187 type Checker = glib::value::GenericValueTypeChecker<Self>;
188
189 #[inline]
190 unsafe fn from_value(value: &'a glib::Value) -> Self {
191 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
192 }
193}
194
195impl ToValue for ConverterResult {
196 #[inline]
197 fn to_value(&self) -> glib::Value {
198 let mut value = glib::Value::for_value_type::<Self>();
199 unsafe {
200 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
201 }
202 value
203 }
204
205 #[inline]
206 fn value_type(&self) -> glib::Type {
207 Self::static_type()
208 }
209}
210
211impl From<ConverterResult> for glib::Value {
212 #[inline]
213 fn from(v: ConverterResult) -> Self {
214 ToValue::to_value(&v)
215 }
216}
217
218#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
220#[non_exhaustive]
221#[doc(alias = "GCredentialsType")]
222pub enum CredentialsType {
223 #[doc(alias = "G_CREDENTIALS_TYPE_INVALID")]
225 Invalid,
226 #[doc(alias = "G_CREDENTIALS_TYPE_LINUX_UCRED")]
228 LinuxUcred,
229 #[doc(alias = "G_CREDENTIALS_TYPE_FREEBSD_CMSGCRED")]
231 FreebsdCmsgcred,
232 #[doc(alias = "G_CREDENTIALS_TYPE_OPENBSD_SOCKPEERCRED")]
234 OpenbsdSockpeercred,
235 #[doc(alias = "G_CREDENTIALS_TYPE_SOLARIS_UCRED")]
237 SolarisUcred,
238 #[doc(alias = "G_CREDENTIALS_TYPE_NETBSD_UNPCBID")]
240 NetbsdUnpcbid,
241 #[doc(alias = "G_CREDENTIALS_TYPE_APPLE_XUCRED")]
243 AppleXucred,
244 #[cfg(feature = "v2_72")]
246 #[cfg_attr(docsrs, doc(cfg(feature = "v2_72")))]
247 #[doc(alias = "G_CREDENTIALS_TYPE_WIN32_PID")]
248 Win32Pid,
249 #[doc(hidden)]
250 __Unknown(i32),
251}
252
253#[doc(hidden)]
254impl IntoGlib for CredentialsType {
255 type GlibType = ffi::GCredentialsType;
256
257 #[inline]
258 fn into_glib(self) -> ffi::GCredentialsType {
259 match self {
260 Self::Invalid => ffi::G_CREDENTIALS_TYPE_INVALID,
261 Self::LinuxUcred => ffi::G_CREDENTIALS_TYPE_LINUX_UCRED,
262 Self::FreebsdCmsgcred => ffi::G_CREDENTIALS_TYPE_FREEBSD_CMSGCRED,
263 Self::OpenbsdSockpeercred => ffi::G_CREDENTIALS_TYPE_OPENBSD_SOCKPEERCRED,
264 Self::SolarisUcred => ffi::G_CREDENTIALS_TYPE_SOLARIS_UCRED,
265 Self::NetbsdUnpcbid => ffi::G_CREDENTIALS_TYPE_NETBSD_UNPCBID,
266 Self::AppleXucred => ffi::G_CREDENTIALS_TYPE_APPLE_XUCRED,
267 #[cfg(feature = "v2_72")]
268 Self::Win32Pid => ffi::G_CREDENTIALS_TYPE_WIN32_PID,
269 Self::__Unknown(value) => value,
270 }
271 }
272}
273
274#[doc(hidden)]
275impl FromGlib<ffi::GCredentialsType> for CredentialsType {
276 #[inline]
277 unsafe fn from_glib(value: ffi::GCredentialsType) -> Self {
278 match value {
279 ffi::G_CREDENTIALS_TYPE_INVALID => Self::Invalid,
280 ffi::G_CREDENTIALS_TYPE_LINUX_UCRED => Self::LinuxUcred,
281 ffi::G_CREDENTIALS_TYPE_FREEBSD_CMSGCRED => Self::FreebsdCmsgcred,
282 ffi::G_CREDENTIALS_TYPE_OPENBSD_SOCKPEERCRED => Self::OpenbsdSockpeercred,
283 ffi::G_CREDENTIALS_TYPE_SOLARIS_UCRED => Self::SolarisUcred,
284 ffi::G_CREDENTIALS_TYPE_NETBSD_UNPCBID => Self::NetbsdUnpcbid,
285 ffi::G_CREDENTIALS_TYPE_APPLE_XUCRED => Self::AppleXucred,
286 #[cfg(feature = "v2_72")]
287 ffi::G_CREDENTIALS_TYPE_WIN32_PID => Self::Win32Pid,
288 value => Self::__Unknown(value),
289 }
290 }
291}
292
293impl StaticType for CredentialsType {
294 #[inline]
295 #[doc(alias = "g_credentials_type_get_type")]
296 fn static_type() -> glib::Type {
297 unsafe { from_glib(ffi::g_credentials_type_get_type()) }
298 }
299}
300
301impl glib::HasParamSpec for CredentialsType {
302 type ParamSpec = glib::ParamSpecEnum;
303 type SetValue = Self;
304 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
305
306 fn param_spec_builder() -> Self::BuilderFn {
307 Self::ParamSpec::builder_with_default
308 }
309}
310
311impl glib::value::ValueType for CredentialsType {
312 type Type = Self;
313}
314
315unsafe impl<'a> glib::value::FromValue<'a> for CredentialsType {
316 type Checker = glib::value::GenericValueTypeChecker<Self>;
317
318 #[inline]
319 unsafe fn from_value(value: &'a glib::Value) -> Self {
320 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
321 }
322}
323
324impl ToValue for CredentialsType {
325 #[inline]
326 fn to_value(&self) -> glib::Value {
327 let mut value = glib::Value::for_value_type::<Self>();
328 unsafe {
329 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
330 }
331 value
332 }
333
334 #[inline]
335 fn value_type(&self) -> glib::Type {
336 Self::static_type()
337 }
338}
339
340impl From<CredentialsType> for glib::Value {
341 #[inline]
342 fn from(v: CredentialsType) -> Self {
343 ToValue::to_value(&v)
344 }
345}
346
347#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
349#[non_exhaustive]
350#[doc(alias = "GDBusError")]
351pub enum DBusError {
352 #[doc(alias = "G_DBUS_ERROR_FAILED")]
355 Failed,
356 #[doc(alias = "G_DBUS_ERROR_NO_MEMORY")]
358 NoMemory,
359 #[doc(alias = "G_DBUS_ERROR_SERVICE_UNKNOWN")]
362 ServiceUnknown,
363 #[doc(alias = "G_DBUS_ERROR_NAME_HAS_NO_OWNER")]
366 NameHasNoOwner,
367 #[doc(alias = "G_DBUS_ERROR_NO_REPLY")]
369 NoReply,
370 #[doc(alias = "G_DBUS_ERROR_IO_ERROR")]
372 IoError,
373 #[doc(alias = "G_DBUS_ERROR_BAD_ADDRESS")]
375 BadAddress,
376 #[doc(alias = "G_DBUS_ERROR_NOT_SUPPORTED")]
378 NotSupported,
379 #[doc(alias = "G_DBUS_ERROR_LIMITS_EXCEEDED")]
381 LimitsExceeded,
382 #[doc(alias = "G_DBUS_ERROR_ACCESS_DENIED")]
384 AccessDenied,
385 #[doc(alias = "G_DBUS_ERROR_AUTH_FAILED")]
387 AuthFailed,
388 #[doc(alias = "G_DBUS_ERROR_NO_SERVER")]
391 NoServer,
392 #[doc(alias = "G_DBUS_ERROR_TIMEOUT")]
398 Timeout,
399 #[doc(alias = "G_DBUS_ERROR_NO_NETWORK")]
401 NoNetwork,
402 #[doc(alias = "G_DBUS_ERROR_ADDRESS_IN_USE")]
404 AddressInUse,
405 #[doc(alias = "G_DBUS_ERROR_DISCONNECTED")]
407 Disconnected,
408 #[doc(alias = "G_DBUS_ERROR_INVALID_ARGS")]
410 InvalidArgs,
411 #[doc(alias = "G_DBUS_ERROR_FILE_NOT_FOUND")]
413 FileNotFound,
414 #[doc(alias = "G_DBUS_ERROR_FILE_EXISTS")]
416 FileExists,
417 #[doc(alias = "G_DBUS_ERROR_UNKNOWN_METHOD")]
419 UnknownMethod,
420 #[doc(alias = "G_DBUS_ERROR_TIMED_OUT")]
424 TimedOut,
425 #[doc(alias = "G_DBUS_ERROR_MATCH_RULE_NOT_FOUND")]
427 MatchRuleNotFound,
428 #[doc(alias = "G_DBUS_ERROR_MATCH_RULE_INVALID")]
430 MatchRuleInvalid,
431 #[doc(alias = "G_DBUS_ERROR_SPAWN_EXEC_FAILED")]
433 SpawnExecFailed,
434 #[doc(alias = "G_DBUS_ERROR_SPAWN_FORK_FAILED")]
436 SpawnForkFailed,
437 #[doc(alias = "G_DBUS_ERROR_SPAWN_CHILD_EXITED")]
439 SpawnChildExited,
440 #[doc(alias = "G_DBUS_ERROR_SPAWN_CHILD_SIGNALED")]
442 SpawnChildSignaled,
443 #[doc(alias = "G_DBUS_ERROR_SPAWN_FAILED")]
445 SpawnFailed,
446 #[doc(alias = "G_DBUS_ERROR_SPAWN_SETUP_FAILED")]
448 SpawnSetupFailed,
449 #[doc(alias = "G_DBUS_ERROR_SPAWN_CONFIG_INVALID")]
451 SpawnConfigInvalid,
452 #[doc(alias = "G_DBUS_ERROR_SPAWN_SERVICE_INVALID")]
454 SpawnServiceInvalid,
455 #[doc(alias = "G_DBUS_ERROR_SPAWN_SERVICE_NOT_FOUND")]
457 SpawnServiceNotFound,
458 #[doc(alias = "G_DBUS_ERROR_SPAWN_PERMISSIONS_INVALID")]
460 SpawnPermissionsInvalid,
461 #[doc(alias = "G_DBUS_ERROR_SPAWN_FILE_INVALID")]
463 SpawnFileInvalid,
464 #[doc(alias = "G_DBUS_ERROR_SPAWN_NO_MEMORY")]
466 SpawnNoMemory,
467 #[doc(alias = "G_DBUS_ERROR_UNIX_PROCESS_ID_UNKNOWN")]
469 UnixProcessIdUnknown,
470 #[doc(alias = "G_DBUS_ERROR_INVALID_SIGNATURE")]
472 InvalidSignature,
473 #[doc(alias = "G_DBUS_ERROR_INVALID_FILE_CONTENT")]
475 InvalidFileContent,
476 #[doc(alias = "G_DBUS_ERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN")]
478 SelinuxSecurityContextUnknown,
479 #[doc(alias = "G_DBUS_ERROR_ADT_AUDIT_DATA_UNKNOWN")]
481 AdtAuditDataUnknown,
482 #[doc(alias = "G_DBUS_ERROR_OBJECT_PATH_IN_USE")]
484 ObjectPathInUse,
485 #[doc(alias = "G_DBUS_ERROR_UNKNOWN_OBJECT")]
487 UnknownObject,
488 #[doc(alias = "G_DBUS_ERROR_UNKNOWN_INTERFACE")]
490 UnknownInterface,
491 #[doc(alias = "G_DBUS_ERROR_UNKNOWN_PROPERTY")]
493 UnknownProperty,
494 #[doc(alias = "G_DBUS_ERROR_PROPERTY_READ_ONLY")]
496 PropertyReadOnly,
497 #[doc(hidden)]
498 __Unknown(i32),
499}
500
501impl DBusError {
502 #[doc(alias = "g_dbus_error_encode_gerror")]
503 pub fn encode_gerror(error: &glib::Error) -> glib::GString {
504 unsafe { from_glib_full(ffi::g_dbus_error_encode_gerror(error.to_glib_none().0)) }
505 }
506
507 #[doc(alias = "g_dbus_error_get_remote_error")]
508 #[doc(alias = "get_remote_error")]
509 pub fn remote_error(error: &glib::Error) -> Option<glib::GString> {
510 unsafe { from_glib_full(ffi::g_dbus_error_get_remote_error(error.to_glib_none().0)) }
511 }
512
513 #[doc(alias = "g_dbus_error_is_remote_error")]
514 pub fn is_remote_error(error: &glib::Error) -> bool {
515 unsafe { from_glib(ffi::g_dbus_error_is_remote_error(error.to_glib_none().0)) }
516 }
517
518 #[doc(alias = "g_dbus_error_new_for_dbus_error")]
519 pub fn new_for_dbus_error(dbus_error_name: &str, dbus_error_message: &str) -> glib::Error {
520 unsafe {
521 from_glib_full(ffi::g_dbus_error_new_for_dbus_error(
522 dbus_error_name.to_glib_none().0,
523 dbus_error_message.to_glib_none().0,
524 ))
525 }
526 }
527
528 #[doc(alias = "g_dbus_error_register_error")]
529 pub fn register_error(
530 error_domain: glib::Quark,
531 error_code: i32,
532 dbus_error_name: &str,
533 ) -> bool {
534 unsafe {
535 from_glib(ffi::g_dbus_error_register_error(
536 error_domain.into_glib(),
537 error_code,
538 dbus_error_name.to_glib_none().0,
539 ))
540 }
541 }
542
543 #[doc(alias = "g_dbus_error_strip_remote_error")]
559 pub fn strip_remote_error(error: &mut glib::Error) -> bool {
560 unsafe {
561 from_glib(ffi::g_dbus_error_strip_remote_error(
562 error.to_glib_none_mut().0,
563 ))
564 }
565 }
566
567 #[doc(alias = "g_dbus_error_unregister_error")]
568 pub fn unregister_error(
569 error_domain: glib::Quark,
570 error_code: i32,
571 dbus_error_name: &str,
572 ) -> bool {
573 unsafe {
574 from_glib(ffi::g_dbus_error_unregister_error(
575 error_domain.into_glib(),
576 error_code,
577 dbus_error_name.to_glib_none().0,
578 ))
579 }
580 }
581}
582
583#[doc(hidden)]
584impl IntoGlib for DBusError {
585 type GlibType = ffi::GDBusError;
586
587 fn into_glib(self) -> ffi::GDBusError {
588 match self {
589 Self::Failed => ffi::G_DBUS_ERROR_FAILED,
590 Self::NoMemory => ffi::G_DBUS_ERROR_NO_MEMORY,
591 Self::ServiceUnknown => ffi::G_DBUS_ERROR_SERVICE_UNKNOWN,
592 Self::NameHasNoOwner => ffi::G_DBUS_ERROR_NAME_HAS_NO_OWNER,
593 Self::NoReply => ffi::G_DBUS_ERROR_NO_REPLY,
594 Self::IoError => ffi::G_DBUS_ERROR_IO_ERROR,
595 Self::BadAddress => ffi::G_DBUS_ERROR_BAD_ADDRESS,
596 Self::NotSupported => ffi::G_DBUS_ERROR_NOT_SUPPORTED,
597 Self::LimitsExceeded => ffi::G_DBUS_ERROR_LIMITS_EXCEEDED,
598 Self::AccessDenied => ffi::G_DBUS_ERROR_ACCESS_DENIED,
599 Self::AuthFailed => ffi::G_DBUS_ERROR_AUTH_FAILED,
600 Self::NoServer => ffi::G_DBUS_ERROR_NO_SERVER,
601 Self::Timeout => ffi::G_DBUS_ERROR_TIMEOUT,
602 Self::NoNetwork => ffi::G_DBUS_ERROR_NO_NETWORK,
603 Self::AddressInUse => ffi::G_DBUS_ERROR_ADDRESS_IN_USE,
604 Self::Disconnected => ffi::G_DBUS_ERROR_DISCONNECTED,
605 Self::InvalidArgs => ffi::G_DBUS_ERROR_INVALID_ARGS,
606 Self::FileNotFound => ffi::G_DBUS_ERROR_FILE_NOT_FOUND,
607 Self::FileExists => ffi::G_DBUS_ERROR_FILE_EXISTS,
608 Self::UnknownMethod => ffi::G_DBUS_ERROR_UNKNOWN_METHOD,
609 Self::TimedOut => ffi::G_DBUS_ERROR_TIMED_OUT,
610 Self::MatchRuleNotFound => ffi::G_DBUS_ERROR_MATCH_RULE_NOT_FOUND,
611 Self::MatchRuleInvalid => ffi::G_DBUS_ERROR_MATCH_RULE_INVALID,
612 Self::SpawnExecFailed => ffi::G_DBUS_ERROR_SPAWN_EXEC_FAILED,
613 Self::SpawnForkFailed => ffi::G_DBUS_ERROR_SPAWN_FORK_FAILED,
614 Self::SpawnChildExited => ffi::G_DBUS_ERROR_SPAWN_CHILD_EXITED,
615 Self::SpawnChildSignaled => ffi::G_DBUS_ERROR_SPAWN_CHILD_SIGNALED,
616 Self::SpawnFailed => ffi::G_DBUS_ERROR_SPAWN_FAILED,
617 Self::SpawnSetupFailed => ffi::G_DBUS_ERROR_SPAWN_SETUP_FAILED,
618 Self::SpawnConfigInvalid => ffi::G_DBUS_ERROR_SPAWN_CONFIG_INVALID,
619 Self::SpawnServiceInvalid => ffi::G_DBUS_ERROR_SPAWN_SERVICE_INVALID,
620 Self::SpawnServiceNotFound => ffi::G_DBUS_ERROR_SPAWN_SERVICE_NOT_FOUND,
621 Self::SpawnPermissionsInvalid => ffi::G_DBUS_ERROR_SPAWN_PERMISSIONS_INVALID,
622 Self::SpawnFileInvalid => ffi::G_DBUS_ERROR_SPAWN_FILE_INVALID,
623 Self::SpawnNoMemory => ffi::G_DBUS_ERROR_SPAWN_NO_MEMORY,
624 Self::UnixProcessIdUnknown => ffi::G_DBUS_ERROR_UNIX_PROCESS_ID_UNKNOWN,
625 Self::InvalidSignature => ffi::G_DBUS_ERROR_INVALID_SIGNATURE,
626 Self::InvalidFileContent => ffi::G_DBUS_ERROR_INVALID_FILE_CONTENT,
627 Self::SelinuxSecurityContextUnknown => {
628 ffi::G_DBUS_ERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN
629 }
630 Self::AdtAuditDataUnknown => ffi::G_DBUS_ERROR_ADT_AUDIT_DATA_UNKNOWN,
631 Self::ObjectPathInUse => ffi::G_DBUS_ERROR_OBJECT_PATH_IN_USE,
632 Self::UnknownObject => ffi::G_DBUS_ERROR_UNKNOWN_OBJECT,
633 Self::UnknownInterface => ffi::G_DBUS_ERROR_UNKNOWN_INTERFACE,
634 Self::UnknownProperty => ffi::G_DBUS_ERROR_UNKNOWN_PROPERTY,
635 Self::PropertyReadOnly => ffi::G_DBUS_ERROR_PROPERTY_READ_ONLY,
636 Self::__Unknown(value) => value,
637 }
638 }
639}
640
641#[doc(hidden)]
642impl FromGlib<ffi::GDBusError> for DBusError {
643 unsafe fn from_glib(value: ffi::GDBusError) -> Self {
644 match value {
645 ffi::G_DBUS_ERROR_FAILED => Self::Failed,
646 ffi::G_DBUS_ERROR_NO_MEMORY => Self::NoMemory,
647 ffi::G_DBUS_ERROR_SERVICE_UNKNOWN => Self::ServiceUnknown,
648 ffi::G_DBUS_ERROR_NAME_HAS_NO_OWNER => Self::NameHasNoOwner,
649 ffi::G_DBUS_ERROR_NO_REPLY => Self::NoReply,
650 ffi::G_DBUS_ERROR_IO_ERROR => Self::IoError,
651 ffi::G_DBUS_ERROR_BAD_ADDRESS => Self::BadAddress,
652 ffi::G_DBUS_ERROR_NOT_SUPPORTED => Self::NotSupported,
653 ffi::G_DBUS_ERROR_LIMITS_EXCEEDED => Self::LimitsExceeded,
654 ffi::G_DBUS_ERROR_ACCESS_DENIED => Self::AccessDenied,
655 ffi::G_DBUS_ERROR_AUTH_FAILED => Self::AuthFailed,
656 ffi::G_DBUS_ERROR_NO_SERVER => Self::NoServer,
657 ffi::G_DBUS_ERROR_TIMEOUT => Self::Timeout,
658 ffi::G_DBUS_ERROR_NO_NETWORK => Self::NoNetwork,
659 ffi::G_DBUS_ERROR_ADDRESS_IN_USE => Self::AddressInUse,
660 ffi::G_DBUS_ERROR_DISCONNECTED => Self::Disconnected,
661 ffi::G_DBUS_ERROR_INVALID_ARGS => Self::InvalidArgs,
662 ffi::G_DBUS_ERROR_FILE_NOT_FOUND => Self::FileNotFound,
663 ffi::G_DBUS_ERROR_FILE_EXISTS => Self::FileExists,
664 ffi::G_DBUS_ERROR_UNKNOWN_METHOD => Self::UnknownMethod,
665 ffi::G_DBUS_ERROR_TIMED_OUT => Self::TimedOut,
666 ffi::G_DBUS_ERROR_MATCH_RULE_NOT_FOUND => Self::MatchRuleNotFound,
667 ffi::G_DBUS_ERROR_MATCH_RULE_INVALID => Self::MatchRuleInvalid,
668 ffi::G_DBUS_ERROR_SPAWN_EXEC_FAILED => Self::SpawnExecFailed,
669 ffi::G_DBUS_ERROR_SPAWN_FORK_FAILED => Self::SpawnForkFailed,
670 ffi::G_DBUS_ERROR_SPAWN_CHILD_EXITED => Self::SpawnChildExited,
671 ffi::G_DBUS_ERROR_SPAWN_CHILD_SIGNALED => Self::SpawnChildSignaled,
672 ffi::G_DBUS_ERROR_SPAWN_FAILED => Self::SpawnFailed,
673 ffi::G_DBUS_ERROR_SPAWN_SETUP_FAILED => Self::SpawnSetupFailed,
674 ffi::G_DBUS_ERROR_SPAWN_CONFIG_INVALID => Self::SpawnConfigInvalid,
675 ffi::G_DBUS_ERROR_SPAWN_SERVICE_INVALID => Self::SpawnServiceInvalid,
676 ffi::G_DBUS_ERROR_SPAWN_SERVICE_NOT_FOUND => Self::SpawnServiceNotFound,
677 ffi::G_DBUS_ERROR_SPAWN_PERMISSIONS_INVALID => Self::SpawnPermissionsInvalid,
678 ffi::G_DBUS_ERROR_SPAWN_FILE_INVALID => Self::SpawnFileInvalid,
679 ffi::G_DBUS_ERROR_SPAWN_NO_MEMORY => Self::SpawnNoMemory,
680 ffi::G_DBUS_ERROR_UNIX_PROCESS_ID_UNKNOWN => Self::UnixProcessIdUnknown,
681 ffi::G_DBUS_ERROR_INVALID_SIGNATURE => Self::InvalidSignature,
682 ffi::G_DBUS_ERROR_INVALID_FILE_CONTENT => Self::InvalidFileContent,
683 ffi::G_DBUS_ERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN => {
684 Self::SelinuxSecurityContextUnknown
685 }
686 ffi::G_DBUS_ERROR_ADT_AUDIT_DATA_UNKNOWN => Self::AdtAuditDataUnknown,
687 ffi::G_DBUS_ERROR_OBJECT_PATH_IN_USE => Self::ObjectPathInUse,
688 ffi::G_DBUS_ERROR_UNKNOWN_OBJECT => Self::UnknownObject,
689 ffi::G_DBUS_ERROR_UNKNOWN_INTERFACE => Self::UnknownInterface,
690 ffi::G_DBUS_ERROR_UNKNOWN_PROPERTY => Self::UnknownProperty,
691 ffi::G_DBUS_ERROR_PROPERTY_READ_ONLY => Self::PropertyReadOnly,
692 value => Self::__Unknown(value),
693 }
694 }
695}
696
697impl glib::error::ErrorDomain for DBusError {
698 #[inline]
699 fn domain() -> glib::Quark {
700 unsafe { from_glib(ffi::g_dbus_error_quark()) }
701 }
702
703 #[inline]
704 fn code(self) -> i32 {
705 self.into_glib()
706 }
707
708 #[inline]
709 #[allow(clippy::match_single_binding)]
710 fn from(code: i32) -> Option<Self> {
711 match unsafe { from_glib(code) } {
712 Self::__Unknown(_) => Some(Self::Failed),
713 value => Some(value),
714 }
715 }
716}
717
718impl StaticType for DBusError {
719 #[inline]
720 #[doc(alias = "g_dbus_error_get_type")]
721 fn static_type() -> glib::Type {
722 unsafe { from_glib(ffi::g_dbus_error_get_type()) }
723 }
724}
725
726impl glib::HasParamSpec for DBusError {
727 type ParamSpec = glib::ParamSpecEnum;
728 type SetValue = Self;
729 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
730
731 fn param_spec_builder() -> Self::BuilderFn {
732 Self::ParamSpec::builder_with_default
733 }
734}
735
736impl glib::value::ValueType for DBusError {
737 type Type = Self;
738}
739
740unsafe impl<'a> glib::value::FromValue<'a> for DBusError {
741 type Checker = glib::value::GenericValueTypeChecker<Self>;
742
743 #[inline]
744 unsafe fn from_value(value: &'a glib::Value) -> Self {
745 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
746 }
747}
748
749impl ToValue for DBusError {
750 #[inline]
751 fn to_value(&self) -> glib::Value {
752 let mut value = glib::Value::for_value_type::<Self>();
753 unsafe {
754 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
755 }
756 value
757 }
758
759 #[inline]
760 fn value_type(&self) -> glib::Type {
761 Self::static_type()
762 }
763}
764
765impl From<DBusError> for glib::Value {
766 #[inline]
767 fn from(v: DBusError) -> Self {
768 ToValue::to_value(&v)
769 }
770}
771
772#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
774#[non_exhaustive]
775#[doc(alias = "GDBusMessageByteOrder")]
776pub enum DBusMessageByteOrder {
777 #[doc(alias = "G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN")]
779 BigEndian,
780 #[doc(alias = "G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN")]
782 LittleEndian,
783 #[doc(hidden)]
784 __Unknown(i32),
785}
786
787#[doc(hidden)]
788impl IntoGlib for DBusMessageByteOrder {
789 type GlibType = ffi::GDBusMessageByteOrder;
790
791 #[inline]
792 fn into_glib(self) -> ffi::GDBusMessageByteOrder {
793 match self {
794 Self::BigEndian => ffi::G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN,
795 Self::LittleEndian => ffi::G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN,
796 Self::__Unknown(value) => value,
797 }
798 }
799}
800
801#[doc(hidden)]
802impl FromGlib<ffi::GDBusMessageByteOrder> for DBusMessageByteOrder {
803 #[inline]
804 unsafe fn from_glib(value: ffi::GDBusMessageByteOrder) -> Self {
805 match value {
806 ffi::G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN => Self::BigEndian,
807 ffi::G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN => Self::LittleEndian,
808 value => Self::__Unknown(value),
809 }
810 }
811}
812
813impl StaticType for DBusMessageByteOrder {
814 #[inline]
815 #[doc(alias = "g_dbus_message_byte_order_get_type")]
816 fn static_type() -> glib::Type {
817 unsafe { from_glib(ffi::g_dbus_message_byte_order_get_type()) }
818 }
819}
820
821impl glib::HasParamSpec for DBusMessageByteOrder {
822 type ParamSpec = glib::ParamSpecEnum;
823 type SetValue = Self;
824 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
825
826 fn param_spec_builder() -> Self::BuilderFn {
827 Self::ParamSpec::builder_with_default
828 }
829}
830
831impl glib::value::ValueType for DBusMessageByteOrder {
832 type Type = Self;
833}
834
835unsafe impl<'a> glib::value::FromValue<'a> for DBusMessageByteOrder {
836 type Checker = glib::value::GenericValueTypeChecker<Self>;
837
838 #[inline]
839 unsafe fn from_value(value: &'a glib::Value) -> Self {
840 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
841 }
842}
843
844impl ToValue for DBusMessageByteOrder {
845 #[inline]
846 fn to_value(&self) -> glib::Value {
847 let mut value = glib::Value::for_value_type::<Self>();
848 unsafe {
849 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
850 }
851 value
852 }
853
854 #[inline]
855 fn value_type(&self) -> glib::Type {
856 Self::static_type()
857 }
858}
859
860impl From<DBusMessageByteOrder> for glib::Value {
861 #[inline]
862 fn from(v: DBusMessageByteOrder) -> Self {
863 ToValue::to_value(&v)
864 }
865}
866
867#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
869#[non_exhaustive]
870#[doc(alias = "GDBusMessageHeaderField")]
871pub enum DBusMessageHeaderField {
872 #[doc(alias = "G_DBUS_MESSAGE_HEADER_FIELD_INVALID")]
874 Invalid,
875 #[doc(alias = "G_DBUS_MESSAGE_HEADER_FIELD_PATH")]
877 Path,
878 #[doc(alias = "G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE")]
880 Interface,
881 #[doc(alias = "G_DBUS_MESSAGE_HEADER_FIELD_MEMBER")]
883 Member,
884 #[doc(alias = "G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME")]
886 ErrorName,
887 #[doc(alias = "G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL")]
889 ReplySerial,
890 #[doc(alias = "G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION")]
892 Destination,
893 #[doc(alias = "G_DBUS_MESSAGE_HEADER_FIELD_SENDER")]
895 Sender,
896 #[doc(alias = "G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE")]
898 Signature,
899 #[doc(alias = "G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS")]
901 NumUnixFds,
902 #[doc(hidden)]
903 __Unknown(i32),
904}
905
906#[doc(hidden)]
907impl IntoGlib for DBusMessageHeaderField {
908 type GlibType = ffi::GDBusMessageHeaderField;
909
910 #[inline]
911 fn into_glib(self) -> ffi::GDBusMessageHeaderField {
912 match self {
913 Self::Invalid => ffi::G_DBUS_MESSAGE_HEADER_FIELD_INVALID,
914 Self::Path => ffi::G_DBUS_MESSAGE_HEADER_FIELD_PATH,
915 Self::Interface => ffi::G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE,
916 Self::Member => ffi::G_DBUS_MESSAGE_HEADER_FIELD_MEMBER,
917 Self::ErrorName => ffi::G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME,
918 Self::ReplySerial => ffi::G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL,
919 Self::Destination => ffi::G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION,
920 Self::Sender => ffi::G_DBUS_MESSAGE_HEADER_FIELD_SENDER,
921 Self::Signature => ffi::G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE,
922 Self::NumUnixFds => ffi::G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS,
923 Self::__Unknown(value) => value,
924 }
925 }
926}
927
928#[doc(hidden)]
929impl FromGlib<ffi::GDBusMessageHeaderField> for DBusMessageHeaderField {
930 #[inline]
931 unsafe fn from_glib(value: ffi::GDBusMessageHeaderField) -> Self {
932 match value {
933 ffi::G_DBUS_MESSAGE_HEADER_FIELD_INVALID => Self::Invalid,
934 ffi::G_DBUS_MESSAGE_HEADER_FIELD_PATH => Self::Path,
935 ffi::G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE => Self::Interface,
936 ffi::G_DBUS_MESSAGE_HEADER_FIELD_MEMBER => Self::Member,
937 ffi::G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME => Self::ErrorName,
938 ffi::G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL => Self::ReplySerial,
939 ffi::G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION => Self::Destination,
940 ffi::G_DBUS_MESSAGE_HEADER_FIELD_SENDER => Self::Sender,
941 ffi::G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE => Self::Signature,
942 ffi::G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS => Self::NumUnixFds,
943 value => Self::__Unknown(value),
944 }
945 }
946}
947
948impl StaticType for DBusMessageHeaderField {
949 #[inline]
950 #[doc(alias = "g_dbus_message_header_field_get_type")]
951 fn static_type() -> glib::Type {
952 unsafe { from_glib(ffi::g_dbus_message_header_field_get_type()) }
953 }
954}
955
956impl glib::HasParamSpec for DBusMessageHeaderField {
957 type ParamSpec = glib::ParamSpecEnum;
958 type SetValue = Self;
959 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
960
961 fn param_spec_builder() -> Self::BuilderFn {
962 Self::ParamSpec::builder_with_default
963 }
964}
965
966impl glib::value::ValueType for DBusMessageHeaderField {
967 type Type = Self;
968}
969
970unsafe impl<'a> glib::value::FromValue<'a> for DBusMessageHeaderField {
971 type Checker = glib::value::GenericValueTypeChecker<Self>;
972
973 #[inline]
974 unsafe fn from_value(value: &'a glib::Value) -> Self {
975 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
976 }
977}
978
979impl ToValue for DBusMessageHeaderField {
980 #[inline]
981 fn to_value(&self) -> glib::Value {
982 let mut value = glib::Value::for_value_type::<Self>();
983 unsafe {
984 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
985 }
986 value
987 }
988
989 #[inline]
990 fn value_type(&self) -> glib::Type {
991 Self::static_type()
992 }
993}
994
995impl From<DBusMessageHeaderField> for glib::Value {
996 #[inline]
997 fn from(v: DBusMessageHeaderField) -> Self {
998 ToValue::to_value(&v)
999 }
1000}
1001
1002#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1004#[non_exhaustive]
1005#[doc(alias = "GDBusMessageType")]
1006pub enum DBusMessageType {
1007 #[doc(alias = "G_DBUS_MESSAGE_TYPE_INVALID")]
1009 Invalid,
1010 #[doc(alias = "G_DBUS_MESSAGE_TYPE_METHOD_CALL")]
1012 MethodCall,
1013 #[doc(alias = "G_DBUS_MESSAGE_TYPE_METHOD_RETURN")]
1015 MethodReturn,
1016 #[doc(alias = "G_DBUS_MESSAGE_TYPE_ERROR")]
1018 Error,
1019 #[doc(alias = "G_DBUS_MESSAGE_TYPE_SIGNAL")]
1021 Signal,
1022 #[doc(hidden)]
1023 __Unknown(i32),
1024}
1025
1026#[doc(hidden)]
1027impl IntoGlib for DBusMessageType {
1028 type GlibType = ffi::GDBusMessageType;
1029
1030 #[inline]
1031 fn into_glib(self) -> ffi::GDBusMessageType {
1032 match self {
1033 Self::Invalid => ffi::G_DBUS_MESSAGE_TYPE_INVALID,
1034 Self::MethodCall => ffi::G_DBUS_MESSAGE_TYPE_METHOD_CALL,
1035 Self::MethodReturn => ffi::G_DBUS_MESSAGE_TYPE_METHOD_RETURN,
1036 Self::Error => ffi::G_DBUS_MESSAGE_TYPE_ERROR,
1037 Self::Signal => ffi::G_DBUS_MESSAGE_TYPE_SIGNAL,
1038 Self::__Unknown(value) => value,
1039 }
1040 }
1041}
1042
1043#[doc(hidden)]
1044impl FromGlib<ffi::GDBusMessageType> for DBusMessageType {
1045 #[inline]
1046 unsafe fn from_glib(value: ffi::GDBusMessageType) -> Self {
1047 match value {
1048 ffi::G_DBUS_MESSAGE_TYPE_INVALID => Self::Invalid,
1049 ffi::G_DBUS_MESSAGE_TYPE_METHOD_CALL => Self::MethodCall,
1050 ffi::G_DBUS_MESSAGE_TYPE_METHOD_RETURN => Self::MethodReturn,
1051 ffi::G_DBUS_MESSAGE_TYPE_ERROR => Self::Error,
1052 ffi::G_DBUS_MESSAGE_TYPE_SIGNAL => Self::Signal,
1053 value => Self::__Unknown(value),
1054 }
1055 }
1056}
1057
1058impl StaticType for DBusMessageType {
1059 #[inline]
1060 #[doc(alias = "g_dbus_message_type_get_type")]
1061 fn static_type() -> glib::Type {
1062 unsafe { from_glib(ffi::g_dbus_message_type_get_type()) }
1063 }
1064}
1065
1066impl glib::HasParamSpec for DBusMessageType {
1067 type ParamSpec = glib::ParamSpecEnum;
1068 type SetValue = Self;
1069 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1070
1071 fn param_spec_builder() -> Self::BuilderFn {
1072 Self::ParamSpec::builder_with_default
1073 }
1074}
1075
1076impl glib::value::ValueType for DBusMessageType {
1077 type Type = Self;
1078}
1079
1080unsafe impl<'a> glib::value::FromValue<'a> for DBusMessageType {
1081 type Checker = glib::value::GenericValueTypeChecker<Self>;
1082
1083 #[inline]
1084 unsafe fn from_value(value: &'a glib::Value) -> Self {
1085 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1086 }
1087}
1088
1089impl ToValue for DBusMessageType {
1090 #[inline]
1091 fn to_value(&self) -> glib::Value {
1092 let mut value = glib::Value::for_value_type::<Self>();
1093 unsafe {
1094 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1095 }
1096 value
1097 }
1098
1099 #[inline]
1100 fn value_type(&self) -> glib::Type {
1101 Self::static_type()
1102 }
1103}
1104
1105impl From<DBusMessageType> for glib::Value {
1106 #[inline]
1107 fn from(v: DBusMessageType) -> Self {
1108 ToValue::to_value(&v)
1109 }
1110}
1111
1112#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1115#[non_exhaustive]
1116#[doc(alias = "GDataStreamByteOrder")]
1117pub enum DataStreamByteOrder {
1118 #[doc(alias = "G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN")]
1120 BigEndian,
1121 #[doc(alias = "G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN")]
1123 LittleEndian,
1124 #[doc(alias = "G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN")]
1126 HostEndian,
1127 #[doc(hidden)]
1128 __Unknown(i32),
1129}
1130
1131#[doc(hidden)]
1132impl IntoGlib for DataStreamByteOrder {
1133 type GlibType = ffi::GDataStreamByteOrder;
1134
1135 #[inline]
1136 fn into_glib(self) -> ffi::GDataStreamByteOrder {
1137 match self {
1138 Self::BigEndian => ffi::G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN,
1139 Self::LittleEndian => ffi::G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN,
1140 Self::HostEndian => ffi::G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN,
1141 Self::__Unknown(value) => value,
1142 }
1143 }
1144}
1145
1146#[doc(hidden)]
1147impl FromGlib<ffi::GDataStreamByteOrder> for DataStreamByteOrder {
1148 #[inline]
1149 unsafe fn from_glib(value: ffi::GDataStreamByteOrder) -> Self {
1150 match value {
1151 ffi::G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN => Self::BigEndian,
1152 ffi::G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN => Self::LittleEndian,
1153 ffi::G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN => Self::HostEndian,
1154 value => Self::__Unknown(value),
1155 }
1156 }
1157}
1158
1159impl StaticType for DataStreamByteOrder {
1160 #[inline]
1161 #[doc(alias = "g_data_stream_byte_order_get_type")]
1162 fn static_type() -> glib::Type {
1163 unsafe { from_glib(ffi::g_data_stream_byte_order_get_type()) }
1164 }
1165}
1166
1167impl glib::HasParamSpec for DataStreamByteOrder {
1168 type ParamSpec = glib::ParamSpecEnum;
1169 type SetValue = Self;
1170 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1171
1172 fn param_spec_builder() -> Self::BuilderFn {
1173 Self::ParamSpec::builder_with_default
1174 }
1175}
1176
1177impl glib::value::ValueType for DataStreamByteOrder {
1178 type Type = Self;
1179}
1180
1181unsafe impl<'a> glib::value::FromValue<'a> for DataStreamByteOrder {
1182 type Checker = glib::value::GenericValueTypeChecker<Self>;
1183
1184 #[inline]
1185 unsafe fn from_value(value: &'a glib::Value) -> Self {
1186 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1187 }
1188}
1189
1190impl ToValue for DataStreamByteOrder {
1191 #[inline]
1192 fn to_value(&self) -> glib::Value {
1193 let mut value = glib::Value::for_value_type::<Self>();
1194 unsafe {
1195 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1196 }
1197 value
1198 }
1199
1200 #[inline]
1201 fn value_type(&self) -> glib::Type {
1202 Self::static_type()
1203 }
1204}
1205
1206impl From<DataStreamByteOrder> for glib::Value {
1207 #[inline]
1208 fn from(v: DataStreamByteOrder) -> Self {
1209 ToValue::to_value(&v)
1210 }
1211}
1212
1213#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1215#[non_exhaustive]
1216#[doc(alias = "GDataStreamNewlineType")]
1217pub enum DataStreamNewlineType {
1218 #[doc(alias = "G_DATA_STREAM_NEWLINE_TYPE_LF")]
1220 Lf,
1221 #[doc(alias = "G_DATA_STREAM_NEWLINE_TYPE_CR")]
1223 Cr,
1224 #[doc(alias = "G_DATA_STREAM_NEWLINE_TYPE_CR_LF")]
1226 CrLf,
1227 #[doc(alias = "G_DATA_STREAM_NEWLINE_TYPE_ANY")]
1229 Any,
1230 #[doc(hidden)]
1231 __Unknown(i32),
1232}
1233
1234#[doc(hidden)]
1235impl IntoGlib for DataStreamNewlineType {
1236 type GlibType = ffi::GDataStreamNewlineType;
1237
1238 #[inline]
1239 fn into_glib(self) -> ffi::GDataStreamNewlineType {
1240 match self {
1241 Self::Lf => ffi::G_DATA_STREAM_NEWLINE_TYPE_LF,
1242 Self::Cr => ffi::G_DATA_STREAM_NEWLINE_TYPE_CR,
1243 Self::CrLf => ffi::G_DATA_STREAM_NEWLINE_TYPE_CR_LF,
1244 Self::Any => ffi::G_DATA_STREAM_NEWLINE_TYPE_ANY,
1245 Self::__Unknown(value) => value,
1246 }
1247 }
1248}
1249
1250#[doc(hidden)]
1251impl FromGlib<ffi::GDataStreamNewlineType> for DataStreamNewlineType {
1252 #[inline]
1253 unsafe fn from_glib(value: ffi::GDataStreamNewlineType) -> Self {
1254 match value {
1255 ffi::G_DATA_STREAM_NEWLINE_TYPE_LF => Self::Lf,
1256 ffi::G_DATA_STREAM_NEWLINE_TYPE_CR => Self::Cr,
1257 ffi::G_DATA_STREAM_NEWLINE_TYPE_CR_LF => Self::CrLf,
1258 ffi::G_DATA_STREAM_NEWLINE_TYPE_ANY => Self::Any,
1259 value => Self::__Unknown(value),
1260 }
1261 }
1262}
1263
1264impl StaticType for DataStreamNewlineType {
1265 #[inline]
1266 #[doc(alias = "g_data_stream_newline_type_get_type")]
1267 fn static_type() -> glib::Type {
1268 unsafe { from_glib(ffi::g_data_stream_newline_type_get_type()) }
1269 }
1270}
1271
1272impl glib::HasParamSpec for DataStreamNewlineType {
1273 type ParamSpec = glib::ParamSpecEnum;
1274 type SetValue = Self;
1275 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1276
1277 fn param_spec_builder() -> Self::BuilderFn {
1278 Self::ParamSpec::builder_with_default
1279 }
1280}
1281
1282impl glib::value::ValueType for DataStreamNewlineType {
1283 type Type = Self;
1284}
1285
1286unsafe impl<'a> glib::value::FromValue<'a> for DataStreamNewlineType {
1287 type Checker = glib::value::GenericValueTypeChecker<Self>;
1288
1289 #[inline]
1290 unsafe fn from_value(value: &'a glib::Value) -> Self {
1291 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1292 }
1293}
1294
1295impl ToValue for DataStreamNewlineType {
1296 #[inline]
1297 fn to_value(&self) -> glib::Value {
1298 let mut value = glib::Value::for_value_type::<Self>();
1299 unsafe {
1300 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1301 }
1302 value
1303 }
1304
1305 #[inline]
1306 fn value_type(&self) -> glib::Type {
1307 Self::static_type()
1308 }
1309}
1310
1311impl From<DataStreamNewlineType> for glib::Value {
1312 #[inline]
1313 fn from(v: DataStreamNewlineType) -> Self {
1314 ToValue::to_value(&v)
1315 }
1316}
1317
1318#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1320#[non_exhaustive]
1321#[doc(alias = "GDriveStartStopType")]
1322pub enum DriveStartStopType {
1323 #[doc(alias = "G_DRIVE_START_STOP_TYPE_UNKNOWN")]
1326 Unknown,
1327 #[doc(alias = "G_DRIVE_START_STOP_TYPE_SHUTDOWN")]
1331 Shutdown,
1332 #[doc(alias = "G_DRIVE_START_STOP_TYPE_NETWORK")]
1335 Network,
1336 #[doc(alias = "G_DRIVE_START_STOP_TYPE_MULTIDISK")]
1340 Multidisk,
1341 #[doc(alias = "G_DRIVE_START_STOP_TYPE_PASSWORD")]
1345 Password,
1346 #[doc(hidden)]
1347 __Unknown(i32),
1348}
1349
1350#[doc(hidden)]
1351impl IntoGlib for DriveStartStopType {
1352 type GlibType = ffi::GDriveStartStopType;
1353
1354 #[inline]
1355 fn into_glib(self) -> ffi::GDriveStartStopType {
1356 match self {
1357 Self::Unknown => ffi::G_DRIVE_START_STOP_TYPE_UNKNOWN,
1358 Self::Shutdown => ffi::G_DRIVE_START_STOP_TYPE_SHUTDOWN,
1359 Self::Network => ffi::G_DRIVE_START_STOP_TYPE_NETWORK,
1360 Self::Multidisk => ffi::G_DRIVE_START_STOP_TYPE_MULTIDISK,
1361 Self::Password => ffi::G_DRIVE_START_STOP_TYPE_PASSWORD,
1362 Self::__Unknown(value) => value,
1363 }
1364 }
1365}
1366
1367#[doc(hidden)]
1368impl FromGlib<ffi::GDriveStartStopType> for DriveStartStopType {
1369 #[inline]
1370 unsafe fn from_glib(value: ffi::GDriveStartStopType) -> Self {
1371 match value {
1372 ffi::G_DRIVE_START_STOP_TYPE_UNKNOWN => Self::Unknown,
1373 ffi::G_DRIVE_START_STOP_TYPE_SHUTDOWN => Self::Shutdown,
1374 ffi::G_DRIVE_START_STOP_TYPE_NETWORK => Self::Network,
1375 ffi::G_DRIVE_START_STOP_TYPE_MULTIDISK => Self::Multidisk,
1376 ffi::G_DRIVE_START_STOP_TYPE_PASSWORD => Self::Password,
1377 value => Self::__Unknown(value),
1378 }
1379 }
1380}
1381
1382impl StaticType for DriveStartStopType {
1383 #[inline]
1384 #[doc(alias = "g_drive_start_stop_type_get_type")]
1385 fn static_type() -> glib::Type {
1386 unsafe { from_glib(ffi::g_drive_start_stop_type_get_type()) }
1387 }
1388}
1389
1390impl glib::HasParamSpec for DriveStartStopType {
1391 type ParamSpec = glib::ParamSpecEnum;
1392 type SetValue = Self;
1393 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1394
1395 fn param_spec_builder() -> Self::BuilderFn {
1396 Self::ParamSpec::builder_with_default
1397 }
1398}
1399
1400impl glib::value::ValueType for DriveStartStopType {
1401 type Type = Self;
1402}
1403
1404unsafe impl<'a> glib::value::FromValue<'a> for DriveStartStopType {
1405 type Checker = glib::value::GenericValueTypeChecker<Self>;
1406
1407 #[inline]
1408 unsafe fn from_value(value: &'a glib::Value) -> Self {
1409 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1410 }
1411}
1412
1413impl ToValue for DriveStartStopType {
1414 #[inline]
1415 fn to_value(&self) -> glib::Value {
1416 let mut value = glib::Value::for_value_type::<Self>();
1417 unsafe {
1418 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1419 }
1420 value
1421 }
1422
1423 #[inline]
1424 fn value_type(&self) -> glib::Type {
1425 Self::static_type()
1426 }
1427}
1428
1429impl From<DriveStartStopType> for glib::Value {
1430 #[inline]
1431 fn from(v: DriveStartStopType) -> Self {
1432 ToValue::to_value(&v)
1433 }
1434}
1435
1436#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1439#[non_exhaustive]
1440#[doc(alias = "GEmblemOrigin")]
1441pub enum EmblemOrigin {
1442 #[doc(alias = "G_EMBLEM_ORIGIN_UNKNOWN")]
1444 Unknown,
1445 #[doc(alias = "G_EMBLEM_ORIGIN_DEVICE")]
1447 Device,
1448 #[doc(alias = "G_EMBLEM_ORIGIN_LIVEMETADATA")]
1450 Livemetadata,
1451 #[doc(alias = "G_EMBLEM_ORIGIN_TAG")]
1453 Tag,
1454 #[doc(hidden)]
1455 __Unknown(i32),
1456}
1457
1458#[doc(hidden)]
1459impl IntoGlib for EmblemOrigin {
1460 type GlibType = ffi::GEmblemOrigin;
1461
1462 #[inline]
1463 fn into_glib(self) -> ffi::GEmblemOrigin {
1464 match self {
1465 Self::Unknown => ffi::G_EMBLEM_ORIGIN_UNKNOWN,
1466 Self::Device => ffi::G_EMBLEM_ORIGIN_DEVICE,
1467 Self::Livemetadata => ffi::G_EMBLEM_ORIGIN_LIVEMETADATA,
1468 Self::Tag => ffi::G_EMBLEM_ORIGIN_TAG,
1469 Self::__Unknown(value) => value,
1470 }
1471 }
1472}
1473
1474#[doc(hidden)]
1475impl FromGlib<ffi::GEmblemOrigin> for EmblemOrigin {
1476 #[inline]
1477 unsafe fn from_glib(value: ffi::GEmblemOrigin) -> Self {
1478 match value {
1479 ffi::G_EMBLEM_ORIGIN_UNKNOWN => Self::Unknown,
1480 ffi::G_EMBLEM_ORIGIN_DEVICE => Self::Device,
1481 ffi::G_EMBLEM_ORIGIN_LIVEMETADATA => Self::Livemetadata,
1482 ffi::G_EMBLEM_ORIGIN_TAG => Self::Tag,
1483 value => Self::__Unknown(value),
1484 }
1485 }
1486}
1487
1488impl StaticType for EmblemOrigin {
1489 #[inline]
1490 #[doc(alias = "g_emblem_origin_get_type")]
1491 fn static_type() -> glib::Type {
1492 unsafe { from_glib(ffi::g_emblem_origin_get_type()) }
1493 }
1494}
1495
1496impl glib::HasParamSpec for EmblemOrigin {
1497 type ParamSpec = glib::ParamSpecEnum;
1498 type SetValue = Self;
1499 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1500
1501 fn param_spec_builder() -> Self::BuilderFn {
1502 Self::ParamSpec::builder_with_default
1503 }
1504}
1505
1506impl glib::value::ValueType for EmblemOrigin {
1507 type Type = Self;
1508}
1509
1510unsafe impl<'a> glib::value::FromValue<'a> for EmblemOrigin {
1511 type Checker = glib::value::GenericValueTypeChecker<Self>;
1512
1513 #[inline]
1514 unsafe fn from_value(value: &'a glib::Value) -> Self {
1515 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1516 }
1517}
1518
1519impl ToValue for EmblemOrigin {
1520 #[inline]
1521 fn to_value(&self) -> glib::Value {
1522 let mut value = glib::Value::for_value_type::<Self>();
1523 unsafe {
1524 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1525 }
1526 value
1527 }
1528
1529 #[inline]
1530 fn value_type(&self) -> glib::Type {
1531 Self::static_type()
1532 }
1533}
1534
1535impl From<EmblemOrigin> for glib::Value {
1536 #[inline]
1537 fn from(v: EmblemOrigin) -> Self {
1538 ToValue::to_value(&v)
1539 }
1540}
1541
1542#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1544#[non_exhaustive]
1545#[doc(alias = "GFileAttributeStatus")]
1546pub enum FileAttributeStatus {
1547 #[doc(alias = "G_FILE_ATTRIBUTE_STATUS_UNSET")]
1549 Unset,
1550 #[doc(alias = "G_FILE_ATTRIBUTE_STATUS_SET")]
1552 Set,
1553 #[doc(alias = "G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING")]
1555 ErrorSetting,
1556 #[doc(hidden)]
1557 __Unknown(i32),
1558}
1559
1560#[doc(hidden)]
1561impl IntoGlib for FileAttributeStatus {
1562 type GlibType = ffi::GFileAttributeStatus;
1563
1564 #[inline]
1565 fn into_glib(self) -> ffi::GFileAttributeStatus {
1566 match self {
1567 Self::Unset => ffi::G_FILE_ATTRIBUTE_STATUS_UNSET,
1568 Self::Set => ffi::G_FILE_ATTRIBUTE_STATUS_SET,
1569 Self::ErrorSetting => ffi::G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING,
1570 Self::__Unknown(value) => value,
1571 }
1572 }
1573}
1574
1575#[doc(hidden)]
1576impl FromGlib<ffi::GFileAttributeStatus> for FileAttributeStatus {
1577 #[inline]
1578 unsafe fn from_glib(value: ffi::GFileAttributeStatus) -> Self {
1579 match value {
1580 ffi::G_FILE_ATTRIBUTE_STATUS_UNSET => Self::Unset,
1581 ffi::G_FILE_ATTRIBUTE_STATUS_SET => Self::Set,
1582 ffi::G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING => Self::ErrorSetting,
1583 value => Self::__Unknown(value),
1584 }
1585 }
1586}
1587
1588impl StaticType for FileAttributeStatus {
1589 #[inline]
1590 #[doc(alias = "g_file_attribute_status_get_type")]
1591 fn static_type() -> glib::Type {
1592 unsafe { from_glib(ffi::g_file_attribute_status_get_type()) }
1593 }
1594}
1595
1596impl glib::HasParamSpec for FileAttributeStatus {
1597 type ParamSpec = glib::ParamSpecEnum;
1598 type SetValue = Self;
1599 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1600
1601 fn param_spec_builder() -> Self::BuilderFn {
1602 Self::ParamSpec::builder_with_default
1603 }
1604}
1605
1606impl glib::value::ValueType for FileAttributeStatus {
1607 type Type = Self;
1608}
1609
1610unsafe impl<'a> glib::value::FromValue<'a> for FileAttributeStatus {
1611 type Checker = glib::value::GenericValueTypeChecker<Self>;
1612
1613 #[inline]
1614 unsafe fn from_value(value: &'a glib::Value) -> Self {
1615 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1616 }
1617}
1618
1619impl ToValue for FileAttributeStatus {
1620 #[inline]
1621 fn to_value(&self) -> glib::Value {
1622 let mut value = glib::Value::for_value_type::<Self>();
1623 unsafe {
1624 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1625 }
1626 value
1627 }
1628
1629 #[inline]
1630 fn value_type(&self) -> glib::Type {
1631 Self::static_type()
1632 }
1633}
1634
1635impl From<FileAttributeStatus> for glib::Value {
1636 #[inline]
1637 fn from(v: FileAttributeStatus) -> Self {
1638 ToValue::to_value(&v)
1639 }
1640}
1641
1642#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1644#[non_exhaustive]
1645#[doc(alias = "GFileAttributeType")]
1646pub enum FileAttributeType {
1647 #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_INVALID")]
1649 Invalid,
1650 #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_STRING")]
1652 String,
1653 #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_BYTE_STRING")]
1655 ByteString,
1656 #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_BOOLEAN")]
1658 Boolean,
1659 #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_UINT32")]
1661 Uint32,
1662 #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_INT32")]
1664 Int32,
1665 #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_UINT64")]
1667 Uint64,
1668 #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_INT64")]
1670 Int64,
1671 #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_OBJECT")]
1673 Object,
1674 #[doc(alias = "G_FILE_ATTRIBUTE_TYPE_STRINGV")]
1676 Stringv,
1677 #[doc(hidden)]
1678 __Unknown(i32),
1679}
1680
1681#[doc(hidden)]
1682impl IntoGlib for FileAttributeType {
1683 type GlibType = ffi::GFileAttributeType;
1684
1685 #[inline]
1686 fn into_glib(self) -> ffi::GFileAttributeType {
1687 match self {
1688 Self::Invalid => ffi::G_FILE_ATTRIBUTE_TYPE_INVALID,
1689 Self::String => ffi::G_FILE_ATTRIBUTE_TYPE_STRING,
1690 Self::ByteString => ffi::G_FILE_ATTRIBUTE_TYPE_BYTE_STRING,
1691 Self::Boolean => ffi::G_FILE_ATTRIBUTE_TYPE_BOOLEAN,
1692 Self::Uint32 => ffi::G_FILE_ATTRIBUTE_TYPE_UINT32,
1693 Self::Int32 => ffi::G_FILE_ATTRIBUTE_TYPE_INT32,
1694 Self::Uint64 => ffi::G_FILE_ATTRIBUTE_TYPE_UINT64,
1695 Self::Int64 => ffi::G_FILE_ATTRIBUTE_TYPE_INT64,
1696 Self::Object => ffi::G_FILE_ATTRIBUTE_TYPE_OBJECT,
1697 Self::Stringv => ffi::G_FILE_ATTRIBUTE_TYPE_STRINGV,
1698 Self::__Unknown(value) => value,
1699 }
1700 }
1701}
1702
1703#[doc(hidden)]
1704impl FromGlib<ffi::GFileAttributeType> for FileAttributeType {
1705 #[inline]
1706 unsafe fn from_glib(value: ffi::GFileAttributeType) -> Self {
1707 match value {
1708 ffi::G_FILE_ATTRIBUTE_TYPE_INVALID => Self::Invalid,
1709 ffi::G_FILE_ATTRIBUTE_TYPE_STRING => Self::String,
1710 ffi::G_FILE_ATTRIBUTE_TYPE_BYTE_STRING => Self::ByteString,
1711 ffi::G_FILE_ATTRIBUTE_TYPE_BOOLEAN => Self::Boolean,
1712 ffi::G_FILE_ATTRIBUTE_TYPE_UINT32 => Self::Uint32,
1713 ffi::G_FILE_ATTRIBUTE_TYPE_INT32 => Self::Int32,
1714 ffi::G_FILE_ATTRIBUTE_TYPE_UINT64 => Self::Uint64,
1715 ffi::G_FILE_ATTRIBUTE_TYPE_INT64 => Self::Int64,
1716 ffi::G_FILE_ATTRIBUTE_TYPE_OBJECT => Self::Object,
1717 ffi::G_FILE_ATTRIBUTE_TYPE_STRINGV => Self::Stringv,
1718 value => Self::__Unknown(value),
1719 }
1720 }
1721}
1722
1723impl StaticType for FileAttributeType {
1724 #[inline]
1725 #[doc(alias = "g_file_attribute_type_get_type")]
1726 fn static_type() -> glib::Type {
1727 unsafe { from_glib(ffi::g_file_attribute_type_get_type()) }
1728 }
1729}
1730
1731impl glib::HasParamSpec for FileAttributeType {
1732 type ParamSpec = glib::ParamSpecEnum;
1733 type SetValue = Self;
1734 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1735
1736 fn param_spec_builder() -> Self::BuilderFn {
1737 Self::ParamSpec::builder_with_default
1738 }
1739}
1740
1741impl glib::value::ValueType for FileAttributeType {
1742 type Type = Self;
1743}
1744
1745unsafe impl<'a> glib::value::FromValue<'a> for FileAttributeType {
1746 type Checker = glib::value::GenericValueTypeChecker<Self>;
1747
1748 #[inline]
1749 unsafe fn from_value(value: &'a glib::Value) -> Self {
1750 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1751 }
1752}
1753
1754impl ToValue for FileAttributeType {
1755 #[inline]
1756 fn to_value(&self) -> glib::Value {
1757 let mut value = glib::Value::for_value_type::<Self>();
1758 unsafe {
1759 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1760 }
1761 value
1762 }
1763
1764 #[inline]
1765 fn value_type(&self) -> glib::Type {
1766 Self::static_type()
1767 }
1768}
1769
1770impl From<FileAttributeType> for glib::Value {
1771 #[inline]
1772 fn from(v: FileAttributeType) -> Self {
1773 ToValue::to_value(&v)
1774 }
1775}
1776
1777#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1779#[non_exhaustive]
1780#[doc(alias = "GFileMonitorEvent")]
1781pub enum FileMonitorEvent {
1782 #[doc(alias = "G_FILE_MONITOR_EVENT_CHANGED")]
1784 Changed,
1785 #[doc(alias = "G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT")]
1787 ChangesDoneHint,
1788 #[doc(alias = "G_FILE_MONITOR_EVENT_DELETED")]
1790 Deleted,
1791 #[doc(alias = "G_FILE_MONITOR_EVENT_CREATED")]
1793 Created,
1794 #[doc(alias = "G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED")]
1796 AttributeChanged,
1797 #[doc(alias = "G_FILE_MONITOR_EVENT_PRE_UNMOUNT")]
1799 PreUnmount,
1800 #[doc(alias = "G_FILE_MONITOR_EVENT_UNMOUNTED")]
1802 Unmounted,
1803 #[doc(alias = "G_FILE_MONITOR_EVENT_MOVED")]
1806 Moved,
1807 #[doc(alias = "G_FILE_MONITOR_EVENT_RENAMED")]
1811 Renamed,
1812 #[doc(alias = "G_FILE_MONITOR_EVENT_MOVED_IN")]
1816 MovedIn,
1817 #[doc(alias = "G_FILE_MONITOR_EVENT_MOVED_OUT")]
1821 MovedOut,
1822 #[doc(hidden)]
1823 __Unknown(i32),
1824}
1825
1826#[doc(hidden)]
1827impl IntoGlib for FileMonitorEvent {
1828 type GlibType = ffi::GFileMonitorEvent;
1829
1830 #[inline]
1831 fn into_glib(self) -> ffi::GFileMonitorEvent {
1832 match self {
1833 Self::Changed => ffi::G_FILE_MONITOR_EVENT_CHANGED,
1834 Self::ChangesDoneHint => ffi::G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT,
1835 Self::Deleted => ffi::G_FILE_MONITOR_EVENT_DELETED,
1836 Self::Created => ffi::G_FILE_MONITOR_EVENT_CREATED,
1837 Self::AttributeChanged => ffi::G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED,
1838 Self::PreUnmount => ffi::G_FILE_MONITOR_EVENT_PRE_UNMOUNT,
1839 Self::Unmounted => ffi::G_FILE_MONITOR_EVENT_UNMOUNTED,
1840 Self::Moved => ffi::G_FILE_MONITOR_EVENT_MOVED,
1841 Self::Renamed => ffi::G_FILE_MONITOR_EVENT_RENAMED,
1842 Self::MovedIn => ffi::G_FILE_MONITOR_EVENT_MOVED_IN,
1843 Self::MovedOut => ffi::G_FILE_MONITOR_EVENT_MOVED_OUT,
1844 Self::__Unknown(value) => value,
1845 }
1846 }
1847}
1848
1849#[doc(hidden)]
1850impl FromGlib<ffi::GFileMonitorEvent> for FileMonitorEvent {
1851 #[inline]
1852 unsafe fn from_glib(value: ffi::GFileMonitorEvent) -> Self {
1853 match value {
1854 ffi::G_FILE_MONITOR_EVENT_CHANGED => Self::Changed,
1855 ffi::G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT => Self::ChangesDoneHint,
1856 ffi::G_FILE_MONITOR_EVENT_DELETED => Self::Deleted,
1857 ffi::G_FILE_MONITOR_EVENT_CREATED => Self::Created,
1858 ffi::G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED => Self::AttributeChanged,
1859 ffi::G_FILE_MONITOR_EVENT_PRE_UNMOUNT => Self::PreUnmount,
1860 ffi::G_FILE_MONITOR_EVENT_UNMOUNTED => Self::Unmounted,
1861 ffi::G_FILE_MONITOR_EVENT_MOVED => Self::Moved,
1862 ffi::G_FILE_MONITOR_EVENT_RENAMED => Self::Renamed,
1863 ffi::G_FILE_MONITOR_EVENT_MOVED_IN => Self::MovedIn,
1864 ffi::G_FILE_MONITOR_EVENT_MOVED_OUT => Self::MovedOut,
1865 value => Self::__Unknown(value),
1866 }
1867 }
1868}
1869
1870impl StaticType for FileMonitorEvent {
1871 #[inline]
1872 #[doc(alias = "g_file_monitor_event_get_type")]
1873 fn static_type() -> glib::Type {
1874 unsafe { from_glib(ffi::g_file_monitor_event_get_type()) }
1875 }
1876}
1877
1878impl glib::HasParamSpec for FileMonitorEvent {
1879 type ParamSpec = glib::ParamSpecEnum;
1880 type SetValue = Self;
1881 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
1882
1883 fn param_spec_builder() -> Self::BuilderFn {
1884 Self::ParamSpec::builder_with_default
1885 }
1886}
1887
1888impl glib::value::ValueType for FileMonitorEvent {
1889 type Type = Self;
1890}
1891
1892unsafe impl<'a> glib::value::FromValue<'a> for FileMonitorEvent {
1893 type Checker = glib::value::GenericValueTypeChecker<Self>;
1894
1895 #[inline]
1896 unsafe fn from_value(value: &'a glib::Value) -> Self {
1897 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
1898 }
1899}
1900
1901impl ToValue for FileMonitorEvent {
1902 #[inline]
1903 fn to_value(&self) -> glib::Value {
1904 let mut value = glib::Value::for_value_type::<Self>();
1905 unsafe {
1906 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
1907 }
1908 value
1909 }
1910
1911 #[inline]
1912 fn value_type(&self) -> glib::Type {
1913 Self::static_type()
1914 }
1915}
1916
1917impl From<FileMonitorEvent> for glib::Value {
1918 #[inline]
1919 fn from(v: FileMonitorEvent) -> Self {
1920 ToValue::to_value(&v)
1921 }
1922}
1923
1924#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1935#[non_exhaustive]
1936#[doc(alias = "GFileType")]
1937pub enum FileType {
1938 #[doc(alias = "G_FILE_TYPE_UNKNOWN")]
1940 Unknown,
1941 #[doc(alias = "G_FILE_TYPE_REGULAR")]
1943 Regular,
1944 #[doc(alias = "G_FILE_TYPE_DIRECTORY")]
1946 Directory,
1947 #[doc(alias = "G_FILE_TYPE_SYMBOLIC_LINK")]
1950 SymbolicLink,
1951 #[doc(alias = "G_FILE_TYPE_SPECIAL")]
1954 Special,
1955 #[doc(alias = "G_FILE_TYPE_SHORTCUT")]
1957 Shortcut,
1958 #[doc(alias = "G_FILE_TYPE_MOUNTABLE")]
1960 Mountable,
1961 #[doc(hidden)]
1962 __Unknown(i32),
1963}
1964
1965#[doc(hidden)]
1966impl IntoGlib for FileType {
1967 type GlibType = ffi::GFileType;
1968
1969 #[inline]
1970 fn into_glib(self) -> ffi::GFileType {
1971 match self {
1972 Self::Unknown => ffi::G_FILE_TYPE_UNKNOWN,
1973 Self::Regular => ffi::G_FILE_TYPE_REGULAR,
1974 Self::Directory => ffi::G_FILE_TYPE_DIRECTORY,
1975 Self::SymbolicLink => ffi::G_FILE_TYPE_SYMBOLIC_LINK,
1976 Self::Special => ffi::G_FILE_TYPE_SPECIAL,
1977 Self::Shortcut => ffi::G_FILE_TYPE_SHORTCUT,
1978 Self::Mountable => ffi::G_FILE_TYPE_MOUNTABLE,
1979 Self::__Unknown(value) => value,
1980 }
1981 }
1982}
1983
1984#[doc(hidden)]
1985impl FromGlib<ffi::GFileType> for FileType {
1986 #[inline]
1987 unsafe fn from_glib(value: ffi::GFileType) -> Self {
1988 match value {
1989 ffi::G_FILE_TYPE_UNKNOWN => Self::Unknown,
1990 ffi::G_FILE_TYPE_REGULAR => Self::Regular,
1991 ffi::G_FILE_TYPE_DIRECTORY => Self::Directory,
1992 ffi::G_FILE_TYPE_SYMBOLIC_LINK => Self::SymbolicLink,
1993 ffi::G_FILE_TYPE_SPECIAL => Self::Special,
1994 ffi::G_FILE_TYPE_SHORTCUT => Self::Shortcut,
1995 ffi::G_FILE_TYPE_MOUNTABLE => Self::Mountable,
1996 value => Self::__Unknown(value),
1997 }
1998 }
1999}
2000
2001impl StaticType for FileType {
2002 #[inline]
2003 #[doc(alias = "g_file_type_get_type")]
2004 fn static_type() -> glib::Type {
2005 unsafe { from_glib(ffi::g_file_type_get_type()) }
2006 }
2007}
2008
2009impl glib::HasParamSpec for FileType {
2010 type ParamSpec = glib::ParamSpecEnum;
2011 type SetValue = Self;
2012 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2013
2014 fn param_spec_builder() -> Self::BuilderFn {
2015 Self::ParamSpec::builder_with_default
2016 }
2017}
2018
2019impl glib::value::ValueType for FileType {
2020 type Type = Self;
2021}
2022
2023unsafe impl<'a> glib::value::FromValue<'a> for FileType {
2024 type Checker = glib::value::GenericValueTypeChecker<Self>;
2025
2026 #[inline]
2027 unsafe fn from_value(value: &'a glib::Value) -> Self {
2028 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2029 }
2030}
2031
2032impl ToValue for FileType {
2033 #[inline]
2034 fn to_value(&self) -> glib::Value {
2035 let mut value = glib::Value::for_value_type::<Self>();
2036 unsafe {
2037 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2038 }
2039 value
2040 }
2041
2042 #[inline]
2043 fn value_type(&self) -> glib::Type {
2044 Self::static_type()
2045 }
2046}
2047
2048impl From<FileType> for glib::Value {
2049 #[inline]
2050 fn from(v: FileType) -> Self {
2051 ToValue::to_value(&v)
2052 }
2053}
2054
2055#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2059#[non_exhaustive]
2060#[doc(alias = "GFilesystemPreviewType")]
2061pub enum FilesystemPreviewType {
2062 #[doc(alias = "G_FILESYSTEM_PREVIEW_TYPE_IF_ALWAYS")]
2064 IfAlways,
2065 #[doc(alias = "G_FILESYSTEM_PREVIEW_TYPE_IF_LOCAL")]
2067 IfLocal,
2068 #[doc(alias = "G_FILESYSTEM_PREVIEW_TYPE_NEVER")]
2070 Never,
2071 #[doc(hidden)]
2072 __Unknown(i32),
2073}
2074
2075#[doc(hidden)]
2076impl IntoGlib for FilesystemPreviewType {
2077 type GlibType = ffi::GFilesystemPreviewType;
2078
2079 #[inline]
2080 fn into_glib(self) -> ffi::GFilesystemPreviewType {
2081 match self {
2082 Self::IfAlways => ffi::G_FILESYSTEM_PREVIEW_TYPE_IF_ALWAYS,
2083 Self::IfLocal => ffi::G_FILESYSTEM_PREVIEW_TYPE_IF_LOCAL,
2084 Self::Never => ffi::G_FILESYSTEM_PREVIEW_TYPE_NEVER,
2085 Self::__Unknown(value) => value,
2086 }
2087 }
2088}
2089
2090#[doc(hidden)]
2091impl FromGlib<ffi::GFilesystemPreviewType> for FilesystemPreviewType {
2092 #[inline]
2093 unsafe fn from_glib(value: ffi::GFilesystemPreviewType) -> Self {
2094 match value {
2095 ffi::G_FILESYSTEM_PREVIEW_TYPE_IF_ALWAYS => Self::IfAlways,
2096 ffi::G_FILESYSTEM_PREVIEW_TYPE_IF_LOCAL => Self::IfLocal,
2097 ffi::G_FILESYSTEM_PREVIEW_TYPE_NEVER => Self::Never,
2098 value => Self::__Unknown(value),
2099 }
2100 }
2101}
2102
2103impl StaticType for FilesystemPreviewType {
2104 #[inline]
2105 #[doc(alias = "g_filesystem_preview_type_get_type")]
2106 fn static_type() -> glib::Type {
2107 unsafe { from_glib(ffi::g_filesystem_preview_type_get_type()) }
2108 }
2109}
2110
2111impl glib::HasParamSpec for FilesystemPreviewType {
2112 type ParamSpec = glib::ParamSpecEnum;
2113 type SetValue = Self;
2114 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2115
2116 fn param_spec_builder() -> Self::BuilderFn {
2117 Self::ParamSpec::builder_with_default
2118 }
2119}
2120
2121impl glib::value::ValueType for FilesystemPreviewType {
2122 type Type = Self;
2123}
2124
2125unsafe impl<'a> glib::value::FromValue<'a> for FilesystemPreviewType {
2126 type Checker = glib::value::GenericValueTypeChecker<Self>;
2127
2128 #[inline]
2129 unsafe fn from_value(value: &'a glib::Value) -> Self {
2130 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2131 }
2132}
2133
2134impl ToValue for FilesystemPreviewType {
2135 #[inline]
2136 fn to_value(&self) -> glib::Value {
2137 let mut value = glib::Value::for_value_type::<Self>();
2138 unsafe {
2139 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2140 }
2141 value
2142 }
2143
2144 #[inline]
2145 fn value_type(&self) -> glib::Type {
2146 Self::static_type()
2147 }
2148}
2149
2150impl From<FilesystemPreviewType> for glib::Value {
2151 #[inline]
2152 fn from(v: FilesystemPreviewType) -> Self {
2153 ToValue::to_value(&v)
2154 }
2155}
2156
2157#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2180#[non_exhaustive]
2181#[doc(alias = "GIOErrorEnum")]
2182pub enum IOErrorEnum {
2183 #[doc(alias = "G_IO_ERROR_FAILED")]
2186 Failed,
2187 #[doc(alias = "G_IO_ERROR_NOT_FOUND")]
2189 NotFound,
2190 #[doc(alias = "G_IO_ERROR_EXISTS")]
2192 Exists,
2193 #[doc(alias = "G_IO_ERROR_IS_DIRECTORY")]
2195 IsDirectory,
2196 #[doc(alias = "G_IO_ERROR_NOT_DIRECTORY")]
2198 NotDirectory,
2199 #[doc(alias = "G_IO_ERROR_NOT_EMPTY")]
2201 NotEmpty,
2202 #[doc(alias = "G_IO_ERROR_NOT_REGULAR_FILE")]
2204 NotRegularFile,
2205 #[doc(alias = "G_IO_ERROR_NOT_SYMBOLIC_LINK")]
2207 NotSymbolicLink,
2208 #[doc(alias = "G_IO_ERROR_NOT_MOUNTABLE_FILE")]
2210 NotMountableFile,
2211 #[doc(alias = "G_IO_ERROR_FILENAME_TOO_LONG")]
2213 FilenameTooLong,
2214 #[doc(alias = "G_IO_ERROR_INVALID_FILENAME")]
2216 InvalidFilename,
2217 #[doc(alias = "G_IO_ERROR_TOO_MANY_LINKS")]
2219 TooManyLinks,
2220 #[doc(alias = "G_IO_ERROR_NO_SPACE")]
2222 NoSpace,
2223 #[doc(alias = "G_IO_ERROR_INVALID_ARGUMENT")]
2225 InvalidArgument,
2226 #[doc(alias = "G_IO_ERROR_PERMISSION_DENIED")]
2228 PermissionDenied,
2229 #[doc(alias = "G_IO_ERROR_NOT_SUPPORTED")]
2231 NotSupported,
2232 #[doc(alias = "G_IO_ERROR_NOT_MOUNTED")]
2234 NotMounted,
2235 #[doc(alias = "G_IO_ERROR_ALREADY_MOUNTED")]
2237 AlreadyMounted,
2238 #[doc(alias = "G_IO_ERROR_CLOSED")]
2240 Closed,
2241 #[doc(alias = "G_IO_ERROR_CANCELLED")]
2243 Cancelled,
2244 #[doc(alias = "G_IO_ERROR_PENDING")]
2246 Pending,
2247 #[doc(alias = "G_IO_ERROR_READ_ONLY")]
2249 ReadOnly,
2250 #[doc(alias = "G_IO_ERROR_CANT_CREATE_BACKUP")]
2252 CantCreateBackup,
2253 #[doc(alias = "G_IO_ERROR_WRONG_ETAG")]
2255 WrongEtag,
2256 #[doc(alias = "G_IO_ERROR_TIMED_OUT")]
2258 TimedOut,
2259 #[doc(alias = "G_IO_ERROR_WOULD_RECURSE")]
2261 WouldRecurse,
2262 #[doc(alias = "G_IO_ERROR_BUSY")]
2264 Busy,
2265 #[doc(alias = "G_IO_ERROR_WOULD_BLOCK")]
2267 WouldBlock,
2268 #[doc(alias = "G_IO_ERROR_HOST_NOT_FOUND")]
2270 HostNotFound,
2271 #[doc(alias = "G_IO_ERROR_WOULD_MERGE")]
2273 WouldMerge,
2274 #[doc(alias = "G_IO_ERROR_FAILED_HANDLED")]
2277 FailedHandled,
2278 #[doc(alias = "G_IO_ERROR_TOO_MANY_OPEN_FILES")]
2282 TooManyOpenFiles,
2283 #[doc(alias = "G_IO_ERROR_NOT_INITIALIZED")]
2285 NotInitialized,
2286 #[doc(alias = "G_IO_ERROR_ADDRESS_IN_USE")]
2288 AddressInUse,
2289 #[doc(alias = "G_IO_ERROR_PARTIAL_INPUT")]
2291 PartialInput,
2292 #[doc(alias = "G_IO_ERROR_INVALID_DATA")]
2294 InvalidData,
2295 #[doc(alias = "G_IO_ERROR_DBUS_ERROR")]
2301 DbusError,
2302 #[doc(alias = "G_IO_ERROR_HOST_UNREACHABLE")]
2304 HostUnreachable,
2305 #[doc(alias = "G_IO_ERROR_NETWORK_UNREACHABLE")]
2307 NetworkUnreachable,
2308 #[doc(alias = "G_IO_ERROR_CONNECTION_REFUSED")]
2310 ConnectionRefused,
2311 #[doc(alias = "G_IO_ERROR_PROXY_FAILED")]
2313 ProxyFailed,
2314 #[doc(alias = "G_IO_ERROR_PROXY_AUTH_FAILED")]
2316 ProxyAuthFailed,
2317 #[doc(alias = "G_IO_ERROR_PROXY_NEED_AUTH")]
2319 ProxyNeedAuth,
2320 #[doc(alias = "G_IO_ERROR_PROXY_NOT_ALLOWED")]
2323 ProxyNotAllowed,
2324 #[doc(alias = "G_IO_ERROR_BROKEN_PIPE")]
2326 BrokenPipe,
2327 #[doc(alias = "G_IO_ERROR_NOT_CONNECTED")]
2329 NotConnected,
2330 #[doc(alias = "G_IO_ERROR_MESSAGE_TOO_LARGE")]
2332 MessageTooLarge,
2333 #[cfg(feature = "v2_72")]
2335 #[cfg_attr(docsrs, doc(cfg(feature = "v2_72")))]
2336 #[doc(alias = "G_IO_ERROR_NO_SUCH_DEVICE")]
2337 NoSuchDevice,
2338 #[cfg(feature = "v2_80")]
2340 #[cfg_attr(docsrs, doc(cfg(feature = "v2_80")))]
2341 #[doc(alias = "G_IO_ERROR_DESTINATION_UNSET")]
2342 DestinationUnset,
2343 #[doc(hidden)]
2344 __Unknown(i32),
2345}
2346
2347#[doc(hidden)]
2348impl IntoGlib for IOErrorEnum {
2349 type GlibType = ffi::GIOErrorEnum;
2350
2351 fn into_glib(self) -> ffi::GIOErrorEnum {
2352 match self {
2353 Self::Failed => ffi::G_IO_ERROR_FAILED,
2354 Self::NotFound => ffi::G_IO_ERROR_NOT_FOUND,
2355 Self::Exists => ffi::G_IO_ERROR_EXISTS,
2356 Self::IsDirectory => ffi::G_IO_ERROR_IS_DIRECTORY,
2357 Self::NotDirectory => ffi::G_IO_ERROR_NOT_DIRECTORY,
2358 Self::NotEmpty => ffi::G_IO_ERROR_NOT_EMPTY,
2359 Self::NotRegularFile => ffi::G_IO_ERROR_NOT_REGULAR_FILE,
2360 Self::NotSymbolicLink => ffi::G_IO_ERROR_NOT_SYMBOLIC_LINK,
2361 Self::NotMountableFile => ffi::G_IO_ERROR_NOT_MOUNTABLE_FILE,
2362 Self::FilenameTooLong => ffi::G_IO_ERROR_FILENAME_TOO_LONG,
2363 Self::InvalidFilename => ffi::G_IO_ERROR_INVALID_FILENAME,
2364 Self::TooManyLinks => ffi::G_IO_ERROR_TOO_MANY_LINKS,
2365 Self::NoSpace => ffi::G_IO_ERROR_NO_SPACE,
2366 Self::InvalidArgument => ffi::G_IO_ERROR_INVALID_ARGUMENT,
2367 Self::PermissionDenied => ffi::G_IO_ERROR_PERMISSION_DENIED,
2368 Self::NotSupported => ffi::G_IO_ERROR_NOT_SUPPORTED,
2369 Self::NotMounted => ffi::G_IO_ERROR_NOT_MOUNTED,
2370 Self::AlreadyMounted => ffi::G_IO_ERROR_ALREADY_MOUNTED,
2371 Self::Closed => ffi::G_IO_ERROR_CLOSED,
2372 Self::Cancelled => ffi::G_IO_ERROR_CANCELLED,
2373 Self::Pending => ffi::G_IO_ERROR_PENDING,
2374 Self::ReadOnly => ffi::G_IO_ERROR_READ_ONLY,
2375 Self::CantCreateBackup => ffi::G_IO_ERROR_CANT_CREATE_BACKUP,
2376 Self::WrongEtag => ffi::G_IO_ERROR_WRONG_ETAG,
2377 Self::TimedOut => ffi::G_IO_ERROR_TIMED_OUT,
2378 Self::WouldRecurse => ffi::G_IO_ERROR_WOULD_RECURSE,
2379 Self::Busy => ffi::G_IO_ERROR_BUSY,
2380 Self::WouldBlock => ffi::G_IO_ERROR_WOULD_BLOCK,
2381 Self::HostNotFound => ffi::G_IO_ERROR_HOST_NOT_FOUND,
2382 Self::WouldMerge => ffi::G_IO_ERROR_WOULD_MERGE,
2383 Self::FailedHandled => ffi::G_IO_ERROR_FAILED_HANDLED,
2384 Self::TooManyOpenFiles => ffi::G_IO_ERROR_TOO_MANY_OPEN_FILES,
2385 Self::NotInitialized => ffi::G_IO_ERROR_NOT_INITIALIZED,
2386 Self::AddressInUse => ffi::G_IO_ERROR_ADDRESS_IN_USE,
2387 Self::PartialInput => ffi::G_IO_ERROR_PARTIAL_INPUT,
2388 Self::InvalidData => ffi::G_IO_ERROR_INVALID_DATA,
2389 Self::DbusError => ffi::G_IO_ERROR_DBUS_ERROR,
2390 Self::HostUnreachable => ffi::G_IO_ERROR_HOST_UNREACHABLE,
2391 Self::NetworkUnreachable => ffi::G_IO_ERROR_NETWORK_UNREACHABLE,
2392 Self::ConnectionRefused => ffi::G_IO_ERROR_CONNECTION_REFUSED,
2393 Self::ProxyFailed => ffi::G_IO_ERROR_PROXY_FAILED,
2394 Self::ProxyAuthFailed => ffi::G_IO_ERROR_PROXY_AUTH_FAILED,
2395 Self::ProxyNeedAuth => ffi::G_IO_ERROR_PROXY_NEED_AUTH,
2396 Self::ProxyNotAllowed => ffi::G_IO_ERROR_PROXY_NOT_ALLOWED,
2397 Self::BrokenPipe => ffi::G_IO_ERROR_BROKEN_PIPE,
2398 Self::NotConnected => ffi::G_IO_ERROR_NOT_CONNECTED,
2399 Self::MessageTooLarge => ffi::G_IO_ERROR_MESSAGE_TOO_LARGE,
2400 #[cfg(feature = "v2_72")]
2401 Self::NoSuchDevice => ffi::G_IO_ERROR_NO_SUCH_DEVICE,
2402 #[cfg(feature = "v2_80")]
2403 Self::DestinationUnset => ffi::G_IO_ERROR_DESTINATION_UNSET,
2404 Self::__Unknown(value) => value,
2405 }
2406 }
2407}
2408
2409#[doc(hidden)]
2410impl FromGlib<ffi::GIOErrorEnum> for IOErrorEnum {
2411 unsafe fn from_glib(value: ffi::GIOErrorEnum) -> Self {
2412 match value {
2413 ffi::G_IO_ERROR_FAILED => Self::Failed,
2414 ffi::G_IO_ERROR_NOT_FOUND => Self::NotFound,
2415 ffi::G_IO_ERROR_EXISTS => Self::Exists,
2416 ffi::G_IO_ERROR_IS_DIRECTORY => Self::IsDirectory,
2417 ffi::G_IO_ERROR_NOT_DIRECTORY => Self::NotDirectory,
2418 ffi::G_IO_ERROR_NOT_EMPTY => Self::NotEmpty,
2419 ffi::G_IO_ERROR_NOT_REGULAR_FILE => Self::NotRegularFile,
2420 ffi::G_IO_ERROR_NOT_SYMBOLIC_LINK => Self::NotSymbolicLink,
2421 ffi::G_IO_ERROR_NOT_MOUNTABLE_FILE => Self::NotMountableFile,
2422 ffi::G_IO_ERROR_FILENAME_TOO_LONG => Self::FilenameTooLong,
2423 ffi::G_IO_ERROR_INVALID_FILENAME => Self::InvalidFilename,
2424 ffi::G_IO_ERROR_TOO_MANY_LINKS => Self::TooManyLinks,
2425 ffi::G_IO_ERROR_NO_SPACE => Self::NoSpace,
2426 ffi::G_IO_ERROR_INVALID_ARGUMENT => Self::InvalidArgument,
2427 ffi::G_IO_ERROR_PERMISSION_DENIED => Self::PermissionDenied,
2428 ffi::G_IO_ERROR_NOT_SUPPORTED => Self::NotSupported,
2429 ffi::G_IO_ERROR_NOT_MOUNTED => Self::NotMounted,
2430 ffi::G_IO_ERROR_ALREADY_MOUNTED => Self::AlreadyMounted,
2431 ffi::G_IO_ERROR_CLOSED => Self::Closed,
2432 ffi::G_IO_ERROR_CANCELLED => Self::Cancelled,
2433 ffi::G_IO_ERROR_PENDING => Self::Pending,
2434 ffi::G_IO_ERROR_READ_ONLY => Self::ReadOnly,
2435 ffi::G_IO_ERROR_CANT_CREATE_BACKUP => Self::CantCreateBackup,
2436 ffi::G_IO_ERROR_WRONG_ETAG => Self::WrongEtag,
2437 ffi::G_IO_ERROR_TIMED_OUT => Self::TimedOut,
2438 ffi::G_IO_ERROR_WOULD_RECURSE => Self::WouldRecurse,
2439 ffi::G_IO_ERROR_BUSY => Self::Busy,
2440 ffi::G_IO_ERROR_WOULD_BLOCK => Self::WouldBlock,
2441 ffi::G_IO_ERROR_HOST_NOT_FOUND => Self::HostNotFound,
2442 ffi::G_IO_ERROR_WOULD_MERGE => Self::WouldMerge,
2443 ffi::G_IO_ERROR_FAILED_HANDLED => Self::FailedHandled,
2444 ffi::G_IO_ERROR_TOO_MANY_OPEN_FILES => Self::TooManyOpenFiles,
2445 ffi::G_IO_ERROR_NOT_INITIALIZED => Self::NotInitialized,
2446 ffi::G_IO_ERROR_ADDRESS_IN_USE => Self::AddressInUse,
2447 ffi::G_IO_ERROR_PARTIAL_INPUT => Self::PartialInput,
2448 ffi::G_IO_ERROR_INVALID_DATA => Self::InvalidData,
2449 ffi::G_IO_ERROR_DBUS_ERROR => Self::DbusError,
2450 ffi::G_IO_ERROR_HOST_UNREACHABLE => Self::HostUnreachable,
2451 ffi::G_IO_ERROR_NETWORK_UNREACHABLE => Self::NetworkUnreachable,
2452 ffi::G_IO_ERROR_CONNECTION_REFUSED => Self::ConnectionRefused,
2453 ffi::G_IO_ERROR_PROXY_FAILED => Self::ProxyFailed,
2454 ffi::G_IO_ERROR_PROXY_AUTH_FAILED => Self::ProxyAuthFailed,
2455 ffi::G_IO_ERROR_PROXY_NEED_AUTH => Self::ProxyNeedAuth,
2456 ffi::G_IO_ERROR_PROXY_NOT_ALLOWED => Self::ProxyNotAllowed,
2457 ffi::G_IO_ERROR_BROKEN_PIPE => Self::BrokenPipe,
2458 ffi::G_IO_ERROR_NOT_CONNECTED => Self::NotConnected,
2459 ffi::G_IO_ERROR_MESSAGE_TOO_LARGE => Self::MessageTooLarge,
2460 #[cfg(feature = "v2_72")]
2461 ffi::G_IO_ERROR_NO_SUCH_DEVICE => Self::NoSuchDevice,
2462 #[cfg(feature = "v2_80")]
2463 ffi::G_IO_ERROR_DESTINATION_UNSET => Self::DestinationUnset,
2464 value => Self::__Unknown(value),
2465 }
2466 }
2467}
2468
2469impl glib::error::ErrorDomain for IOErrorEnum {
2470 #[inline]
2471 fn domain() -> glib::Quark {
2472 unsafe { from_glib(ffi::g_io_error_quark()) }
2473 }
2474
2475 #[inline]
2476 fn code(self) -> i32 {
2477 self.into_glib()
2478 }
2479
2480 #[inline]
2481 #[allow(clippy::match_single_binding)]
2482 fn from(code: i32) -> Option<Self> {
2483 match unsafe { from_glib(code) } {
2484 Self::__Unknown(_) => Some(Self::Failed),
2485 value => Some(value),
2486 }
2487 }
2488}
2489
2490impl StaticType for IOErrorEnum {
2491 #[inline]
2492 #[doc(alias = "g_io_error_enum_get_type")]
2493 fn static_type() -> glib::Type {
2494 unsafe { from_glib(ffi::g_io_error_enum_get_type()) }
2495 }
2496}
2497
2498impl glib::HasParamSpec for IOErrorEnum {
2499 type ParamSpec = glib::ParamSpecEnum;
2500 type SetValue = Self;
2501 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2502
2503 fn param_spec_builder() -> Self::BuilderFn {
2504 Self::ParamSpec::builder_with_default
2505 }
2506}
2507
2508impl glib::value::ValueType for IOErrorEnum {
2509 type Type = Self;
2510}
2511
2512unsafe impl<'a> glib::value::FromValue<'a> for IOErrorEnum {
2513 type Checker = glib::value::GenericValueTypeChecker<Self>;
2514
2515 #[inline]
2516 unsafe fn from_value(value: &'a glib::Value) -> Self {
2517 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2518 }
2519}
2520
2521impl ToValue for IOErrorEnum {
2522 #[inline]
2523 fn to_value(&self) -> glib::Value {
2524 let mut value = glib::Value::for_value_type::<Self>();
2525 unsafe {
2526 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2527 }
2528 value
2529 }
2530
2531 #[inline]
2532 fn value_type(&self) -> glib::Type {
2533 Self::static_type()
2534 }
2535}
2536
2537impl From<IOErrorEnum> for glib::Value {
2538 #[inline]
2539 fn from(v: IOErrorEnum) -> Self {
2540 ToValue::to_value(&v)
2541 }
2542}
2543
2544#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2546#[non_exhaustive]
2547#[doc(alias = "GIOModuleScopeFlags")]
2548pub enum IOModuleScopeFlags {
2549 #[doc(alias = "G_IO_MODULE_SCOPE_NONE")]
2551 None,
2552 #[doc(alias = "G_IO_MODULE_SCOPE_BLOCK_DUPLICATES")]
2556 BlockDuplicates,
2557 #[doc(hidden)]
2558 __Unknown(i32),
2559}
2560
2561#[doc(hidden)]
2562impl IntoGlib for IOModuleScopeFlags {
2563 type GlibType = ffi::GIOModuleScopeFlags;
2564
2565 #[inline]
2566 fn into_glib(self) -> ffi::GIOModuleScopeFlags {
2567 match self {
2568 Self::None => ffi::G_IO_MODULE_SCOPE_NONE,
2569 Self::BlockDuplicates => ffi::G_IO_MODULE_SCOPE_BLOCK_DUPLICATES,
2570 Self::__Unknown(value) => value,
2571 }
2572 }
2573}
2574
2575#[doc(hidden)]
2576impl FromGlib<ffi::GIOModuleScopeFlags> for IOModuleScopeFlags {
2577 #[inline]
2578 unsafe fn from_glib(value: ffi::GIOModuleScopeFlags) -> Self {
2579 match value {
2580 ffi::G_IO_MODULE_SCOPE_NONE => Self::None,
2581 ffi::G_IO_MODULE_SCOPE_BLOCK_DUPLICATES => Self::BlockDuplicates,
2582 value => Self::__Unknown(value),
2583 }
2584 }
2585}
2586
2587impl StaticType for IOModuleScopeFlags {
2588 #[inline]
2589 #[doc(alias = "g_io_module_scope_flags_get_type")]
2590 fn static_type() -> glib::Type {
2591 unsafe { from_glib(ffi::g_io_module_scope_flags_get_type()) }
2592 }
2593}
2594
2595impl glib::HasParamSpec for IOModuleScopeFlags {
2596 type ParamSpec = glib::ParamSpecEnum;
2597 type SetValue = Self;
2598 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2599
2600 fn param_spec_builder() -> Self::BuilderFn {
2601 Self::ParamSpec::builder_with_default
2602 }
2603}
2604
2605impl glib::value::ValueType for IOModuleScopeFlags {
2606 type Type = Self;
2607}
2608
2609unsafe impl<'a> glib::value::FromValue<'a> for IOModuleScopeFlags {
2610 type Checker = glib::value::GenericValueTypeChecker<Self>;
2611
2612 #[inline]
2613 unsafe fn from_value(value: &'a glib::Value) -> Self {
2614 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2615 }
2616}
2617
2618impl ToValue for IOModuleScopeFlags {
2619 #[inline]
2620 fn to_value(&self) -> glib::Value {
2621 let mut value = glib::Value::for_value_type::<Self>();
2622 unsafe {
2623 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2624 }
2625 value
2626 }
2627
2628 #[inline]
2629 fn value_type(&self) -> glib::Type {
2630 Self::static_type()
2631 }
2632}
2633
2634impl From<IOModuleScopeFlags> for glib::Value {
2635 #[inline]
2636 fn from(v: IOModuleScopeFlags) -> Self {
2637 ToValue::to_value(&v)
2638 }
2639}
2640
2641#[cfg(feature = "v2_64")]
2654#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
2655#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2656#[non_exhaustive]
2657#[doc(alias = "GMemoryMonitorWarningLevel")]
2658pub enum MemoryMonitorWarningLevel {
2659 #[doc(alias = "G_MEMORY_MONITOR_WARNING_LEVEL_LOW")]
2663 Low,
2664 #[doc(alias = "G_MEMORY_MONITOR_WARNING_LEVEL_MEDIUM")]
2669 Medium,
2670 #[doc(alias = "G_MEMORY_MONITOR_WARNING_LEVEL_CRITICAL")]
2673 Critical,
2674 #[doc(hidden)]
2675 __Unknown(i32),
2676}
2677
2678#[cfg(feature = "v2_64")]
2679#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
2680#[doc(hidden)]
2681impl IntoGlib for MemoryMonitorWarningLevel {
2682 type GlibType = ffi::GMemoryMonitorWarningLevel;
2683
2684 #[inline]
2685 fn into_glib(self) -> ffi::GMemoryMonitorWarningLevel {
2686 match self {
2687 Self::Low => ffi::G_MEMORY_MONITOR_WARNING_LEVEL_LOW,
2688 Self::Medium => ffi::G_MEMORY_MONITOR_WARNING_LEVEL_MEDIUM,
2689 Self::Critical => ffi::G_MEMORY_MONITOR_WARNING_LEVEL_CRITICAL,
2690 Self::__Unknown(value) => value,
2691 }
2692 }
2693}
2694
2695#[cfg(feature = "v2_64")]
2696#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
2697#[doc(hidden)]
2698impl FromGlib<ffi::GMemoryMonitorWarningLevel> for MemoryMonitorWarningLevel {
2699 #[inline]
2700 unsafe fn from_glib(value: ffi::GMemoryMonitorWarningLevel) -> Self {
2701 match value {
2702 ffi::G_MEMORY_MONITOR_WARNING_LEVEL_LOW => Self::Low,
2703 ffi::G_MEMORY_MONITOR_WARNING_LEVEL_MEDIUM => Self::Medium,
2704 ffi::G_MEMORY_MONITOR_WARNING_LEVEL_CRITICAL => Self::Critical,
2705 value => Self::__Unknown(value),
2706 }
2707 }
2708}
2709
2710#[cfg(feature = "v2_64")]
2711#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
2712impl StaticType for MemoryMonitorWarningLevel {
2713 #[inline]
2714 #[doc(alias = "g_memory_monitor_warning_level_get_type")]
2715 fn static_type() -> glib::Type {
2716 unsafe { from_glib(ffi::g_memory_monitor_warning_level_get_type()) }
2717 }
2718}
2719
2720#[cfg(feature = "v2_64")]
2721#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
2722impl glib::HasParamSpec for MemoryMonitorWarningLevel {
2723 type ParamSpec = glib::ParamSpecEnum;
2724 type SetValue = Self;
2725 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2726
2727 fn param_spec_builder() -> Self::BuilderFn {
2728 Self::ParamSpec::builder_with_default
2729 }
2730}
2731
2732#[cfg(feature = "v2_64")]
2733#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
2734impl glib::value::ValueType for MemoryMonitorWarningLevel {
2735 type Type = Self;
2736}
2737
2738#[cfg(feature = "v2_64")]
2739#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
2740unsafe impl<'a> glib::value::FromValue<'a> for MemoryMonitorWarningLevel {
2741 type Checker = glib::value::GenericValueTypeChecker<Self>;
2742
2743 #[inline]
2744 unsafe fn from_value(value: &'a glib::Value) -> Self {
2745 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2746 }
2747}
2748
2749#[cfg(feature = "v2_64")]
2750#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
2751impl ToValue for MemoryMonitorWarningLevel {
2752 #[inline]
2753 fn to_value(&self) -> glib::Value {
2754 let mut value = glib::Value::for_value_type::<Self>();
2755 unsafe {
2756 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2757 }
2758 value
2759 }
2760
2761 #[inline]
2762 fn value_type(&self) -> glib::Type {
2763 Self::static_type()
2764 }
2765}
2766
2767#[cfg(feature = "v2_64")]
2768#[cfg_attr(docsrs, doc(cfg(feature = "v2_64")))]
2769impl From<MemoryMonitorWarningLevel> for glib::Value {
2770 #[inline]
2771 fn from(v: MemoryMonitorWarningLevel) -> Self {
2772 ToValue::to_value(&v)
2773 }
2774}
2775
2776#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2779#[non_exhaustive]
2780#[doc(alias = "GMountOperationResult")]
2781pub enum MountOperationResult {
2782 #[doc(alias = "G_MOUNT_OPERATION_HANDLED")]
2785 Handled,
2786 #[doc(alias = "G_MOUNT_OPERATION_ABORTED")]
2789 Aborted,
2790 #[doc(alias = "G_MOUNT_OPERATION_UNHANDLED")]
2793 Unhandled,
2794 #[doc(hidden)]
2795 __Unknown(i32),
2796}
2797
2798#[doc(hidden)]
2799impl IntoGlib for MountOperationResult {
2800 type GlibType = ffi::GMountOperationResult;
2801
2802 #[inline]
2803 fn into_glib(self) -> ffi::GMountOperationResult {
2804 match self {
2805 Self::Handled => ffi::G_MOUNT_OPERATION_HANDLED,
2806 Self::Aborted => ffi::G_MOUNT_OPERATION_ABORTED,
2807 Self::Unhandled => ffi::G_MOUNT_OPERATION_UNHANDLED,
2808 Self::__Unknown(value) => value,
2809 }
2810 }
2811}
2812
2813#[doc(hidden)]
2814impl FromGlib<ffi::GMountOperationResult> for MountOperationResult {
2815 #[inline]
2816 unsafe fn from_glib(value: ffi::GMountOperationResult) -> Self {
2817 match value {
2818 ffi::G_MOUNT_OPERATION_HANDLED => Self::Handled,
2819 ffi::G_MOUNT_OPERATION_ABORTED => Self::Aborted,
2820 ffi::G_MOUNT_OPERATION_UNHANDLED => Self::Unhandled,
2821 value => Self::__Unknown(value),
2822 }
2823 }
2824}
2825
2826impl StaticType for MountOperationResult {
2827 #[inline]
2828 #[doc(alias = "g_mount_operation_result_get_type")]
2829 fn static_type() -> glib::Type {
2830 unsafe { from_glib(ffi::g_mount_operation_result_get_type()) }
2831 }
2832}
2833
2834impl glib::HasParamSpec for MountOperationResult {
2835 type ParamSpec = glib::ParamSpecEnum;
2836 type SetValue = Self;
2837 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2838
2839 fn param_spec_builder() -> Self::BuilderFn {
2840 Self::ParamSpec::builder_with_default
2841 }
2842}
2843
2844impl glib::value::ValueType for MountOperationResult {
2845 type Type = Self;
2846}
2847
2848unsafe impl<'a> glib::value::FromValue<'a> for MountOperationResult {
2849 type Checker = glib::value::GenericValueTypeChecker<Self>;
2850
2851 #[inline]
2852 unsafe fn from_value(value: &'a glib::Value) -> Self {
2853 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2854 }
2855}
2856
2857impl ToValue for MountOperationResult {
2858 #[inline]
2859 fn to_value(&self) -> glib::Value {
2860 let mut value = glib::Value::for_value_type::<Self>();
2861 unsafe {
2862 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2863 }
2864 value
2865 }
2866
2867 #[inline]
2868 fn value_type(&self) -> glib::Type {
2869 Self::static_type()
2870 }
2871}
2872
2873impl From<MountOperationResult> for glib::Value {
2874 #[inline]
2875 fn from(v: MountOperationResult) -> Self {
2876 ToValue::to_value(&v)
2877 }
2878}
2879
2880#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2882#[non_exhaustive]
2883#[doc(alias = "GNetworkConnectivity")]
2884pub enum NetworkConnectivity {
2885 #[doc(alias = "G_NETWORK_CONNECTIVITY_LOCAL")]
2889 Local,
2890 #[doc(alias = "G_NETWORK_CONNECTIVITY_LIMITED")]
2894 Limited,
2895 #[doc(alias = "G_NETWORK_CONNECTIVITY_PORTAL")]
2898 Portal,
2899 #[doc(alias = "G_NETWORK_CONNECTIVITY_FULL")]
2902 Full,
2903 #[doc(hidden)]
2904 __Unknown(i32),
2905}
2906
2907#[doc(hidden)]
2908impl IntoGlib for NetworkConnectivity {
2909 type GlibType = ffi::GNetworkConnectivity;
2910
2911 #[inline]
2912 fn into_glib(self) -> ffi::GNetworkConnectivity {
2913 match self {
2914 Self::Local => ffi::G_NETWORK_CONNECTIVITY_LOCAL,
2915 Self::Limited => ffi::G_NETWORK_CONNECTIVITY_LIMITED,
2916 Self::Portal => ffi::G_NETWORK_CONNECTIVITY_PORTAL,
2917 Self::Full => ffi::G_NETWORK_CONNECTIVITY_FULL,
2918 Self::__Unknown(value) => value,
2919 }
2920 }
2921}
2922
2923#[doc(hidden)]
2924impl FromGlib<ffi::GNetworkConnectivity> for NetworkConnectivity {
2925 #[inline]
2926 unsafe fn from_glib(value: ffi::GNetworkConnectivity) -> Self {
2927 match value {
2928 ffi::G_NETWORK_CONNECTIVITY_LOCAL => Self::Local,
2929 ffi::G_NETWORK_CONNECTIVITY_LIMITED => Self::Limited,
2930 ffi::G_NETWORK_CONNECTIVITY_PORTAL => Self::Portal,
2931 ffi::G_NETWORK_CONNECTIVITY_FULL => Self::Full,
2932 value => Self::__Unknown(value),
2933 }
2934 }
2935}
2936
2937impl StaticType for NetworkConnectivity {
2938 #[inline]
2939 #[doc(alias = "g_network_connectivity_get_type")]
2940 fn static_type() -> glib::Type {
2941 unsafe { from_glib(ffi::g_network_connectivity_get_type()) }
2942 }
2943}
2944
2945impl glib::HasParamSpec for NetworkConnectivity {
2946 type ParamSpec = glib::ParamSpecEnum;
2947 type SetValue = Self;
2948 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
2949
2950 fn param_spec_builder() -> Self::BuilderFn {
2951 Self::ParamSpec::builder_with_default
2952 }
2953}
2954
2955impl glib::value::ValueType for NetworkConnectivity {
2956 type Type = Self;
2957}
2958
2959unsafe impl<'a> glib::value::FromValue<'a> for NetworkConnectivity {
2960 type Checker = glib::value::GenericValueTypeChecker<Self>;
2961
2962 #[inline]
2963 unsafe fn from_value(value: &'a glib::Value) -> Self {
2964 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
2965 }
2966}
2967
2968impl ToValue for NetworkConnectivity {
2969 #[inline]
2970 fn to_value(&self) -> glib::Value {
2971 let mut value = glib::Value::for_value_type::<Self>();
2972 unsafe {
2973 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
2974 }
2975 value
2976 }
2977
2978 #[inline]
2979 fn value_type(&self) -> glib::Type {
2980 Self::static_type()
2981 }
2982}
2983
2984impl From<NetworkConnectivity> for glib::Value {
2985 #[inline]
2986 fn from(v: NetworkConnectivity) -> Self {
2987 ToValue::to_value(&v)
2988 }
2989}
2990
2991#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2993#[non_exhaustive]
2994#[doc(alias = "GNotificationPriority")]
2995pub enum NotificationPriority {
2996 #[doc(alias = "G_NOTIFICATION_PRIORITY_NORMAL")]
3000 Normal,
3001 #[doc(alias = "G_NOTIFICATION_PRIORITY_LOW")]
3005 Low,
3006 #[doc(alias = "G_NOTIFICATION_PRIORITY_HIGH")]
3010 High,
3011 #[doc(alias = "G_NOTIFICATION_PRIORITY_URGENT")]
3015 Urgent,
3016 #[doc(hidden)]
3017 __Unknown(i32),
3018}
3019
3020#[doc(hidden)]
3021impl IntoGlib for NotificationPriority {
3022 type GlibType = ffi::GNotificationPriority;
3023
3024 #[inline]
3025 fn into_glib(self) -> ffi::GNotificationPriority {
3026 match self {
3027 Self::Normal => ffi::G_NOTIFICATION_PRIORITY_NORMAL,
3028 Self::Low => ffi::G_NOTIFICATION_PRIORITY_LOW,
3029 Self::High => ffi::G_NOTIFICATION_PRIORITY_HIGH,
3030 Self::Urgent => ffi::G_NOTIFICATION_PRIORITY_URGENT,
3031 Self::__Unknown(value) => value,
3032 }
3033 }
3034}
3035
3036#[doc(hidden)]
3037impl FromGlib<ffi::GNotificationPriority> for NotificationPriority {
3038 #[inline]
3039 unsafe fn from_glib(value: ffi::GNotificationPriority) -> Self {
3040 match value {
3041 ffi::G_NOTIFICATION_PRIORITY_NORMAL => Self::Normal,
3042 ffi::G_NOTIFICATION_PRIORITY_LOW => Self::Low,
3043 ffi::G_NOTIFICATION_PRIORITY_HIGH => Self::High,
3044 ffi::G_NOTIFICATION_PRIORITY_URGENT => Self::Urgent,
3045 value => Self::__Unknown(value),
3046 }
3047 }
3048}
3049
3050impl StaticType for NotificationPriority {
3051 #[inline]
3052 #[doc(alias = "g_notification_priority_get_type")]
3053 fn static_type() -> glib::Type {
3054 unsafe { from_glib(ffi::g_notification_priority_get_type()) }
3055 }
3056}
3057
3058impl glib::HasParamSpec for NotificationPriority {
3059 type ParamSpec = glib::ParamSpecEnum;
3060 type SetValue = Self;
3061 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3062
3063 fn param_spec_builder() -> Self::BuilderFn {
3064 Self::ParamSpec::builder_with_default
3065 }
3066}
3067
3068impl glib::value::ValueType for NotificationPriority {
3069 type Type = Self;
3070}
3071
3072unsafe impl<'a> glib::value::FromValue<'a> for NotificationPriority {
3073 type Checker = glib::value::GenericValueTypeChecker<Self>;
3074
3075 #[inline]
3076 unsafe fn from_value(value: &'a glib::Value) -> Self {
3077 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3078 }
3079}
3080
3081impl ToValue for NotificationPriority {
3082 #[inline]
3083 fn to_value(&self) -> glib::Value {
3084 let mut value = glib::Value::for_value_type::<Self>();
3085 unsafe {
3086 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3087 }
3088 value
3089 }
3090
3091 #[inline]
3092 fn value_type(&self) -> glib::Type {
3093 Self::static_type()
3094 }
3095}
3096
3097impl From<NotificationPriority> for glib::Value {
3098 #[inline]
3099 fn from(v: NotificationPriority) -> Self {
3100 ToValue::to_value(&v)
3101 }
3102}
3103
3104#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3109#[non_exhaustive]
3110#[doc(alias = "GPasswordSave")]
3111pub enum PasswordSave {
3112 #[doc(alias = "G_PASSWORD_SAVE_NEVER")]
3114 Never,
3115 #[doc(alias = "G_PASSWORD_SAVE_FOR_SESSION")]
3117 ForSession,
3118 #[doc(alias = "G_PASSWORD_SAVE_PERMANENTLY")]
3120 Permanently,
3121 #[doc(hidden)]
3122 __Unknown(i32),
3123}
3124
3125#[doc(hidden)]
3126impl IntoGlib for PasswordSave {
3127 type GlibType = ffi::GPasswordSave;
3128
3129 #[inline]
3130 fn into_glib(self) -> ffi::GPasswordSave {
3131 match self {
3132 Self::Never => ffi::G_PASSWORD_SAVE_NEVER,
3133 Self::ForSession => ffi::G_PASSWORD_SAVE_FOR_SESSION,
3134 Self::Permanently => ffi::G_PASSWORD_SAVE_PERMANENTLY,
3135 Self::__Unknown(value) => value,
3136 }
3137 }
3138}
3139
3140#[doc(hidden)]
3141impl FromGlib<ffi::GPasswordSave> for PasswordSave {
3142 #[inline]
3143 unsafe fn from_glib(value: ffi::GPasswordSave) -> Self {
3144 match value {
3145 ffi::G_PASSWORD_SAVE_NEVER => Self::Never,
3146 ffi::G_PASSWORD_SAVE_FOR_SESSION => Self::ForSession,
3147 ffi::G_PASSWORD_SAVE_PERMANENTLY => Self::Permanently,
3148 value => Self::__Unknown(value),
3149 }
3150 }
3151}
3152
3153impl StaticType for PasswordSave {
3154 #[inline]
3155 #[doc(alias = "g_password_save_get_type")]
3156 fn static_type() -> glib::Type {
3157 unsafe { from_glib(ffi::g_password_save_get_type()) }
3158 }
3159}
3160
3161impl glib::HasParamSpec for PasswordSave {
3162 type ParamSpec = glib::ParamSpecEnum;
3163 type SetValue = Self;
3164 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3165
3166 fn param_spec_builder() -> Self::BuilderFn {
3167 Self::ParamSpec::builder_with_default
3168 }
3169}
3170
3171impl glib::value::ValueType for PasswordSave {
3172 type Type = Self;
3173}
3174
3175unsafe impl<'a> glib::value::FromValue<'a> for PasswordSave {
3176 type Checker = glib::value::GenericValueTypeChecker<Self>;
3177
3178 #[inline]
3179 unsafe fn from_value(value: &'a glib::Value) -> Self {
3180 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3181 }
3182}
3183
3184impl ToValue for PasswordSave {
3185 #[inline]
3186 fn to_value(&self) -> glib::Value {
3187 let mut value = glib::Value::for_value_type::<Self>();
3188 unsafe {
3189 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3190 }
3191 value
3192 }
3193
3194 #[inline]
3195 fn value_type(&self) -> glib::Type {
3196 Self::static_type()
3197 }
3198}
3199
3200impl From<PasswordSave> for glib::Value {
3201 #[inline]
3202 fn from(v: PasswordSave) -> Self {
3203 ToValue::to_value(&v)
3204 }
3205}
3206
3207#[cfg(feature = "v2_60")]
3217#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
3218#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3219#[non_exhaustive]
3220#[doc(alias = "GPollableReturn")]
3221pub enum PollableReturn {
3222 #[doc(alias = "G_POLLABLE_RETURN_FAILED")]
3224 Failed,
3225 #[doc(alias = "G_POLLABLE_RETURN_OK")]
3227 Ok,
3228 #[doc(alias = "G_POLLABLE_RETURN_WOULD_BLOCK")]
3230 WouldBlock,
3231 #[doc(hidden)]
3232 __Unknown(i32),
3233}
3234
3235#[cfg(feature = "v2_60")]
3236#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
3237#[doc(hidden)]
3238impl IntoGlib for PollableReturn {
3239 type GlibType = ffi::GPollableReturn;
3240
3241 #[inline]
3242 fn into_glib(self) -> ffi::GPollableReturn {
3243 match self {
3244 Self::Failed => ffi::G_POLLABLE_RETURN_FAILED,
3245 Self::Ok => ffi::G_POLLABLE_RETURN_OK,
3246 Self::WouldBlock => ffi::G_POLLABLE_RETURN_WOULD_BLOCK,
3247 Self::__Unknown(value) => value,
3248 }
3249 }
3250}
3251
3252#[cfg(feature = "v2_60")]
3253#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
3254#[doc(hidden)]
3255impl FromGlib<ffi::GPollableReturn> for PollableReturn {
3256 #[inline]
3257 unsafe fn from_glib(value: ffi::GPollableReturn) -> Self {
3258 match value {
3259 ffi::G_POLLABLE_RETURN_FAILED => Self::Failed,
3260 ffi::G_POLLABLE_RETURN_OK => Self::Ok,
3261 ffi::G_POLLABLE_RETURN_WOULD_BLOCK => Self::WouldBlock,
3262 value => Self::__Unknown(value),
3263 }
3264 }
3265}
3266
3267#[cfg(feature = "v2_60")]
3268#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
3269impl StaticType for PollableReturn {
3270 #[inline]
3271 #[doc(alias = "g_pollable_return_get_type")]
3272 fn static_type() -> glib::Type {
3273 unsafe { from_glib(ffi::g_pollable_return_get_type()) }
3274 }
3275}
3276
3277#[cfg(feature = "v2_60")]
3278#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
3279impl glib::HasParamSpec for PollableReturn {
3280 type ParamSpec = glib::ParamSpecEnum;
3281 type SetValue = Self;
3282 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3283
3284 fn param_spec_builder() -> Self::BuilderFn {
3285 Self::ParamSpec::builder_with_default
3286 }
3287}
3288
3289#[cfg(feature = "v2_60")]
3290#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
3291impl glib::value::ValueType for PollableReturn {
3292 type Type = Self;
3293}
3294
3295#[cfg(feature = "v2_60")]
3296#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
3297unsafe impl<'a> glib::value::FromValue<'a> for PollableReturn {
3298 type Checker = glib::value::GenericValueTypeChecker<Self>;
3299
3300 #[inline]
3301 unsafe fn from_value(value: &'a glib::Value) -> Self {
3302 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3303 }
3304}
3305
3306#[cfg(feature = "v2_60")]
3307#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
3308impl ToValue for PollableReturn {
3309 #[inline]
3310 fn to_value(&self) -> glib::Value {
3311 let mut value = glib::Value::for_value_type::<Self>();
3312 unsafe {
3313 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3314 }
3315 value
3316 }
3317
3318 #[inline]
3319 fn value_type(&self) -> glib::Type {
3320 Self::static_type()
3321 }
3322}
3323
3324#[cfg(feature = "v2_60")]
3325#[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
3326impl From<PollableReturn> for glib::Value {
3327 #[inline]
3328 fn from(v: PollableReturn) -> Self {
3329 ToValue::to_value(&v)
3330 }
3331}
3332
3333#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3336#[non_exhaustive]
3337#[doc(alias = "GResolverError")]
3338pub enum ResolverError {
3339 #[doc(alias = "G_RESOLVER_ERROR_NOT_FOUND")]
3342 NotFound,
3343 #[doc(alias = "G_RESOLVER_ERROR_TEMPORARY_FAILURE")]
3346 TemporaryFailure,
3347 #[doc(alias = "G_RESOLVER_ERROR_INTERNAL")]
3349 Internal,
3350 #[doc(hidden)]
3351 __Unknown(i32),
3352}
3353
3354#[doc(hidden)]
3355impl IntoGlib for ResolverError {
3356 type GlibType = ffi::GResolverError;
3357
3358 #[inline]
3359 fn into_glib(self) -> ffi::GResolverError {
3360 match self {
3361 Self::NotFound => ffi::G_RESOLVER_ERROR_NOT_FOUND,
3362 Self::TemporaryFailure => ffi::G_RESOLVER_ERROR_TEMPORARY_FAILURE,
3363 Self::Internal => ffi::G_RESOLVER_ERROR_INTERNAL,
3364 Self::__Unknown(value) => value,
3365 }
3366 }
3367}
3368
3369#[doc(hidden)]
3370impl FromGlib<ffi::GResolverError> for ResolverError {
3371 #[inline]
3372 unsafe fn from_glib(value: ffi::GResolverError) -> Self {
3373 match value {
3374 ffi::G_RESOLVER_ERROR_NOT_FOUND => Self::NotFound,
3375 ffi::G_RESOLVER_ERROR_TEMPORARY_FAILURE => Self::TemporaryFailure,
3376 ffi::G_RESOLVER_ERROR_INTERNAL => Self::Internal,
3377 value => Self::__Unknown(value),
3378 }
3379 }
3380}
3381
3382impl glib::error::ErrorDomain for ResolverError {
3383 #[inline]
3384 fn domain() -> glib::Quark {
3385 unsafe { from_glib(ffi::g_resolver_error_quark()) }
3386 }
3387
3388 #[inline]
3389 fn code(self) -> i32 {
3390 self.into_glib()
3391 }
3392
3393 #[inline]
3394 #[allow(clippy::match_single_binding)]
3395 fn from(code: i32) -> Option<Self> {
3396 match unsafe { from_glib(code) } {
3397 value => Some(value),
3398 }
3399 }
3400}
3401
3402impl StaticType for ResolverError {
3403 #[inline]
3404 #[doc(alias = "g_resolver_error_get_type")]
3405 fn static_type() -> glib::Type {
3406 unsafe { from_glib(ffi::g_resolver_error_get_type()) }
3407 }
3408}
3409
3410impl glib::HasParamSpec for ResolverError {
3411 type ParamSpec = glib::ParamSpecEnum;
3412 type SetValue = Self;
3413 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3414
3415 fn param_spec_builder() -> Self::BuilderFn {
3416 Self::ParamSpec::builder_with_default
3417 }
3418}
3419
3420impl glib::value::ValueType for ResolverError {
3421 type Type = Self;
3422}
3423
3424unsafe impl<'a> glib::value::FromValue<'a> for ResolverError {
3425 type Checker = glib::value::GenericValueTypeChecker<Self>;
3426
3427 #[inline]
3428 unsafe fn from_value(value: &'a glib::Value) -> Self {
3429 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3430 }
3431}
3432
3433impl ToValue for ResolverError {
3434 #[inline]
3435 fn to_value(&self) -> glib::Value {
3436 let mut value = glib::Value::for_value_type::<Self>();
3437 unsafe {
3438 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3439 }
3440 value
3441 }
3442
3443 #[inline]
3444 fn value_type(&self) -> glib::Type {
3445 Self::static_type()
3446 }
3447}
3448
3449impl From<ResolverError> for glib::Value {
3450 #[inline]
3451 fn from(v: ResolverError) -> Self {
3452 ToValue::to_value(&v)
3453 }
3454}
3455
3456#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3487#[non_exhaustive]
3488#[doc(alias = "GResolverRecordType")]
3489pub enum ResolverRecordType {
3490 #[doc(alias = "G_RESOLVER_RECORD_SRV")]
3492 Srv,
3493 #[doc(alias = "G_RESOLVER_RECORD_MX")]
3495 Mx,
3496 #[doc(alias = "G_RESOLVER_RECORD_TXT")]
3498 Txt,
3499 #[doc(alias = "G_RESOLVER_RECORD_SOA")]
3501 Soa,
3502 #[doc(alias = "G_RESOLVER_RECORD_NS")]
3504 Ns,
3505 #[doc(hidden)]
3506 __Unknown(i32),
3507}
3508
3509#[doc(hidden)]
3510impl IntoGlib for ResolverRecordType {
3511 type GlibType = ffi::GResolverRecordType;
3512
3513 #[inline]
3514 fn into_glib(self) -> ffi::GResolverRecordType {
3515 match self {
3516 Self::Srv => ffi::G_RESOLVER_RECORD_SRV,
3517 Self::Mx => ffi::G_RESOLVER_RECORD_MX,
3518 Self::Txt => ffi::G_RESOLVER_RECORD_TXT,
3519 Self::Soa => ffi::G_RESOLVER_RECORD_SOA,
3520 Self::Ns => ffi::G_RESOLVER_RECORD_NS,
3521 Self::__Unknown(value) => value,
3522 }
3523 }
3524}
3525
3526#[doc(hidden)]
3527impl FromGlib<ffi::GResolverRecordType> for ResolverRecordType {
3528 #[inline]
3529 unsafe fn from_glib(value: ffi::GResolverRecordType) -> Self {
3530 match value {
3531 ffi::G_RESOLVER_RECORD_SRV => Self::Srv,
3532 ffi::G_RESOLVER_RECORD_MX => Self::Mx,
3533 ffi::G_RESOLVER_RECORD_TXT => Self::Txt,
3534 ffi::G_RESOLVER_RECORD_SOA => Self::Soa,
3535 ffi::G_RESOLVER_RECORD_NS => Self::Ns,
3536 value => Self::__Unknown(value),
3537 }
3538 }
3539}
3540
3541impl StaticType for ResolverRecordType {
3542 #[inline]
3543 #[doc(alias = "g_resolver_record_type_get_type")]
3544 fn static_type() -> glib::Type {
3545 unsafe { from_glib(ffi::g_resolver_record_type_get_type()) }
3546 }
3547}
3548
3549impl glib::HasParamSpec for ResolverRecordType {
3550 type ParamSpec = glib::ParamSpecEnum;
3551 type SetValue = Self;
3552 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3553
3554 fn param_spec_builder() -> Self::BuilderFn {
3555 Self::ParamSpec::builder_with_default
3556 }
3557}
3558
3559impl glib::value::ValueType for ResolverRecordType {
3560 type Type = Self;
3561}
3562
3563unsafe impl<'a> glib::value::FromValue<'a> for ResolverRecordType {
3564 type Checker = glib::value::GenericValueTypeChecker<Self>;
3565
3566 #[inline]
3567 unsafe fn from_value(value: &'a glib::Value) -> Self {
3568 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3569 }
3570}
3571
3572impl ToValue for ResolverRecordType {
3573 #[inline]
3574 fn to_value(&self) -> glib::Value {
3575 let mut value = glib::Value::for_value_type::<Self>();
3576 unsafe {
3577 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3578 }
3579 value
3580 }
3581
3582 #[inline]
3583 fn value_type(&self) -> glib::Type {
3584 Self::static_type()
3585 }
3586}
3587
3588impl From<ResolverRecordType> for glib::Value {
3589 #[inline]
3590 fn from(v: ResolverRecordType) -> Self {
3591 ToValue::to_value(&v)
3592 }
3593}
3594
3595#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3598#[non_exhaustive]
3599#[doc(alias = "GResourceError")]
3600pub enum ResourceError {
3601 #[doc(alias = "G_RESOURCE_ERROR_NOT_FOUND")]
3603 NotFound,
3604 #[doc(alias = "G_RESOURCE_ERROR_INTERNAL")]
3606 Internal,
3607 #[doc(hidden)]
3608 __Unknown(i32),
3609}
3610
3611#[doc(hidden)]
3612impl IntoGlib for ResourceError {
3613 type GlibType = ffi::GResourceError;
3614
3615 #[inline]
3616 fn into_glib(self) -> ffi::GResourceError {
3617 match self {
3618 Self::NotFound => ffi::G_RESOURCE_ERROR_NOT_FOUND,
3619 Self::Internal => ffi::G_RESOURCE_ERROR_INTERNAL,
3620 Self::__Unknown(value) => value,
3621 }
3622 }
3623}
3624
3625#[doc(hidden)]
3626impl FromGlib<ffi::GResourceError> for ResourceError {
3627 #[inline]
3628 unsafe fn from_glib(value: ffi::GResourceError) -> Self {
3629 match value {
3630 ffi::G_RESOURCE_ERROR_NOT_FOUND => Self::NotFound,
3631 ffi::G_RESOURCE_ERROR_INTERNAL => Self::Internal,
3632 value => Self::__Unknown(value),
3633 }
3634 }
3635}
3636
3637impl glib::error::ErrorDomain for ResourceError {
3638 #[inline]
3639 fn domain() -> glib::Quark {
3640 unsafe { from_glib(ffi::g_resource_error_quark()) }
3641 }
3642
3643 #[inline]
3644 fn code(self) -> i32 {
3645 self.into_glib()
3646 }
3647
3648 #[inline]
3649 #[allow(clippy::match_single_binding)]
3650 fn from(code: i32) -> Option<Self> {
3651 match unsafe { from_glib(code) } {
3652 value => Some(value),
3653 }
3654 }
3655}
3656
3657impl StaticType for ResourceError {
3658 #[inline]
3659 #[doc(alias = "g_resource_error_get_type")]
3660 fn static_type() -> glib::Type {
3661 unsafe { from_glib(ffi::g_resource_error_get_type()) }
3662 }
3663}
3664
3665impl glib::HasParamSpec for ResourceError {
3666 type ParamSpec = glib::ParamSpecEnum;
3667 type SetValue = Self;
3668 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3669
3670 fn param_spec_builder() -> Self::BuilderFn {
3671 Self::ParamSpec::builder_with_default
3672 }
3673}
3674
3675impl glib::value::ValueType for ResourceError {
3676 type Type = Self;
3677}
3678
3679unsafe impl<'a> glib::value::FromValue<'a> for ResourceError {
3680 type Checker = glib::value::GenericValueTypeChecker<Self>;
3681
3682 #[inline]
3683 unsafe fn from_value(value: &'a glib::Value) -> Self {
3684 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3685 }
3686}
3687
3688impl ToValue for ResourceError {
3689 #[inline]
3690 fn to_value(&self) -> glib::Value {
3691 let mut value = glib::Value::for_value_type::<Self>();
3692 unsafe {
3693 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3694 }
3695 value
3696 }
3697
3698 #[inline]
3699 fn value_type(&self) -> glib::Type {
3700 Self::static_type()
3701 }
3702}
3703
3704impl From<ResourceError> for glib::Value {
3705 #[inline]
3706 fn from(v: ResourceError) -> Self {
3707 ToValue::to_value(&v)
3708 }
3709}
3710
3711#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3716#[non_exhaustive]
3717#[doc(alias = "GSocketClientEvent")]
3718pub enum SocketClientEvent {
3719 #[doc(alias = "G_SOCKET_CLIENT_RESOLVING")]
3721 Resolving,
3722 #[doc(alias = "G_SOCKET_CLIENT_RESOLVED")]
3724 Resolved,
3725 #[doc(alias = "G_SOCKET_CLIENT_CONNECTING")]
3728 Connecting,
3729 #[doc(alias = "G_SOCKET_CLIENT_CONNECTED")]
3732 Connected,
3733 #[doc(alias = "G_SOCKET_CLIENT_PROXY_NEGOTIATING")]
3736 ProxyNegotiating,
3737 #[doc(alias = "G_SOCKET_CLIENT_PROXY_NEGOTIATED")]
3740 ProxyNegotiated,
3741 #[doc(alias = "G_SOCKET_CLIENT_TLS_HANDSHAKING")]
3744 TlsHandshaking,
3745 #[doc(alias = "G_SOCKET_CLIENT_TLS_HANDSHAKED")]
3748 TlsHandshaked,
3749 #[doc(alias = "G_SOCKET_CLIENT_COMPLETE")]
3752 Complete,
3753 #[doc(hidden)]
3754 __Unknown(i32),
3755}
3756
3757#[doc(hidden)]
3758impl IntoGlib for SocketClientEvent {
3759 type GlibType = ffi::GSocketClientEvent;
3760
3761 #[inline]
3762 fn into_glib(self) -> ffi::GSocketClientEvent {
3763 match self {
3764 Self::Resolving => ffi::G_SOCKET_CLIENT_RESOLVING,
3765 Self::Resolved => ffi::G_SOCKET_CLIENT_RESOLVED,
3766 Self::Connecting => ffi::G_SOCKET_CLIENT_CONNECTING,
3767 Self::Connected => ffi::G_SOCKET_CLIENT_CONNECTED,
3768 Self::ProxyNegotiating => ffi::G_SOCKET_CLIENT_PROXY_NEGOTIATING,
3769 Self::ProxyNegotiated => ffi::G_SOCKET_CLIENT_PROXY_NEGOTIATED,
3770 Self::TlsHandshaking => ffi::G_SOCKET_CLIENT_TLS_HANDSHAKING,
3771 Self::TlsHandshaked => ffi::G_SOCKET_CLIENT_TLS_HANDSHAKED,
3772 Self::Complete => ffi::G_SOCKET_CLIENT_COMPLETE,
3773 Self::__Unknown(value) => value,
3774 }
3775 }
3776}
3777
3778#[doc(hidden)]
3779impl FromGlib<ffi::GSocketClientEvent> for SocketClientEvent {
3780 #[inline]
3781 unsafe fn from_glib(value: ffi::GSocketClientEvent) -> Self {
3782 match value {
3783 ffi::G_SOCKET_CLIENT_RESOLVING => Self::Resolving,
3784 ffi::G_SOCKET_CLIENT_RESOLVED => Self::Resolved,
3785 ffi::G_SOCKET_CLIENT_CONNECTING => Self::Connecting,
3786 ffi::G_SOCKET_CLIENT_CONNECTED => Self::Connected,
3787 ffi::G_SOCKET_CLIENT_PROXY_NEGOTIATING => Self::ProxyNegotiating,
3788 ffi::G_SOCKET_CLIENT_PROXY_NEGOTIATED => Self::ProxyNegotiated,
3789 ffi::G_SOCKET_CLIENT_TLS_HANDSHAKING => Self::TlsHandshaking,
3790 ffi::G_SOCKET_CLIENT_TLS_HANDSHAKED => Self::TlsHandshaked,
3791 ffi::G_SOCKET_CLIENT_COMPLETE => Self::Complete,
3792 value => Self::__Unknown(value),
3793 }
3794 }
3795}
3796
3797impl StaticType for SocketClientEvent {
3798 #[inline]
3799 #[doc(alias = "g_socket_client_event_get_type")]
3800 fn static_type() -> glib::Type {
3801 unsafe { from_glib(ffi::g_socket_client_event_get_type()) }
3802 }
3803}
3804
3805impl glib::HasParamSpec for SocketClientEvent {
3806 type ParamSpec = glib::ParamSpecEnum;
3807 type SetValue = Self;
3808 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3809
3810 fn param_spec_builder() -> Self::BuilderFn {
3811 Self::ParamSpec::builder_with_default
3812 }
3813}
3814
3815impl glib::value::ValueType for SocketClientEvent {
3816 type Type = Self;
3817}
3818
3819unsafe impl<'a> glib::value::FromValue<'a> for SocketClientEvent {
3820 type Checker = glib::value::GenericValueTypeChecker<Self>;
3821
3822 #[inline]
3823 unsafe fn from_value(value: &'a glib::Value) -> Self {
3824 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3825 }
3826}
3827
3828impl ToValue for SocketClientEvent {
3829 #[inline]
3830 fn to_value(&self) -> glib::Value {
3831 let mut value = glib::Value::for_value_type::<Self>();
3832 unsafe {
3833 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3834 }
3835 value
3836 }
3837
3838 #[inline]
3839 fn value_type(&self) -> glib::Type {
3840 Self::static_type()
3841 }
3842}
3843
3844impl From<SocketClientEvent> for glib::Value {
3845 #[inline]
3846 fn from(v: SocketClientEvent) -> Self {
3847 ToValue::to_value(&v)
3848 }
3849}
3850
3851#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3855#[non_exhaustive]
3856#[doc(alias = "GSocketFamily")]
3857pub enum SocketFamily {
3858 #[doc(alias = "G_SOCKET_FAMILY_INVALID")]
3860 Invalid,
3861 #[doc(alias = "G_SOCKET_FAMILY_UNIX")]
3863 Unix,
3864 #[doc(alias = "G_SOCKET_FAMILY_IPV4")]
3866 Ipv4,
3867 #[doc(alias = "G_SOCKET_FAMILY_IPV6")]
3869 Ipv6,
3870 #[doc(hidden)]
3871 __Unknown(i32),
3872}
3873
3874#[doc(hidden)]
3875impl IntoGlib for SocketFamily {
3876 type GlibType = ffi::GSocketFamily;
3877
3878 #[inline]
3879 fn into_glib(self) -> ffi::GSocketFamily {
3880 match self {
3881 Self::Invalid => ffi::G_SOCKET_FAMILY_INVALID,
3882 Self::Unix => ffi::G_SOCKET_FAMILY_UNIX,
3883 Self::Ipv4 => ffi::G_SOCKET_FAMILY_IPV4,
3884 Self::Ipv6 => ffi::G_SOCKET_FAMILY_IPV6,
3885 Self::__Unknown(value) => value,
3886 }
3887 }
3888}
3889
3890#[doc(hidden)]
3891impl FromGlib<ffi::GSocketFamily> for SocketFamily {
3892 #[inline]
3893 unsafe fn from_glib(value: ffi::GSocketFamily) -> Self {
3894 match value {
3895 ffi::G_SOCKET_FAMILY_INVALID => Self::Invalid,
3896 ffi::G_SOCKET_FAMILY_UNIX => Self::Unix,
3897 ffi::G_SOCKET_FAMILY_IPV4 => Self::Ipv4,
3898 ffi::G_SOCKET_FAMILY_IPV6 => Self::Ipv6,
3899 value => Self::__Unknown(value),
3900 }
3901 }
3902}
3903
3904impl StaticType for SocketFamily {
3905 #[inline]
3906 #[doc(alias = "g_socket_family_get_type")]
3907 fn static_type() -> glib::Type {
3908 unsafe { from_glib(ffi::g_socket_family_get_type()) }
3909 }
3910}
3911
3912impl glib::HasParamSpec for SocketFamily {
3913 type ParamSpec = glib::ParamSpecEnum;
3914 type SetValue = Self;
3915 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
3916
3917 fn param_spec_builder() -> Self::BuilderFn {
3918 Self::ParamSpec::builder_with_default
3919 }
3920}
3921
3922impl glib::value::ValueType for SocketFamily {
3923 type Type = Self;
3924}
3925
3926unsafe impl<'a> glib::value::FromValue<'a> for SocketFamily {
3927 type Checker = glib::value::GenericValueTypeChecker<Self>;
3928
3929 #[inline]
3930 unsafe fn from_value(value: &'a glib::Value) -> Self {
3931 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
3932 }
3933}
3934
3935impl ToValue for SocketFamily {
3936 #[inline]
3937 fn to_value(&self) -> glib::Value {
3938 let mut value = glib::Value::for_value_type::<Self>();
3939 unsafe {
3940 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
3941 }
3942 value
3943 }
3944
3945 #[inline]
3946 fn value_type(&self) -> glib::Type {
3947 Self::static_type()
3948 }
3949}
3950
3951impl From<SocketFamily> for glib::Value {
3952 #[inline]
3953 fn from(v: SocketFamily) -> Self {
3954 ToValue::to_value(&v)
3955 }
3956}
3957
3958#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
3963#[non_exhaustive]
3964#[doc(alias = "GSocketListenerEvent")]
3965pub enum SocketListenerEvent {
3966 #[doc(alias = "G_SOCKET_LISTENER_BINDING")]
3968 Binding,
3969 #[doc(alias = "G_SOCKET_LISTENER_BOUND")]
3971 Bound,
3972 #[doc(alias = "G_SOCKET_LISTENER_LISTENING")]
3975 Listening,
3976 #[doc(alias = "G_SOCKET_LISTENER_LISTENED")]
3979 Listened,
3980 #[doc(hidden)]
3981 __Unknown(i32),
3982}
3983
3984#[doc(hidden)]
3985impl IntoGlib for SocketListenerEvent {
3986 type GlibType = ffi::GSocketListenerEvent;
3987
3988 #[inline]
3989 fn into_glib(self) -> ffi::GSocketListenerEvent {
3990 match self {
3991 Self::Binding => ffi::G_SOCKET_LISTENER_BINDING,
3992 Self::Bound => ffi::G_SOCKET_LISTENER_BOUND,
3993 Self::Listening => ffi::G_SOCKET_LISTENER_LISTENING,
3994 Self::Listened => ffi::G_SOCKET_LISTENER_LISTENED,
3995 Self::__Unknown(value) => value,
3996 }
3997 }
3998}
3999
4000#[doc(hidden)]
4001impl FromGlib<ffi::GSocketListenerEvent> for SocketListenerEvent {
4002 #[inline]
4003 unsafe fn from_glib(value: ffi::GSocketListenerEvent) -> Self {
4004 match value {
4005 ffi::G_SOCKET_LISTENER_BINDING => Self::Binding,
4006 ffi::G_SOCKET_LISTENER_BOUND => Self::Bound,
4007 ffi::G_SOCKET_LISTENER_LISTENING => Self::Listening,
4008 ffi::G_SOCKET_LISTENER_LISTENED => Self::Listened,
4009 value => Self::__Unknown(value),
4010 }
4011 }
4012}
4013
4014impl StaticType for SocketListenerEvent {
4015 #[inline]
4016 #[doc(alias = "g_socket_listener_event_get_type")]
4017 fn static_type() -> glib::Type {
4018 unsafe { from_glib(ffi::g_socket_listener_event_get_type()) }
4019 }
4020}
4021
4022impl glib::HasParamSpec for SocketListenerEvent {
4023 type ParamSpec = glib::ParamSpecEnum;
4024 type SetValue = Self;
4025 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4026
4027 fn param_spec_builder() -> Self::BuilderFn {
4028 Self::ParamSpec::builder_with_default
4029 }
4030}
4031
4032impl glib::value::ValueType for SocketListenerEvent {
4033 type Type = Self;
4034}
4035
4036unsafe impl<'a> glib::value::FromValue<'a> for SocketListenerEvent {
4037 type Checker = glib::value::GenericValueTypeChecker<Self>;
4038
4039 #[inline]
4040 unsafe fn from_value(value: &'a glib::Value) -> Self {
4041 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4042 }
4043}
4044
4045impl ToValue for SocketListenerEvent {
4046 #[inline]
4047 fn to_value(&self) -> glib::Value {
4048 let mut value = glib::Value::for_value_type::<Self>();
4049 unsafe {
4050 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4051 }
4052 value
4053 }
4054
4055 #[inline]
4056 fn value_type(&self) -> glib::Type {
4057 Self::static_type()
4058 }
4059}
4060
4061impl From<SocketListenerEvent> for glib::Value {
4062 #[inline]
4063 fn from(v: SocketListenerEvent) -> Self {
4064 ToValue::to_value(&v)
4065 }
4066}
4067
4068#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4076#[non_exhaustive]
4077#[doc(alias = "GSocketProtocol")]
4078pub enum SocketProtocol {
4079 #[doc(alias = "G_SOCKET_PROTOCOL_UNKNOWN")]
4081 Unknown,
4082 #[doc(alias = "G_SOCKET_PROTOCOL_DEFAULT")]
4084 Default,
4085 #[doc(alias = "G_SOCKET_PROTOCOL_TCP")]
4087 Tcp,
4088 #[doc(alias = "G_SOCKET_PROTOCOL_UDP")]
4090 Udp,
4091 #[doc(alias = "G_SOCKET_PROTOCOL_SCTP")]
4093 Sctp,
4094 #[doc(hidden)]
4095 __Unknown(i32),
4096}
4097
4098#[doc(hidden)]
4099impl IntoGlib for SocketProtocol {
4100 type GlibType = ffi::GSocketProtocol;
4101
4102 #[inline]
4103 fn into_glib(self) -> ffi::GSocketProtocol {
4104 match self {
4105 Self::Unknown => ffi::G_SOCKET_PROTOCOL_UNKNOWN,
4106 Self::Default => ffi::G_SOCKET_PROTOCOL_DEFAULT,
4107 Self::Tcp => ffi::G_SOCKET_PROTOCOL_TCP,
4108 Self::Udp => ffi::G_SOCKET_PROTOCOL_UDP,
4109 Self::Sctp => ffi::G_SOCKET_PROTOCOL_SCTP,
4110 Self::__Unknown(value) => value,
4111 }
4112 }
4113}
4114
4115#[doc(hidden)]
4116impl FromGlib<ffi::GSocketProtocol> for SocketProtocol {
4117 #[inline]
4118 unsafe fn from_glib(value: ffi::GSocketProtocol) -> Self {
4119 match value {
4120 ffi::G_SOCKET_PROTOCOL_UNKNOWN => Self::Unknown,
4121 ffi::G_SOCKET_PROTOCOL_DEFAULT => Self::Default,
4122 ffi::G_SOCKET_PROTOCOL_TCP => Self::Tcp,
4123 ffi::G_SOCKET_PROTOCOL_UDP => Self::Udp,
4124 ffi::G_SOCKET_PROTOCOL_SCTP => Self::Sctp,
4125 value => Self::__Unknown(value),
4126 }
4127 }
4128}
4129
4130impl StaticType for SocketProtocol {
4131 #[inline]
4132 #[doc(alias = "g_socket_protocol_get_type")]
4133 fn static_type() -> glib::Type {
4134 unsafe { from_glib(ffi::g_socket_protocol_get_type()) }
4135 }
4136}
4137
4138impl glib::HasParamSpec for SocketProtocol {
4139 type ParamSpec = glib::ParamSpecEnum;
4140 type SetValue = Self;
4141 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4142
4143 fn param_spec_builder() -> Self::BuilderFn {
4144 Self::ParamSpec::builder_with_default
4145 }
4146}
4147
4148impl glib::value::ValueType for SocketProtocol {
4149 type Type = Self;
4150}
4151
4152unsafe impl<'a> glib::value::FromValue<'a> for SocketProtocol {
4153 type Checker = glib::value::GenericValueTypeChecker<Self>;
4154
4155 #[inline]
4156 unsafe fn from_value(value: &'a glib::Value) -> Self {
4157 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4158 }
4159}
4160
4161impl ToValue for SocketProtocol {
4162 #[inline]
4163 fn to_value(&self) -> glib::Value {
4164 let mut value = glib::Value::for_value_type::<Self>();
4165 unsafe {
4166 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4167 }
4168 value
4169 }
4170
4171 #[inline]
4172 fn value_type(&self) -> glib::Type {
4173 Self::static_type()
4174 }
4175}
4176
4177impl From<SocketProtocol> for glib::Value {
4178 #[inline]
4179 fn from(v: SocketProtocol) -> Self {
4180 ToValue::to_value(&v)
4181 }
4182}
4183
4184#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4187#[non_exhaustive]
4188#[doc(alias = "GSocketType")]
4189pub enum SocketType {
4190 #[doc(alias = "G_SOCKET_TYPE_INVALID")]
4192 Invalid,
4193 #[doc(alias = "G_SOCKET_TYPE_STREAM")]
4195 Stream,
4196 #[doc(alias = "G_SOCKET_TYPE_DATAGRAM")]
4199 Datagram,
4200 #[doc(alias = "G_SOCKET_TYPE_SEQPACKET")]
4203 Seqpacket,
4204 #[doc(hidden)]
4205 __Unknown(i32),
4206}
4207
4208#[doc(hidden)]
4209impl IntoGlib for SocketType {
4210 type GlibType = ffi::GSocketType;
4211
4212 #[inline]
4213 fn into_glib(self) -> ffi::GSocketType {
4214 match self {
4215 Self::Invalid => ffi::G_SOCKET_TYPE_INVALID,
4216 Self::Stream => ffi::G_SOCKET_TYPE_STREAM,
4217 Self::Datagram => ffi::G_SOCKET_TYPE_DATAGRAM,
4218 Self::Seqpacket => ffi::G_SOCKET_TYPE_SEQPACKET,
4219 Self::__Unknown(value) => value,
4220 }
4221 }
4222}
4223
4224#[doc(hidden)]
4225impl FromGlib<ffi::GSocketType> for SocketType {
4226 #[inline]
4227 unsafe fn from_glib(value: ffi::GSocketType) -> Self {
4228 match value {
4229 ffi::G_SOCKET_TYPE_INVALID => Self::Invalid,
4230 ffi::G_SOCKET_TYPE_STREAM => Self::Stream,
4231 ffi::G_SOCKET_TYPE_DATAGRAM => Self::Datagram,
4232 ffi::G_SOCKET_TYPE_SEQPACKET => Self::Seqpacket,
4233 value => Self::__Unknown(value),
4234 }
4235 }
4236}
4237
4238impl StaticType for SocketType {
4239 #[inline]
4240 #[doc(alias = "g_socket_type_get_type")]
4241 fn static_type() -> glib::Type {
4242 unsafe { from_glib(ffi::g_socket_type_get_type()) }
4243 }
4244}
4245
4246impl glib::HasParamSpec for SocketType {
4247 type ParamSpec = glib::ParamSpecEnum;
4248 type SetValue = Self;
4249 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4250
4251 fn param_spec_builder() -> Self::BuilderFn {
4252 Self::ParamSpec::builder_with_default
4253 }
4254}
4255
4256impl glib::value::ValueType for SocketType {
4257 type Type = Self;
4258}
4259
4260unsafe impl<'a> glib::value::FromValue<'a> for SocketType {
4261 type Checker = glib::value::GenericValueTypeChecker<Self>;
4262
4263 #[inline]
4264 unsafe fn from_value(value: &'a glib::Value) -> Self {
4265 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4266 }
4267}
4268
4269impl ToValue for SocketType {
4270 #[inline]
4271 fn to_value(&self) -> glib::Value {
4272 let mut value = glib::Value::for_value_type::<Self>();
4273 unsafe {
4274 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4275 }
4276 value
4277 }
4278
4279 #[inline]
4280 fn value_type(&self) -> glib::Type {
4281 Self::static_type()
4282 }
4283}
4284
4285impl From<SocketType> for glib::Value {
4286 #[inline]
4287 fn from(v: SocketType) -> Self {
4288 ToValue::to_value(&v)
4289 }
4290}
4291
4292#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4294#[non_exhaustive]
4295#[doc(alias = "GTlsAuthenticationMode")]
4296pub enum TlsAuthenticationMode {
4297 #[doc(alias = "G_TLS_AUTHENTICATION_NONE")]
4299 None,
4300 #[doc(alias = "G_TLS_AUTHENTICATION_REQUESTED")]
4302 Requested,
4303 #[doc(alias = "G_TLS_AUTHENTICATION_REQUIRED")]
4305 Required,
4306 #[doc(hidden)]
4307 __Unknown(i32),
4308}
4309
4310#[doc(hidden)]
4311impl IntoGlib for TlsAuthenticationMode {
4312 type GlibType = ffi::GTlsAuthenticationMode;
4313
4314 #[inline]
4315 fn into_glib(self) -> ffi::GTlsAuthenticationMode {
4316 match self {
4317 Self::None => ffi::G_TLS_AUTHENTICATION_NONE,
4318 Self::Requested => ffi::G_TLS_AUTHENTICATION_REQUESTED,
4319 Self::Required => ffi::G_TLS_AUTHENTICATION_REQUIRED,
4320 Self::__Unknown(value) => value,
4321 }
4322 }
4323}
4324
4325#[doc(hidden)]
4326impl FromGlib<ffi::GTlsAuthenticationMode> for TlsAuthenticationMode {
4327 #[inline]
4328 unsafe fn from_glib(value: ffi::GTlsAuthenticationMode) -> Self {
4329 match value {
4330 ffi::G_TLS_AUTHENTICATION_NONE => Self::None,
4331 ffi::G_TLS_AUTHENTICATION_REQUESTED => Self::Requested,
4332 ffi::G_TLS_AUTHENTICATION_REQUIRED => Self::Required,
4333 value => Self::__Unknown(value),
4334 }
4335 }
4336}
4337
4338impl StaticType for TlsAuthenticationMode {
4339 #[inline]
4340 #[doc(alias = "g_tls_authentication_mode_get_type")]
4341 fn static_type() -> glib::Type {
4342 unsafe { from_glib(ffi::g_tls_authentication_mode_get_type()) }
4343 }
4344}
4345
4346impl glib::HasParamSpec for TlsAuthenticationMode {
4347 type ParamSpec = glib::ParamSpecEnum;
4348 type SetValue = Self;
4349 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4350
4351 fn param_spec_builder() -> Self::BuilderFn {
4352 Self::ParamSpec::builder_with_default
4353 }
4354}
4355
4356impl glib::value::ValueType for TlsAuthenticationMode {
4357 type Type = Self;
4358}
4359
4360unsafe impl<'a> glib::value::FromValue<'a> for TlsAuthenticationMode {
4361 type Checker = glib::value::GenericValueTypeChecker<Self>;
4362
4363 #[inline]
4364 unsafe fn from_value(value: &'a glib::Value) -> Self {
4365 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4366 }
4367}
4368
4369impl ToValue for TlsAuthenticationMode {
4370 #[inline]
4371 fn to_value(&self) -> glib::Value {
4372 let mut value = glib::Value::for_value_type::<Self>();
4373 unsafe {
4374 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4375 }
4376 value
4377 }
4378
4379 #[inline]
4380 fn value_type(&self) -> glib::Type {
4381 Self::static_type()
4382 }
4383}
4384
4385impl From<TlsAuthenticationMode> for glib::Value {
4386 #[inline]
4387 fn from(v: TlsAuthenticationMode) -> Self {
4388 ToValue::to_value(&v)
4389 }
4390}
4391
4392#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4396#[non_exhaustive]
4397#[doc(alias = "GTlsCertificateRequestFlags")]
4398pub enum TlsCertificateRequestFlags {
4399 #[doc(alias = "G_TLS_CERTIFICATE_REQUEST_NONE")]
4401 None,
4402 #[doc(hidden)]
4403 __Unknown(i32),
4404}
4405
4406#[doc(hidden)]
4407impl IntoGlib for TlsCertificateRequestFlags {
4408 type GlibType = ffi::GTlsCertificateRequestFlags;
4409
4410 #[inline]
4411 fn into_glib(self) -> ffi::GTlsCertificateRequestFlags {
4412 match self {
4413 Self::None => ffi::G_TLS_CERTIFICATE_REQUEST_NONE,
4414 Self::__Unknown(value) => value,
4415 }
4416 }
4417}
4418
4419#[doc(hidden)]
4420impl FromGlib<ffi::GTlsCertificateRequestFlags> for TlsCertificateRequestFlags {
4421 #[inline]
4422 unsafe fn from_glib(value: ffi::GTlsCertificateRequestFlags) -> Self {
4423 match value {
4424 ffi::G_TLS_CERTIFICATE_REQUEST_NONE => Self::None,
4425 value => Self::__Unknown(value),
4426 }
4427 }
4428}
4429
4430impl StaticType for TlsCertificateRequestFlags {
4431 #[inline]
4432 #[doc(alias = "g_tls_certificate_request_flags_get_type")]
4433 fn static_type() -> glib::Type {
4434 unsafe { from_glib(ffi::g_tls_certificate_request_flags_get_type()) }
4435 }
4436}
4437
4438impl glib::HasParamSpec for TlsCertificateRequestFlags {
4439 type ParamSpec = glib::ParamSpecEnum;
4440 type SetValue = Self;
4441 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4442
4443 fn param_spec_builder() -> Self::BuilderFn {
4444 Self::ParamSpec::builder_with_default
4445 }
4446}
4447
4448impl glib::value::ValueType for TlsCertificateRequestFlags {
4449 type Type = Self;
4450}
4451
4452unsafe impl<'a> glib::value::FromValue<'a> for TlsCertificateRequestFlags {
4453 type Checker = glib::value::GenericValueTypeChecker<Self>;
4454
4455 #[inline]
4456 unsafe fn from_value(value: &'a glib::Value) -> Self {
4457 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4458 }
4459}
4460
4461impl ToValue for TlsCertificateRequestFlags {
4462 #[inline]
4463 fn to_value(&self) -> glib::Value {
4464 let mut value = glib::Value::for_value_type::<Self>();
4465 unsafe {
4466 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4467 }
4468 value
4469 }
4470
4471 #[inline]
4472 fn value_type(&self) -> glib::Type {
4473 Self::static_type()
4474 }
4475}
4476
4477impl From<TlsCertificateRequestFlags> for glib::Value {
4478 #[inline]
4479 fn from(v: TlsCertificateRequestFlags) -> Self {
4480 ToValue::to_value(&v)
4481 }
4482}
4483
4484#[cfg(feature = "v2_66")]
4487#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4488#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4489#[non_exhaustive]
4490#[doc(alias = "GTlsChannelBindingError")]
4491pub enum TlsChannelBindingError {
4492 #[doc(alias = "G_TLS_CHANNEL_BINDING_ERROR_NOT_IMPLEMENTED")]
4496 NotImplemented,
4497 #[doc(alias = "G_TLS_CHANNEL_BINDING_ERROR_INVALID_STATE")]
4501 InvalidState,
4502 #[doc(alias = "G_TLS_CHANNEL_BINDING_ERROR_NOT_AVAILABLE")]
4507 NotAvailable,
4508 #[doc(alias = "G_TLS_CHANNEL_BINDING_ERROR_NOT_SUPPORTED")]
4513 NotSupported,
4514 #[doc(alias = "G_TLS_CHANNEL_BINDING_ERROR_GENERAL_ERROR")]
4517 GeneralError,
4518 #[doc(hidden)]
4519 __Unknown(i32),
4520}
4521
4522#[cfg(feature = "v2_66")]
4523#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4524#[doc(hidden)]
4525impl IntoGlib for TlsChannelBindingError {
4526 type GlibType = ffi::GTlsChannelBindingError;
4527
4528 #[inline]
4529 fn into_glib(self) -> ffi::GTlsChannelBindingError {
4530 match self {
4531 Self::NotImplemented => ffi::G_TLS_CHANNEL_BINDING_ERROR_NOT_IMPLEMENTED,
4532 Self::InvalidState => ffi::G_TLS_CHANNEL_BINDING_ERROR_INVALID_STATE,
4533 Self::NotAvailable => ffi::G_TLS_CHANNEL_BINDING_ERROR_NOT_AVAILABLE,
4534 Self::NotSupported => ffi::G_TLS_CHANNEL_BINDING_ERROR_NOT_SUPPORTED,
4535 Self::GeneralError => ffi::G_TLS_CHANNEL_BINDING_ERROR_GENERAL_ERROR,
4536 Self::__Unknown(value) => value,
4537 }
4538 }
4539}
4540
4541#[cfg(feature = "v2_66")]
4542#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4543#[doc(hidden)]
4544impl FromGlib<ffi::GTlsChannelBindingError> for TlsChannelBindingError {
4545 #[inline]
4546 unsafe fn from_glib(value: ffi::GTlsChannelBindingError) -> Self {
4547 match value {
4548 ffi::G_TLS_CHANNEL_BINDING_ERROR_NOT_IMPLEMENTED => Self::NotImplemented,
4549 ffi::G_TLS_CHANNEL_BINDING_ERROR_INVALID_STATE => Self::InvalidState,
4550 ffi::G_TLS_CHANNEL_BINDING_ERROR_NOT_AVAILABLE => Self::NotAvailable,
4551 ffi::G_TLS_CHANNEL_BINDING_ERROR_NOT_SUPPORTED => Self::NotSupported,
4552 ffi::G_TLS_CHANNEL_BINDING_ERROR_GENERAL_ERROR => Self::GeneralError,
4553 value => Self::__Unknown(value),
4554 }
4555 }
4556}
4557
4558#[cfg(feature = "v2_66")]
4559#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4560impl glib::error::ErrorDomain for TlsChannelBindingError {
4561 #[inline]
4562 fn domain() -> glib::Quark {
4563 unsafe { from_glib(ffi::g_tls_channel_binding_error_quark()) }
4564 }
4565
4566 #[inline]
4567 fn code(self) -> i32 {
4568 self.into_glib()
4569 }
4570
4571 #[inline]
4572 #[allow(clippy::match_single_binding)]
4573 fn from(code: i32) -> Option<Self> {
4574 match unsafe { from_glib(code) } {
4575 value => Some(value),
4576 }
4577 }
4578}
4579
4580#[cfg(feature = "v2_66")]
4581#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4582impl StaticType for TlsChannelBindingError {
4583 #[inline]
4584 #[doc(alias = "g_tls_channel_binding_error_get_type")]
4585 fn static_type() -> glib::Type {
4586 unsafe { from_glib(ffi::g_tls_channel_binding_error_get_type()) }
4587 }
4588}
4589
4590#[cfg(feature = "v2_66")]
4591#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4592impl glib::HasParamSpec for TlsChannelBindingError {
4593 type ParamSpec = glib::ParamSpecEnum;
4594 type SetValue = Self;
4595 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4596
4597 fn param_spec_builder() -> Self::BuilderFn {
4598 Self::ParamSpec::builder_with_default
4599 }
4600}
4601
4602#[cfg(feature = "v2_66")]
4603#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4604impl glib::value::ValueType for TlsChannelBindingError {
4605 type Type = Self;
4606}
4607
4608#[cfg(feature = "v2_66")]
4609#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4610unsafe impl<'a> glib::value::FromValue<'a> for TlsChannelBindingError {
4611 type Checker = glib::value::GenericValueTypeChecker<Self>;
4612
4613 #[inline]
4614 unsafe fn from_value(value: &'a glib::Value) -> Self {
4615 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4616 }
4617}
4618
4619#[cfg(feature = "v2_66")]
4620#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4621impl ToValue for TlsChannelBindingError {
4622 #[inline]
4623 fn to_value(&self) -> glib::Value {
4624 let mut value = glib::Value::for_value_type::<Self>();
4625 unsafe {
4626 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4627 }
4628 value
4629 }
4630
4631 #[inline]
4632 fn value_type(&self) -> glib::Type {
4633 Self::static_type()
4634 }
4635}
4636
4637#[cfg(feature = "v2_66")]
4638#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4639impl From<TlsChannelBindingError> for glib::Value {
4640 #[inline]
4641 fn from(v: TlsChannelBindingError) -> Self {
4642 ToValue::to_value(&v)
4643 }
4644}
4645
4646#[cfg(feature = "v2_66")]
4651#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4652#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4653#[non_exhaustive]
4654#[doc(alias = "GTlsChannelBindingType")]
4655pub enum TlsChannelBindingType {
4656 #[doc(alias = "G_TLS_CHANNEL_BINDING_TLS_UNIQUE")]
4659 Unique,
4660 #[doc(alias = "G_TLS_CHANNEL_BINDING_TLS_SERVER_END_POINT")]
4663 ServerEndPoint,
4664 #[cfg(feature = "v2_74")]
4667 #[cfg_attr(docsrs, doc(cfg(feature = "v2_74")))]
4668 #[doc(alias = "G_TLS_CHANNEL_BINDING_TLS_EXPORTER")]
4669 Exporter,
4670 #[doc(hidden)]
4671 __Unknown(i32),
4672}
4673
4674#[cfg(feature = "v2_66")]
4675#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4676#[doc(hidden)]
4677impl IntoGlib for TlsChannelBindingType {
4678 type GlibType = ffi::GTlsChannelBindingType;
4679
4680 #[inline]
4681 fn into_glib(self) -> ffi::GTlsChannelBindingType {
4682 match self {
4683 Self::Unique => ffi::G_TLS_CHANNEL_BINDING_TLS_UNIQUE,
4684 Self::ServerEndPoint => ffi::G_TLS_CHANNEL_BINDING_TLS_SERVER_END_POINT,
4685 #[cfg(feature = "v2_74")]
4686 Self::Exporter => ffi::G_TLS_CHANNEL_BINDING_TLS_EXPORTER,
4687 Self::__Unknown(value) => value,
4688 }
4689 }
4690}
4691
4692#[cfg(feature = "v2_66")]
4693#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4694#[doc(hidden)]
4695impl FromGlib<ffi::GTlsChannelBindingType> for TlsChannelBindingType {
4696 #[inline]
4697 unsafe fn from_glib(value: ffi::GTlsChannelBindingType) -> Self {
4698 match value {
4699 ffi::G_TLS_CHANNEL_BINDING_TLS_UNIQUE => Self::Unique,
4700 ffi::G_TLS_CHANNEL_BINDING_TLS_SERVER_END_POINT => Self::ServerEndPoint,
4701 #[cfg(feature = "v2_74")]
4702 ffi::G_TLS_CHANNEL_BINDING_TLS_EXPORTER => Self::Exporter,
4703 value => Self::__Unknown(value),
4704 }
4705 }
4706}
4707
4708#[cfg(feature = "v2_66")]
4709#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4710impl StaticType for TlsChannelBindingType {
4711 #[inline]
4712 #[doc(alias = "g_tls_channel_binding_type_get_type")]
4713 fn static_type() -> glib::Type {
4714 unsafe { from_glib(ffi::g_tls_channel_binding_type_get_type()) }
4715 }
4716}
4717
4718#[cfg(feature = "v2_66")]
4719#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4720impl glib::HasParamSpec for TlsChannelBindingType {
4721 type ParamSpec = glib::ParamSpecEnum;
4722 type SetValue = Self;
4723 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4724
4725 fn param_spec_builder() -> Self::BuilderFn {
4726 Self::ParamSpec::builder_with_default
4727 }
4728}
4729
4730#[cfg(feature = "v2_66")]
4731#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4732impl glib::value::ValueType for TlsChannelBindingType {
4733 type Type = Self;
4734}
4735
4736#[cfg(feature = "v2_66")]
4737#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4738unsafe impl<'a> glib::value::FromValue<'a> for TlsChannelBindingType {
4739 type Checker = glib::value::GenericValueTypeChecker<Self>;
4740
4741 #[inline]
4742 unsafe fn from_value(value: &'a glib::Value) -> Self {
4743 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4744 }
4745}
4746
4747#[cfg(feature = "v2_66")]
4748#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4749impl ToValue for TlsChannelBindingType {
4750 #[inline]
4751 fn to_value(&self) -> glib::Value {
4752 let mut value = glib::Value::for_value_type::<Self>();
4753 unsafe {
4754 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4755 }
4756 value
4757 }
4758
4759 #[inline]
4760 fn value_type(&self) -> glib::Type {
4761 Self::static_type()
4762 }
4763}
4764
4765#[cfg(feature = "v2_66")]
4766#[cfg_attr(docsrs, doc(cfg(feature = "v2_66")))]
4767impl From<TlsChannelBindingType> for glib::Value {
4768 #[inline]
4769 fn from(v: TlsChannelBindingType) -> Self {
4770 ToValue::to_value(&v)
4771 }
4772}
4773
4774#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4778#[non_exhaustive]
4779#[doc(alias = "GTlsDatabaseLookupFlags")]
4780pub enum TlsDatabaseLookupFlags {
4781 #[doc(alias = "G_TLS_DATABASE_LOOKUP_NONE")]
4783 None,
4784 #[doc(alias = "G_TLS_DATABASE_LOOKUP_KEYPAIR")]
4787 Keypair,
4788 #[doc(hidden)]
4789 __Unknown(i32),
4790}
4791
4792#[doc(hidden)]
4793impl IntoGlib for TlsDatabaseLookupFlags {
4794 type GlibType = ffi::GTlsDatabaseLookupFlags;
4795
4796 #[inline]
4797 fn into_glib(self) -> ffi::GTlsDatabaseLookupFlags {
4798 match self {
4799 Self::None => ffi::G_TLS_DATABASE_LOOKUP_NONE,
4800 Self::Keypair => ffi::G_TLS_DATABASE_LOOKUP_KEYPAIR,
4801 Self::__Unknown(value) => value,
4802 }
4803 }
4804}
4805
4806#[doc(hidden)]
4807impl FromGlib<ffi::GTlsDatabaseLookupFlags> for TlsDatabaseLookupFlags {
4808 #[inline]
4809 unsafe fn from_glib(value: ffi::GTlsDatabaseLookupFlags) -> Self {
4810 match value {
4811 ffi::G_TLS_DATABASE_LOOKUP_NONE => Self::None,
4812 ffi::G_TLS_DATABASE_LOOKUP_KEYPAIR => Self::Keypair,
4813 value => Self::__Unknown(value),
4814 }
4815 }
4816}
4817
4818impl StaticType for TlsDatabaseLookupFlags {
4819 #[inline]
4820 #[doc(alias = "g_tls_database_lookup_flags_get_type")]
4821 fn static_type() -> glib::Type {
4822 unsafe { from_glib(ffi::g_tls_database_lookup_flags_get_type()) }
4823 }
4824}
4825
4826impl glib::HasParamSpec for TlsDatabaseLookupFlags {
4827 type ParamSpec = glib::ParamSpecEnum;
4828 type SetValue = Self;
4829 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4830
4831 fn param_spec_builder() -> Self::BuilderFn {
4832 Self::ParamSpec::builder_with_default
4833 }
4834}
4835
4836impl glib::value::ValueType for TlsDatabaseLookupFlags {
4837 type Type = Self;
4838}
4839
4840unsafe impl<'a> glib::value::FromValue<'a> for TlsDatabaseLookupFlags {
4841 type Checker = glib::value::GenericValueTypeChecker<Self>;
4842
4843 #[inline]
4844 unsafe fn from_value(value: &'a glib::Value) -> Self {
4845 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
4846 }
4847}
4848
4849impl ToValue for TlsDatabaseLookupFlags {
4850 #[inline]
4851 fn to_value(&self) -> glib::Value {
4852 let mut value = glib::Value::for_value_type::<Self>();
4853 unsafe {
4854 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
4855 }
4856 value
4857 }
4858
4859 #[inline]
4860 fn value_type(&self) -> glib::Type {
4861 Self::static_type()
4862 }
4863}
4864
4865impl From<TlsDatabaseLookupFlags> for glib::Value {
4866 #[inline]
4867 fn from(v: TlsDatabaseLookupFlags) -> Self {
4868 ToValue::to_value(&v)
4869 }
4870}
4871
4872#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
4875#[non_exhaustive]
4876#[doc(alias = "GTlsError")]
4877pub enum TlsError {
4878 #[doc(alias = "G_TLS_ERROR_UNAVAILABLE")]
4880 Unavailable,
4881 #[doc(alias = "G_TLS_ERROR_MISC")]
4883 Misc,
4884 #[doc(alias = "G_TLS_ERROR_BAD_CERTIFICATE")]
4887 BadCertificate,
4888 #[doc(alias = "G_TLS_ERROR_NOT_TLS")]
4891 NotTls,
4892 #[doc(alias = "G_TLS_ERROR_HANDSHAKE")]
4895 Handshake,
4896 #[doc(alias = "G_TLS_ERROR_CERTIFICATE_REQUIRED")]
4900 CertificateRequired,
4901 #[doc(alias = "G_TLS_ERROR_EOF")]
4905 Eof,
4906 #[doc(alias = "G_TLS_ERROR_INAPPROPRIATE_FALLBACK")]
4910 InappropriateFallback,
4911 #[cfg(feature = "v2_72")]
4914 #[cfg_attr(docsrs, doc(cfg(feature = "v2_72")))]
4915 #[doc(alias = "G_TLS_ERROR_BAD_CERTIFICATE_PASSWORD")]
4916 BadCertificatePassword,
4917 #[doc(hidden)]
4918 __Unknown(i32),
4919}
4920
4921#[doc(hidden)]
4922impl IntoGlib for TlsError {
4923 type GlibType = ffi::GTlsError;
4924
4925 #[inline]
4926 fn into_glib(self) -> ffi::GTlsError {
4927 match self {
4928 Self::Unavailable => ffi::G_TLS_ERROR_UNAVAILABLE,
4929 Self::Misc => ffi::G_TLS_ERROR_MISC,
4930 Self::BadCertificate => ffi::G_TLS_ERROR_BAD_CERTIFICATE,
4931 Self::NotTls => ffi::G_TLS_ERROR_NOT_TLS,
4932 Self::Handshake => ffi::G_TLS_ERROR_HANDSHAKE,
4933 Self::CertificateRequired => ffi::G_TLS_ERROR_CERTIFICATE_REQUIRED,
4934 Self::Eof => ffi::G_TLS_ERROR_EOF,
4935 Self::InappropriateFallback => ffi::G_TLS_ERROR_INAPPROPRIATE_FALLBACK,
4936 #[cfg(feature = "v2_72")]
4937 Self::BadCertificatePassword => ffi::G_TLS_ERROR_BAD_CERTIFICATE_PASSWORD,
4938 Self::__Unknown(value) => value,
4939 }
4940 }
4941}
4942
4943#[doc(hidden)]
4944impl FromGlib<ffi::GTlsError> for TlsError {
4945 #[inline]
4946 unsafe fn from_glib(value: ffi::GTlsError) -> Self {
4947 match value {
4948 ffi::G_TLS_ERROR_UNAVAILABLE => Self::Unavailable,
4949 ffi::G_TLS_ERROR_MISC => Self::Misc,
4950 ffi::G_TLS_ERROR_BAD_CERTIFICATE => Self::BadCertificate,
4951 ffi::G_TLS_ERROR_NOT_TLS => Self::NotTls,
4952 ffi::G_TLS_ERROR_HANDSHAKE => Self::Handshake,
4953 ffi::G_TLS_ERROR_CERTIFICATE_REQUIRED => Self::CertificateRequired,
4954 ffi::G_TLS_ERROR_EOF => Self::Eof,
4955 ffi::G_TLS_ERROR_INAPPROPRIATE_FALLBACK => Self::InappropriateFallback,
4956 #[cfg(feature = "v2_72")]
4957 ffi::G_TLS_ERROR_BAD_CERTIFICATE_PASSWORD => Self::BadCertificatePassword,
4958 value => Self::__Unknown(value),
4959 }
4960 }
4961}
4962
4963impl glib::error::ErrorDomain for TlsError {
4964 #[inline]
4965 fn domain() -> glib::Quark {
4966 unsafe { from_glib(ffi::g_tls_error_quark()) }
4967 }
4968
4969 #[inline]
4970 fn code(self) -> i32 {
4971 self.into_glib()
4972 }
4973
4974 #[inline]
4975 #[allow(clippy::match_single_binding)]
4976 fn from(code: i32) -> Option<Self> {
4977 match unsafe { from_glib(code) } {
4978 value => Some(value),
4979 }
4980 }
4981}
4982
4983impl StaticType for TlsError {
4984 #[inline]
4985 #[doc(alias = "g_tls_error_get_type")]
4986 fn static_type() -> glib::Type {
4987 unsafe { from_glib(ffi::g_tls_error_get_type()) }
4988 }
4989}
4990
4991impl glib::HasParamSpec for TlsError {
4992 type ParamSpec = glib::ParamSpecEnum;
4993 type SetValue = Self;
4994 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
4995
4996 fn param_spec_builder() -> Self::BuilderFn {
4997 Self::ParamSpec::builder_with_default
4998 }
4999}
5000
5001impl glib::value::ValueType for TlsError {
5002 type Type = Self;
5003}
5004
5005unsafe impl<'a> glib::value::FromValue<'a> for TlsError {
5006 type Checker = glib::value::GenericValueTypeChecker<Self>;
5007
5008 #[inline]
5009 unsafe fn from_value(value: &'a glib::Value) -> Self {
5010 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5011 }
5012}
5013
5014impl ToValue for TlsError {
5015 #[inline]
5016 fn to_value(&self) -> glib::Value {
5017 let mut value = glib::Value::for_value_type::<Self>();
5018 unsafe {
5019 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5020 }
5021 value
5022 }
5023
5024 #[inline]
5025 fn value_type(&self) -> glib::Type {
5026 Self::static_type()
5027 }
5028}
5029
5030impl From<TlsError> for glib::Value {
5031 #[inline]
5032 fn from(v: TlsError) -> Self {
5033 ToValue::to_value(&v)
5034 }
5035}
5036
5037#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5040#[non_exhaustive]
5041#[doc(alias = "GTlsInteractionResult")]
5042pub enum TlsInteractionResult {
5043 #[doc(alias = "G_TLS_INTERACTION_UNHANDLED")]
5046 Unhandled,
5047 #[doc(alias = "G_TLS_INTERACTION_HANDLED")]
5050 Handled,
5051 #[doc(alias = "G_TLS_INTERACTION_FAILED")]
5054 Failed,
5055 #[doc(hidden)]
5056 __Unknown(i32),
5057}
5058
5059#[doc(hidden)]
5060impl IntoGlib for TlsInteractionResult {
5061 type GlibType = ffi::GTlsInteractionResult;
5062
5063 #[inline]
5064 fn into_glib(self) -> ffi::GTlsInteractionResult {
5065 match self {
5066 Self::Unhandled => ffi::G_TLS_INTERACTION_UNHANDLED,
5067 Self::Handled => ffi::G_TLS_INTERACTION_HANDLED,
5068 Self::Failed => ffi::G_TLS_INTERACTION_FAILED,
5069 Self::__Unknown(value) => value,
5070 }
5071 }
5072}
5073
5074#[doc(hidden)]
5075impl FromGlib<ffi::GTlsInteractionResult> for TlsInteractionResult {
5076 #[inline]
5077 unsafe fn from_glib(value: ffi::GTlsInteractionResult) -> Self {
5078 match value {
5079 ffi::G_TLS_INTERACTION_UNHANDLED => Self::Unhandled,
5080 ffi::G_TLS_INTERACTION_HANDLED => Self::Handled,
5081 ffi::G_TLS_INTERACTION_FAILED => Self::Failed,
5082 value => Self::__Unknown(value),
5083 }
5084 }
5085}
5086
5087impl StaticType for TlsInteractionResult {
5088 #[inline]
5089 #[doc(alias = "g_tls_interaction_result_get_type")]
5090 fn static_type() -> glib::Type {
5091 unsafe { from_glib(ffi::g_tls_interaction_result_get_type()) }
5092 }
5093}
5094
5095impl glib::HasParamSpec for TlsInteractionResult {
5096 type ParamSpec = glib::ParamSpecEnum;
5097 type SetValue = Self;
5098 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5099
5100 fn param_spec_builder() -> Self::BuilderFn {
5101 Self::ParamSpec::builder_with_default
5102 }
5103}
5104
5105impl glib::value::ValueType for TlsInteractionResult {
5106 type Type = Self;
5107}
5108
5109unsafe impl<'a> glib::value::FromValue<'a> for TlsInteractionResult {
5110 type Checker = glib::value::GenericValueTypeChecker<Self>;
5111
5112 #[inline]
5113 unsafe fn from_value(value: &'a glib::Value) -> Self {
5114 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5115 }
5116}
5117
5118impl ToValue for TlsInteractionResult {
5119 #[inline]
5120 fn to_value(&self) -> glib::Value {
5121 let mut value = glib::Value::for_value_type::<Self>();
5122 unsafe {
5123 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5124 }
5125 value
5126 }
5127
5128 #[inline]
5129 fn value_type(&self) -> glib::Type {
5130 Self::static_type()
5131 }
5132}
5133
5134impl From<TlsInteractionResult> for glib::Value {
5135 #[inline]
5136 fn from(v: TlsInteractionResult) -> Self {
5137 ToValue::to_value(&v)
5138 }
5139}
5140
5141#[cfg(feature = "v2_70")]
5151#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
5152#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5153#[non_exhaustive]
5154#[doc(alias = "GTlsProtocolVersion")]
5155pub enum TlsProtocolVersion {
5156 #[doc(alias = "G_TLS_PROTOCOL_VERSION_UNKNOWN")]
5158 Unknown,
5159 #[doc(alias = "G_TLS_PROTOCOL_VERSION_SSL_3_0")]
5161 Ssl30,
5162 #[doc(alias = "G_TLS_PROTOCOL_VERSION_TLS_1_0")]
5164 Tls10,
5165 #[doc(alias = "G_TLS_PROTOCOL_VERSION_TLS_1_1")]
5167 Tls11,
5168 #[doc(alias = "G_TLS_PROTOCOL_VERSION_TLS_1_2")]
5170 Tls12,
5171 #[doc(alias = "G_TLS_PROTOCOL_VERSION_TLS_1_3")]
5173 Tls13,
5174 #[doc(alias = "G_TLS_PROTOCOL_VERSION_DTLS_1_0")]
5176 Dtls10,
5177 #[doc(alias = "G_TLS_PROTOCOL_VERSION_DTLS_1_2")]
5179 Dtls12,
5180 #[doc(hidden)]
5181 __Unknown(i32),
5182}
5183
5184#[cfg(feature = "v2_70")]
5185#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
5186#[doc(hidden)]
5187impl IntoGlib for TlsProtocolVersion {
5188 type GlibType = ffi::GTlsProtocolVersion;
5189
5190 #[inline]
5191 fn into_glib(self) -> ffi::GTlsProtocolVersion {
5192 match self {
5193 Self::Unknown => ffi::G_TLS_PROTOCOL_VERSION_UNKNOWN,
5194 Self::Ssl30 => ffi::G_TLS_PROTOCOL_VERSION_SSL_3_0,
5195 Self::Tls10 => ffi::G_TLS_PROTOCOL_VERSION_TLS_1_0,
5196 Self::Tls11 => ffi::G_TLS_PROTOCOL_VERSION_TLS_1_1,
5197 Self::Tls12 => ffi::G_TLS_PROTOCOL_VERSION_TLS_1_2,
5198 Self::Tls13 => ffi::G_TLS_PROTOCOL_VERSION_TLS_1_3,
5199 Self::Dtls10 => ffi::G_TLS_PROTOCOL_VERSION_DTLS_1_0,
5200 Self::Dtls12 => ffi::G_TLS_PROTOCOL_VERSION_DTLS_1_2,
5201 Self::__Unknown(value) => value,
5202 }
5203 }
5204}
5205
5206#[cfg(feature = "v2_70")]
5207#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
5208#[doc(hidden)]
5209impl FromGlib<ffi::GTlsProtocolVersion> for TlsProtocolVersion {
5210 #[inline]
5211 unsafe fn from_glib(value: ffi::GTlsProtocolVersion) -> Self {
5212 match value {
5213 ffi::G_TLS_PROTOCOL_VERSION_UNKNOWN => Self::Unknown,
5214 ffi::G_TLS_PROTOCOL_VERSION_SSL_3_0 => Self::Ssl30,
5215 ffi::G_TLS_PROTOCOL_VERSION_TLS_1_0 => Self::Tls10,
5216 ffi::G_TLS_PROTOCOL_VERSION_TLS_1_1 => Self::Tls11,
5217 ffi::G_TLS_PROTOCOL_VERSION_TLS_1_2 => Self::Tls12,
5218 ffi::G_TLS_PROTOCOL_VERSION_TLS_1_3 => Self::Tls13,
5219 ffi::G_TLS_PROTOCOL_VERSION_DTLS_1_0 => Self::Dtls10,
5220 ffi::G_TLS_PROTOCOL_VERSION_DTLS_1_2 => Self::Dtls12,
5221 value => Self::__Unknown(value),
5222 }
5223 }
5224}
5225
5226#[cfg(feature = "v2_70")]
5227#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
5228impl StaticType for TlsProtocolVersion {
5229 #[inline]
5230 #[doc(alias = "g_tls_protocol_version_get_type")]
5231 fn static_type() -> glib::Type {
5232 unsafe { from_glib(ffi::g_tls_protocol_version_get_type()) }
5233 }
5234}
5235
5236#[cfg(feature = "v2_70")]
5237#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
5238impl glib::HasParamSpec for TlsProtocolVersion {
5239 type ParamSpec = glib::ParamSpecEnum;
5240 type SetValue = Self;
5241 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5242
5243 fn param_spec_builder() -> Self::BuilderFn {
5244 Self::ParamSpec::builder_with_default
5245 }
5246}
5247
5248#[cfg(feature = "v2_70")]
5249#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
5250impl glib::value::ValueType for TlsProtocolVersion {
5251 type Type = Self;
5252}
5253
5254#[cfg(feature = "v2_70")]
5255#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
5256unsafe impl<'a> glib::value::FromValue<'a> for TlsProtocolVersion {
5257 type Checker = glib::value::GenericValueTypeChecker<Self>;
5258
5259 #[inline]
5260 unsafe fn from_value(value: &'a glib::Value) -> Self {
5261 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5262 }
5263}
5264
5265#[cfg(feature = "v2_70")]
5266#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
5267impl ToValue for TlsProtocolVersion {
5268 #[inline]
5269 fn to_value(&self) -> glib::Value {
5270 let mut value = glib::Value::for_value_type::<Self>();
5271 unsafe {
5272 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5273 }
5274 value
5275 }
5276
5277 #[inline]
5278 fn value_type(&self) -> glib::Type {
5279 Self::static_type()
5280 }
5281}
5282
5283#[cfg(feature = "v2_70")]
5284#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
5285impl From<TlsProtocolVersion> for glib::Value {
5286 #[inline]
5287 fn from(v: TlsProtocolVersion) -> Self {
5288 ToValue::to_value(&v)
5289 }
5290}
5291
5292#[cfg_attr(feature = "v2_60", deprecated = "Since 2.60")]
5301#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5302#[non_exhaustive]
5303#[doc(alias = "GTlsRehandshakeMode")]
5304pub enum TlsRehandshakeMode {
5305 #[doc(alias = "G_TLS_REHANDSHAKE_NEVER")]
5307 Never,
5308 #[doc(alias = "G_TLS_REHANDSHAKE_SAFELY")]
5310 Safely,
5311 #[doc(alias = "G_TLS_REHANDSHAKE_UNSAFELY")]
5313 Unsafely,
5314 #[doc(hidden)]
5315 __Unknown(i32),
5316}
5317
5318#[allow(deprecated)]
5319#[doc(hidden)]
5320impl IntoGlib for TlsRehandshakeMode {
5321 type GlibType = ffi::GTlsRehandshakeMode;
5322
5323 #[inline]
5324 fn into_glib(self) -> ffi::GTlsRehandshakeMode {
5325 match self {
5326 Self::Never => ffi::G_TLS_REHANDSHAKE_NEVER,
5327 Self::Safely => ffi::G_TLS_REHANDSHAKE_SAFELY,
5328 Self::Unsafely => ffi::G_TLS_REHANDSHAKE_UNSAFELY,
5329 Self::__Unknown(value) => value,
5330 }
5331 }
5332}
5333
5334#[allow(deprecated)]
5335#[doc(hidden)]
5336impl FromGlib<ffi::GTlsRehandshakeMode> for TlsRehandshakeMode {
5337 #[inline]
5338 unsafe fn from_glib(value: ffi::GTlsRehandshakeMode) -> Self {
5339 match value {
5340 ffi::G_TLS_REHANDSHAKE_NEVER => Self::Never,
5341 ffi::G_TLS_REHANDSHAKE_SAFELY => Self::Safely,
5342 ffi::G_TLS_REHANDSHAKE_UNSAFELY => Self::Unsafely,
5343 value => Self::__Unknown(value),
5344 }
5345 }
5346}
5347
5348#[allow(deprecated)]
5349impl StaticType for TlsRehandshakeMode {
5350 #[inline]
5351 #[doc(alias = "g_tls_rehandshake_mode_get_type")]
5352 fn static_type() -> glib::Type {
5353 unsafe { from_glib(ffi::g_tls_rehandshake_mode_get_type()) }
5354 }
5355}
5356
5357#[allow(deprecated)]
5358impl glib::HasParamSpec for TlsRehandshakeMode {
5359 type ParamSpec = glib::ParamSpecEnum;
5360 type SetValue = Self;
5361 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5362
5363 fn param_spec_builder() -> Self::BuilderFn {
5364 Self::ParamSpec::builder_with_default
5365 }
5366}
5367
5368#[allow(deprecated)]
5369impl glib::value::ValueType for TlsRehandshakeMode {
5370 type Type = Self;
5371}
5372
5373#[allow(deprecated)]
5374unsafe impl<'a> glib::value::FromValue<'a> for TlsRehandshakeMode {
5375 type Checker = glib::value::GenericValueTypeChecker<Self>;
5376
5377 #[inline]
5378 unsafe fn from_value(value: &'a glib::Value) -> Self {
5379 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5380 }
5381}
5382
5383#[allow(deprecated)]
5384impl ToValue for TlsRehandshakeMode {
5385 #[inline]
5386 fn to_value(&self) -> glib::Value {
5387 let mut value = glib::Value::for_value_type::<Self>();
5388 unsafe {
5389 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5390 }
5391 value
5392 }
5393
5394 #[inline]
5395 fn value_type(&self) -> glib::Type {
5396 Self::static_type()
5397 }
5398}
5399
5400#[allow(deprecated)]
5401impl From<TlsRehandshakeMode> for glib::Value {
5402 #[inline]
5403 fn from(v: TlsRehandshakeMode) -> Self {
5404 ToValue::to_value(&v)
5405 }
5406}
5407
5408#[cfg(unix)]
5422#[cfg_attr(docsrs, doc(cfg(unix)))]
5423#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5424#[non_exhaustive]
5425#[doc(alias = "GUnixSocketAddressType")]
5426pub enum UnixSocketAddressType {
5427 #[doc(alias = "G_UNIX_SOCKET_ADDRESS_INVALID")]
5429 Invalid,
5430 #[doc(alias = "G_UNIX_SOCKET_ADDRESS_ANONYMOUS")]
5432 Anonymous,
5433 #[doc(alias = "G_UNIX_SOCKET_ADDRESS_PATH")]
5435 Path,
5436 #[doc(alias = "G_UNIX_SOCKET_ADDRESS_ABSTRACT")]
5438 Abstract,
5439 #[doc(alias = "G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED")]
5442 AbstractPadded,
5443 #[doc(hidden)]
5444 __Unknown(i32),
5445}
5446
5447#[cfg(unix)]
5448#[doc(hidden)]
5449impl IntoGlib for UnixSocketAddressType {
5450 type GlibType = ffi::GUnixSocketAddressType;
5451
5452 #[inline]
5453 fn into_glib(self) -> ffi::GUnixSocketAddressType {
5454 match self {
5455 Self::Invalid => ffi::G_UNIX_SOCKET_ADDRESS_INVALID,
5456 Self::Anonymous => ffi::G_UNIX_SOCKET_ADDRESS_ANONYMOUS,
5457 Self::Path => ffi::G_UNIX_SOCKET_ADDRESS_PATH,
5458 Self::Abstract => ffi::G_UNIX_SOCKET_ADDRESS_ABSTRACT,
5459 Self::AbstractPadded => ffi::G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED,
5460 Self::__Unknown(value) => value,
5461 }
5462 }
5463}
5464
5465#[cfg(unix)]
5466#[doc(hidden)]
5467impl FromGlib<ffi::GUnixSocketAddressType> for UnixSocketAddressType {
5468 #[inline]
5469 unsafe fn from_glib(value: ffi::GUnixSocketAddressType) -> Self {
5470 match value {
5471 ffi::G_UNIX_SOCKET_ADDRESS_INVALID => Self::Invalid,
5472 ffi::G_UNIX_SOCKET_ADDRESS_ANONYMOUS => Self::Anonymous,
5473 ffi::G_UNIX_SOCKET_ADDRESS_PATH => Self::Path,
5474 ffi::G_UNIX_SOCKET_ADDRESS_ABSTRACT => Self::Abstract,
5475 ffi::G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED => Self::AbstractPadded,
5476 value => Self::__Unknown(value),
5477 }
5478 }
5479}
5480
5481#[cfg(unix)]
5482impl StaticType for UnixSocketAddressType {
5483 #[inline]
5484 #[doc(alias = "g_unix_socket_address_type_get_type")]
5485 fn static_type() -> glib::Type {
5486 unsafe { from_glib(ffi::g_unix_socket_address_type_get_type()) }
5487 }
5488}
5489
5490#[cfg(unix)]
5491impl glib::HasParamSpec for UnixSocketAddressType {
5492 type ParamSpec = glib::ParamSpecEnum;
5493 type SetValue = Self;
5494 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5495
5496 fn param_spec_builder() -> Self::BuilderFn {
5497 Self::ParamSpec::builder_with_default
5498 }
5499}
5500
5501#[cfg(unix)]
5502impl glib::value::ValueType for UnixSocketAddressType {
5503 type Type = Self;
5504}
5505
5506#[cfg(unix)]
5507unsafe impl<'a> glib::value::FromValue<'a> for UnixSocketAddressType {
5508 type Checker = glib::value::GenericValueTypeChecker<Self>;
5509
5510 #[inline]
5511 unsafe fn from_value(value: &'a glib::Value) -> Self {
5512 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5513 }
5514}
5515
5516#[cfg(unix)]
5517impl ToValue for UnixSocketAddressType {
5518 #[inline]
5519 fn to_value(&self) -> glib::Value {
5520 let mut value = glib::Value::for_value_type::<Self>();
5521 unsafe {
5522 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5523 }
5524 value
5525 }
5526
5527 #[inline]
5528 fn value_type(&self) -> glib::Type {
5529 Self::static_type()
5530 }
5531}
5532
5533#[cfg(unix)]
5534impl From<UnixSocketAddressType> for glib::Value {
5535 #[inline]
5536 fn from(v: UnixSocketAddressType) -> Self {
5537 ToValue::to_value(&v)
5538 }
5539}
5540
5541#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
5544#[non_exhaustive]
5545#[doc(alias = "GZlibCompressorFormat")]
5546pub enum ZlibCompressorFormat {
5547 #[doc(alias = "G_ZLIB_COMPRESSOR_FORMAT_ZLIB")]
5549 Zlib,
5550 #[doc(alias = "G_ZLIB_COMPRESSOR_FORMAT_GZIP")]
5552 Gzip,
5553 #[doc(alias = "G_ZLIB_COMPRESSOR_FORMAT_RAW")]
5555 Raw,
5556 #[doc(hidden)]
5557 __Unknown(i32),
5558}
5559
5560#[doc(hidden)]
5561impl IntoGlib for ZlibCompressorFormat {
5562 type GlibType = ffi::GZlibCompressorFormat;
5563
5564 #[inline]
5565 fn into_glib(self) -> ffi::GZlibCompressorFormat {
5566 match self {
5567 Self::Zlib => ffi::G_ZLIB_COMPRESSOR_FORMAT_ZLIB,
5568 Self::Gzip => ffi::G_ZLIB_COMPRESSOR_FORMAT_GZIP,
5569 Self::Raw => ffi::G_ZLIB_COMPRESSOR_FORMAT_RAW,
5570 Self::__Unknown(value) => value,
5571 }
5572 }
5573}
5574
5575#[doc(hidden)]
5576impl FromGlib<ffi::GZlibCompressorFormat> for ZlibCompressorFormat {
5577 #[inline]
5578 unsafe fn from_glib(value: ffi::GZlibCompressorFormat) -> Self {
5579 match value {
5580 ffi::G_ZLIB_COMPRESSOR_FORMAT_ZLIB => Self::Zlib,
5581 ffi::G_ZLIB_COMPRESSOR_FORMAT_GZIP => Self::Gzip,
5582 ffi::G_ZLIB_COMPRESSOR_FORMAT_RAW => Self::Raw,
5583 value => Self::__Unknown(value),
5584 }
5585 }
5586}
5587
5588impl StaticType for ZlibCompressorFormat {
5589 #[inline]
5590 #[doc(alias = "g_zlib_compressor_format_get_type")]
5591 fn static_type() -> glib::Type {
5592 unsafe { from_glib(ffi::g_zlib_compressor_format_get_type()) }
5593 }
5594}
5595
5596impl glib::HasParamSpec for ZlibCompressorFormat {
5597 type ParamSpec = glib::ParamSpecEnum;
5598 type SetValue = Self;
5599 type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>;
5600
5601 fn param_spec_builder() -> Self::BuilderFn {
5602 Self::ParamSpec::builder_with_default
5603 }
5604}
5605
5606impl glib::value::ValueType for ZlibCompressorFormat {
5607 type Type = Self;
5608}
5609
5610unsafe impl<'a> glib::value::FromValue<'a> for ZlibCompressorFormat {
5611 type Checker = glib::value::GenericValueTypeChecker<Self>;
5612
5613 #[inline]
5614 unsafe fn from_value(value: &'a glib::Value) -> Self {
5615 from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0))
5616 }
5617}
5618
5619impl ToValue for ZlibCompressorFormat {
5620 #[inline]
5621 fn to_value(&self) -> glib::Value {
5622 let mut value = glib::Value::for_value_type::<Self>();
5623 unsafe {
5624 glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib());
5625 }
5626 value
5627 }
5628
5629 #[inline]
5630 fn value_type(&self) -> glib::Type {
5631 Self::static_type()
5632 }
5633}
5634
5635impl From<ZlibCompressorFormat> for glib::Value {
5636 #[inline]
5637 fn from(v: ZlibCompressorFormat) -> Self {
5638 ToValue::to_value(&v)
5639 }
5640}