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
16using namespace lldb;
17using namespace lldb_private;
18
19SBBroadcaster::SBBroadcaster() : m_opaque_sp(), m_opaque_ptr(nullptr) {
20  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBroadcaster);
21}
22
23SBBroadcaster::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
30SBBroadcaster::SBBroadcaster(lldb_private::Broadcaster *broadcaster, bool owns)
31    : m_opaque_sp(owns ? broadcaster : nullptr), m_opaque_ptr(broadcaster) {}
32
33SBBroadcaster::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
38const 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
50SBBroadcaster::~SBBroadcaster() { reset(nullptr, false); }
51
52void 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
65void 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
79void 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
90uint32_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
101const 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
109bool 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
118bool 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
129Broadcaster *SBBroadcaster::get() const { return m_opaque_ptr; }
130
131void 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
139bool SBBroadcaster::IsValid() const {
140  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBroadcaster, IsValid);
141  return this->operator bool();
142}
143SBBroadcaster::operator bool() const {
144  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBroadcaster, operator bool);
145
146  return m_opaque_ptr != nullptr;
147}
148
149void SBBroadcaster::Clear() {
150  LLDB_RECORD_METHOD_NO_ARGS(void, SBBroadcaster, Clear);
151
152  m_opaque_sp.reset();
153  m_opaque_ptr = nullptr;
154}
155
156bool 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
163bool 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
170bool 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
177namespace lldb_private {
178namespace repro {
179
180template <>
181void 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