llvm/lldb/source/API/SBTypeCategory.cpp

//===-- SBTypeCategory.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/SBTypeCategory.h"
#include "lldb/Utility/Instrumentation.h"

#include "lldb/API/SBStream.h"
#include "lldb/API/SBTypeFilter.h"
#include "lldb/API/SBTypeFormat.h"
#include "lldb/API/SBTypeNameSpecifier.h"
#include "lldb/API/SBTypeSummary.h"
#include "lldb/API/SBTypeSynthetic.h"

#include "lldb/Core/Debugger.h"
#include "lldb/DataFormatters/DataVisualization.h"
#include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/ScriptInterpreter.h"

usingnamespacelldb;
usingnamespacelldb_private;

ImplType;

SBTypeCategory::SBTypeCategory() { … }

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

SBTypeCategory::SBTypeCategory(const lldb::SBTypeCategory &rhs)
    : … { … }

SBTypeCategory::~SBTypeCategory() = default;

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

bool SBTypeCategory::GetEnabled() { … }

void SBTypeCategory::SetEnabled(bool enabled) { … }

const char *SBTypeCategory::GetName() { … }

lldb::LanguageType SBTypeCategory::GetLanguageAtIndex(uint32_t idx) { … }

uint32_t SBTypeCategory::GetNumLanguages() { … }

void SBTypeCategory::AddLanguage(lldb::LanguageType language) { … }

uint32_t SBTypeCategory::GetNumFormats() { … }

uint32_t SBTypeCategory::GetNumSummaries() { … }

uint32_t SBTypeCategory::GetNumFilters() { … }

uint32_t SBTypeCategory::GetNumSynthetics() { … }

lldb::SBTypeNameSpecifier
SBTypeCategory::GetTypeNameSpecifierForFilterAtIndex(uint32_t index) { … }

lldb::SBTypeNameSpecifier
SBTypeCategory::GetTypeNameSpecifierForFormatAtIndex(uint32_t index) { … }

lldb::SBTypeNameSpecifier
SBTypeCategory::GetTypeNameSpecifierForSummaryAtIndex(uint32_t index) { … }

lldb::SBTypeNameSpecifier
SBTypeCategory::GetTypeNameSpecifierForSyntheticAtIndex(uint32_t index) { … }

SBTypeFilter SBTypeCategory::GetFilterForType(SBTypeNameSpecifier spec) { … }
SBTypeFormat SBTypeCategory::GetFormatForType(SBTypeNameSpecifier spec) { … }

SBTypeSummary SBTypeCategory::GetSummaryForType(SBTypeNameSpecifier spec) { … }

SBTypeSynthetic SBTypeCategory::GetSyntheticForType(SBTypeNameSpecifier spec) { … }

SBTypeFilter SBTypeCategory::GetFilterAtIndex(uint32_t index) { … }

SBTypeFormat SBTypeCategory::GetFormatAtIndex(uint32_t index) { … }

SBTypeSummary SBTypeCategory::GetSummaryAtIndex(uint32_t index) { … }

SBTypeSynthetic SBTypeCategory::GetSyntheticAtIndex(uint32_t index) { … }

bool SBTypeCategory::AddTypeFormat(SBTypeNameSpecifier type_name,
                                   SBTypeFormat format) { … }

bool SBTypeCategory::DeleteTypeFormat(SBTypeNameSpecifier type_name) { … }

bool SBTypeCategory::AddTypeSummary(SBTypeNameSpecifier type_name,
                                    SBTypeSummary summary) { … }

bool SBTypeCategory::DeleteTypeSummary(SBTypeNameSpecifier type_name) { … }

bool SBTypeCategory::AddTypeFilter(SBTypeNameSpecifier type_name,
                                   SBTypeFilter filter) { … }

bool SBTypeCategory::DeleteTypeFilter(SBTypeNameSpecifier type_name) { … }

bool SBTypeCategory::AddTypeSynthetic(SBTypeNameSpecifier type_name,
                                      SBTypeSynthetic synth) { … }

bool SBTypeCategory::DeleteTypeSynthetic(SBTypeNameSpecifier type_name) { … }

bool SBTypeCategory::GetDescription(lldb::SBStream &description,
                                    lldb::DescriptionLevel description_level) { … }

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

bool SBTypeCategory::operator==(lldb::SBTypeCategory &rhs) { … }

bool SBTypeCategory::operator!=(lldb::SBTypeCategory &rhs) { … }

lldb::TypeCategoryImplSP SBTypeCategory::GetSP() { … }

void SBTypeCategory::SetSP(
    const lldb::TypeCategoryImplSP &typecategory_impl_sp) { … }

SBTypeCategory::SBTypeCategory(
    const lldb::TypeCategoryImplSP &typecategory_impl_sp)
    : … { … }

bool SBTypeCategory::IsDefaultCategory() { … }