1 //===-- Listener.h ----------------------------------------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #ifndef LLDB_UTILITY_LISTENER_H 10 #define LLDB_UTILITY_LISTENER_H 11 12 #include "lldb/Utility/Broadcaster.h" 13 #include "lldb/Utility/Timeout.h" 14 #include "lldb/lldb-defines.h" 15 #include "lldb/lldb-forward.h" 16 17 #include <condition_variable> 18 #include <list> 19 #include <map> 20 #include <memory> 21 #include <mutex> 22 #include <ratio> 23 #include <string> 24 #include <vector> 25 26 #include <cstddef> 27 #include <cstdint> 28 29 namespace lldb_private { 30 class Event; 31 } 32 33 namespace lldb_private { 34 35 class Listener : public std::enable_shared_from_this<Listener> { 36 public: 37 typedef bool (*HandleBroadcastCallback)(lldb::EventSP &event_sp, void *baton); 38 39 friend class Broadcaster; 40 friend class BroadcasterManager; 41 42 // Constructors and Destructors 43 // 44 // Listeners have to be constructed into shared pointers - at least if you 45 // want them to listen to Broadcasters, 46 protected: 47 Listener(const char *name); 48 49 public: 50 static lldb::ListenerSP MakeListener(const char *name); 51 52 ~Listener(); 53 54 void AddEvent(lldb::EventSP &event); 55 56 void Clear(); 57 GetName()58 const char *GetName() { return m_name.c_str(); } 59 60 uint32_t 61 StartListeningForEventSpec(const lldb::BroadcasterManagerSP &manager_sp, 62 const BroadcastEventSpec &event_spec); 63 64 bool StopListeningForEventSpec(const lldb::BroadcasterManagerSP &manager_sp, 65 const BroadcastEventSpec &event_spec); 66 67 uint32_t StartListeningForEvents(Broadcaster *broadcaster, 68 uint32_t event_mask); 69 70 uint32_t StartListeningForEvents(Broadcaster *broadcaster, 71 uint32_t event_mask, 72 HandleBroadcastCallback callback, 73 void *callback_user_data); 74 75 bool StopListeningForEvents(Broadcaster *broadcaster, uint32_t event_mask); 76 77 Event *PeekAtNextEvent(); 78 79 Event *PeekAtNextEventForBroadcaster(Broadcaster *broadcaster); 80 81 Event *PeekAtNextEventForBroadcasterWithType(Broadcaster *broadcaster, 82 uint32_t event_type_mask); 83 84 // Returns true if an event was received, false if we timed out. 85 bool GetEvent(lldb::EventSP &event_sp, const Timeout<std::micro> &timeout); 86 87 bool GetEventForBroadcaster(Broadcaster *broadcaster, lldb::EventSP &event_sp, 88 const Timeout<std::micro> &timeout); 89 90 bool GetEventForBroadcasterWithType(Broadcaster *broadcaster, 91 uint32_t event_type_mask, 92 lldb::EventSP &event_sp, 93 const Timeout<std::micro> &timeout); 94 95 size_t HandleBroadcastEvent(lldb::EventSP &event_sp); 96 97 private: 98 // Classes that inherit from Listener can see and modify these 99 struct BroadcasterInfo { 100 BroadcasterInfo(uint32_t mask, HandleBroadcastCallback cb = nullptr, 101 void *ud = nullptr) event_maskBroadcasterInfo102 : event_mask(mask), callback(cb), callback_user_data(ud) {} 103 104 uint32_t event_mask; 105 HandleBroadcastCallback callback; 106 void *callback_user_data; 107 }; 108 109 typedef std::multimap<Broadcaster::BroadcasterImplWP, BroadcasterInfo, 110 std::owner_less<Broadcaster::BroadcasterImplWP>> 111 broadcaster_collection; 112 typedef std::list<lldb::EventSP> event_collection; 113 typedef std::vector<lldb::BroadcasterManagerWP> 114 broadcaster_manager_collection; 115 116 bool 117 FindNextEventInternal(std::unique_lock<std::mutex> &lock, 118 Broadcaster *broadcaster, // nullptr for any broadcaster 119 uint32_t event_type_mask, lldb::EventSP &event_sp, 120 bool remove); 121 122 bool GetEventInternal(const Timeout<std::micro> &timeout, 123 Broadcaster *broadcaster, // nullptr for any broadcaster 124 uint32_t event_type_mask, lldb::EventSP &event_sp); 125 126 std::string m_name; 127 broadcaster_collection m_broadcasters; 128 std::mutex m_broadcasters_mutex; // Protects m_broadcasters 129 event_collection m_events; 130 std::mutex m_events_mutex; // Protects m_broadcasters and m_events 131 std::condition_variable m_events_condition; 132 broadcaster_manager_collection m_broadcaster_managers; 133 134 void BroadcasterWillDestruct(Broadcaster *); 135 136 void BroadcasterManagerWillDestruct(lldb::BroadcasterManagerSP manager_sp); 137 138 // broadcaster_collection::iterator 139 // FindBroadcasterWithMask (Broadcaster *broadcaster, 140 // uint32_t event_mask, 141 // bool exact); 142 143 // For Listener only 144 Listener(const Listener &) = delete; 145 const Listener &operator=(const Listener &) = delete; 146 }; 147 148 } // namespace lldb_private 149 150 #endif // LLDB_UTILITY_LISTENER_H 151