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