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