23class BroadcasterManagerWPMatcher {
25 BroadcasterManagerWPMatcher(BroadcasterManagerSP manager_sp)
26 : m_manager_sp(std::move(manager_sp)) {}
27 bool operator()(
const BroadcasterManagerWP &input_wp)
const {
28 BroadcasterManagerSP input_sp = input_wp.lock();
29 return (input_sp && input_sp == m_manager_sp);
32 BroadcasterManagerSP m_manager_sp;
37 : m_name(name), m_broadcasters(), m_broadcasters_mutex(), m_events(),
38 m_events_mutex(), m_is_shadow() {
41 LLDB_LOGF(log,
"%p Listener::Listener('%s')",
static_cast<void *
>(
this),
50 LLDB_LOGF(log,
"%p Listener::%s('%s')",
static_cast<void *
>(
this),
51 __FUNCTION__,
m_name.c_str());
56 std::lock_guard<std::recursive_mutex> broadcasters_guard(
62 broadcaster_sp->RemoveListener(
this, pos->second.event_mask);
70 for (
size_t i = 0; i < num_managers; i++) {
73 manager_sp->RemoveListener(
this);
76 LLDB_LOGF(log,
"%p Listener::%s('%s')",
static_cast<void *
>(
this),
77 __FUNCTION__,
m_name.c_str());
86 std::lock_guard<std::recursive_mutex> broadcasters_guard(
94 broadcaster->
AddListener(this->shared_from_this(), event_mask);
99 "%p Listener::StartListeningForEvents (broadcaster = %p, "
100 "mask = 0x%8.8x) acquired_mask = 0x%8.8x for %s",
101 static_cast<void *
>(
this),
static_cast<void *
>(broadcaster),
102 event_mask, acquired_mask,
m_name.c_str());
104 return acquired_mask;
111 HandleBroadcastCallback callback,
112 void *callback_user_data) {
117 std::lock_guard<std::recursive_mutex> broadcasters_guard(
125 broadcaster->
AddListener(this->shared_from_this(), event_mask);
128 if (log !=
nullptr) {
129 void **pointer =
reinterpret_cast<void **
>(&callback);
131 "%p Listener::StartListeningForEvents (broadcaster = %p, "
132 "mask = 0x%8.8x, callback = %p, user_data = %p) "
133 "acquired_mask = 0x%8.8x for %s",
134 static_cast<void *
>(
this),
static_cast<void *
>(broadcaster),
135 event_mask, *pointer,
static_cast<void *
>(callback_user_data),
136 acquired_mask,
m_name.c_str());
139 return acquired_mask;
149 std::lock_guard<std::recursive_mutex> broadcasters_guard(
154 return broadcaster->
RemoveListener(this->shared_from_this(), event_mask);
165 std::lock_guard<std::recursive_mutex> broadcasters_guard(
174 event_collection::iterator pos =
m_events.begin();
176 if ((*pos)->GetBroadcaster() == broadcaster)
186 broadcaster_manager_collection::iterator iter,
188 BroadcasterManagerWP manager_wp;
190 BroadcasterManagerWPMatcher matcher(std::move(manager_sp));
191 iter = std::find_if<broadcaster_manager_collection::iterator,
192 BroadcasterManagerWPMatcher>(
194 if (iter != end_iter)
201 LLDB_LOGF(log,
"%p Listener('%s')::AddEvent (event_sp = {%p})",
202 static_cast<void *
>(
this),
m_name.c_str(),
203 static_cast<void *
>(event_sp.get()));
213 : m_broadcaster(broadcaster) {}
216 return event_sp->BroadcasterIs(m_broadcaster);
227 : m_broadcaster(broadcaster), m_broadcaster_names(broadcaster_names),
228 m_num_broadcaster_names(num_broadcaster_names),
229 m_event_type_mask(event_type_mask) {}
232 if (m_broadcaster && !event_sp->BroadcasterIs(m_broadcaster))
235 if (m_broadcaster_names) {
236 bool found_source =
false;
238 event_sp->GetBroadcaster()->GetBroadcasterName();
239 for (
uint32_t i = 0; i < m_num_broadcaster_names; ++i) {
240 if (m_broadcaster_names[i] == event_broadcaster_name) {
249 return m_event_type_mask == 0 || m_event_type_mask & event_sp->GetType();
260 std::unique_lock<std::mutex> &lock,
263 uint32_t num_broadcaster_names,
uint32_t event_type_mask, EventSP &event_sp,
274 Listener::event_collection::iterator pos =
m_events.end();
276 if (broadcaster ==
nullptr && broadcaster_names ==
nullptr &&
277 event_type_mask == 0) {
282 num_broadcaster_names, event_type_mask));
290 "%p '%s' Listener::FindNextEventInternal(broadcaster=%p, "
291 "broadcaster_names=%p[%u], event_type_mask=0x%8.8x, "
292 "remove=%i) event %p",
293 static_cast<void *
>(
this),
GetName(),
294 static_cast<void *
>(broadcaster),
295 static_cast<const void *
>(broadcaster_names),
296 num_broadcaster_names, event_type_mask, remove,
297 static_cast<void *
>(event_sp.get()));
306 event_sp->DoOnRemoval();
319 return event_sp.get();
327 return event_sp.get();
338 return event_sp.get();
349 LLDB_LOG(log,
"this = {0}, timeout = {1} for {2}",
this, timeout,
m_name);
355 num_broadcaster_names, event_type_mask, event_sp,
359 std::cv_status result = std::cv_status::no_timeout;
365 if (result == std::cv_status::timeout) {
367 LLDB_LOGF(log,
"%p Listener::GetEventInternal() timed out for %s",
368 static_cast<void *
>(
this),
m_name.c_str());
370 }
else if (result != std::cv_status::no_timeout) {
372 LLDB_LOGF(log,
"%p Listener::GetEventInternal() unknown error for %s",
373 static_cast<void *
>(
this),
m_name.c_str());
400 size_t num_handled = 0;
402 Broadcaster *broadcaster = event_sp->GetBroadcaster();
405 broadcaster_collection::iterator pos;
410 pos != end && pos->first.lock() == broadcaster_impl_sp; ++pos) {
430 std::lock_guard<std::recursive_mutex> manager_guard(
431 manager_sp->m_manager_mutex);
434 uint32_t bits_acquired = manager_sp->RegisterListenerForEvents(
435 this->shared_from_this(), event_spec);
437 broadcaster_manager_collection::iterator iter,
439 BroadcasterManagerWP manager_wp(manager_sp);
440 BroadcasterManagerWPMatcher matcher(manager_sp);
441 iter = std::find_if<broadcaster_manager_collection::iterator,
442 BroadcasterManagerWPMatcher>(
444 if (iter == end_iter)
448 return bits_acquired;
457 return manager_sp->UnregisterListenerForEvents(this->shared_from_this(),
462 return ListenerSP(
new Listener(name));
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
#define LLDB_LOGF(log,...)
EventBroadcasterMatches(Broadcaster *broadcaster)
bool operator()(const EventSP &event_sp) const
Broadcaster * m_broadcaster
const ConstString * m_broadcaster_names
const uint32_t m_num_broadcaster_names
EventMatcher(Broadcaster *broadcaster, const ConstString *broadcaster_names, uint32_t num_broadcaster_names, uint32_t event_type_mask)
const uint32_t m_event_type_mask
bool operator()(const EventSP &event_sp) const
Broadcaster * m_broadcaster
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
A uniqued constant string class.
size_t HandleBroadcastEvent(lldb::EventSP &event_sp)
static lldb::ListenerSP MakeListener(const char *name)
event_collection m_events
bool GetEventInternal(const Timeout< std::micro > &timeout, Broadcaster *broadcaster, const ConstString *sources, uint32_t num_sources, uint32_t event_type_mask, lldb::EventSP &event_sp)
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 FindNextEventInternal(std::unique_lock< std::mutex > &lock, Broadcaster *broadcaster, const ConstString *sources, uint32_t num_sources, uint32_t event_type_mask, lldb::EventSP &event_sp, bool remove)
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)
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
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.
void * callback_user_data
HandleBroadcastCallback callback