Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 1 | //===-- SBListener.cpp ------------------------------------------*- C++ -*-===// |
| 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
| 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
| 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | |
Daniel Malea | d891f9b | 2012-12-05 00:20:57 +0000 | [diff] [blame] | 10 | #include "lldb/lldb-python.h" |
| 11 | |
Greg Clayton | 49ce682 | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 12 | #include "lldb/API/SBListener.h" |
| 13 | #include "lldb/API/SBBroadcaster.h" |
Jim Ingham | 5a15e69 | 2012-02-16 06:50:00 +0000 | [diff] [blame] | 14 | #include "lldb/API/SBDebugger.h" |
Greg Clayton | 49ce682 | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 15 | #include "lldb/API/SBEvent.h" |
| 16 | #include "lldb/API/SBStream.h" |
| 17 | #include "lldb/Core/Broadcaster.h" |
Jim Ingham | 5a15e69 | 2012-02-16 06:50:00 +0000 | [diff] [blame] | 18 | #include "lldb/Core/Debugger.h" |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 19 | #include "lldb/Core/Listener.h" |
Caroline Tice | 7826c88 | 2010-10-26 03:11:13 +0000 | [diff] [blame] | 20 | #include "lldb/Core/Log.h" |
Greg Clayton | 49ce682 | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 21 | #include "lldb/Core/StreamString.h" |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 22 | #include "lldb/Host/TimeValue.h" |
| 23 | |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 24 | |
| 25 | using namespace lldb; |
| 26 | using namespace lldb_private; |
| 27 | |
| 28 | |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 29 | SBListener::SBListener () : |
Greg Clayton | 538eb82 | 2010-11-05 23:17:00 +0000 | [diff] [blame] | 30 | m_opaque_sp (), |
| 31 | m_opaque_ptr (NULL) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 32 | { |
| 33 | } |
| 34 | |
| 35 | SBListener::SBListener (const char *name) : |
Greg Clayton | 538eb82 | 2010-11-05 23:17:00 +0000 | [diff] [blame] | 36 | m_opaque_sp (new Listener (name)), |
| 37 | m_opaque_ptr (NULL) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 38 | { |
Greg Clayton | 538eb82 | 2010-11-05 23:17:00 +0000 | [diff] [blame] | 39 | m_opaque_ptr = m_opaque_sp.get(); |
| 40 | |
Greg Clayton | 952e9dc | 2013-03-27 23:08:40 +0000 | [diff] [blame] | 41 | Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Caroline Tice | 7826c88 | 2010-10-26 03:11:13 +0000 | [diff] [blame] | 42 | |
| 43 | if (log) |
Greg Clayton | 49ce682 | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 44 | log->Printf ("SBListener::SBListener (name=\"%s\") => SBListener(%p)", |
Caroline Tice | 61ba7ec | 2010-10-26 23:49:36 +0000 | [diff] [blame] | 45 | name, m_opaque_ptr); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 46 | } |
| 47 | |
Greg Clayton | 538eb82 | 2010-11-05 23:17:00 +0000 | [diff] [blame] | 48 | |
| 49 | SBListener::SBListener (const SBListener &rhs) : |
| 50 | m_opaque_sp (rhs.m_opaque_sp), |
| 51 | m_opaque_ptr (rhs.m_opaque_ptr) |
| 52 | { |
| 53 | } |
| 54 | |
| 55 | const lldb::SBListener & |
| 56 | SBListener::operator = (const lldb::SBListener &rhs) |
| 57 | { |
| 58 | if (this != &rhs) |
| 59 | { |
| 60 | m_opaque_sp = rhs.m_opaque_sp; |
| 61 | m_opaque_ptr = rhs.m_opaque_ptr; |
| 62 | } |
| 63 | return *this; |
| 64 | } |
| 65 | |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 66 | SBListener::SBListener (Listener &listener) : |
Greg Clayton | 538eb82 | 2010-11-05 23:17:00 +0000 | [diff] [blame] | 67 | m_opaque_sp (), |
| 68 | m_opaque_ptr (&listener) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 69 | { |
| 70 | } |
| 71 | |
| 72 | SBListener::~SBListener () |
| 73 | { |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 74 | } |
| 75 | |
| 76 | bool |
| 77 | SBListener::IsValid() const |
| 78 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 79 | return m_opaque_ptr != NULL; |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 80 | } |
| 81 | |
| 82 | void |
| 83 | SBListener::AddEvent (const SBEvent &event) |
| 84 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 85 | EventSP &event_sp = event.GetSP (); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 86 | if (event_sp) |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 87 | m_opaque_ptr->AddEvent (event_sp); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 88 | } |
| 89 | |
| 90 | void |
| 91 | SBListener::Clear () |
| 92 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 93 | if (m_opaque_ptr) |
| 94 | m_opaque_ptr->Clear (); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 95 | } |
| 96 | |
Jim Ingham | 4c87ebf | 2012-05-08 20:05:08 +0000 | [diff] [blame] | 97 | uint32_t |
| 98 | SBListener::StartListeningForEventClass (SBDebugger &debugger, |
| 99 | const char *broadcaster_class, |
| 100 | uint32_t event_mask) |
| 101 | { |
| 102 | if (m_opaque_ptr) |
Jim Ingham | 5a15e69 | 2012-02-16 06:50:00 +0000 | [diff] [blame] | 103 | { |
Jim Ingham | 4c87ebf | 2012-05-08 20:05:08 +0000 | [diff] [blame] | 104 | Debugger *lldb_debugger = debugger.get(); |
| 105 | if (!lldb_debugger) |
Jim Ingham | 5a15e69 | 2012-02-16 06:50:00 +0000 | [diff] [blame] | 106 | return 0; |
Jim Ingham | 4c87ebf | 2012-05-08 20:05:08 +0000 | [diff] [blame] | 107 | BroadcastEventSpec event_spec (ConstString (broadcaster_class), event_mask); |
| 108 | return m_opaque_ptr->StartListeningForEventSpec (*lldb_debugger, event_spec); |
Jim Ingham | 5a15e69 | 2012-02-16 06:50:00 +0000 | [diff] [blame] | 109 | } |
Jim Ingham | 4c87ebf | 2012-05-08 20:05:08 +0000 | [diff] [blame] | 110 | else |
| 111 | return 0; |
| 112 | } |
| 113 | |
| 114 | bool |
| 115 | SBListener::StopListeningForEventClass (SBDebugger &debugger, |
| 116 | const char *broadcaster_class, |
| 117 | uint32_t event_mask) |
| 118 | { |
| 119 | if (m_opaque_ptr) |
Jim Ingham | 5a15e69 | 2012-02-16 06:50:00 +0000 | [diff] [blame] | 120 | { |
Jim Ingham | 4c87ebf | 2012-05-08 20:05:08 +0000 | [diff] [blame] | 121 | Debugger *lldb_debugger = debugger.get(); |
| 122 | if (!lldb_debugger) |
Jim Ingham | 5a15e69 | 2012-02-16 06:50:00 +0000 | [diff] [blame] | 123 | return false; |
Jim Ingham | 4c87ebf | 2012-05-08 20:05:08 +0000 | [diff] [blame] | 124 | BroadcastEventSpec event_spec (ConstString (broadcaster_class), event_mask); |
| 125 | return m_opaque_ptr->StopListeningForEventSpec (*lldb_debugger, event_spec); |
Jim Ingham | 5a15e69 | 2012-02-16 06:50:00 +0000 | [diff] [blame] | 126 | } |
Jim Ingham | 4c87ebf | 2012-05-08 20:05:08 +0000 | [diff] [blame] | 127 | else |
| 128 | return false; |
| 129 | } |
Jim Ingham | 5a15e69 | 2012-02-16 06:50:00 +0000 | [diff] [blame] | 130 | |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 131 | uint32_t |
| 132 | SBListener::StartListeningForEvents (const SBBroadcaster& broadcaster, uint32_t event_mask) |
| 133 | { |
Greg Clayton | 49ce682 | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 134 | uint32_t acquired_event_mask = 0; |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 135 | if (m_opaque_ptr && broadcaster.IsValid()) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 136 | { |
Greg Clayton | 49ce682 | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 137 | acquired_event_mask = m_opaque_ptr->StartListeningForEvents (broadcaster.get(), event_mask); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 138 | } |
Caroline Tice | 7826c88 | 2010-10-26 03:11:13 +0000 | [diff] [blame] | 139 | |
Jason Molenda | 08f60c8 | 2013-05-04 00:39:52 +0000 | [diff] [blame] | 140 | Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API); |
Caroline Tice | 7826c88 | 2010-10-26 03:11:13 +0000 | [diff] [blame] | 141 | if (log) |
Greg Clayton | 49ce682 | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 142 | { |
| 143 | StreamString sstr_requested; |
| 144 | StreamString sstr_acquired; |
| 145 | |
| 146 | Broadcaster *lldb_broadcaster = broadcaster.get(); |
| 147 | if (lldb_broadcaster) |
| 148 | { |
| 149 | const bool got_requested_names = lldb_broadcaster->GetEventNames (sstr_requested, event_mask, false); |
| 150 | const bool got_acquired_names = lldb_broadcaster->GetEventNames (sstr_acquired, acquired_event_mask, false); |
| 151 | log->Printf ("SBListener(%p)::StartListeneingForEvents (SBBroadcaster(%p): %s, event_mask=0x%8.8x%s%s%s) => 0x%8.8x%s%s%s", |
| 152 | m_opaque_ptr, |
| 153 | lldb_broadcaster, |
| 154 | lldb_broadcaster->GetBroadcasterName().GetCString(), |
| 155 | event_mask, |
| 156 | got_requested_names ? " (" : "", |
| 157 | sstr_requested.GetData(), |
| 158 | got_requested_names ? ")" : "", |
| 159 | acquired_event_mask, |
| 160 | got_acquired_names ? " (" : "", |
| 161 | sstr_acquired.GetData(), |
| 162 | got_acquired_names ? ")" : ""); |
| 163 | } |
| 164 | else |
| 165 | { |
| 166 | log->Printf ("SBListener(%p)::StartListeneingForEvents (SBBroadcaster(%p), event_mask=0x%8.8x) => 0x%8.8x", |
| 167 | m_opaque_ptr, |
| 168 | lldb_broadcaster, |
| 169 | event_mask, |
| 170 | acquired_event_mask); |
| 171 | |
| 172 | } |
| 173 | } |
Caroline Tice | 7826c88 | 2010-10-26 03:11:13 +0000 | [diff] [blame] | 174 | |
Greg Clayton | 49ce682 | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 175 | return acquired_event_mask; |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 176 | } |
| 177 | |
| 178 | bool |
| 179 | SBListener::StopListeningForEvents (const SBBroadcaster& broadcaster, uint32_t event_mask) |
| 180 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 181 | if (m_opaque_ptr && broadcaster.IsValid()) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 182 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 183 | return m_opaque_ptr->StopListeningForEvents (broadcaster.get(), event_mask); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 184 | } |
| 185 | return false; |
| 186 | } |
| 187 | |
| 188 | bool |
Greg Clayton | 49ce682 | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 189 | SBListener::WaitForEvent (uint32_t timeout_secs, SBEvent &event) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 190 | { |
Greg Clayton | 952e9dc | 2013-03-27 23:08:40 +0000 | [diff] [blame] | 191 | Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Greg Clayton | 49ce682 | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 192 | if (log) |
| 193 | { |
| 194 | if (timeout_secs == UINT32_MAX) |
| 195 | { |
| 196 | log->Printf ("SBListener(%p)::WaitForEvent (timeout_secs=INFINITE, SBEvent(%p))...", |
| 197 | m_opaque_ptr, event.get()); |
| 198 | } |
| 199 | else |
| 200 | { |
| 201 | log->Printf ("SBListener(%p)::WaitForEvent (timeout_secs=%d, SBEvent(%p))...", |
| 202 | m_opaque_ptr, timeout_secs, event.get()); |
| 203 | } |
| 204 | } |
| 205 | bool success = false; |
Caroline Tice | 7826c88 | 2010-10-26 03:11:13 +0000 | [diff] [blame] | 206 | |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 207 | if (m_opaque_ptr) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 208 | { |
| 209 | TimeValue time_value; |
Greg Clayton | 49ce682 | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 210 | if (timeout_secs != UINT32_MAX) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 211 | { |
Greg Clayton | 49ce682 | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 212 | assert (timeout_secs != 0); // Take this out after all calls with timeout set to zero have been removed.... |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 213 | time_value = TimeValue::Now(); |
Greg Clayton | 49ce682 | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 214 | time_value.OffsetWithSeconds (timeout_secs); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 215 | } |
| 216 | EventSP event_sp; |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 217 | if (m_opaque_ptr->WaitForEvent (time_value.IsValid() ? &time_value : NULL, event_sp)) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 218 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 219 | event.reset (event_sp); |
Greg Clayton | 49ce682 | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 220 | success = true; |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 221 | } |
| 222 | } |
Caroline Tice | 7826c88 | 2010-10-26 03:11:13 +0000 | [diff] [blame] | 223 | |
| 224 | if (log) |
Greg Clayton | 49ce682 | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 225 | { |
| 226 | if (timeout_secs == UINT32_MAX) |
| 227 | { |
| 228 | log->Printf ("SBListener(%p)::WaitForEvent (timeout_secs=INFINITE, SBEvent(%p)) => %i", |
| 229 | m_opaque_ptr, event.get(), success); |
| 230 | } |
| 231 | else |
| 232 | { |
| 233 | log->Printf ("SBListener(%p)::WaitForEvent (timeout_secs=%d, SBEvent(%p)) => %i", |
| 234 | m_opaque_ptr, timeout_secs, event.get(), success); |
| 235 | } |
| 236 | } |
| 237 | if (!success) |
| 238 | event.reset (NULL); |
| 239 | return success; |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 240 | } |
| 241 | |
| 242 | bool |
| 243 | SBListener::WaitForEventForBroadcaster |
| 244 | ( |
| 245 | uint32_t num_seconds, |
| 246 | const SBBroadcaster &broadcaster, |
| 247 | SBEvent &event |
| 248 | ) |
| 249 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 250 | if (m_opaque_ptr && broadcaster.IsValid()) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 251 | { |
| 252 | TimeValue time_value; |
| 253 | if (num_seconds != UINT32_MAX) |
| 254 | { |
| 255 | time_value = TimeValue::Now(); |
| 256 | time_value.OffsetWithSeconds (num_seconds); |
| 257 | } |
| 258 | EventSP event_sp; |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 259 | if (m_opaque_ptr->WaitForEventForBroadcaster (time_value.IsValid() ? &time_value : NULL, |
| 260 | broadcaster.get(), |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 261 | event_sp)) |
| 262 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 263 | event.reset (event_sp); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 264 | return true; |
| 265 | } |
| 266 | |
| 267 | } |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 268 | event.reset (NULL); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 269 | return false; |
| 270 | } |
| 271 | |
| 272 | bool |
| 273 | SBListener::WaitForEventForBroadcasterWithType |
| 274 | ( |
| 275 | uint32_t num_seconds, |
| 276 | const SBBroadcaster &broadcaster, |
| 277 | uint32_t event_type_mask, |
| 278 | SBEvent &event |
| 279 | ) |
| 280 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 281 | if (m_opaque_ptr && broadcaster.IsValid()) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 282 | { |
| 283 | TimeValue time_value; |
| 284 | if (num_seconds != UINT32_MAX) |
| 285 | { |
| 286 | time_value = TimeValue::Now(); |
| 287 | time_value.OffsetWithSeconds (num_seconds); |
| 288 | } |
| 289 | EventSP event_sp; |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 290 | if (m_opaque_ptr->WaitForEventForBroadcasterWithType (time_value.IsValid() ? &time_value : NULL, |
| 291 | broadcaster.get(), |
| 292 | event_type_mask, |
| 293 | event_sp)) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 294 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 295 | event.reset (event_sp); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 296 | return true; |
| 297 | } |
| 298 | } |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 299 | event.reset (NULL); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 300 | return false; |
| 301 | } |
| 302 | |
| 303 | bool |
| 304 | SBListener::PeekAtNextEvent (SBEvent &event) |
| 305 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 306 | if (m_opaque_ptr) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 307 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 308 | event.reset (m_opaque_ptr->PeekAtNextEvent ()); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 309 | return event.IsValid(); |
| 310 | } |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 311 | event.reset (NULL); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 312 | return false; |
| 313 | } |
| 314 | |
| 315 | bool |
| 316 | SBListener::PeekAtNextEventForBroadcaster (const SBBroadcaster &broadcaster, SBEvent &event) |
| 317 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 318 | if (m_opaque_ptr && broadcaster.IsValid()) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 319 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 320 | event.reset (m_opaque_ptr->PeekAtNextEventForBroadcaster (broadcaster.get())); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 321 | return event.IsValid(); |
| 322 | } |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 323 | event.reset (NULL); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 324 | return false; |
| 325 | } |
| 326 | |
| 327 | bool |
| 328 | SBListener::PeekAtNextEventForBroadcasterWithType (const SBBroadcaster &broadcaster, uint32_t event_type_mask, |
| 329 | SBEvent &event) |
| 330 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 331 | if (m_opaque_ptr && broadcaster.IsValid()) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 332 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 333 | event.reset(m_opaque_ptr->PeekAtNextEventForBroadcasterWithType (broadcaster.get(), event_type_mask)); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 334 | return event.IsValid(); |
| 335 | } |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 336 | event.reset (NULL); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 337 | return false; |
| 338 | } |
| 339 | |
| 340 | bool |
| 341 | SBListener::GetNextEvent (SBEvent &event) |
| 342 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 343 | if (m_opaque_ptr) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 344 | { |
| 345 | EventSP event_sp; |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 346 | if (m_opaque_ptr->GetNextEvent (event_sp)) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 347 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 348 | event.reset (event_sp); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 349 | return true; |
| 350 | } |
| 351 | } |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 352 | event.reset (NULL); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 353 | return false; |
| 354 | } |
| 355 | |
| 356 | bool |
| 357 | SBListener::GetNextEventForBroadcaster (const SBBroadcaster &broadcaster, SBEvent &event) |
| 358 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 359 | if (m_opaque_ptr && broadcaster.IsValid()) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 360 | { |
| 361 | EventSP event_sp; |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 362 | if (m_opaque_ptr->GetNextEventForBroadcaster (broadcaster.get(), event_sp)) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 363 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 364 | event.reset (event_sp); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 365 | return true; |
| 366 | } |
| 367 | } |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 368 | event.reset (NULL); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 369 | return false; |
| 370 | } |
| 371 | |
| 372 | bool |
| 373 | SBListener::GetNextEventForBroadcasterWithType |
| 374 | ( |
| 375 | const SBBroadcaster &broadcaster, |
| 376 | uint32_t event_type_mask, |
| 377 | SBEvent &event |
| 378 | ) |
| 379 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 380 | if (m_opaque_ptr && broadcaster.IsValid()) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 381 | { |
| 382 | EventSP event_sp; |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 383 | if (m_opaque_ptr->GetNextEventForBroadcasterWithType (broadcaster.get(), |
| 384 | event_type_mask, |
| 385 | event_sp)) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 386 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 387 | event.reset (event_sp); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 388 | return true; |
| 389 | } |
| 390 | } |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 391 | event.reset (NULL); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 392 | return false; |
| 393 | } |
| 394 | |
| 395 | bool |
| 396 | SBListener::HandleBroadcastEvent (const SBEvent &event) |
| 397 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 398 | if (m_opaque_ptr) |
| 399 | return m_opaque_ptr->HandleBroadcastEvent (event.GetSP()); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 400 | return false; |
| 401 | } |
| 402 | |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 403 | Listener * |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 404 | SBListener::operator->() const |
| 405 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 406 | return m_opaque_ptr; |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 407 | } |
| 408 | |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 409 | Listener * |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 410 | SBListener::get() const |
| 411 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 412 | return m_opaque_ptr; |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 413 | } |
| 414 | |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 415 | void |
Greg Clayton | 538eb82 | 2010-11-05 23:17:00 +0000 | [diff] [blame] | 416 | SBListener::reset(Listener *listener, bool owns) |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 417 | { |
Greg Clayton | 538eb82 | 2010-11-05 23:17:00 +0000 | [diff] [blame] | 418 | if (owns) |
| 419 | m_opaque_sp.reset (listener); |
| 420 | else |
| 421 | m_opaque_sp.reset (); |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 422 | m_opaque_ptr = listener; |
| 423 | } |
| 424 | |
Greg Clayton | 271a5db | 2011-02-03 21:28:34 +0000 | [diff] [blame] | 425 | Listener & |
| 426 | SBListener::ref() const |
| 427 | { |
| 428 | return *m_opaque_ptr; |
| 429 | } |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 430 | |
| 431 | Listener & |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 432 | SBListener::operator *() |
| 433 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 434 | return *m_opaque_ptr; |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 435 | } |
| 436 | |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 437 | const Listener & |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 438 | SBListener::operator *() const |
| 439 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 440 | return *m_opaque_ptr; |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 441 | } |
| 442 | |
| 443 | |