include/lldb/API/SBTypeCategory.h


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177

//===-- SBTypeCategory.h --------------------------------------------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#ifndef LLDB_SBTypeCategory_h_
#define LLDB_SBTypeCategory_h_

#include "lldb/API/SBDefines.h"

namespace lldb {
    
    class LLDB_API SBTypeCategory
    {
    public:
        
        SBTypeCategory();
        
        SBTypeCategory (const lldb::SBTypeCategory &rhs);
        
        ~SBTypeCategory ();
        
        bool
        IsValid() const;
        
        bool
        GetEnabled ();
        
        void
        SetEnabled (bool);
        
        const char*
        GetName();
        
        lldb::LanguageType
        GetLanguageAtIndex (uint32_t idx);
        
        uint32_t
        GetNumLanguages ();
        
        void
        AddLanguage (lldb::LanguageType language);
        
        bool
        GetDescription (lldb::SBStream &description, 
                        lldb::DescriptionLevel description_level);
        
        uint32_t
        GetNumFormats ();
        
        uint32_t
        GetNumSummaries ();
        
        uint32_t
        GetNumFilters ();
        
#ifndef LLDB_DISABLE_PYTHON
        uint32_t
        GetNumSynthetics ();
#endif
        
        SBTypeNameSpecifier
        GetTypeNameSpecifierForFilterAtIndex (uint32_t);
        
        SBTypeNameSpecifier
        GetTypeNameSpecifierForFormatAtIndex (uint32_t);
        
        SBTypeNameSpecifier
        GetTypeNameSpecifierForSummaryAtIndex (uint32_t);

#ifndef LLDB_DISABLE_PYTHON
        SBTypeNameSpecifier
        GetTypeNameSpecifierForSyntheticAtIndex (uint32_t);
#endif
        
        SBTypeFilter
        GetFilterForType (SBTypeNameSpecifier);

        SBTypeFormat
        GetFormatForType (SBTypeNameSpecifier);
        
#ifndef LLDB_DISABLE_PYTHON
        SBTypeSummary
        GetSummaryForType (SBTypeNameSpecifier);
#endif

#ifndef LLDB_DISABLE_PYTHON
        SBTypeSynthetic
        GetSyntheticForType (SBTypeNameSpecifier);
#endif
        
#ifndef LLDB_DISABLE_PYTHON
        SBTypeFilter
        GetFilterAtIndex (uint32_t);
#endif
        
        SBTypeFormat
        GetFormatAtIndex (uint32_t);
        
#ifndef LLDB_DISABLE_PYTHON
        SBTypeSummary
        GetSummaryAtIndex (uint32_t);
#endif
        
#ifndef LLDB_DISABLE_PYTHON
        SBTypeSynthetic
        GetSyntheticAtIndex (uint32_t);
#endif
        
        bool
        AddTypeFormat (SBTypeNameSpecifier,
                       SBTypeFormat);
        
        bool
        DeleteTypeFormat (SBTypeNameSpecifier);
        
#ifndef LLDB_DISABLE_PYTHON
        bool
        AddTypeSummary (SBTypeNameSpecifier,
                        SBTypeSummary);
#endif
        
        bool
        DeleteTypeSummary (SBTypeNameSpecifier);
        
        bool
        AddTypeFilter (SBTypeNameSpecifier,
                       SBTypeFilter);
        
        bool
        DeleteTypeFilter (SBTypeNameSpecifier);
        
#ifndef LLDB_DISABLE_PYTHON
        bool
        AddTypeSynthetic (SBTypeNameSpecifier,
                          SBTypeSynthetic);
        
        bool
        DeleteTypeSynthetic (SBTypeNameSpecifier);
#endif
        
        lldb::SBTypeCategory &
        operator = (const lldb::SBTypeCategory &rhs);
        
        bool
        operator == (lldb::SBTypeCategory &rhs);
        
        bool
        operator != (lldb::SBTypeCategory &rhs);
        
    protected:
        friend class SBDebugger;
        
        lldb::TypeCategoryImplSP
        GetSP ();
        
        void
        SetSP (const lldb::TypeCategoryImplSP &typecategory_impl_sp);    
        
        TypeCategoryImplSP m_opaque_sp;
        
        SBTypeCategory (const lldb::TypeCategoryImplSP &);
        
        SBTypeCategory (const char*);
        
        bool
        IsDefaultCategory();
        
    };
    
} // namespace lldb

#endif // LLDB_SBTypeCategory_h_