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\")",
35 static_cast<void*>(this), m_broadcaster_name.AsCString());
38 Broadcaster::~Broadcaster()
40 Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
42 log->Printf ("%p Broadcaster::~Broadcaster(\"%s\")",
43 static_cast<void*>(this), m_broadcaster_name.AsCString());
49 Broadcaster::CheckInWithManager ()
51 if (m_manager != NULL)
53 m_manager->SignUpListenersForBroadcaster(*this);
60 Mutex::Locker listeners_locker(m_listeners_mutex);
62 // Make sure the listener forgets about this broadcaster. We do
63 // this in the broadcaster in case the broadcaster object initiates
66 collection::iterator pos, end = m_listeners.end();
67 for (pos = m_listeners.begin(); pos != end; ++pos)
68 pos->first->BroadcasterWillDestruct (this);
73 Broadcaster::GetBroadcasterName ()
75 return m_broadcaster_name;
79 Broadcaster::GetEventNames (Stream &s, uint32_t event_mask, bool prefix_with_broadcaster_name) const
81 uint32_t num_names_added = 0;
82 if (event_mask && !m_event_names.empty())
84 event_names_map::const_iterator end = m_event_names.end();
85 for (uint32_t bit=1u, mask=event_mask; mask != 0 && bit != 0; bit <<= 1, mask >>= 1)
89 event_names_map::const_iterator pos = m_event_names.find(bit);
92 if (num_names_added > 0)
95 if (prefix_with_broadcaster_name)
97 s.PutCString (m_broadcaster_name.GetCString());
100 s.PutCString(pos->second.c_str());
106 return num_names_added > 0;
110 Broadcaster::AddInitialEventsToListener (Listener *listener, uint32_t requested_events)
116 Broadcaster::AddListener (Listener* listener, uint32_t event_mask)
118 if (listener == NULL)
121 Mutex::Locker locker(m_listeners_mutex);
122 collection::iterator pos, end = m_listeners.end();
124 collection::iterator existing_pos = end;
125 // See if we already have this listener, and if so, update its mask
126 uint32_t taken_event_types = 0;
127 for (pos = m_listeners.begin(); pos != end; ++pos)
129 if (pos->first == listener)
131 // For now don't descriminate on who gets what
132 // FIXME: Implement "unique listener for this bit" mask
133 // taken_event_types |= pos->second;
136 // Each event bit in a Broadcaster object can only be used
138 uint32_t available_event_types = ~taken_event_types & event_mask;
140 if (available_event_types)
142 // If we didn't find our listener, add it
143 if (existing_pos == end)
145 // Grant a new listener the available event bits
146 m_listeners.push_back(std::make_pair(listener, available_event_types));
150 // Grant the existing listener the available event bits
151 existing_pos->second |= available_event_types;
154 // Individual broadcasters decide whether they have outstanding data when a
155 // listener attaches, and insert it into the listener with this method.
157 AddInitialEventsToListener (listener, available_event_types);
160 // Return the event bits that were granted to the listener
161 return available_event_types;
165 Broadcaster::EventTypeHasListeners (uint32_t event_type)
167 Mutex::Locker locker (m_listeners_mutex);
169 if (m_hijacking_listeners.size() > 0 && event_type & m_hijacking_masks.back())
172 if (m_listeners.empty())
175 collection::iterator pos, end = m_listeners.end();
176 for (pos = m_listeners.begin(); pos != end; ++pos)
178 if (pos->second & event_type)
185 Broadcaster::RemoveListener (Listener* listener, uint32_t event_mask)
187 Mutex::Locker locker(m_listeners_mutex);
188 collection::iterator pos, end = m_listeners.end();
189 // See if we already have this listener, and if so, update its mask
190 for (pos = m_listeners.begin(); pos != end; ++pos)
192 if (pos->first == listener)
194 // Relinquish all event bits in "event_mask"
195 pos->second &= ~event_mask;
196 // If all bits have been relinquished then remove this listener
197 if (pos->second == 0)
198 m_listeners.erase (pos);
206 Broadcaster::BroadcastEvent (EventSP &event_sp)
208 return PrivateBroadcastEvent (event_sp, false);
212 Broadcaster::BroadcastEventIfUnique (EventSP &event_sp)
214 return PrivateBroadcastEvent (event_sp, true);
218 Broadcaster::PrivateBroadcastEvent (EventSP &event_sp, bool unique)
220 // Can't add a NULL event...
221 if (event_sp.get() == NULL)
224 // Update the broadcaster on this event
225 event_sp->SetBroadcaster (this);
227 const uint32_t event_type = event_sp->GetType();
229 Mutex::Locker event_types_locker(m_listeners_mutex);
231 Listener *hijacking_listener = NULL;
232 if (!m_hijacking_listeners.empty())
234 assert (!m_hijacking_masks.empty());
235 hijacking_listener = m_hijacking_listeners.back();
236 if ((event_type & m_hijacking_masks.back()) == 0)
237 hijacking_listener = NULL;
240 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_EVENTS));
243 StreamString event_description;
244 event_sp->Dump (&event_description);
245 log->Printf ("%p Broadcaster(\"%s\")::BroadcastEvent (event_sp = {%s}, unique =%i) hijack = %p",
246 static_cast<void*>(this), m_broadcaster_name.AsCString(""),
247 event_description.GetData(), unique,
248 static_cast<void*>(hijacking_listener));
251 if (hijacking_listener)
253 if (unique && hijacking_listener->PeekAtNextEventForBroadcasterWithType (this, event_type))
255 hijacking_listener->AddEvent (event_sp);
259 collection::iterator pos, end = m_listeners.end();
262 // Iterate through all listener/mask pairs
263 for (pos = m_listeners.begin(); pos != end; ++pos)
265 // If the listener's mask matches any bits that we just set, then
266 // put the new event on its event queue.
267 if (event_type & pos->second)
269 if (unique && pos->first->PeekAtNextEventForBroadcasterWithType (this, event_type))
271 pos->first->AddEvent (event_sp);
278 Broadcaster::BroadcastEvent (uint32_t event_type, EventData *event_data)
280 EventSP event_sp (new Event (event_type, event_data));
281 PrivateBroadcastEvent (event_sp, false);
285 Broadcaster::BroadcastEventIfUnique (uint32_t event_type, EventData *event_data)
287 EventSP event_sp (new Event (event_type, event_data));
288 PrivateBroadcastEvent (event_sp, true);
292 Broadcaster::HijackBroadcaster (Listener *listener, uint32_t event_mask)
294 Mutex::Locker event_types_locker(m_listeners_mutex);
296 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_EVENTS));
298 log->Printf ("%p Broadcaster(\"%s\")::HijackBroadcaster (listener(\"%s\")=%p)",
299 static_cast<void*>(this), m_broadcaster_name.AsCString(""),
300 listener->m_name.c_str(), static_cast<void*>(listener));
301 m_hijacking_listeners.push_back(listener);
302 m_hijacking_masks.push_back(event_mask);
307 Broadcaster::RestoreBroadcaster ()
309 Mutex::Locker event_types_locker(m_listeners_mutex);
311 if (!m_hijacking_listeners.empty())
313 Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_EVENTS));
316 Listener *listener = m_hijacking_listeners.back();
317 log->Printf ("%p Broadcaster(\"%s\")::RestoreBroadcaster (about to pop listener(\"%s\")=%p)",
318 static_cast<void*>(this),
319 m_broadcaster_name.AsCString(""),
320 listener->m_name.c_str(), static_cast<void*>(listener));
322 m_hijacking_listeners.pop_back();
324 if (!m_hijacking_masks.empty())
325 m_hijacking_masks.pop_back();
329 Broadcaster::GetBroadcasterClass() const
331 static ConstString class_name ("lldb.anonymous");
335 BroadcastEventSpec::BroadcastEventSpec (const BroadcastEventSpec &rhs) :
336 m_broadcaster_class (rhs.m_broadcaster_class),
337 m_event_bits (rhs.m_event_bits)
342 BroadcastEventSpec::operator< (const BroadcastEventSpec &rhs) const
344 if (GetBroadcasterClass() == rhs.GetBroadcasterClass())
346 return GetEventBits() < rhs.GetEventBits();
350 return GetBroadcasterClass() < rhs.GetBroadcasterClass();
354 const BroadcastEventSpec &
355 BroadcastEventSpec::operator= (const BroadcastEventSpec &rhs)
357 m_broadcaster_class = rhs.m_broadcaster_class;
358 m_event_bits = rhs.m_event_bits;
362 BroadcasterManager::BroadcasterManager() :
363 m_manager_mutex(Mutex::eMutexTypeRecursive)
369 BroadcasterManager::RegisterListenerForEvents (Listener &listener, BroadcastEventSpec event_spec)
371 Mutex::Locker locker(m_manager_mutex);
373 collection::iterator iter = m_event_map.begin(), end_iter = m_event_map.end();
374 uint32_t available_bits = event_spec.GetEventBits();
376 while (iter != end_iter
377 && (iter = find_if (iter, end_iter, BroadcasterClassMatches(event_spec.GetBroadcasterClass()))) != end_iter)
379 available_bits &= ~((*iter).first.GetEventBits());
383 if (available_bits != 0)
385 m_event_map.insert (event_listener_key (BroadcastEventSpec (event_spec.GetBroadcasterClass(), available_bits), &listener));
386 m_listeners.insert(&listener);
389 return available_bits;
393 BroadcasterManager::UnregisterListenerForEvents (Listener &listener, BroadcastEventSpec event_spec)
395 Mutex::Locker locker(m_manager_mutex);
396 bool removed_some = false;
398 if (m_listeners.erase(&listener) == 0)
401 ListenerMatchesAndSharedBits predicate (event_spec, listener);
402 std::vector<BroadcastEventSpec> to_be_readded;
403 uint32_t event_bits_to_remove = event_spec.GetEventBits();
405 // Go through the map and delete the exact matches, and build a list of matches that weren't exact to re-add:
408 collection::iterator iter, end_iter = m_event_map.end();
409 iter = find_if (m_event_map.begin(), end_iter, predicate);
410 if (iter == end_iter)
416 uint32_t iter_event_bits = (*iter).first.GetEventBits();
419 if (event_bits_to_remove != iter_event_bits)
421 uint32_t new_event_bits = iter_event_bits & ~event_bits_to_remove;
422 to_be_readded.push_back(BroadcastEventSpec (event_spec.GetBroadcasterClass(), new_event_bits));
424 m_event_map.erase (iter);
428 // Okay now add back the bits that weren't completely removed:
429 for (size_t i = 0; i < to_be_readded.size(); i++)
431 m_event_map.insert (event_listener_key (to_be_readded[i], &listener));
438 BroadcasterManager::GetListenerForEventSpec (BroadcastEventSpec event_spec) const
440 Mutex::Locker locker(*(const_cast<Mutex *> (&m_manager_mutex)));
442 collection::const_iterator iter, end_iter = m_event_map.end();
443 iter = find_if (m_event_map.begin(), end_iter, BroadcastEventSpecMatches (event_spec));
444 if (iter != end_iter)
445 return (*iter).second;
451 BroadcasterManager::RemoveListener (Listener &listener)
453 Mutex::Locker locker(m_manager_mutex);
454 ListenerMatches predicate (listener);
457 if (m_listeners.erase (&listener) == 0)
462 collection::iterator iter, end_iter = m_event_map.end();
463 iter = find_if (m_event_map.begin(), end_iter, predicate);
464 if (iter == end_iter)
467 m_event_map.erase(iter);
472 BroadcasterManager::SignUpListenersForBroadcaster (Broadcaster &broadcaster)
474 Mutex::Locker locker(m_manager_mutex);
476 collection::iterator iter = m_event_map.begin(), end_iter = m_event_map.end();
478 while (iter != end_iter
479 && (iter = find_if (iter, end_iter, BroadcasterClassMatches(broadcaster.GetBroadcasterClass()))) != end_iter)
481 (*iter).second->StartListeningForEvents (&broadcaster, (*iter).first.GetEventBits());
487 BroadcasterManager::Clear ()
489 Mutex::Locker locker(m_manager_mutex);
490 listener_collection::iterator end_iter = m_listeners.end();
492 for (listener_collection::iterator iter = m_listeners.begin(); iter != end_iter; iter++)
493 (*iter)->BroadcasterManagerWillDestruct(this);