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