gio/auto/
enums.rs

1// This file was generated by gir (https://github.com/gtk-rs/gir)
2// from gir-files (https://github.com/gtk-rs/gir-files)
3// DO NOT EDIT
4
5use gio_sys;
6use glib::error::ErrorDomain;
7use glib::translate::*;
8use glib::value::FromValue;
9use glib::value::FromValueOptional;
10use glib::value::SetValue;
11use glib::value::Value;
12use glib::Quark;
13use glib::StaticType;
14use glib::Type;
15use gobject_sys;
16use std::fmt;
17
18#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
19pub enum ConverterResult {
20    Error,
21    Converted,
22    Finished,
23    Flushed,
24    #[doc(hidden)]
25    __Unknown(i32),
26}
27
28impl fmt::Display for ConverterResult {
29    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
30        write!(
31            f,
32            "ConverterResult::{}",
33            match *self {
34                ConverterResult::Error => "Error",
35                ConverterResult::Converted => "Converted",
36                ConverterResult::Finished => "Finished",
37                ConverterResult::Flushed => "Flushed",
38                _ => "Unknown",
39            }
40        )
41    }
42}
43
44#[doc(hidden)]
45impl ToGlib for ConverterResult {
46    type GlibType = gio_sys::GConverterResult;
47
48    fn to_glib(&self) -> gio_sys::GConverterResult {
49        match *self {
50            ConverterResult::Error => gio_sys::G_CONVERTER_ERROR,
51            ConverterResult::Converted => gio_sys::G_CONVERTER_CONVERTED,
52            ConverterResult::Finished => gio_sys::G_CONVERTER_FINISHED,
53            ConverterResult::Flushed => gio_sys::G_CONVERTER_FLUSHED,
54            ConverterResult::__Unknown(value) => value,
55        }
56    }
57}
58
59#[doc(hidden)]
60impl FromGlib<gio_sys::GConverterResult> for ConverterResult {
61    fn from_glib(value: gio_sys::GConverterResult) -> Self {
62        match value {
63            0 => ConverterResult::Error,
64            1 => ConverterResult::Converted,
65            2 => ConverterResult::Finished,
66            3 => ConverterResult::Flushed,
67            value => ConverterResult::__Unknown(value),
68        }
69    }
70}
71
72impl StaticType for ConverterResult {
73    fn static_type() -> Type {
74        unsafe { from_glib(gio_sys::g_converter_result_get_type()) }
75    }
76}
77
78impl<'a> FromValueOptional<'a> for ConverterResult {
79    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
80        Some(FromValue::from_value(value))
81    }
82}
83
84impl<'a> FromValue<'a> for ConverterResult {
85    unsafe fn from_value(value: &Value) -> Self {
86        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
87    }
88}
89
90impl SetValue for ConverterResult {
91    unsafe fn set_value(value: &mut Value, this: &Self) {
92        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
93    }
94}
95
96#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
97pub enum CredentialsType {
98    Invalid,
99    LinuxUcred,
100    FreebsdCmsgcred,
101    OpenbsdSockpeercred,
102    SolarisUcred,
103    NetbsdUnpcbid,
104    #[doc(hidden)]
105    __Unknown(i32),
106}
107
108impl fmt::Display for CredentialsType {
109    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
110        write!(
111            f,
112            "CredentialsType::{}",
113            match *self {
114                CredentialsType::Invalid => "Invalid",
115                CredentialsType::LinuxUcred => "LinuxUcred",
116                CredentialsType::FreebsdCmsgcred => "FreebsdCmsgcred",
117                CredentialsType::OpenbsdSockpeercred => "OpenbsdSockpeercred",
118                CredentialsType::SolarisUcred => "SolarisUcred",
119                CredentialsType::NetbsdUnpcbid => "NetbsdUnpcbid",
120                _ => "Unknown",
121            }
122        )
123    }
124}
125
126#[doc(hidden)]
127impl ToGlib for CredentialsType {
128    type GlibType = gio_sys::GCredentialsType;
129
130    fn to_glib(&self) -> gio_sys::GCredentialsType {
131        match *self {
132            CredentialsType::Invalid => gio_sys::G_CREDENTIALS_TYPE_INVALID,
133            CredentialsType::LinuxUcred => gio_sys::G_CREDENTIALS_TYPE_LINUX_UCRED,
134            CredentialsType::FreebsdCmsgcred => gio_sys::G_CREDENTIALS_TYPE_FREEBSD_CMSGCRED,
135            CredentialsType::OpenbsdSockpeercred => {
136                gio_sys::G_CREDENTIALS_TYPE_OPENBSD_SOCKPEERCRED
137            }
138            CredentialsType::SolarisUcred => gio_sys::G_CREDENTIALS_TYPE_SOLARIS_UCRED,
139            CredentialsType::NetbsdUnpcbid => gio_sys::G_CREDENTIALS_TYPE_NETBSD_UNPCBID,
140            CredentialsType::__Unknown(value) => value,
141        }
142    }
143}
144
145#[doc(hidden)]
146impl FromGlib<gio_sys::GCredentialsType> for CredentialsType {
147    fn from_glib(value: gio_sys::GCredentialsType) -> Self {
148        match value {
149            0 => CredentialsType::Invalid,
150            1 => CredentialsType::LinuxUcred,
151            2 => CredentialsType::FreebsdCmsgcred,
152            3 => CredentialsType::OpenbsdSockpeercred,
153            4 => CredentialsType::SolarisUcred,
154            5 => CredentialsType::NetbsdUnpcbid,
155            value => CredentialsType::__Unknown(value),
156        }
157    }
158}
159
160impl StaticType for CredentialsType {
161    fn static_type() -> Type {
162        unsafe { from_glib(gio_sys::g_credentials_type_get_type()) }
163    }
164}
165
166impl<'a> FromValueOptional<'a> for CredentialsType {
167    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
168        Some(FromValue::from_value(value))
169    }
170}
171
172impl<'a> FromValue<'a> for CredentialsType {
173    unsafe fn from_value(value: &Value) -> Self {
174        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
175    }
176}
177
178impl SetValue for CredentialsType {
179    unsafe fn set_value(value: &mut Value, this: &Self) {
180        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
181    }
182}
183
184#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
185pub enum DataStreamByteOrder {
186    BigEndian,
187    LittleEndian,
188    HostEndian,
189    #[doc(hidden)]
190    __Unknown(i32),
191}
192
193impl fmt::Display for DataStreamByteOrder {
194    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
195        write!(
196            f,
197            "DataStreamByteOrder::{}",
198            match *self {
199                DataStreamByteOrder::BigEndian => "BigEndian",
200                DataStreamByteOrder::LittleEndian => "LittleEndian",
201                DataStreamByteOrder::HostEndian => "HostEndian",
202                _ => "Unknown",
203            }
204        )
205    }
206}
207
208#[doc(hidden)]
209impl ToGlib for DataStreamByteOrder {
210    type GlibType = gio_sys::GDataStreamByteOrder;
211
212    fn to_glib(&self) -> gio_sys::GDataStreamByteOrder {
213        match *self {
214            DataStreamByteOrder::BigEndian => gio_sys::G_DATA_STREAM_BYTE_ORDER_BIG_ENDIAN,
215            DataStreamByteOrder::LittleEndian => gio_sys::G_DATA_STREAM_BYTE_ORDER_LITTLE_ENDIAN,
216            DataStreamByteOrder::HostEndian => gio_sys::G_DATA_STREAM_BYTE_ORDER_HOST_ENDIAN,
217            DataStreamByteOrder::__Unknown(value) => value,
218        }
219    }
220}
221
222#[doc(hidden)]
223impl FromGlib<gio_sys::GDataStreamByteOrder> for DataStreamByteOrder {
224    fn from_glib(value: gio_sys::GDataStreamByteOrder) -> Self {
225        match value {
226            0 => DataStreamByteOrder::BigEndian,
227            1 => DataStreamByteOrder::LittleEndian,
228            2 => DataStreamByteOrder::HostEndian,
229            value => DataStreamByteOrder::__Unknown(value),
230        }
231    }
232}
233
234impl StaticType for DataStreamByteOrder {
235    fn static_type() -> Type {
236        unsafe { from_glib(gio_sys::g_data_stream_byte_order_get_type()) }
237    }
238}
239
240impl<'a> FromValueOptional<'a> for DataStreamByteOrder {
241    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
242        Some(FromValue::from_value(value))
243    }
244}
245
246impl<'a> FromValue<'a> for DataStreamByteOrder {
247    unsafe fn from_value(value: &Value) -> Self {
248        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
249    }
250}
251
252impl SetValue for DataStreamByteOrder {
253    unsafe fn set_value(value: &mut Value, this: &Self) {
254        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
255    }
256}
257
258#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
259pub enum DataStreamNewlineType {
260    Lf,
261    Cr,
262    CrLf,
263    Any,
264    #[doc(hidden)]
265    __Unknown(i32),
266}
267
268impl fmt::Display for DataStreamNewlineType {
269    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
270        write!(
271            f,
272            "DataStreamNewlineType::{}",
273            match *self {
274                DataStreamNewlineType::Lf => "Lf",
275                DataStreamNewlineType::Cr => "Cr",
276                DataStreamNewlineType::CrLf => "CrLf",
277                DataStreamNewlineType::Any => "Any",
278                _ => "Unknown",
279            }
280        )
281    }
282}
283
284#[doc(hidden)]
285impl ToGlib for DataStreamNewlineType {
286    type GlibType = gio_sys::GDataStreamNewlineType;
287
288    fn to_glib(&self) -> gio_sys::GDataStreamNewlineType {
289        match *self {
290            DataStreamNewlineType::Lf => gio_sys::G_DATA_STREAM_NEWLINE_TYPE_LF,
291            DataStreamNewlineType::Cr => gio_sys::G_DATA_STREAM_NEWLINE_TYPE_CR,
292            DataStreamNewlineType::CrLf => gio_sys::G_DATA_STREAM_NEWLINE_TYPE_CR_LF,
293            DataStreamNewlineType::Any => gio_sys::G_DATA_STREAM_NEWLINE_TYPE_ANY,
294            DataStreamNewlineType::__Unknown(value) => value,
295        }
296    }
297}
298
299#[doc(hidden)]
300impl FromGlib<gio_sys::GDataStreamNewlineType> for DataStreamNewlineType {
301    fn from_glib(value: gio_sys::GDataStreamNewlineType) -> Self {
302        match value {
303            0 => DataStreamNewlineType::Lf,
304            1 => DataStreamNewlineType::Cr,
305            2 => DataStreamNewlineType::CrLf,
306            3 => DataStreamNewlineType::Any,
307            value => DataStreamNewlineType::__Unknown(value),
308        }
309    }
310}
311
312impl StaticType for DataStreamNewlineType {
313    fn static_type() -> Type {
314        unsafe { from_glib(gio_sys::g_data_stream_newline_type_get_type()) }
315    }
316}
317
318impl<'a> FromValueOptional<'a> for DataStreamNewlineType {
319    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
320        Some(FromValue::from_value(value))
321    }
322}
323
324impl<'a> FromValue<'a> for DataStreamNewlineType {
325    unsafe fn from_value(value: &Value) -> Self {
326        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
327    }
328}
329
330impl SetValue for DataStreamNewlineType {
331    unsafe fn set_value(value: &mut Value, this: &Self) {
332        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
333    }
334}
335
336#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
337pub enum DriveStartStopType {
338    Unknown,
339    Shutdown,
340    Network,
341    Multidisk,
342    Password,
343    #[doc(hidden)]
344    __Unknown(i32),
345}
346
347impl fmt::Display for DriveStartStopType {
348    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
349        write!(
350            f,
351            "DriveStartStopType::{}",
352            match *self {
353                DriveStartStopType::Unknown => "Unknown",
354                DriveStartStopType::Shutdown => "Shutdown",
355                DriveStartStopType::Network => "Network",
356                DriveStartStopType::Multidisk => "Multidisk",
357                DriveStartStopType::Password => "Password",
358                _ => "Unknown",
359            }
360        )
361    }
362}
363
364#[doc(hidden)]
365impl ToGlib for DriveStartStopType {
366    type GlibType = gio_sys::GDriveStartStopType;
367
368    fn to_glib(&self) -> gio_sys::GDriveStartStopType {
369        match *self {
370            DriveStartStopType::Unknown => gio_sys::G_DRIVE_START_STOP_TYPE_UNKNOWN,
371            DriveStartStopType::Shutdown => gio_sys::G_DRIVE_START_STOP_TYPE_SHUTDOWN,
372            DriveStartStopType::Network => gio_sys::G_DRIVE_START_STOP_TYPE_NETWORK,
373            DriveStartStopType::Multidisk => gio_sys::G_DRIVE_START_STOP_TYPE_MULTIDISK,
374            DriveStartStopType::Password => gio_sys::G_DRIVE_START_STOP_TYPE_PASSWORD,
375            DriveStartStopType::__Unknown(value) => value,
376        }
377    }
378}
379
380#[doc(hidden)]
381impl FromGlib<gio_sys::GDriveStartStopType> for DriveStartStopType {
382    fn from_glib(value: gio_sys::GDriveStartStopType) -> Self {
383        match value {
384            0 => DriveStartStopType::Unknown,
385            1 => DriveStartStopType::Shutdown,
386            2 => DriveStartStopType::Network,
387            3 => DriveStartStopType::Multidisk,
388            4 => DriveStartStopType::Password,
389            value => DriveStartStopType::__Unknown(value),
390        }
391    }
392}
393
394impl StaticType for DriveStartStopType {
395    fn static_type() -> Type {
396        unsafe { from_glib(gio_sys::g_drive_start_stop_type_get_type()) }
397    }
398}
399
400impl<'a> FromValueOptional<'a> for DriveStartStopType {
401    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
402        Some(FromValue::from_value(value))
403    }
404}
405
406impl<'a> FromValue<'a> for DriveStartStopType {
407    unsafe fn from_value(value: &Value) -> Self {
408        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
409    }
410}
411
412impl SetValue for DriveStartStopType {
413    unsafe fn set_value(value: &mut Value, this: &Self) {
414        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
415    }
416}
417
418#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
419pub enum EmblemOrigin {
420    Unknown,
421    Device,
422    Livemetadata,
423    Tag,
424    #[doc(hidden)]
425    __Unknown(i32),
426}
427
428impl fmt::Display for EmblemOrigin {
429    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
430        write!(
431            f,
432            "EmblemOrigin::{}",
433            match *self {
434                EmblemOrigin::Unknown => "Unknown",
435                EmblemOrigin::Device => "Device",
436                EmblemOrigin::Livemetadata => "Livemetadata",
437                EmblemOrigin::Tag => "Tag",
438                _ => "Unknown",
439            }
440        )
441    }
442}
443
444#[doc(hidden)]
445impl ToGlib for EmblemOrigin {
446    type GlibType = gio_sys::GEmblemOrigin;
447
448    fn to_glib(&self) -> gio_sys::GEmblemOrigin {
449        match *self {
450            EmblemOrigin::Unknown => gio_sys::G_EMBLEM_ORIGIN_UNKNOWN,
451            EmblemOrigin::Device => gio_sys::G_EMBLEM_ORIGIN_DEVICE,
452            EmblemOrigin::Livemetadata => gio_sys::G_EMBLEM_ORIGIN_LIVEMETADATA,
453            EmblemOrigin::Tag => gio_sys::G_EMBLEM_ORIGIN_TAG,
454            EmblemOrigin::__Unknown(value) => value,
455        }
456    }
457}
458
459#[doc(hidden)]
460impl FromGlib<gio_sys::GEmblemOrigin> for EmblemOrigin {
461    fn from_glib(value: gio_sys::GEmblemOrigin) -> Self {
462        match value {
463            0 => EmblemOrigin::Unknown,
464            1 => EmblemOrigin::Device,
465            2 => EmblemOrigin::Livemetadata,
466            3 => EmblemOrigin::Tag,
467            value => EmblemOrigin::__Unknown(value),
468        }
469    }
470}
471
472impl StaticType for EmblemOrigin {
473    fn static_type() -> Type {
474        unsafe { from_glib(gio_sys::g_emblem_origin_get_type()) }
475    }
476}
477
478impl<'a> FromValueOptional<'a> for EmblemOrigin {
479    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
480        Some(FromValue::from_value(value))
481    }
482}
483
484impl<'a> FromValue<'a> for EmblemOrigin {
485    unsafe fn from_value(value: &Value) -> Self {
486        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
487    }
488}
489
490impl SetValue for EmblemOrigin {
491    unsafe fn set_value(value: &mut Value, this: &Self) {
492        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
493    }
494}
495
496#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
497pub enum FileAttributeStatus {
498    Unset,
499    Set,
500    ErrorSetting,
501    #[doc(hidden)]
502    __Unknown(i32),
503}
504
505impl fmt::Display for FileAttributeStatus {
506    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
507        write!(
508            f,
509            "FileAttributeStatus::{}",
510            match *self {
511                FileAttributeStatus::Unset => "Unset",
512                FileAttributeStatus::Set => "Set",
513                FileAttributeStatus::ErrorSetting => "ErrorSetting",
514                _ => "Unknown",
515            }
516        )
517    }
518}
519
520#[doc(hidden)]
521impl ToGlib for FileAttributeStatus {
522    type GlibType = gio_sys::GFileAttributeStatus;
523
524    fn to_glib(&self) -> gio_sys::GFileAttributeStatus {
525        match *self {
526            FileAttributeStatus::Unset => gio_sys::G_FILE_ATTRIBUTE_STATUS_UNSET,
527            FileAttributeStatus::Set => gio_sys::G_FILE_ATTRIBUTE_STATUS_SET,
528            FileAttributeStatus::ErrorSetting => gio_sys::G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING,
529            FileAttributeStatus::__Unknown(value) => value,
530        }
531    }
532}
533
534#[doc(hidden)]
535impl FromGlib<gio_sys::GFileAttributeStatus> for FileAttributeStatus {
536    fn from_glib(value: gio_sys::GFileAttributeStatus) -> Self {
537        match value {
538            0 => FileAttributeStatus::Unset,
539            1 => FileAttributeStatus::Set,
540            2 => FileAttributeStatus::ErrorSetting,
541            value => FileAttributeStatus::__Unknown(value),
542        }
543    }
544}
545
546impl StaticType for FileAttributeStatus {
547    fn static_type() -> Type {
548        unsafe { from_glib(gio_sys::g_file_attribute_status_get_type()) }
549    }
550}
551
552impl<'a> FromValueOptional<'a> for FileAttributeStatus {
553    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
554        Some(FromValue::from_value(value))
555    }
556}
557
558impl<'a> FromValue<'a> for FileAttributeStatus {
559    unsafe fn from_value(value: &Value) -> Self {
560        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
561    }
562}
563
564impl SetValue for FileAttributeStatus {
565    unsafe fn set_value(value: &mut Value, this: &Self) {
566        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
567    }
568}
569
570#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
571pub enum FileAttributeType {
572    Invalid,
573    String,
574    ByteString,
575    Boolean,
576    Uint32,
577    Int32,
578    Uint64,
579    Int64,
580    Object,
581    Stringv,
582    #[doc(hidden)]
583    __Unknown(i32),
584}
585
586impl fmt::Display for FileAttributeType {
587    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
588        write!(
589            f,
590            "FileAttributeType::{}",
591            match *self {
592                FileAttributeType::Invalid => "Invalid",
593                FileAttributeType::String => "String",
594                FileAttributeType::ByteString => "ByteString",
595                FileAttributeType::Boolean => "Boolean",
596                FileAttributeType::Uint32 => "Uint32",
597                FileAttributeType::Int32 => "Int32",
598                FileAttributeType::Uint64 => "Uint64",
599                FileAttributeType::Int64 => "Int64",
600                FileAttributeType::Object => "Object",
601                FileAttributeType::Stringv => "Stringv",
602                _ => "Unknown",
603            }
604        )
605    }
606}
607
608#[doc(hidden)]
609impl ToGlib for FileAttributeType {
610    type GlibType = gio_sys::GFileAttributeType;
611
612    fn to_glib(&self) -> gio_sys::GFileAttributeType {
613        match *self {
614            FileAttributeType::Invalid => gio_sys::G_FILE_ATTRIBUTE_TYPE_INVALID,
615            FileAttributeType::String => gio_sys::G_FILE_ATTRIBUTE_TYPE_STRING,
616            FileAttributeType::ByteString => gio_sys::G_FILE_ATTRIBUTE_TYPE_BYTE_STRING,
617            FileAttributeType::Boolean => gio_sys::G_FILE_ATTRIBUTE_TYPE_BOOLEAN,
618            FileAttributeType::Uint32 => gio_sys::G_FILE_ATTRIBUTE_TYPE_UINT32,
619            FileAttributeType::Int32 => gio_sys::G_FILE_ATTRIBUTE_TYPE_INT32,
620            FileAttributeType::Uint64 => gio_sys::G_FILE_ATTRIBUTE_TYPE_UINT64,
621            FileAttributeType::Int64 => gio_sys::G_FILE_ATTRIBUTE_TYPE_INT64,
622            FileAttributeType::Object => gio_sys::G_FILE_ATTRIBUTE_TYPE_OBJECT,
623            FileAttributeType::Stringv => gio_sys::G_FILE_ATTRIBUTE_TYPE_STRINGV,
624            FileAttributeType::__Unknown(value) => value,
625        }
626    }
627}
628
629#[doc(hidden)]
630impl FromGlib<gio_sys::GFileAttributeType> for FileAttributeType {
631    fn from_glib(value: gio_sys::GFileAttributeType) -> Self {
632        match value {
633            0 => FileAttributeType::Invalid,
634            1 => FileAttributeType::String,
635            2 => FileAttributeType::ByteString,
636            3 => FileAttributeType::Boolean,
637            4 => FileAttributeType::Uint32,
638            5 => FileAttributeType::Int32,
639            6 => FileAttributeType::Uint64,
640            7 => FileAttributeType::Int64,
641            8 => FileAttributeType::Object,
642            9 => FileAttributeType::Stringv,
643            value => FileAttributeType::__Unknown(value),
644        }
645    }
646}
647
648impl StaticType for FileAttributeType {
649    fn static_type() -> Type {
650        unsafe { from_glib(gio_sys::g_file_attribute_type_get_type()) }
651    }
652}
653
654impl<'a> FromValueOptional<'a> for FileAttributeType {
655    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
656        Some(FromValue::from_value(value))
657    }
658}
659
660impl<'a> FromValue<'a> for FileAttributeType {
661    unsafe fn from_value(value: &Value) -> Self {
662        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
663    }
664}
665
666impl SetValue for FileAttributeType {
667    unsafe fn set_value(value: &mut Value, this: &Self) {
668        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
669    }
670}
671
672#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
673pub enum FileMonitorEvent {
674    Changed,
675    ChangesDoneHint,
676    Deleted,
677    Created,
678    AttributeChanged,
679    PreUnmount,
680    Unmounted,
681    Moved,
682    Renamed,
683    MovedIn,
684    MovedOut,
685    #[doc(hidden)]
686    __Unknown(i32),
687}
688
689impl fmt::Display for FileMonitorEvent {
690    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
691        write!(
692            f,
693            "FileMonitorEvent::{}",
694            match *self {
695                FileMonitorEvent::Changed => "Changed",
696                FileMonitorEvent::ChangesDoneHint => "ChangesDoneHint",
697                FileMonitorEvent::Deleted => "Deleted",
698                FileMonitorEvent::Created => "Created",
699                FileMonitorEvent::AttributeChanged => "AttributeChanged",
700                FileMonitorEvent::PreUnmount => "PreUnmount",
701                FileMonitorEvent::Unmounted => "Unmounted",
702                FileMonitorEvent::Moved => "Moved",
703                FileMonitorEvent::Renamed => "Renamed",
704                FileMonitorEvent::MovedIn => "MovedIn",
705                FileMonitorEvent::MovedOut => "MovedOut",
706                _ => "Unknown",
707            }
708        )
709    }
710}
711
712#[doc(hidden)]
713impl ToGlib for FileMonitorEvent {
714    type GlibType = gio_sys::GFileMonitorEvent;
715
716    fn to_glib(&self) -> gio_sys::GFileMonitorEvent {
717        match *self {
718            FileMonitorEvent::Changed => gio_sys::G_FILE_MONITOR_EVENT_CHANGED,
719            FileMonitorEvent::ChangesDoneHint => gio_sys::G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT,
720            FileMonitorEvent::Deleted => gio_sys::G_FILE_MONITOR_EVENT_DELETED,
721            FileMonitorEvent::Created => gio_sys::G_FILE_MONITOR_EVENT_CREATED,
722            FileMonitorEvent::AttributeChanged => gio_sys::G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED,
723            FileMonitorEvent::PreUnmount => gio_sys::G_FILE_MONITOR_EVENT_PRE_UNMOUNT,
724            FileMonitorEvent::Unmounted => gio_sys::G_FILE_MONITOR_EVENT_UNMOUNTED,
725            FileMonitorEvent::Moved => gio_sys::G_FILE_MONITOR_EVENT_MOVED,
726            FileMonitorEvent::Renamed => gio_sys::G_FILE_MONITOR_EVENT_RENAMED,
727            FileMonitorEvent::MovedIn => gio_sys::G_FILE_MONITOR_EVENT_MOVED_IN,
728            FileMonitorEvent::MovedOut => gio_sys::G_FILE_MONITOR_EVENT_MOVED_OUT,
729            FileMonitorEvent::__Unknown(value) => value,
730        }
731    }
732}
733
734#[doc(hidden)]
735impl FromGlib<gio_sys::GFileMonitorEvent> for FileMonitorEvent {
736    fn from_glib(value: gio_sys::GFileMonitorEvent) -> Self {
737        match value {
738            0 => FileMonitorEvent::Changed,
739            1 => FileMonitorEvent::ChangesDoneHint,
740            2 => FileMonitorEvent::Deleted,
741            3 => FileMonitorEvent::Created,
742            4 => FileMonitorEvent::AttributeChanged,
743            5 => FileMonitorEvent::PreUnmount,
744            6 => FileMonitorEvent::Unmounted,
745            7 => FileMonitorEvent::Moved,
746            8 => FileMonitorEvent::Renamed,
747            9 => FileMonitorEvent::MovedIn,
748            10 => FileMonitorEvent::MovedOut,
749            value => FileMonitorEvent::__Unknown(value),
750        }
751    }
752}
753
754impl StaticType for FileMonitorEvent {
755    fn static_type() -> Type {
756        unsafe { from_glib(gio_sys::g_file_monitor_event_get_type()) }
757    }
758}
759
760impl<'a> FromValueOptional<'a> for FileMonitorEvent {
761    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
762        Some(FromValue::from_value(value))
763    }
764}
765
766impl<'a> FromValue<'a> for FileMonitorEvent {
767    unsafe fn from_value(value: &Value) -> Self {
768        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
769    }
770}
771
772impl SetValue for FileMonitorEvent {
773    unsafe fn set_value(value: &mut Value, this: &Self) {
774        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
775    }
776}
777
778#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
779pub enum FileType {
780    Unknown,
781    Regular,
782    Directory,
783    SymbolicLink,
784    Special,
785    Shortcut,
786    Mountable,
787    #[doc(hidden)]
788    __Unknown(i32),
789}
790
791impl fmt::Display for FileType {
792    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
793        write!(
794            f,
795            "FileType::{}",
796            match *self {
797                FileType::Unknown => "Unknown",
798                FileType::Regular => "Regular",
799                FileType::Directory => "Directory",
800                FileType::SymbolicLink => "SymbolicLink",
801                FileType::Special => "Special",
802                FileType::Shortcut => "Shortcut",
803                FileType::Mountable => "Mountable",
804                _ => "Unknown",
805            }
806        )
807    }
808}
809
810#[doc(hidden)]
811impl ToGlib for FileType {
812    type GlibType = gio_sys::GFileType;
813
814    fn to_glib(&self) -> gio_sys::GFileType {
815        match *self {
816            FileType::Unknown => gio_sys::G_FILE_TYPE_UNKNOWN,
817            FileType::Regular => gio_sys::G_FILE_TYPE_REGULAR,
818            FileType::Directory => gio_sys::G_FILE_TYPE_DIRECTORY,
819            FileType::SymbolicLink => gio_sys::G_FILE_TYPE_SYMBOLIC_LINK,
820            FileType::Special => gio_sys::G_FILE_TYPE_SPECIAL,
821            FileType::Shortcut => gio_sys::G_FILE_TYPE_SHORTCUT,
822            FileType::Mountable => gio_sys::G_FILE_TYPE_MOUNTABLE,
823            FileType::__Unknown(value) => value,
824        }
825    }
826}
827
828#[doc(hidden)]
829impl FromGlib<gio_sys::GFileType> for FileType {
830    fn from_glib(value: gio_sys::GFileType) -> Self {
831        match value {
832            0 => FileType::Unknown,
833            1 => FileType::Regular,
834            2 => FileType::Directory,
835            3 => FileType::SymbolicLink,
836            4 => FileType::Special,
837            5 => FileType::Shortcut,
838            6 => FileType::Mountable,
839            value => FileType::__Unknown(value),
840        }
841    }
842}
843
844impl StaticType for FileType {
845    fn static_type() -> Type {
846        unsafe { from_glib(gio_sys::g_file_type_get_type()) }
847    }
848}
849
850impl<'a> FromValueOptional<'a> for FileType {
851    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
852        Some(FromValue::from_value(value))
853    }
854}
855
856impl<'a> FromValue<'a> for FileType {
857    unsafe fn from_value(value: &Value) -> Self {
858        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
859    }
860}
861
862impl SetValue for FileType {
863    unsafe fn set_value(value: &mut Value, this: &Self) {
864        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
865    }
866}
867
868#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
869pub enum IOErrorEnum {
870    Failed,
871    NotFound,
872    Exists,
873    IsDirectory,
874    NotDirectory,
875    NotEmpty,
876    NotRegularFile,
877    NotSymbolicLink,
878    NotMountableFile,
879    FilenameTooLong,
880    InvalidFilename,
881    TooManyLinks,
882    NoSpace,
883    InvalidArgument,
884    PermissionDenied,
885    NotSupported,
886    NotMounted,
887    AlreadyMounted,
888    Closed,
889    Cancelled,
890    Pending,
891    ReadOnly,
892    CantCreateBackup,
893    WrongEtag,
894    TimedOut,
895    WouldRecurse,
896    Busy,
897    WouldBlock,
898    HostNotFound,
899    WouldMerge,
900    FailedHandled,
901    TooManyOpenFiles,
902    NotInitialized,
903    AddressInUse,
904    PartialInput,
905    InvalidData,
906    DbusError,
907    HostUnreachable,
908    NetworkUnreachable,
909    ConnectionRefused,
910    ProxyFailed,
911    ProxyAuthFailed,
912    ProxyNeedAuth,
913    ProxyNotAllowed,
914    BrokenPipe,
915    NotConnected,
916    MessageTooLarge,
917    #[doc(hidden)]
918    __Unknown(i32),
919}
920
921impl fmt::Display for IOErrorEnum {
922    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
923        write!(
924            f,
925            "IOErrorEnum::{}",
926            match *self {
927                IOErrorEnum::Failed => "Failed",
928                IOErrorEnum::NotFound => "NotFound",
929                IOErrorEnum::Exists => "Exists",
930                IOErrorEnum::IsDirectory => "IsDirectory",
931                IOErrorEnum::NotDirectory => "NotDirectory",
932                IOErrorEnum::NotEmpty => "NotEmpty",
933                IOErrorEnum::NotRegularFile => "NotRegularFile",
934                IOErrorEnum::NotSymbolicLink => "NotSymbolicLink",
935                IOErrorEnum::NotMountableFile => "NotMountableFile",
936                IOErrorEnum::FilenameTooLong => "FilenameTooLong",
937                IOErrorEnum::InvalidFilename => "InvalidFilename",
938                IOErrorEnum::TooManyLinks => "TooManyLinks",
939                IOErrorEnum::NoSpace => "NoSpace",
940                IOErrorEnum::InvalidArgument => "InvalidArgument",
941                IOErrorEnum::PermissionDenied => "PermissionDenied",
942                IOErrorEnum::NotSupported => "NotSupported",
943                IOErrorEnum::NotMounted => "NotMounted",
944                IOErrorEnum::AlreadyMounted => "AlreadyMounted",
945                IOErrorEnum::Closed => "Closed",
946                IOErrorEnum::Cancelled => "Cancelled",
947                IOErrorEnum::Pending => "Pending",
948                IOErrorEnum::ReadOnly => "ReadOnly",
949                IOErrorEnum::CantCreateBackup => "CantCreateBackup",
950                IOErrorEnum::WrongEtag => "WrongEtag",
951                IOErrorEnum::TimedOut => "TimedOut",
952                IOErrorEnum::WouldRecurse => "WouldRecurse",
953                IOErrorEnum::Busy => "Busy",
954                IOErrorEnum::WouldBlock => "WouldBlock",
955                IOErrorEnum::HostNotFound => "HostNotFound",
956                IOErrorEnum::WouldMerge => "WouldMerge",
957                IOErrorEnum::FailedHandled => "FailedHandled",
958                IOErrorEnum::TooManyOpenFiles => "TooManyOpenFiles",
959                IOErrorEnum::NotInitialized => "NotInitialized",
960                IOErrorEnum::AddressInUse => "AddressInUse",
961                IOErrorEnum::PartialInput => "PartialInput",
962                IOErrorEnum::InvalidData => "InvalidData",
963                IOErrorEnum::DbusError => "DbusError",
964                IOErrorEnum::HostUnreachable => "HostUnreachable",
965                IOErrorEnum::NetworkUnreachable => "NetworkUnreachable",
966                IOErrorEnum::ConnectionRefused => "ConnectionRefused",
967                IOErrorEnum::ProxyFailed => "ProxyFailed",
968                IOErrorEnum::ProxyAuthFailed => "ProxyAuthFailed",
969                IOErrorEnum::ProxyNeedAuth => "ProxyNeedAuth",
970                IOErrorEnum::ProxyNotAllowed => "ProxyNotAllowed",
971                IOErrorEnum::BrokenPipe => "BrokenPipe",
972                IOErrorEnum::NotConnected => "NotConnected",
973                IOErrorEnum::MessageTooLarge => "MessageTooLarge",
974                _ => "Unknown",
975            }
976        )
977    }
978}
979
980#[doc(hidden)]
981impl ToGlib for IOErrorEnum {
982    type GlibType = gio_sys::GIOErrorEnum;
983
984    fn to_glib(&self) -> gio_sys::GIOErrorEnum {
985        match *self {
986            IOErrorEnum::Failed => gio_sys::G_IO_ERROR_FAILED,
987            IOErrorEnum::NotFound => gio_sys::G_IO_ERROR_NOT_FOUND,
988            IOErrorEnum::Exists => gio_sys::G_IO_ERROR_EXISTS,
989            IOErrorEnum::IsDirectory => gio_sys::G_IO_ERROR_IS_DIRECTORY,
990            IOErrorEnum::NotDirectory => gio_sys::G_IO_ERROR_NOT_DIRECTORY,
991            IOErrorEnum::NotEmpty => gio_sys::G_IO_ERROR_NOT_EMPTY,
992            IOErrorEnum::NotRegularFile => gio_sys::G_IO_ERROR_NOT_REGULAR_FILE,
993            IOErrorEnum::NotSymbolicLink => gio_sys::G_IO_ERROR_NOT_SYMBOLIC_LINK,
994            IOErrorEnum::NotMountableFile => gio_sys::G_IO_ERROR_NOT_MOUNTABLE_FILE,
995            IOErrorEnum::FilenameTooLong => gio_sys::G_IO_ERROR_FILENAME_TOO_LONG,
996            IOErrorEnum::InvalidFilename => gio_sys::G_IO_ERROR_INVALID_FILENAME,
997            IOErrorEnum::TooManyLinks => gio_sys::G_IO_ERROR_TOO_MANY_LINKS,
998            IOErrorEnum::NoSpace => gio_sys::G_IO_ERROR_NO_SPACE,
999            IOErrorEnum::InvalidArgument => gio_sys::G_IO_ERROR_INVALID_ARGUMENT,
1000            IOErrorEnum::PermissionDenied => gio_sys::G_IO_ERROR_PERMISSION_DENIED,
1001            IOErrorEnum::NotSupported => gio_sys::G_IO_ERROR_NOT_SUPPORTED,
1002            IOErrorEnum::NotMounted => gio_sys::G_IO_ERROR_NOT_MOUNTED,
1003            IOErrorEnum::AlreadyMounted => gio_sys::G_IO_ERROR_ALREADY_MOUNTED,
1004            IOErrorEnum::Closed => gio_sys::G_IO_ERROR_CLOSED,
1005            IOErrorEnum::Cancelled => gio_sys::G_IO_ERROR_CANCELLED,
1006            IOErrorEnum::Pending => gio_sys::G_IO_ERROR_PENDING,
1007            IOErrorEnum::ReadOnly => gio_sys::G_IO_ERROR_READ_ONLY,
1008            IOErrorEnum::CantCreateBackup => gio_sys::G_IO_ERROR_CANT_CREATE_BACKUP,
1009            IOErrorEnum::WrongEtag => gio_sys::G_IO_ERROR_WRONG_ETAG,
1010            IOErrorEnum::TimedOut => gio_sys::G_IO_ERROR_TIMED_OUT,
1011            IOErrorEnum::WouldRecurse => gio_sys::G_IO_ERROR_WOULD_RECURSE,
1012            IOErrorEnum::Busy => gio_sys::G_IO_ERROR_BUSY,
1013            IOErrorEnum::WouldBlock => gio_sys::G_IO_ERROR_WOULD_BLOCK,
1014            IOErrorEnum::HostNotFound => gio_sys::G_IO_ERROR_HOST_NOT_FOUND,
1015            IOErrorEnum::WouldMerge => gio_sys::G_IO_ERROR_WOULD_MERGE,
1016            IOErrorEnum::FailedHandled => gio_sys::G_IO_ERROR_FAILED_HANDLED,
1017            IOErrorEnum::TooManyOpenFiles => gio_sys::G_IO_ERROR_TOO_MANY_OPEN_FILES,
1018            IOErrorEnum::NotInitialized => gio_sys::G_IO_ERROR_NOT_INITIALIZED,
1019            IOErrorEnum::AddressInUse => gio_sys::G_IO_ERROR_ADDRESS_IN_USE,
1020            IOErrorEnum::PartialInput => gio_sys::G_IO_ERROR_PARTIAL_INPUT,
1021            IOErrorEnum::InvalidData => gio_sys::G_IO_ERROR_INVALID_DATA,
1022            IOErrorEnum::DbusError => gio_sys::G_IO_ERROR_DBUS_ERROR,
1023            IOErrorEnum::HostUnreachable => gio_sys::G_IO_ERROR_HOST_UNREACHABLE,
1024            IOErrorEnum::NetworkUnreachable => gio_sys::G_IO_ERROR_NETWORK_UNREACHABLE,
1025            IOErrorEnum::ConnectionRefused => gio_sys::G_IO_ERROR_CONNECTION_REFUSED,
1026            IOErrorEnum::ProxyFailed => gio_sys::G_IO_ERROR_PROXY_FAILED,
1027            IOErrorEnum::ProxyAuthFailed => gio_sys::G_IO_ERROR_PROXY_AUTH_FAILED,
1028            IOErrorEnum::ProxyNeedAuth => gio_sys::G_IO_ERROR_PROXY_NEED_AUTH,
1029            IOErrorEnum::ProxyNotAllowed => gio_sys::G_IO_ERROR_PROXY_NOT_ALLOWED,
1030            IOErrorEnum::BrokenPipe => gio_sys::G_IO_ERROR_BROKEN_PIPE,
1031            IOErrorEnum::NotConnected => gio_sys::G_IO_ERROR_NOT_CONNECTED,
1032            IOErrorEnum::MessageTooLarge => gio_sys::G_IO_ERROR_MESSAGE_TOO_LARGE,
1033            IOErrorEnum::__Unknown(value) => value,
1034        }
1035    }
1036}
1037
1038#[doc(hidden)]
1039impl FromGlib<gio_sys::GIOErrorEnum> for IOErrorEnum {
1040    fn from_glib(value: gio_sys::GIOErrorEnum) -> Self {
1041        match value {
1042            0 => IOErrorEnum::Failed,
1043            1 => IOErrorEnum::NotFound,
1044            2 => IOErrorEnum::Exists,
1045            3 => IOErrorEnum::IsDirectory,
1046            4 => IOErrorEnum::NotDirectory,
1047            5 => IOErrorEnum::NotEmpty,
1048            6 => IOErrorEnum::NotRegularFile,
1049            7 => IOErrorEnum::NotSymbolicLink,
1050            8 => IOErrorEnum::NotMountableFile,
1051            9 => IOErrorEnum::FilenameTooLong,
1052            10 => IOErrorEnum::InvalidFilename,
1053            11 => IOErrorEnum::TooManyLinks,
1054            12 => IOErrorEnum::NoSpace,
1055            13 => IOErrorEnum::InvalidArgument,
1056            14 => IOErrorEnum::PermissionDenied,
1057            15 => IOErrorEnum::NotSupported,
1058            16 => IOErrorEnum::NotMounted,
1059            17 => IOErrorEnum::AlreadyMounted,
1060            18 => IOErrorEnum::Closed,
1061            19 => IOErrorEnum::Cancelled,
1062            20 => IOErrorEnum::Pending,
1063            21 => IOErrorEnum::ReadOnly,
1064            22 => IOErrorEnum::CantCreateBackup,
1065            23 => IOErrorEnum::WrongEtag,
1066            24 => IOErrorEnum::TimedOut,
1067            25 => IOErrorEnum::WouldRecurse,
1068            26 => IOErrorEnum::Busy,
1069            27 => IOErrorEnum::WouldBlock,
1070            28 => IOErrorEnum::HostNotFound,
1071            29 => IOErrorEnum::WouldMerge,
1072            30 => IOErrorEnum::FailedHandled,
1073            31 => IOErrorEnum::TooManyOpenFiles,
1074            32 => IOErrorEnum::NotInitialized,
1075            33 => IOErrorEnum::AddressInUse,
1076            34 => IOErrorEnum::PartialInput,
1077            35 => IOErrorEnum::InvalidData,
1078            36 => IOErrorEnum::DbusError,
1079            37 => IOErrorEnum::HostUnreachable,
1080            38 => IOErrorEnum::NetworkUnreachable,
1081            39 => IOErrorEnum::ConnectionRefused,
1082            40 => IOErrorEnum::ProxyFailed,
1083            41 => IOErrorEnum::ProxyAuthFailed,
1084            42 => IOErrorEnum::ProxyNeedAuth,
1085            43 => IOErrorEnum::ProxyNotAllowed,
1086            44 => IOErrorEnum::BrokenPipe,
1087            45 => IOErrorEnum::NotConnected,
1088            46 => IOErrorEnum::MessageTooLarge,
1089            value => IOErrorEnum::__Unknown(value),
1090        }
1091    }
1092}
1093
1094impl ErrorDomain for IOErrorEnum {
1095    fn domain() -> Quark {
1096        unsafe { from_glib(gio_sys::g_io_error_quark()) }
1097    }
1098
1099    fn code(self) -> i32 {
1100        self.to_glib()
1101    }
1102
1103    fn from(code: i32) -> Option<Self> {
1104        match code {
1105            0 => Some(IOErrorEnum::Failed),
1106            1 => Some(IOErrorEnum::NotFound),
1107            2 => Some(IOErrorEnum::Exists),
1108            3 => Some(IOErrorEnum::IsDirectory),
1109            4 => Some(IOErrorEnum::NotDirectory),
1110            5 => Some(IOErrorEnum::NotEmpty),
1111            6 => Some(IOErrorEnum::NotRegularFile),
1112            7 => Some(IOErrorEnum::NotSymbolicLink),
1113            8 => Some(IOErrorEnum::NotMountableFile),
1114            9 => Some(IOErrorEnum::FilenameTooLong),
1115            10 => Some(IOErrorEnum::InvalidFilename),
1116            11 => Some(IOErrorEnum::TooManyLinks),
1117            12 => Some(IOErrorEnum::NoSpace),
1118            13 => Some(IOErrorEnum::InvalidArgument),
1119            14 => Some(IOErrorEnum::PermissionDenied),
1120            15 => Some(IOErrorEnum::NotSupported),
1121            16 => Some(IOErrorEnum::NotMounted),
1122            17 => Some(IOErrorEnum::AlreadyMounted),
1123            18 => Some(IOErrorEnum::Closed),
1124            19 => Some(IOErrorEnum::Cancelled),
1125            20 => Some(IOErrorEnum::Pending),
1126            21 => Some(IOErrorEnum::ReadOnly),
1127            22 => Some(IOErrorEnum::CantCreateBackup),
1128            23 => Some(IOErrorEnum::WrongEtag),
1129            24 => Some(IOErrorEnum::TimedOut),
1130            25 => Some(IOErrorEnum::WouldRecurse),
1131            26 => Some(IOErrorEnum::Busy),
1132            27 => Some(IOErrorEnum::WouldBlock),
1133            28 => Some(IOErrorEnum::HostNotFound),
1134            29 => Some(IOErrorEnum::WouldMerge),
1135            30 => Some(IOErrorEnum::FailedHandled),
1136            31 => Some(IOErrorEnum::TooManyOpenFiles),
1137            32 => Some(IOErrorEnum::NotInitialized),
1138            33 => Some(IOErrorEnum::AddressInUse),
1139            34 => Some(IOErrorEnum::PartialInput),
1140            35 => Some(IOErrorEnum::InvalidData),
1141            36 => Some(IOErrorEnum::DbusError),
1142            37 => Some(IOErrorEnum::HostUnreachable),
1143            38 => Some(IOErrorEnum::NetworkUnreachable),
1144            39 => Some(IOErrorEnum::ConnectionRefused),
1145            40 => Some(IOErrorEnum::ProxyFailed),
1146            41 => Some(IOErrorEnum::ProxyAuthFailed),
1147            42 => Some(IOErrorEnum::ProxyNeedAuth),
1148            43 => Some(IOErrorEnum::ProxyNotAllowed),
1149            44 => Some(IOErrorEnum::BrokenPipe),
1150            45 => Some(IOErrorEnum::NotConnected),
1151            46 => Some(IOErrorEnum::MessageTooLarge),
1152            _ => Some(IOErrorEnum::Failed),
1153        }
1154    }
1155}
1156
1157impl StaticType for IOErrorEnum {
1158    fn static_type() -> Type {
1159        unsafe { from_glib(gio_sys::g_io_error_enum_get_type()) }
1160    }
1161}
1162
1163impl<'a> FromValueOptional<'a> for IOErrorEnum {
1164    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1165        Some(FromValue::from_value(value))
1166    }
1167}
1168
1169impl<'a> FromValue<'a> for IOErrorEnum {
1170    unsafe fn from_value(value: &Value) -> Self {
1171        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1172    }
1173}
1174
1175impl SetValue for IOErrorEnum {
1176    unsafe fn set_value(value: &mut Value, this: &Self) {
1177        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1178    }
1179}
1180
1181#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1182pub enum MountOperationResult {
1183    Handled,
1184    Aborted,
1185    Unhandled,
1186    #[doc(hidden)]
1187    __Unknown(i32),
1188}
1189
1190impl fmt::Display for MountOperationResult {
1191    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1192        write!(
1193            f,
1194            "MountOperationResult::{}",
1195            match *self {
1196                MountOperationResult::Handled => "Handled",
1197                MountOperationResult::Aborted => "Aborted",
1198                MountOperationResult::Unhandled => "Unhandled",
1199                _ => "Unknown",
1200            }
1201        )
1202    }
1203}
1204
1205#[doc(hidden)]
1206impl ToGlib for MountOperationResult {
1207    type GlibType = gio_sys::GMountOperationResult;
1208
1209    fn to_glib(&self) -> gio_sys::GMountOperationResult {
1210        match *self {
1211            MountOperationResult::Handled => gio_sys::G_MOUNT_OPERATION_HANDLED,
1212            MountOperationResult::Aborted => gio_sys::G_MOUNT_OPERATION_ABORTED,
1213            MountOperationResult::Unhandled => gio_sys::G_MOUNT_OPERATION_UNHANDLED,
1214            MountOperationResult::__Unknown(value) => value,
1215        }
1216    }
1217}
1218
1219#[doc(hidden)]
1220impl FromGlib<gio_sys::GMountOperationResult> for MountOperationResult {
1221    fn from_glib(value: gio_sys::GMountOperationResult) -> Self {
1222        match value {
1223            0 => MountOperationResult::Handled,
1224            1 => MountOperationResult::Aborted,
1225            2 => MountOperationResult::Unhandled,
1226            value => MountOperationResult::__Unknown(value),
1227        }
1228    }
1229}
1230
1231impl StaticType for MountOperationResult {
1232    fn static_type() -> Type {
1233        unsafe { from_glib(gio_sys::g_mount_operation_result_get_type()) }
1234    }
1235}
1236
1237impl<'a> FromValueOptional<'a> for MountOperationResult {
1238    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1239        Some(FromValue::from_value(value))
1240    }
1241}
1242
1243impl<'a> FromValue<'a> for MountOperationResult {
1244    unsafe fn from_value(value: &Value) -> Self {
1245        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1246    }
1247}
1248
1249impl SetValue for MountOperationResult {
1250    unsafe fn set_value(value: &mut Value, this: &Self) {
1251        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1252    }
1253}
1254
1255#[cfg(any(feature = "v2_44", feature = "dox"))]
1256#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1257pub enum NetworkConnectivity {
1258    Local,
1259    Limited,
1260    Portal,
1261    Full,
1262    #[doc(hidden)]
1263    __Unknown(i32),
1264}
1265
1266#[cfg(any(feature = "v2_44", feature = "dox"))]
1267impl fmt::Display for NetworkConnectivity {
1268    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1269        write!(
1270            f,
1271            "NetworkConnectivity::{}",
1272            match *self {
1273                NetworkConnectivity::Local => "Local",
1274                NetworkConnectivity::Limited => "Limited",
1275                NetworkConnectivity::Portal => "Portal",
1276                NetworkConnectivity::Full => "Full",
1277                _ => "Unknown",
1278            }
1279        )
1280    }
1281}
1282
1283#[cfg(any(feature = "v2_44", feature = "dox"))]
1284#[doc(hidden)]
1285impl ToGlib for NetworkConnectivity {
1286    type GlibType = gio_sys::GNetworkConnectivity;
1287
1288    fn to_glib(&self) -> gio_sys::GNetworkConnectivity {
1289        match *self {
1290            NetworkConnectivity::Local => gio_sys::G_NETWORK_CONNECTIVITY_LOCAL,
1291            NetworkConnectivity::Limited => gio_sys::G_NETWORK_CONNECTIVITY_LIMITED,
1292            NetworkConnectivity::Portal => gio_sys::G_NETWORK_CONNECTIVITY_PORTAL,
1293            NetworkConnectivity::Full => gio_sys::G_NETWORK_CONNECTIVITY_FULL,
1294            NetworkConnectivity::__Unknown(value) => value,
1295        }
1296    }
1297}
1298
1299#[cfg(any(feature = "v2_44", feature = "dox"))]
1300#[doc(hidden)]
1301impl FromGlib<gio_sys::GNetworkConnectivity> for NetworkConnectivity {
1302    fn from_glib(value: gio_sys::GNetworkConnectivity) -> Self {
1303        match value {
1304            1 => NetworkConnectivity::Local,
1305            2 => NetworkConnectivity::Limited,
1306            3 => NetworkConnectivity::Portal,
1307            4 => NetworkConnectivity::Full,
1308            value => NetworkConnectivity::__Unknown(value),
1309        }
1310    }
1311}
1312
1313#[cfg(any(feature = "v2_44", feature = "dox"))]
1314impl StaticType for NetworkConnectivity {
1315    fn static_type() -> Type {
1316        unsafe { from_glib(gio_sys::g_network_connectivity_get_type()) }
1317    }
1318}
1319
1320#[cfg(any(feature = "v2_44", feature = "dox"))]
1321impl<'a> FromValueOptional<'a> for NetworkConnectivity {
1322    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1323        Some(FromValue::from_value(value))
1324    }
1325}
1326
1327#[cfg(any(feature = "v2_44", feature = "dox"))]
1328impl<'a> FromValue<'a> for NetworkConnectivity {
1329    unsafe fn from_value(value: &Value) -> Self {
1330        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1331    }
1332}
1333
1334#[cfg(any(feature = "v2_44", feature = "dox"))]
1335impl SetValue for NetworkConnectivity {
1336    unsafe fn set_value(value: &mut Value, this: &Self) {
1337        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1338    }
1339}
1340
1341#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1342pub enum NotificationPriority {
1343    Normal,
1344    Low,
1345    High,
1346    Urgent,
1347    #[doc(hidden)]
1348    __Unknown(i32),
1349}
1350
1351impl fmt::Display for NotificationPriority {
1352    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1353        write!(
1354            f,
1355            "NotificationPriority::{}",
1356            match *self {
1357                NotificationPriority::Normal => "Normal",
1358                NotificationPriority::Low => "Low",
1359                NotificationPriority::High => "High",
1360                NotificationPriority::Urgent => "Urgent",
1361                _ => "Unknown",
1362            }
1363        )
1364    }
1365}
1366
1367#[doc(hidden)]
1368impl ToGlib for NotificationPriority {
1369    type GlibType = gio_sys::GNotificationPriority;
1370
1371    fn to_glib(&self) -> gio_sys::GNotificationPriority {
1372        match *self {
1373            NotificationPriority::Normal => gio_sys::G_NOTIFICATION_PRIORITY_NORMAL,
1374            NotificationPriority::Low => gio_sys::G_NOTIFICATION_PRIORITY_LOW,
1375            NotificationPriority::High => gio_sys::G_NOTIFICATION_PRIORITY_HIGH,
1376            NotificationPriority::Urgent => gio_sys::G_NOTIFICATION_PRIORITY_URGENT,
1377            NotificationPriority::__Unknown(value) => value,
1378        }
1379    }
1380}
1381
1382#[doc(hidden)]
1383impl FromGlib<gio_sys::GNotificationPriority> for NotificationPriority {
1384    fn from_glib(value: gio_sys::GNotificationPriority) -> Self {
1385        match value {
1386            0 => NotificationPriority::Normal,
1387            1 => NotificationPriority::Low,
1388            2 => NotificationPriority::High,
1389            3 => NotificationPriority::Urgent,
1390            value => NotificationPriority::__Unknown(value),
1391        }
1392    }
1393}
1394
1395impl StaticType for NotificationPriority {
1396    fn static_type() -> Type {
1397        unsafe { from_glib(gio_sys::g_notification_priority_get_type()) }
1398    }
1399}
1400
1401impl<'a> FromValueOptional<'a> for NotificationPriority {
1402    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1403        Some(FromValue::from_value(value))
1404    }
1405}
1406
1407impl<'a> FromValue<'a> for NotificationPriority {
1408    unsafe fn from_value(value: &Value) -> Self {
1409        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1410    }
1411}
1412
1413impl SetValue for NotificationPriority {
1414    unsafe fn set_value(value: &mut Value, this: &Self) {
1415        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1416    }
1417}
1418
1419#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1420pub enum PasswordSave {
1421    Never,
1422    ForSession,
1423    Permanently,
1424    #[doc(hidden)]
1425    __Unknown(i32),
1426}
1427
1428impl fmt::Display for PasswordSave {
1429    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1430        write!(
1431            f,
1432            "PasswordSave::{}",
1433            match *self {
1434                PasswordSave::Never => "Never",
1435                PasswordSave::ForSession => "ForSession",
1436                PasswordSave::Permanently => "Permanently",
1437                _ => "Unknown",
1438            }
1439        )
1440    }
1441}
1442
1443#[doc(hidden)]
1444impl ToGlib for PasswordSave {
1445    type GlibType = gio_sys::GPasswordSave;
1446
1447    fn to_glib(&self) -> gio_sys::GPasswordSave {
1448        match *self {
1449            PasswordSave::Never => gio_sys::G_PASSWORD_SAVE_NEVER,
1450            PasswordSave::ForSession => gio_sys::G_PASSWORD_SAVE_FOR_SESSION,
1451            PasswordSave::Permanently => gio_sys::G_PASSWORD_SAVE_PERMANENTLY,
1452            PasswordSave::__Unknown(value) => value,
1453        }
1454    }
1455}
1456
1457#[doc(hidden)]
1458impl FromGlib<gio_sys::GPasswordSave> for PasswordSave {
1459    fn from_glib(value: gio_sys::GPasswordSave) -> Self {
1460        match value {
1461            0 => PasswordSave::Never,
1462            1 => PasswordSave::ForSession,
1463            2 => PasswordSave::Permanently,
1464            value => PasswordSave::__Unknown(value),
1465        }
1466    }
1467}
1468
1469impl StaticType for PasswordSave {
1470    fn static_type() -> Type {
1471        unsafe { from_glib(gio_sys::g_password_save_get_type()) }
1472    }
1473}
1474
1475impl<'a> FromValueOptional<'a> for PasswordSave {
1476    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1477        Some(FromValue::from_value(value))
1478    }
1479}
1480
1481impl<'a> FromValue<'a> for PasswordSave {
1482    unsafe fn from_value(value: &Value) -> Self {
1483        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1484    }
1485}
1486
1487impl SetValue for PasswordSave {
1488    unsafe fn set_value(value: &mut Value, this: &Self) {
1489        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1490    }
1491}
1492
1493#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1494pub enum ResolverRecordType {
1495    Srv,
1496    Mx,
1497    Txt,
1498    Soa,
1499    Ns,
1500    #[doc(hidden)]
1501    __Unknown(i32),
1502}
1503
1504impl fmt::Display for ResolverRecordType {
1505    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1506        write!(
1507            f,
1508            "ResolverRecordType::{}",
1509            match *self {
1510                ResolverRecordType::Srv => "Srv",
1511                ResolverRecordType::Mx => "Mx",
1512                ResolverRecordType::Txt => "Txt",
1513                ResolverRecordType::Soa => "Soa",
1514                ResolverRecordType::Ns => "Ns",
1515                _ => "Unknown",
1516            }
1517        )
1518    }
1519}
1520
1521#[doc(hidden)]
1522impl ToGlib for ResolverRecordType {
1523    type GlibType = gio_sys::GResolverRecordType;
1524
1525    fn to_glib(&self) -> gio_sys::GResolverRecordType {
1526        match *self {
1527            ResolverRecordType::Srv => gio_sys::G_RESOLVER_RECORD_SRV,
1528            ResolverRecordType::Mx => gio_sys::G_RESOLVER_RECORD_MX,
1529            ResolverRecordType::Txt => gio_sys::G_RESOLVER_RECORD_TXT,
1530            ResolverRecordType::Soa => gio_sys::G_RESOLVER_RECORD_SOA,
1531            ResolverRecordType::Ns => gio_sys::G_RESOLVER_RECORD_NS,
1532            ResolverRecordType::__Unknown(value) => value,
1533        }
1534    }
1535}
1536
1537#[doc(hidden)]
1538impl FromGlib<gio_sys::GResolverRecordType> for ResolverRecordType {
1539    fn from_glib(value: gio_sys::GResolverRecordType) -> Self {
1540        match value {
1541            1 => ResolverRecordType::Srv,
1542            2 => ResolverRecordType::Mx,
1543            3 => ResolverRecordType::Txt,
1544            4 => ResolverRecordType::Soa,
1545            5 => ResolverRecordType::Ns,
1546            value => ResolverRecordType::__Unknown(value),
1547        }
1548    }
1549}
1550
1551impl StaticType for ResolverRecordType {
1552    fn static_type() -> Type {
1553        unsafe { from_glib(gio_sys::g_resolver_record_type_get_type()) }
1554    }
1555}
1556
1557impl<'a> FromValueOptional<'a> for ResolverRecordType {
1558    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1559        Some(FromValue::from_value(value))
1560    }
1561}
1562
1563impl<'a> FromValue<'a> for ResolverRecordType {
1564    unsafe fn from_value(value: &Value) -> Self {
1565        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1566    }
1567}
1568
1569impl SetValue for ResolverRecordType {
1570    unsafe fn set_value(value: &mut Value, this: &Self) {
1571        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1572    }
1573}
1574
1575#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1576pub enum ResourceError {
1577    NotFound,
1578    Internal,
1579    #[doc(hidden)]
1580    __Unknown(i32),
1581}
1582
1583impl fmt::Display for ResourceError {
1584    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1585        write!(
1586            f,
1587            "ResourceError::{}",
1588            match *self {
1589                ResourceError::NotFound => "NotFound",
1590                ResourceError::Internal => "Internal",
1591                _ => "Unknown",
1592            }
1593        )
1594    }
1595}
1596
1597#[doc(hidden)]
1598impl ToGlib for ResourceError {
1599    type GlibType = gio_sys::GResourceError;
1600
1601    fn to_glib(&self) -> gio_sys::GResourceError {
1602        match *self {
1603            ResourceError::NotFound => gio_sys::G_RESOURCE_ERROR_NOT_FOUND,
1604            ResourceError::Internal => gio_sys::G_RESOURCE_ERROR_INTERNAL,
1605            ResourceError::__Unknown(value) => value,
1606        }
1607    }
1608}
1609
1610#[doc(hidden)]
1611impl FromGlib<gio_sys::GResourceError> for ResourceError {
1612    fn from_glib(value: gio_sys::GResourceError) -> Self {
1613        match value {
1614            0 => ResourceError::NotFound,
1615            1 => ResourceError::Internal,
1616            value => ResourceError::__Unknown(value),
1617        }
1618    }
1619}
1620
1621impl ErrorDomain for ResourceError {
1622    fn domain() -> Quark {
1623        unsafe { from_glib(gio_sys::g_resource_error_quark()) }
1624    }
1625
1626    fn code(self) -> i32 {
1627        self.to_glib()
1628    }
1629
1630    fn from(code: i32) -> Option<Self> {
1631        match code {
1632            0 => Some(ResourceError::NotFound),
1633            1 => Some(ResourceError::Internal),
1634            value => Some(ResourceError::__Unknown(value)),
1635        }
1636    }
1637}
1638
1639impl StaticType for ResourceError {
1640    fn static_type() -> Type {
1641        unsafe { from_glib(gio_sys::g_resource_error_get_type()) }
1642    }
1643}
1644
1645impl<'a> FromValueOptional<'a> for ResourceError {
1646    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1647        Some(FromValue::from_value(value))
1648    }
1649}
1650
1651impl<'a> FromValue<'a> for ResourceError {
1652    unsafe fn from_value(value: &Value) -> Self {
1653        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1654    }
1655}
1656
1657impl SetValue for ResourceError {
1658    unsafe fn set_value(value: &mut Value, this: &Self) {
1659        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1660    }
1661}
1662
1663#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1664pub enum SocketClientEvent {
1665    Resolving,
1666    Resolved,
1667    Connecting,
1668    Connected,
1669    ProxyNegotiating,
1670    ProxyNegotiated,
1671    TlsHandshaking,
1672    TlsHandshaked,
1673    Complete,
1674    #[doc(hidden)]
1675    __Unknown(i32),
1676}
1677
1678impl fmt::Display for SocketClientEvent {
1679    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1680        write!(
1681            f,
1682            "SocketClientEvent::{}",
1683            match *self {
1684                SocketClientEvent::Resolving => "Resolving",
1685                SocketClientEvent::Resolved => "Resolved",
1686                SocketClientEvent::Connecting => "Connecting",
1687                SocketClientEvent::Connected => "Connected",
1688                SocketClientEvent::ProxyNegotiating => "ProxyNegotiating",
1689                SocketClientEvent::ProxyNegotiated => "ProxyNegotiated",
1690                SocketClientEvent::TlsHandshaking => "TlsHandshaking",
1691                SocketClientEvent::TlsHandshaked => "TlsHandshaked",
1692                SocketClientEvent::Complete => "Complete",
1693                _ => "Unknown",
1694            }
1695        )
1696    }
1697}
1698
1699#[doc(hidden)]
1700impl ToGlib for SocketClientEvent {
1701    type GlibType = gio_sys::GSocketClientEvent;
1702
1703    fn to_glib(&self) -> gio_sys::GSocketClientEvent {
1704        match *self {
1705            SocketClientEvent::Resolving => gio_sys::G_SOCKET_CLIENT_RESOLVING,
1706            SocketClientEvent::Resolved => gio_sys::G_SOCKET_CLIENT_RESOLVED,
1707            SocketClientEvent::Connecting => gio_sys::G_SOCKET_CLIENT_CONNECTING,
1708            SocketClientEvent::Connected => gio_sys::G_SOCKET_CLIENT_CONNECTED,
1709            SocketClientEvent::ProxyNegotiating => gio_sys::G_SOCKET_CLIENT_PROXY_NEGOTIATING,
1710            SocketClientEvent::ProxyNegotiated => gio_sys::G_SOCKET_CLIENT_PROXY_NEGOTIATED,
1711            SocketClientEvent::TlsHandshaking => gio_sys::G_SOCKET_CLIENT_TLS_HANDSHAKING,
1712            SocketClientEvent::TlsHandshaked => gio_sys::G_SOCKET_CLIENT_TLS_HANDSHAKED,
1713            SocketClientEvent::Complete => gio_sys::G_SOCKET_CLIENT_COMPLETE,
1714            SocketClientEvent::__Unknown(value) => value,
1715        }
1716    }
1717}
1718
1719#[doc(hidden)]
1720impl FromGlib<gio_sys::GSocketClientEvent> for SocketClientEvent {
1721    fn from_glib(value: gio_sys::GSocketClientEvent) -> Self {
1722        match value {
1723            0 => SocketClientEvent::Resolving,
1724            1 => SocketClientEvent::Resolved,
1725            2 => SocketClientEvent::Connecting,
1726            3 => SocketClientEvent::Connected,
1727            4 => SocketClientEvent::ProxyNegotiating,
1728            5 => SocketClientEvent::ProxyNegotiated,
1729            6 => SocketClientEvent::TlsHandshaking,
1730            7 => SocketClientEvent::TlsHandshaked,
1731            8 => SocketClientEvent::Complete,
1732            value => SocketClientEvent::__Unknown(value),
1733        }
1734    }
1735}
1736
1737impl StaticType for SocketClientEvent {
1738    fn static_type() -> Type {
1739        unsafe { from_glib(gio_sys::g_socket_client_event_get_type()) }
1740    }
1741}
1742
1743impl<'a> FromValueOptional<'a> for SocketClientEvent {
1744    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1745        Some(FromValue::from_value(value))
1746    }
1747}
1748
1749impl<'a> FromValue<'a> for SocketClientEvent {
1750    unsafe fn from_value(value: &Value) -> Self {
1751        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1752    }
1753}
1754
1755impl SetValue for SocketClientEvent {
1756    unsafe fn set_value(value: &mut Value, this: &Self) {
1757        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1758    }
1759}
1760
1761#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1762pub enum SocketFamily {
1763    Invalid,
1764    Unix,
1765    Ipv4,
1766    Ipv6,
1767    #[doc(hidden)]
1768    __Unknown(i32),
1769}
1770
1771impl fmt::Display for SocketFamily {
1772    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1773        write!(
1774            f,
1775            "SocketFamily::{}",
1776            match *self {
1777                SocketFamily::Invalid => "Invalid",
1778                SocketFamily::Unix => "Unix",
1779                SocketFamily::Ipv4 => "Ipv4",
1780                SocketFamily::Ipv6 => "Ipv6",
1781                _ => "Unknown",
1782            }
1783        )
1784    }
1785}
1786
1787#[doc(hidden)]
1788impl ToGlib for SocketFamily {
1789    type GlibType = gio_sys::GSocketFamily;
1790
1791    fn to_glib(&self) -> gio_sys::GSocketFamily {
1792        match *self {
1793            SocketFamily::Invalid => gio_sys::G_SOCKET_FAMILY_INVALID,
1794            SocketFamily::Unix => gio_sys::G_SOCKET_FAMILY_UNIX,
1795            SocketFamily::Ipv4 => gio_sys::G_SOCKET_FAMILY_IPV4,
1796            SocketFamily::Ipv6 => gio_sys::G_SOCKET_FAMILY_IPV6,
1797            SocketFamily::__Unknown(value) => value,
1798        }
1799    }
1800}
1801
1802#[doc(hidden)]
1803impl FromGlib<gio_sys::GSocketFamily> for SocketFamily {
1804    fn from_glib(value: gio_sys::GSocketFamily) -> Self {
1805        match value {
1806            0 => SocketFamily::Invalid,
1807            1 => SocketFamily::Unix,
1808            2 => SocketFamily::Ipv4,
1809            10 => SocketFamily::Ipv6,
1810            value => SocketFamily::__Unknown(value),
1811        }
1812    }
1813}
1814
1815impl StaticType for SocketFamily {
1816    fn static_type() -> Type {
1817        unsafe { from_glib(gio_sys::g_socket_family_get_type()) }
1818    }
1819}
1820
1821impl<'a> FromValueOptional<'a> for SocketFamily {
1822    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1823        Some(FromValue::from_value(value))
1824    }
1825}
1826
1827impl<'a> FromValue<'a> for SocketFamily {
1828    unsafe fn from_value(value: &Value) -> Self {
1829        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1830    }
1831}
1832
1833impl SetValue for SocketFamily {
1834    unsafe fn set_value(value: &mut Value, this: &Self) {
1835        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1836    }
1837}
1838
1839#[cfg(any(feature = "v2_46", feature = "dox"))]
1840#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1841pub enum SocketListenerEvent {
1842    Binding,
1843    Bound,
1844    Listening,
1845    Listened,
1846    #[doc(hidden)]
1847    __Unknown(i32),
1848}
1849
1850#[cfg(any(feature = "v2_46", feature = "dox"))]
1851impl fmt::Display for SocketListenerEvent {
1852    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1853        write!(
1854            f,
1855            "SocketListenerEvent::{}",
1856            match *self {
1857                SocketListenerEvent::Binding => "Binding",
1858                SocketListenerEvent::Bound => "Bound",
1859                SocketListenerEvent::Listening => "Listening",
1860                SocketListenerEvent::Listened => "Listened",
1861                _ => "Unknown",
1862            }
1863        )
1864    }
1865}
1866
1867#[cfg(any(feature = "v2_46", feature = "dox"))]
1868#[doc(hidden)]
1869impl ToGlib for SocketListenerEvent {
1870    type GlibType = gio_sys::GSocketListenerEvent;
1871
1872    fn to_glib(&self) -> gio_sys::GSocketListenerEvent {
1873        match *self {
1874            SocketListenerEvent::Binding => gio_sys::G_SOCKET_LISTENER_BINDING,
1875            SocketListenerEvent::Bound => gio_sys::G_SOCKET_LISTENER_BOUND,
1876            SocketListenerEvent::Listening => gio_sys::G_SOCKET_LISTENER_LISTENING,
1877            SocketListenerEvent::Listened => gio_sys::G_SOCKET_LISTENER_LISTENED,
1878            SocketListenerEvent::__Unknown(value) => value,
1879        }
1880    }
1881}
1882
1883#[cfg(any(feature = "v2_46", feature = "dox"))]
1884#[doc(hidden)]
1885impl FromGlib<gio_sys::GSocketListenerEvent> for SocketListenerEvent {
1886    fn from_glib(value: gio_sys::GSocketListenerEvent) -> Self {
1887        match value {
1888            0 => SocketListenerEvent::Binding,
1889            1 => SocketListenerEvent::Bound,
1890            2 => SocketListenerEvent::Listening,
1891            3 => SocketListenerEvent::Listened,
1892            value => SocketListenerEvent::__Unknown(value),
1893        }
1894    }
1895}
1896
1897#[cfg(any(feature = "v2_46", feature = "dox"))]
1898impl StaticType for SocketListenerEvent {
1899    fn static_type() -> Type {
1900        unsafe { from_glib(gio_sys::g_socket_listener_event_get_type()) }
1901    }
1902}
1903
1904#[cfg(any(feature = "v2_46", feature = "dox"))]
1905impl<'a> FromValueOptional<'a> for SocketListenerEvent {
1906    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1907        Some(FromValue::from_value(value))
1908    }
1909}
1910
1911#[cfg(any(feature = "v2_46", feature = "dox"))]
1912impl<'a> FromValue<'a> for SocketListenerEvent {
1913    unsafe fn from_value(value: &Value) -> Self {
1914        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1915    }
1916}
1917
1918#[cfg(any(feature = "v2_46", feature = "dox"))]
1919impl SetValue for SocketListenerEvent {
1920    unsafe fn set_value(value: &mut Value, this: &Self) {
1921        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
1922    }
1923}
1924
1925#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
1926pub enum SocketProtocol {
1927    Unknown,
1928    Default,
1929    Tcp,
1930    Udp,
1931    Sctp,
1932    #[doc(hidden)]
1933    __Unknown(i32),
1934}
1935
1936impl fmt::Display for SocketProtocol {
1937    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1938        write!(
1939            f,
1940            "SocketProtocol::{}",
1941            match *self {
1942                SocketProtocol::Unknown => "Unknown",
1943                SocketProtocol::Default => "Default",
1944                SocketProtocol::Tcp => "Tcp",
1945                SocketProtocol::Udp => "Udp",
1946                SocketProtocol::Sctp => "Sctp",
1947                _ => "Unknown",
1948            }
1949        )
1950    }
1951}
1952
1953#[doc(hidden)]
1954impl ToGlib for SocketProtocol {
1955    type GlibType = gio_sys::GSocketProtocol;
1956
1957    fn to_glib(&self) -> gio_sys::GSocketProtocol {
1958        match *self {
1959            SocketProtocol::Unknown => gio_sys::G_SOCKET_PROTOCOL_UNKNOWN,
1960            SocketProtocol::Default => gio_sys::G_SOCKET_PROTOCOL_DEFAULT,
1961            SocketProtocol::Tcp => gio_sys::G_SOCKET_PROTOCOL_TCP,
1962            SocketProtocol::Udp => gio_sys::G_SOCKET_PROTOCOL_UDP,
1963            SocketProtocol::Sctp => gio_sys::G_SOCKET_PROTOCOL_SCTP,
1964            SocketProtocol::__Unknown(value) => value,
1965        }
1966    }
1967}
1968
1969#[doc(hidden)]
1970impl FromGlib<gio_sys::GSocketProtocol> for SocketProtocol {
1971    fn from_glib(value: gio_sys::GSocketProtocol) -> Self {
1972        match value {
1973            -1 => SocketProtocol::Unknown,
1974            0 => SocketProtocol::Default,
1975            6 => SocketProtocol::Tcp,
1976            17 => SocketProtocol::Udp,
1977            132 => SocketProtocol::Sctp,
1978            value => SocketProtocol::__Unknown(value),
1979        }
1980    }
1981}
1982
1983impl StaticType for SocketProtocol {
1984    fn static_type() -> Type {
1985        unsafe { from_glib(gio_sys::g_socket_protocol_get_type()) }
1986    }
1987}
1988
1989impl<'a> FromValueOptional<'a> for SocketProtocol {
1990    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
1991        Some(FromValue::from_value(value))
1992    }
1993}
1994
1995impl<'a> FromValue<'a> for SocketProtocol {
1996    unsafe fn from_value(value: &Value) -> Self {
1997        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
1998    }
1999}
2000
2001impl SetValue for SocketProtocol {
2002    unsafe fn set_value(value: &mut Value, this: &Self) {
2003        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2004    }
2005}
2006
2007#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2008pub enum SocketType {
2009    Invalid,
2010    Stream,
2011    Datagram,
2012    Seqpacket,
2013    #[doc(hidden)]
2014    __Unknown(i32),
2015}
2016
2017impl fmt::Display for SocketType {
2018    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2019        write!(
2020            f,
2021            "SocketType::{}",
2022            match *self {
2023                SocketType::Invalid => "Invalid",
2024                SocketType::Stream => "Stream",
2025                SocketType::Datagram => "Datagram",
2026                SocketType::Seqpacket => "Seqpacket",
2027                _ => "Unknown",
2028            }
2029        )
2030    }
2031}
2032
2033#[doc(hidden)]
2034impl ToGlib for SocketType {
2035    type GlibType = gio_sys::GSocketType;
2036
2037    fn to_glib(&self) -> gio_sys::GSocketType {
2038        match *self {
2039            SocketType::Invalid => gio_sys::G_SOCKET_TYPE_INVALID,
2040            SocketType::Stream => gio_sys::G_SOCKET_TYPE_STREAM,
2041            SocketType::Datagram => gio_sys::G_SOCKET_TYPE_DATAGRAM,
2042            SocketType::Seqpacket => gio_sys::G_SOCKET_TYPE_SEQPACKET,
2043            SocketType::__Unknown(value) => value,
2044        }
2045    }
2046}
2047
2048#[doc(hidden)]
2049impl FromGlib<gio_sys::GSocketType> for SocketType {
2050    fn from_glib(value: gio_sys::GSocketType) -> Self {
2051        match value {
2052            0 => SocketType::Invalid,
2053            1 => SocketType::Stream,
2054            2 => SocketType::Datagram,
2055            3 => SocketType::Seqpacket,
2056            value => SocketType::__Unknown(value),
2057        }
2058    }
2059}
2060
2061impl StaticType for SocketType {
2062    fn static_type() -> Type {
2063        unsafe { from_glib(gio_sys::g_socket_type_get_type()) }
2064    }
2065}
2066
2067impl<'a> FromValueOptional<'a> for SocketType {
2068    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2069        Some(FromValue::from_value(value))
2070    }
2071}
2072
2073impl<'a> FromValue<'a> for SocketType {
2074    unsafe fn from_value(value: &Value) -> Self {
2075        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2076    }
2077}
2078
2079impl SetValue for SocketType {
2080    unsafe fn set_value(value: &mut Value, this: &Self) {
2081        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2082    }
2083}
2084
2085#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2086pub enum TlsAuthenticationMode {
2087    None,
2088    Requested,
2089    Required,
2090    #[doc(hidden)]
2091    __Unknown(i32),
2092}
2093
2094impl fmt::Display for TlsAuthenticationMode {
2095    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2096        write!(
2097            f,
2098            "TlsAuthenticationMode::{}",
2099            match *self {
2100                TlsAuthenticationMode::None => "None",
2101                TlsAuthenticationMode::Requested => "Requested",
2102                TlsAuthenticationMode::Required => "Required",
2103                _ => "Unknown",
2104            }
2105        )
2106    }
2107}
2108
2109#[doc(hidden)]
2110impl ToGlib for TlsAuthenticationMode {
2111    type GlibType = gio_sys::GTlsAuthenticationMode;
2112
2113    fn to_glib(&self) -> gio_sys::GTlsAuthenticationMode {
2114        match *self {
2115            TlsAuthenticationMode::None => gio_sys::G_TLS_AUTHENTICATION_NONE,
2116            TlsAuthenticationMode::Requested => gio_sys::G_TLS_AUTHENTICATION_REQUESTED,
2117            TlsAuthenticationMode::Required => gio_sys::G_TLS_AUTHENTICATION_REQUIRED,
2118            TlsAuthenticationMode::__Unknown(value) => value,
2119        }
2120    }
2121}
2122
2123#[doc(hidden)]
2124impl FromGlib<gio_sys::GTlsAuthenticationMode> for TlsAuthenticationMode {
2125    fn from_glib(value: gio_sys::GTlsAuthenticationMode) -> Self {
2126        match value {
2127            0 => TlsAuthenticationMode::None,
2128            1 => TlsAuthenticationMode::Requested,
2129            2 => TlsAuthenticationMode::Required,
2130            value => TlsAuthenticationMode::__Unknown(value),
2131        }
2132    }
2133}
2134
2135impl StaticType for TlsAuthenticationMode {
2136    fn static_type() -> Type {
2137        unsafe { from_glib(gio_sys::g_tls_authentication_mode_get_type()) }
2138    }
2139}
2140
2141impl<'a> FromValueOptional<'a> for TlsAuthenticationMode {
2142    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2143        Some(FromValue::from_value(value))
2144    }
2145}
2146
2147impl<'a> FromValue<'a> for TlsAuthenticationMode {
2148    unsafe fn from_value(value: &Value) -> Self {
2149        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2150    }
2151}
2152
2153impl SetValue for TlsAuthenticationMode {
2154    unsafe fn set_value(value: &mut Value, this: &Self) {
2155        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2156    }
2157}
2158
2159#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2160pub enum TlsCertificateRequestFlags {
2161    None,
2162    #[doc(hidden)]
2163    __Unknown(i32),
2164}
2165
2166impl fmt::Display for TlsCertificateRequestFlags {
2167    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2168        write!(
2169            f,
2170            "TlsCertificateRequestFlags::{}",
2171            match *self {
2172                TlsCertificateRequestFlags::None => "None",
2173                _ => "Unknown",
2174            }
2175        )
2176    }
2177}
2178
2179#[doc(hidden)]
2180impl ToGlib for TlsCertificateRequestFlags {
2181    type GlibType = gio_sys::GTlsCertificateRequestFlags;
2182
2183    fn to_glib(&self) -> gio_sys::GTlsCertificateRequestFlags {
2184        match *self {
2185            TlsCertificateRequestFlags::None => gio_sys::G_TLS_CERTIFICATE_REQUEST_NONE,
2186            TlsCertificateRequestFlags::__Unknown(value) => value,
2187        }
2188    }
2189}
2190
2191#[doc(hidden)]
2192impl FromGlib<gio_sys::GTlsCertificateRequestFlags> for TlsCertificateRequestFlags {
2193    fn from_glib(value: gio_sys::GTlsCertificateRequestFlags) -> Self {
2194        match value {
2195            0 => TlsCertificateRequestFlags::None,
2196            value => TlsCertificateRequestFlags::__Unknown(value),
2197        }
2198    }
2199}
2200
2201impl StaticType for TlsCertificateRequestFlags {
2202    fn static_type() -> Type {
2203        unsafe { from_glib(gio_sys::g_tls_certificate_request_flags_get_type()) }
2204    }
2205}
2206
2207impl<'a> FromValueOptional<'a> for TlsCertificateRequestFlags {
2208    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2209        Some(FromValue::from_value(value))
2210    }
2211}
2212
2213impl<'a> FromValue<'a> for TlsCertificateRequestFlags {
2214    unsafe fn from_value(value: &Value) -> Self {
2215        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2216    }
2217}
2218
2219impl SetValue for TlsCertificateRequestFlags {
2220    unsafe fn set_value(value: &mut Value, this: &Self) {
2221        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2222    }
2223}
2224
2225#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2226pub enum TlsDatabaseLookupFlags {
2227    None,
2228    Keypair,
2229    #[doc(hidden)]
2230    __Unknown(i32),
2231}
2232
2233impl fmt::Display for TlsDatabaseLookupFlags {
2234    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2235        write!(
2236            f,
2237            "TlsDatabaseLookupFlags::{}",
2238            match *self {
2239                TlsDatabaseLookupFlags::None => "None",
2240                TlsDatabaseLookupFlags::Keypair => "Keypair",
2241                _ => "Unknown",
2242            }
2243        )
2244    }
2245}
2246
2247#[doc(hidden)]
2248impl ToGlib for TlsDatabaseLookupFlags {
2249    type GlibType = gio_sys::GTlsDatabaseLookupFlags;
2250
2251    fn to_glib(&self) -> gio_sys::GTlsDatabaseLookupFlags {
2252        match *self {
2253            TlsDatabaseLookupFlags::None => gio_sys::G_TLS_DATABASE_LOOKUP_NONE,
2254            TlsDatabaseLookupFlags::Keypair => gio_sys::G_TLS_DATABASE_LOOKUP_KEYPAIR,
2255            TlsDatabaseLookupFlags::__Unknown(value) => value,
2256        }
2257    }
2258}
2259
2260#[doc(hidden)]
2261impl FromGlib<gio_sys::GTlsDatabaseLookupFlags> for TlsDatabaseLookupFlags {
2262    fn from_glib(value: gio_sys::GTlsDatabaseLookupFlags) -> Self {
2263        match value {
2264            0 => TlsDatabaseLookupFlags::None,
2265            1 => TlsDatabaseLookupFlags::Keypair,
2266            value => TlsDatabaseLookupFlags::__Unknown(value),
2267        }
2268    }
2269}
2270
2271impl StaticType for TlsDatabaseLookupFlags {
2272    fn static_type() -> Type {
2273        unsafe { from_glib(gio_sys::g_tls_database_lookup_flags_get_type()) }
2274    }
2275}
2276
2277impl<'a> FromValueOptional<'a> for TlsDatabaseLookupFlags {
2278    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2279        Some(FromValue::from_value(value))
2280    }
2281}
2282
2283impl<'a> FromValue<'a> for TlsDatabaseLookupFlags {
2284    unsafe fn from_value(value: &Value) -> Self {
2285        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2286    }
2287}
2288
2289impl SetValue for TlsDatabaseLookupFlags {
2290    unsafe fn set_value(value: &mut Value, this: &Self) {
2291        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2292    }
2293}
2294
2295#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2296pub enum TlsInteractionResult {
2297    Unhandled,
2298    Handled,
2299    Failed,
2300    #[doc(hidden)]
2301    __Unknown(i32),
2302}
2303
2304impl fmt::Display for TlsInteractionResult {
2305    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2306        write!(
2307            f,
2308            "TlsInteractionResult::{}",
2309            match *self {
2310                TlsInteractionResult::Unhandled => "Unhandled",
2311                TlsInteractionResult::Handled => "Handled",
2312                TlsInteractionResult::Failed => "Failed",
2313                _ => "Unknown",
2314            }
2315        )
2316    }
2317}
2318
2319#[doc(hidden)]
2320impl ToGlib for TlsInteractionResult {
2321    type GlibType = gio_sys::GTlsInteractionResult;
2322
2323    fn to_glib(&self) -> gio_sys::GTlsInteractionResult {
2324        match *self {
2325            TlsInteractionResult::Unhandled => gio_sys::G_TLS_INTERACTION_UNHANDLED,
2326            TlsInteractionResult::Handled => gio_sys::G_TLS_INTERACTION_HANDLED,
2327            TlsInteractionResult::Failed => gio_sys::G_TLS_INTERACTION_FAILED,
2328            TlsInteractionResult::__Unknown(value) => value,
2329        }
2330    }
2331}
2332
2333#[doc(hidden)]
2334impl FromGlib<gio_sys::GTlsInteractionResult> for TlsInteractionResult {
2335    fn from_glib(value: gio_sys::GTlsInteractionResult) -> Self {
2336        match value {
2337            0 => TlsInteractionResult::Unhandled,
2338            1 => TlsInteractionResult::Handled,
2339            2 => TlsInteractionResult::Failed,
2340            value => TlsInteractionResult::__Unknown(value),
2341        }
2342    }
2343}
2344
2345impl StaticType for TlsInteractionResult {
2346    fn static_type() -> Type {
2347        unsafe { from_glib(gio_sys::g_tls_interaction_result_get_type()) }
2348    }
2349}
2350
2351impl<'a> FromValueOptional<'a> for TlsInteractionResult {
2352    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2353        Some(FromValue::from_value(value))
2354    }
2355}
2356
2357impl<'a> FromValue<'a> for TlsInteractionResult {
2358    unsafe fn from_value(value: &Value) -> Self {
2359        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2360    }
2361}
2362
2363impl SetValue for TlsInteractionResult {
2364    unsafe fn set_value(value: &mut Value, this: &Self) {
2365        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2366    }
2367}
2368
2369#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2370pub enum TlsRehandshakeMode {
2371    Never,
2372    Safely,
2373    Unsafely,
2374    #[doc(hidden)]
2375    __Unknown(i32),
2376}
2377
2378impl fmt::Display for TlsRehandshakeMode {
2379    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2380        write!(
2381            f,
2382            "TlsRehandshakeMode::{}",
2383            match *self {
2384                TlsRehandshakeMode::Never => "Never",
2385                TlsRehandshakeMode::Safely => "Safely",
2386                TlsRehandshakeMode::Unsafely => "Unsafely",
2387                _ => "Unknown",
2388            }
2389        )
2390    }
2391}
2392
2393#[doc(hidden)]
2394impl ToGlib for TlsRehandshakeMode {
2395    type GlibType = gio_sys::GTlsRehandshakeMode;
2396
2397    fn to_glib(&self) -> gio_sys::GTlsRehandshakeMode {
2398        match *self {
2399            TlsRehandshakeMode::Never => gio_sys::G_TLS_REHANDSHAKE_NEVER,
2400            TlsRehandshakeMode::Safely => gio_sys::G_TLS_REHANDSHAKE_SAFELY,
2401            TlsRehandshakeMode::Unsafely => gio_sys::G_TLS_REHANDSHAKE_UNSAFELY,
2402            TlsRehandshakeMode::__Unknown(value) => value,
2403        }
2404    }
2405}
2406
2407#[doc(hidden)]
2408impl FromGlib<gio_sys::GTlsRehandshakeMode> for TlsRehandshakeMode {
2409    fn from_glib(value: gio_sys::GTlsRehandshakeMode) -> Self {
2410        match value {
2411            0 => TlsRehandshakeMode::Never,
2412            1 => TlsRehandshakeMode::Safely,
2413            2 => TlsRehandshakeMode::Unsafely,
2414            value => TlsRehandshakeMode::__Unknown(value),
2415        }
2416    }
2417}
2418
2419impl StaticType for TlsRehandshakeMode {
2420    fn static_type() -> Type {
2421        unsafe { from_glib(gio_sys::g_tls_rehandshake_mode_get_type()) }
2422    }
2423}
2424
2425impl<'a> FromValueOptional<'a> for TlsRehandshakeMode {
2426    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2427        Some(FromValue::from_value(value))
2428    }
2429}
2430
2431impl<'a> FromValue<'a> for TlsRehandshakeMode {
2432    unsafe fn from_value(value: &Value) -> Self {
2433        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2434    }
2435}
2436
2437impl SetValue for TlsRehandshakeMode {
2438    unsafe fn set_value(value: &mut Value, this: &Self) {
2439        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2440    }
2441}
2442
2443#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2444pub enum UnixSocketAddressType {
2445    Invalid,
2446    Anonymous,
2447    Path,
2448    Abstract,
2449    AbstractPadded,
2450    #[doc(hidden)]
2451    __Unknown(i32),
2452}
2453
2454impl fmt::Display for UnixSocketAddressType {
2455    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2456        write!(
2457            f,
2458            "UnixSocketAddressType::{}",
2459            match *self {
2460                UnixSocketAddressType::Invalid => "Invalid",
2461                UnixSocketAddressType::Anonymous => "Anonymous",
2462                UnixSocketAddressType::Path => "Path",
2463                UnixSocketAddressType::Abstract => "Abstract",
2464                UnixSocketAddressType::AbstractPadded => "AbstractPadded",
2465                _ => "Unknown",
2466            }
2467        )
2468    }
2469}
2470
2471#[doc(hidden)]
2472impl ToGlib for UnixSocketAddressType {
2473    type GlibType = gio_sys::GUnixSocketAddressType;
2474
2475    fn to_glib(&self) -> gio_sys::GUnixSocketAddressType {
2476        match *self {
2477            UnixSocketAddressType::Invalid => gio_sys::G_UNIX_SOCKET_ADDRESS_INVALID,
2478            UnixSocketAddressType::Anonymous => gio_sys::G_UNIX_SOCKET_ADDRESS_ANONYMOUS,
2479            UnixSocketAddressType::Path => gio_sys::G_UNIX_SOCKET_ADDRESS_PATH,
2480            UnixSocketAddressType::Abstract => gio_sys::G_UNIX_SOCKET_ADDRESS_ABSTRACT,
2481            UnixSocketAddressType::AbstractPadded => gio_sys::G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED,
2482            UnixSocketAddressType::__Unknown(value) => value,
2483        }
2484    }
2485}
2486
2487#[doc(hidden)]
2488impl FromGlib<gio_sys::GUnixSocketAddressType> for UnixSocketAddressType {
2489    fn from_glib(value: gio_sys::GUnixSocketAddressType) -> Self {
2490        match value {
2491            0 => UnixSocketAddressType::Invalid,
2492            1 => UnixSocketAddressType::Anonymous,
2493            2 => UnixSocketAddressType::Path,
2494            3 => UnixSocketAddressType::Abstract,
2495            4 => UnixSocketAddressType::AbstractPadded,
2496            value => UnixSocketAddressType::__Unknown(value),
2497        }
2498    }
2499}
2500
2501impl StaticType for UnixSocketAddressType {
2502    fn static_type() -> Type {
2503        unsafe { from_glib(gio_sys::g_unix_socket_address_type_get_type()) }
2504    }
2505}
2506
2507impl<'a> FromValueOptional<'a> for UnixSocketAddressType {
2508    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2509        Some(FromValue::from_value(value))
2510    }
2511}
2512
2513impl<'a> FromValue<'a> for UnixSocketAddressType {
2514    unsafe fn from_value(value: &Value) -> Self {
2515        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2516    }
2517}
2518
2519impl SetValue for UnixSocketAddressType {
2520    unsafe fn set_value(value: &mut Value, this: &Self) {
2521        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2522    }
2523}
2524
2525#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)]
2526pub enum ZlibCompressorFormat {
2527    Zlib,
2528    Gzip,
2529    Raw,
2530    #[doc(hidden)]
2531    __Unknown(i32),
2532}
2533
2534impl fmt::Display for ZlibCompressorFormat {
2535    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2536        write!(
2537            f,
2538            "ZlibCompressorFormat::{}",
2539            match *self {
2540                ZlibCompressorFormat::Zlib => "Zlib",
2541                ZlibCompressorFormat::Gzip => "Gzip",
2542                ZlibCompressorFormat::Raw => "Raw",
2543                _ => "Unknown",
2544            }
2545        )
2546    }
2547}
2548
2549#[doc(hidden)]
2550impl ToGlib for ZlibCompressorFormat {
2551    type GlibType = gio_sys::GZlibCompressorFormat;
2552
2553    fn to_glib(&self) -> gio_sys::GZlibCompressorFormat {
2554        match *self {
2555            ZlibCompressorFormat::Zlib => gio_sys::G_ZLIB_COMPRESSOR_FORMAT_ZLIB,
2556            ZlibCompressorFormat::Gzip => gio_sys::G_ZLIB_COMPRESSOR_FORMAT_GZIP,
2557            ZlibCompressorFormat::Raw => gio_sys::G_ZLIB_COMPRESSOR_FORMAT_RAW,
2558            ZlibCompressorFormat::__Unknown(value) => value,
2559        }
2560    }
2561}
2562
2563#[doc(hidden)]
2564impl FromGlib<gio_sys::GZlibCompressorFormat> for ZlibCompressorFormat {
2565    fn from_glib(value: gio_sys::GZlibCompressorFormat) -> Self {
2566        match value {
2567            0 => ZlibCompressorFormat::Zlib,
2568            1 => ZlibCompressorFormat::Gzip,
2569            2 => ZlibCompressorFormat::Raw,
2570            value => ZlibCompressorFormat::__Unknown(value),
2571        }
2572    }
2573}
2574
2575impl StaticType for ZlibCompressorFormat {
2576    fn static_type() -> Type {
2577        unsafe { from_glib(gio_sys::g_zlib_compressor_format_get_type()) }
2578    }
2579}
2580
2581impl<'a> FromValueOptional<'a> for ZlibCompressorFormat {
2582    unsafe fn from_value_optional(value: &Value) -> Option<Self> {
2583        Some(FromValue::from_value(value))
2584    }
2585}
2586
2587impl<'a> FromValue<'a> for ZlibCompressorFormat {
2588    unsafe fn from_value(value: &Value) -> Self {
2589        from_glib(gobject_sys::g_value_get_enum(value.to_glib_none().0))
2590    }
2591}
2592
2593impl SetValue for ZlibCompressorFormat {
2594    unsafe fn set_value(value: &mut Value, this: &Self) {
2595        gobject_sys::g_value_set_enum(value.to_glib_none_mut().0, this.to_glib())
2596    }
2597}