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 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 void SetShadow(bool is_shadow) { m_is_shadow = is_shadow; } 98 99 private: 100 // Classes that inherit from Listener can see and modify these 101 struct BroadcasterInfo { 102 BroadcasterInfo(uint32_t mask, HandleBroadcastCallback cb = nullptr, 103 void *ud = nullptr) 104 : event_mask(mask), callback(cb), callback_user_data(ud) {} 105 106 uint32_t event_mask; 107 HandleBroadcastCallback callback; 108 void *callback_user_data; 109 }; 110 111 typedef std::multimap<Broadcaster::BroadcasterImplWP, BroadcasterInfo, 112 std::owner_less<Broadcaster::BroadcasterImplWP>> 113 broadcaster_collection; 114 typedef std::list<lldb::EventSP> event_collection; 115 typedef std::vector<lldb::BroadcasterManagerWP> 116 broadcaster_manager_collection; 117 118 bool 119 FindNextEventInternal(std::unique_lock<std::mutex> &lock, 120 Broadcaster *broadcaster, // nullptr for any broadcaster 121 uint32_t event_type_mask, lldb::EventSP &event_sp, 122 bool remove); 123 124 bool GetEventInternal(const Timeout<std::micro> &timeout, 125 Broadcaster *broadcaster, // nullptr for any broadcaster 126 uint32_t event_type_mask, lldb::EventSP &event_sp); 127 128 std::string m_name; 129 broadcaster_collection m_broadcasters; 130 std::recursive_mutex m_broadcasters_mutex; // Protects m_broadcasters 131 event_collection m_events; 132 std::mutex m_events_mutex; // Protects m_broadcasters and m_events 133 std::condition_variable m_events_condition; 134 broadcaster_manager_collection m_broadcaster_managers; 135 bool m_is_shadow = false; 136 137 void BroadcasterWillDestruct(Broadcaster *); 138 139 void BroadcasterManagerWillDestruct(lldb::BroadcasterManagerSP manager_sp); 140 141 // broadcaster_collection::iterator 142 // FindBroadcasterWithMask (Broadcaster *broadcaster, 143 // uint32_t event_mask, 144 // bool exact); 145 146 // For Listener only 147 Listener(const Listener &) = delete; 148 const Listener &operator=(const Listener &) = delete; 149 }; 150 151 } // namespace lldb_private 152 153 #endif // LLDB_UTILITY_LISTENER_H 154