gio/auto/
proxy_address_enumerator.rs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

use crate::{ffi, ProxyResolver, SocketAddressEnumerator, SocketConnectable};
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// `GProxyAddressEnumerator` is a wrapper around
    /// [`SocketAddressEnumerator`][crate::SocketAddressEnumerator] which takes the [`SocketAddress`][crate::SocketAddress]
    /// instances returned by the [`SocketAddressEnumerator`][crate::SocketAddressEnumerator]
    /// and wraps them in [`ProxyAddress`][crate::ProxyAddress] instances, using the given
    /// [`proxy-resolver`][struct@crate::ProxyAddressEnumerator#proxy-resolver].
    ///
    /// This enumerator will be returned (for example, by
    /// [`SocketConnectableExt::enumerate()`][crate::prelude::SocketConnectableExt::enumerate()]) as appropriate when a proxy is
    /// configured; there should be no need to manually wrap a
    /// [`SocketAddressEnumerator`][crate::SocketAddressEnumerator] instance with one.
    ///
    /// ## Properties
    ///
    ///
    /// #### `connectable`
    ///  The connectable being enumerated.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `default-port`
    ///  The default port to use if #GProxyAddressEnumerator:uri does not
    /// specify one.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `proxy-resolver`
    ///  The proxy resolver to use.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `uri`
    ///  The destination URI. Use `none://` for a generic socket.
    ///
    /// Readable | Writeable | Construct Only
    ///
    /// # Implements
    ///
    /// [`ProxyAddressEnumeratorExt`][trait@crate::prelude::ProxyAddressEnumeratorExt], [`SocketAddressEnumeratorExt`][trait@crate::prelude::SocketAddressEnumeratorExt], [`trait@glib::ObjectExt`]
    #[doc(alias = "GProxyAddressEnumerator")]
    pub struct ProxyAddressEnumerator(Object<ffi::GProxyAddressEnumerator, ffi::GProxyAddressEnumeratorClass>) @extends SocketAddressEnumerator;

    match fn {
        type_ => || ffi::g_proxy_address_enumerator_get_type(),
    }
}

impl ProxyAddressEnumerator {
    pub const NONE: Option<&'static ProxyAddressEnumerator> = None;
}

mod sealed {
    pub trait Sealed {}
    impl<T: super::IsA<super::ProxyAddressEnumerator>> Sealed for T {}
}

/// Trait containing all [`struct@ProxyAddressEnumerator`] methods.
///
/// # Implementors
///
/// [`ProxyAddressEnumerator`][struct@crate::ProxyAddressEnumerator]
pub trait ProxyAddressEnumeratorExt:
    IsA<ProxyAddressEnumerator> + sealed::Sealed + 'static
{
    /// The connectable being enumerated.
    fn connectable(&self) -> Option<SocketConnectable> {
        ObjectExt::property(self.as_ref(), "connectable")
    }

    /// The default port to use if #GProxyAddressEnumerator:uri does not
    /// specify one.
    #[doc(alias = "default-port")]
    fn default_port(&self) -> u32 {
        ObjectExt::property(self.as_ref(), "default-port")
    }

    /// The proxy resolver to use.
    #[doc(alias = "proxy-resolver")]
    fn proxy_resolver(&self) -> Option<ProxyResolver> {
        ObjectExt::property(self.as_ref(), "proxy-resolver")
    }

    /// The proxy resolver to use.
    #[doc(alias = "proxy-resolver")]
    fn set_proxy_resolver<P: IsA<ProxyResolver>>(&self, proxy_resolver: Option<&P>) {
        ObjectExt::set_property(self.as_ref(), "proxy-resolver", proxy_resolver)
    }

    /// The destination URI. Use `none://` for a generic socket.
    fn uri(&self) -> Option<glib::GString> {
        ObjectExt::property(self.as_ref(), "uri")
    }

    #[doc(alias = "proxy-resolver")]
    fn connect_proxy_resolver_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_proxy_resolver_trampoline<
            P: IsA<ProxyAddressEnumerator>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GProxyAddressEnumerator,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(ProxyAddressEnumerator::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::proxy-resolver\0".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_proxy_resolver_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<ProxyAddressEnumerator>> ProxyAddressEnumeratorExt for O {}