26 Broadcaster::Broadcaster(BroadcasterManagerSP manager_sp,
const char *name)
27 : m_broadcaster_sp(std::make_shared<BroadcasterImpl>(*this)),
28 m_manager_sp(std::move(manager_sp)), m_broadcaster_name(name) {
30 LLDB_LOG(log,
"{0} Broadcaster::Broadcaster(\"{1}\")",
31 static_cast<void *
>(
this), GetBroadcasterName());
35 : m_broadcaster(broadcaster), m_listeners(), m_listeners_mutex(),
36 m_hijacking_listeners(), m_hijacking_masks() {}
40 LLDB_LOG(log,
"{0} Broadcaster::~Broadcaster(\"{1}\")",
52 llvm::SmallVector<std::pair<ListenerSP, uint32_t &>, 4>
54 llvm::SmallVector<std::pair<ListenerSP, uint32_t &>, 4> listeners;
55 listeners.reserve(m_listeners.size());
57 for (
auto it = m_listeners.begin(); it != m_listeners.end();) {
58 lldb::ListenerSP curr_listener_sp(it->first.lock());
59 if (curr_listener_sp && it->second) {
60 listeners.emplace_back(std::move(curr_listener_sp), it->second);
63 it = m_listeners.erase(it);
70 std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
74 for (
auto &pair : GetListeners())
75 pair.first->BroadcasterWillDestruct(&m_broadcaster);
81 return &m_broadcaster;
85 Stream &s,
uint32_t event_mask,
bool prefix_with_broadcaster_name)
const {
87 if (event_mask && !m_event_names.empty()) {
88 event_names_map::const_iterator end = m_event_names.end();
90 bit <<= 1, mask >>= 1) {
92 event_names_map::const_iterator pos = m_event_names.find(
bit);
94 if (num_names_added > 0)
97 if (prefix_with_broadcaster_name) {
107 return num_names_added > 0;
111 const lldb::ListenerSP &listener_sp,
uint32_t requested_events) {}
119 std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
123 bool handled =
false;
125 for (
auto &pair : GetListeners()) {
126 if (pair.first == listener_sp) {
128 pair.second |= event_mask;
129 m_broadcaster.AddInitialEventsToListener(listener_sp, event_mask);
136 m_listeners.push_back(
137 std::make_pair(lldb::ListenerWP(listener_sp), event_mask));
141 m_broadcaster.AddInitialEventsToListener(listener_sp, event_mask);
149 std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
151 if (!m_hijacking_listeners.empty() && event_type & m_hijacking_masks.back())
154 for (
auto &pair : GetListeners()) {
155 if (pair.second & event_type)
166 std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
167 for (
auto &pair : GetListeners()) {
168 if (pair.first.get() == listener) {
169 pair.second &= ~event_mask;
177 const lldb::ListenerSP &listener_sp,
uint32_t event_mask) {
182 return PrivateBroadcastEvent(event_sp,
false);
186 return PrivateBroadcastEvent(event_sp,
true);
196 event_sp->SetBroadcaster(&m_broadcaster);
198 const uint32_t event_type = event_sp->GetType();
200 std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
202 ListenerSP hijacking_listener_sp;
204 if (!m_hijacking_listeners.empty()) {
205 assert(!m_hijacking_masks.empty());
206 hijacking_listener_sp = m_hijacking_listeners.back();
207 if ((event_type & m_hijacking_masks.back()) == 0)
208 hijacking_listener_sp.reset();
212 if (!log && event_sp->GetData())
213 log = event_sp->GetData()->GetLogChannel();
217 event_sp->Dump(&event_description);
219 "%p Broadcaster(\"%s\")::BroadcastEvent (event_sp = {%s}, "
220 "unique =%i) hijack = %p",
222 event_description.
GetData(), unique,
223 static_cast<void *
>(hijacking_listener_sp.get()));
226 if (hijacking_listener_sp) {
227 if (unique && hijacking_listener_sp->PeekAtNextEventForBroadcasterWithType(
228 &m_broadcaster, event_type))
230 hijacking_listener_sp->AddEvent(event_sp);
232 for (
auto &pair : GetListeners()) {
233 if (!(pair.second & event_type))
235 if (unique && pair.first->PeekAtNextEventForBroadcasterWithType(
236 &m_broadcaster, event_type))
239 pair.first->AddEvent(event_sp);
246 auto event_sp = std::make_shared<Event>(event_type, event_data);
247 PrivateBroadcastEvent(event_sp,
false);
251 uint32_t event_type,
const lldb::EventDataSP &event_data_sp) {
252 auto event_sp = std::make_shared<Event>(event_type, event_data_sp);
253 PrivateBroadcastEvent(event_sp,
false);
258 auto event_sp = std::make_shared<Event>(event_type, event_data);
259 PrivateBroadcastEvent(event_sp,
true);
263 const lldb::ListenerSP &listener_sp,
uint32_t event_mask) {
264 std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
269 "{0} Broadcaster(\"{1}\")::HijackBroadcaster (listener(\"{2}\")={3})",
271 listener_sp->m_name.c_str(),
static_cast<void *
>(listener_sp.get()));
272 m_hijacking_listeners.push_back(listener_sp);
273 m_hijacking_masks.push_back(event_mask);
278 std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
280 if (!m_hijacking_listeners.empty())
281 return (event_mask & m_hijacking_masks.back()) != 0;
286 if (m_hijacking_listeners.size()) {
287 return m_hijacking_listeners.back()->GetName();
293 std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
295 if (!m_hijacking_listeners.empty()) {
296 ListenerSP listener_sp = m_hijacking_listeners.back();
299 "{0} Broadcaster(\"{1}\")::RestoreBroadcaster (about to pop "
300 "listener(\"{2}\")={3})",
302 listener_sp->m_name.c_str(),
303 static_cast<void *
>(listener_sp.get()));
304 m_hijacking_listeners.pop_back();
306 if (!m_hijacking_masks.empty())
307 m_hijacking_masks.pop_back();
335 while (iter != end_iter &&
336 (iter = find_if(iter, end_iter,
339 available_bits &= ~((*iter).first.GetEventBits());
343 if (available_bits != 0) {
350 return available_bits;
356 bool removed_some =
false;
362 std::vector<BroadcastEventSpec> to_be_readded;
368 collection::iterator iter, end_iter =
m_event_map.end();
369 iter = find_if(
m_event_map.begin(), end_iter, predicate);
370 if (iter == end_iter) {
373 uint32_t iter_event_bits = (*iter).first.GetEventBits();
376 if (event_bits_to_remove != iter_event_bits) {
377 uint32_t new_event_bits = iter_event_bits & ~event_bits_to_remove;
385 for (
size_t i = 0; i < to_be_readded.size(); i++) {
396 collection::const_iterator iter, end_iter =
m_event_map.end();
399 if (iter != end_iter)
400 return (*iter).second;
408 listener_collection::iterator iter =
m_listeners.begin(),
411 iter = std::find_if(iter, end_iter, predicate);
412 if (iter != end_iter)
416 collection::iterator iter, end_iter =
m_event_map.end();
417 iter = find_if(
m_event_map.begin(), end_iter, predicate);
418 if (iter == end_iter)
433 collection::iterator iter, end_iter =
m_event_map.end();
434 iter = find_if(
m_event_map.begin(), end_iter, predicate);
435 if (iter == end_iter)
448 while (iter != end_iter &&
449 (iter = find_if(iter, end_iter,
452 (*iter).second->StartListeningForEvents(&broadcaster,
453 (*iter).first.GetEventBits());
460 listener_collection::iterator end_iter =
m_listeners.end();
462 for (listener_collection::iterator iter =
m_listeners.begin();
463 iter != end_iter; iter++)
464 (*iter)->BroadcasterManagerWillDestruct(this->shared_from_this());