lldb/
listener.rs

1// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
2// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
3// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
4// option. This file may not be copied, modified, or distributed
5// except according to those terms.
6
7use crate::{sys, SBBroadcaster, SBDebugger, SBEvent};
8use std::ffi::CString;
9
10/// Listen for debugger events.
11#[derive(Debug)]
12pub struct SBListener {
13    /// The underlying raw `SBListenerRef`.
14    pub raw: sys::SBListenerRef,
15}
16
17impl SBListener {
18    /// Construct a new `SBListener`.
19    pub fn new() -> SBListener {
20        SBListener::wrap(unsafe { sys::CreateSBListener() })
21    }
22
23    /// Construct a new `SBListener`.
24    pub(crate) fn wrap(raw: sys::SBListenerRef) -> SBListener {
25        SBListener { raw }
26    }
27
28    /// Construct a new `Some(SBListener)` or `None`.
29    pub(crate) fn maybe_wrap(raw: sys::SBListenerRef) -> Option<SBListener> {
30        if unsafe { sys::SBListenerIsValid(raw) } {
31            Some(SBListener { raw })
32        } else {
33            None
34        }
35    }
36
37    /// Check whether or not this is a valid `SBListener` value.
38    pub fn is_valid(&self) -> bool {
39        unsafe { sys::SBListenerIsValid(self.raw) }
40    }
41
42    #[allow(missing_docs)]
43    pub fn start_listening_for_event_class(
44        &self,
45        debugger: &SBDebugger,
46        broadcaster_class: &str,
47        event_mask: u32,
48    ) -> u32 {
49        let bc = CString::new(broadcaster_class).unwrap();
50        unsafe {
51            sys::SBListenerStartListeningForEventClass(
52                self.raw,
53                debugger.raw,
54                bc.as_ptr(),
55                event_mask,
56            )
57        }
58    }
59
60    #[allow(missing_docs)]
61    pub fn stop_listening_for_event_class(
62        &self,
63        debugger: &SBDebugger,
64        broadcaster_class: &str,
65        event_mask: u32,
66    ) -> bool {
67        let bc = CString::new(broadcaster_class).unwrap();
68        unsafe {
69            sys::SBListenerStopListeningForEventClass(
70                self.raw,
71                debugger.raw,
72                bc.as_ptr(),
73                event_mask,
74            )
75        }
76    }
77
78    #[allow(missing_docs)]
79    pub fn start_listening_for_events(&self, broadcaster: &SBBroadcaster, event_mask: u32) -> u32 {
80        unsafe { sys::SBListenerStartListeningForEvents(self.raw, broadcaster.raw, event_mask) }
81    }
82
83    #[allow(missing_docs)]
84    pub fn stop_listening_for_events(&self, broadcaster: &SBBroadcaster, event_mask: u32) -> bool {
85        unsafe { sys::SBListenerStopListeningForEvents(self.raw, broadcaster.raw, event_mask) }
86    }
87
88    #[allow(missing_docs)]
89    pub fn wait_for_event(&self, num_seconds: u32, event: &SBEvent) -> bool {
90        unsafe { sys::SBListenerWaitForEvent(self.raw, num_seconds, event.raw) }
91    }
92
93    #[allow(missing_docs)]
94    pub fn wait_for_event_for_broadcaster(
95        &self,
96        num_seconds: u32,
97        broadcaster: &SBBroadcaster,
98        event: &SBEvent,
99    ) -> bool {
100        unsafe {
101            sys::SBListenerWaitForEventForBroadcaster(
102                self.raw,
103                num_seconds,
104                broadcaster.raw,
105                event.raw,
106            )
107        }
108    }
109
110    #[allow(missing_docs)]
111    pub fn wait_for_event_for_broadcaster_with_type(
112        &self,
113        num_seconds: u32,
114        broadcaster: &SBBroadcaster,
115        event_type_mask: u32,
116        event: &SBEvent,
117    ) -> bool {
118        unsafe {
119            sys::SBListenerWaitForEventForBroadcasterWithType(
120                self.raw,
121                num_seconds,
122                broadcaster.raw,
123                event_type_mask,
124                event.raw,
125            )
126        }
127    }
128
129    #[allow(missing_docs)]
130    pub fn peek_at_next_event(&self, event: &SBEvent) -> bool {
131        unsafe { sys::SBListenerPeekAtNextEvent(self.raw, event.raw) }
132    }
133
134    #[allow(missing_docs)]
135    pub fn peek_at_next_event_for_broadcaster(
136        &self,
137        broadcaster: &SBBroadcaster,
138        event: &SBEvent,
139    ) -> bool {
140        unsafe {
141            sys::SBListenerPeekAtNextEventForBroadcaster(self.raw, broadcaster.raw, event.raw)
142        }
143    }
144
145    #[allow(missing_docs)]
146    pub fn peek_at_next_event_for_broadcaster_with_type(
147        &self,
148        broadcaster: &SBBroadcaster,
149        event_type_mask: u32,
150        event: &SBEvent,
151    ) -> bool {
152        unsafe {
153            sys::SBListenerPeekAtNextEventForBroadcasterWithType(
154                self.raw,
155                broadcaster.raw,
156                event_type_mask,
157                event.raw,
158            )
159        }
160    }
161
162    #[allow(missing_docs)]
163    pub fn get_next_event(&self, event: &SBEvent) -> bool {
164        unsafe { sys::SBListenerGetNextEvent(self.raw, event.raw) }
165    }
166
167    #[allow(missing_docs)]
168    pub fn get_next_event_for_broadcaster(
169        &self,
170        broadcaster: &SBBroadcaster,
171        event: &SBEvent,
172    ) -> bool {
173        unsafe { sys::SBListenerGetNextEventForBroadcaster(self.raw, broadcaster.raw, event.raw) }
174    }
175
176    #[allow(missing_docs)]
177    pub fn get_next_event_for_broadcaster_with_type(
178        &self,
179        broadcaster: &SBBroadcaster,
180        event_type_mask: u32,
181        event: &SBEvent,
182    ) -> bool {
183        unsafe {
184            sys::SBListenerGetNextEventForBroadcasterWithType(
185                self.raw,
186                broadcaster.raw,
187                event_type_mask,
188                event.raw,
189            )
190        }
191    }
192
193    #[allow(missing_docs)]
194    pub fn handle_broadcast_event(&self, event: &SBEvent) -> bool {
195        unsafe { sys::SBListenerHandleBroadcastEvent(self.raw, event.raw) }
196    }
197}
198
199impl Clone for SBListener {
200    fn clone(&self) -> SBListener {
201        SBListener {
202            raw: unsafe { sys::CloneSBListener(self.raw) },
203        }
204    }
205}
206
207impl Default for SBListener {
208    fn default() -> SBListener {
209        SBListener::new()
210    }
211}
212
213impl Drop for SBListener {
214    fn drop(&mut self) {
215        unsafe { sys::DisposeSBListener(self.raw) };
216    }
217}
218
219unsafe impl Send for SBListener {}
220unsafe impl Sync for SBListener {}
lldb/listener.rs

lldb/
listener.rs
