contrib/llvm/tools/lldb/include/lldb/DataFormatters/TypeCategory.h

   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_TypeCategory_h_
  10 #define lldb_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
  21 #include "lldb/DataFormatters/FormatClasses.h"
  22 #include "lldb/DataFormatters/FormattersContainer.h"
  23
  24 namespace lldb_private {
  25
  26 template <typename FormatterImpl> class FormatterContainerPair {
  27 public:
  28   typedef FormattersContainer<ConstString, FormatterImpl> ExactMatchContainer;
  29   typedef FormattersContainer<lldb::RegularExpressionSP, FormatterImpl>
  30       RegexMatchContainer;
  31
  32   typedef typename ExactMatchContainer::MapType ExactMatchMap;
  33   typedef typename RegexMatchContainer::MapType RegexMatchMap;
  34
  35   typedef typename ExactMatchContainer::MapValueType MapValueType;
  36
  37   typedef typename ExactMatchContainer::SharedPointer ExactMatchContainerSP;
  38   typedef typename RegexMatchContainer::SharedPointer RegexMatchContainerSP;
  39
  40   typedef
  41       typename ExactMatchContainer::ForEachCallback ExactMatchForEachCallback;
  42   typedef
  43       typename RegexMatchContainer::ForEachCallback RegexMatchForEachCallback;
  44
  45   FormatterContainerPair(const char *exact_name, const char *regex_name,
  46                          IFormatChangeListener *clist)
  47       : m_exact_sp(new ExactMatchContainer(std::string(exact_name), clist)),
  48         m_regex_sp(new RegexMatchContainer(std::string(regex_name), clist)) {}
  49
  50   ~FormatterContainerPair() = default;
  51
  52   ExactMatchContainerSP GetExactMatch() const { return m_exact_sp; }
  53
  54   RegexMatchContainerSP GetRegexMatch() const { return m_regex_sp; }
  55
  56   uint32_t GetCount() {
  57     return GetExactMatch()->GetCount() + GetRegexMatch()->GetCount();
  58   }
  59
  60 private:
  61   ExactMatchContainerSP m_exact_sp;
  62   RegexMatchContainerSP m_regex_sp;
  63 };
  64
  65 class TypeCategoryImpl {
  66 private:
  67   typedef FormatterContainerPair<TypeFormatImpl> FormatContainer;
  68   typedef FormatterContainerPair<TypeSummaryImpl> SummaryContainer;
  69   typedef FormatterContainerPair<TypeFilterImpl> FilterContainer;
  70   typedef FormatterContainerPair<TypeValidatorImpl> ValidatorContainer;
  71   typedef FormatterContainerPair<SyntheticChildren> SynthContainer;
  72
  73 public:
  74   typedef uint16_t FormatCategoryItems;
  75   static const uint16_t ALL_ITEM_TYPES = UINT16_MAX;
  76
  77   typedef FormatContainer::ExactMatchContainerSP FormatContainerSP;
  78   typedef FormatContainer::RegexMatchContainerSP RegexFormatContainerSP;
  79
  80   typedef SummaryContainer::ExactMatchContainerSP SummaryContainerSP;
  81   typedef SummaryContainer::RegexMatchContainerSP RegexSummaryContainerSP;
  82
  83   typedef FilterContainer::ExactMatchContainerSP FilterContainerSP;
  84   typedef FilterContainer::RegexMatchContainerSP RegexFilterContainerSP;
  85
  86   typedef SynthContainer::ExactMatchContainerSP SynthContainerSP;
  87   typedef SynthContainer::RegexMatchContainerSP RegexSynthContainerSP;
  88
  89   typedef ValidatorContainer::ExactMatchContainerSP ValidatorContainerSP;
  90   typedef ValidatorContainer::RegexMatchContainerSP RegexValidatorContainerSP;
  91
  92   template <typename T> class ForEachCallbacks {
  93   public:
  94     ForEachCallbacks() = default;
  95     ~ForEachCallbacks() = default;
  96
  97     template <typename U = TypeFormatImpl>
  98     typename std::enable_if<std::is_same<U, T>::value, ForEachCallbacks &>::type
  99     SetExact(FormatContainer::ExactMatchForEachCallback callback) {
 100       m_format_exact = callback;
 101       return *this;
 102     }
 103     template <typename U = TypeFormatImpl>
 104     typename std::enable_if<std::is_same<U, T>::value, ForEachCallbacks &>::type
 105     SetWithRegex(FormatContainer::RegexMatchForEachCallback callback) {
 106       m_format_regex = callback;
 107       return *this;
 108     }
 109
 110     template <typename U = TypeSummaryImpl>
 111     typename std::enable_if<std::is_same<U, T>::value, ForEachCallbacks &>::type
 112     SetExact(SummaryContainer::ExactMatchForEachCallback callback) {
 113       m_summary_exact = callback;
 114       return *this;
 115     }
 116     template <typename U = TypeSummaryImpl>
 117     typename std::enable_if<std::is_same<U, T>::value, ForEachCallbacks &>::type
 118     SetWithRegex(SummaryContainer::RegexMatchForEachCallback callback) {
 119       m_summary_regex = callback;
 120       return *this;
 121     }
 122
 123     template <typename U = TypeFilterImpl>
 124     typename std::enable_if<std::is_same<U, T>::value, ForEachCallbacks &>::type
 125     SetExact(FilterContainer::ExactMatchForEachCallback callback) {
 126       m_filter_exact = callback;
 127       return *this;
 128     }
 129     template <typename U = TypeFilterImpl>
 130     typename std::enable_if<std::is_same<U, T>::value, ForEachCallbacks &>::type
 131     SetWithRegex(FilterContainer::RegexMatchForEachCallback callback) {
 132       m_filter_regex = callback;
 133       return *this;
 134     }
 135
 136     template <typename U = SyntheticChildren>
 137     typename std::enable_if<std::is_same<U, T>::value, ForEachCallbacks &>::type
 138     SetExact(SynthContainer::ExactMatchForEachCallback callback) {
 139       m_synth_exact = callback;
 140       return *this;
 141     }
 142     template <typename U = SyntheticChildren>
 143     typename std::enable_if<std::is_same<U, T>::value, ForEachCallbacks &>::type
 144     SetWithRegex(SynthContainer::RegexMatchForEachCallback callback) {
 145       m_synth_regex = callback;
 146       return *this;
 147     }
 148     template <typename U = TypeValidatorImpl>
 149     typename std::enable_if<std::is_same<U, T>::value, ForEachCallbacks &>::type
 150     SetExact(ValidatorContainer::ExactMatchForEachCallback callback) {
 151       m_validator_exact = callback;
 152       return *this;
 153     }
 154     template <typename U = TypeValidatorImpl>
 155     typename std::enable_if<std::is_same<U, T>::value, ForEachCallbacks &>::type
 156     SetWithRegex(ValidatorContainer::RegexMatchForEachCallback callback) {
 157       m_validator_regex = callback;
 158       return *this;
 159     }
 160
 161     FormatContainer::ExactMatchForEachCallback GetFormatExactCallback() const {
 162       return m_format_exact;
 163     }
 164     FormatContainer::RegexMatchForEachCallback GetFormatRegexCallback() const {
 165       return m_format_regex;
 166     }
 167
 168     SummaryContainer::ExactMatchForEachCallback
 169     GetSummaryExactCallback() const {
 170       return m_summary_exact;
 171     }
 172     SummaryContainer::RegexMatchForEachCallback
 173     GetSummaryRegexCallback() const {
 174       return m_summary_regex;
 175     }
 176
 177     FilterContainer::ExactMatchForEachCallback GetFilterExactCallback() const {
 178       return m_filter_exact;
 179     }
 180     FilterContainer::RegexMatchForEachCallback GetFilterRegexCallback() const {
 181       return m_filter_regex;
 182     }
 183
 184     SynthContainer::ExactMatchForEachCallback GetSynthExactCallback() const {
 185       return m_synth_exact;
 186     }
 187     SynthContainer::RegexMatchForEachCallback GetSynthRegexCallback() const {
 188       return m_synth_regex;
 189     }
 190
 191     ValidatorContainer::ExactMatchForEachCallback
 192     GetValidatorExactCallback() const {
 193       return m_validator_exact;
 194     }
 195     ValidatorContainer::RegexMatchForEachCallback
 196     GetValidatorRegexCallback() const {
 197       return m_validator_regex;
 198     }
 199
 200   private:
 201     FormatContainer::ExactMatchForEachCallback m_format_exact;
 202     FormatContainer::RegexMatchForEachCallback m_format_regex;
 203
 204     SummaryContainer::ExactMatchForEachCallback m_summary_exact;
 205     SummaryContainer::RegexMatchForEachCallback m_summary_regex;
 206
 207     FilterContainer::ExactMatchForEachCallback m_filter_exact;
 208     FilterContainer::RegexMatchForEachCallback m_filter_regex;
 209
 210     SynthContainer::ExactMatchForEachCallback m_synth_exact;
 211     SynthContainer::RegexMatchForEachCallback m_synth_regex;
 212
 213     ValidatorContainer::ExactMatchForEachCallback m_validator_exact;
 214     ValidatorContainer::RegexMatchForEachCallback m_validator_regex;
 215   };
 216
 217   TypeCategoryImpl(IFormatChangeListener *clist, ConstString name,
 218                    std::initializer_list<lldb::LanguageType> langs = {});
 219
 220   template <typename T> void ForEach(const ForEachCallbacks<T> &foreach) {
 221     GetTypeFormatsContainer()->ForEach(foreach.GetFormatExactCallback());
 222     GetRegexTypeFormatsContainer()->ForEach(foreach.GetFormatRegexCallback());
 223
 224     GetTypeSummariesContainer()->ForEach(foreach.GetSummaryExactCallback());
 225     GetRegexTypeSummariesContainer()->ForEach(
 226         foreach.GetSummaryRegexCallback());
 227
 228     GetTypeFiltersContainer()->ForEach(foreach.GetFilterExactCallback());
 229     GetRegexTypeFiltersContainer()->ForEach(foreach.GetFilterRegexCallback());
 230
 231     GetTypeSyntheticsContainer()->ForEach(foreach.GetSynthExactCallback());
 232     GetRegexTypeSyntheticsContainer()->ForEach(foreach.GetSynthRegexCallback());
 233
 234     GetTypeValidatorsContainer()->ForEach(foreach.GetValidatorExactCallback());
 235     GetRegexTypeValidatorsContainer()->ForEach(
 236         foreach.GetValidatorRegexCallback());
 237   }
 238
 239   FormatContainerSP GetTypeFormatsContainer() {
 240     return m_format_cont.GetExactMatch();
 241   }
 242
 243   RegexFormatContainerSP GetRegexTypeFormatsContainer() {
 244     return m_format_cont.GetRegexMatch();
 245   }
 246
 247   FormatContainer &GetFormatContainer() { return m_format_cont; }
 248
 249   SummaryContainerSP GetTypeSummariesContainer() {
 250     return m_summary_cont.GetExactMatch();
 251   }
 252
 253   RegexSummaryContainerSP GetRegexTypeSummariesContainer() {
 254     return m_summary_cont.GetRegexMatch();
 255   }
 256
 257   SummaryContainer &GetSummaryContainer() { return m_summary_cont; }
 258
 259   FilterContainerSP GetTypeFiltersContainer() {
 260     return m_filter_cont.GetExactMatch();
 261   }
 262
 263   RegexFilterContainerSP GetRegexTypeFiltersContainer() {
 264     return m_filter_cont.GetRegexMatch();
 265   }
 266
 267   FilterContainer &GetFilterContainer() { return m_filter_cont; }
 268
 269   FormatContainer::MapValueType
 270   GetFormatForType(lldb::TypeNameSpecifierImplSP type_sp);
 271
 272   SummaryContainer::MapValueType
 273   GetSummaryForType(lldb::TypeNameSpecifierImplSP type_sp);
 274
 275   FilterContainer::MapValueType
 276   GetFilterForType(lldb::TypeNameSpecifierImplSP type_sp);
 277
 278   SynthContainer::MapValueType
 279   GetSyntheticForType(lldb::TypeNameSpecifierImplSP type_sp);
 280
 281   ValidatorContainer::MapValueType
 282   GetValidatorForType(lldb::TypeNameSpecifierImplSP type_sp);
 283
 284   lldb::TypeNameSpecifierImplSP
 285   GetTypeNameSpecifierForFormatAtIndex(size_t index);
 286
 287   lldb::TypeNameSpecifierImplSP
 288   GetTypeNameSpecifierForSummaryAtIndex(size_t index);
 289
 290   FormatContainer::MapValueType GetFormatAtIndex(size_t index);
 291
 292   SummaryContainer::MapValueType GetSummaryAtIndex(size_t index);
 293
 294   FilterContainer::MapValueType GetFilterAtIndex(size_t index);
 295
 296   lldb::TypeNameSpecifierImplSP
 297   GetTypeNameSpecifierForFilterAtIndex(size_t index);
 298
 299   SynthContainerSP GetTypeSyntheticsContainer() {
 300     return m_synth_cont.GetExactMatch();
 301   }
 302
 303   RegexSynthContainerSP GetRegexTypeSyntheticsContainer() {
 304     return m_synth_cont.GetRegexMatch();
 305   }
 306
 307   SynthContainer &GetSyntheticsContainer() { return m_synth_cont; }
 308
 309   SynthContainer::MapValueType GetSyntheticAtIndex(size_t index);
 310
 311   lldb::TypeNameSpecifierImplSP
 312   GetTypeNameSpecifierForSyntheticAtIndex(size_t index);
 313
 314   ValidatorContainerSP GetTypeValidatorsContainer() {
 315     return m_validator_cont.GetExactMatch();
 316   }
 317
 318   RegexValidatorContainerSP GetRegexTypeValidatorsContainer() {
 319     return m_validator_cont.GetRegexMatch();
 320   }
 321
 322   ValidatorContainer::MapValueType GetValidatorAtIndex(size_t index);
 323
 324   lldb::TypeNameSpecifierImplSP
 325   GetTypeNameSpecifierForValidatorAtIndex(size_t index);
 326
 327   bool IsEnabled() const { return m_enabled; }
 328
 329   uint32_t GetEnabledPosition() {
 330     if (!m_enabled)
 331       return UINT32_MAX;
 332     else
 333       return m_enabled_position;
 334   }
 335
 336   bool Get(ValueObject &valobj, const FormattersMatchVector &candidates,
 337            lldb::TypeFormatImplSP &entry, uint32_t *reason = nullptr);
 338
 339   bool Get(ValueObject &valobj, const FormattersMatchVector &candidates,
 340            lldb::TypeSummaryImplSP &entry, uint32_t *reason = nullptr);
 341
 342   bool Get(ValueObject &valobj, const FormattersMatchVector &candidates,
 343            lldb::SyntheticChildrenSP &entry, uint32_t *reason = nullptr);
 344
 345   bool Get(ValueObject &valobj, const FormattersMatchVector &candidates,
 346            lldb::TypeValidatorImplSP &entry, uint32_t *reason = nullptr);
 347
 348   void Clear(FormatCategoryItems items = ALL_ITEM_TYPES);
 349
 350   bool Delete(ConstString name, FormatCategoryItems items = ALL_ITEM_TYPES);
 351
 352   uint32_t GetCount(FormatCategoryItems items = ALL_ITEM_TYPES);
 353
 354   const char *GetName() { return m_name.GetCString(); }
 355
 356   size_t GetNumLanguages();
 357
 358   lldb::LanguageType GetLanguageAtIndex(size_t idx);
 359
 360   void AddLanguage(lldb::LanguageType lang);
 361
 362   bool HasLanguage(lldb::LanguageType lang);
 363
 364   std::string GetDescription();
 365
 366   bool AnyMatches(ConstString type_name,
 367                   FormatCategoryItems items = ALL_ITEM_TYPES,
 368                   bool only_enabled = true,
 369                   const char **matching_category = nullptr,
 370                   FormatCategoryItems *matching_type = nullptr);
 371
 372   typedef std::shared_ptr<TypeCategoryImpl> SharedPointer;
 373
 374 private:
 375   FormatContainer m_format_cont;
 376   SummaryContainer m_summary_cont;
 377   FilterContainer m_filter_cont;
 378   SynthContainer m_synth_cont;
 379   ValidatorContainer m_validator_cont;
 380
 381   bool m_enabled;
 382
 383   IFormatChangeListener *m_change_listener;
 384
 385   std::recursive_mutex m_mutex;
 386
 387   ConstString m_name;
 388
 389   std::vector<lldb::LanguageType> m_languages;
 390
 391   uint32_t m_enabled_position;
 392
 393   void Enable(bool value, uint32_t position);
 394
 395   void Disable() { Enable(false, UINT32_MAX); }
 396
 397   bool IsApplicable(ValueObject &valobj);
 398
 399   uint32_t GetLastEnabledPosition() { return m_enabled_position; }
 400
 401   void SetEnabledPosition(uint32_t p) { m_enabled_position = p; }
 402
 403   friend class FormatManager;
 404   friend class LanguageCategory;
 405   friend class TypeCategoryMap;
 406
 407   friend class FormattersContainer<ConstString, TypeFormatImpl>;
 408   friend class FormattersContainer<lldb::RegularExpressionSP, TypeFormatImpl>;
 409
 410   friend class FormattersContainer<ConstString, TypeSummaryImpl>;
 411   friend class FormattersContainer<lldb::RegularExpressionSP, TypeSummaryImpl>;
 412
 413   friend class FormattersContainer<ConstString, TypeFilterImpl>;
 414   friend class FormattersContainer<lldb::RegularExpressionSP, TypeFilterImpl>;
 415
 416   friend class FormattersContainer<ConstString, ScriptedSyntheticChildren>;
 417   friend class FormattersContainer<lldb::RegularExpressionSP,
 418                                    ScriptedSyntheticChildren>;
 419
 420   friend class FormattersContainer<ConstString, TypeValidatorImpl>;
 421   friend class FormattersContainer<lldb::RegularExpressionSP,
 422                                    TypeValidatorImpl>;
 423 };
 424
 425 } // namespace lldb_private
 426
 427 #endif // lldb_TypeCategory_h_