• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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