1 //===-- SBValueList.cpp -----------------------------------------*- 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 
11 #include "lldb/API/SBValueList.h"
12 #include "lldb/API/SBValue.h"
13 #include "lldb/API/SBStream.h"
14 #include "lldb/Core/Log.h"
15 #include "lldb/Core/ValueObjectList.h"
16 
17 #include <vector>
18 
19 using namespace lldb;
20 using namespace lldb_private;
21 
22 class ValueListImpl
23 {
24 public:
25     ValueListImpl () :
26     m_values()
27     {
28     }
29 
30     ValueListImpl (const ValueListImpl& rhs) :
31     m_values(rhs.m_values)
32     {
33     }
34 
35     ValueListImpl&
36     operator = (const ValueListImpl& rhs)
37     {
38         if (this == &rhs)
39             return *this;
40         m_values = rhs.m_values;
41         return *this;
42     }
43 
44     uint32_t
45     GetSize ()
46     {
47         return m_values.size();
48     }
49 
50     void
51     Append (const lldb::SBValue& sb_value)
52     {
53         m_values.push_back(sb_value);
54     }
55 
56     void
57     Append (const ValueListImpl& list)
58     {
59         for (auto val : list.m_values)
60             Append (val);
61     }
62 
63     lldb::SBValue
64     GetValueAtIndex (uint32_t index)
65     {
66         if (index >= GetSize())
67             return lldb::SBValue();
68         return m_values[index];
69     }
70 
71     lldb::SBValue
72     FindValueByUID (lldb::user_id_t uid)
73     {
74         for (auto val : m_values)
75         {
76             if (val.IsValid() && val.GetID() == uid)
77                 return val;
78         }
79         return lldb::SBValue();
80     }
81 
82     lldb::SBValue
83     GetFirstValueByName (const char* name) const
84     {
85         if (name)
86         {
87             for (auto val : m_values)
88             {
89                 if (val.IsValid() && val.GetName() &&
90                     strcmp(name,val.GetName()) == 0)
91                     return val;
92             }
93         }
94         return lldb::SBValue();
95     }
96 
97 private:
98     std::vector<lldb::SBValue> m_values;
99 };
100 
101 SBValueList::SBValueList () :
102     m_opaque_ap ()
103 {
104 }
105 
106 SBValueList::SBValueList (const SBValueList &rhs) :
107     m_opaque_ap ()
108 {
109     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
110 
111     if (rhs.IsValid())
112         m_opaque_ap.reset (new ValueListImpl (*rhs));
113 
114     if (log)
115     {
116         log->Printf ("SBValueList::SBValueList (rhs.ap=%p) => this.ap = %p",
117                      static_cast<void*>(rhs.IsValid() ? rhs.m_opaque_ap.get() : NULL),
118                      static_cast<void*>(m_opaque_ap.get()));
119     }
120 }
121 
122 SBValueList::SBValueList (const ValueListImpl *lldb_object_ptr) :
123     m_opaque_ap ()
124 {
125     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
126 
127     if (lldb_object_ptr)
128         m_opaque_ap.reset (new ValueListImpl (*lldb_object_ptr));
129 
130     if (log)
131     {
132         log->Printf ("SBValueList::SBValueList (lldb_object_ptr=%p) => this.ap = %p",
133                      static_cast<const void*>(lldb_object_ptr),
134                      static_cast<void*>(m_opaque_ap.get()));
135     }
136 }
137 
138 SBValueList::~SBValueList ()
139 {
140 }
141 
142 bool
143 SBValueList::IsValid () const
144 {
145     return (m_opaque_ap.get() != NULL);
146 }
147 
148 void
149 SBValueList::Clear()
150 {
151     m_opaque_ap.reset();
152 }
153 
154 const SBValueList &
155 SBValueList::operator = (const SBValueList &rhs)
156 {
157     if (this != &rhs)
158     {
159         if (rhs.IsValid())
160             m_opaque_ap.reset (new ValueListImpl (*rhs));
161         else
162             m_opaque_ap.reset ();
163     }
164     return *this;
165 }
166 
167 ValueListImpl *
168 SBValueList::operator->()
169 {
170     return m_opaque_ap.get();
171 }
172 
173 ValueListImpl &
174 SBValueList::operator*()
175 {
176     return *m_opaque_ap;
177 }
178 
179 const ValueListImpl *
180 SBValueList::operator->() const
181 {
182     return m_opaque_ap.get();
183 }
184 
185 const ValueListImpl &
186 SBValueList::operator*() const
187 {
188     return *m_opaque_ap;
189 }
190 
191 void
192 SBValueList::Append (const SBValue &val_obj)
193 {
194     CreateIfNeeded ();
195     m_opaque_ap->Append (val_obj);
196 }
197 
198 void
199 SBValueList::Append (lldb::ValueObjectSP& val_obj_sp)
200 {
201     if (val_obj_sp)
202     {
203         CreateIfNeeded ();
204         m_opaque_ap->Append (SBValue(val_obj_sp));
205     }
206 }
207 
208 void
209 SBValueList::Append (const lldb::SBValueList& value_list)
210 {
211     if (value_list.IsValid())
212     {
213         CreateIfNeeded ();
214         m_opaque_ap->Append (*value_list);
215     }
216 }
217 
218 
219 SBValue
220 SBValueList::GetValueAtIndex (uint32_t idx) const
221 {
222     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
223 
224     //if (log)
225     //    log->Printf ("SBValueList::GetValueAtIndex (uint32_t idx) idx = %d", idx);
226 
227     SBValue sb_value;
228     if (m_opaque_ap.get())
229         sb_value = m_opaque_ap->GetValueAtIndex (idx);
230 
231     if (log)
232     {
233         SBStream sstr;
234         sb_value.GetDescription (sstr);
235         log->Printf ("SBValueList::GetValueAtIndex (this.ap=%p, idx=%d) => SBValue (this.sp = %p, '%s')",
236                      static_cast<void*>(m_opaque_ap.get()), idx,
237                      static_cast<void*>(sb_value.GetSP().get()), sstr.GetData());
238     }
239 
240     return sb_value;
241 }
242 
243 uint32_t
244 SBValueList::GetSize () const
245 {
246     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
247 
248     //if (log)
249     //    log->Printf ("SBValueList::GetSize ()");
250 
251     uint32_t size = 0;
252     if (m_opaque_ap.get())
253         size = m_opaque_ap->GetSize();
254 
255     if (log)
256         log->Printf ("SBValueList::GetSize (this.ap=%p) => %d",
257                      static_cast<void*>(m_opaque_ap.get()), size);
258 
259     return size;
260 }
261 
262 void
263 SBValueList::CreateIfNeeded ()
264 {
265     if (m_opaque_ap.get() == NULL)
266         m_opaque_ap.reset (new ValueListImpl());
267 }
268 
269 
270 SBValue
271 SBValueList::FindValueObjectByUID (lldb::user_id_t uid)
272 {
273     SBValue sb_value;
274     if (m_opaque_ap.get())
275         sb_value = m_opaque_ap->FindValueByUID(uid);
276     return sb_value;
277 }
278 
279 SBValue
280 SBValueList::GetFirstValueByName (const char* name) const
281 {
282     SBValue sb_value;
283     if (m_opaque_ap.get())
284         sb_value = m_opaque_ap->GetFirstValueByName(name);
285     return sb_value;
286 }
287 
288 void *
289 SBValueList::opaque_ptr ()
290 {
291     return m_opaque_ap.get();
292 }
293 
294 ValueListImpl &
295 SBValueList::ref ()
296 {
297     CreateIfNeeded();
298     return *m_opaque_ap.get();
299 }
300