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