1 //===-- Broadcaster.cpp -----------------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "lldb/Core/Broadcaster.h"
14 // Other libraries and framework includes
16 #include "lldb/Core/Log.h"
17 #include "lldb/Core/Event.h"
18 #include "lldb/Core/StreamString.h"
19 #include "lldb/lldb-private-log.h"
22 using namespace lldb_private;
24 Broadcaster::Broadcaster (BroadcasterManager *manager, const char *name) :
25 m_broadcaster_name (name),
27 m_listeners_mutex (Mutex::eMutexTypeRecursive),
28 m_hijacking_listeners(),
32 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
34 log->Printf ("%p Broadcaster::Broadcaster(\"%s\")", this, m_broadcaster_name.AsCString());
38 Broadcaster::~Broadcaster()
40 Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
42 log->Printf ("%p Broadcaster::~Broadcaster(\"%s\")", this, m_broadcaster_name.AsCString());
48 Broadcaster::CheckInWithManager ()
50 if (m_manager != NULL)
52 m_manager->SignUpListenersForBroadcaster(*this);
59 Mutex::Locker listeners_locker(m_listeners_mutex);
61 // Make sure the listener forgets about this broadcaster. We do
62 // this in the broadcaster in case the broadcaster object initiates
65 collection::iterator pos, end = m_listeners.end();
66 for (pos = m_listeners.begin(); pos != end; ++pos)
67 pos->first->BroadcasterWillDestruct (this);
72 Broadcaster::GetBroadcasterName ()
74 return m_broadcaster_name;
78 Broadcaster::GetEventNames (Stream &s, uint32_t event_mask, bool prefix_with_broadcaster_name) const
80 uint32_t num_names_added = 0;
81 if (event_mask && !m_event_names.empty())
83 event_names_map::const_iterator end = m_event_names.end();
84 for (uint32_t bit=1u, mask=event_mask; mask != 0 && bit != 0; bit <<= 1, mask >>= 1)
88 event_names_map::const_iterator pos = m_event_names.find(bit);
91 if (num_names_added > 0)
94 if (prefix_with_broadcaster_name)
96 s.PutCString (m_broadcaster_name.GetCString());
99 s.PutCString(pos->second.c_str());
105 return num_names_added > 0;
109 Broadcaster::AddInitialEventsToListener (Listener *listener, uint32_t requested_events)
115 Broadcaster::AddListener (Listener* listener, uint32_t event_mask)
117 if (listener == NULL)
120 Mutex::Locker locker(m_listeners_mutex);
121 collection::iterator pos, end = m_listeners.end();
123 collection::iterator existing_pos = end;
124 // See if we already have this listener, and if so, update its mask
125 uint32_t taken_event_types = 0;
126 for (pos = m_listeners.begin(); pos != end; ++pos)
128 if (pos->first == listener)
130 // For now don't descriminate on who gets what
131 // FIXME: Implement "unique listener for this bit" mask
132 // taken_event_types |= pos->second;
135 // Each event bit in a Broadcaster object can only be used
137 uint32_t available_event_types = ~taken_event_types & event_mask;
139 if (available_event_types)
141 // If we didn't find our listener, add it
142 if (existing_pos == end)
144 // Grant a new listener the available event bits
145 m_listeners.push_back(std::make_pair(listener, available_event_types));
149 // Grant the existing listener the available event bits
150 existing_pos->second |= available_event_types;
153 // Individual broadcasters decide whether they have outstanding data when a
154 // listener attaches, and insert it into the listener with this method.
156 AddInitialEventsToListener (listener, available_event_types);
159 // Return the event bits that were granted to the listener
160 return available_event_types;
164 Broadcaster::EventTypeHasListeners (uint32_t event_type)
166 Mutex::Locker locker (m_listeners_mutex);
168 if (m_hijacking_listeners.size() > 0 && event_type & m_hijacking_masks.back())
171 if (m_listeners.empty())
174 collection::iterator pos, end = m_listeners.end();
175 for (pos = m_listeners.begin(); pos != end; ++pos)
177 if (pos->second & event_type)
184 Broadcaster::RemoveListener (Listener* listener, uint32_t event_mask)
186 Mutex::Locker locker(m_listeners_mutex);
187 collection::iterator pos, end = m_listeners.end();
188 // See if we already have this listener, and if so, update its mask
189 for (pos = m_listeners.begin(); pos != end; ++pos)
191 if (pos->first == listener)
193 // Relinquish all event bits in "event_mask"
194 pos->second &= ~event_mask;
195 // If all bits have been relinquished then remove this listener
196 if (pos->second == 0)
197 m_listeners.erase (pos);
205 Broadcaster::BroadcastEvent (EventSP &event_sp)
207 return PrivateBroadcastEvent (event_sp, false);
211 Broadcaster::BroadcastEventIfUnique (EventSP &event_sp)
213 return PrivateBroadcastEvent (event_sp, true);
217 Broadcaster::PrivateBroadcastEvent (EventSP &event_sp, bool unique)
219 // Can't add a NULL event...
220 if (event_sp.get() == NULL)
223 // Update the broadcaster on this event
224 event_sp->SetBroadcaster (this);
226 const uint32_t event_type = event_sp->GetType();
228 Mutex::Locker event_types_locker(m_listeners_mutex);
230 Listener *hijacking_listener = NULL;
231 if (!m_hijacking_listeners.empty())
233 assert (!m_hijacking_masks.empty());
234 hijacking_listener = m_hijacking_listeners.back();
235 if ((event_type & m_hijacking_masks.back()) == 0)
236 hijacking_listener = NULL;
239 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_EVENTS));
242 StreamString event_description;
243 event_sp->Dump (&event_description);
244 log->Printf ("%p Broadcaster(\"%s\")::BroadcastEvent (event_sp = {%s}, unique =%i) hijack = %p",
246 m_broadcaster_name.AsCString(""),
247 event_description.GetData(),
252 if (hijacking_listener)
254 if (unique && hijacking_listener->PeekAtNextEventForBroadcasterWithType (this, event_type))
256 hijacking_listener->AddEvent (event_sp);
260 collection::iterator pos, end = m_listeners.end();
263 // Iterate through all listener/mask pairs
264 for (pos = m_listeners.begin(); pos != end; ++pos)
266 // If the listener's mask matches any bits that we just set, then
267 // put the new event on its event queue.
268 if (event_type & pos->second)
270 if (unique && pos->first->PeekAtNextEventForBroadcasterWithType (this, event_type))
272 pos->first->AddEvent (event_sp);
279 Broadcaster::BroadcastEvent (uint32_t event_type, EventData *event_data)
281 EventSP event_sp (new Event (event_type, event_data));
282 PrivateBroadcastEvent (event_sp, false);
286 Broadcaster::BroadcastEventIfUnique (uint32_t event_type, EventData *event_data)
288 EventSP event_sp (new Event (event_type, event_data));
289 PrivateBroadcastEvent (event_sp, true);
293 Broadcaster::HijackBroadcaster (Listener *listener, uint32_t event_mask)
295 Mutex::Locker event_types_locker(m_listeners_mutex);
297 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_EVENTS));
300 log->Printf ("%p Broadcaster(\"%s\")::HijackBroadcaster (listener(\"%s\")=%p)",
302 m_broadcaster_name.AsCString(""),
303 listener->m_name.c_str(),
306 m_hijacking_listeners.push_back(listener);
307 m_hijacking_masks.push_back(event_mask);
312 Broadcaster::RestoreBroadcaster ()
314 Mutex::Locker event_types_locker(m_listeners_mutex);
316 if (!m_hijacking_listeners.empty())
318 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_EVENTS));
321 Listener *listener = m_hijacking_listeners.back();
322 log->Printf ("%p Broadcaster(\"%s\")::RestoreBroadcaster (about to pop listener(\"%s\")=%p)",
324 m_broadcaster_name.AsCString(""),
325 listener->m_name.c_str(),
328 m_hijacking_listeners.pop_back();
330 if (!m_hijacking_masks.empty())
331 m_hijacking_masks.pop_back();
335 Broadcaster::GetBroadcasterClass() const
337 static ConstString class_name ("lldb.anonymous");
341 BroadcastEventSpec::BroadcastEventSpec (const BroadcastEventSpec &rhs) :
342 m_broadcaster_class (rhs.m_broadcaster_class),
343 m_event_bits (rhs.m_event_bits)
348 BroadcastEventSpec::operator< (const BroadcastEventSpec &rhs) const
350 if (GetBroadcasterClass() == rhs.GetBroadcasterClass())
352 return GetEventBits() < rhs.GetEventBits();
356 return GetBroadcasterClass() < rhs.GetBroadcasterClass();
360 const BroadcastEventSpec &
361 BroadcastEventSpec::operator= (const BroadcastEventSpec &rhs)
363 m_broadcaster_class = rhs.m_broadcaster_class;
364 m_event_bits = rhs.m_event_bits;
368 BroadcasterManager::BroadcasterManager() :
369 m_manager_mutex(Mutex::eMutexTypeRecursive)
375 BroadcasterManager::RegisterListenerForEvents (Listener &listener, BroadcastEventSpec event_spec)
377 Mutex::Locker locker(m_manager_mutex);
379 collection::iterator iter = m_event_map.begin(), end_iter = m_event_map.end();
380 uint32_t available_bits = event_spec.GetEventBits();
382 while (iter != end_iter
383 && (iter = find_if (iter, end_iter, BroadcasterClassMatches(event_spec.GetBroadcasterClass()))) != end_iter)
385 available_bits &= ~((*iter).first.GetEventBits());
389 if (available_bits != 0)
391 m_event_map.insert (event_listener_key (BroadcastEventSpec (event_spec.GetBroadcasterClass(), available_bits), &listener));
392 m_listeners.insert(&listener);
395 return available_bits;
399 BroadcasterManager::UnregisterListenerForEvents (Listener &listener, BroadcastEventSpec event_spec)
401 Mutex::Locker locker(m_manager_mutex);
402 bool removed_some = false;
404 if (m_listeners.erase(&listener) == 0)
407 ListenerMatchesAndSharedBits predicate (event_spec, listener);
408 std::vector<BroadcastEventSpec> to_be_readded;
409 uint32_t event_bits_to_remove = event_spec.GetEventBits();
411 // Go through the map and delete the exact matches, and build a list of matches that weren't exact to re-add:
414 collection::iterator iter, end_iter = m_event_map.end();
415 iter = find_if (m_event_map.begin(), end_iter, predicate);
416 if (iter == end_iter)
422 uint32_t iter_event_bits = (*iter).first.GetEventBits();
425 if (event_bits_to_remove != iter_event_bits)
427 uint32_t new_event_bits = iter_event_bits & ~event_bits_to_remove;
428 to_be_readded.push_back(BroadcastEventSpec (event_spec.GetBroadcasterClass(), new_event_bits));
430 m_event_map.erase (iter);
434 // Okay now add back the bits that weren't completely removed:
435 for (size_t i = 0; i < to_be_readded.size(); i++)
437 m_event_map.insert (event_listener_key (to_be_readded[i], &listener));
444 BroadcasterManager::GetListenerForEventSpec (BroadcastEventSpec event_spec) const
446 Mutex::Locker locker(*(const_cast<Mutex *> (&m_manager_mutex)));
448 collection::const_iterator iter, end_iter = m_event_map.end();
449 iter = find_if (m_event_map.begin(), end_iter, BroadcastEventSpecMatches (event_spec));
450 if (iter != end_iter)
451 return (*iter).second;
457 BroadcasterManager::RemoveListener (Listener &listener)
459 Mutex::Locker locker(m_manager_mutex);
460 ListenerMatches predicate (listener);
463 if (m_listeners.erase (&listener) == 0)
468 collection::iterator iter, end_iter = m_event_map.end();
469 iter = find_if (m_event_map.begin(), end_iter, predicate);
470 if (iter == end_iter)
473 m_event_map.erase(iter);
478 BroadcasterManager::SignUpListenersForBroadcaster (Broadcaster &broadcaster)
480 Mutex::Locker locker(m_manager_mutex);
482 collection::iterator iter = m_event_map.begin(), end_iter = m_event_map.end();
484 while (iter != end_iter
485 && (iter = find_if (iter, end_iter, BroadcasterClassMatches(broadcaster.GetBroadcasterClass()))) != end_iter)
487 (*iter).second->StartListeningForEvents (&broadcaster, (*iter).first.GetEventBits());
493 BroadcasterManager::Clear ()
495 Mutex::Locker locker(m_manager_mutex);
496 listener_collection::iterator end_iter = m_listeners.end();
498 for (listener_collection::iterator iter = m_listeners.begin(); iter != end_iter; iter++)
499 (*iter)->BroadcasterManagerWillDestruct(this);