Broadcaster.h revision 343218
155682Smarkm//===-- Broadcaster.h -------------------------------------------*- C++ -*-===// 2178825Sdfr// 355682Smarkm// The LLVM Compiler Infrastructure 455682Smarkm// 555682Smarkm// This file is distributed under the University of Illinois Open Source 655682Smarkm// License. See LICENSE.TXT for details. 755682Smarkm// 855682Smarkm//===----------------------------------------------------------------------===// 955682Smarkm 1055682Smarkm#ifndef LLDB_UTILITY_BROADCASTER_H 1155682Smarkm#define LLDB_UTILITY_BROADCASTER_H 1255682Smarkm 1355682Smarkm#include "lldb/Utility/ConstString.h" 1455682Smarkm#include "lldb/lldb-defines.h" 1555682Smarkm#include "lldb/lldb-forward.h" 1655682Smarkm 1755682Smarkm#include "llvm/ADT/SmallVector.h" 1855682Smarkm 1955682Smarkm#include <cstdint> 2055682Smarkm#include <map> 2155682Smarkm#include <memory> 2255682Smarkm#include <mutex> 2355682Smarkm#include <set> 2455682Smarkm#include <string> 2555682Smarkm#include <utility> 2655682Smarkm#include <vector> 2755682Smarkm 2855682Smarkmnamespace lldb_private { 2955682Smarkmclass Broadcaster; 3055682Smarkm} 3155682Smarkmnamespace lldb_private { 3255682Smarkmclass EventData; 3355682Smarkm} 3455682Smarkmnamespace lldb_private { 3555682Smarkmclass Listener; 36178825Sdfr} 3755682Smarkmnamespace lldb_private { 3855682Smarkmclass Stream; 3972445Sassar} 4072445Sassar 4172445Sassarnamespace lldb_private { 4272445Sassar 4372445Sassar//---------------------------------------------------------------------- 4472445Sassar// lldb::BroadcastEventSpec 4572445Sassar// 4672445Sassar// This class is used to specify a kind of event to register for. The Debugger 4772445Sassar// maintains a list of BroadcastEventSpec's and when it is made 4872445Sassar//---------------------------------------------------------------------- 49178825Sdfrclass BroadcastEventSpec { 5072445Sassarpublic: 51178825Sdfr BroadcastEventSpec(const ConstString &broadcaster_class, uint32_t event_bits) 52178825Sdfr : m_broadcaster_class(broadcaster_class), m_event_bits(event_bits) {} 53178825Sdfr 54178825Sdfr BroadcastEventSpec(const BroadcastEventSpec &rhs); 55178825Sdfr 5672445Sassar ~BroadcastEventSpec() = default; 57178825Sdfr 5855682Smarkm const ConstString &GetBroadcasterClass() const { return m_broadcaster_class; } 5972445Sassar 60178825Sdfr uint32_t GetEventBits() const { return m_event_bits; } 61178825Sdfr 62178825Sdfr // Tell whether this BroadcastEventSpec is contained in in_spec. That is: (a) 63178825Sdfr // the two spec's share the same broadcaster class (b) the event bits of this 64178825Sdfr // spec are wholly contained in those of in_spec. 65178825Sdfr bool IsContainedIn(BroadcastEventSpec in_spec) const { 66178825Sdfr if (m_broadcaster_class != in_spec.GetBroadcasterClass()) 67178825Sdfr return false; 68178825Sdfr uint32_t in_bits = in_spec.GetEventBits(); 69178825Sdfr if (in_bits == m_event_bits) 70178825Sdfr return true; 71178825Sdfr else { 7272445Sassar if ((m_event_bits & in_bits) != 0 && (m_event_bits & ~in_bits) == 0) 7355682Smarkm return true; 7455682Smarkm } 7555682Smarkm return false; 7655682Smarkm } 7755682Smarkm 7855682Smarkm bool operator<(const BroadcastEventSpec &rhs) const; 7955682Smarkm BroadcastEventSpec &operator=(const BroadcastEventSpec &rhs); 8072445Sassar 8172445Sassarprivate: 8255682Smarkm ConstString m_broadcaster_class; 8355682Smarkm uint32_t m_event_bits; 8455682Smarkm}; 8555682Smarkm 8655682Smarkmclass BroadcasterManager 8772445Sassar : public std::enable_shared_from_this<BroadcasterManager> { 8872445Sassarpublic: 8955682Smarkm friend class Listener; 9072445Sassar 9172445Sassarprotected: 9272445Sassar BroadcasterManager(); 9355682Smarkm 9472445Sassarpublic: 9572445Sassar // Listeners hold onto weak pointers to their broadcaster managers. So they 9672445Sassar // must be made into shared pointers, which you do with 9755682Smarkm // MakeBroadcasterManager. 9872445Sassar 9972445Sassar static lldb::BroadcasterManagerSP MakeBroadcasterManager(); 10072445Sassar 10155682Smarkm ~BroadcasterManager() = default; 10255682Smarkm 10355682Smarkm uint32_t RegisterListenerForEvents(const lldb::ListenerSP &listener_sp, 10472445Sassar BroadcastEventSpec event_spec); 10555682Smarkm 10655682Smarkm bool UnregisterListenerForEvents(const lldb::ListenerSP &listener_sp, 10772445Sassar BroadcastEventSpec event_spec); 10855682Smarkm 10972445Sassar lldb::ListenerSP GetListenerForEventSpec(BroadcastEventSpec event_spec) const; 11072445Sassar 11172445Sassar void SignUpListenersForBroadcaster(Broadcaster &broadcaster); 11272445Sassar 11372445Sassar void RemoveListener(const lldb::ListenerSP &listener_sp); 11455682Smarkm 11555682Smarkm void RemoveListener(Listener *listener); 11655682Smarkm 11755682Smarkm void Clear(); 11855682Smarkm 11972445Sassarprivate: 12055682Smarkm typedef std::pair<BroadcastEventSpec, lldb::ListenerSP> event_listener_key; 121178825Sdfr typedef std::map<BroadcastEventSpec, lldb::ListenerSP> collection; 12272445Sassar typedef std::set<lldb::ListenerSP> listener_collection; 12372445Sassar collection m_event_map; 124178825Sdfr listener_collection m_listeners; 125178825Sdfr 126178825Sdfr mutable std::recursive_mutex m_manager_mutex; 127178825Sdfr 12855682Smarkm // A couple of comparator classes for find_if: 12972445Sassar 130178825Sdfr class BroadcasterClassMatches { 13172445Sassar public: 13255682Smarkm BroadcasterClassMatches(const ConstString &broadcaster_class) 13355682Smarkm : m_broadcaster_class(broadcaster_class) {} 13455682Smarkm 13572445Sassar ~BroadcasterClassMatches() = default; 13672445Sassar 13772445Sassar bool operator()(const event_listener_key input) const { 13872445Sassar return (input.first.GetBroadcasterClass() == m_broadcaster_class); 13972445Sassar } 14072445Sassar 14172445Sassar private: 14272445Sassar ConstString m_broadcaster_class; 14372445Sassar }; 14472445Sassar 14572445Sassar class BroadcastEventSpecMatches { 14672445Sassar public: 14772445Sassar BroadcastEventSpecMatches(BroadcastEventSpec broadcaster_spec) 14872445Sassar : m_broadcaster_spec(broadcaster_spec) {} 14972445Sassar 15072445Sassar ~BroadcastEventSpecMatches() = default; 15172445Sassar 15272445Sassar bool operator()(const event_listener_key input) const { 15372445Sassar return (input.first.IsContainedIn(m_broadcaster_spec)); 15472445Sassar } 15572445Sassar 15672445Sassar private: 15772445Sassar BroadcastEventSpec m_broadcaster_spec; 15872445Sassar }; 15972445Sassar 16072445Sassar class ListenerMatchesAndSharedBits { 16172445Sassar public: 16272445Sassar explicit ListenerMatchesAndSharedBits(BroadcastEventSpec broadcaster_spec, 16372445Sassar const lldb::ListenerSP listener_sp) 16472445Sassar : m_broadcaster_spec(broadcaster_spec), m_listener_sp(listener_sp) {} 165178825Sdfr 16672445Sassar ~ListenerMatchesAndSharedBits() = default; 16772445Sassar 168178825Sdfr bool operator()(const event_listener_key input) const { 169178825Sdfr return (input.first.GetBroadcasterClass() == 170178825Sdfr m_broadcaster_spec.GetBroadcasterClass() && 171178825Sdfr (input.first.GetEventBits() & 17272445Sassar m_broadcaster_spec.GetEventBits()) != 0 && 17372445Sassar input.second == m_listener_sp); 174178825Sdfr } 17572445Sassar 17672445Sassar private: 17772445Sassar BroadcastEventSpec m_broadcaster_spec; 17872445Sassar const lldb::ListenerSP m_listener_sp; 179178825Sdfr }; 180178825Sdfr 181178825Sdfr class ListenerMatches { 182178825Sdfr public: 183178825Sdfr explicit ListenerMatches(const lldb::ListenerSP in_listener_sp) 184178825Sdfr : m_listener_sp(in_listener_sp) {} 185178825Sdfr 186178825Sdfr ~ListenerMatches() = default; 187178825Sdfr 188178825Sdfr bool operator()(const event_listener_key input) const { 189178825Sdfr if (input.second == m_listener_sp) 190178825Sdfr return true; 191178825Sdfr else 19255682Smarkm return false; 19355682Smarkm } 19455682Smarkm 19555682Smarkm private: 19655682Smarkm const lldb::ListenerSP m_listener_sp; 19755682Smarkm }; 19855682Smarkm 19955682Smarkm class ListenerMatchesPointer { 20055682Smarkm public: 20155682Smarkm ListenerMatchesPointer(const Listener *in_listener) 202178825Sdfr : m_listener(in_listener) {} 203178825Sdfr 204178825Sdfr ~ListenerMatchesPointer() = default; 205178825Sdfr 206178825Sdfr bool operator()(const event_listener_key input) const { 20755682Smarkm if (input.second.get() == m_listener) 208178825Sdfr return true; 209178825Sdfr else 210178825Sdfr return false; 211178825Sdfr } 21255682Smarkm 213178825Sdfr bool operator()(const lldb::ListenerSP input) const { 214178825Sdfr if (input.get() == m_listener) 215178825Sdfr return true; 216178825Sdfr else 217178825Sdfr return false; 218178825Sdfr } 219178825Sdfr 22055682Smarkm private: 221178825Sdfr const Listener *m_listener; 222178825Sdfr }; 22355682Smarkm}; 224178825Sdfr 225178825Sdfr//---------------------------------------------------------------------- 226178825Sdfr/// @class Broadcaster Broadcaster.h "lldb/Utility/Broadcaster.h" An event 227178825Sdfr/// broadcasting class. 22855682Smarkm/// 229178825Sdfr/// The Broadcaster class is designed to be subclassed by objects that wish to 230178825Sdfr/// vend events in a multi-threaded environment. Broadcaster objects can each 231178825Sdfr/// vend 32 events. Each event is represented by a bit in a 32 bit value and 232178825Sdfr/// these bits can be set: 233178825Sdfr/// @see Broadcaster::SetEventBits(uint32_t) 234178825Sdfr/// or cleared: 235178825Sdfr/// @see Broadcaster::ResetEventBits(uint32_t) 236178825Sdfr/// When an event gets set the Broadcaster object will notify the Listener 237178825Sdfr/// object that is listening for the event (if there is one). 238178825Sdfr/// 239178825Sdfr/// Subclasses should provide broadcast bit definitions for any events they 240178825Sdfr/// vend, typically using an enumeration: 241178825Sdfr/// \code 24255682Smarkm/// class Foo : public Broadcaster 243178825Sdfr/// { 244178825Sdfr/// public: 245178825Sdfr/// //---------------------------------------------------------- 24655682Smarkm/// // Broadcaster event bits definitions. 24755682Smarkm/// //---------------------------------------------------------- 248178825Sdfr/// enum 249178825Sdfr/// { 25055682Smarkm/// eBroadcastBitOne = (1 << 0), 25155682Smarkm/// eBroadcastBitTwo = (1 << 1), 252178825Sdfr/// eBroadcastBitThree = (1 << 2), 25355682Smarkm/// ... 254178825Sdfr/// }; 255178825Sdfr/// \endcode 256178825Sdfr//---------------------------------------------------------------------- 257178825Sdfrclass Broadcaster { 258178825Sdfr friend class Listener; 259178825Sdfr friend class Event; 260178825Sdfr 261178825Sdfrpublic: 262178825Sdfr //------------------------------------------------------------------ 263178825Sdfr /// Construct with a broadcaster with a name. 264178825Sdfr /// 265178825Sdfr /// @param[in] name 266178825Sdfr /// A NULL terminated C string that contains the name of the 267178825Sdfr /// broadcaster object. 26855682Smarkm //------------------------------------------------------------------ 269178825Sdfr Broadcaster(lldb::BroadcasterManagerSP manager_sp, const char *name); 270178825Sdfr 27155682Smarkm //------------------------------------------------------------------ 272178825Sdfr /// Destructor. 27355682Smarkm /// 274 /// The destructor is virtual since this class gets subclassed. 275 //------------------------------------------------------------------ 276 virtual ~Broadcaster(); 277 278 void CheckInWithManager(); 279 280 //------------------------------------------------------------------ 281 /// Broadcast an event which has no associated data. 282 /// 283 /// @param[in] event_type 284 /// The element from the enum defining this broadcaster's events 285 /// that is being broadcast. 286 /// 287 /// @param[in] event_data 288 /// User event data that will be owned by the lldb::Event that 289 /// is created internally. 290 /// 291 /// @param[in] unique 292 /// If true, then only add an event of this type if there isn't 293 /// one already in the queue. 294 /// 295 //------------------------------------------------------------------ 296 void BroadcastEvent(lldb::EventSP &event_sp) { 297 m_broadcaster_sp->BroadcastEvent(event_sp); 298 } 299 300 void BroadcastEventIfUnique(lldb::EventSP &event_sp) { 301 m_broadcaster_sp->BroadcastEventIfUnique(event_sp); 302 } 303 304 void BroadcastEvent(uint32_t event_type, 305 const lldb::EventDataSP &event_data_sp) { 306 m_broadcaster_sp->BroadcastEvent(event_type, event_data_sp); 307 } 308 309 void BroadcastEvent(uint32_t event_type, EventData *event_data = nullptr) { 310 m_broadcaster_sp->BroadcastEvent(event_type, event_data); 311 } 312 313 void BroadcastEventIfUnique(uint32_t event_type, 314 EventData *event_data = nullptr) { 315 m_broadcaster_sp->BroadcastEventIfUnique(event_type, event_data); 316 } 317 318 void Clear() { m_broadcaster_sp->Clear(); } 319 320 virtual void AddInitialEventsToListener(const lldb::ListenerSP &listener_sp, 321 uint32_t requested_events); 322 323 //------------------------------------------------------------------ 324 /// Listen for any events specified by \a event_mask. 325 /// 326 /// Only one listener can listen to each event bit in a given Broadcaster. 327 /// Once a listener has acquired an event bit, no other broadcaster will 328 /// have access to it until it is relinquished by the first listener that 329 /// gets it. The actual event bits that get acquired by \a listener may be 330 /// different from what is requested in \a event_mask, and to track this the 331 /// actual event bits that are acquired get returned. 332 /// 333 /// @param[in] listener 334 /// The Listener object that wants to monitor the events that 335 /// get broadcast by this object. 336 /// 337 /// @param[in] event_mask 338 /// A bit mask that indicates which events the listener is 339 /// asking to monitor. 340 /// 341 /// @return 342 /// The actual event bits that were acquired by \a listener. 343 //------------------------------------------------------------------ 344 uint32_t AddListener(const lldb::ListenerSP &listener_sp, 345 uint32_t event_mask) { 346 return m_broadcaster_sp->AddListener(listener_sp, event_mask); 347 } 348 349 //------------------------------------------------------------------ 350 /// Get the NULL terminated C string name of this Broadcaster object. 351 /// 352 /// @return 353 /// The NULL terminated C string name of this Broadcaster. 354 //------------------------------------------------------------------ 355 const ConstString &GetBroadcasterName() { return m_broadcaster_name; } 356 357 //------------------------------------------------------------------ 358 /// Get the event name(s) for one or more event bits. 359 /// 360 /// @param[in] event_mask 361 /// A bit mask that indicates which events to get names for. 362 /// 363 /// @return 364 /// The NULL terminated C string name of this Broadcaster. 365 //------------------------------------------------------------------ 366 bool GetEventNames(Stream &s, const uint32_t event_mask, 367 bool prefix_with_broadcaster_name) const { 368 return m_broadcaster_sp->GetEventNames(s, event_mask, 369 prefix_with_broadcaster_name); 370 } 371 372 //------------------------------------------------------------------ 373 /// Set the name for an event bit. 374 /// 375 /// @param[in] event_mask 376 /// A bit mask that indicates which events the listener is 377 /// asking to monitor. 378 /// 379 /// @return 380 /// The NULL terminated C string name of this Broadcaster. 381 //------------------------------------------------------------------ 382 void SetEventName(uint32_t event_mask, const char *name) { 383 m_broadcaster_sp->SetEventName(event_mask, name); 384 } 385 386 const char *GetEventName(uint32_t event_mask) const { 387 return m_broadcaster_sp->GetEventName(event_mask); 388 } 389 390 bool EventTypeHasListeners(uint32_t event_type) { 391 return m_broadcaster_sp->EventTypeHasListeners(event_type); 392 } 393 394 //------------------------------------------------------------------ 395 /// Removes a Listener from this broadcasters list and frees the event bits 396 /// specified by \a event_mask that were previously acquired by \a listener 397 /// (assuming \a listener was listening to this object) for other listener 398 /// objects to use. 399 /// 400 /// @param[in] listener 401 /// A Listener object that previously called AddListener. 402 /// 403 /// @param[in] event_mask 404 /// The event bits \a listener wishes to relinquish. 405 /// 406 /// @return 407 /// \b True if the listener was listening to this broadcaster 408 /// and was removed, \b false otherwise. 409 /// 410 /// @see uint32_t Broadcaster::AddListener (Listener*, uint32_t) 411 //------------------------------------------------------------------ 412 bool RemoveListener(const lldb::ListenerSP &listener_sp, 413 uint32_t event_mask = UINT32_MAX) { 414 return m_broadcaster_sp->RemoveListener(listener_sp, event_mask); 415 } 416 417 //------------------------------------------------------------------ 418 /// Provides a simple mechanism to temporarily redirect events from 419 /// broadcaster. When you call this function passing in a listener and 420 /// event type mask, all events from the broadcaster matching the mask will 421 /// now go to the hijacking listener. Only one hijack can occur at a time. 422 /// If we need more than this we will have to implement a Listener stack. 423 /// 424 /// @param[in] listener 425 /// A Listener object. You do not need to call StartListeningForEvents 426 /// for this broadcaster (that would fail anyway since the event bits 427 /// would most likely be taken by the listener(s) you are usurping. 428 /// 429 /// @param[in] event_mask 430 /// The event bits \a listener wishes to hijack. 431 /// 432 /// @return 433 /// \b True if the event mask could be hijacked, \b false otherwise. 434 /// 435 /// @see uint32_t Broadcaster::AddListener (Listener*, uint32_t) 436 //------------------------------------------------------------------ 437 bool HijackBroadcaster(const lldb::ListenerSP &listener_sp, 438 uint32_t event_mask = UINT32_MAX) { 439 return m_broadcaster_sp->HijackBroadcaster(listener_sp, event_mask); 440 } 441 442 bool IsHijackedForEvent(uint32_t event_mask) { 443 return m_broadcaster_sp->IsHijackedForEvent(event_mask); 444 } 445 446 //------------------------------------------------------------------ 447 /// Restore the state of the Broadcaster from a previous hijack attempt. 448 /// 449 //------------------------------------------------------------------ 450 void RestoreBroadcaster() { m_broadcaster_sp->RestoreBroadcaster(); } 451 452 // This needs to be filled in if you are going to register the broadcaster 453 // with the broadcaster manager and do broadcaster class matching. 454 // FIXME: Probably should make a ManagedBroadcaster subclass with all the bits 455 // needed to work 456 // with the BroadcasterManager, so that it is clearer how to add one. 457 virtual ConstString &GetBroadcasterClass() const; 458 459 lldb::BroadcasterManagerSP GetManager(); 460 461protected: 462 // BroadcasterImpl contains the actual Broadcaster implementation. The 463 // Broadcaster makes a BroadcasterImpl which lives as long as it does. The 464 // Listeners & the Events hold a weak pointer to the BroadcasterImpl, so that 465 // they can survive if a Broadcaster they were listening to is destroyed w/o 466 // their being able to unregister from it (which can happen if the 467 // Broadcasters & Listeners are being destroyed on separate threads 468 // simultaneously. The Broadcaster itself can't be shared out as a weak 469 // pointer, because some things that are broadcasters (e.g. the Target and 470 // the Process) are shared in their own right. 471 // 472 // For the most part, the Broadcaster functions dispatch to the 473 // BroadcasterImpl, and are documented in the public Broadcaster API above. 474 475 class BroadcasterImpl { 476 friend class Listener; 477 friend class Broadcaster; 478 479 public: 480 BroadcasterImpl(Broadcaster &broadcaster); 481 482 ~BroadcasterImpl() = default; 483 484 void BroadcastEvent(lldb::EventSP &event_sp); 485 486 void BroadcastEventIfUnique(lldb::EventSP &event_sp); 487 488 void BroadcastEvent(uint32_t event_type, EventData *event_data = nullptr); 489 490 void BroadcastEvent(uint32_t event_type, 491 const lldb::EventDataSP &event_data_sp); 492 493 void BroadcastEventIfUnique(uint32_t event_type, 494 EventData *event_data = nullptr); 495 496 void Clear(); 497 498 uint32_t AddListener(const lldb::ListenerSP &listener_sp, 499 uint32_t event_mask); 500 501 const char *GetBroadcasterName() const { 502 return m_broadcaster.GetBroadcasterName().AsCString(); 503 } 504 505 Broadcaster *GetBroadcaster(); 506 507 bool GetEventNames(Stream &s, const uint32_t event_mask, 508 bool prefix_with_broadcaster_name) const; 509 510 void SetEventName(uint32_t event_mask, const char *name) { 511 m_event_names[event_mask] = name; 512 } 513 514 const char *GetEventName(uint32_t event_mask) const { 515 const auto pos = m_event_names.find(event_mask); 516 if (pos != m_event_names.end()) 517 return pos->second.c_str(); 518 return nullptr; 519 } 520 521 bool EventTypeHasListeners(uint32_t event_type); 522 523 bool RemoveListener(lldb_private::Listener *listener, 524 uint32_t event_mask = UINT32_MAX); 525 526 bool RemoveListener(const lldb::ListenerSP &listener_sp, 527 uint32_t event_mask = UINT32_MAX); 528 529 bool HijackBroadcaster(const lldb::ListenerSP &listener_sp, 530 uint32_t event_mask = UINT32_MAX); 531 532 bool IsHijackedForEvent(uint32_t event_mask); 533 534 void RestoreBroadcaster(); 535 536 protected: 537 void PrivateBroadcastEvent(lldb::EventSP &event_sp, bool unique); 538 539 const char *GetHijackingListenerName(); 540 541 //------------------------------------------------------------------ 542 // 543 //------------------------------------------------------------------ 544 typedef llvm::SmallVector<std::pair<lldb::ListenerWP, uint32_t>, 4> 545 collection; 546 typedef std::map<uint32_t, std::string> event_names_map; 547 548 llvm::SmallVector<std::pair<lldb::ListenerSP, uint32_t &>, 4> 549 GetListeners(); 550 551 Broadcaster &m_broadcaster; ///< The broadcaster that this implements 552 event_names_map m_event_names; ///< Optionally define event names for 553 ///readability and logging for each event bit 554 collection m_listeners; ///< A list of Listener / event_mask pairs that are 555 ///listening to this broadcaster. 556 std::recursive_mutex 557 m_listeners_mutex; ///< A mutex that protects \a m_listeners. 558 std::vector<lldb::ListenerSP> m_hijacking_listeners; // A simple mechanism 559 // to intercept events 560 // from a broadcaster 561 std::vector<uint32_t> m_hijacking_masks; // At some point we may want to 562 // have a stack or Listener 563 // collections, but for now this is just for private hijacking. 564 565 private: 566 //------------------------------------------------------------------ 567 // For Broadcaster only 568 //------------------------------------------------------------------ 569 DISALLOW_COPY_AND_ASSIGN(BroadcasterImpl); 570 }; 571 572 typedef std::shared_ptr<BroadcasterImpl> BroadcasterImplSP; 573 typedef std::weak_ptr<BroadcasterImpl> BroadcasterImplWP; 574 575 BroadcasterImplSP GetBroadcasterImpl() { return m_broadcaster_sp; } 576 577 const char *GetHijackingListenerName() { 578 return m_broadcaster_sp->GetHijackingListenerName(); 579 } 580 //------------------------------------------------------------------ 581 // Classes that inherit from Broadcaster can see and modify these 582 //------------------------------------------------------------------ 583 584private: 585 //------------------------------------------------------------------ 586 // For Broadcaster only 587 //------------------------------------------------------------------ 588 BroadcasterImplSP m_broadcaster_sp; 589 lldb::BroadcasterManagerSP m_manager_sp; 590 const ConstString 591 m_broadcaster_name; ///< The name of this broadcaster object. 592 593 DISALLOW_COPY_AND_ASSIGN(Broadcaster); 594}; 595 596} // namespace lldb_private 597 598#endif // LLDB_UTILITY_BROADCASTER_H 599