Branch data Line data Source code
1 : : // Copyright 2014 BitPay Inc.
2 : : // Copyright 2015 Bitcoin Core Developers
3 : : // Distributed under the MIT software license, see the accompanying
4 : : // file COPYING or https://opensource.org/licenses/mit-license.php.
5 : :
6 : : #include <univalue.h>
7 : :
8 : : #include <iomanip>
9 : : #include <map>
10 : : #include <memory>
11 : : #include <sstream>
12 : : #include <string>
13 : : #include <utility>
14 : : #include <vector>
15 : :
16 : : const UniValue NullUniValue;
17 : :
18 : 10247601 : void UniValue::clear()
19 : : {
20 : 10247601 : typ = VNULL;
21 : 10247601 : val.clear();
22 : 10247601 : keys.clear();
23 : 10247601 : values.clear();
24 : 10247601 : }
25 : :
26 : 197515 : void UniValue::setNull()
27 : : {
28 : 197515 : clear();
29 : 197515 : }
30 : :
31 : 5655751 : void UniValue::setBool(bool val_)
32 : : {
33 : 5655751 : clear();
34 : 5655751 : typ = VBOOL;
35 [ + + ]: 5655751 : if (val_)
36 : 5261151 : val = "1";
37 : 5655751 : }
38 : :
39 : 1547903 : static bool validNumStr(const std::string& s)
40 : : {
41 [ - + ]: 1547903 : std::string tokenVal;
42 : 1547903 : unsigned int consumed;
43 [ - + + - ]: 1547903 : enum jtokentype tt = getJsonToken(tokenVal, consumed, s.data(), s.data() + s.size());
44 : 1547903 : return (tt == JTOK_NUMBER);
45 : 1547903 : }
46 : :
47 : 1547903 : void UniValue::setNumStr(std::string str)
48 : : {
49 [ + + ]: 1547903 : if (!validNumStr(str)) {
50 [ + - + - ]: 3 : throw std::runtime_error{"The string '" + str + "' is not a valid JSON number"};
51 : : }
52 : :
53 : 1547902 : clear();
54 : 1547902 : typ = VNUM;
55 : 1547902 : val = std::move(str);
56 : 1547902 : }
57 : :
58 : 725944 : void UniValue::setInt(uint64_t val_)
59 : : {
60 : 725944 : std::ostringstream oss;
61 : :
62 [ + - ]: 725944 : oss << val_;
63 : :
64 [ + - + - ]: 1451888 : return setNumStr(oss.str());
65 : 725944 : }
66 : :
67 : 747214 : void UniValue::setInt(int64_t val_)
68 : : {
69 : 747214 : std::ostringstream oss;
70 : :
71 [ + - ]: 747214 : oss << val_;
72 : :
73 [ + - + - ]: 1494428 : return setNumStr(oss.str());
74 : 747214 : }
75 : :
76 : 74709 : void UniValue::setFloat(double val_)
77 : : {
78 : 74709 : std::ostringstream oss;
79 : :
80 [ + - ]: 74709 : oss << std::setprecision(16) << val_;
81 : :
82 [ + - + - ]: 149418 : return setNumStr(oss.str());
83 : 74709 : }
84 : :
85 : 2457297 : void UniValue::setStr(std::string str)
86 : : {
87 : 2457297 : clear();
88 : 2457297 : typ = VSTR;
89 : 2457297 : val = std::move(str);
90 : 2457297 : }
91 : :
92 : 756 : void UniValue::setArray()
93 : : {
94 : 756 : clear();
95 : 756 : typ = VARR;
96 : 756 : }
97 : :
98 : 193824 : void UniValue::setObject()
99 : : {
100 : 193824 : clear();
101 : 193824 : typ = VOBJ;
102 : 193824 : }
103 : :
104 : 824533 : void UniValue::push_back(UniValue val)
105 : : {
106 : 824533 : checkType(VARR);
107 : :
108 : 824532 : values.push_back(std::move(val));
109 : 824532 : }
110 : :
111 : 2 : void UniValue::push_backV(const std::vector<UniValue>& vec)
112 : : {
113 : 2 : checkType(VARR);
114 : :
115 : 1 : values.insert(values.end(), vec.begin(), vec.end());
116 : 1 : }
117 : :
118 : 4321859 : void UniValue::pushKVEnd(std::string key, UniValue val)
119 : : {
120 : 4321859 : checkType(VOBJ);
121 : :
122 : 4321858 : keys.push_back(std::move(key));
123 : 4321858 : values.push_back(std::move(val));
124 : 4321858 : }
125 : :
126 : 4301197 : void UniValue::pushKV(std::string key, UniValue val)
127 : : {
128 : 4301197 : checkType(VOBJ);
129 : :
130 : 4301196 : size_t idx;
131 [ + + ]: 4301196 : if (findKey(key, idx))
132 : 10 : values[idx] = std::move(val);
133 : : else
134 [ + - ]: 8602372 : pushKVEnd(std::move(key), std::move(val));
135 : 4301196 : }
136 : :
137 : 10269 : void UniValue::pushKVs(UniValue obj)
138 : : {
139 : 10269 : checkType(VOBJ);
140 : 10268 : obj.checkType(VOBJ);
141 : :
142 [ - + + + ]: 25992 : for (size_t i = 0; i < obj.keys.size(); i++)
143 [ + - + - ]: 31448 : pushKVEnd(std::move(obj.keys.at(i)), std::move(obj.values.at(i)));
144 : 10268 : }
145 : :
146 : 388223 : void UniValue::getObjMap(std::map<std::string,UniValue>& kv) const
147 : : {
148 [ + - ]: 388223 : if (typ != VOBJ)
149 : : return;
150 : :
151 : 388223 : kv.clear();
152 [ - + + + ]: 3727489 : for (size_t i = 0; i < keys.size(); i++)
153 : 3339266 : kv[keys[i]] = values[i];
154 : : }
155 : :
156 : 4554545 : bool UniValue::findKey(const std::string& key, size_t& retIdx) const
157 : : {
158 [ - + + + ]: 36220339 : for (size_t i = 0; i < keys.size(); i++) {
159 [ + + ]: 31895562 : if (keys[i] == key) {
160 : 229768 : retIdx = i;
161 : 229768 : return true;
162 : : }
163 : : }
164 : :
165 : : return false;
166 : : }
167 : :
168 : 11 : bool UniValue::checkObject(const std::map<std::string,UniValue::VType>& t) const
169 : : {
170 [ + - ]: 11 : if (typ != VOBJ) {
171 : : return false;
172 : : }
173 : :
174 [ + + ]: 51 : for (const auto& object: t) {
175 : 42 : size_t idx = 0;
176 [ + - ]: 42 : if (!findKey(object.first, idx)) {
177 : : return false;
178 : : }
179 : :
180 [ + + ]: 42 : if (values.at(idx).getType() != object.second) {
181 : : return false;
182 : : }
183 : : }
184 : :
185 : : return true;
186 : : }
187 : :
188 : 25390 : const UniValue& UniValue::operator[](const std::string& key) const
189 : : {
190 [ + + ]: 25390 : if (typ != VOBJ)
191 : : return NullUniValue;
192 : :
193 : 25322 : size_t index = 0;
194 [ + + ]: 25322 : if (!findKey(key, index))
195 : : return NullUniValue;
196 : :
197 : 22302 : return values.at(index);
198 : : }
199 : :
200 : 1748842 : const UniValue& UniValue::operator[](size_t index) const
201 : : {
202 [ + - ]: 1748842 : if (typ != VOBJ && typ != VARR)
203 : : return NullUniValue;
204 [ - + + + ]: 1748842 : if (index >= values.size())
205 : : return NullUniValue;
206 : :
207 : 1480152 : return values.at(index);
208 : : }
209 : :
210 : 13180124 : void UniValue::checkType(const VType& expected) const
211 : : {
212 [ + + ]: 13180124 : if (typ != expected) {
213 [ + - + - : 90 : throw type_error{"JSON value of type " + std::string{uvTypeName(typ)} + " is not of expected type " +
+ - ]
214 [ + - + - : 180 : std::string{uvTypeName(expected)}};
+ - ]
215 : : }
216 : 13180079 : }
217 : :
218 : 38507 : const char *uvTypeName(UniValue::VType t)
219 : : {
220 [ + + + + : 38507 : switch (t) {
+ - + ]
221 : : case UniValue::VNULL: return "null";
222 : 17 : case UniValue::VBOOL: return "bool";
223 : 11253 : case UniValue::VOBJ: return "object";
224 : 1150 : case UniValue::VARR: return "array";
225 : 15966 : case UniValue::VSTR: return "string";
226 : 86 : case UniValue::VNUM: return "number";
227 : : }
228 : :
229 : : // not reached
230 : 0 : return nullptr;
231 : : }
232 : :
233 : 862701 : const UniValue& UniValue::find_value(std::string_view key) const
234 : : {
235 [ - + + + ]: 2187643 : for (unsigned int i = 0; i < keys.size(); ++i) {
236 [ - + + + ]: 2164003 : if (keys[i] == key) {
237 : 839061 : return values.at(i);
238 : : }
239 : : }
240 : : return NullUniValue;
241 : : }
242 : :
243 : 31524 : void UniValue::reserve(size_t new_cap)
244 : : {
245 : 31524 : values.reserve(new_cap);
246 [ - + ]: 31524 : if (typ == VOBJ) {
247 : 0 : keys.reserve(new_cap);
248 : : }
249 : 31524 : }
|
