source/API/SBBroadcaster.cpp

   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 }