1use 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}