lldb/source/API/SBBroadcaster.cpp

   1 //===-- SBBroadcaster.cpp ---------------------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "SBReproducerPrivate.h"
  10 #include "lldb/Utility/Broadcaster.h"
  11
  12 #include "lldb/API/SBBroadcaster.h"
  13 #include "lldb/API/SBEvent.h"
  14 #include "lldb/API/SBListener.h"
  15
  16 using namespace lldb;
  17 using namespace lldb_private;
  18
  19 SBBroadcaster::SBBroadcaster() : m_opaque_sp(), m_opaque_ptr(nullptr) {
  20   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBroadcaster);
  21 }
  22
  23 SBBroadcaster::SBBroadcaster(const char *name)
  24     : m_opaque_sp(new Broadcaster(nullptr, name)), m_opaque_ptr(nullptr) {
  25   LLDB_RECORD_CONSTRUCTOR(SBBroadcaster, (const char *), name);
  26
  27   m_opaque_ptr = m_opaque_sp.get();
  28 }
  29
  30 SBBroadcaster::SBBroadcaster(lldb_private::Broadcaster *broadcaster, bool owns)
  31     : m_opaque_sp(owns ? broadcaster : nullptr), m_opaque_ptr(broadcaster) {}
  32
  33 SBBroadcaster::SBBroadcaster(const SBBroadcaster &rhs)
  34     : m_opaque_sp(rhs.m_opaque_sp), m_opaque_ptr(rhs.m_opaque_ptr) {
  35   LLDB_RECORD_CONSTRUCTOR(SBBroadcaster, (const lldb::SBBroadcaster &), rhs);
  36 }
  37
  38 const SBBroadcaster &SBBroadcaster::operator=(const SBBroadcaster &rhs) {
  39   LLDB_RECORD_METHOD(const lldb::SBBroadcaster &,
  40                      SBBroadcaster, operator=,(const lldb::SBBroadcaster &),
  41                      rhs);
  42
  43   if (this != &rhs) {
  44     m_opaque_sp = rhs.m_opaque_sp;
  45     m_opaque_ptr = rhs.m_opaque_ptr;
  46   }
  47   return LLDB_RECORD_RESULT(*this);
  48 }
  49
  50 SBBroadcaster::~SBBroadcaster() { reset(nullptr, false); }
  51
  52 void SBBroadcaster::BroadcastEventByType(uint32_t event_type, bool unique) {
  53   LLDB_RECORD_METHOD(void, SBBroadcaster, BroadcastEventByType,
  54                      (uint32_t, bool), event_type, unique);
  55
  56   if (m_opaque_ptr == nullptr)
  57     return;
  58
  59   if (unique)
  60     m_opaque_ptr->BroadcastEventIfUnique(event_type);
  61   else
  62     m_opaque_ptr->BroadcastEvent(event_type);
  63 }
  64
  65 void SBBroadcaster::BroadcastEvent(const SBEvent &event, bool unique) {
  66   LLDB_RECORD_METHOD(void, SBBroadcaster, BroadcastEvent,
  67                      (const lldb::SBEvent &, bool), event, unique);
  68
  69   if (m_opaque_ptr == nullptr)
  70     return;
  71
  72   EventSP event_sp = event.GetSP();
  73   if (unique)
  74     m_opaque_ptr->BroadcastEventIfUnique(event_sp);
  75   else
  76     m_opaque_ptr->BroadcastEvent(event_sp);
  77 }
  78
  79 void SBBroadcaster::AddInitialEventsToListener(const SBListener &listener,
  80                                                uint32_t requested_events) {
  81   LLDB_RECORD_METHOD(void, SBBroadcaster, AddInitialEventsToListener,
  82                      (const lldb::SBListener &, uint32_t), listener,
  83                      requested_events);
  84
  85   if (m_opaque_ptr)
  86     m_opaque_ptr->AddInitialEventsToListener(listener.m_opaque_sp,
  87                                              requested_events);
  88 }
  89
  90 uint32_t SBBroadcaster::AddListener(const SBListener &listener,
  91                                     uint32_t event_mask) {
  92   LLDB_RECORD_METHOD(uint32_t, SBBroadcaster, AddListener,
  93                      (const lldb::SBListener &, uint32_t), listener,
  94                      event_mask);
  95
  96   if (m_opaque_ptr)
  97     return m_opaque_ptr->AddListener(listener.m_opaque_sp, event_mask);
  98   return 0;
  99 }
 100
 101 const char *SBBroadcaster::GetName() const {
 102   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBroadcaster, GetName);
 103
 104   if (m_opaque_ptr)
 105     return m_opaque_ptr->GetBroadcasterName().GetCString();
 106   return nullptr;
 107 }
 108
 109 bool SBBroadcaster::EventTypeHasListeners(uint32_t event_type) {
 110   LLDB_RECORD_METHOD(bool, SBBroadcaster, EventTypeHasListeners, (uint32_t),
 111                      event_type);
 112
 113   if (m_opaque_ptr)
 114     return m_opaque_ptr->EventTypeHasListeners(event_type);
 115   return false;
 116 }
 117
 118 bool SBBroadcaster::RemoveListener(const SBListener &listener,
 119                                    uint32_t event_mask) {
 120   LLDB_RECORD_METHOD(bool, SBBroadcaster, RemoveListener,
 121                      (const lldb::SBListener &, uint32_t), listener,
 122                      event_mask);
 123
 124   if (m_opaque_ptr)
 125     return m_opaque_ptr->RemoveListener(listener.m_opaque_sp, event_mask);
 126   return false;
 127 }
 128
 129 Broadcaster *SBBroadcaster::get() const { return m_opaque_ptr; }
 130
 131 void SBBroadcaster::reset(Broadcaster *broadcaster, bool owns) {
 132   if (owns)
 133     m_opaque_sp.reset(broadcaster);
 134   else
 135     m_opaque_sp.reset();
 136   m_opaque_ptr = broadcaster;
 137 }
 138
 139 bool SBBroadcaster::IsValid() const {
 140   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBroadcaster, IsValid);
 141   return this->operator bool();
 142 }
 143 SBBroadcaster::operator bool() const {
 144   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBroadcaster, operator bool);
 145
 146   return m_opaque_ptr != nullptr;
 147 }
 148
 149 void SBBroadcaster::Clear() {
 150   LLDB_RECORD_METHOD_NO_ARGS(void, SBBroadcaster, Clear);
 151
 152   m_opaque_sp.reset();
 153   m_opaque_ptr = nullptr;
 154 }
 155
 156 bool SBBroadcaster::operator==(const SBBroadcaster &rhs) const {
 157   LLDB_RECORD_METHOD_CONST(
 158       bool, SBBroadcaster, operator==,(const lldb::SBBroadcaster &), rhs);
 159
 160   return m_opaque_ptr == rhs.m_opaque_ptr;
 161 }
 162
 163 bool SBBroadcaster::operator!=(const SBBroadcaster &rhs) const {
 164   LLDB_RECORD_METHOD_CONST(
 165       bool, SBBroadcaster, operator!=,(const lldb::SBBroadcaster &), rhs);
 166
 167   return m_opaque_ptr != rhs.m_opaque_ptr;
 168 }
 169
 170 bool SBBroadcaster::operator<(const SBBroadcaster &rhs) const {
 171   LLDB_RECORD_METHOD_CONST(
 172       bool, SBBroadcaster, operator<,(const lldb::SBBroadcaster &), rhs);
 173
 174   return m_opaque_ptr < rhs.m_opaque_ptr;
 175 }
 176
 177 namespace lldb_private {
 178 namespace repro {
 179
 180 template <>
 181 void RegisterMethods<SBBroadcaster>(Registry &R) {
 182   LLDB_REGISTER_CONSTRUCTOR(SBBroadcaster, ());
 183   LLDB_REGISTER_CONSTRUCTOR(SBBroadcaster, (const char *));
 184   LLDB_REGISTER_CONSTRUCTOR(SBBroadcaster, (const lldb::SBBroadcaster &));
 185   LLDB_REGISTER_METHOD(
 186       const lldb::SBBroadcaster &,
 187       SBBroadcaster, operator=,(const lldb::SBBroadcaster &));
 188   LLDB_REGISTER_METHOD(void, SBBroadcaster, BroadcastEventByType,
 189                        (uint32_t, bool));
 190   LLDB_REGISTER_METHOD(void, SBBroadcaster, BroadcastEvent,
 191                        (const lldb::SBEvent &, bool));
 192   LLDB_REGISTER_METHOD(void, SBBroadcaster, AddInitialEventsToListener,
 193                        (const lldb::SBListener &, uint32_t));
 194   LLDB_REGISTER_METHOD(uint32_t, SBBroadcaster, AddListener,
 195                        (const lldb::SBListener &, uint32_t));
 196   LLDB_REGISTER_METHOD_CONST(const char *, SBBroadcaster, GetName, ());
 197   LLDB_REGISTER_METHOD(bool, SBBroadcaster, EventTypeHasListeners,
 198                        (uint32_t));
 199   LLDB_REGISTER_METHOD(bool, SBBroadcaster, RemoveListener,
 200                        (const lldb::SBListener &, uint32_t));
 201   LLDB_REGISTER_METHOD_CONST(bool, SBBroadcaster, IsValid, ());
 202   LLDB_REGISTER_METHOD_CONST(bool, SBBroadcaster, operator bool, ());
 203   LLDB_REGISTER_METHOD(void, SBBroadcaster, Clear, ());
 204   LLDB_REGISTER_METHOD_CONST(
 205       bool, SBBroadcaster, operator==,(const lldb::SBBroadcaster &));
 206   LLDB_REGISTER_METHOD_CONST(
 207       bool, SBBroadcaster, operator!=,(const lldb::SBBroadcaster &));
 208   LLDB_REGISTER_METHOD_CONST(
 209       bool, SBBroadcaster, operator<,(const lldb::SBBroadcaster &));
 210 }
 211
 212 }
 213 }