contrib/llvm/tools/lldb/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/Utility/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 }