1 //===-- SBVariablesOptions.cpp --------------------------------------*- C++
2 //-*-===//
3 //
4 //                     The LLVM Compiler Infrastructure
5 //
6 // This file is distributed under the University of Illinois Open Source
7 // License. See LICENSE.TXT for details.
8 //
9 //===----------------------------------------------------------------------===//
10 
11 #include "lldb/API/SBVariablesOptions.h"
12 
13 using namespace lldb;
14 using namespace lldb_private;
15 
16 class VariablesOptionsImpl {
17 public:
18   VariablesOptionsImpl()
19       : m_include_arguments(false), m_include_recognized_arguments(false),
20         m_include_locals(false), m_include_statics(false),
21         m_in_scope_only(false), m_include_runtime_support_values(false),
22         m_use_dynamic(lldb::eNoDynamicValues) {}
23 
24   VariablesOptionsImpl(const VariablesOptionsImpl &) = default;
25 
26   ~VariablesOptionsImpl() = default;
27 
28   VariablesOptionsImpl &operator=(const VariablesOptionsImpl &) = default;
29 
30   bool GetIncludeArguments() const { return m_include_arguments; }
31 
32   void SetIncludeArguments(bool b) { m_include_arguments = b; }
33 
34   bool GetIncludeRecognizedArguments() const {
35     return m_include_recognized_arguments;
36   }
37 
38   void SetIncludeRecognizedArguments(bool b) {
39     m_include_recognized_arguments = b;
40   }
41 
42   bool GetIncludeLocals() const { return m_include_locals; }
43 
44   void SetIncludeLocals(bool b) { m_include_locals = b; }
45 
46   bool GetIncludeStatics() const { return m_include_statics; }
47 
48   void SetIncludeStatics(bool b) { m_include_statics = b; }
49 
50   bool GetInScopeOnly() const { return m_in_scope_only; }
51 
52   void SetInScopeOnly(bool b) { m_in_scope_only = b; }
53 
54   bool GetIncludeRuntimeSupportValues() const {
55     return m_include_runtime_support_values;
56   }
57 
58   void SetIncludeRuntimeSupportValues(bool b) {
59     m_include_runtime_support_values = b;
60   }
61 
62   lldb::DynamicValueType GetUseDynamic() const { return m_use_dynamic; }
63 
64   void SetUseDynamic(lldb::DynamicValueType d) { m_use_dynamic = d; }
65 
66 private:
67   bool m_include_arguments : 1;
68   bool m_include_recognized_arguments : 1;
69   bool m_include_locals : 1;
70   bool m_include_statics : 1;
71   bool m_in_scope_only : 1;
72   bool m_include_runtime_support_values : 1;
73   lldb::DynamicValueType m_use_dynamic;
74 };
75 
76 SBVariablesOptions::SBVariablesOptions()
77     : m_opaque_ap(new VariablesOptionsImpl()) {}
78 
79 SBVariablesOptions::SBVariablesOptions(const SBVariablesOptions &options)
80     : m_opaque_ap(new VariablesOptionsImpl(options.ref())) {}
81 
82 SBVariablesOptions &SBVariablesOptions::
83 operator=(const SBVariablesOptions &options) {
84   m_opaque_ap.reset(new VariablesOptionsImpl(options.ref()));
85   return *this;
86 }
87 
88 SBVariablesOptions::~SBVariablesOptions() = default;
89 
90 bool SBVariablesOptions::IsValid() const {
91   return m_opaque_ap.get() != nullptr;
92 }
93 
94 bool SBVariablesOptions::GetIncludeArguments() const {
95   return m_opaque_ap->GetIncludeArguments();
96 }
97 
98 void SBVariablesOptions::SetIncludeArguments(bool arguments) {
99   m_opaque_ap->SetIncludeArguments(arguments);
100 }
101 
102 bool SBVariablesOptions::GetIncludeRecognizedArguments() const {
103   return m_opaque_ap->GetIncludeRecognizedArguments();
104 }
105 
106 void SBVariablesOptions::SetIncludeRecognizedArguments(bool arguments) {
107   m_opaque_ap->SetIncludeRecognizedArguments(arguments);
108 }
109 
110 bool SBVariablesOptions::GetIncludeLocals() const {
111   return m_opaque_ap->GetIncludeLocals();
112 }
113 
114 void SBVariablesOptions::SetIncludeLocals(bool locals) {
115   m_opaque_ap->SetIncludeLocals(locals);
116 }
117 
118 bool SBVariablesOptions::GetIncludeStatics() const {
119   return m_opaque_ap->GetIncludeStatics();
120 }
121 
122 void SBVariablesOptions::SetIncludeStatics(bool statics) {
123   m_opaque_ap->SetIncludeStatics(statics);
124 }
125 
126 bool SBVariablesOptions::GetInScopeOnly() const {
127   return m_opaque_ap->GetInScopeOnly();
128 }
129 
130 void SBVariablesOptions::SetInScopeOnly(bool in_scope_only) {
131   m_opaque_ap->SetInScopeOnly(in_scope_only);
132 }
133 
134 bool SBVariablesOptions::GetIncludeRuntimeSupportValues() const {
135   return m_opaque_ap->GetIncludeRuntimeSupportValues();
136 }
137 
138 void SBVariablesOptions::SetIncludeRuntimeSupportValues(
139     bool runtime_support_values) {
140   m_opaque_ap->SetIncludeRuntimeSupportValues(runtime_support_values);
141 }
142 
143 lldb::DynamicValueType SBVariablesOptions::GetUseDynamic() const {
144   return m_opaque_ap->GetUseDynamic();
145 }
146 
147 void SBVariablesOptions::SetUseDynamic(lldb::DynamicValueType dynamic) {
148   m_opaque_ap->SetUseDynamic(dynamic);
149 }
150 
151 VariablesOptionsImpl *SBVariablesOptions::operator->() {
152   return m_opaque_ap.operator->();
153 }
154 
155 const VariablesOptionsImpl *SBVariablesOptions::operator->() const {
156   return m_opaque_ap.operator->();
157 }
158 
159 VariablesOptionsImpl *SBVariablesOptions::get() { return m_opaque_ap.get(); }
160 
161 VariablesOptionsImpl &SBVariablesOptions::ref() { return *m_opaque_ap; }
162 
163 const VariablesOptionsImpl &SBVariablesOptions::ref() const {
164   return *m_opaque_ap;
165 }
166 
167 SBVariablesOptions::SBVariablesOptions(VariablesOptionsImpl *lldb_object_ptr)
168     : m_opaque_ap(std::move(lldb_object_ptr)) {}
169 
170 void SBVariablesOptions::SetOptions(VariablesOptionsImpl *lldb_object_ptr) {
171   m_opaque_ap.reset(std::move(lldb_object_ptr));
172 }
173