1 //===-- SBThreadCollection.cpp --------------------------------------------===//
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/SBThreadCollection.h"
10 #include "SBReproducerPrivate.h"
11 #include "lldb/API/SBThread.h"
12 #include "lldb/Target/ThreadList.h"
13 
14 using namespace lldb;
15 using namespace lldb_private;
16 
17 SBThreadCollection::SBThreadCollection() : m_opaque_sp() {
18   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBThreadCollection);
19 }
20 
21 SBThreadCollection::SBThreadCollection(const SBThreadCollection &rhs)
22     : m_opaque_sp(rhs.m_opaque_sp) {
23   LLDB_RECORD_CONSTRUCTOR(SBThreadCollection,
24                           (const lldb::SBThreadCollection &), rhs);
25 }
26 
27 const SBThreadCollection &SBThreadCollection::
28 operator=(const SBThreadCollection &rhs) {
29   LLDB_RECORD_METHOD(
30       const lldb::SBThreadCollection &,
31       SBThreadCollection, operator=,(const lldb::SBThreadCollection &), rhs);
32 
33   if (this != &rhs)
34     m_opaque_sp = rhs.m_opaque_sp;
35   return LLDB_RECORD_RESULT(*this);
36 }
37 
38 SBThreadCollection::SBThreadCollection(const ThreadCollectionSP &threads)
39     : m_opaque_sp(threads) {}
40 
41 SBThreadCollection::~SBThreadCollection() = default;
42 
43 void SBThreadCollection::SetOpaque(const lldb::ThreadCollectionSP &threads) {
44   m_opaque_sp = threads;
45 }
46 
47 lldb_private::ThreadCollection *SBThreadCollection::get() const {
48   return m_opaque_sp.get();
49 }
50 
51 lldb_private::ThreadCollection *SBThreadCollection::operator->() const {
52   return m_opaque_sp.operator->();
53 }
54 
55 lldb::ThreadCollectionSP &SBThreadCollection::operator*() {
56   return m_opaque_sp;
57 }
58 
59 const lldb::ThreadCollectionSP &SBThreadCollection::operator*() const {
60   return m_opaque_sp;
61 }
62 
63 bool SBThreadCollection::IsValid() const {
64   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadCollection, IsValid);
65   return this->operator bool();
66 }
67 SBThreadCollection::operator bool() const {
68   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBThreadCollection, operator bool);
69 
70   return m_opaque_sp.get() != nullptr;
71 }
72 
73 size_t SBThreadCollection::GetSize() {
74   LLDB_RECORD_METHOD_NO_ARGS(size_t, SBThreadCollection, GetSize);
75 
76   if (m_opaque_sp)
77     return m_opaque_sp->GetSize();
78   return 0;
79 }
80 
81 SBThread SBThreadCollection::GetThreadAtIndex(size_t idx) {
82   LLDB_RECORD_METHOD(lldb::SBThread, SBThreadCollection, GetThreadAtIndex,
83                      (size_t), idx);
84 
85   SBThread thread;
86   if (m_opaque_sp && idx < m_opaque_sp->GetSize())
87     thread = m_opaque_sp->GetThreadAtIndex(idx);
88   return LLDB_RECORD_RESULT(thread);
89 }
90 
91 namespace lldb_private {
92 namespace repro {
93 
94 template <>
95 void RegisterMethods<SBThreadCollection>(Registry &R) {
96   LLDB_REGISTER_CONSTRUCTOR(SBThreadCollection, ());
97   LLDB_REGISTER_CONSTRUCTOR(SBThreadCollection,
98                             (const lldb::SBThreadCollection &));
99   LLDB_REGISTER_METHOD(
100       const lldb::SBThreadCollection &,
101       SBThreadCollection, operator=,(const lldb::SBThreadCollection &));
102   LLDB_REGISTER_METHOD_CONST(bool, SBThreadCollection, IsValid, ());
103   LLDB_REGISTER_METHOD_CONST(bool, SBThreadCollection, operator bool, ());
104   LLDB_REGISTER_METHOD(size_t, SBThreadCollection, GetSize, ());
105   LLDB_REGISTER_METHOD(lldb::SBThread, SBThreadCollection, GetThreadAtIndex,
106                        (size_t));
107 }
108 
109 }
110 }
111