Broadcaster.h revision 355940
1228060Sbapt//===-- Broadcaster.h -------------------------------------------*- C++ -*-===// 2228060Sbapt// 3228060Sbapt// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4228060Sbapt// See https://llvm.org/LICENSE.txt for license information. 5228060Sbapt// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6228060Sbapt// 7228060Sbapt//===----------------------------------------------------------------------===// 8228060Sbapt 9228060Sbapt#ifndef LLDB_UTILITY_BROADCASTER_H 10228060Sbapt#define LLDB_UTILITY_BROADCASTER_H 11228060Sbapt 12228060Sbapt#include "lldb/Utility/ConstString.h" 13228060Sbapt#include "lldb/lldb-defines.h" 14228060Sbapt#include "lldb/lldb-forward.h" 15228060Sbapt 16228060Sbapt#include "llvm/ADT/SmallVector.h" 17228060Sbapt 18228060Sbapt#include <cstdint> 19228060Sbapt#include <map> 20228060Sbapt#include <memory> 21228060Sbapt#include <mutex> 22228060Sbapt#include <set> 23228060Sbapt#include <string> 24228060Sbapt#include <utility> 25228060Sbapt#include <vector> 26228060Sbapt 27228060Sbaptnamespace lldb_private { 28228060Sbaptclass Broadcaster; 29228060Sbaptclass EventData; 30228060Sbaptclass Listener; 31228060Sbaptclass Stream; 32228060Sbapt} // namespace lldb_private 33228060Sbapt 34228060Sbaptnamespace lldb_private { 35228060Sbapt 36228060Sbapt/// lldb::BroadcastEventSpec 37228060Sbapt/// 38228060Sbapt/// This class is used to specify a kind of event to register for. The 39228060Sbapt/// Debugger maintains a list of BroadcastEventSpec's and when it is made 40228060Sbaptclass BroadcastEventSpec { 41228060Sbaptpublic: 42228060Sbapt BroadcastEventSpec(ConstString broadcaster_class, uint32_t event_bits) 43228060Sbapt : m_broadcaster_class(broadcaster_class), m_event_bits(event_bits) {} 44228060Sbapt 45228060Sbapt ~BroadcastEventSpec() = default; 46228060Sbapt 47228060Sbapt ConstString GetBroadcasterClass() const { return m_broadcaster_class; } 48228060Sbapt 49228060Sbapt uint32_t GetEventBits() const { return m_event_bits; } 50228060Sbapt 51228060Sbapt /// Tell whether this BroadcastEventSpec is contained in in_spec. That is: 52228060Sbapt /// (a) the two spec's share the same broadcaster class (b) the event bits of 53228060Sbapt /// this spec are wholly contained in those of in_spec. 54228060Sbapt bool IsContainedIn(const BroadcastEventSpec &in_spec) const { 55228060Sbapt if (m_broadcaster_class != in_spec.GetBroadcasterClass()) 56228060Sbapt return false; 57228060Sbapt uint32_t in_bits = in_spec.GetEventBits(); 58228060Sbapt if (in_bits == m_event_bits) 59228060Sbapt return true; 60228060Sbapt 61228060Sbapt if ((m_event_bits & in_bits) != 0 && (m_event_bits & ~in_bits) == 0) 62228060Sbapt return true; 63228060Sbapt 64228060Sbapt return false; 65228060Sbapt } 66228060Sbapt 67228060Sbapt bool operator<(const BroadcastEventSpec &rhs) const; 68228060Sbapt BroadcastEventSpec &operator=(const BroadcastEventSpec &rhs); 69228060Sbapt 70228060Sbaptprivate: 71228060Sbapt ConstString m_broadcaster_class; 72228060Sbapt uint32_t m_event_bits; 73228060Sbapt}; 74228060Sbapt 75228060Sbaptclass BroadcasterManager 76228060Sbapt : public std::enable_shared_from_this<BroadcasterManager> { 77228060Sbaptpublic: 78228060Sbapt friend class Listener; 79228060Sbapt 80228060Sbaptprotected: 81228060Sbapt BroadcasterManager(); 82228060Sbapt 83228060Sbaptpublic: 84228060Sbapt /// Listeners hold onto weak pointers to their broadcaster managers. So they 85228060Sbapt /// must be made into shared pointers, which you do with 86228060Sbapt /// MakeBroadcasterManager. 87228060Sbapt static lldb::BroadcasterManagerSP MakeBroadcasterManager(); 88228060Sbapt 89228060Sbapt ~BroadcasterManager() = default; 90228060Sbapt 91228060Sbapt uint32_t RegisterListenerForEvents(const lldb::ListenerSP &listener_sp, 92228060Sbapt const BroadcastEventSpec &event_spec); 93228060Sbapt 94228060Sbapt bool UnregisterListenerForEvents(const lldb::ListenerSP &listener_sp, 95228060Sbapt const BroadcastEventSpec &event_spec); 96228060Sbapt 97228060Sbapt lldb::ListenerSP 98228060Sbapt GetListenerForEventSpec(const BroadcastEventSpec &event_spec) const; 99228060Sbapt 100228060Sbapt void SignUpListenersForBroadcaster(Broadcaster &broadcaster); 101228060Sbapt 102228060Sbapt void RemoveListener(const lldb::ListenerSP &listener_sp); 103228060Sbapt 104228060Sbapt void RemoveListener(Listener *listener); 105228060Sbapt 106228060Sbapt void Clear(); 107228060Sbapt 108228060Sbaptprivate: 109228060Sbapt typedef std::pair<BroadcastEventSpec, lldb::ListenerSP> event_listener_key; 110228060Sbapt typedef std::map<BroadcastEventSpec, lldb::ListenerSP> collection; 111228060Sbapt typedef std::set<lldb::ListenerSP> listener_collection; 112228060Sbapt collection m_event_map; 113228060Sbapt listener_collection m_listeners; 114228060Sbapt 115228060Sbapt mutable std::recursive_mutex m_manager_mutex; 116228060Sbapt 117228060Sbapt // A couple of comparator classes for find_if: 118228060Sbapt 119228060Sbapt class BroadcasterClassMatches { 120228060Sbapt public: 121228060Sbapt BroadcasterClassMatches(ConstString broadcaster_class) 122228060Sbapt : m_broadcaster_class(broadcaster_class) {} 123228060Sbapt 124228060Sbapt ~BroadcasterClassMatches() = default; 125228060Sbapt 126228060Sbapt bool operator()(const event_listener_key &input) const { 127228060Sbapt return (input.first.GetBroadcasterClass() == m_broadcaster_class); 128228060Sbapt } 129228060Sbapt 130228060Sbapt private: 131228060Sbapt ConstString m_broadcaster_class; 132228060Sbapt }; 133228060Sbapt 134228060Sbapt class BroadcastEventSpecMatches { 135228060Sbapt public: 136228060Sbapt BroadcastEventSpecMatches(const BroadcastEventSpec &broadcaster_spec) 137228060Sbapt : m_broadcaster_spec(broadcaster_spec) {} 138228060Sbapt 139228060Sbapt ~BroadcastEventSpecMatches() = default; 140228060Sbapt 141228060Sbapt bool operator()(const event_listener_key &input) const { 142228060Sbapt return (input.first.IsContainedIn(m_broadcaster_spec)); 143228060Sbapt } 144228060Sbapt 145228060Sbapt private: 146228060Sbapt BroadcastEventSpec m_broadcaster_spec; 147228060Sbapt }; 148228060Sbapt 149228060Sbapt class ListenerMatchesAndSharedBits { 150228060Sbapt public: 151228060Sbapt explicit ListenerMatchesAndSharedBits( 152228060Sbapt const BroadcastEventSpec &broadcaster_spec, 153228060Sbapt const lldb::ListenerSP &listener_sp) 154228060Sbapt : m_broadcaster_spec(broadcaster_spec), m_listener_sp(listener_sp) {} 155228060Sbapt 156228060Sbapt ~ListenerMatchesAndSharedBits() = default; 157228060Sbapt 158228060Sbapt bool operator()(const event_listener_key &input) const { 159228060Sbapt return (input.first.GetBroadcasterClass() == 160228060Sbapt m_broadcaster_spec.GetBroadcasterClass() && 161228060Sbapt (input.first.GetEventBits() & 162228060Sbapt m_broadcaster_spec.GetEventBits()) != 0 && 163228060Sbapt input.second == m_listener_sp); 164228060Sbapt } 165228060Sbapt 166228060Sbapt private: 167228060Sbapt BroadcastEventSpec m_broadcaster_spec; 168228060Sbapt const lldb::ListenerSP m_listener_sp; 169228060Sbapt }; 170228060Sbapt 171228060Sbapt class ListenerMatches { 172228060Sbapt public: 173228060Sbapt explicit ListenerMatches(const lldb::ListenerSP &in_listener_sp) 174228060Sbapt : m_listener_sp(in_listener_sp) {} 175228060Sbapt 176228060Sbapt ~ListenerMatches() = default; 177228060Sbapt 178228060Sbapt bool operator()(const event_listener_key &input) const { 179228060Sbapt if (input.second == m_listener_sp) 180228060Sbapt return true; 181228060Sbapt 182228060Sbapt return false; 183228060Sbapt } 184228060Sbapt 185228060Sbapt private: 186228060Sbapt const lldb::ListenerSP m_listener_sp; 187228060Sbapt }; 188228060Sbapt 189228060Sbapt class ListenerMatchesPointer { 190228060Sbapt public: 191228060Sbapt ListenerMatchesPointer(const Listener *in_listener) 192228060Sbapt : m_listener(in_listener) {} 193228060Sbapt 194228060Sbapt ~ListenerMatchesPointer() = default; 195228060Sbapt 196228060Sbapt bool operator()(const event_listener_key &input) const { 197228060Sbapt if (input.second.get() == m_listener) 198228060Sbapt return true; 199228060Sbapt 200228060Sbapt return false; 201228060Sbapt } 202228060Sbapt 203228060Sbapt bool operator()(const lldb::ListenerSP &input) const { 204228060Sbapt if (input.get() == m_listener) 205228060Sbapt return true; 206228060Sbapt 207228060Sbapt return false; 208228060Sbapt } 209228060Sbapt 210228060Sbapt private: 211228060Sbapt const Listener *m_listener; 212228060Sbapt }; 213228060Sbapt}; 214228060Sbapt 215228060Sbapt/// \class Broadcaster Broadcaster.h "lldb/Utility/Broadcaster.h" An event 216228060Sbapt/// broadcasting class. 217228060Sbapt/// 218228060Sbapt/// The Broadcaster class is designed to be subclassed by objects that wish to 219228060Sbapt/// vend events in a multi-threaded environment. Broadcaster objects can each 220228060Sbapt/// vend 32 events. Each event is represented by a bit in a 32 bit value and 221228060Sbapt/// these bits can be set: 222228060Sbapt/// \see Broadcaster::SetEventBits(uint32_t) 223228060Sbapt/// or cleared: 224228060Sbapt/// \see Broadcaster::ResetEventBits(uint32_t) 225228060Sbapt/// When an event gets set the Broadcaster object will notify the Listener 226228060Sbapt/// object that is listening for the event (if there is one). 227228060Sbapt/// 228228060Sbapt/// Subclasses should provide broadcast bit definitions for any events they 229228060Sbapt/// vend, typically using an enumeration: 230228060Sbapt/// \code 231228060Sbapt/// class Foo : public Broadcaster 232228060Sbapt/// { 233228060Sbapt/// public: 234228060Sbapt/// // Broadcaster event bits definitions. 235228060Sbapt/// enum 236228060Sbapt/// { 237228060Sbapt/// eBroadcastBitOne = (1 << 0), 238228060Sbapt/// eBroadcastBitTwo = (1 << 1), 239228060Sbapt/// eBroadcastBitThree = (1 << 2), 240228060Sbapt/// ... 241228060Sbapt/// }; 242228060Sbapt/// \endcode 243228060Sbaptclass Broadcaster { 244228060Sbapt friend class Listener; 245228060Sbapt friend class Event; 246228060Sbapt 247228060Sbaptpublic: 248228060Sbapt /// Construct with a broadcaster with a name. 249228060Sbapt /// 250228060Sbapt /// \param[in] name 251228060Sbapt /// A NULL terminated C string that contains the name of the 252228060Sbapt /// broadcaster object. 253228060Sbapt Broadcaster(lldb::BroadcasterManagerSP manager_sp, const char *name); 254228060Sbapt 255228060Sbapt /// Destructor. 256228060Sbapt /// 257228060Sbapt /// The destructor is virtual since this class gets subclassed. 258228060Sbapt virtual ~Broadcaster(); 259228060Sbapt 260228060Sbapt void CheckInWithManager(); 261228060Sbapt 262228060Sbapt /// Broadcast an event which has no associated data. 263228060Sbapt /// 264228060Sbapt /// \param[in] event_type 265228060Sbapt /// The element from the enum defining this broadcaster's events 266228060Sbapt /// that is being broadcast. 267228060Sbapt /// 268228060Sbapt /// \param[in] event_data 269228060Sbapt /// User event data that will be owned by the lldb::Event that 270228060Sbapt /// is created internally. 271228060Sbapt /// 272228060Sbapt /// \param[in] unique 273228060Sbapt /// If true, then only add an event of this type if there isn't 274228060Sbapt /// one already in the queue. 275228060Sbapt /// 276228060Sbapt void BroadcastEvent(lldb::EventSP &event_sp) { 277228060Sbapt m_broadcaster_sp->BroadcastEvent(event_sp); 278228060Sbapt } 279228060Sbapt 280228060Sbapt void BroadcastEventIfUnique(lldb::EventSP &event_sp) { 281228060Sbapt m_broadcaster_sp->BroadcastEventIfUnique(event_sp); 282228060Sbapt } 283228060Sbapt 284228060Sbapt void BroadcastEvent(uint32_t event_type, 285228060Sbapt const lldb::EventDataSP &event_data_sp) { 286228060Sbapt m_broadcaster_sp->BroadcastEvent(event_type, event_data_sp); 287228060Sbapt } 288228060Sbapt 289228060Sbapt void BroadcastEvent(uint32_t event_type, EventData *event_data = nullptr) { 290228060Sbapt m_broadcaster_sp->BroadcastEvent(event_type, event_data); 291228060Sbapt } 292228060Sbapt 293228060Sbapt void BroadcastEventIfUnique(uint32_t event_type, 294228060Sbapt EventData *event_data = nullptr) { 295228060Sbapt m_broadcaster_sp->BroadcastEventIfUnique(event_type, event_data); 296228060Sbapt } 297228060Sbapt 298228060Sbapt void Clear() { m_broadcaster_sp->Clear(); } 299228060Sbapt 300228060Sbapt virtual void AddInitialEventsToListener(const lldb::ListenerSP &listener_sp, 301228060Sbapt uint32_t requested_events); 302228060Sbapt 303228060Sbapt /// Listen for any events specified by \a event_mask. 304228060Sbapt /// 305228060Sbapt /// Only one listener can listen to each event bit in a given Broadcaster. 306228060Sbapt /// Once a listener has acquired an event bit, no other broadcaster will 307228060Sbapt /// have access to it until it is relinquished by the first listener that 308228060Sbapt /// gets it. The actual event bits that get acquired by \a listener may be 309228060Sbapt /// different from what is requested in \a event_mask, and to track this the 310228060Sbapt /// actual event bits that are acquired get returned. 311228060Sbapt /// 312228060Sbapt /// \param[in] listener 313228060Sbapt /// The Listener object that wants to monitor the events that 314228060Sbapt /// get broadcast by this object. 315228060Sbapt /// 316228060Sbapt /// \param[in] event_mask 317228060Sbapt /// A bit mask that indicates which events the listener is 318228060Sbapt /// asking to monitor. 319228060Sbapt /// 320228060Sbapt /// \return 321228060Sbapt /// The actual event bits that were acquired by \a listener. 322228060Sbapt uint32_t AddListener(const lldb::ListenerSP &listener_sp, 323228060Sbapt uint32_t event_mask) { 324228060Sbapt return m_broadcaster_sp->AddListener(listener_sp, event_mask); 325228060Sbapt } 326228060Sbapt 327228060Sbapt /// Get the NULL terminated C string name of this Broadcaster object. 328228060Sbapt /// 329228060Sbapt /// \return 330228060Sbapt /// The NULL terminated C string name of this Broadcaster. 331228060Sbapt ConstString GetBroadcasterName() { return m_broadcaster_name; } 332228060Sbapt 333228060Sbapt /// Get the event name(s) for one or more event bits. 334228060Sbapt /// 335228060Sbapt /// \param[in] event_mask 336228060Sbapt /// A bit mask that indicates which events to get names for. 337228060Sbapt /// 338228060Sbapt /// \return 339228060Sbapt /// The NULL terminated C string name of this Broadcaster. 340228060Sbapt bool GetEventNames(Stream &s, const uint32_t event_mask, 341228060Sbapt bool prefix_with_broadcaster_name) const { 342228060Sbapt return m_broadcaster_sp->GetEventNames(s, event_mask, 343228060Sbapt prefix_with_broadcaster_name); 344228060Sbapt } 345228060Sbapt 346228060Sbapt /// Set the name for an event bit. 347228060Sbapt /// 348228060Sbapt /// \param[in] event_mask 349228060Sbapt /// A bit mask that indicates which events the listener is 350228060Sbapt /// asking to monitor. 351228060Sbapt /// 352228060Sbapt /// \return 353228060Sbapt /// The NULL terminated C string name of this Broadcaster. 354228060Sbapt void SetEventName(uint32_t event_mask, const char *name) { 355228060Sbapt m_broadcaster_sp->SetEventName(event_mask, name); 356228060Sbapt } 357228060Sbapt 358228060Sbapt const char *GetEventName(uint32_t event_mask) const { 359228060Sbapt return m_broadcaster_sp->GetEventName(event_mask); 360228060Sbapt } 361228060Sbapt 362228060Sbapt bool EventTypeHasListeners(uint32_t event_type) { 363228060Sbapt return m_broadcaster_sp->EventTypeHasListeners(event_type); 364228060Sbapt } 365228060Sbapt 366228060Sbapt /// Removes a Listener from this broadcasters list and frees the event bits 367228060Sbapt /// specified by \a event_mask that were previously acquired by \a listener 368228060Sbapt /// (assuming \a listener was listening to this object) for other listener 369228060Sbapt /// objects to use. 370228060Sbapt /// 371228060Sbapt /// \param[in] listener 372228060Sbapt /// A Listener object that previously called AddListener. 373228060Sbapt /// 374228060Sbapt /// \param[in] event_mask 375228060Sbapt /// The event bits \a listener wishes to relinquish. 376228060Sbapt /// 377228060Sbapt /// \return 378228060Sbapt /// \b True if the listener was listening to this broadcaster 379228060Sbapt /// and was removed, \b false otherwise. 380228060Sbapt /// 381228060Sbapt /// \see uint32_t Broadcaster::AddListener (Listener*, uint32_t) 382228060Sbapt bool RemoveListener(const lldb::ListenerSP &listener_sp, 383228060Sbapt uint32_t event_mask = UINT32_MAX) { 384228060Sbapt return m_broadcaster_sp->RemoveListener(listener_sp, event_mask); 385228060Sbapt } 386228060Sbapt 387228060Sbapt /// Provides a simple mechanism to temporarily redirect events from 388228060Sbapt /// broadcaster. When you call this function passing in a listener and 389228060Sbapt /// event type mask, all events from the broadcaster matching the mask will 390228060Sbapt /// now go to the hijacking listener. Only one hijack can occur at a time. 391228060Sbapt /// If we need more than this we will have to implement a Listener stack. 392228060Sbapt /// 393228060Sbapt /// \param[in] listener 394228060Sbapt /// A Listener object. You do not need to call StartListeningForEvents 395228060Sbapt /// for this broadcaster (that would fail anyway since the event bits 396228060Sbapt /// would most likely be taken by the listener(s) you are usurping. 397228060Sbapt /// 398228060Sbapt /// \param[in] event_mask 399228060Sbapt /// The event bits \a listener wishes to hijack. 400228060Sbapt /// 401228060Sbapt /// \return 402228060Sbapt /// \b True if the event mask could be hijacked, \b false otherwise. 403228060Sbapt /// 404228060Sbapt /// \see uint32_t Broadcaster::AddListener (Listener*, uint32_t) 405228060Sbapt bool HijackBroadcaster(const lldb::ListenerSP &listener_sp, 406228060Sbapt uint32_t event_mask = UINT32_MAX) { 407228060Sbapt return m_broadcaster_sp->HijackBroadcaster(listener_sp, event_mask); 408228060Sbapt } 409228060Sbapt 410228060Sbapt bool IsHijackedForEvent(uint32_t event_mask) { 411228060Sbapt return m_broadcaster_sp->IsHijackedForEvent(event_mask); 412228060Sbapt } 413228060Sbapt 414228060Sbapt /// Restore the state of the Broadcaster from a previous hijack attempt. 415228060Sbapt void RestoreBroadcaster() { m_broadcaster_sp->RestoreBroadcaster(); } 416228060Sbapt 417228060Sbapt /// This needs to be filled in if you are going to register the broadcaster 418228060Sbapt /// with the broadcaster manager and do broadcaster class matching. 419228060Sbapt /// FIXME: Probably should make a ManagedBroadcaster subclass with all the 420228060Sbapt /// bits needed to work with the BroadcasterManager, so that it is clearer 421228060Sbapt /// how to add one. 422228060Sbapt virtual ConstString &GetBroadcasterClass() const; 423228060Sbapt 424228060Sbapt lldb::BroadcasterManagerSP GetManager(); 425228060Sbapt 426228060Sbaptprotected: 427228060Sbapt /// BroadcasterImpl contains the actual Broadcaster implementation. The 428228060Sbapt /// Broadcaster makes a BroadcasterImpl which lives as long as it does. The 429228060Sbapt /// Listeners & the Events hold a weak pointer to the BroadcasterImpl, so 430228060Sbapt /// that they can survive if a Broadcaster they were listening to is 431228060Sbapt /// destroyed w/o their being able to unregister from it (which can happen if 432228060Sbapt /// the Broadcasters & Listeners are being destroyed on separate threads 433228060Sbapt /// simultaneously. The Broadcaster itself can't be shared out as a weak 434228060Sbapt /// pointer, because some things that are broadcasters (e.g. the Target and 435228060Sbapt /// the Process) are shared in their own right. 436228060Sbapt /// 437228060Sbapt /// For the most part, the Broadcaster functions dispatch to the 438228060Sbapt /// BroadcasterImpl, and are documented in the public Broadcaster API above. 439228060Sbapt class BroadcasterImpl { 440228060Sbapt friend class Listener; 441228060Sbapt friend class Broadcaster; 442228060Sbapt 443228060Sbapt public: 444228060Sbapt BroadcasterImpl(Broadcaster &broadcaster); 445228060Sbapt 446228060Sbapt ~BroadcasterImpl() = default; 447228060Sbapt 448228060Sbapt void BroadcastEvent(lldb::EventSP &event_sp); 449228060Sbapt 450228060Sbapt void BroadcastEventIfUnique(lldb::EventSP &event_sp); 451228060Sbapt 452228060Sbapt void BroadcastEvent(uint32_t event_type, EventData *event_data = nullptr); 453228060Sbapt 454228060Sbapt void BroadcastEvent(uint32_t event_type, 455228060Sbapt const lldb::EventDataSP &event_data_sp); 456228060Sbapt 457228060Sbapt void BroadcastEventIfUnique(uint32_t event_type, 458228060Sbapt EventData *event_data = nullptr); 459228060Sbapt 460228060Sbapt void Clear(); 461228060Sbapt 462228060Sbapt uint32_t AddListener(const lldb::ListenerSP &listener_sp, 463228060Sbapt uint32_t event_mask); 464228060Sbapt 465228060Sbapt const char *GetBroadcasterName() const { 466228060Sbapt return m_broadcaster.GetBroadcasterName().AsCString(); 467228060Sbapt } 468228060Sbapt 469228060Sbapt Broadcaster *GetBroadcaster(); 470228060Sbapt 471228060Sbapt bool GetEventNames(Stream &s, const uint32_t event_mask, 472228060Sbapt bool prefix_with_broadcaster_name) const; 473228060Sbapt 474228060Sbapt void SetEventName(uint32_t event_mask, const char *name) { 475228060Sbapt m_event_names[event_mask] = name; 476228060Sbapt } 477228060Sbapt 478228060Sbapt const char *GetEventName(uint32_t event_mask) const { 479228060Sbapt const auto pos = m_event_names.find(event_mask); 480228060Sbapt if (pos != m_event_names.end()) 481228060Sbapt return pos->second.c_str(); 482228060Sbapt return nullptr; 483228060Sbapt } 484228060Sbapt 485228060Sbapt bool EventTypeHasListeners(uint32_t event_type); 486228060Sbapt 487228060Sbapt bool RemoveListener(lldb_private::Listener *listener, 488228060Sbapt uint32_t event_mask = UINT32_MAX); 489228060Sbapt 490228060Sbapt bool RemoveListener(const lldb::ListenerSP &listener_sp, 491228060Sbapt uint32_t event_mask = UINT32_MAX); 492228060Sbapt 493228060Sbapt bool HijackBroadcaster(const lldb::ListenerSP &listener_sp, 494228060Sbapt uint32_t event_mask = UINT32_MAX); 495228060Sbapt 496228060Sbapt bool IsHijackedForEvent(uint32_t event_mask); 497228060Sbapt 498228060Sbapt void RestoreBroadcaster(); 499228060Sbapt 500228060Sbapt protected: 501228060Sbapt void PrivateBroadcastEvent(lldb::EventSP &event_sp, bool unique); 502228060Sbapt 503228060Sbapt const char *GetHijackingListenerName(); 504228060Sbapt 505228060Sbapt typedef llvm::SmallVector<std::pair<lldb::ListenerWP, uint32_t>, 4> 506228060Sbapt collection; 507228060Sbapt typedef std::map<uint32_t, std::string> event_names_map; 508228060Sbapt 509228060Sbapt llvm::SmallVector<std::pair<lldb::ListenerSP, uint32_t &>, 4> 510228060Sbapt GetListeners(); 511228060Sbapt 512228060Sbapt /// The broadcaster that this implements. 513228060Sbapt Broadcaster &m_broadcaster; 514228060Sbapt 515228060Sbapt /// Optionally define event names for readability and logging for each 516228060Sbapt /// event bit. 517228060Sbapt event_names_map m_event_names; 518228060Sbapt 519228060Sbapt /// A list of Listener / event_mask pairs that are listening to this 520228060Sbapt /// broadcaster. 521228060Sbapt collection m_listeners; 522228060Sbapt 523228060Sbapt /// A mutex that protects \a m_listeners. 524228060Sbapt std::recursive_mutex m_listeners_mutex; 525228060Sbapt 526228060Sbapt /// A simple mechanism to intercept events from a broadcaster 527228060Sbapt std::vector<lldb::ListenerSP> m_hijacking_listeners; 528228060Sbapt 529228060Sbapt /// At some point we may want to have a stack or Listener collections, but 530228060Sbapt /// for now this is just for private hijacking. 531228060Sbapt std::vector<uint32_t> m_hijacking_masks; 532228060Sbapt 533228060Sbapt private: 534228060Sbapt DISALLOW_COPY_AND_ASSIGN(BroadcasterImpl); 535228060Sbapt }; 536228060Sbapt 537228060Sbapt typedef std::shared_ptr<BroadcasterImpl> BroadcasterImplSP; 538228060Sbapt typedef std::weak_ptr<BroadcasterImpl> BroadcasterImplWP; 539228060Sbapt 540228060Sbapt BroadcasterImplSP GetBroadcasterImpl() { return m_broadcaster_sp; } 541228060Sbapt 542228060Sbapt const char *GetHijackingListenerName() { 543228060Sbapt return m_broadcaster_sp->GetHijackingListenerName(); 544228060Sbapt } 545228060Sbapt 546228060Sbaptprivate: 547228060Sbapt BroadcasterImplSP m_broadcaster_sp; 548228060Sbapt lldb::BroadcasterManagerSP m_manager_sp; 549228060Sbapt 550228060Sbapt /// The name of this broadcaster object. 551228060Sbapt const ConstString m_broadcaster_name; 552228060Sbapt 553228060Sbapt DISALLOW_COPY_AND_ASSIGN(Broadcaster); 554228060Sbapt}; 555228060Sbapt 556228060Sbapt} // namespace lldb_private 557228060Sbapt 558228060Sbapt#endif // LLDB_UTILITY_BROADCASTER_H 559228060Sbapt