1 //===-- SBBroadcaster.cpp ---------------------------------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "lldb/Core/Broadcaster.h"
11 #include "lldb/Core/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 
22 SBBroadcaster::SBBroadcaster(const char *name)
23     : m_opaque_sp(new Broadcaster(NULL, name)), m_opaque_ptr(NULL) {
24   m_opaque_ptr = m_opaque_sp.get();
25   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API |
26                                                   LIBLLDB_LOG_VERBOSE));
27 
28   if (log)
29     log->Printf(
30         "SBBroadcaster::SBBroadcaster (name=\"%s\") => SBBroadcaster(%p)", name,
31         static_cast<void *>(m_opaque_ptr));
32 }
33 
34 SBBroadcaster::SBBroadcaster(lldb_private::Broadcaster *broadcaster, bool owns)
35     : m_opaque_sp(owns ? broadcaster : NULL), m_opaque_ptr(broadcaster) {
36   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API |
37                                                   LIBLLDB_LOG_VERBOSE));
38 
39   if (log)
40     log->Printf("SBBroadcaster::SBBroadcaster (broadcaster=%p, bool owns=%i) "
41                 "=> SBBroadcaster(%p)",
42                 static_cast<void *>(broadcaster), owns,
43                 static_cast<void *>(m_opaque_ptr));
44 }
45 
46 SBBroadcaster::SBBroadcaster(const SBBroadcaster &rhs)
47     : m_opaque_sp(rhs.m_opaque_sp), m_opaque_ptr(rhs.m_opaque_ptr) {}
48 
49 const SBBroadcaster &SBBroadcaster::operator=(const SBBroadcaster &rhs) {
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   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
61 
62   if (log)
63     log->Printf("SBBroadcaster(%p)::BroadcastEventByType (event_type=0x%8.8x, "
64                 "unique=%i)",
65                 static_cast<void *>(m_opaque_ptr), event_type, unique);
66 
67   if (m_opaque_ptr == NULL)
68     return;
69 
70   if (unique)
71     m_opaque_ptr->BroadcastEventIfUnique(event_type);
72   else
73     m_opaque_ptr->BroadcastEvent(event_type);
74 }
75 
76 void SBBroadcaster::BroadcastEvent(const SBEvent &event, bool unique) {
77   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
78 
79   if (log)
80     log->Printf(
81         "SBBroadcaster(%p)::BroadcastEventByType (SBEvent(%p), unique=%i)",
82         static_cast<void *>(m_opaque_ptr), static_cast<void *>(event.get()),
83         unique);
84 
85   if (m_opaque_ptr == NULL)
86     return;
87 
88   EventSP event_sp = event.GetSP();
89   if (unique)
90     m_opaque_ptr->BroadcastEventIfUnique(event_sp);
91   else
92     m_opaque_ptr->BroadcastEvent(event_sp);
93 }
94 
95 void SBBroadcaster::AddInitialEventsToListener(const SBListener &listener,
96                                                uint32_t requested_events) {
97   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
98   if (log)
99     log->Printf("SBBroadcaster(%p)::AddInitialEventsToListener "
100                 "(SBListener(%p), event_mask=0x%8.8x)",
101                 static_cast<void *>(m_opaque_ptr),
102                 static_cast<void *>(listener.get()), requested_events);
103   if (m_opaque_ptr)
104     m_opaque_ptr->AddInitialEventsToListener(listener.m_opaque_sp,
105                                              requested_events);
106 }
107 
108 uint32_t SBBroadcaster::AddListener(const SBListener &listener,
109                                     uint32_t event_mask) {
110   if (m_opaque_ptr)
111     return m_opaque_ptr->AddListener(listener.m_opaque_sp, event_mask);
112   return 0;
113 }
114 
115 const char *SBBroadcaster::GetName() const {
116   if (m_opaque_ptr)
117     return m_opaque_ptr->GetBroadcasterName().GetCString();
118   return NULL;
119 }
120 
121 bool SBBroadcaster::EventTypeHasListeners(uint32_t event_type) {
122   if (m_opaque_ptr)
123     return m_opaque_ptr->EventTypeHasListeners(event_type);
124   return false;
125 }
126 
127 bool SBBroadcaster::RemoveListener(const SBListener &listener,
128                                    uint32_t event_mask) {
129   if (m_opaque_ptr)
130     return m_opaque_ptr->RemoveListener(listener.m_opaque_sp, event_mask);
131   return false;
132 }
133 
134 Broadcaster *SBBroadcaster::get() const { return m_opaque_ptr; }
135 
136 void SBBroadcaster::reset(Broadcaster *broadcaster, bool owns) {
137   if (owns)
138     m_opaque_sp.reset(broadcaster);
139   else
140     m_opaque_sp.reset();
141   m_opaque_ptr = broadcaster;
142 }
143 
144 bool SBBroadcaster::IsValid() const { return m_opaque_ptr != NULL; }
145 
146 void SBBroadcaster::Clear() {
147   m_opaque_sp.reset();
148   m_opaque_ptr = NULL;
149 }
150 
151 bool SBBroadcaster::operator==(const SBBroadcaster &rhs) const {
152   return m_opaque_ptr == rhs.m_opaque_ptr;
153 }
154 
155 bool SBBroadcaster::operator!=(const SBBroadcaster &rhs) const {
156   return m_opaque_ptr != rhs.m_opaque_ptr;
157 }
158 
159 bool SBBroadcaster::operator<(const SBBroadcaster &rhs) const {
160   return m_opaque_ptr < rhs.m_opaque_ptr;
161 }
162