llvm/lldb/source/Utility/Event.cpp

//===-- Event.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/Event.h"

#include "lldb/Utility/Broadcaster.h"
#include "lldb/Utility/DataExtractor.h"
#include "lldb/Utility/Endian.h"
#include "lldb/Utility/Listener.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamString.h"
#include "lldb/lldb-enumerations.h"

#include "llvm/ADT/StringExtras.h"

#include <algorithm>

#include <cctype>

usingnamespacelldb;
usingnamespacelldb_private;

#pragma mark -
#pragma mark Event

// Event functions

Event::Event(Broadcaster *broadcaster, uint32_t event_type, EventData *data)
    : … { … }

Event::Event(Broadcaster *broadcaster, uint32_t event_type,
             const EventDataSP &event_data_sp)
    : … { … }

Event::Event(uint32_t event_type, EventData *data)
    : … { … }

Event::Event(uint32_t event_type, const EventDataSP &event_data_sp)
    : … { … }

Event::~Event() = default;

void Event::Dump(Stream *s) const { … }

void Event::DoOnRemoval() { … }

#pragma mark -
#pragma mark EventData

// EventData functions

EventData::EventData() = default;

EventData::~EventData() = default;

void EventData::Dump(Stream *s) const { … }

#pragma mark -
#pragma mark EventDataBytes

// EventDataBytes functions

EventDataBytes::EventDataBytes() : … { … }

EventDataBytes::EventDataBytes(llvm::StringRef str) : … { … }

EventDataBytes::~EventDataBytes() = default;

llvm::StringRef EventDataBytes::GetFlavorString() { … }

llvm::StringRef EventDataBytes::GetFlavor() const { … }

void EventDataBytes::Dump(Stream *s) const { … }

const void *EventDataBytes::GetBytes() const { … }

size_t EventDataBytes::GetByteSize() const { … }

const void *EventDataBytes::GetBytesFromEvent(const Event *event_ptr) { … }

size_t EventDataBytes::GetByteSizeFromEvent(const Event *event_ptr) { … }

const EventDataBytes *
EventDataBytes::GetEventDataFromEvent(const Event *event_ptr) { … }

llvm::StringRef EventDataReceipt::GetFlavorString() { … }

#pragma mark -
#pragma mark EventStructuredData

// EventDataStructuredData definitions

EventDataStructuredData::EventDataStructuredData()
    : … { … }

EventDataStructuredData::EventDataStructuredData(
    const ProcessSP &process_sp, const StructuredData::ObjectSP &object_sp,
    const lldb::StructuredDataPluginSP &plugin_sp)
    : … { … }

EventDataStructuredData::~EventDataStructuredData() = default;

// EventDataStructuredData member functions

llvm::StringRef EventDataStructuredData::GetFlavor() const { … }

void EventDataStructuredData::Dump(Stream *s) const { … }

const ProcessSP &EventDataStructuredData::GetProcess() const { … }

const StructuredData::ObjectSP &EventDataStructuredData::GetObject() const { … }

const lldb::StructuredDataPluginSP &
EventDataStructuredData::GetStructuredDataPlugin() const { … }

void EventDataStructuredData::SetProcess(const ProcessSP &process_sp) { … }

void EventDataStructuredData::SetObject(
    const StructuredData::ObjectSP &object_sp) { … }

void EventDataStructuredData::SetStructuredDataPlugin(
    const lldb::StructuredDataPluginSP &plugin_sp) { … }

// EventDataStructuredData static functions

const EventDataStructuredData *
EventDataStructuredData::GetEventDataFromEvent(const Event *event_ptr) { … }

ProcessSP EventDataStructuredData::GetProcessFromEvent(const Event *event_ptr) { … }

StructuredData::ObjectSP
EventDataStructuredData::GetObjectFromEvent(const Event *event_ptr) { … }

lldb::StructuredDataPluginSP
EventDataStructuredData::GetPluginFromEvent(const Event *event_ptr) { … }

llvm::StringRef EventDataStructuredData::GetFlavorString() { … }