1 //===-- SBBroadcaster.cpp ---------------------------------------*- 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 #include "lldb/Core/Broadcaster.h"
11 #include "lldb/Core/Log.h"
12
13 #include "lldb/API/SBBroadcaster.h"
14 #include "lldb/API/SBListener.h"
15 #include "lldb/API/SBEvent.h"
16
17 using namespace lldb;
18 using namespace lldb_private;
19
20
SBBroadcaster()21 SBBroadcaster::SBBroadcaster () :
22 m_opaque_sp (),
23 m_opaque_ptr (NULL)
24 {
25 }
26
SBBroadcaster(const char * name)27 SBBroadcaster::SBBroadcaster (const char *name) :
28 m_opaque_sp (new Broadcaster (NULL, name)),
29 m_opaque_ptr (NULL)
30 {
31 m_opaque_ptr = m_opaque_sp.get();
32 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API | LIBLLDB_LOG_VERBOSE));
33
34 if (log)
35 log->Printf ("SBBroadcaster::SBBroadcaster (name=\"%s\") => SBBroadcaster(%p)",
36 name, static_cast<void*>(m_opaque_ptr));
37 }
38
SBBroadcaster(lldb_private::Broadcaster * broadcaster,bool owns)39 SBBroadcaster::SBBroadcaster (lldb_private::Broadcaster *broadcaster, bool owns) :
40 m_opaque_sp (owns ? broadcaster : NULL),
41 m_opaque_ptr (broadcaster)
42 {
43 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API | LIBLLDB_LOG_VERBOSE));
44
45 if (log)
46 log->Printf ("SBBroadcaster::SBBroadcaster (broadcaster=%p, bool owns=%i) => SBBroadcaster(%p)",
47 static_cast<void*>(broadcaster), owns,
48 static_cast<void*>(m_opaque_ptr));
49 }
50
SBBroadcaster(const SBBroadcaster & rhs)51 SBBroadcaster::SBBroadcaster (const SBBroadcaster &rhs) :
52 m_opaque_sp (rhs.m_opaque_sp),
53 m_opaque_ptr (rhs.m_opaque_ptr)
54 {
55 }
56
57 const SBBroadcaster &
operator =(const SBBroadcaster & rhs)58 SBBroadcaster::operator = (const SBBroadcaster &rhs)
59 {
60 if (this != &rhs)
61 {
62 m_opaque_sp = rhs.m_opaque_sp;
63 m_opaque_ptr = rhs.m_opaque_ptr;
64 }
65 return *this;
66 }
67
~SBBroadcaster()68 SBBroadcaster::~SBBroadcaster()
69 {
70 reset (NULL, false);
71 }
72
73 void
BroadcastEventByType(uint32_t event_type,bool unique)74 SBBroadcaster::BroadcastEventByType (uint32_t event_type, bool unique)
75 {
76 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
77
78 if (log)
79 log->Printf ("SBBroadcaster(%p)::BroadcastEventByType (event_type=0x%8.8x, unique=%i)",
80 static_cast<void*>(m_opaque_ptr), event_type, unique);
81
82 if (m_opaque_ptr == NULL)
83 return;
84
85 if (unique)
86 m_opaque_ptr->BroadcastEventIfUnique (event_type);
87 else
88 m_opaque_ptr->BroadcastEvent (event_type);
89 }
90
91 void
BroadcastEvent(const SBEvent & event,bool unique)92 SBBroadcaster::BroadcastEvent (const SBEvent &event, bool unique)
93 {
94 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
95
96 if (log)
97 log->Printf ("SBBroadcaster(%p)::BroadcastEventByType (SBEvent(%p), unique=%i)",
98 static_cast<void*>(m_opaque_ptr),
99 static_cast<void*>(event.get()), unique);
100
101 if (m_opaque_ptr == NULL)
102 return;
103
104 EventSP event_sp = event.GetSP ();
105 if (unique)
106 m_opaque_ptr->BroadcastEventIfUnique (event_sp);
107 else
108 m_opaque_ptr->BroadcastEvent (event_sp);
109 }
110
111 void
AddInitialEventsToListener(const SBListener & listener,uint32_t requested_events)112 SBBroadcaster::AddInitialEventsToListener (const SBListener &listener, uint32_t requested_events)
113 {
114 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
115 if (log)
116 log->Printf ("SBBroadcaster(%p)::AddInitialEventsToListener (SBListener(%p), event_mask=0x%8.8x)",
117 static_cast<void*>(m_opaque_ptr),
118 static_cast<void*>(listener.get()), requested_events);
119 if (m_opaque_ptr)
120 m_opaque_ptr->AddInitialEventsToListener (listener.get(), requested_events);
121 }
122
123 uint32_t
AddListener(const SBListener & listener,uint32_t event_mask)124 SBBroadcaster::AddListener (const SBListener &listener, uint32_t event_mask)
125 {
126 if (m_opaque_ptr)
127 return m_opaque_ptr->AddListener (listener.get(), event_mask);
128 return 0;
129 }
130
131 const char *
GetName() const132 SBBroadcaster::GetName () const
133 {
134 if (m_opaque_ptr)
135 return m_opaque_ptr->GetBroadcasterName().GetCString();
136 return NULL;
137 }
138
139 bool
EventTypeHasListeners(uint32_t event_type)140 SBBroadcaster::EventTypeHasListeners (uint32_t event_type)
141 {
142 if (m_opaque_ptr)
143 return m_opaque_ptr->EventTypeHasListeners (event_type);
144 return false;
145 }
146
147 bool
RemoveListener(const SBListener & listener,uint32_t event_mask)148 SBBroadcaster::RemoveListener (const SBListener &listener, uint32_t event_mask)
149 {
150 if (m_opaque_ptr)
151 return m_opaque_ptr->RemoveListener (listener.get(), event_mask);
152 return false;
153 }
154
155 Broadcaster *
get() const156 SBBroadcaster::get () const
157 {
158 return m_opaque_ptr;
159 }
160
161 void
reset(Broadcaster * broadcaster,bool owns)162 SBBroadcaster::reset (Broadcaster *broadcaster, bool owns)
163 {
164 if (owns)
165 m_opaque_sp.reset (broadcaster);
166 else
167 m_opaque_sp.reset ();
168 m_opaque_ptr = broadcaster;
169 }
170
171
172 bool
IsValid() const173 SBBroadcaster::IsValid () const
174 {
175 return m_opaque_ptr != NULL;
176 }
177
178 void
Clear()179 SBBroadcaster::Clear ()
180 {
181 m_opaque_sp.reset();
182 m_opaque_ptr = NULL;
183 }
184
185 bool
operator ==(const SBBroadcaster & rhs) const186 SBBroadcaster::operator == (const SBBroadcaster &rhs) const
187 {
188 return m_opaque_ptr == rhs.m_opaque_ptr;
189
190 }
191
192 bool
operator !=(const SBBroadcaster & rhs) const193 SBBroadcaster::operator != (const SBBroadcaster &rhs) const
194 {
195 return m_opaque_ptr != rhs.m_opaque_ptr;
196 }
197
198 bool
operator <(const SBBroadcaster & rhs) const199 SBBroadcaster::operator < (const SBBroadcaster &rhs) const
200 {
201 return m_opaque_ptr < rhs.m_opaque_ptr;
202 }
203