1 //===-- SBTypeFilter.cpp --------------------------------------------------===//
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
9 #include "lldb/API/SBTypeFilter.h"
10 #include "SBReproducerPrivate.h"
12 #include "lldb/API/SBStream.h"
14 #include "lldb/DataFormatters/DataVisualization.h"
17 using namespace lldb_private;
19 SBTypeFilter::SBTypeFilter() : m_opaque_sp() {
20 LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBTypeFilter);
23 SBTypeFilter::SBTypeFilter(uint32_t options)
24 : m_opaque_sp(TypeFilterImplSP(new TypeFilterImpl(options))) {
25 LLDB_RECORD_CONSTRUCTOR(SBTypeFilter, (uint32_t), options);
28 SBTypeFilter::SBTypeFilter(const lldb::SBTypeFilter &rhs)
29 : m_opaque_sp(rhs.m_opaque_sp) {
30 LLDB_RECORD_CONSTRUCTOR(SBTypeFilter, (const lldb::SBTypeFilter &), rhs);
33 SBTypeFilter::~SBTypeFilter() = default;
35 bool SBTypeFilter::IsValid() const {
36 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFilter, IsValid);
37 return this->operator bool();
39 SBTypeFilter::operator bool() const {
40 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTypeFilter, operator bool);
42 return m_opaque_sp.get() != nullptr;
45 uint32_t SBTypeFilter::GetOptions() {
46 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeFilter, GetOptions);
49 return m_opaque_sp->GetOptions();
53 void SBTypeFilter::SetOptions(uint32_t value) {
54 LLDB_RECORD_METHOD(void, SBTypeFilter, SetOptions, (uint32_t), value);
56 if (CopyOnWrite_Impl())
57 m_opaque_sp->SetOptions(value);
60 bool SBTypeFilter::GetDescription(lldb::SBStream &description,
61 lldb::DescriptionLevel description_level) {
62 LLDB_RECORD_METHOD(bool, SBTypeFilter, GetDescription,
63 (lldb::SBStream &, lldb::DescriptionLevel), description,
69 description.Printf("%s\n", m_opaque_sp->GetDescription().c_str());
74 void SBTypeFilter::Clear() {
75 LLDB_RECORD_METHOD_NO_ARGS(void, SBTypeFilter, Clear);
77 if (CopyOnWrite_Impl())
81 uint32_t SBTypeFilter::GetNumberOfExpressionPaths() {
82 LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBTypeFilter,
83 GetNumberOfExpressionPaths);
86 return m_opaque_sp->GetCount();
90 const char *SBTypeFilter::GetExpressionPathAtIndex(uint32_t i) {
91 LLDB_RECORD_METHOD(const char *, SBTypeFilter, GetExpressionPathAtIndex,
95 const char *item = m_opaque_sp->GetExpressionPathAtIndex(i);
96 if (item && *item == '.')
103 bool SBTypeFilter::ReplaceExpressionPathAtIndex(uint32_t i, const char *item) {
104 LLDB_RECORD_METHOD(bool, SBTypeFilter, ReplaceExpressionPathAtIndex,
105 (uint32_t, const char *), i, item);
107 if (CopyOnWrite_Impl())
108 return m_opaque_sp->SetExpressionPathAtIndex(i, item);
113 void SBTypeFilter::AppendExpressionPath(const char *item) {
114 LLDB_RECORD_METHOD(void, SBTypeFilter, AppendExpressionPath, (const char *),
117 if (CopyOnWrite_Impl())
118 m_opaque_sp->AddExpressionPath(item);
121 lldb::SBTypeFilter &SBTypeFilter::operator=(const lldb::SBTypeFilter &rhs) {
122 LLDB_RECORD_METHOD(lldb::SBTypeFilter &,
123 SBTypeFilter, operator=,(const lldb::SBTypeFilter &), rhs);
126 m_opaque_sp = rhs.m_opaque_sp;
128 return LLDB_RECORD_RESULT(*this);
131 bool SBTypeFilter::operator==(lldb::SBTypeFilter &rhs) {
132 LLDB_RECORD_METHOD(bool, SBTypeFilter, operator==,(lldb::SBTypeFilter &),
136 return !rhs.IsValid();
138 return m_opaque_sp == rhs.m_opaque_sp;
141 bool SBTypeFilter::IsEqualTo(lldb::SBTypeFilter &rhs) {
142 LLDB_RECORD_METHOD(bool, SBTypeFilter, IsEqualTo, (lldb::SBTypeFilter &),
146 return !rhs.IsValid();
148 if (GetNumberOfExpressionPaths() != rhs.GetNumberOfExpressionPaths())
151 for (uint32_t j = 0; j < GetNumberOfExpressionPaths(); j++)
152 if (strcmp(GetExpressionPathAtIndex(j), rhs.GetExpressionPathAtIndex(j)) !=
156 return GetOptions() == rhs.GetOptions();
159 bool SBTypeFilter::operator!=(lldb::SBTypeFilter &rhs) {
160 LLDB_RECORD_METHOD(bool, SBTypeFilter, operator!=,(lldb::SBTypeFilter &),
164 return !rhs.IsValid();
166 return m_opaque_sp != rhs.m_opaque_sp;
169 lldb::TypeFilterImplSP SBTypeFilter::GetSP() { return m_opaque_sp; }
171 void SBTypeFilter::SetSP(const lldb::TypeFilterImplSP &typefilter_impl_sp) {
172 m_opaque_sp = typefilter_impl_sp;
175 SBTypeFilter::SBTypeFilter(const lldb::TypeFilterImplSP &typefilter_impl_sp)
176 : m_opaque_sp(typefilter_impl_sp) {}
178 bool SBTypeFilter::CopyOnWrite_Impl() {
181 if (m_opaque_sp.unique())
184 TypeFilterImplSP new_sp(new TypeFilterImpl(GetOptions()));
186 for (uint32_t j = 0; j < GetNumberOfExpressionPaths(); j++)
187 new_sp->AddExpressionPath(GetExpressionPathAtIndex(j));
194 namespace lldb_private {
198 void RegisterMethods<SBTypeFilter>(Registry &R) {
199 LLDB_REGISTER_CONSTRUCTOR(SBTypeFilter, ());
200 LLDB_REGISTER_CONSTRUCTOR(SBTypeFilter, (uint32_t));
201 LLDB_REGISTER_CONSTRUCTOR(SBTypeFilter, (const lldb::SBTypeFilter &));
202 LLDB_REGISTER_METHOD_CONST(bool, SBTypeFilter, IsValid, ());
203 LLDB_REGISTER_METHOD_CONST(bool, SBTypeFilter, operator bool, ());
204 LLDB_REGISTER_METHOD(uint32_t, SBTypeFilter, GetOptions, ());
205 LLDB_REGISTER_METHOD(void, SBTypeFilter, SetOptions, (uint32_t));
206 LLDB_REGISTER_METHOD(bool, SBTypeFilter, GetDescription,
207 (lldb::SBStream &, lldb::DescriptionLevel));
208 LLDB_REGISTER_METHOD(void, SBTypeFilter, Clear, ());
209 LLDB_REGISTER_METHOD(uint32_t, SBTypeFilter, GetNumberOfExpressionPaths,
211 LLDB_REGISTER_METHOD(const char *, SBTypeFilter, GetExpressionPathAtIndex,
213 LLDB_REGISTER_METHOD(bool, SBTypeFilter, ReplaceExpressionPathAtIndex,
214 (uint32_t, const char *));
215 LLDB_REGISTER_METHOD(void, SBTypeFilter, AppendExpressionPath,
217 LLDB_REGISTER_METHOD(lldb::SBTypeFilter &,
218 SBTypeFilter, operator=,(const lldb::SBTypeFilter &));
219 LLDB_REGISTER_METHOD(bool, SBTypeFilter, operator==,(lldb::SBTypeFilter &));
220 LLDB_REGISTER_METHOD(bool, SBTypeFilter, IsEqualTo, (lldb::SBTypeFilter &));
221 LLDB_REGISTER_METHOD(bool, SBTypeFilter, operator!=,(lldb::SBTypeFilter &));