Debian Codegraph @

modules/lsp-runtime-lib/src/main/fmt/json/dom/Node.cpp

raw
1 /*
2 * Copyright (C) 2021 Linux Studio Plugins Project <https://lsp-plug.in/>
3 * (C) 2021 Vladimir Sadovnikov <[email protected]>
4 *
5 * This file is part of lsp-runtime-lib
6 * Created on: 31 янв. 2021 г.
7 *
8 * lsp-runtime-lib is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU Lesser General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or
11 * any later version.
12 *
13 * lsp-runtime-lib is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public License
19 * along with lsp-runtime-lib. If not, see <https://www.gnu.org/licenses/>.
20 */
21
22 #include <lsp-plug.in/fmt/json/dom/Node.h>
23 #include <lsp-plug.in/io/InStringSequence.h>
24 #include <lsp-plug.in/expr/Tokenizer.h>
25 #include <lsp-plug.in/stdlib/locale.h>
26
27 namespace lsp
28 {
29 namespace json
30 {
31 Node::Node(node_t *node)
32 {
33 pNode = node;
34 if (node != NULL)
35 node->refs++;
36 }
37
38 Node::Node(const Node &src)
39 {
40 pNode = NULL;
41 copy_ref(&src);
42 }
43
44 Node::Node(const Node *src)
45 {
46 pNode = NULL;
47 copy_ref(src);
48 }
49
50 Node::~Node()
51 {
52 if (pNode != NULL)
53 {
54 release_ref(pNode);
55 pNode = NULL;
56 }
57 }
58
59 status_t Node::create()
60 {
61 node_t *node = new node_t();
62 if (node == NULL)
63 return STATUS_NO_MEM;
64
65 node->refs = 1;
66 node->type = JN_NULL;
67 node->pData = NULL;
68
69 release_ref(pNode);
70 pNode = node;
71
72 return STATUS_OK;
73 }
74
75 Node Node::build()
76 {
77 Node res;
78 res.create();
79 return res;
80 }
81
82 Node *Node::allocate()
83 {
84 Node *res = new Node();
85 if (res == NULL)
86 return NULL;
87 else if (res->create() == STATUS_OK)
88 return res;
89
90 delete res;
91 return NULL;
92 }
93
94 void Node::copy_ref(const Node *src)
95 {
96 if (this == src)
97 return;
98 else if (this->pNode == src->pNode)
99 return;
100
101 // Increment number of references for source node
102 node_t *ref = src->make_ref();
103
104 // Release self reference and replace with new one
105 release_ref(pNode);
106 pNode = ref;
107 }
108
109 Node::node_t *Node::make_ref() const
110 {
111 if (pNode != NULL)
112 {
113 pNode->refs ++;
114 return pNode;
115 }
116
117 // Need to allocate the node
118 if ((pNode = new node_t()) == NULL)
119 return NULL;
120
121 pNode->refs = 2; // self and exported
122 pNode->type = JN_NULL;
123 pNode->pData= NULL;
124
125 return pNode;
126 }
127
128 void Node::undef_node(node_t *node)
129 {
130 if (node == NULL)
131 return;
132
133 // Destroy object
134 switch (node->type)
135 {
136 case JN_NULL:
137 break;
138
139 case JN_INT:
140 node->nValue = 0;
141 break;
142
143 case JN_DOUBLE:
144 node->fValue = 0.0;
145 break;
146
147 case JN_BOOL:
148 node->bValue = false;
149 break;
150
151 case JN_STRING:
152 {
153 LSPString *s = node->sValue;
154 if (s == NULL)
155 break;
156
157 node->sValue = NULL;
158 delete s;
159 break;
160 }
161
162 case JN_ARRAY:
163 {
164 lltl::parray<node_t> *v = node->pArray;
165 if (v == NULL)
166 break;
167
168 node->pArray = NULL;
169 for (size_t i=0, n=v->size(); i<n; ++i)
170 release_ref(v->uget(i));
171 delete v;
172
173 break;
174 }
175
176 case JN_OBJECT:
177 {
178 lltl::pphash<LSPString, node_t> *h = node->pObject;
179 if (h == NULL)
180 break;
181
182 node->pObject = NULL;
183 lltl::parray<node_t> v;
184 if (h->values(&v))
185 {
186 for (size_t i=0, n=v.size(); i<n; ++i)
187 release_ref(v.uget(i));
188 v.flush();
189 }
190 delete h;
191 break;
192 }
193 }
194
195 // Clear type
196 node->type = JN_NULL;
197 }
198
199 Node::node_t *Node::clear_node(node_t *node)
200 {
201 if (node != NULL)
202 {
203 undef_node(node);
204 return node;
205 }
206
207 node = new node_t;
208 if (node != NULL)
209 {
210 node->type = JN_NULL;
211 node->refs = 1;
212 node->pData = NULL;
213 }
214 return node;
215 }
216
217 void Node::release_ref(node_t *node)
218 {
219 // Check the value
220 if ((node == NULL) || (--node->refs) > 0)
221 return;
222
223 // Undef node data and free node
224 undef_node(node);
225 delete node;
226 }
227
228 bool Node::of_type(const Node *src) const
229 {
230 return type() == src->type();
231 }
232
233 bool Node::of_type(const Node &src) const
234 {
235 return type() == src.type();
236 }
237
238 bool Node::of_type(node_type_t ntype) const
239 {
240 return type() == ntype;
241 }
242
243 void Node::move_data(node_t *dst, node_t *src)
244 {
245 switch (src->type)
246 {
247 case JN_NULL: dst->pData = src->pData; break;
248 case JN_INT: dst->nValue = src->nValue; break;
249 case JN_DOUBLE: dst->fValue = src->fValue; break;
250 case JN_BOOL: dst->bValue = src->bValue; break;
251 case JN_STRING: dst->sValue = src->sValue; break;
252 case JN_ARRAY: dst->pArray = src->pArray; break;
253 case JN_OBJECT: dst->pObject = src->pObject; break;
254 default: break;
255 }
256 dst->type = src->type;
257
258 src->pData = NULL;
259 src->type = JN_NULL;
260 }
261
262 status_t Node::cast_to(node_type_t dtype)
263 {
264 // Check that type matches
265 switch (dtype)
266 {
267 case JN_NULL:
268 undef_node(pNode);
269 return STATUS_OK;
270
271 case JN_INT: return cast_to_int();
272 case JN_DOUBLE: return cast_to_double();
273 case JN_BOOL: return cast_to_bool();
274 case JN_STRING: return cast_to_string();
275 case JN_ARRAY: return cast_to_array();
276 case JN_OBJECT: return cast_to_object();
277
278 default:
279 break;
280 }
281
282 return STATUS_BAD_TYPE;
283 }
284
285 status_t Node::cast_to_int()
286 {
287 ssize_t ivalue;
288
289 switch (type())
290 {
291 case JN_NULL: ivalue = 0; break;
292 case JN_INT: return STATUS_OK;
293 case JN_DOUBLE: ivalue = pNode->fValue; break;
294 case JN_BOOL: ivalue = (pNode->bValue) ? 1 : 0; break;
295 case JN_STRING:
296 {
297 // Parse integer/float number as string and cast to integer
298 io::InStringSequence s(pNode->sValue);
299 expr::Tokenizer t(&s);
300
301 switch (t.get_token(expr::TF_GET))
302 {
303 case expr::TT_IVALUE: ivalue = t.int_value(); break;
304 case expr::TT_FVALUE: ivalue = t.float_value(); break;
305 case expr::TT_TRUE: ivalue = 1; break;
306 case expr::TT_FALSE: ivalue = 0; break;
307 default:
308 return STATUS_BAD_FORMAT;
309 }
310
311 if (t.get_token(expr::TF_GET) != expr::TT_EOF)
312 return STATUS_BAD_FORMAT;
313 break;
314 }
315
316 case JN_ARRAY: ivalue = pNode->pArray->size(); break;
317 case JN_OBJECT: ivalue = pNode->pObject->size(); break;
318
319 default:
320 return STATUS_BAD_TYPE;
321 }
322
323 // Update node value
324 node_t *node = clear_node(pNode);
325 if (node == NULL)
326 return STATUS_NO_MEM;
327
328 pNode = node;
329 pNode->type = JN_INT;
330 pNode->nValue = ivalue;
331
332 return STATUS_OK;
333 }
334
335 status_t Node::cast_to_double()
336 {
337 double fvalue;
338
339 switch (type())
340 {
341 case JN_NULL: fvalue = 0.0f; break;
342 case JN_INT: fvalue = pNode->nValue; break;
343 case JN_DOUBLE: return STATUS_OK;
344 case JN_BOOL: fvalue = (pNode->bValue) ? 1.0f : 0.0f; break;
345 case JN_STRING:
346 {
347 // Parse integer/float number as string and cast to integer
348 io::InStringSequence s(pNode->sValue);
349 expr::Tokenizer t(&s);
350
351 switch (t.get_token(expr::TF_GET))
352 {
353 case expr::TT_IVALUE: fvalue = t.int_value(); break;
354 case expr::TT_FVALUE: fvalue = t.float_value(); break;
355 case expr::TT_TRUE: fvalue = 1.0f; break;
356 case expr::TT_FALSE: fvalue = 0.0f; break;
357 default:
358 return STATUS_BAD_FORMAT;
359 }
360
361 if (t.get_token(expr::TF_GET) != expr::TT_EOF)
362 return STATUS_BAD_FORMAT;
363 break;
364 }
365
366 case JN_ARRAY: fvalue = pNode->pArray->size(); break;
367 case JN_OBJECT: fvalue = pNode->pObject->size(); break;
368
369 default:
370 return STATUS_BAD_TYPE;
371 }
372
373 // Update node value
374 node_t *node = clear_node(pNode);
375 if (node == NULL)
376 return STATUS_NO_MEM;
377
378 pNode->type = JN_DOUBLE;
379 pNode->fValue = fvalue;
380
381 return STATUS_OK;
382 }
383
384 status_t Node::cast_to_bool()
385 {
386 bool bvalue;
387
388 switch (type())
389 {
390 case JN_NULL: bvalue = false; break;
391 case JN_INT: bvalue = pNode->nValue != 0; break;
392 case JN_DOUBLE: bvalue = (pNode->fValue >= 0.5) || (pNode->fValue <= -0.5); break;
393 case JN_BOOL: return STATUS_OK;
394 case JN_STRING:
395 {
396 // Parse integer/float number as string and cast to integer
397 io::InStringSequence s(pNode->sValue);
398 expr::Tokenizer t(&s);
399
400 switch (t.get_token(expr::TF_GET))
401 {
402 case expr::TT_IVALUE: bvalue = t.int_value() != 0; break;
403 case expr::TT_FVALUE: bvalue = (t.float_value() >= 0.5) || (t.float_value() <= -0.5); break;
404 case expr::TT_TRUE: bvalue = true; break;
405 case expr::TT_FALSE: bvalue = false; break;
406 default:
407 return STATUS_BAD_FORMAT;
408 }
409
410 if (t.get_token(expr::TF_GET) != expr::TT_EOF)
411 return STATUS_BAD_FORMAT;
412 break;
413 }
414
415 case JN_ARRAY: bvalue = pNode->pArray->size() > 0; break;
416 case JN_OBJECT: bvalue = pNode->pObject->size() > 0; break;
417
418 default:
419 return STATUS_BAD_TYPE;
420 }
421
422 // Update node value
423 node_t *node = clear_node(pNode);
424 if (node == NULL)
425 return STATUS_NO_MEM;
426
427 pNode->type = JN_BOOL;
428 pNode->bValue = bvalue;
429
430 return STATUS_OK;
431 }
432
433 status_t Node::cast_to_string()
434 {
435 LSPString tmp;
436
437 switch (type())
438 {
439 case JN_NULL: break;
440 case JN_INT:
441 if (!tmp.fmt_ascii("%ld", long(pNode->nValue)))
442 return STATUS_NO_MEM;
443 break;
444 case JN_DOUBLE:
445 {
446 SET_LOCALE_SCOPED(LC_NUMERIC, "C");
447 if (!tmp.fmt_ascii("%f", double(pNode->fValue)))
448 return STATUS_NO_MEM;
449 break;
450 }
451 case JN_BOOL:
452 if (!tmp.set_ascii((pNode->bValue) ? "true" : "false"))
453 return STATUS_NO_MEM;
454 break;
455 case JN_STRING: return STATUS_OK;
456
457 case JN_ARRAY: return STATUS_BAD_TYPE; // TODO
458 case JN_OBJECT: return STATUS_BAD_TYPE; // TODO
459
460 default:
461 return STATUS_BAD_TYPE;
462 }
463
464 LSPString *ns = tmp.release();
465 if (ns == NULL)
466 return STATUS_NO_MEM;
467
468 // Update node value
469 node_t *node = clear_node(pNode);
470 if (node == NULL)
471 return STATUS_NO_MEM;
472
473 pNode->type = JN_STRING;
474 pNode->sValue = ns;
475
476 return STATUS_OK;
477 }
478
479 status_t Node::cast_to_array()
480 {
481 lltl::parray<node_t> *tmp;
482 node_t *child;
483
484 switch (type())
485 {
486 case JN_ARRAY: return STATUS_OK;
487 default:
488 break;
489 }
490
491 // Create array and add new node to array
492 child = new node_t;
493 if (child == NULL)
494 return STATUS_NO_MEM;
495
496 tmp = new lltl::parray<node_t>();
497 if (tmp == NULL)
498 {
499 delete child;
500 return STATUS_NO_MEM;
501 }
502 if (!tmp->add(child))
503 {
504 delete child;
505 delete tmp;
506 return STATUS_NO_MEM;
507 }
508
509 // Transfer data
510 if (pNode != NULL)
511 move_data(child, pNode);
512 else
513 {
514 // Update node value
515 node_t *node = clear_node(pNode);
516 if (node == NULL)
517 {
518 delete child;
519 delete tmp;
520 return STATUS_NO_MEM;
521 }
522 pNode = node;
523 }
524
525 // Update node value
526 pNode->type = JN_ARRAY;
527 pNode->pArray = tmp;
528
529 return STATUS_OK;
530 }
531
532 status_t Node::cast_to_object()
533 {
534 LSPString key;
535 lltl::pphash<LSPString, node_t> *tmp;
536 node_t *child;
537
538 switch (type())
539 {
540 case JN_ARRAY: return STATUS_OK;
541 default:
542 break;
543 }
544
545 // Create array and add new node to array
546 child = new node_t;
547 if (child == NULL)
548 return STATUS_NO_MEM;
549
550 tmp = new lltl::pphash<LSPString, node_t>();
551 if (tmp == NULL)
552 {
553 delete child;
554 return STATUS_NO_MEM;
555 }
556 if (!tmp->create(&key, child))
557 {
558 delete child;
559 delete tmp;
560 return STATUS_NO_MEM;
561 }
562
563 // Transfer data
564 if (pNode != NULL)
565 move_data(child, pNode);
566 else
567 {
568 // Update node value
569 node_t *node = clear_node(pNode);
570 if (node == NULL)
571 {
572 delete child;
573 delete tmp;
574 return STATUS_NO_MEM;
575 }
576 pNode = node;
577 }
578
579 // Update node value
580 pNode->type = JN_OBJECT;
581 pNode->pObject = tmp;
582
583 return STATUS_OK;
584 }
585
586 Integer Node::as_int() const
587 {
588 return Integer(this);
589 }
590
591 Double Node::as_double() const
592 {
593 return Double(this);
594 }
595
596 Boolean Node::as_bool() const
597 {
598 return Boolean(this);
599 }
600
601 String Node::as_string() const
602 {
603 return String(this);
604 }
605
606 Array Node::as_array() const
607 {
608 return Array(this);
609 }
610
611 Object Node::as_object() const
612 {
613 return Object(this);
614 }
615
616 const char *Node::stype() const
617 {
618 size_t type = (pNode == NULL) ? JN_NULL : pNode->type;
619 switch (type)
620 {
621 case JN_NULL: return "NULL";
622 case JN_INT: return "INT";
623 case JN_DOUBLE: return "DOUBLE";
624 case JN_BOOL: return "BOOL";
625 case JN_STRING: return "STRING";
626 case JN_ARRAY: return "ARRAY";
627 case JN_OBJECT: return "OBJECT";
628 default: break;
629 }
630
631 return "UNKNOWN (corrupted)";
632 }
633
634 } /* namespace json */
635 } /* namespace lsp */
636
637