1//===-- SBValueList.cpp -----------------------------------------*- 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#include "lldb/API/SBValueList.h"
10#include "SBReproducerPrivate.h"
11#include "lldb/API/SBStream.h"
12#include "lldb/API/SBValue.h"
13#include "lldb/Core/ValueObjectList.h"
14
15#include <vector>
16
17using namespace lldb;
18using namespace lldb_private;
19
20class ValueListImpl {
21public:
22  ValueListImpl() : m_values() {}
23
24  ValueListImpl(const ValueListImpl &rhs) : m_values(rhs.m_values) {}
25
26  ValueListImpl &operator=(const ValueListImpl &rhs) {
27    if (this == &rhs)
28      return *this;
29    m_values = rhs.m_values;
30    return *this;
31  }
32
33  uint32_t GetSize() { return m_values.size(); }
34
35  void Append(const lldb::SBValue &sb_value) { m_values.push_back(sb_value); }
36
37  void Append(const ValueListImpl &list) {
38    for (auto val : list.m_values)
39      Append(val);
40  }
41
42  lldb::SBValue GetValueAtIndex(uint32_t index) {
43    if (index >= GetSize())
44      return lldb::SBValue();
45    return m_values[index];
46  }
47
48  lldb::SBValue FindValueByUID(lldb::user_id_t uid) {
49    for (auto val : m_values) {
50      if (val.IsValid() && val.GetID() == uid)
51        return val;
52    }
53    return lldb::SBValue();
54  }
55
56  lldb::SBValue GetFirstValueByName(const char *name) const {
57    if (name) {
58      for (auto val : m_values) {
59        if (val.IsValid() && val.GetName() && strcmp(name, val.GetName()) == 0)
60          return val;
61      }
62    }
63    return lldb::SBValue();
64  }
65
66private:
67  std::vector<lldb::SBValue> m_values;
68};
69
70SBValueList::SBValueList() : m_opaque_up() {
71  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBValueList);
72}
73
74SBValueList::SBValueList(const SBValueList &rhs) : m_opaque_up() {
75  LLDB_RECORD_CONSTRUCTOR(SBValueList, (const lldb::SBValueList &), rhs);
76
77  if (rhs.IsValid())
78    m_opaque_up.reset(new ValueListImpl(*rhs));
79}
80
81SBValueList::SBValueList(const ValueListImpl *lldb_object_ptr) : m_opaque_up() {
82  if (lldb_object_ptr)
83    m_opaque_up.reset(new ValueListImpl(*lldb_object_ptr));
84}
85
86SBValueList::~SBValueList() {}
87
88bool SBValueList::IsValid() const {
89  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBValueList, IsValid);
90  return this->operator bool();
91}
92SBValueList::operator bool() const {
93  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBValueList, operator bool);
94
95  return (m_opaque_up != nullptr);
96}
97
98void SBValueList::Clear() {
99  LLDB_RECORD_METHOD_NO_ARGS(void, SBValueList, Clear);
100
101  m_opaque_up.reset();
102}
103
104const SBValueList &SBValueList::operator=(const SBValueList &rhs) {
105  LLDB_RECORD_METHOD(const lldb::SBValueList &,
106                     SBValueList, operator=,(const lldb::SBValueList &), rhs);
107
108  if (this != &rhs) {
109    if (rhs.IsValid())
110      m_opaque_up.reset(new ValueListImpl(*rhs));
111    else
112      m_opaque_up.reset();
113  }
114  return LLDB_RECORD_RESULT(*this);
115}
116
117ValueListImpl *SBValueList::operator->() { return m_opaque_up.get(); }
118
119ValueListImpl &SBValueList::operator*() { return *m_opaque_up; }
120
121const ValueListImpl *SBValueList::operator->() const {
122  return m_opaque_up.get();
123}
124
125const ValueListImpl &SBValueList::operator*() const { return *m_opaque_up; }
126
127void SBValueList::Append(const SBValue &val_obj) {
128  LLDB_RECORD_METHOD(void, SBValueList, Append, (const lldb::SBValue &),
129                     val_obj);
130
131  CreateIfNeeded();
132  m_opaque_up->Append(val_obj);
133}
134
135void SBValueList::Append(lldb::ValueObjectSP &val_obj_sp) {
136  if (val_obj_sp) {
137    CreateIfNeeded();
138    m_opaque_up->Append(SBValue(val_obj_sp));
139  }
140}
141
142void SBValueList::Append(const lldb::SBValueList &value_list) {
143  LLDB_RECORD_METHOD(void, SBValueList, Append, (const lldb::SBValueList &),
144                     value_list);
145
146  if (value_list.IsValid()) {
147    CreateIfNeeded();
148    m_opaque_up->Append(*value_list);
149  }
150}
151
152SBValue SBValueList::GetValueAtIndex(uint32_t idx) const {
153  LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValueList, GetValueAtIndex,
154                           (uint32_t), idx);
155
156
157  SBValue sb_value;
158  if (m_opaque_up)
159    sb_value = m_opaque_up->GetValueAtIndex(idx);
160
161  return LLDB_RECORD_RESULT(sb_value);
162}
163
164uint32_t SBValueList::GetSize() const {
165  LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBValueList, GetSize);
166
167  uint32_t size = 0;
168  if (m_opaque_up)
169    size = m_opaque_up->GetSize();
170
171  return size;
172}
173
174void SBValueList::CreateIfNeeded() {
175  if (m_opaque_up == nullptr)
176    m_opaque_up.reset(new ValueListImpl());
177}
178
179SBValue SBValueList::FindValueObjectByUID(lldb::user_id_t uid) {
180  LLDB_RECORD_METHOD(lldb::SBValue, SBValueList, FindValueObjectByUID,
181                     (lldb::user_id_t), uid);
182
183  SBValue sb_value;
184  if (m_opaque_up)
185    sb_value = m_opaque_up->FindValueByUID(uid);
186  return LLDB_RECORD_RESULT(sb_value);
187}
188
189SBValue SBValueList::GetFirstValueByName(const char *name) const {
190  LLDB_RECORD_METHOD_CONST(lldb::SBValue, SBValueList, GetFirstValueByName,
191                           (const char *), name);
192
193  SBValue sb_value;
194  if (m_opaque_up)
195    sb_value = m_opaque_up->GetFirstValueByName(name);
196  return LLDB_RECORD_RESULT(sb_value);
197}
198
199void *SBValueList::opaque_ptr() { return m_opaque_up.get(); }
200
201ValueListImpl &SBValueList::ref() {
202  CreateIfNeeded();
203  return *m_opaque_up;
204}
205
206namespace lldb_private {
207namespace repro {
208
209template <>
210void RegisterMethods<SBValueList>(Registry &R) {
211  LLDB_REGISTER_CONSTRUCTOR(SBValueList, ());
212  LLDB_REGISTER_CONSTRUCTOR(SBValueList, (const lldb::SBValueList &));
213  LLDB_REGISTER_METHOD_CONST(bool, SBValueList, IsValid, ());
214  LLDB_REGISTER_METHOD_CONST(bool, SBValueList, operator bool, ());
215  LLDB_REGISTER_METHOD(void, SBValueList, Clear, ());
216  LLDB_REGISTER_METHOD(const lldb::SBValueList &,
217                       SBValueList, operator=,(const lldb::SBValueList &));
218  LLDB_REGISTER_METHOD(void, SBValueList, Append, (const lldb::SBValue &));
219  LLDB_REGISTER_METHOD(void, SBValueList, Append,
220                       (const lldb::SBValueList &));
221  LLDB_REGISTER_METHOD_CONST(lldb::SBValue, SBValueList, GetValueAtIndex,
222                             (uint32_t));
223  LLDB_REGISTER_METHOD_CONST(uint32_t, SBValueList, GetSize, ());
224  LLDB_REGISTER_METHOD(lldb::SBValue, SBValueList, FindValueObjectByUID,
225                       (lldb::user_id_t));
226  LLDB_REGISTER_METHOD_CONST(lldb::SBValue, SBValueList, GetFirstValueByName,
227                             (const char *));
228}
229
230}
231}
232