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