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 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_EVENTS));
319 Listener *listener = m_hijacking_listeners.back();
320 log->Printf ("%p Broadcaster(\"%s\")::RestoreBroadcaster (about to pop listener(\"%s\")=%p)",
322 m_broadcaster_name.AsCString(""),
323 listener->m_name.c_str(),
326 m_hijacking_listeners.pop_back();
327 m_hijacking_masks.pop_back();
331 Broadcaster::GetBroadcasterClass() const
333 static ConstString class_name ("lldb.anonymous");
337 BroadcastEventSpec::BroadcastEventSpec (const BroadcastEventSpec &rhs) :
338 m_broadcaster_class (rhs.m_broadcaster_class),
339 m_event_bits (rhs.m_event_bits)
344 BroadcastEventSpec::operator< (const BroadcastEventSpec &rhs) const
346 if (GetBroadcasterClass() == rhs.GetBroadcasterClass())
348 return GetEventBits() < rhs.GetEventBits();
352 return GetBroadcasterClass() < rhs.GetBroadcasterClass();
356 const BroadcastEventSpec &
357 BroadcastEventSpec::operator= (const BroadcastEventSpec &rhs)
359 m_broadcaster_class = rhs.m_broadcaster_class;
360 m_event_bits = rhs.m_event_bits;
364 BroadcasterManager::BroadcasterManager() :
365 m_manager_mutex(Mutex::eMutexTypeRecursive)
371 BroadcasterManager::RegisterListenerForEvents (Listener &listener, BroadcastEventSpec event_spec)
373 Mutex::Locker locker(m_manager_mutex);
375 collection::iterator iter = m_event_map.begin(), end_iter = m_event_map.end();
376 uint32_t available_bits = event_spec.GetEventBits();
378 while (iter != end_iter
379 && (iter = find_if (iter, end_iter, BroadcasterClassMatches(event_spec.GetBroadcasterClass()))) != end_iter)
381 available_bits &= ~((*iter).first.GetEventBits());
385 if (available_bits != 0)
387 m_event_map.insert (event_listener_key (BroadcastEventSpec (event_spec.GetBroadcasterClass(), available_bits), &listener));
388 m_listeners.insert(&listener);
391 return available_bits;
395 BroadcasterManager::UnregisterListenerForEvents (Listener &listener, BroadcastEventSpec event_spec)
397 Mutex::Locker locker(m_manager_mutex);
398 bool removed_some = false;
400 if (m_listeners.erase(&listener) == 0)
403 ListenerMatchesAndSharedBits predicate (event_spec, listener);
404 std::vector<BroadcastEventSpec> to_be_readded;
405 uint32_t event_bits_to_remove = event_spec.GetEventBits();
407 // Go through the map and delete the exact matches, and build a list of matches that weren't exact to re-add:
410 collection::iterator iter, end_iter = m_event_map.end();
411 iter = find_if (m_event_map.begin(), end_iter, predicate);
412 if (iter == end_iter)
418 uint32_t iter_event_bits = (*iter).first.GetEventBits();
421 if (event_bits_to_remove != iter_event_bits)
423 uint32_t new_event_bits = iter_event_bits & ~event_bits_to_remove;
424 to_be_readded.push_back(BroadcastEventSpec (event_spec.GetBroadcasterClass(), new_event_bits));
426 m_event_map.erase (iter);
430 // Okay now add back the bits that weren't completely removed:
431 for (size_t i = 0; i < to_be_readded.size(); i++)
433 m_event_map.insert (event_listener_key (to_be_readded[i], &listener));
440 BroadcasterManager::GetListenerForEventSpec (BroadcastEventSpec event_spec) const
442 Mutex::Locker locker(*(const_cast<Mutex *> (&m_manager_mutex)));
444 collection::const_iterator iter, end_iter = m_event_map.end();
445 iter = find_if (m_event_map.begin(), end_iter, BroadcastEventSpecMatches (event_spec));
446 if (iter != end_iter)
447 return (*iter).second;
453 BroadcasterManager::RemoveListener (Listener &listener)
455 Mutex::Locker locker(m_manager_mutex);
456 ListenerMatches predicate (listener);
459 if (m_listeners.erase (&listener) == 0)
464 collection::iterator iter, end_iter = m_event_map.end();
465 iter = find_if (m_event_map.begin(), end_iter, predicate);
466 if (iter == end_iter)
469 m_event_map.erase(iter);
474 BroadcasterManager::SignUpListenersForBroadcaster (Broadcaster &broadcaster)
476 Mutex::Locker locker(m_manager_mutex);
478 collection::iterator iter = m_event_map.begin(), end_iter = m_event_map.end();
480 while (iter != end_iter
481 && (iter = find_if (iter, end_iter, BroadcasterClassMatches(broadcaster.GetBroadcasterClass()))) != end_iter)
483 (*iter).second->StartListeningForEvents (&broadcaster, (*iter).first.GetEventBits());
489 BroadcasterManager::Clear ()
491 Mutex::Locker locker(m_manager_mutex);
492 listener_collection::iterator end_iter = m_listeners.end();
494 for (listener_collection::iterator iter = m_listeners.begin(); iter != end_iter; iter++)
495 (*iter)->BroadcasterManagerWillDestruct(this);