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