contrib/llvm/tools/lldb/include/lldb/Core/Listener.h

   1 //===-- Listener.h ----------------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef liblldb_Select_h_
  11 #define liblldb_Select_h_
  12
  13 // C Includes
  14 // C++ Includes
  15 #include <list>
  16 #include <map>
  17 #include <mutex>
  18 #include <string>
  19 #include <vector>
  20
  21 // Other libraries and framework includes
  22 // Project includes
  23 #include "lldb/lldb-private.h"
  24 #include "lldb/Core/Broadcaster.h"
  25 #include "lldb/Host/Condition.h"
  26 #include "lldb/Core/Event.h"
  27
  28 namespace lldb_private {
  29
  30 class Listener :
  31     public std::enable_shared_from_this<Listener>
  32 {
  33 public:
  34     typedef bool (*HandleBroadcastCallback) (lldb::EventSP &event_sp, void *baton);
  35
  36     friend class Broadcaster;
  37     friend class BroadcasterManager;
  38
  39     //------------------------------------------------------------------
  40     // Constructors and Destructors
  41     //------------------------------------------------------------------
  42     //
  43     // Listeners have to be constructed into shared pointers - at least if you want them to listen to
  44     // Broadcasters,
  45 protected:
  46     Listener (const char *name);
  47
  48 public:
  49     static lldb::ListenerSP
  50     MakeListener(const char *name);
  51
  52     ~Listener ();
  53
  54     void
  55     AddEvent (lldb::EventSP &event);
  56
  57     void
  58     Clear ();
  59
  60     const char *
  61     GetName ()
  62     {
  63         return m_name.c_str();
  64     }
  65
  66     uint32_t
  67     StartListeningForEventSpec (lldb::BroadcasterManagerSP manager_sp,
  68                                  const BroadcastEventSpec &event_spec);
  69
  70     bool
  71     StopListeningForEventSpec (lldb::BroadcasterManagerSP manager_sp,
  72                                  const BroadcastEventSpec &event_spec);
  73
  74     uint32_t
  75     StartListeningForEvents (Broadcaster* broadcaster,
  76                              uint32_t event_mask);
  77
  78     uint32_t
  79     StartListeningForEvents (Broadcaster* broadcaster,
  80                              uint32_t event_mask,
  81                              HandleBroadcastCallback callback,
  82                              void *callback_user_data);
  83
  84     bool
  85     StopListeningForEvents (Broadcaster* broadcaster,
  86                             uint32_t event_mask);
  87
  88     // Returns true if an event was received, false if we timed out.
  89     bool
  90     WaitForEvent (const TimeValue *timeout,
  91                   lldb::EventSP &event_sp);
  92
  93     bool
  94     WaitForEventForBroadcaster (const TimeValue *timeout,
  95                                 Broadcaster *broadcaster,
  96                                 lldb::EventSP &event_sp);
  97
  98     bool
  99     WaitForEventForBroadcasterWithType (const TimeValue *timeout,
 100                                         Broadcaster *broadcaster,
 101                                         uint32_t event_type_mask,
 102                                         lldb::EventSP &event_sp);
 103
 104     Event *
 105     PeekAtNextEvent ();
 106
 107     Event *
 108     PeekAtNextEventForBroadcaster (Broadcaster *broadcaster);
 109
 110     Event *
 111     PeekAtNextEventForBroadcasterWithType (Broadcaster *broadcaster,
 112                                            uint32_t event_type_mask);
 113
 114     bool
 115     GetNextEvent (lldb::EventSP &event_sp);
 116
 117     bool
 118     GetNextEventForBroadcaster (Broadcaster *broadcaster,
 119                                 lldb::EventSP &event_sp);
 120
 121     bool
 122     GetNextEventForBroadcasterWithType (Broadcaster *broadcaster,
 123                                         uint32_t event_type_mask,
 124                                         lldb::EventSP &event_sp);
 125
 126     size_t
 127     HandleBroadcastEvent (lldb::EventSP &event_sp);
 128
 129 private:
 130     //------------------------------------------------------------------
 131     // Classes that inherit from Listener can see and modify these
 132     //------------------------------------------------------------------
 133     struct BroadcasterInfo
 134     {
 135         BroadcasterInfo(uint32_t mask, HandleBroadcastCallback cb = nullptr, void *ud = nullptr) :
 136             event_mask (mask),
 137             callback (cb),
 138             callback_user_data (ud)
 139         {
 140         }
 141
 142         uint32_t event_mask;
 143         HandleBroadcastCallback callback;
 144         void *callback_user_data;
 145     };
 146
 147     typedef std::multimap<Broadcaster::BroadcasterImplWP,
 148                           BroadcasterInfo,
 149                           std::owner_less<Broadcaster::BroadcasterImplWP>> broadcaster_collection;
 150     typedef std::list<lldb::EventSP> event_collection;
 151     typedef std::vector<lldb::BroadcasterManagerWP> broadcaster_manager_collection;
 152
 153     bool
 154     FindNextEventInternal(Mutex::Locker& lock,
 155                           Broadcaster *broadcaster,   // nullptr for any broadcaster
 156                           const ConstString *sources, // nullptr for any event
 157                           uint32_t num_sources,
 158                           uint32_t event_type_mask,
 159                           lldb::EventSP &event_sp,
 160                           bool remove);
 161
 162     bool
 163     GetNextEventInternal(Broadcaster *broadcaster,   // nullptr for any broadcaster
 164                          const ConstString *sources, // nullptr for any event
 165                          uint32_t num_sources,
 166                          uint32_t event_type_mask,
 167                          lldb::EventSP &event_sp);
 168
 169     bool
 170     WaitForEventsInternal(const TimeValue *timeout,
 171                           Broadcaster *broadcaster,   // nullptr for any broadcaster
 172                           const ConstString *sources, // nullptr for any event
 173                           uint32_t num_sources,
 174                           uint32_t event_type_mask,
 175                           lldb::EventSP &event_sp);
 176
 177     std::string m_name;
 178     broadcaster_collection m_broadcasters;
 179     std::recursive_mutex m_broadcasters_mutex; // Protects m_broadcasters
 180     event_collection m_events;
 181     Mutex m_events_mutex; // Protects m_broadcasters and m_events
 182     Condition m_events_condition;
 183     broadcaster_manager_collection m_broadcaster_managers;
 184
 185     void
 186     BroadcasterWillDestruct (Broadcaster *);
 187
 188     void
 189     BroadcasterManagerWillDestruct (lldb::BroadcasterManagerSP manager_sp);
 190
 191
 192 //    broadcaster_collection::iterator
 193 //    FindBroadcasterWithMask (Broadcaster *broadcaster,
 194 //                             uint32_t event_mask,
 195 //                             bool exact);
 196
 197     //------------------------------------------------------------------
 198     // For Listener only
 199     //------------------------------------------------------------------
 200     DISALLOW_COPY_AND_ASSIGN (Listener);
 201 };
 202
 203 } // namespace lldb_private
 204
 205 #endif // liblldb_Select_h_