TypeCategory.h revision 280031 
1//===-- TypeCategory.h -------------------------------------------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#ifndef lldb_TypeCategory_h_
11#define lldb_TypeCategory_h_
12
13// C Includes
14// C++ Includes
15
16// Other libraries and framework includes
17// Project includes
18#include "lldb/lldb-public.h"
19#include "lldb/lldb-enumerations.h"
20
21#include "lldb/DataFormatters/FormatClasses.h"
22#include "lldb/DataFormatters/FormattersContainer.h"
23
24namespace lldb_private {
25
26    template <typename FormatterImpl>
27    class FormatterContainerPair
28    {
29    public:
30        typedef FormattersContainer<ConstString, FormatterImpl> ExactMatchContainer;
31        typedef FormattersContainer<lldb::RegularExpressionSP, FormatterImpl> RegexMatchContainer;
32
33        typedef typename ExactMatchContainer::MapType ExactMatchMap;
34        typedef typename RegexMatchContainer::MapType RegexMatchMap;
35
36        typedef typename ExactMatchContainer::MapValueType MapValueType;
37
38        typedef typename ExactMatchContainer::SharedPointer ExactMatchContainerSP;
39        typedef typename RegexMatchContainer::SharedPointer RegexMatchContainerSP;
40
41        FormatterContainerPair (const char* exact_name,
42                                const char* regex_name,
43                                IFormatChangeListener* clist) :
44            m_exact_sp(new ExactMatchContainer(std::string(exact_name),clist)),
45            m_regex_sp(new RegexMatchContainer(std::string(regex_name),clist))
46        {
47        }
48
49        ~FormatterContainerPair () = default;
50
51        ExactMatchContainerSP
52        GetExactMatch () const
53        {
54            return m_exact_sp;
55        }
56
57        RegexMatchContainerSP
58        GetRegexMatch () const
59        {
60            return m_regex_sp;
61        }
62
63    private:
64        ExactMatchContainerSP m_exact_sp;
65        RegexMatchContainerSP m_regex_sp;
66    };
67
68    class TypeCategoryImpl
69    {
70    private:
71        typedef FormatterContainerPair<TypeFormatImpl> FormatContainer;
72        typedef FormatterContainerPair<TypeSummaryImpl> SummaryContainer;
73        typedef FormatterContainerPair<TypeFilterImpl> FilterContainer;
74        typedef FormatterContainerPair<TypeValidatorImpl> ValidatorContainer;
75
76#ifndef LLDB_DISABLE_PYTHON
77        typedef FormatterContainerPair<ScriptedSyntheticChildren> SynthContainer;
78#endif // #ifndef LLDB_DISABLE_PYTHON
79
80    public:
81
82        typedef uint16_t FormatCategoryItems;
83        static const uint16_t ALL_ITEM_TYPES = UINT16_MAX;
84
85        typedef FormatContainer::ExactMatchContainerSP FormatContainerSP;
86        typedef FormatContainer::RegexMatchContainerSP RegexFormatContainerSP;
87
88        typedef SummaryContainer::ExactMatchContainerSP SummaryContainerSP;
89        typedef SummaryContainer::RegexMatchContainerSP RegexSummaryContainerSP;
90
91        typedef FilterContainer::ExactMatchContainerSP FilterContainerSP;
92        typedef FilterContainer::RegexMatchContainerSP RegexFilterContainerSP;
93#ifndef LLDB_DISABLE_PYTHON
94        typedef SynthContainer::ExactMatchContainerSP SynthContainerSP;
95        typedef SynthContainer::RegexMatchContainerSP RegexSynthContainerSP;
96#endif // #ifndef LLDB_DISABLE_PYTHON
97
98        typedef ValidatorContainer::ExactMatchContainerSP ValidatorContainerSP;
99        typedef ValidatorContainer::RegexMatchContainerSP RegexValidatorContainerSP;
100
101        TypeCategoryImpl (IFormatChangeListener* clist,
102                          ConstString name);
103
104        FormatContainerSP
105        GetTypeFormatsContainer ()
106        {
107            return m_format_cont.GetExactMatch();
108        }
109
110        RegexFormatContainerSP
111        GetRegexTypeFormatsContainer ()
112        {
113            return m_format_cont.GetRegexMatch();
114        }
115
116        SummaryContainerSP
117        GetTypeSummariesContainer ()
118        {
119            return m_summary_cont.GetExactMatch();
120        }
121
122        RegexSummaryContainerSP
123        GetRegexTypeSummariesContainer ()
124        {
125            return m_summary_cont.GetRegexMatch();
126        }
127
128        FilterContainerSP
129        GetTypeFiltersContainer ()
130        {
131            return m_filter_cont.GetExactMatch();
132        }
133
134        RegexFilterContainerSP
135        GetRegexTypeFiltersContainer ()
136        {
137            return m_filter_cont.GetRegexMatch();
138        }
139
140        FormatContainer::MapValueType
141        GetFormatForType (lldb::TypeNameSpecifierImplSP type_sp);
142
143        SummaryContainer::MapValueType
144        GetSummaryForType (lldb::TypeNameSpecifierImplSP type_sp);
145
146        FilterContainer::MapValueType
147        GetFilterForType (lldb::TypeNameSpecifierImplSP type_sp);
148
149#ifndef LLDB_DISABLE_PYTHON
150        SynthContainer::MapValueType
151        GetSyntheticForType (lldb::TypeNameSpecifierImplSP type_sp);
152#endif
153
154        ValidatorContainer::MapValueType
155        GetValidatorForType (lldb::TypeNameSpecifierImplSP type_sp);
156
157        lldb::TypeNameSpecifierImplSP
158        GetTypeNameSpecifierForFormatAtIndex (size_t index);
159
160        lldb::TypeNameSpecifierImplSP
161        GetTypeNameSpecifierForSummaryAtIndex (size_t index);
162
163        FormatContainer::MapValueType
164        GetFormatAtIndex (size_t index);
165
166        SummaryContainer::MapValueType
167        GetSummaryAtIndex (size_t index);
168
169        FilterContainer::MapValueType
170        GetFilterAtIndex (size_t index);
171
172        lldb::TypeNameSpecifierImplSP
173        GetTypeNameSpecifierForFilterAtIndex (size_t index);
174
175#ifndef LLDB_DISABLE_PYTHON
176        SynthContainerSP
177        GetTypeSyntheticsContainer ()
178        {
179            return m_synth_cont.GetExactMatch();
180        }
181
182        RegexSynthContainerSP
183        GetRegexTypeSyntheticsContainer ()
184        {
185            return m_synth_cont.GetRegexMatch();
186        }
187
188        SynthContainer::MapValueType
189        GetSyntheticAtIndex (size_t index);
190
191        lldb::TypeNameSpecifierImplSP
192        GetTypeNameSpecifierForSyntheticAtIndex (size_t index);
193#endif // #ifndef LLDB_DISABLE_PYTHON
194
195        ValidatorContainerSP
196        GetTypeValidatorsContainer ()
197        {
198            return m_validator_cont.GetExactMatch();
199        }
200
201        RegexValidatorContainerSP
202        GetRegexTypeValidatorsContainer ()
203        {
204            return m_validator_cont.GetRegexMatch();
205        }
206
207        ValidatorContainer::MapValueType
208        GetValidatorAtIndex (size_t index);
209
210        lldb::TypeNameSpecifierImplSP
211        GetTypeNameSpecifierForValidatorAtIndex (size_t index);
212
213        bool
214        IsEnabled () const
215        {
216            return m_enabled;
217        }
218
219        uint32_t
220        GetEnabledPosition()
221        {
222            if (m_enabled == false)
223                return UINT32_MAX;
224            else
225                return m_enabled_position;
226        }
227
228        bool
229        Get (ValueObject& valobj,
230             const FormattersMatchVector& candidates,
231             lldb::TypeFormatImplSP& entry,
232             uint32_t* reason = NULL);
233
234        bool
235        Get (ValueObject& valobj,
236             const FormattersMatchVector& candidates,
237             lldb::TypeSummaryImplSP& entry,
238             uint32_t* reason = NULL);
239
240        bool
241        Get (ValueObject& valobj,
242             const FormattersMatchVector& candidates,
243             lldb::SyntheticChildrenSP& entry,
244             uint32_t* reason = NULL);
245
246        bool
247        Get (ValueObject& valobj,
248             const FormattersMatchVector& candidates,
249             lldb::TypeValidatorImplSP& entry,
250             uint32_t* reason = NULL);
251
252        void
253        Clear (FormatCategoryItems items = ALL_ITEM_TYPES);
254
255        bool
256        Delete (ConstString name,
257                FormatCategoryItems items = ALL_ITEM_TYPES);
258
259        uint32_t
260        GetCount (FormatCategoryItems items = ALL_ITEM_TYPES);
261
262        const char*
263        GetName ()
264        {
265            return m_name.GetCString();
266        }
267
268        bool
269        AnyMatches (ConstString type_name,
270                    FormatCategoryItems items = ALL_ITEM_TYPES,
271                    bool only_enabled = true,
272                    const char** matching_category = NULL,
273                    FormatCategoryItems* matching_type = NULL);
274
275        typedef std::shared_ptr<TypeCategoryImpl> SharedPointer;
276
277    private:
278        FormatContainer m_format_cont;
279        SummaryContainer m_summary_cont;
280        FilterContainer m_filter_cont;
281#ifndef LLDB_DISABLE_PYTHON
282        SynthContainer m_synth_cont;
283#endif // #ifndef LLDB_DISABLE_PYTHON
284        ValidatorContainer m_validator_cont;
285
286        bool m_enabled;
287
288        IFormatChangeListener* m_change_listener;
289
290        Mutex m_mutex;
291
292        ConstString m_name;
293
294        uint32_t m_enabled_position;
295
296        void
297        Enable (bool value, uint32_t position);
298
299        void
300        Disable ()
301        {
302            Enable(false, UINT32_MAX);
303        }
304
305        uint32_t
306        GetLastEnabledPosition ()
307        {
308            return m_enabled_position;
309        }
310
311        void
312        SetEnabledPosition (uint32_t p)
313        {
314            m_enabled_position = p;
315        }
316
317        friend class TypeCategoryMap;
318
319        friend class FormattersContainer<ConstString, TypeFormatImpl>;
320        friend class FormattersContainer<lldb::RegularExpressionSP, TypeFormatImpl>;
321
322        friend class FormattersContainer<ConstString, TypeSummaryImpl>;
323        friend class FormattersContainer<lldb::RegularExpressionSP, TypeSummaryImpl>;
324
325        friend class FormattersContainer<ConstString, TypeFilterImpl>;
326        friend class FormattersContainer<lldb::RegularExpressionSP, TypeFilterImpl>;
327
328#ifndef LLDB_DISABLE_PYTHON
329        friend class FormattersContainer<ConstString, ScriptedSyntheticChildren>;
330        friend class FormattersContainer<lldb::RegularExpressionSP, ScriptedSyntheticChildren>;
331#endif // #ifndef LLDB_DISABLE_PYTHON
332
333        friend class FormattersContainer<ConstString, TypeValidatorImpl>;
334        friend class FormattersContainer<lldb::RegularExpressionSP, TypeValidatorImpl>;
335    };
336
337} // namespace lldb_private
338
339#endif	// lldb_TypeCategory_h_
340