aboutsummaryrefslogtreecommitdiff
path: root/include/lldb/Core/ValueObjectSyntheticFilter.h
blob: e12698f49bb1697a75ffb1c427043ca79e942a37 (plain) (blame)
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
178
179
180
181
182
183
184
185
//===-- ValueObjectSyntheticFilter.h -------------------------------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#ifndef liblldb_ValueObjectSyntheticFilter_h_
#define liblldb_ValueObjectSyntheticFilter_h_

// C Includes
// C++ Includes
#include <map>
#include <vector>
// Other libraries and framework includes
// Project includes
#include "lldb/Core/ValueObject.h"

namespace lldb_private {

//----------------------------------------------------------------------
// A ValueObject that obtains its children from some source other than
// real information
// This is currently used to implement Python-based children and filters
// but you can bind it to any source of synthetic information and have
// it behave accordingly
//----------------------------------------------------------------------
class ValueObjectSynthetic : public ValueObject
{
public:
    virtual
    ~ValueObjectSynthetic();

    virtual uint64_t
    GetByteSize();
    
    virtual ConstString
    GetTypeName();
    
    virtual ConstString
    GetQualifiedTypeName();
    
    virtual ConstString
    GetDisplayTypeName();

    virtual bool
    MightHaveChildren();

    virtual size_t
    CalculateNumChildren();

    virtual lldb::ValueType
    GetValueType() const;
    
    virtual lldb::ValueObjectSP
    GetChildAtIndex (size_t idx, bool can_create);
    
    virtual lldb::ValueObjectSP
    GetChildMemberWithName (const ConstString &name, bool can_create);
    
    virtual size_t
    GetIndexOfChildWithName (const ConstString &name);

    virtual lldb::ValueObjectSP
    GetDynamicValue (lldb::DynamicValueType valueType);
    
    virtual bool
    IsInScope ();
    
    virtual bool
    HasSyntheticValue()
    {
        return false;
    }
    
    virtual bool
    IsSynthetic() { return true; }
    
    virtual void
    CalculateSyntheticValue (bool use_synthetic)
    {
    }
    
    virtual bool
    IsDynamic ()
    {
        if (m_parent)
            return m_parent->IsDynamic();
        else
            return false;
    }
    
    virtual lldb::ValueObjectSP
    GetStaticValue ()
    {
        if (m_parent)
            return m_parent->GetStaticValue();
        else
            return GetSP();
    }
    
    virtual lldb::DynamicValueType
    GetDynamicValueType ()
    {
        if (m_parent)
            return m_parent->GetDynamicValueType();
        else
            return lldb::eNoDynamicValues;
    }

    virtual ValueObject *
    GetParent()
    {
        if (m_parent)
            return m_parent->GetParent();
        else
            return NULL;
    }

    virtual const ValueObject *
    GetParent() const
    {
        if (m_parent)
            return m_parent->GetParent();
        else
            return NULL;
    }
    
    virtual lldb::ValueObjectSP
    GetNonSyntheticValue ();
    
    virtual bool
    ResolveValue (Scalar &scalar)
    {
        if (m_parent)
            return m_parent->ResolveValue(scalar);
        return false;
    }
    
protected:
    virtual bool
    UpdateValue ();
    
    virtual ClangASTType
    GetClangTypeImpl ();
    
    virtual void
    CreateSynthFilter ();

    // we need to hold on to the SyntheticChildren because someone might delete the type binding while we are alive
    lldb::SyntheticChildrenSP m_synth_sp;
    std::unique_ptr<SyntheticChildrenFrontEnd> m_synth_filter_ap;
    
    typedef std::map<uint32_t, ValueObject*> ByIndexMap;
    typedef std::map<const char*, uint32_t> NameToIndexMap;
    
    typedef ByIndexMap::iterator ByIndexIterator;
    typedef NameToIndexMap::iterator NameToIndexIterator;

    ByIndexMap      m_children_byindex;
    NameToIndexMap  m_name_toindex;
    uint32_t        m_synthetic_children_count; // FIXME use the ValueObject's ChildrenManager instead of a special purpose solution
    
    ConstString     m_parent_type_name;

    LazyBool        m_might_have_children;
    
private:
    friend class ValueObject;
    ValueObjectSynthetic (ValueObject &parent, lldb::SyntheticChildrenSP filter);
    
    void
    CopyParentData ();
    
    //------------------------------------------------------------------
    // For ValueObject only
    //------------------------------------------------------------------
    DISALLOW_COPY_AND_ASSIGN (ValueObjectSynthetic);
};

} // namespace lldb_private

#endif  // liblldb_ValueObjectSyntheticFilter_h_