llvm/lldb/source/Utility/Listener.cpp

//===-- Listener.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/Utility/Listener.h"
#include "lldb/Utility/Broadcaster.h"
#include "lldb/Utility/Event.h"
#include "lldb/Utility/LLDBLog.h"

#include <algorithm>
#include <memory>
#include <utility>

usingnamespacelldb;
usingnamespacelldb_private;

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

Listener::~Listener() { … }

void Listener::Clear() { … }

uint32_t Listener::StartListeningForEvents(Broadcaster *broadcaster,
                                           uint32_t event_mask) { … }

uint32_t Listener::StartListeningForEvents(Broadcaster *broadcaster,
                                           uint32_t event_mask,
                                           HandleBroadcastCallback callback,
                                           void *callback_user_data) { … }

bool Listener::StopListeningForEvents(Broadcaster *broadcaster,
                                      uint32_t event_mask) { … }

// Called when a Broadcaster is in its destructor. We need to remove all
// knowledge of this broadcaster and any events that it may have queued up
void Listener::BroadcasterWillDestruct(Broadcaster *broadcaster) { … }

void Listener::BroadcasterManagerWillDestruct(BroadcasterManagerSP manager_sp) { … }

void Listener::AddEvent(EventSP &event_sp) { … }

bool Listener::FindNextEventInternal(
    std::unique_lock<std::mutex> &lock,
    Broadcaster *broadcaster, // nullptr for any broadcaster
    uint32_t event_type_mask, EventSP &event_sp, bool remove) { … }

Event *Listener::PeekAtNextEvent() { … }

Event *Listener::PeekAtNextEventForBroadcaster(Broadcaster *broadcaster) { … }

Event *
Listener::PeekAtNextEventForBroadcasterWithType(Broadcaster *broadcaster,
                                                uint32_t event_type_mask) { … }

bool Listener::GetEventInternal(
    const Timeout<std::micro> &timeout,
    Broadcaster *broadcaster, // nullptr for any broadcaster
    uint32_t event_type_mask, EventSP &event_sp) { … }

bool Listener::GetEventForBroadcasterWithType(
    Broadcaster *broadcaster, uint32_t event_type_mask, EventSP &event_sp,
    const Timeout<std::micro> &timeout) { … }

bool Listener::GetEventForBroadcaster(Broadcaster *broadcaster,
                                      EventSP &event_sp,
                                      const Timeout<std::micro> &timeout) { … }

bool Listener::GetEvent(EventSP &event_sp, const Timeout<std::micro> &timeout) { … }

size_t Listener::HandleBroadcastEvent(EventSP &event_sp) { … }

uint32_t
Listener::StartListeningForEventSpec(const BroadcasterManagerSP &manager_sp,
                                     const BroadcastEventSpec &event_spec) { … }

bool Listener::StopListeningForEventSpec(const BroadcasterManagerSP &manager_sp,
                                         const BroadcastEventSpec &event_spec) { … }

ListenerSP Listener::MakeListener(const char *name) { … }