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