22 : m_name(name), m_broadcasters(), m_broadcasters_mutex(), m_events(),
23 m_events_mutex(), m_is_shadow() {
26 LLDB_LOGF(log,
"%p Listener::Listener('%s')",
static_cast<void *
>(
this),
35 LLDB_LOGF(log,
"%p Listener::%s('%s')",
static_cast<void *
>(
this),
36 __FUNCTION__,
m_name.c_str());
41 std::lock_guard<std::recursive_mutex> broadcasters_guard(
47 broadcaster_sp->RemoveListener(
this, pos->second.event_mask);
55 for (
size_t i = 0; i < num_managers; i++) {
58 manager_sp->RemoveListener(
this);
61 LLDB_LOGF(log,
"%p Listener::%s('%s')",
static_cast<void *
>(
this),
62 __FUNCTION__,
m_name.c_str());
66 uint32_t event_mask) {
71 std::lock_guard<std::recursive_mutex> broadcasters_guard(
78 uint32_t acquired_mask =
79 broadcaster->
AddListener(this->shared_from_this(), event_mask);
84 "%p Listener::StartListeningForEvents (broadcaster = %p, "
85 "mask = 0x%8.8x) acquired_mask = 0x%8.8x for %s",
86 static_cast<void *
>(
this),
static_cast<void *
>(broadcaster),
87 event_mask, acquired_mask,
m_name.c_str());
96 HandleBroadcastCallback callback,
97 void *callback_user_data) {
102 std::lock_guard<std::recursive_mutex> broadcasters_guard(
109 uint32_t acquired_mask =
110 broadcaster->
AddListener(this->shared_from_this(), event_mask);
113 if (log !=
nullptr) {
114 void **pointer =
reinterpret_cast<void **
>(&callback);
116 "%p Listener::StartListeningForEvents (broadcaster = %p, "
117 "mask = 0x%8.8x, callback = %p, user_data = %p) "
118 "acquired_mask = 0x%8.8x for %s",
119 static_cast<void *
>(
this),
static_cast<void *
>(broadcaster),
120 event_mask, *pointer,
static_cast<void *
>(callback_user_data),
121 acquired_mask,
m_name.c_str());
124 return acquired_mask;
130 uint32_t event_mask) {
134 std::lock_guard<std::recursive_mutex> broadcasters_guard(
139 return broadcaster->
RemoveListener(this->shared_from_this(), event_mask);
150 std::lock_guard<std::recursive_mutex> broadcasters_guard(
159 event_collection::iterator pos =
m_events.begin();
161 if ((*pos)->GetBroadcaster() == broadcaster)
170 const auto manager_matcher =
173 return (input_sp && input_sp == manager_sp);
181 LLDB_LOGF(log,
"%p Listener('%s')::AddEvent (event_sp = {%p})",
182 static_cast<void *
>(
this),
m_name.c_str(),
183 static_cast<void *
>(event_sp.get()));
191 std::unique_lock<std::mutex> &lock,
193 uint32_t event_type_mask,
EventSP &event_sp,
bool remove) {
203 const auto event_matcher =
204 [broadcaster, event_type_mask](
const EventSP &event_sp) ->
bool {
205 if (broadcaster && !event_sp->BroadcasterIs(broadcaster))
207 return event_type_mask == 0 || event_type_mask & event_sp->GetType();
209 Listener::event_collection::iterator pos =
m_events.end();
211 if (broadcaster ==
nullptr && event_type_mask == 0)
214 pos = llvm::find_if(
m_events, event_matcher);
221 "%p '%s' Listener::FindNextEventInternal(broadcaster=%p, "
222 "event_type_mask=0x%8.8x, "
223 "remove=%i) event %p",
224 static_cast<void *
>(
this),
GetName(),
225 static_cast<void *
>(broadcaster), event_type_mask, remove,
226 static_cast<void *
>(event_sp.get()));
234 event_sp->DoOnRemoval();
247 return event_sp.get();
255 return event_sp.get();
261 uint32_t event_type_mask) {
266 return event_sp.get();
273 uint32_t event_type_mask,
EventSP &event_sp) {
275 LLDB_LOG(log,
"this = {0}, timeout = {1} for {2}",
this, timeout,
m_name);
284 std::cv_status result = std::cv_status::no_timeout;
290 if (result == std::cv_status::timeout) {
292 LLDB_LOGF(log,
"%p Listener::GetEventInternal() timed out for %s",
293 static_cast<void *
>(
this),
m_name.c_str());
295 }
else if (result != std::cv_status::no_timeout) {
297 LLDB_LOGF(log,
"%p Listener::GetEventInternal() unknown error for %s",
298 static_cast<void *
>(
this),
m_name.c_str());
324 size_t num_handled = 0;
326 Broadcaster *broadcaster = event_sp->GetBroadcaster();
329 broadcaster_collection::iterator pos;
334 pos != end && pos->first.lock() == broadcaster_impl_sp; ++pos) {
352 const auto manager_matcher =
355 return (input_sp && input_sp == manager_sp);
359 std::lock_guard<std::recursive_mutex> manager_guard(
360 manager_sp->m_manager_mutex);
363 uint32_t bits_acquired = manager_sp->RegisterListenerForEvents(
364 this->shared_from_this(), event_spec);
372 return bits_acquired;
381 return manager_sp->UnregisterListenerForEvents(this->shared_from_this(),
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
#define LLDB_LOGF(log,...)
An event broadcasting class.
uint32_t AddListener(const lldb::ListenerSP &listener_sp, uint32_t event_mask)
Listen for any events specified by event_mask.
bool RemoveListener(const lldb::ListenerSP &listener_sp, uint32_t event_mask=UINT32_MAX)
Removes a Listener from this broadcasters list and frees the event bits specified by event_mask that ...
std::weak_ptr< BroadcasterImpl > BroadcasterImplWP
BroadcasterImplSP GetBroadcasterImpl()
std::shared_ptr< BroadcasterImpl > BroadcasterImplSP
size_t HandleBroadcastEvent(lldb::EventSP &event_sp)
static lldb::ListenerSP MakeListener(const char *name)
event_collection m_events
Event * PeekAtNextEventForBroadcaster(Broadcaster *broadcaster)
Event * PeekAtNextEvent()
uint32_t StartListeningForEvents(Broadcaster *broadcaster, uint32_t event_mask)
std::condition_variable m_events_condition
uint32_t StartListeningForEventSpec(const lldb::BroadcasterManagerSP &manager_sp, const BroadcastEventSpec &event_spec)
std::recursive_mutex m_broadcasters_mutex
bool StopListeningForEventSpec(const lldb::BroadcasterManagerSP &manager_sp, const BroadcastEventSpec &event_spec)
broadcaster_manager_collection m_broadcaster_managers
bool GetEventForBroadcaster(Broadcaster *broadcaster, lldb::EventSP &event_sp, const Timeout< std::micro > &timeout)
bool FindNextEventInternal(std::unique_lock< std::mutex > &lock, Broadcaster *broadcaster, uint32_t event_type_mask, lldb::EventSP &event_sp, bool remove)
Event * PeekAtNextEventForBroadcasterWithType(Broadcaster *broadcaster, uint32_t event_type_mask)
bool StopListeningForEvents(Broadcaster *broadcaster, uint32_t event_mask)
bool GetEventForBroadcasterWithType(Broadcaster *broadcaster, uint32_t event_type_mask, lldb::EventSP &event_sp, const Timeout< std::micro > &timeout)
Listener(const char *name)
void BroadcasterWillDestruct(Broadcaster *)
void BroadcasterManagerWillDestruct(lldb::BroadcasterManagerSP manager_sp)
broadcaster_collection m_broadcasters
bool GetEventInternal(const Timeout< std::micro > &timeout, Broadcaster *broadcaster, uint32_t event_type_mask, lldb::EventSP &event_sp)
std::mutex m_events_mutex
void AddEvent(lldb::EventSP &event)
bool GetEvent(lldb::EventSP &event_sp, const Timeout< std::micro > &timeout)
A class that represents a running process on the host machine.
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
std::shared_ptr< lldb_private::BroadcasterManager > BroadcasterManagerSP
std::shared_ptr< lldb_private::Event > EventSP
std::shared_ptr< lldb_private::Listener > ListenerSP
std::weak_ptr< lldb_private::BroadcasterManager > BroadcasterManagerWP
void * callback_user_data
HandleBroadcastCallback callback