LLDB  mainline
TypeCategory.h
Go to the documentation of this file.
1 //===-- TypeCategory.h ------------------------------------------*- C++ -*-===//
2 //
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
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #ifndef LLDB_DATAFORMATTERS_TYPECATEGORY_H
10 #define LLDB_DATAFORMATTERS_TYPECATEGORY_H
11 
12 #include <initializer_list>
13 #include <memory>
14 #include <mutex>
15 #include <string>
16 #include <vector>
17 
18 #include "lldb/lldb-enumerations.h"
19 #include "lldb/lldb-public.h"
20 
23 
24 namespace lldb_private {
25 
26 template <typename FormatterImpl> class FormatterContainerPair {
27 public:
30 
33 
35 
38 
39  typedef
41  typedef
43 
45  : m_exact_sp(new ExactMatchContainer(clist)),
46  m_regex_sp(new RegexMatchContainer(clist)) {}
47 
48  ~FormatterContainerPair() = default;
49 
51 
53 
55  return GetExactMatch()->GetCount() + GetRegexMatch()->GetCount();
56  }
57 
58 private:
61 };
62 
64 private:
69 
70 public:
72  static const uint16_t ALL_ITEM_TYPES = UINT16_MAX;
73 
76 
79 
82 
85 
86  template <typename T> class ForEachCallbacks {
87  public:
88  ForEachCallbacks() = default;
89  ~ForEachCallbacks() = default;
90 
91  template <typename U = TypeFormatImpl>
92  typename std::enable_if<std::is_same<U, T>::value, ForEachCallbacks &>::type
94  m_format_exact = std::move(callback);
95  return *this;
96  }
97  template <typename U = TypeFormatImpl>
98  typename std::enable_if<std::is_same<U, T>::value, ForEachCallbacks &>::type
100  m_format_regex = std::move(callback);
101  return *this;
102  }
103 
104  template <typename U = TypeSummaryImpl>
105  typename std::enable_if<std::is_same<U, T>::value, ForEachCallbacks &>::type
107  m_summary_exact = std::move(callback);
108  return *this;
109  }
110  template <typename U = TypeSummaryImpl>
111  typename std::enable_if<std::is_same<U, T>::value, ForEachCallbacks &>::type
113  m_summary_regex = std::move(callback);
114  return *this;
115  }
116 
117  template <typename U = TypeFilterImpl>
118  typename std::enable_if<std::is_same<U, T>::value, ForEachCallbacks &>::type
120  m_filter_exact = std::move(callback);
121  return *this;
122  }
123  template <typename U = TypeFilterImpl>
124  typename std::enable_if<std::is_same<U, T>::value, ForEachCallbacks &>::type
126  m_filter_regex = std::move(callback);
127  return *this;
128  }
129 
130  template <typename U = SyntheticChildren>
131  typename std::enable_if<std::is_same<U, T>::value, ForEachCallbacks &>::type
133  m_synth_exact = std::move(callback);
134  return *this;
135  }
136  template <typename U = SyntheticChildren>
137  typename std::enable_if<std::is_same<U, T>::value, ForEachCallbacks &>::type
139  m_synth_regex = std::move(callback);
140  return *this;
141  }
142 
144  return m_format_exact;
145  }
147  return m_format_regex;
148  }
149 
152  return m_summary_exact;
153  }
156  return m_summary_regex;
157  }
158 
160  return m_filter_exact;
161  }
163  return m_filter_regex;
164  }
165 
167  return m_synth_exact;
168  }
170  return m_synth_regex;
171  }
172 
173  private:
176 
179 
182 
185  };
186 
188 
189  template <typename T> void ForEach(const ForEachCallbacks<T> &foreach) {
190  GetTypeFormatsContainer()->ForEach(foreach.GetFormatExactCallback());
191  GetRegexTypeFormatsContainer()->ForEach(foreach.GetFormatRegexCallback());
192 
193  GetTypeSummariesContainer()->ForEach(foreach.GetSummaryExactCallback());
195  foreach.GetSummaryRegexCallback());
196 
197  GetTypeFiltersContainer()->ForEach(foreach.GetFilterExactCallback());
198  GetRegexTypeFiltersContainer()->ForEach(foreach.GetFilterRegexCallback());
199 
200  GetTypeSyntheticsContainer()->ForEach(foreach.GetSynthExactCallback());
201  GetRegexTypeSyntheticsContainer()->ForEach(foreach.GetSynthRegexCallback());
202  }
203 
205  return m_format_cont.GetExactMatch();
206  }
207 
209  return m_format_cont.GetRegexMatch();
210  }
211 
213 
215  return m_summary_cont.GetExactMatch();
216  }
217 
219  return m_summary_cont.GetRegexMatch();
220  }
221 
223 
225  return m_filter_cont.GetExactMatch();
226  }
227 
229  return m_filter_cont.GetRegexMatch();
230  }
231 
233 
235  GetFormatForType(lldb::TypeNameSpecifierImplSP type_sp);
236 
238  GetSummaryForType(lldb::TypeNameSpecifierImplSP type_sp);
239 
241  GetFilterForType(lldb::TypeNameSpecifierImplSP type_sp);
242 
244  GetSyntheticForType(lldb::TypeNameSpecifierImplSP type_sp);
245 
246  lldb::TypeNameSpecifierImplSP
248 
249  lldb::TypeNameSpecifierImplSP
251 
253 
255 
257 
258  lldb::TypeNameSpecifierImplSP
260 
262  return m_synth_cont.GetExactMatch();
263  }
264 
266  return m_synth_cont.GetRegexMatch();
267  }
268 
270 
272 
273  lldb::TypeNameSpecifierImplSP
275 
276  bool IsEnabled() const { return m_enabled; }
277 
279  if (!m_enabled)
280  return UINT32_MAX;
281  else
282  return m_enabled_position;
283  }
284 
285  bool Get(lldb::LanguageType lang, const FormattersMatchVector &candidates,
286  lldb::TypeFormatImplSP &entry);
287 
288  bool Get(lldb::LanguageType lang, const FormattersMatchVector &candidates,
289  lldb::TypeSummaryImplSP &entry);
290 
291  bool Get(lldb::LanguageType lang, const FormattersMatchVector &candidates,
292  lldb::SyntheticChildrenSP &entry);
293 
295 
297 
299 
300  const char *GetName() { return m_name.GetCString(); }
301 
302  size_t GetNumLanguages();
303 
305 
306  void AddLanguage(lldb::LanguageType lang);
307 
309 
310  bool AnyMatches(ConstString type_name,
312  bool only_enabled = true,
313  const char **matching_category = nullptr,
314  FormatCategoryItems *matching_type = nullptr);
315 
316  typedef std::shared_ptr<TypeCategoryImpl> SharedPointer;
317 
318 private:
323 
324  bool m_enabled;
325 
327 
328  std::recursive_mutex m_mutex;
329 
331 
332  std::vector<lldb::LanguageType> m_languages;
333 
335 
336  void Enable(bool value, uint32_t position);
337 
338  void Disable() { Enable(false, UINT32_MAX); }
339 
340  bool IsApplicable(lldb::LanguageType lang);
341 
343 
345 
346  friend class FormatManager;
347  friend class LanguageCategory;
348  friend class TypeCategoryMap;
349 
351 
353 
355 
357 };
358 
359 } // namespace lldb_private
360 
361 #endif // LLDB_DATAFORMATTERS_TYPECATEGORY_H
lldb_private::TypeCategoryImpl::GetTypeFormatsContainer
FormatContainerSP GetTypeFormatsContainer()
Definition: TypeCategory.h:204
lldb_private::TypeCategoryImpl::GetFormatForType
FormatContainer::MapValueType GetFormatForType(lldb::TypeNameSpecifierImplSP type_sp)
Definition: TypeCategory.cpp:320
lldb_private::TypeCategoryImpl::GetSummaryForType
SummaryContainer::MapValueType GetSummaryForType(lldb::TypeNameSpecifierImplSP type_sp)
Definition: TypeCategory.cpp:336
lldb_private::TypeCategoryImpl::GetRegexTypeFormatsContainer
RegexFormatContainerSP GetRegexTypeFormatsContainer()
Definition: TypeCategory.h:208
lldb_private::TypeCategoryImpl::TypeCategoryImpl
TypeCategoryImpl(IFormatChangeListener *clist, ConstString name)
Definition: TypeCategory.cpp:16
lldb_private::ScriptedSyntheticChildren
Definition: TypeSynthetic.h:387
lldb_private::TypeCategoryImpl::FormatContainerSP
FormatContainer::ExactMatchContainerSP FormatContainerSP
Definition: TypeCategory.h:74
lldb_private::TypeCategoryImpl::SynthContainer
FormatterContainerPair< SyntheticChildren > SynthContainer
Definition: TypeCategory.h:68
lldb-public.h
lldb_private::TypeCategoryImpl::ForEachCallbacks::m_format_regex
FormatContainer::RegexMatchForEachCallback m_format_regex
Definition: TypeCategory.h:175
lldb_private::FormatterContainerPair::GetExactMatch
ExactMatchContainerSP GetExactMatch() const
Definition: TypeCategory.h:50
lldb_private::FormatterContainerPair::m_exact_sp
ExactMatchContainerSP m_exact_sp
Definition: TypeCategory.h:59
lldb_private::FormatterContainerPair::RegexMatchMap
TypeMatcher RegexMatchMap
Definition: TypeCategory.h:32
lldb_private::FormatManager
Definition: FormatManager.h:36
lldb_private::TypeCategoryImpl::GetTypeNameSpecifierForSyntheticAtIndex
lldb::TypeNameSpecifierImplSP GetTypeNameSpecifierForSyntheticAtIndex(size_t index)
Definition: TypeCategory.cpp:447
lldb_private::TypeSummaryImpl
Definition: TypeSummary.h:45
lldb_private::FormatterContainerPair::MapValueType
ExactMatchContainer::ValueSP MapValueType
Definition: TypeCategory.h:34
lldb_private::TypeCategoryImpl::m_change_listener
IFormatChangeListener * m_change_listener
Definition: TypeCategory.h:326
lldb_private::TypeMatcher
Class for matching type names.
Definition: FormattersContainer.h:41
FormatClasses.h
lldb_private::TypeCategoryImpl::SummaryContainerSP
SummaryContainer::ExactMatchContainerSP SummaryContainerSP
Definition: TypeCategory.h:77
lldb_private::TypeCategoryImpl::GetTypeNameSpecifierForFilterAtIndex
lldb::TypeNameSpecifierImplSP GetTypeNameSpecifierForFilterAtIndex(size_t index)
Definition: TypeCategory.cpp:429
lldb_private::TypeCategoryImpl::GetTypeSyntheticsContainer
SynthContainerSP GetTypeSyntheticsContainer()
Definition: TypeCategory.h:261
lldb_private::FormatterContainerPair
Definition: TypeCategory.h:26
lldb::LanguageType
LanguageType
Programming language type.
Definition: lldb-enumerations.h:436
lldb_private::TypeFilterImpl
Definition: TypeSynthetic.h:277
lldb_private::TypeCategoryImpl::Delete
bool Delete(ConstString name, FormatCategoryItems items=ALL_ITEM_TYPES)
Definition: TypeCategory.cpp:168
lldb_private::TypeCategoryImpl::ALL_ITEM_TYPES
static const uint16_t ALL_ITEM_TYPES
Definition: TypeCategory.h:72
lldb_private::TypeCategoryImpl::ForEachCallbacks::SetExact
std::enable_if< std::is_same< U, T >::value, ForEachCallbacks & >::type SetExact(FilterContainer::ExactMatchForEachCallback callback)
Definition: TypeCategory.h:119
lldb_private::TypeCategoryImpl::GetName
const char * GetName()
Definition: TypeCategory.h:300
lldb_private::TypeCategoryImpl::IsEnabled
bool IsEnabled() const
Definition: TypeCategory.h:276
lldb_private::TypeCategoryImpl::ForEachCallbacks::m_filter_exact
FilterContainer::ExactMatchForEachCallback m_filter_exact
Definition: TypeCategory.h:180
lldb_private::FormatterContainerPair::ExactMatchForEachCallback
ExactMatchContainer::ForEachCallback ExactMatchForEachCallback
Definition: TypeCategory.h:40
lldb_private::TypeCategoryImpl::GetEnabledPosition
uint32_t GetEnabledPosition()
Definition: TypeCategory.h:278
lldb_private::FormattersContainer
Definition: FormattersContainer.h:107
lldb_private::TypeCategoryImpl::GetSummaryAtIndex
SummaryContainer::MapValueType GetSummaryAtIndex(size_t index)
Definition: TypeCategory.cpp:402
lldb_private::TypeCategoryImpl::FormatCategoryItems
uint16_t FormatCategoryItems
Definition: TypeCategory.h:71
lldb_private::TypeCategoryImpl::FilterContainerSP
FilterContainer::ExactMatchContainerSP FilterContainerSP
Definition: TypeCategory.h:80
lldb_private::TypeCategoryImpl::GetSyntheticsContainer
SynthContainer & GetSyntheticsContainer()
Definition: TypeCategory.h:269
lldb_private::TypeFormatImpl
Definition: TypeFormat.h:24
lldb_private::TypeCategoryImpl::SynthContainerSP
SynthContainer::ExactMatchContainerSP SynthContainerSP
Definition: TypeCategory.h:83
lldb_private::TypeCategoryImpl::ForEachCallbacks::m_format_exact
FormatContainer::ExactMatchForEachCallback m_format_exact
Definition: TypeCategory.h:174
lldb_private::TypeCategoryImpl::ForEachCallbacks::SetWithRegex
std::enable_if< std::is_same< U, T >::value, ForEachCallbacks & >::type SetWithRegex(FormatContainer::RegexMatchForEachCallback callback)
Definition: TypeCategory.h:99
lldb_private::TypeCategoryMap
Definition: TypeCategoryMap.h:24
lldb_private::TypeCategoryImpl::GetFilterAtIndex
FilterContainer::MapValueType GetFilterAtIndex(size_t index)
Definition: TypeCategory.cpp:411
lldb_private::TypeCategoryImpl::GetRegexTypeSummariesContainer
RegexSummaryContainerSP GetRegexTypeSummariesContainer()
Definition: TypeCategory.h:218
lldb_private::TypeCategoryImpl::RegexFilterContainerSP
FilterContainer::RegexMatchContainerSP RegexFilterContainerSP
Definition: TypeCategory.h:81
lldb_private::FormatterContainerPair::GetRegexMatch
RegexMatchContainerSP GetRegexMatch() const
Definition: TypeCategory.h:52
lldb_private::FormattersMatchVector
std::vector< FormattersMatchCandidate > FormattersMatchVector
Definition: FormatClasses.h:81
lldb_private::TypeCategoryImpl::ForEachCallbacks::m_synth_exact
SynthContainer::ExactMatchForEachCallback m_synth_exact
Definition: TypeCategory.h:183
lldb_private::TypeCategoryImpl::RegexSynthContainerSP
SynthContainer::RegexMatchContainerSP RegexSynthContainerSP
Definition: TypeCategory.h:84
lldb_private::TypeCategoryImpl::ForEachCallbacks::SetWithRegex
std::enable_if< std::is_same< U, T >::value, ForEachCallbacks & >::type SetWithRegex(SummaryContainer::RegexMatchForEachCallback callback)
Definition: TypeCategory.h:112
lldb_private::TypeCategoryImpl::ForEachCallbacks::m_summary_exact
SummaryContainer::ExactMatchForEachCallback m_summary_exact
Definition: TypeCategory.h:177
lldb_private::TypeCategoryImpl::ForEachCallbacks::GetFormatRegexCallback
FormatContainer::RegexMatchForEachCallback GetFormatRegexCallback() const
Definition: TypeCategory.h:146
lldb_private::TypeCategoryImpl::GetDescription
std::string GetDescription()
Definition: TypeCategory.cpp:463
lldb_private::FormattersContainer::ValueSP
std::shared_ptr< ValueType > ValueSP
Definition: FormattersContainer.h:109
lldb_private::FormatterContainerPair::RegexMatchContainerSP
RegexMatchContainer::SharedPointer RegexMatchContainerSP
Definition: TypeCategory.h:37
lldb_private::TypeCategoryImpl::GetRegexTypeSyntheticsContainer
RegexSynthContainerSP GetRegexTypeSyntheticsContainer()
Definition: TypeCategory.h:265
lldb_private::ConstString
Definition: ConstString.h:40
lldb_private::TypeCategoryImpl::GetTypeNameSpecifierForSummaryAtIndex
lldb::TypeNameSpecifierImplSP GetTypeNameSpecifierForSummaryAtIndex(size_t index)
Definition: TypeCategory.cpp:384
lldb-enumerations.h
lldb_private::TypeCategoryImpl::RegexFormatContainerSP
FormatContainer::RegexMatchContainerSP RegexFormatContainerSP
Definition: TypeCategory.h:75
lldb_private::TypeCategoryImpl::GetNumLanguages
size_t GetNumLanguages()
Definition: TypeCategory.cpp:69
lldb_private::TypeCategoryImpl::Enable
void Enable(bool value, uint32_t position)
Definition: TypeCategory.cpp:455
lldb_private::TypeCategoryImpl::ForEachCallbacks::m_summary_regex
SummaryContainer::RegexMatchForEachCallback m_summary_regex
Definition: TypeCategory.h:178
lldb_private::TypeCategoryImpl::m_languages
std::vector< lldb::LanguageType > m_languages
Definition: TypeCategory.h:332
lldb_private::TypeCategoryImpl::FilterContainer
FormatterContainerPair< TypeFilterImpl > FilterContainer
Definition: TypeCategory.h:67
string
string(SUBSTRING ${p} 10 -1 pStripped) if($
Definition: Plugins/CMakeLists.txt:40
lldb_private::TypeCategoryImpl::ForEachCallbacks::SetWithRegex
std::enable_if< std::is_same< U, T >::value, ForEachCallbacks & >::type SetWithRegex(FilterContainer::RegexMatchForEachCallback callback)
Definition: TypeCategory.h:125
lldb_private::TypeCategoryImpl::ForEachCallbacks::GetSynthExactCallback
SynthContainer::ExactMatchForEachCallback GetSynthExactCallback() const
Definition: TypeCategory.h:166
lldb_private::TypeCategoryImpl::m_filter_cont
FilterContainer m_filter_cont
Definition: TypeCategory.h:321
lldb_private::FormatterContainerPair::ExactMatchContainer
FormattersContainer< FormatterImpl > ExactMatchContainer
Definition: TypeCategory.h:28
lldb_private::TypeCategoryImpl::m_synth_cont
SynthContainer m_synth_cont
Definition: TypeCategory.h:322
lldb_private::LanguageCategory
Definition: LanguageCategory.h:21
lldb_private::TypeCategoryImpl::ForEachCallbacks::GetFilterExactCallback
FilterContainer::ExactMatchForEachCallback GetFilterExactCallback() const
Definition: TypeCategory.h:159
lldb_private::TypeCategoryImpl::SharedPointer
std::shared_ptr< TypeCategoryImpl > SharedPointer
Definition: TypeCategory.h:316
lldb_private::TypeCategoryImpl::GetTypeSummariesContainer
SummaryContainerSP GetTypeSummariesContainer()
Definition: TypeCategory.h:214
lldb_private::TypeCategoryImpl::IsApplicable
bool IsApplicable(lldb::LanguageType lang)
Definition: TypeCategory.cpp:60
lldb_private::TypeCategoryImpl::Disable
void Disable()
Definition: TypeCategory.h:338
lldb_private::TypeCategoryImpl::ForEach
void ForEach(const ForEachCallbacks< T > &foreach)
Definition: TypeCategory.h:189
lldb_private::TypeCategoryImpl::ForEachCallbacks::GetSynthRegexCallback
SynthContainer::RegexMatchForEachCallback GetSynthRegexCallback() const
Definition: TypeCategory.h:169
lldb_private::TypeCategoryImpl::RegexSummaryContainerSP
SummaryContainer::RegexMatchContainerSP RegexSummaryContainerSP
Definition: TypeCategory.h:78
lldb_private::FormatterContainerPair::GetCount
uint32_t GetCount()
Definition: TypeCategory.h:54
lldb_private::TypeCategoryImpl::ForEachCallbacks::m_synth_regex
SynthContainer::RegexMatchForEachCallback m_synth_regex
Definition: TypeCategory.h:184
uint32_t
lldb_private::TypeCategoryImpl::GetFormatContainer
FormatContainer & GetFormatContainer()
Definition: TypeCategory.h:212
lldb_private::TypeCategoryImpl::GetLanguageAtIndex
lldb::LanguageType GetLanguageAtIndex(size_t idx)
Definition: TypeCategory.cpp:75
lldb_private::TypeCategoryImpl::ForEachCallbacks::GetSummaryExactCallback
SummaryContainer::ExactMatchForEachCallback GetSummaryExactCallback() const
Definition: TypeCategory.h:151
lldb_private::FormatterContainerPair::ExactMatchMap
TypeMatcher ExactMatchMap
Definition: TypeCategory.h:31
lldb_private::TypeCategoryImpl::GetSyntheticAtIndex
SynthContainer::MapValueType GetSyntheticAtIndex(size_t index)
Definition: TypeCategory.cpp:438
lldb_private::TypeCategoryImpl::SummaryContainer
FormatterContainerPair< TypeSummaryImpl > SummaryContainer
Definition: TypeCategory.h:66
lldb_private::TypeCategoryImpl::ForEachCallbacks::SetWithRegex
std::enable_if< std::is_same< U, T >::value, ForEachCallbacks & >::type SetWithRegex(SynthContainer::RegexMatchForEachCallback callback)
Definition: TypeCategory.h:138
lldb_private::TypeCategoryImpl::AddLanguage
void AddLanguage(lldb::LanguageType lang)
Definition: TypeCategory.cpp:81
lldb_private::TypeCategoryImpl::m_mutex
std::recursive_mutex m_mutex
Definition: TypeCategory.h:328
lldb_private::FormatterContainerPair::~FormatterContainerPair
~FormatterContainerPair()=default
lldb_private::TypeCategoryImpl::m_enabled
bool m_enabled
Definition: TypeCategory.h:324
lldb_private::FormatterContainerPair::FormatterContainerPair
FormatterContainerPair(IFormatChangeListener *clist)
Definition: TypeCategory.h:44
lldb_private::FormattersContainer::ForEachCallback
std::function< bool(const TypeMatcher &, const ValueSP &)> ForEachCallback
Definition: FormattersContainer.h:112
lldb_private::TypeCategoryImpl::GetCount
uint32_t GetCount(FormatCategoryItems items=ALL_ITEM_TYPES)
Definition: TypeCategory.cpp:196
lldb_private::TypeCategoryImpl::ForEachCallbacks::ForEachCallbacks
ForEachCallbacks()=default
UINT32_MAX
#define UINT32_MAX
Definition: lldb-defines.h:31
lldb_private::TypeCategoryImpl::GetFormatAtIndex
FormatContainer::MapValueType GetFormatAtIndex(size_t index)
Definition: TypeCategory.cpp:393
lldb_private::TypeCategoryImpl::m_enabled_position
uint32_t m_enabled_position
Definition: TypeCategory.h:334
uint16_t
lldb_private::TypeCategoryImpl::Get
bool Get(lldb::LanguageType lang, const FormattersMatchVector &candidates, lldb::TypeFormatImplSP &entry)
Definition: TypeCategory.cpp:85
lldb_private::TypeCategoryImpl::GetTypeFiltersContainer
FilterContainerSP GetTypeFiltersContainer()
Definition: TypeCategory.h:224
lldb_private::ConstString::GetCString
const char * GetCString() const
Get the string value as a C string.
Definition: ConstString.h:216
lldb_private::TypeCategoryImpl::ForEachCallbacks::GetSummaryRegexCallback
SummaryContainer::RegexMatchForEachCallback GetSummaryRegexCallback() const
Definition: TypeCategory.h:155
lldb_private::FormattersContainer::SharedPointer
std::shared_ptr< FormattersContainer< ValueType > > SharedPointer
Definition: FormattersContainer.h:114
lldb_private::TypeCategoryImpl::GetLastEnabledPosition
uint32_t GetLastEnabledPosition()
Definition: TypeCategory.h:342
lldb_private::TypeCategoryImpl::Clear
void Clear(FormatCategoryItems items=ALL_ITEM_TYPES)
Definition: TypeCategory.cpp:144
lldb_private::TypeCategoryImpl::m_summary_cont
SummaryContainer m_summary_cont
Definition: TypeCategory.h:320
lldb_private::FormatterContainerPair::RegexMatchContainer
FormattersContainer< FormatterImpl > RegexMatchContainer
Definition: TypeCategory.h:29
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb_private::TypeCategoryImpl::AnyMatches
bool AnyMatches(ConstString type_name, FormatCategoryItems items=ALL_ITEM_TYPES, bool only_enabled=true, const char **matching_category=nullptr, FormatCategoryItems *matching_type=nullptr)
Definition: TypeCategory.cpp:224
lldb_private::TypeCategoryImpl::ForEachCallbacks::SetExact
std::enable_if< std::is_same< U, T >::value, ForEachCallbacks & >::type SetExact(SynthContainer::ExactMatchForEachCallback callback)
Definition: TypeCategory.h:132
lldb_private::TypeCategoryImpl::m_name
ConstString m_name
Definition: TypeCategory.h:330
lldb_private::TypeCategoryImpl::ForEachCallbacks
Definition: TypeCategory.h:86
lldb_private::TypeCategoryImpl::GetSummaryContainer
SummaryContainer & GetSummaryContainer()
Definition: TypeCategory.h:222
lldb_private::TypeCategoryImpl::ForEachCallbacks::SetExact
std::enable_if< std::is_same< U, T >::value, ForEachCallbacks & >::type SetExact(SummaryContainer::ExactMatchForEachCallback callback)
Definition: TypeCategory.h:106
lldb_private::TypeCategoryImpl::GetTypeNameSpecifierForFormatAtIndex
lldb::TypeNameSpecifierImplSP GetTypeNameSpecifierForFormatAtIndex(size_t index)
Definition: TypeCategory.cpp:420
lldb_private::FormatterContainerPair::m_regex_sp
RegexMatchContainerSP m_regex_sp
Definition: TypeCategory.h:60
lldb_private::TypeCategoryImpl::ForEachCallbacks::GetFilterRegexCallback
FilterContainer::RegexMatchForEachCallback GetFilterRegexCallback() const
Definition: TypeCategory.h:162
lldb_private::FormatterContainerPair::RegexMatchForEachCallback
RegexMatchContainer::ForEachCallback RegexMatchForEachCallback
Definition: TypeCategory.h:42
lldb_private::TypeCategoryImpl
Definition: TypeCategory.h:63
lldb_private::TypeCategoryImpl::ForEachCallbacks::SetExact
std::enable_if< std::is_same< U, T >::value, ForEachCallbacks & >::type SetExact(FormatContainer::ExactMatchForEachCallback callback)
Definition: TypeCategory.h:93
lldb_private::TypeCategoryImpl::ForEachCallbacks::m_filter_regex
FilterContainer::RegexMatchForEachCallback m_filter_regex
Definition: TypeCategory.h:181
lldb_private::TypeCategoryImpl::SetEnabledPosition
void SetEnabledPosition(uint32_t p)
Definition: TypeCategory.h:344
FormattersContainer.h
lldb_private::TypeCategoryImpl::GetRegexTypeFiltersContainer
RegexFilterContainerSP GetRegexTypeFiltersContainer()
Definition: TypeCategory.h:228
lldb_private::FormatterContainerPair::ExactMatchContainerSP
ExactMatchContainer::SharedPointer ExactMatchContainerSP
Definition: TypeCategory.h:36
lldb_private::TypeCategoryImpl::m_format_cont
FormatContainer m_format_cont
Definition: TypeCategory.h:319
lldb_private::TypeCategoryImpl::GetFilterForType
FilterContainer::MapValueType GetFilterForType(lldb::TypeNameSpecifierImplSP type_sp)
Definition: TypeCategory.cpp:352
lldb_private::IFormatChangeListener
Definition: FormattersContainer.h:31
lldb_private::TypeCategoryImpl::ForEachCallbacks::~ForEachCallbacks
~ForEachCallbacks()=default
lldb_private::TypeCategoryImpl::GetSyntheticForType
SynthContainer::MapValueType GetSyntheticForType(lldb::TypeNameSpecifierImplSP type_sp)
Definition: TypeCategory.cpp:368
lldb_private::TypeCategoryImpl::GetFilterContainer
FilterContainer & GetFilterContainer()
Definition: TypeCategory.h:232
lldb_private::TypeCategoryImpl::FormatContainer
FormatterContainerPair< TypeFormatImpl > FormatContainer
Definition: TypeCategory.h:65
lldb_private::TypeCategoryImpl::ForEachCallbacks::GetFormatExactCallback
FormatContainer::ExactMatchForEachCallback GetFormatExactCallback() const
Definition: TypeCategory.h:143