1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "base/pt_json.h"
17
18 #include "libpandabase/macros.h"
19
20 namespace panda::ecmascript::tooling {
CreateObject()21 std::unique_ptr<PtJson> PtJson::CreateObject()
22 {
23 return std::make_unique<PtJson>(cJSON_CreateObject());
24 }
25
CreateArray()26 std::unique_ptr<PtJson> PtJson::CreateArray()
27 {
28 return std::make_unique<PtJson>(cJSON_CreateArray());
29 }
30
ReleaseRoot()31 void PtJson::ReleaseRoot()
32 {
33 if (object_ != nullptr) {
34 cJSON_Delete(object_);
35 object_ = nullptr;
36 }
37 }
38
Parse(const std::string & data)39 std::unique_ptr<PtJson> PtJson::Parse(const std::string &data)
40 {
41 cJSON *value = cJSON_ParseWithOpts(data.c_str(), nullptr, true);
42 return std::make_unique<PtJson>(value);
43 }
44
Stringify() const45 std::string PtJson::Stringify() const
46 {
47 if (object_ == nullptr) {
48 return "";
49 }
50
51 char *str = cJSON_PrintUnformatted(object_);
52 if (str == nullptr) {
53 return "";
54 }
55
56 std::string result(str);
57 cJSON_free(str);
58 return result;
59 }
60
Add(const char * key,bool value) const61 bool PtJson::Add(const char *key, bool value) const
62 {
63 ASSERT(key != nullptr && !Contains(key));
64
65 cJSON *node = cJSON_CreateBool(value);
66 if (node == nullptr) {
67 return false;
68 }
69
70 cJSON_bool ret = cJSON_AddItemToObject(object_, key, node);
71 if (ret == 0) {
72 cJSON_Delete(node);
73 return false;
74 }
75
76 return true;
77 }
78
Add(const char * key,int32_t value) const79 bool PtJson::Add(const char *key, int32_t value) const
80 {
81 return Add(key, static_cast<double>(value));
82 }
83
Add(const char * key,int64_t value) const84 bool PtJson::Add(const char *key, int64_t value) const
85 {
86 return Add(key, static_cast<double>(value));
87 }
88
Add(const char * key,uint32_t value) const89 bool PtJson::Add(const char *key, uint32_t value) const
90 {
91 return Add(key, static_cast<double>(value));
92 }
93
Add(const char * key,double value) const94 bool PtJson::Add(const char *key, double value) const
95 {
96 ASSERT(key != nullptr && !Contains(key));
97
98 cJSON *node = cJSON_CreateNumber(value);
99 if (node == nullptr) {
100 return false;
101 }
102
103 cJSON_bool ret = cJSON_AddItemToObject(object_, key, node);
104 if (ret == 0) {
105 cJSON_Delete(node);
106 return false;
107 }
108
109 return true;
110 }
111
Add(const char * key,const char * value) const112 bool PtJson::Add(const char *key, const char *value) const
113 {
114 ASSERT(key != nullptr && !Contains(key));
115
116 cJSON *node = cJSON_CreateString(value);
117 if (node == nullptr) {
118 return false;
119 }
120
121 cJSON_bool ret = cJSON_AddItemToObject(object_, key, node);
122 if (ret == 0) {
123 cJSON_Delete(node);
124 return false;
125 }
126
127 return true;
128 }
129
Add(const char * key,const std::unique_ptr<PtJson> & value) const130 bool PtJson::Add(const char *key, const std::unique_ptr<PtJson> &value) const
131 {
132 ASSERT(key != nullptr && !Contains(key));
133
134 cJSON *node = value->GetJson();
135 if (node == nullptr) {
136 return false;
137 }
138
139 cJSON_bool ret = cJSON_AddItemToObject(object_, key, node);
140 if (ret == 0) {
141 return false;
142 }
143
144 return true;
145 }
146
Push(bool value) const147 bool PtJson::Push(bool value) const
148 {
149 cJSON *node = cJSON_CreateBool(value);
150 if (node == nullptr) {
151 return false;
152 }
153
154 cJSON_bool ret = cJSON_AddItemToArray(object_, node);
155 if (ret == 0) {
156 cJSON_Delete(node);
157 return false;
158 }
159
160 return true;
161 }
162
Push(int32_t value) const163 bool PtJson::Push(int32_t value) const
164 {
165 return Push(static_cast<double>(value));
166 }
167
Push(int64_t value) const168 bool PtJson::Push(int64_t value) const
169 {
170 return Push(static_cast<double>(value));
171 }
172
Push(uint32_t value) const173 bool PtJson::Push(uint32_t value) const
174 {
175 return Push(static_cast<double>(value));
176 }
177
Push(double value) const178 bool PtJson::Push(double value) const
179 {
180 cJSON *node = cJSON_CreateNumber(value);
181 if (node == nullptr) {
182 return false;
183 }
184
185 cJSON_bool ret = cJSON_AddItemToArray(object_, node);
186 if (ret == 0) {
187 cJSON_Delete(node);
188 return false;
189 }
190
191 return true;
192 }
193
Push(const char * value) const194 bool PtJson::Push(const char *value) const
195 {
196 cJSON *node = cJSON_CreateString(value);
197 if (node == nullptr) {
198 return false;
199 }
200
201 cJSON_bool ret = cJSON_AddItemToArray(object_, node);
202 if (ret == 0) {
203 cJSON_Delete(node);
204 return false;
205 }
206
207 return true;
208 }
209
Push(const std::unique_ptr<PtJson> & value) const210 bool PtJson::Push(const std::unique_ptr<PtJson> &value) const
211 {
212 if (value == nullptr) {
213 return false;
214 }
215
216 cJSON *node = value->GetJson();
217 if (node == nullptr) {
218 return false;
219 }
220
221 cJSON_bool ret = cJSON_AddItemToArray(object_, node);
222 if (ret == 0) {
223 return false;
224 }
225
226 return true;
227 }
228
Remove(const char * key) const229 bool PtJson::Remove(const char *key) const
230 {
231 ASSERT(key != nullptr && Contains(key));
232
233 cJSON_DeleteItemFromObject(object_, key);
234 return true;
235 }
236
Contains(const char * key) const237 bool PtJson::Contains(const char *key) const
238 {
239 cJSON *node = cJSON_GetObjectItemCaseSensitive(object_, key);
240 return node != nullptr;
241 }
242
GetKey() const243 std::string PtJson::GetKey() const
244 {
245 if (object_ == nullptr || object_->string == nullptr) {
246 return "";
247 }
248
249 return std::string(object_->string);
250 }
251
GetJson() const252 cJSON *PtJson::GetJson() const
253 {
254 return object_;
255 }
256
IsBool() const257 bool PtJson::IsBool() const
258 {
259 return cJSON_IsBool(object_) != 0;
260 }
261
IsNumber() const262 bool PtJson::IsNumber() const
263 {
264 return cJSON_IsNumber(object_) != 0;
265 }
266
IsString() const267 bool PtJson::IsString() const
268 {
269 return cJSON_IsString(object_) != 0;
270 }
271
IsObject() const272 bool PtJson::IsObject() const
273 {
274 return cJSON_IsObject(object_) != 0;
275 }
276
IsArray() const277 bool PtJson::IsArray() const
278 {
279 return cJSON_IsArray(object_) != 0;
280 }
281
IsNull() const282 bool PtJson::IsNull() const
283 {
284 return cJSON_IsNull(object_) != 0;
285 }
286
GetBool(bool defaultValue) const287 bool PtJson::GetBool(bool defaultValue) const
288 {
289 if (!IsBool()) {
290 return defaultValue;
291 }
292
293 return cJSON_IsTrue(object_) != 0;
294 }
295
GetInt(int32_t defaultValue) const296 int32_t PtJson::GetInt(int32_t defaultValue) const
297 {
298 if (!IsNumber()) {
299 return defaultValue;
300 }
301
302 return static_cast<int32_t>(object_->valuedouble);
303 }
304
GetInt64(int64_t defaultValue) const305 int64_t PtJson::GetInt64(int64_t defaultValue) const
306 {
307 if (!IsNumber()) {
308 return defaultValue;
309 }
310
311 return static_cast<int64_t>(object_->valuedouble);
312 }
313
GetUInt(uint32_t defaultValue) const314 uint32_t PtJson::GetUInt(uint32_t defaultValue) const
315 {
316 if (!IsNumber()) {
317 return defaultValue;
318 }
319
320 return static_cast<uint32_t>(object_->valuedouble);
321 }
322
GetDouble(double defaultValue) const323 double PtJson::GetDouble(double defaultValue) const
324 {
325 if (!IsNumber()) {
326 return defaultValue;
327 }
328
329 return object_->valuedouble;
330 }
331
GetString() const332 std::string PtJson::GetString() const
333 {
334 if (!IsString()) {
335 return "";
336 }
337
338 return std::string(object_->valuestring);
339 }
340
GetSize() const341 int32_t PtJson::GetSize() const
342 {
343 return cJSON_GetArraySize(object_);
344 }
345
Get(int32_t index) const346 std::unique_ptr<PtJson> PtJson::Get(int32_t index) const
347 {
348 return std::make_unique<PtJson>(cJSON_GetArrayItem(object_, index));
349 }
350
GetBool(const char * key,bool * value) const351 Result PtJson::GetBool(const char *key, bool *value) const
352 {
353 cJSON *item = cJSON_GetObjectItem(object_, key);
354 if (item == nullptr) {
355 return Result::NOT_EXIST;
356 }
357 if (cJSON_IsBool(item) == 0) {
358 return Result::TYPE_ERROR;
359 }
360
361 *value = cJSON_IsTrue(item) != 0;
362 return Result::SUCCESS;
363 }
364
GetInt(const char * key,int32_t * value) const365 Result PtJson::GetInt(const char *key, int32_t *value) const
366 {
367 double result;
368 Result ret = GetDouble(key, &result);
369 if (ret == Result::SUCCESS) {
370 *value = static_cast<int32_t>(result);
371 }
372 return ret;
373 }
374
GetInt64(const char * key,int64_t * value) const375 Result PtJson::GetInt64(const char *key, int64_t *value) const
376 {
377 double result;
378 Result ret = GetDouble(key, &result);
379 if (ret == Result::SUCCESS) {
380 *value = static_cast<int64_t>(result);
381 }
382 return ret;
383 }
384
GetUInt(const char * key,uint32_t * value) const385 Result PtJson::GetUInt(const char *key, uint32_t *value) const
386 {
387 double result;
388 Result ret = GetDouble(key, &result);
389 if (ret == Result::SUCCESS) {
390 *value = static_cast<uint32_t>(result);
391 }
392 return ret;
393 }
394
GetDouble(const char * key,double * value) const395 Result PtJson::GetDouble(const char *key, double *value) const
396 {
397 cJSON *item = cJSON_GetObjectItem(object_, key);
398 if (item == nullptr) {
399 return Result::NOT_EXIST;
400 }
401 if (cJSON_IsNumber(item) == 0) {
402 return Result::TYPE_ERROR;
403 }
404
405 *value = item->valuedouble;
406 return Result::SUCCESS;
407 }
408
GetString(const char * key,std::string * value) const409 Result PtJson::GetString(const char *key, std::string *value) const
410 {
411 cJSON *item = cJSON_GetObjectItem(object_, key);
412 if (item == nullptr) {
413 return Result::NOT_EXIST;
414 }
415 if (cJSON_IsString(item) == 0) {
416 return Result::TYPE_ERROR;
417 }
418
419 *value = item->valuestring;
420 return Result::SUCCESS;
421 }
422
GetObject(const char * key,std::unique_ptr<PtJson> * value) const423 Result PtJson::GetObject(const char *key, std::unique_ptr<PtJson> *value) const
424 {
425 cJSON *item = cJSON_GetObjectItem(object_, key);
426 if (item == nullptr) {
427 return Result::NOT_EXIST;
428 }
429 if (cJSON_IsObject(item) == 0) {
430 return Result::TYPE_ERROR;
431 }
432
433 *value = std::make_unique<PtJson>(item);
434 return Result::SUCCESS;
435 }
436
GetArray(const char * key,std::unique_ptr<PtJson> * value) const437 Result PtJson::GetArray(const char *key, std::unique_ptr<PtJson> *value) const
438 {
439 cJSON *item = cJSON_GetObjectItem(object_, key);
440 if (item == nullptr) {
441 return Result::NOT_EXIST;
442 }
443 if (cJSON_IsArray(item) == 0) {
444 return Result::TYPE_ERROR;
445 }
446
447 *value = std::make_unique<PtJson>(item);
448 return Result::SUCCESS;
449 }
450
GetAny(const char * key,std::unique_ptr<PtJson> * value) const451 Result PtJson::GetAny(const char *key, std::unique_ptr<PtJson> *value) const
452 {
453 cJSON *item = cJSON_GetObjectItem(object_, key);
454 if (item == nullptr) {
455 return Result::NOT_EXIST;
456 }
457
458 *value = std::make_unique<PtJson>(item);
459 return Result::SUCCESS;
460 }
461 } // namespace panda::ecmascript
462