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