llvm/lldb/source/API/SBListener.cpp

//===-- SBListener.cpp ----------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "lldb/API/SBListener.h"
#include "lldb/API/SBBroadcaster.h"
#include "lldb/API/SBDebugger.h"
#include "lldb/API/SBEvent.h"
#include "lldb/API/SBStream.h"
#include "lldb/Core/Debugger.h"
#include "lldb/Utility/Broadcaster.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/Listener.h"
#include "lldb/Utility/StreamString.h"

usingnamespacelldb;
usingnamespacelldb_private;

SBListener::SBListener() { … }

SBListener::SBListener(const char *name)
    : … { … }

SBListener::SBListener(const SBListener &rhs) : … { … }

const lldb::SBListener &SBListener::operator=(const lldb::SBListener &rhs) { … }

SBListener::SBListener(const lldb::ListenerSP &listener_sp)
    : … { … }

SBListener::~SBListener() = default;

bool SBListener::IsValid() const { … }
operator bool()

void SBListener::AddEvent(const SBEvent &event) { … }

void SBListener::Clear() { … }

uint32_t SBListener::StartListeningForEventClass(SBDebugger &debugger,
                                                 const char *broadcaster_class,
                                                 uint32_t event_mask) { … }

bool SBListener::StopListeningForEventClass(SBDebugger &debugger,
                                            const char *broadcaster_class,
                                            uint32_t event_mask) { … }

uint32_t SBListener::StartListeningForEvents(const SBBroadcaster &broadcaster,
                                             uint32_t event_mask) { … }

bool SBListener::StopListeningForEvents(const SBBroadcaster &broadcaster,
                                        uint32_t event_mask) { … }

bool SBListener::WaitForEvent(uint32_t timeout_secs, SBEvent &event) { … }

bool SBListener::WaitForEventForBroadcaster(uint32_t num_seconds,
                                            const SBBroadcaster &broadcaster,
                                            SBEvent &event) { … }

bool SBListener::WaitForEventForBroadcasterWithType(
    uint32_t num_seconds, const SBBroadcaster &broadcaster,
    uint32_t event_type_mask, SBEvent &event) { … }

bool SBListener::PeekAtNextEvent(SBEvent &event) { … }

bool SBListener::PeekAtNextEventForBroadcaster(const SBBroadcaster &broadcaster,
                                               SBEvent &event) { … }

bool SBListener::PeekAtNextEventForBroadcasterWithType(
    const SBBroadcaster &broadcaster, uint32_t event_type_mask,
    SBEvent &event) { … }

bool SBListener::GetNextEvent(SBEvent &event) { … }

bool SBListener::GetNextEventForBroadcaster(const SBBroadcaster &broadcaster,
                                            SBEvent &event) { … }

bool SBListener::GetNextEventForBroadcasterWithType(
    const SBBroadcaster &broadcaster, uint32_t event_type_mask,
    SBEvent &event) { … }

bool SBListener::HandleBroadcastEvent(const SBEvent &event) { … }

lldb::ListenerSP SBListener::GetSP() { … }

Listener *SBListener::operator->() const { … }

Listener *SBListener::get() const { … }

void SBListener::reset(ListenerSP listener_sp) { … }