1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
|
//===-- Broadcaster.h -------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_Broadcaster_h_
#define liblldb_Broadcaster_h_
// C Includes
// C++ Includes
#include <string>
#include <vector>
// Other libraries and framework includes
// Project includes
#include "lldb/lldb-private.h"
//#include "lldb/Core/Flags.h"
#include "lldb/Core/Listener.h"
namespace lldb_private {
//----------------------------------------------------------------------
/// @class Broadcaster Broadcaster.h "lldb/Core/Broadcaster.h"
/// @brief An event broadcasting class.
///
/// The Broadcaster class is designed to be subclassed by objects that
/// wish to vend events in a multi-threaded environment. Broadcaster
/// objects can each vend 32 events. Each event is represented by a bit
/// in a 32 bit value and these bits can be set:
/// @see Broadcaster::SetEventBits(uint32_t)
/// or cleared:
/// @see Broadcaster::ResetEventBits(uint32_t)
/// When an event gets set the Broadcaster object will notify the
/// Listener object that is listening for the event (if there is one).
///
/// Subclasses should provide broadcast bit definitions for any events
/// they vend, typically using an enumeration:
/// \code
/// class Foo : public Broadcaster
/// {
/// public:
/// //----------------------------------------------------------
/// // Broadcaster event bits definitions.
/// //----------------------------------------------------------
/// enum
/// {
/// eBroadcastBitStateChanged = (1 << 0),
/// eBroadcastBitInterrupt = (1 << 1),
/// eBroadcastBitSTDOUT = (1 << 2),
/// eBroadcastBitSTDERR = (1 << 3)
/// };
/// \endcode
//----------------------------------------------------------------------
class Broadcaster
{
public:
//------------------------------------------------------------------
/// Construct with a broadcaster with a name.
///
/// @param[in] name
/// A NULL terminated C string that contains the name of the
/// broadcaster object.
//------------------------------------------------------------------
Broadcaster (const char *name);
//------------------------------------------------------------------
/// Destructor.
///
/// The destructor is virtual since this class gets subclassed.
//------------------------------------------------------------------
virtual
~Broadcaster();
//------------------------------------------------------------------
/// Broadcast an event which has no associated data.
///
/// @param[in] event_type
/// The element from the enum defining this broadcaster's events
/// that is being broadcast.
///
/// @param[in] event_data
/// User event data that will be owned by the lldb::Event that
/// is created internally.
///
/// @param[in] unique
/// If true, then only add an event of this type if there isn't
/// one already in the queue.
///
//------------------------------------------------------------------
void
BroadcastEvent (lldb::EventSP &event_sp);
void
BroadcastEventIfUnique (lldb::EventSP &event_sp);
void
BroadcastEvent (uint32_t event_type, EventData *event_data = NULL);
void
BroadcastEventIfUnique (uint32_t event_type, EventData *event_data = NULL);
virtual void
AddInitialEventsToListener (Listener *listener, uint32_t requested_events);
//------------------------------------------------------------------
/// Listen for any events specified by \a event_mask.
///
/// Only one listener can listen to each event bit in a given
/// Broadcaster. Once a listener has acquired an event bit, no
/// other broadcaster will have access to it until it is
/// relinquished by the first listener that gets it. The actual
/// event bits that get acquired by \a listener may be different
/// from what is requested in \a event_mask, and to track this the
/// actual event bits that are acquired get returned.
///
/// @param[in] listener
/// The Listener object that wants to monitor the events that
/// get broadcast by this object.
///
/// @param[in] event_mask
/// A bit mask that indicates which events the listener is
/// asking to monitor.
///
/// @return
/// The actual event bits that were acquired by \a listener.
//------------------------------------------------------------------
uint32_t
AddListener (Listener* listener, uint32_t event_mask);
//------------------------------------------------------------------
/// Get the NULL terminated C string name of this Broadcaster
/// object.
///
/// @return
/// The NULL terminated C string name of this Broadcaster.
//------------------------------------------------------------------
const ConstString &
GetBroadcasterName ();
bool
EventTypeHasListeners (uint32_t event_type);
//------------------------------------------------------------------
/// Removes a Listener from this broadcasters list and frees the
/// event bits specified by \a event_mask that were previously
/// acquired by \a listener (assuming \a listener was listening to
/// this object) for other listener objects to use.
///
/// @param[in] listener
/// A Listener object that previously called AddListener.
///
/// @param[in] event_mask
/// The event bits \a listener wishes to relinquish.
///
/// @return
/// \b True if the listener was listening to this broadcaster
/// and was removed, \b false otherwise.
///
/// @see uint32_t Broadcaster::AddListener (Listener*, uint32_t)
//------------------------------------------------------------------
bool
RemoveListener (Listener* listener, uint32_t event_mask = UINT32_MAX);
protected:
void
PrivateBroadcastEvent (lldb::EventSP &event_sp, bool unique);
//------------------------------------------------------------------
// Classes that inherit from Broadcaster can see and modify these
//------------------------------------------------------------------
typedef std::vector< std::pair<Listener*,uint32_t> > collection;
// Prefix the name of our member variables with "m_broadcaster_"
// since this is a class that gets subclassed.
const ConstString m_broadcaster_name; ///< The name of this broadcaster object.
collection m_broadcaster_listeners; ///< A list of Listener / event_mask pairs that are listening to this broadcaster.
Mutex m_broadcaster_listeners_mutex; ///< A mutex that protects \a m_broadcaster_listeners.
private:
//------------------------------------------------------------------
// For Broadcaster only
//------------------------------------------------------------------
DISALLOW_COPY_AND_ASSIGN (Broadcaster);
};
} // namespace lldb_private
#endif // liblldb_Broadcaster_h_
|
