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 <string>
  18 #include <vector>
  19
  20 // Other libraries and framework includes
  21 // Project includes
  22 #include "lldb/lldb-private.h"
  23 #include "lldb/Host/Predicate.h"
  24 #include "lldb/Core/Event.h"
  25
  26 namespace lldb_private {
  27
  28 class Listener
  29 {
  30 public:
  31     typedef bool (*HandleBroadcastCallback) (lldb::EventSP &event_sp, void *baton);
  32
  33     friend class Broadcaster;
  34     friend class BroadcasterManager;
  35
  36     //------------------------------------------------------------------
  37     // Constructors and Destructors
  38     //------------------------------------------------------------------
  39     Listener (const char *name);
  40
  41     ~Listener ();
  42
  43     void
  44     AddEvent (lldb::EventSP &event);
  45
  46     void
  47     Clear ();
  48
  49     const char *
  50     GetName ()
  51     {
  52         return m_name.c_str();
  53     }
  54
  55     uint32_t
  56     StartListeningForEventSpec (BroadcasterManager &manager,
  57                                  const BroadcastEventSpec &event_spec);
  58
  59     bool
  60     StopListeningForEventSpec (BroadcasterManager &manager,
  61                                  const BroadcastEventSpec &event_spec);
  62
  63     uint32_t
  64     StartListeningForEvents (Broadcaster* broadcaster,
  65                              uint32_t event_mask);
  66
  67     uint32_t
  68     StartListeningForEvents (Broadcaster* broadcaster,
  69                              uint32_t event_mask,
  70                              HandleBroadcastCallback callback,
  71                              void *callback_user_data);
  72
  73     bool
  74     StopListeningForEvents (Broadcaster* broadcaster,
  75                             uint32_t event_mask);
  76
  77     // Returns true if an event was received, false if we timed out.
  78     bool
  79     WaitForEvent (const TimeValue *timeout,
  80                   lldb::EventSP &event_sp);
  81
  82     bool
  83     WaitForEventForBroadcaster (const TimeValue *timeout,
  84                                 Broadcaster *broadcaster,
  85                                 lldb::EventSP &event_sp);
  86
  87     bool
  88     WaitForEventForBroadcasterWithType (const TimeValue *timeout,
  89                                         Broadcaster *broadcaster,
  90                                         uint32_t event_type_mask,
  91                                         lldb::EventSP &event_sp);
  92
  93     Event *
  94     PeekAtNextEvent ();
  95
  96     Event *
  97     PeekAtNextEventForBroadcaster (Broadcaster *broadcaster);
  98
  99     Event *
 100     PeekAtNextEventForBroadcasterWithType (Broadcaster *broadcaster,
 101                                            uint32_t event_type_mask);
 102
 103     bool
 104     GetNextEvent (lldb::EventSP &event_sp);
 105
 106     bool
 107     GetNextEventForBroadcaster (Broadcaster *broadcaster,
 108                                 lldb::EventSP &event_sp);
 109
 110     bool
 111     GetNextEventForBroadcasterWithType (Broadcaster *broadcaster,
 112                                         uint32_t event_type_mask,
 113                                         lldb::EventSP &event_sp);
 114
 115     size_t
 116     HandleBroadcastEvent (lldb::EventSP &event_sp);
 117
 118 private:
 119     //------------------------------------------------------------------
 120     // Classes that inherit from Listener can see and modify these
 121     //------------------------------------------------------------------
 122     struct BroadcasterInfo
 123     {
 124         BroadcasterInfo(uint32_t mask, HandleBroadcastCallback cb = nullptr, void *ud = nullptr) :
 125             event_mask (mask),
 126             callback (cb),
 127             callback_user_data (ud)
 128         {
 129         }
 130
 131         uint32_t event_mask;
 132         HandleBroadcastCallback callback;
 133         void *callback_user_data;
 134     };
 135
 136     typedef std::multimap<Broadcaster*, BroadcasterInfo> broadcaster_collection;
 137     typedef std::list<lldb::EventSP> event_collection;
 138     typedef std::vector<BroadcasterManager *> broadcaster_manager_collection;
 139
 140     bool
 141     FindNextEventInternal(Broadcaster *broadcaster,   // nullptr for any broadcaster
 142                           const ConstString *sources, // nullptr for any event
 143                           uint32_t num_sources,
 144                           uint32_t event_type_mask,
 145                           lldb::EventSP &event_sp,
 146                           bool remove);
 147
 148     bool
 149     GetNextEventInternal(Broadcaster *broadcaster,   // nullptr for any broadcaster
 150                          const ConstString *sources, // nullptr for any event
 151                          uint32_t num_sources,
 152                          uint32_t event_type_mask,
 153                          lldb::EventSP &event_sp);
 154
 155     bool
 156     WaitForEventsInternal(const TimeValue *timeout,
 157                           Broadcaster *broadcaster,   // nullptr for any broadcaster
 158                           const ConstString *sources, // nullptr for any event
 159                           uint32_t num_sources,
 160                           uint32_t event_type_mask,
 161                           lldb::EventSP &event_sp);
 162
 163     std::string m_name;
 164     broadcaster_collection m_broadcasters;
 165     Mutex m_broadcasters_mutex; // Protects m_broadcasters
 166     event_collection m_events;
 167     Mutex m_events_mutex; // Protects m_broadcasters and m_events
 168     Predicate<bool> m_cond_wait;
 169     broadcaster_manager_collection m_broadcaster_managers;
 170
 171     void
 172     BroadcasterWillDestruct (Broadcaster *);
 173
 174     void
 175     BroadcasterManagerWillDestruct (BroadcasterManager *manager);
 176
 177
 178 //    broadcaster_collection::iterator
 179 //    FindBroadcasterWithMask (Broadcaster *broadcaster,
 180 //                             uint32_t event_mask,
 181 //                             bool exact);
 182
 183     //------------------------------------------------------------------
 184     // For Listener only
 185     //------------------------------------------------------------------
 186     DISALLOW_COPY_AND_ASSIGN (Listener);
 187 };
 188
 189 } // namespace lldb_private
 190
 191 #endif // liblldb_Select_h_