1 /*
2 * Copyright (c) 2023 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 "JsonReader.h"
17
18 #include <fstream>
19 #include <sstream>
20 #include <limits>
21 #include <cstdint>
22 #include "PreviewerEngineLog.h"
23 #include "cJSON.h"
24
25 namespace Json2 {
Value(cJSON * object)26 Value::Value(cJSON* object) : jsonPtr(object), rootNode(true) {}
27
Value(cJSON * object,bool isRoot)28 Value::Value(cJSON* object, bool isRoot) : jsonPtr(object), rootNode(isRoot) {}
29
~Value()30 Value::~Value()
31 {
32 if (!jsonPtr) {
33 return;
34 }
35 if (rootNode) {
36 cJSON_Delete(jsonPtr);
37 }
38 jsonPtr = nullptr;
39 }
40
operator [](const char * key)41 Value Value::operator[](const char* key)
42 {
43 if (!cJSON_HasObjectItem(jsonPtr, key)) {
44 return Value();
45 }
46 return Value(cJSON_GetObjectItemCaseSensitive(jsonPtr, key), false);
47 }
48
operator [](const char * key) const49 const Value Value::operator[](const char* key) const
50 {
51 if (!cJSON_HasObjectItem(jsonPtr, key)) {
52 return Value();
53 }
54 return Value(cJSON_GetObjectItemCaseSensitive(jsonPtr, key), false);
55 }
56
operator [](const std::string & key)57 Value Value::operator[](const std::string& key)
58 {
59 if (!cJSON_HasObjectItem(jsonPtr, key.c_str())) {
60 return Value();
61 }
62 return Value(cJSON_GetObjectItemCaseSensitive(jsonPtr, key.c_str()), false);
63 }
64
operator [](const std::string & key) const65 const Value Value::operator[](const std::string& key) const
66 {
67 if (!cJSON_HasObjectItem(jsonPtr, key.c_str())) {
68 return Value();
69 }
70 return Value(cJSON_GetObjectItemCaseSensitive(jsonPtr, key.c_str()), false);
71 }
72
GetMemberNames() const73 Value::Members Value::GetMemberNames() const
74 {
75 Members names;
76 if (jsonPtr) {
77 cJSON* item = jsonPtr->child;
78 while (item != nullptr) {
79 names.push_back(item->string);
80 item = item->next;
81 }
82 }
83 return names;
84 }
85
ToString() const86 std::string Value::ToString() const
87 {
88 std::string ret;
89 if (!jsonPtr) {
90 return ret;
91 }
92 char* jsonData = cJSON_PrintUnformatted(jsonPtr);
93 if (jsonData) {
94 ret = jsonData;
95 cJSON_free(jsonData);
96 }
97 return ret;
98 }
99
ToStyledString() const100 std::string Value::ToStyledString() const
101 {
102 std::string ret;
103 if (!jsonPtr) {
104 return ret;
105 }
106 char* jsonData = cJSON_Print(jsonPtr);
107 if (jsonData) {
108 ret = jsonData;
109 cJSON_free(jsonData);
110 }
111 return ret;
112 }
113
GetJsonPtr() const114 const cJSON* Value::GetJsonPtr() const
115 {
116 return jsonPtr;
117 }
118
IsNull() const119 bool Value::IsNull() const
120 {
121 return !jsonPtr || cJSON_IsNull(jsonPtr);
122 }
123
IsValid() const124 bool Value::IsValid() const
125 {
126 return jsonPtr && !cJSON_IsInvalid(jsonPtr);
127 }
128
IsNumber() const129 bool Value::IsNumber() const
130 {
131 return cJSON_IsNumber(jsonPtr);
132 }
133
IsInt() const134 bool Value::IsInt() const
135 {
136 if (!IsNumber()) {
137 return false;
138 }
139 double num = cJSON_GetNumberValue(jsonPtr);
140 return (num >= static_cast<double>(std::numeric_limits<int32_t>::min())) &&
141 (num <= static_cast<double>(std::numeric_limits<int32_t>::max()));
142 }
143
IsUInt() const144 bool Value::IsUInt() const
145 {
146 if (!IsNumber()) {
147 return false;
148 }
149 double num = cJSON_GetNumberValue(jsonPtr);
150 return (num >= static_cast<double>(std::numeric_limits<uint32_t>::min())) &&
151 (num <= static_cast<double>(std::numeric_limits<uint32_t>::max()));
152 }
153
IsInt64() const154 bool Value::IsInt64() const
155 {
156 if (!IsNumber()) {
157 return false;
158 }
159 double num = cJSON_GetNumberValue(jsonPtr);
160 return (num >= static_cast<double>(std::numeric_limits<int64_t>::min())) &&
161 (num <= static_cast<double>(std::numeric_limits<int64_t>::max()));
162 }
163
IsUInt64() const164 bool Value::IsUInt64() const
165 {
166 if (!IsNumber()) {
167 return false;
168 }
169 double num = cJSON_GetNumberValue(jsonPtr);
170 return (num >= static_cast<double>(std::numeric_limits<uint64_t>::min())) &&
171 (num <= static_cast<double>(std::numeric_limits<uint64_t>::max()));
172 }
173
IsDouble() const174 bool Value::IsDouble() const
175 {
176 if (!IsNumber()) {
177 return false;
178 }
179 double num = cJSON_GetNumberValue(jsonPtr);
180 return (num >= std::numeric_limits<double>::lowest()) && (num <= std::numeric_limits<double>::max());
181 }
182
IsBool() const183 bool Value::IsBool() const
184 {
185 return cJSON_IsBool(jsonPtr);
186 }
187
IsString() const188 bool Value::IsString() const
189 {
190 return cJSON_IsString(jsonPtr);
191 }
192
IsObject() const193 bool Value::IsObject() const
194 {
195 return cJSON_IsObject(jsonPtr);
196 }
197
IsArray() const198 bool Value::IsArray() const
199 {
200 return cJSON_IsArray(jsonPtr);
201 }
202
IsMember(const char * key) const203 bool Value::IsMember(const char* key) const
204 {
205 return cJSON_HasObjectItem(jsonPtr, key);
206 }
207
GetInt(const char * key,int32_t defaultVal) const208 int32_t Value::GetInt(const char* key, int32_t defaultVal) const
209 {
210 return static_cast<int32_t>(GetDouble(key, defaultVal));
211 }
212
GetUInt(const char * key,int32_t defaultVal) const213 uint32_t Value::GetUInt(const char* key, int32_t defaultVal) const
214 {
215 return static_cast<uint32_t>(GetDouble(key, defaultVal));
216 }
217
GetInt64(const char * key,int32_t defaultVal) const218 int64_t Value::GetInt64(const char* key, int32_t defaultVal) const
219 {
220 return static_cast<int64_t>(GetDouble(key, defaultVal));
221 }
222
GetFloat(const char * key,float defaultVal) const223 float Value::GetFloat(const char* key, float defaultVal) const
224 {
225 return static_cast<float>(GetDouble(key, defaultVal));
226 }
227
GetDouble(const char * key,double defaultVal) const228 double Value::GetDouble(const char* key, double defaultVal) const
229 {
230 Value val = GetValue(key);
231 if (!val.IsNull() && val.IsNumber()) {
232 return val.AsDouble();
233 }
234 return defaultVal;
235 }
236
GetBool(const char * key,bool defaultVal) const237 bool Value::GetBool(const char* key, bool defaultVal) const
238 {
239 Value val = GetValue(key);
240 if (!val.IsNull() && val.IsBool()) {
241 return val.AsBool();
242 }
243 return defaultVal;
244 }
245
GetString(const char * key,const std::string defaultVal) const246 std::string Value::GetString(const char* key, const std::string defaultVal) const
247 {
248 Value val = GetValue(key);
249 if (!val.IsNull() && val.IsString()) {
250 return val.AsString();
251 }
252 return defaultVal;
253 }
254
GetValue(const char * key) const255 Value Value::GetValue(const char* key) const
256 {
257 return Value(cJSON_GetObjectItemCaseSensitive(jsonPtr, key), false);
258 }
259
AsInt() const260 int32_t Value::AsInt() const
261 {
262 return static_cast<int32_t>(AsDouble());
263 }
264
AsUInt() const265 uint32_t Value::AsUInt() const
266 {
267 return static_cast<uint32_t>(AsDouble());
268 }
269
AsInt64() const270 int64_t Value::AsInt64() const
271 {
272 return static_cast<int64_t>(AsDouble());
273 }
274
AsFloat() const275 float Value::AsFloat() const
276 {
277 return static_cast<float>(AsDouble());
278 }
279
AsDouble() const280 double Value::AsDouble() const
281 {
282 if (jsonPtr && cJSON_IsNumber(jsonPtr)) {
283 return cJSON_GetNumberValue(jsonPtr);
284 }
285 return 0.0;
286 }
287
AsBool() const288 bool Value::AsBool() const
289 {
290 if (jsonPtr && cJSON_IsBool(jsonPtr)) {
291 return cJSON_IsTrue(jsonPtr);
292 }
293 return false;
294 }
295
AsString() const296 std::string Value::AsString() const
297 {
298 if (jsonPtr && cJSON_IsString(jsonPtr)) {
299 return std::string(cJSON_GetStringValue(jsonPtr));
300 }
301 return "";
302 }
303
304
Add(const char * key,const char * value)305 bool Value::Add(const char* key, const char* value)
306 {
307 if (!key || !cJSON_IsObject(jsonPtr)) {
308 return false;
309 }
310 cJSON* child = cJSON_CreateString(value);
311 if (child == nullptr) {
312 return false;
313 }
314 cJSON_AddItemToObject(jsonPtr, key, child);
315 return true;
316 }
317
Add(const char * key,bool value)318 bool Value::Add(const char* key, bool value)
319 {
320 if (!key || !cJSON_IsObject(jsonPtr)) {
321 return false;
322 }
323 cJSON* child = cJSON_CreateBool(static_cast<int>(value));
324 if (child == nullptr) {
325 return false;
326 }
327 cJSON_AddItemToObject(jsonPtr, key, child);
328 return true;
329 }
330
Add(const char * key,int32_t value)331 bool Value::Add(const char* key, int32_t value)
332 {
333 return Add(key, static_cast<double>(value));
334 }
335
Add(const char * key,uint32_t value)336 bool Value::Add(const char* key, uint32_t value)
337 {
338 return Add(key, static_cast<double>(value));
339 }
340
Add(const char * key,int64_t value)341 bool Value::Add(const char* key, int64_t value)
342 {
343 return Add(key, static_cast<double>(value));
344 }
345
Add(const char * key,double value)346 bool Value::Add(const char* key, double value)
347 {
348 if (!key || !cJSON_IsObject(jsonPtr)) {
349 return false;
350 }
351 cJSON* child = cJSON_CreateNumber(value);
352 if (child == nullptr) {
353 return false;
354 }
355 cJSON_AddItemToObject(jsonPtr, key, child);
356 return true;
357 }
358
Add(const char * key,const Value & value)359 bool Value::Add(const char* key, const Value& value)
360 {
361 if (!key || value.IsNull() || !value.IsValid()) {
362 return false;
363 }
364 cJSON* jsonObject = cJSON_Duplicate(const_cast<cJSON*>(value.GetJsonPtr()), true);
365 if (jsonObject == nullptr) {
366 return false;
367 }
368 cJSON_AddItemToObject(jsonPtr, key, jsonObject);
369 return true;
370 }
371
Add(const char * value)372 bool Value::Add(const char* value)
373 {
374 if (!cJSON_IsArray(jsonPtr)) {
375 return false;
376 }
377 cJSON* child = cJSON_CreateString(value);
378 if (child == nullptr) {
379 return false;
380 }
381 cJSON_AddItemToArray(jsonPtr, child);
382 return true;
383 }
384
Add(bool value)385 bool Value::Add(bool value)
386 {
387 if (!cJSON_IsArray(jsonPtr)) {
388 return false;
389 }
390 cJSON* child = cJSON_CreateBool(static_cast<int>(value));
391 if (child == nullptr) {
392 return false;
393 }
394 cJSON_AddItemToArray(jsonPtr, child);
395 return true;
396 }
397
Add(int32_t value)398 bool Value::Add(int32_t value)
399 {
400 return Add(static_cast<double>(value));
401 }
402
Add(uint32_t value)403 bool Value::Add(uint32_t value)
404 {
405 return Add(static_cast<double>(value));
406 }
407
Add(int64_t value)408 bool Value::Add(int64_t value)
409 {
410 return Add(static_cast<double>(value));
411 }
412
Add(double value)413 bool Value::Add(double value)
414 {
415 if (!cJSON_IsArray(jsonPtr)) {
416 return false;
417 }
418 cJSON* child = cJSON_CreateNumber(value);
419 if (child == nullptr) {
420 return false;
421 }
422 cJSON_AddItemToArray(jsonPtr, child);
423 return true;
424 }
425
426
Add(const Value & value)427 bool Value::Add(const Value& value)
428 {
429 if (value.IsNull() || !value.IsValid()) {
430 return false;
431 }
432 cJSON* jsonObject = cJSON_Duplicate(const_cast<cJSON*>(value.GetJsonPtr()), true);
433 if (jsonObject == nullptr) {
434 return false;
435 }
436 cJSON_AddItemToArray(jsonPtr, jsonObject);
437 return true;
438 }
439
Replace(const char * key,bool value)440 bool Value::Replace(const char* key, bool value)
441 {
442 if (!key) {
443 return false;
444 }
445 cJSON* child = cJSON_CreateBool(static_cast<int>(value));
446 if (child == nullptr) {
447 return false;
448 }
449 if (!cJSON_ReplaceItemInObjectCaseSensitive(jsonPtr, key, child)) {
450 cJSON_Delete(child);
451 return false;
452 }
453 return true;
454 }
455
Replace(const char * key,int32_t value)456 bool Value::Replace(const char* key, int32_t value)
457 {
458 return Replace(key, static_cast<double>(value));
459 }
460
Replace(const char * key,uint32_t value)461 bool Value::Replace(const char* key, uint32_t value)
462 {
463 return Replace(key, static_cast<double>(value));
464 }
465
Replace(const char * key,int64_t value)466 bool Value::Replace(const char* key, int64_t value)
467 {
468 return Replace(key, static_cast<double>(value));
469 }
470
Replace(const char * key,double value)471 bool Value::Replace(const char* key, double value)
472 {
473 if (!key) {
474 return false;
475 }
476 cJSON* child = cJSON_CreateNumber(value);
477 if (child == nullptr) {
478 return false;
479 }
480 if (!cJSON_ReplaceItemInObjectCaseSensitive(jsonPtr, key, child)) {
481 cJSON_Delete(child);
482 return false;
483 }
484 return true;
485 }
486
Replace(const char * key,const char * value)487 bool Value::Replace(const char* key, const char* value)
488 {
489 if (!key) {
490 return false;
491 }
492 cJSON* child = cJSON_CreateString(value);
493 if (child == nullptr) {
494 return false;
495 }
496 if (!cJSON_ReplaceItemInObjectCaseSensitive(jsonPtr, key, child)) {
497 cJSON_Delete(child);
498 return false;
499 }
500 return true;
501 }
502
Replace(const char * key,const Value & value)503 bool Value::Replace(const char* key, const Value& value)
504 {
505 if (!key) {
506 return false;
507 }
508 cJSON* jsonObject = cJSON_Duplicate(const_cast<cJSON*>(value.GetJsonPtr()), true);
509 if (jsonObject == nullptr) {
510 return false;
511 }
512
513 if (!cJSON_ReplaceItemInObjectCaseSensitive(jsonPtr, key, jsonObject)) {
514 cJSON_Delete(jsonObject);
515 return false;
516 }
517 return true;
518 }
519
Replace(int index,bool value)520 bool Value::Replace(int index, bool value)
521 {
522 if (index < 0 || index >= GetArraySize()) {
523 return false;
524 }
525 cJSON* child = cJSON_CreateBool(static_cast<int>(value));
526 if (child == nullptr) {
527 return false;
528 }
529 if (!cJSON_ReplaceItemInArray(jsonPtr, index, child)) {
530 cJSON_Delete(child);
531 return false;
532 }
533 return true;
534 }
535
Replace(int index,int32_t value)536 bool Value::Replace(int index, int32_t value)
537 {
538 return Replace(index, static_cast<double>(value));
539 }
540
Replace(int index,uint32_t value)541 bool Value::Replace(int index, uint32_t value)
542 {
543 return Replace(index, static_cast<double>(value));
544 }
545
Replace(int index,int64_t value)546 bool Value::Replace(int index, int64_t value)
547 {
548 return Replace(index, static_cast<double>(value));
549 }
550
Replace(int index,double value)551 bool Value::Replace(int index, double value)
552 {
553 if (index < 0 || index >= GetArraySize()) {
554 return false;
555 }
556 cJSON* child = cJSON_CreateNumber(value);
557 if (child == nullptr) {
558 return false;
559 }
560 if (!cJSON_ReplaceItemInArray(jsonPtr, index, child)) {
561 cJSON_Delete(child);
562 return false;
563 }
564 return true;
565 }
566
Replace(int index,const char * value)567 bool Value::Replace(int index, const char* value)
568 {
569 if (index < 0 || index >= GetArraySize()) {
570 return false;
571 }
572 cJSON* child = cJSON_CreateString(value);
573 if (child == nullptr) {
574 return false;
575 }
576 if (!cJSON_ReplaceItemInArray(jsonPtr, index, child)) {
577 cJSON_Delete(child);
578 return false;
579 }
580 return true;
581 }
582
Replace(int index,const Value & value)583 bool Value::Replace(int index, const Value& value)
584 {
585 if (index < 0 || index >= GetArraySize()) {
586 return false;
587 }
588 cJSON* jsonObject = cJSON_Duplicate(const_cast<cJSON*>(value.GetJsonPtr()), true);
589 if (jsonObject == nullptr) {
590 return false;
591 }
592
593 if (!cJSON_ReplaceItemInArray(jsonPtr, index, jsonObject)) {
594 cJSON_Delete(jsonObject);
595 return false;
596 }
597 return true;
598 }
599
GetArraySize() const600 uint32_t Value::GetArraySize() const
601 {
602 return cJSON_GetArraySize(jsonPtr);
603 }
604
GetArrayItem(int32_t index) const605 Value Value::GetArrayItem(int32_t index) const
606 {
607 return Value(cJSON_GetArrayItem(jsonPtr, index), false);
608 }
609
Clear()610 void Value::Clear()
611 {
612 cJSON_Delete(jsonPtr);
613 jsonPtr = cJSON_CreateObject();
614 }
615
GetKey()616 std::string Value::GetKey()
617 {
618 const char* key = jsonPtr->string;
619 if (key) {
620 return std::string(key);
621 }
622 return std::string();
623 }
624 }
625
626
ReadFile(const std::string & path)627 std::string JsonReader::ReadFile(const std::string& path)
628 {
629 std::ifstream inFile(path);
630 if (!inFile.is_open()) {
631 ELOG("JsonReader: Open json file failed.");
632 return std::string();
633 }
634 std::string jsonStr((std::istreambuf_iterator<char>(inFile)), std::istreambuf_iterator<char>());
635 inFile.close();
636 return jsonStr;
637 }
638
ParseJsonData2(const std::string & jsonStr)639 Json2::Value JsonReader::ParseJsonData2(const std::string& jsonStr)
640 {
641 return Json2::Value(cJSON_Parse(jsonStr.c_str()));
642 }
643
GetErrorPtr()644 std::string JsonReader::GetErrorPtr()
645 {
646 const char* err = cJSON_GetErrorPtr();
647 if (err) {
648 return std::string(err);
649 }
650 return std::string();
651 }
652
CreateObject()653 Json2::Value JsonReader::CreateObject()
654 {
655 return Json2::Value(cJSON_CreateObject());
656 }
657
CreateArray()658 Json2::Value JsonReader::CreateArray()
659 {
660 return Json2::Value(cJSON_CreateArray());
661 }
662
CreateBool(const bool value)663 Json2::Value JsonReader::CreateBool(const bool value)
664 {
665 return Json2::Value(cJSON_CreateBool(value));
666 }
667
CreateString(const std::string & value)668 Json2::Value JsonReader::CreateString(const std::string& value)
669 {
670 return Json2::Value(cJSON_CreateString(value.c_str()));
671 }
672
DepthCopy(const Json2::Value & value)673 Json2::Value JsonReader::DepthCopy(const Json2::Value& value)
674 {
675 return Json2::Value(cJSON_Duplicate(const_cast<cJSON*>(value.GetJsonPtr()), true));
676 }
677
CreateNull()678 Json2::Value JsonReader::CreateNull()
679 {
680 return Json2::Value(cJSON_CreateNull());
681 }