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
| //===-- StructuredDataImpl.h ------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_StructuredDataImpl_h_
#define liblldb_StructuredDataImpl_h_
#include "lldb/Target/StructuredDataPlugin.h"
#include "lldb/Utility/Event.h"
#include "lldb/Utility/Status.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StructuredData.h"
#include "lldb/lldb-enumerations.h"
#include "lldb/lldb-forward.h"
#include "llvm/ADT/StringRef.h"
#pragma mark--
#pragma mark StructuredDataImpl
namespace lldb_private {
class StructuredDataImpl {
public:
StructuredDataImpl() : m_plugin_wp(), m_data_sp() {}
StructuredDataImpl(const StructuredDataImpl &rhs) = default;
StructuredDataImpl(const lldb::EventSP &event_sp)
: m_plugin_wp(
EventDataStructuredData::GetPluginFromEvent(event_sp.get())),
m_data_sp(EventDataStructuredData::GetObjectFromEvent(event_sp.get())) {
}
~StructuredDataImpl() = default;
StructuredDataImpl &operator=(const StructuredDataImpl &rhs) = default;
bool IsValid() const { return m_data_sp.get() != nullptr; }
void Clear() {
m_plugin_wp.reset();
m_data_sp.reset();
}
Status GetAsJSON(Stream &stream) const {
Status error;
if (!m_data_sp) {
error.SetErrorString("No structured data.");
return error;
}
llvm::json::OStream s(stream.AsRawOstream());
m_data_sp->Serialize(s);
return error;
}
Status GetDescription(Stream &stream) const {
Status error;
if (!m_data_sp) {
error.SetErrorString("Cannot pretty print structured data: "
"no data to print.");
return error;
}
// Grab the plugin.
auto plugin_sp = lldb::StructuredDataPluginSP(m_plugin_wp);
if (!plugin_sp) {
error.SetErrorString("Cannot pretty print structured data: "
"plugin doesn't exist.");
return error;
}
// Get the data's description.
return plugin_sp->GetDescription(m_data_sp, stream);
}
StructuredData::ObjectSP GetObjectSP() { return m_data_sp; }
void SetObjectSP(const StructuredData::ObjectSP &obj) { m_data_sp = obj; }
lldb::StructuredDataType GetType() const {
return (m_data_sp ? m_data_sp->GetType() :
lldb::eStructuredDataTypeInvalid);
}
size_t GetSize() const {
if (!m_data_sp)
return 0;
if (m_data_sp->GetType() == lldb::eStructuredDataTypeDictionary) {
auto dict = m_data_sp->GetAsDictionary();
return (dict->GetSize());
} else if (m_data_sp->GetType() == lldb::eStructuredDataTypeArray) {
auto array = m_data_sp->GetAsArray();
return (array->GetSize());
} else
return 0;
}
StructuredData::ObjectSP GetValueForKey(const char *key) const {
if (m_data_sp) {
auto dict = m_data_sp->GetAsDictionary();
if (dict)
return dict->GetValueForKey(llvm::StringRef(key));
}
return StructuredData::ObjectSP();
}
StructuredData::ObjectSP GetItemAtIndex(size_t idx) const {
if (m_data_sp) {
auto array = m_data_sp->GetAsArray();
if (array)
return array->GetItemAtIndex(idx);
}
return StructuredData::ObjectSP();
}
uint64_t GetIntegerValue(uint64_t fail_value = 0) const {
return (m_data_sp ? m_data_sp->GetIntegerValue(fail_value) : fail_value);
}
double GetFloatValue(double fail_value = 0.0) const {
return (m_data_sp ? m_data_sp->GetFloatValue(fail_value) : fail_value);
}
bool GetBooleanValue(bool fail_value = false) const {
return (m_data_sp ? m_data_sp->GetBooleanValue(fail_value) : fail_value);
}
size_t GetStringValue(char *dst, size_t dst_len) const {
if (!m_data_sp)
return 0;
llvm::StringRef result = m_data_sp->GetStringValue();
if (result.empty())
return 0;
if (!dst || !dst_len) {
char s[1];
return (::snprintf(s, 1, "%s", result.data()));
}
return (::snprintf(dst, dst_len, "%s", result.data()));
}
private:
lldb::StructuredDataPluginWP m_plugin_wp;
StructuredData::ObjectSP m_data_sp;
};
} // namespace lldb_private
#endif
|