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