SBListener.cpp revision 49ce682dfa7993d31206cea19ce7006cd3f3077e 
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
10#include "lldb/API/SBListener.h"
11#include "lldb/API/SBBroadcaster.h"
12#include "lldb/API/SBEvent.h"
13#include "lldb/API/SBStream.h"
14#include "lldb/Core/Broadcaster.h"
15#include "lldb/Core/Listener.h"
16#include "lldb/Core/Log.h"
17#include "lldb/Core/StreamString.h"
18#include "lldb/Host/TimeValue.h"
19
20
21using namespace lldb;
22using namespace lldb_private;
23
24
25SBListener::SBListener () :
26    m_opaque_ptr (NULL),
27    m_opaque_ptr_owned (false)
28{
29}
30
31SBListener::SBListener (const char *name) :
32    m_opaque_ptr (new Listener (name)),
33    m_opaque_ptr_owned (true)
34{
35    Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API);
36
37    if (log)
38        log->Printf ("SBListener::SBListener (name=\"%s\") => SBListener(%p)",
39                     name, m_opaque_ptr);
40}
41
42SBListener::SBListener (Listener &listener) :
43    m_opaque_ptr (&listener),
44    m_opaque_ptr_owned (false)
45{
46}
47
48SBListener::~SBListener ()
49{
50    if (m_opaque_ptr_owned)
51    {
52        if (m_opaque_ptr)
53        {
54            delete m_opaque_ptr;
55            m_opaque_ptr = NULL;
56        }
57    }
58}
59
60bool
61SBListener::IsValid() const
62{
63    return m_opaque_ptr != NULL;
64}
65
66void
67SBListener::AddEvent (const SBEvent &event)
68{
69    EventSP &event_sp = event.GetSP ();
70    if (event_sp)
71        m_opaque_ptr->AddEvent (event_sp);
72}
73
74void
75SBListener::Clear ()
76{
77    if (m_opaque_ptr)
78        m_opaque_ptr->Clear ();
79}
80
81uint32_t
82SBListener::StartListeningForEvents (const SBBroadcaster& broadcaster, uint32_t event_mask)
83{
84    Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API);
85
86    uint32_t acquired_event_mask = 0;
87    if (m_opaque_ptr && broadcaster.IsValid())
88    {
89        acquired_event_mask = m_opaque_ptr->StartListeningForEvents (broadcaster.get(), event_mask);
90    }
91
92    log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API);
93    if (log)
94    {
95        StreamString sstr_requested;
96        StreamString sstr_acquired;
97
98        Broadcaster *lldb_broadcaster = broadcaster.get();
99        if (lldb_broadcaster)
100        {
101            const bool got_requested_names = lldb_broadcaster->GetEventNames (sstr_requested, event_mask, false);
102            const bool got_acquired_names = lldb_broadcaster->GetEventNames (sstr_acquired, acquired_event_mask, false);
103            log->Printf ("SBListener(%p)::StartListeneingForEvents (SBBroadcaster(%p): %s, event_mask=0x%8.8x%s%s%s) => 0x%8.8x%s%s%s",
104                         m_opaque_ptr,
105                         lldb_broadcaster,
106                         lldb_broadcaster->GetBroadcasterName().GetCString(),
107                         event_mask,
108                         got_requested_names ? " (" : "",
109                         sstr_requested.GetData(),
110                         got_requested_names ? ")" : "",
111                         acquired_event_mask,
112                         got_acquired_names ? " (" : "",
113                         sstr_acquired.GetData(),
114                         got_acquired_names ? ")" : "");
115        }
116        else
117        {
118            log->Printf ("SBListener(%p)::StartListeneingForEvents (SBBroadcaster(%p), event_mask=0x%8.8x) => 0x%8.8x",
119                         m_opaque_ptr,
120                         lldb_broadcaster,
121                         event_mask,
122                         acquired_event_mask);
123
124        }
125    }
126
127    return acquired_event_mask;
128}
129
130bool
131SBListener::StopListeningForEvents (const SBBroadcaster& broadcaster, uint32_t event_mask)
132{
133    if (m_opaque_ptr && broadcaster.IsValid())
134    {
135        return m_opaque_ptr->StopListeningForEvents (broadcaster.get(), event_mask);
136    }
137    return false;
138}
139
140bool
141SBListener::WaitForEvent (uint32_t timeout_secs, SBEvent &event)
142{
143    Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API);
144    if (log)
145    {
146        if (timeout_secs == UINT32_MAX)
147        {
148            log->Printf ("SBListener(%p)::WaitForEvent (timeout_secs=INFINITE, SBEvent(%p))...",
149                         m_opaque_ptr, event.get());
150        }
151        else
152        {
153            log->Printf ("SBListener(%p)::WaitForEvent (timeout_secs=%d, SBEvent(%p))...",
154                         m_opaque_ptr, timeout_secs, event.get());
155        }
156    }
157    bool success = false;
158
159    if (m_opaque_ptr)
160    {
161        TimeValue time_value;
162        if (timeout_secs != UINT32_MAX)
163        {
164            assert (timeout_secs != 0); // Take this out after all calls with timeout set to zero have been removed....
165            time_value = TimeValue::Now();
166            time_value.OffsetWithSeconds (timeout_secs);
167        }
168        EventSP event_sp;
169        if (m_opaque_ptr->WaitForEvent (time_value.IsValid() ? &time_value : NULL, event_sp))
170        {
171            event.reset (event_sp);
172            success = true;
173        }
174    }
175
176    if (log)
177    {
178        if (timeout_secs == UINT32_MAX)
179        {
180            log->Printf ("SBListener(%p)::WaitForEvent (timeout_secs=INFINITE, SBEvent(%p)) => %i",
181                         m_opaque_ptr, event.get(), success);
182        }
183        else
184        {
185            log->Printf ("SBListener(%p)::WaitForEvent (timeout_secs=%d, SBEvent(%p)) => %i",
186                         m_opaque_ptr, timeout_secs, event.get(), success);
187        }
188    }
189    if (!success)
190        event.reset (NULL);
191    return success;
192}
193
194bool
195SBListener::WaitForEventForBroadcaster
196(
197    uint32_t num_seconds,
198    const SBBroadcaster &broadcaster,
199    SBEvent &event
200)
201{
202    if (m_opaque_ptr && broadcaster.IsValid())
203    {
204        TimeValue time_value;
205        if (num_seconds != UINT32_MAX)
206        {
207            time_value = TimeValue::Now();
208            time_value.OffsetWithSeconds (num_seconds);
209        }
210        EventSP event_sp;
211        if (m_opaque_ptr->WaitForEventForBroadcaster (time_value.IsValid() ? &time_value : NULL,
212                                                         broadcaster.get(),
213                                                         event_sp))
214        {
215            event.reset (event_sp);
216            return true;
217        }
218
219    }
220    event.reset (NULL);
221    return false;
222}
223
224bool
225SBListener::WaitForEventForBroadcasterWithType
226(
227    uint32_t num_seconds,
228    const SBBroadcaster &broadcaster,
229    uint32_t event_type_mask,
230    SBEvent &event
231)
232{
233    if (m_opaque_ptr && broadcaster.IsValid())
234    {
235        TimeValue time_value;
236        if (num_seconds != UINT32_MAX)
237        {
238            time_value = TimeValue::Now();
239            time_value.OffsetWithSeconds (num_seconds);
240        }
241        EventSP event_sp;
242        if (m_opaque_ptr->WaitForEventForBroadcasterWithType (time_value.IsValid() ? &time_value : NULL,
243                                                              broadcaster.get(),
244                                                              event_type_mask,
245                                                              event_sp))
246        {
247            event.reset (event_sp);
248            return true;
249        }
250    }
251    event.reset (NULL);
252    return false;
253}
254
255bool
256SBListener::PeekAtNextEvent (SBEvent &event)
257{
258    if (m_opaque_ptr)
259    {
260        event.reset (m_opaque_ptr->PeekAtNextEvent ());
261        return event.IsValid();
262    }
263    event.reset (NULL);
264    return false;
265}
266
267bool
268SBListener::PeekAtNextEventForBroadcaster (const SBBroadcaster &broadcaster, SBEvent &event)
269{
270    if (m_opaque_ptr && broadcaster.IsValid())
271    {
272        event.reset (m_opaque_ptr->PeekAtNextEventForBroadcaster (broadcaster.get()));
273        return event.IsValid();
274    }
275    event.reset (NULL);
276    return false;
277}
278
279bool
280SBListener::PeekAtNextEventForBroadcasterWithType (const SBBroadcaster &broadcaster, uint32_t event_type_mask,
281                                                   SBEvent &event)
282{
283    if (m_opaque_ptr && broadcaster.IsValid())
284    {
285        event.reset(m_opaque_ptr->PeekAtNextEventForBroadcasterWithType (broadcaster.get(), event_type_mask));
286        return event.IsValid();
287    }
288    event.reset (NULL);
289    return false;
290}
291
292bool
293SBListener::GetNextEvent (SBEvent &event)
294{
295    if (m_opaque_ptr)
296    {
297        EventSP event_sp;
298        if (m_opaque_ptr->GetNextEvent (event_sp))
299        {
300            event.reset (event_sp);
301            return true;
302        }
303    }
304    event.reset (NULL);
305    return false;
306}
307
308bool
309SBListener::GetNextEventForBroadcaster (const SBBroadcaster &broadcaster, SBEvent &event)
310{
311    if (m_opaque_ptr && broadcaster.IsValid())
312    {
313        EventSP event_sp;
314        if (m_opaque_ptr->GetNextEventForBroadcaster (broadcaster.get(), event_sp))
315        {
316            event.reset (event_sp);
317            return true;
318        }
319    }
320    event.reset (NULL);
321    return false;
322}
323
324bool
325SBListener::GetNextEventForBroadcasterWithType
326(
327    const SBBroadcaster &broadcaster,
328    uint32_t event_type_mask,
329    SBEvent &event
330)
331{
332    if (m_opaque_ptr && broadcaster.IsValid())
333    {
334        EventSP event_sp;
335        if (m_opaque_ptr->GetNextEventForBroadcasterWithType (broadcaster.get(),
336                                                              event_type_mask,
337                                                              event_sp))
338        {
339            event.reset (event_sp);
340            return true;
341        }
342    }
343    event.reset (NULL);
344    return false;
345}
346
347bool
348SBListener::HandleBroadcastEvent (const SBEvent &event)
349{
350    if (m_opaque_ptr)
351        return m_opaque_ptr->HandleBroadcastEvent (event.GetSP());
352    return false;
353}
354
355Listener *
356SBListener::operator->() const
357{
358    return m_opaque_ptr;
359}
360
361Listener *
362SBListener::get() const
363{
364    return m_opaque_ptr;
365}
366
367void
368SBListener::reset(Listener *listener, bool transfer_ownership)
369{
370    if (m_opaque_ptr_owned && m_opaque_ptr)
371        delete m_opaque_ptr;
372    m_opaque_ptr_owned = transfer_ownership;
373    m_opaque_ptr = listener;
374}
375
376
377Listener &
378SBListener::operator *()
379{
380    return *m_opaque_ptr;
381}
382
383const Listener &
384SBListener::operator *() const
385{
386    return *m_opaque_ptr;
387}
388
389
390