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 "lldb/Utility/Broadcaster.h"
10 #include "lldb/Utility/Log.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 
21 SBBroadcaster::SBBroadcaster(const char *name)
22     : m_opaque_sp(new Broadcaster(NULL, name)), m_opaque_ptr(NULL) {
23   m_opaque_ptr = m_opaque_sp.get();
24   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
25   LLDB_LOGV(log, "(name=\"{0}\") => SBBroadcaster({1})", name, m_opaque_ptr);
26 }
27 
28 SBBroadcaster::SBBroadcaster(lldb_private::Broadcaster *broadcaster, bool owns)
29     : m_opaque_sp(owns ? broadcaster : NULL), m_opaque_ptr(broadcaster) {
30   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
31   LLDB_LOGV(log, "(broadcaster={0}, owns={1}) => SBBroadcaster({2})",
32             broadcaster, owns, m_opaque_ptr);
33 }
34 
35 SBBroadcaster::SBBroadcaster(const SBBroadcaster &rhs)
36     : m_opaque_sp(rhs.m_opaque_sp), m_opaque_ptr(rhs.m_opaque_ptr) {}
37 
38 const SBBroadcaster &SBBroadcaster::operator=(const SBBroadcaster &rhs) {
39   if (this != &rhs) {
40     m_opaque_sp = rhs.m_opaque_sp;
41     m_opaque_ptr = rhs.m_opaque_ptr;
42   }
43   return *this;
44 }
45 
46 SBBroadcaster::~SBBroadcaster() { reset(NULL, false); }
47 
48 void SBBroadcaster::BroadcastEventByType(uint32_t event_type, bool unique) {
49   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
50 
51   if (log)
52     log->Printf("SBBroadcaster(%p)::BroadcastEventByType (event_type=0x%8.8x, "
53                 "unique=%i)",
54                 static_cast<void *>(m_opaque_ptr), event_type, unique);
55 
56   if (m_opaque_ptr == NULL)
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   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
67 
68   if (log)
69     log->Printf(
70         "SBBroadcaster(%p)::BroadcastEventByType (SBEvent(%p), unique=%i)",
71         static_cast<void *>(m_opaque_ptr), static_cast<void *>(event.get()),
72         unique);
73 
74   if (m_opaque_ptr == NULL)
75     return;
76 
77   EventSP event_sp = event.GetSP();
78   if (unique)
79     m_opaque_ptr->BroadcastEventIfUnique(event_sp);
80   else
81     m_opaque_ptr->BroadcastEvent(event_sp);
82 }
83 
84 void SBBroadcaster::AddInitialEventsToListener(const SBListener &listener,
85                                                uint32_t requested_events) {
86   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
87   if (log)
88     log->Printf("SBBroadcaster(%p)::AddInitialEventsToListener "
89                 "(SBListener(%p), event_mask=0x%8.8x)",
90                 static_cast<void *>(m_opaque_ptr),
91                 static_cast<void *>(listener.get()), requested_events);
92   if (m_opaque_ptr)
93     m_opaque_ptr->AddInitialEventsToListener(listener.m_opaque_sp,
94                                              requested_events);
95 }
96 
97 uint32_t SBBroadcaster::AddListener(const SBListener &listener,
98                                     uint32_t event_mask) {
99   if (m_opaque_ptr)
100     return m_opaque_ptr->AddListener(listener.m_opaque_sp, event_mask);
101   return 0;
102 }
103 
104 const char *SBBroadcaster::GetName() const {
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   if (m_opaque_ptr)
112     return m_opaque_ptr->EventTypeHasListeners(event_type);
113   return false;
114 }
115 
116 bool SBBroadcaster::RemoveListener(const SBListener &listener,
117                                    uint32_t event_mask) {
118   if (m_opaque_ptr)
119     return m_opaque_ptr->RemoveListener(listener.m_opaque_sp, event_mask);
120   return false;
121 }
122 
123 Broadcaster *SBBroadcaster::get() const { return m_opaque_ptr; }
124 
125 void SBBroadcaster::reset(Broadcaster *broadcaster, bool owns) {
126   if (owns)
127     m_opaque_sp.reset(broadcaster);
128   else
129     m_opaque_sp.reset();
130   m_opaque_ptr = broadcaster;
131 }
132 
133 bool SBBroadcaster::IsValid() const { return m_opaque_ptr != NULL; }
134 
135 void SBBroadcaster::Clear() {
136   m_opaque_sp.reset();
137   m_opaque_ptr = NULL;
138 }
139 
140 bool SBBroadcaster::operator==(const SBBroadcaster &rhs) const {
141   return m_opaque_ptr == rhs.m_opaque_ptr;
142 }
143 
144 bool SBBroadcaster::operator!=(const SBBroadcaster &rhs) const {
145   return m_opaque_ptr != rhs.m_opaque_ptr;
146 }
147 
148 bool SBBroadcaster::operator<(const SBBroadcaster &rhs) const {
149   return m_opaque_ptr < rhs.m_opaque_ptr;
150 }
151