cidre 0.10.1

Apple frameworks bindings for rust
Documentation 
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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165

use crate::{arc, define_obj_type, dispatch, ns, nw};

#[cfg(feature = "blocks")]
use crate::blocks;

#[doc(alias = "nw_browser_state_changed_handler_t")]
pub type StateChangedHandler = blocks::SyncBlock<fn(State, Option<&ns::Error>)>;

#[doc(alias = "nw_browser_browse_results_changed_handler_t")]
pub type BrowseResultsChandedHandler =
    blocks::SyncBlock<fn(&nw::BrowseResult, &nw::BrowseResult, bool)>;

#[doc(alias = "nw_browser_state_t")]
#[derive(Debug, Eq, PartialEq, Copy, Clone)]
#[repr(i32)]
pub enum State {
    /// The state of the browser is not valid.
    ///
    /// This state will never be delivered in the browser's state update
    /// handler and can be treated as an unexpected value.
    #[doc(alias = "nw_browser_state_invalid")]
    Invalid = 0,

    /// The browser is ready and able to receive
    /// endpoint updates. All callbacks from the browse_results_changed_handler
    /// occur when the browser is in this state.
    #[doc(alias = "nw_browser_state_ready")]
    Ready = 1,

    /// The browser has irrecoverably failed.
    ///
    /// You should not try to call [`nw::Browser::start()`] on the browser to restart
    /// it. Instead, cancel the browser and create a new browser object.
    #[doc(alias = "nw_browser_state_failed")]
    Failed = 2,

    /// The browser has been cancelled by
    /// the caller. You should not try to call [`nw::Browser::start()`] on the
    /// browser to restart it. Instead, create a new browser object.
    #[doc(alias = "nw_browser_state_cancelled")]
    Cancelled = 3,

    /// The browser is waiting for connectivity.
    ///
    /// Results will not be delivered until the browser moves into the ready
    /// state. A browser can move from the ready state into the waiting state.
    /// The associated error indicates why the browser is unable to browse.
    #[doc(alias = "nw_browser_state_waiting")]
    Waiting = 4,
}

define_obj_type!(
    #[doc(alias = "nw_browser")]
    #[doc(alias = "nw_browser_t")]
    pub Browser(ns::Id)
);

unsafe impl Send for Browser {}
unsafe impl Sync for Browser {}

impl Browser {
    #[doc(alias = "nw_browser_create")]
    #[inline]
    pub fn with_desc(desc: &nw::BrowseDesc, params: Option<&nw::Params>) -> arc::R<Self> {
        unsafe { nw_browser_create(desc, params) }
    }

    #[doc(alias = "nw_browser_set_queue")]
    #[inline]
    fn set_queue(&mut self, val: &dispatch::Queue) {
        unsafe { nw_browser_set_queue(self, val) }
    }

    #[inline]
    pub fn start(&mut self, queue: &dispatch::Queue) {
        self.set_queue(queue);
        unsafe { nw_browser_start(self) }
    }

    #[doc(alias = "nw_browser_cancel")]
    #[inline]
    pub fn cancel(&mut self) {
        unsafe { nw_browser_cancel(self) }
    }

    #[doc(alias = "nw_browser_copy_parameters")]
    #[inline]
    pub fn params(&self) -> arc::R<nw::Params> {
        unsafe { nw_browser_copy_parameters(self) }
    }

    #[doc(alias = "nw_browser_copy_browse_descriptor")]
    #[inline]
    pub fn desc(&self) -> arc::R<nw::BrowseDesc> {
        unsafe { nw_browser_copy_browse_descriptor(self) }
    }

    #[doc(alias = "nw_browser_set_state_changed_handler")]
    #[cfg(feature = "blocks")]
    #[inline]
    pub fn set_state_changed_handler(&mut self, handler: Option<&mut StateChangedHandler>) {
        unsafe {
            nw_browser_set_state_changed_handler(self, handler);
        }
    }

    #[doc(alias = "nw_browser_set_browse_results_changed_handler")]
    #[cfg(feature = "blocks")]
    #[inline]
    pub fn set_results_changed_handler(
        &mut self,
        handler: Option<&mut BrowseResultsChandedHandler>,
    ) {
        unsafe {
            nw_browser_set_browse_results_changed_handler(self, handler);
        }
    }
}

#[link(name = "Network", kind = "framework")]
unsafe extern "C-unwind" {
    fn nw_browser_create(
        descriptor: &nw::BrowseDesc,
        params: Option<&nw::Params>,
    ) -> arc::R<Browser>;
    fn nw_browser_set_queue(browser: &mut Browser, val: &dispatch::Queue);
    fn nw_browser_start(browser: &mut Browser);
    fn nw_browser_cancel(browser: &mut Browser);
    fn nw_browser_copy_parameters(browser: &Browser) -> arc::R<nw::Params>;
    fn nw_browser_copy_browse_descriptor(browser: &Browser) -> arc::R<nw::BrowseDesc>;
    #[cfg(feature = "blocks")]
    fn nw_browser_set_browse_results_changed_handler(
        browser: &mut Browser,
        handler: Option<&mut BrowseResultsChandedHandler>,
    );
    #[cfg(feature = "blocks")]
    fn nw_browser_set_state_changed_handler(
        browser: &mut Browser,
        handler: Option<&mut StateChangedHandler>,
    );
}

#[cfg(test)]
mod tests {
    use crate::{dispatch, nw};

    #[test]
    fn basics() {
        let queue = dispatch::Queue::new();
        let desc = nw::BrowseDesc::bonjour_service(c"_service._udp", None::<&std::ffi::CStr>);
        let mut browser = nw::Browser::with_desc(&desc, None);
        let mut state_handler = nw::BrowserChangedHandler::new2(|state, error| {
            eprintln!("------ {:?} {:?}", state, error);
        });
        browser.set_state_changed_handler(Some(&mut state_handler));
        let mut changes_handler =
            nw::BrowserBrowseResultsChandedHandler::new3(|old, new, _complete| {
                eprintln!("------ {:?} {:?}", old, new);
            });
        browser.set_results_changed_handler(Some(&mut changes_handler));

        browser.start(&queue);
        eprintln!("browser {:?}", browser);
    }
}