SBListener.cpp revision 7a62c8b129b7e1b5e838b7616a794e01df01818b 
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/Core/Listener.h"
11#include "lldb/lldb-forward-rtti.h"
12#include "lldb/Host/TimeValue.h"
13
14#include "lldb/API/SBListener.h"
15#include "lldb/API/SBEvent.h"
16#include "lldb/API/SBBroadcaster.h"
17
18using namespace lldb;
19using namespace lldb_private;
20
21
22SBListener::SBListener ()
23{
24}
25
26SBListener::SBListener (const char *name) :
27    m_lldb_object_ptr (new Listener (name)),
28    m_lldb_object_ptr_owned (true)
29{
30}
31
32SBListener::SBListener (Listener &listener) :
33    m_lldb_object_ptr (&listener),
34    m_lldb_object_ptr_owned (false)
35{
36}
37
38SBListener::~SBListener ()
39{
40    if (m_lldb_object_ptr_owned)
41    {
42        if (m_lldb_object_ptr)
43        {
44            delete m_lldb_object_ptr;
45            m_lldb_object_ptr = NULL;
46        }
47    }
48}
49
50bool
51SBListener::IsValid() const
52{
53    return m_lldb_object_ptr != NULL;
54}
55
56void
57SBListener::AddEvent (const SBEvent &event)
58{
59    EventSP &event_sp = event.GetSharedPtr ();
60    if (event_sp)
61        m_lldb_object_ptr->AddEvent (event_sp);
62}
63
64void
65SBListener::Clear ()
66{
67    if (IsValid())
68        m_lldb_object_ptr->Clear ();
69}
70
71uint32_t
72SBListener::StartListeningForEvents (const SBBroadcaster& broadcaster, uint32_t event_mask)
73{
74    if (IsValid() && broadcaster.IsValid())
75    {
76        return m_lldb_object_ptr->StartListeningForEvents (broadcaster.GetLLDBObjectPtr (), event_mask);
77    }
78    return false;
79}
80
81bool
82SBListener::StopListeningForEvents (const SBBroadcaster& broadcaster, uint32_t event_mask)
83{
84    if (IsValid() && broadcaster.IsValid())
85    {
86        return m_lldb_object_ptr->StopListeningForEvents (broadcaster.GetLLDBObjectPtr (), event_mask);
87    }
88    return false;
89}
90
91bool
92SBListener::WaitForEvent (uint32_t num_seconds, SBEvent &event)
93{
94    if (IsValid())
95    {
96        TimeValue time_value;
97        if (num_seconds != UINT32_MAX)
98        {
99            assert (num_seconds != 0); // Take this out after all calls with timeout set to zero have been removed....
100            time_value = TimeValue::Now();
101            time_value.OffsetWithSeconds (num_seconds);
102        }
103        EventSP event_sp;
104        if (m_lldb_object_ptr->WaitForEvent (time_value.IsValid() ? &time_value : NULL, event_sp))
105        {
106            event.SetEventSP (event_sp);
107            return true;
108        }
109    }
110    event.SetLLDBObjectPtr (NULL);
111    return false;
112}
113
114bool
115SBListener::WaitForEventForBroadcaster
116(
117    uint32_t num_seconds,
118    const SBBroadcaster &broadcaster,
119    SBEvent &event
120)
121{
122    if (IsValid() && broadcaster.IsValid())
123    {
124        TimeValue time_value;
125        if (num_seconds != UINT32_MAX)
126        {
127            time_value = TimeValue::Now();
128            time_value.OffsetWithSeconds (num_seconds);
129        }
130        EventSP event_sp;
131        if (m_lldb_object_ptr->WaitForEventForBroadcaster (time_value.IsValid() ? &time_value : NULL,
132                                                         broadcaster.GetLLDBObjectPtr (),
133                                                         event_sp))
134        {
135            event.SetEventSP (event_sp);
136            return true;
137        }
138
139    }
140    event.SetLLDBObjectPtr (NULL);
141    return false;
142}
143
144bool
145SBListener::WaitForEventForBroadcasterWithType
146(
147    uint32_t num_seconds,
148    const SBBroadcaster &broadcaster,
149    uint32_t event_type_mask,
150    SBEvent &event
151)
152{
153    if (IsValid() && broadcaster.IsValid())
154    {
155        TimeValue time_value;
156        if (num_seconds != UINT32_MAX)
157        {
158            time_value = TimeValue::Now();
159            time_value.OffsetWithSeconds (num_seconds);
160        }
161        EventSP event_sp;
162        if (m_lldb_object_ptr->WaitForEventForBroadcasterWithType (time_value.IsValid() ? &time_value : NULL,
163                                                                 broadcaster.GetLLDBObjectPtr (),
164                                                                 event_type_mask,
165                                                                 event_sp))
166        {
167            event.SetEventSP (event_sp);
168            return true;
169        }
170    }
171    event.SetLLDBObjectPtr (NULL);
172    return false;
173}
174
175bool
176SBListener::PeekAtNextEvent (SBEvent &event)
177{
178    if (m_lldb_object_ptr)
179    {
180        event.SetLLDBObjectPtr (m_lldb_object_ptr->PeekAtNextEvent ());
181        return event.IsValid();
182    }
183    event.SetLLDBObjectPtr (NULL);
184    return false;
185}
186
187bool
188SBListener::PeekAtNextEventForBroadcaster (const SBBroadcaster &broadcaster, SBEvent &event)
189{
190    if (IsValid() && broadcaster.IsValid())
191    {
192        event.SetLLDBObjectPtr (m_lldb_object_ptr->PeekAtNextEventForBroadcaster (broadcaster.GetLLDBObjectPtr ()));
193        return event.IsValid();
194    }
195    event.SetLLDBObjectPtr (NULL);
196    return false;
197}
198
199bool
200SBListener::PeekAtNextEventForBroadcasterWithType (const SBBroadcaster &broadcaster, uint32_t event_type_mask,
201                                                   SBEvent &event)
202{
203    if (IsValid() && broadcaster.IsValid())
204    {
205        event.SetLLDBObjectPtr(m_lldb_object_ptr->PeekAtNextEventForBroadcasterWithType (broadcaster.GetLLDBObjectPtr (), event_type_mask));
206        return event.IsValid();
207    }
208    event.SetLLDBObjectPtr (NULL);
209    return false;
210}
211
212bool
213SBListener::GetNextEvent (SBEvent &event)
214{
215    if (m_lldb_object_ptr)
216    {
217        EventSP event_sp;
218        if (m_lldb_object_ptr->GetNextEvent (event_sp))
219        {
220            event.SetEventSP (event_sp);
221            return true;
222        }
223    }
224    event.SetLLDBObjectPtr (NULL);
225    return false;
226}
227
228bool
229SBListener::GetNextEventForBroadcaster (const SBBroadcaster &broadcaster, SBEvent &event)
230{
231    if (IsValid() && broadcaster.IsValid())
232    {
233        EventSP event_sp;
234        if (m_lldb_object_ptr->GetNextEventForBroadcaster (broadcaster.GetLLDBObjectPtr (), event_sp))
235        {
236            event.SetEventSP (event_sp);
237            return true;
238        }
239    }
240    event.SetLLDBObjectPtr (NULL);
241    return false;
242}
243
244bool
245SBListener::GetNextEventForBroadcasterWithType
246(
247    const SBBroadcaster &broadcaster,
248    uint32_t event_type_mask,
249    SBEvent &event
250)
251{
252    if (IsValid() && broadcaster.IsValid())
253    {
254        EventSP event_sp;
255        if (m_lldb_object_ptr->GetNextEventForBroadcasterWithType (broadcaster.GetLLDBObjectPtr (),
256                                                                 event_type_mask,
257                                                                 event_sp))
258        {
259            event.SetEventSP (event_sp);
260            return true;
261        }
262    }
263    event.SetLLDBObjectPtr (NULL);
264    return false;
265}
266
267bool
268SBListener::HandleBroadcastEvent (const SBEvent &event)
269{
270    if (m_lldb_object_ptr)
271        return m_lldb_object_ptr->HandleBroadcastEvent (event.GetSharedPtr());
272    return false;
273}
274
275lldb_private::Listener *
276SBListener::operator->() const
277{
278    return m_lldb_object_ptr;
279}
280
281lldb_private::Listener *
282SBListener::get() const
283{
284    return m_lldb_object_ptr;
285}
286
287lldb_private::Listener &
288SBListener::operator *()
289{
290    return *m_lldb_object_ptr;
291}
292
293const lldb_private::Listener &
294SBListener::operator *() const
295{
296    return *m_lldb_object_ptr;
297}
298
299
300