projects / babeltrace.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Replace assert() -> BT_ASSERT() and some preconditions with BT_ASSERT_PRE()
[babeltrace.git] / lib / values.c
1 /*
2 * Values.c: value objects
3 *
4 * Babeltrace Library
5 *
6 * Copyright (c) 2015 EfficiOS Inc. and Linux Foundation
7 * Copyright (c) 2015 Philippe Proulx <pproulx@efficios.com>
8 *
9 * Permission is hereby granted, free of charge, to any person obtaining a copy
10 * of this software and associated documentation files (the "Software"), to deal
11 * in the Software without restriction, including without limitation the rights
12 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13 * copies of the Software, and to permit persons to whom the Software is
14 * furnished to do so, subject to the following conditions:
15 *
16 * The above copyright notice and this permission notice shall be included in
17 * all copies or substantial portions of the Software.
18 *
19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
22 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
25 * SOFTWARE.
26 */
27
28 #define BT_LOG_TAG "VALUES"
29 #include <babeltrace/lib-logging-internal.h>
30
31 #include <stdlib.h>
32 #include <string.h>
33 #include <string.h>
34 #include <inttypes.h>
35 #include <babeltrace/compiler-internal.h>
36 #include <babeltrace/ref.h>
37 #include <babeltrace/values.h>
38 #include <babeltrace/compat/glib-internal.h>
39 #include <babeltrace/types.h>
40 #include <babeltrace/object-internal.h>
41 #include <babeltrace/values-internal.h>
42 #include <babeltrace/assert-internal.h>
43 #include <babeltrace/assert-pre-internal.h>
44
45 #define BT_VALUE_FROM_CONCRETE(_concrete) ((struct bt_value *) (_concrete))
46 #define BT_VALUE_TO_BOOL(_base) ((struct bt_value_bool *) (_base))
47 #define BT_VALUE_TO_INTEGER(_base) ((struct bt_value_integer *) (_base))
48 #define BT_VALUE_TO_FLOAT(_base) ((struct bt_value_float *) (_base))
49 #define BT_VALUE_TO_STRING(_base) ((struct bt_value_string *) (_base))
50 #define BT_VALUE_TO_ARRAY(_base) ((struct bt_value_array *) (_base))
51 #define BT_VALUE_TO_MAP(_base) ((struct bt_value_map *) (_base))
52
53 #define BT_ASSERT_PRE_VALUE_IS_TYPE(_value, _type) \
54 BT_ASSERT_PRE((_value)->type == (_type), \
55 "Value has the wrong type ID: expected-type=%s, " \
56 "%![value-]+v", bt_value_type_string(_type), \
57 (_value))
58
59 #define BT_ASSERT_PRE_VALUE_HOT(_value, _name) \
60 BT_ASSERT_PRE_HOT((_value), (_name), ": +%!+v", (_value))
61
62 #define BT_ASSERT_PRE_VALUE_INDEX_IN_BOUNDS(_index, _count) \
63 BT_ASSERT_PRE((_index) < (_count), \
64 "Index is out of bound: " \
65 "index=%" PRIu64 ", count=%u", (_index), (_count));
66
67
68 struct bt_value {
69 struct bt_object base;
70 enum bt_value_type type;
71 bt_bool frozen;
72 };
73
74 static
75 struct bt_value bt_value_null_instance = {
76 .base = {
77 .ref_count = {
78 .count = 1,
79 .release = NULL,
80 },
81 .release = NULL,
82 .parent = NULL,
83 },
84 .type = BT_VALUE_TYPE_NULL,
85 .frozen = BT_TRUE,
86 };
87
88 struct bt_value *bt_value_null = &bt_value_null_instance;
89
90 struct bt_value_bool {
91 struct bt_value base;
92 bt_bool value;
93 };
94
95 struct bt_value_integer {
96 struct bt_value base;
97 int64_t value;
98 };
99
100 struct bt_value_float {
101 struct bt_value base;
102 double value;
103 };
104
105 struct bt_value_string {
106 struct bt_value base;
107 GString *gstr;
108 };
109
110 struct bt_value_array {
111 struct bt_value base;
112 GPtrArray *garray;
113 };
114
115 struct bt_value_map {
116 struct bt_value base;
117 GHashTable *ght;
118 };
119
120 static
121 void bt_value_destroy(struct bt_object *obj);
122
123 static
124 void bt_value_string_destroy(struct bt_value *object)
125 {
126 g_string_free(BT_VALUE_TO_STRING(object)->gstr, TRUE);
127 }
128
129 static
130 void bt_value_array_destroy(struct bt_value *object)
131 {
132 /*
133 * Pointer array's registered value destructor will take care
134 * of putting each contained object.
135 */
136 g_ptr_array_free(BT_VALUE_TO_ARRAY(object)->garray, TRUE);
137 }
138
139 static
140 void bt_value_map_destroy(struct bt_value *object)
141 {
142 /*
143 * Hash table's registered value destructor will take care of
144 * putting each contained object. Keys are GQuarks and cannot
145 * be destroyed anyway.
146 */
147 g_hash_table_destroy(BT_VALUE_TO_MAP(object)->ght);
148 }
149
150 static
151 void (* const destroy_funcs[])(struct bt_value *) = {
152 [BT_VALUE_TYPE_NULL] = NULL,
153 [BT_VALUE_TYPE_BOOL] = NULL,
154 [BT_VALUE_TYPE_INTEGER] = NULL,
155 [BT_VALUE_TYPE_FLOAT] = NULL,
156 [BT_VALUE_TYPE_STRING] = bt_value_string_destroy,
157 [BT_VALUE_TYPE_ARRAY] = bt_value_array_destroy,
158 [BT_VALUE_TYPE_MAP] = bt_value_map_destroy,
159 };
160
161 static
162 struct bt_value *bt_value_null_copy(const struct bt_value *null_obj)
163 {
164 return bt_value_null;
165 }
166
167 static
168 struct bt_value *bt_value_bool_copy(const struct bt_value *bool_obj)
169 {
170 return bt_value_bool_create_init(BT_VALUE_TO_BOOL(bool_obj)->value);
171 }
172
173 static
174 struct bt_value *bt_value_integer_copy(const struct bt_value *integer_obj)
175 {
176 return bt_value_integer_create_init(
177 BT_VALUE_TO_INTEGER(integer_obj)->value);
178 }
179
180 static
181 struct bt_value *bt_value_float_copy(const struct bt_value *float_obj)
182 {
183 return bt_value_float_create_init(
184 BT_VALUE_TO_FLOAT(float_obj)->value);
185 }
186
187 static
188 struct bt_value *bt_value_string_copy(const struct bt_value *string_obj)
189 {
190 return bt_value_string_create_init(
191 BT_VALUE_TO_STRING(string_obj)->gstr->str);
192 }
193
194 static
195 struct bt_value *bt_value_array_copy(const struct bt_value *array_obj)
196 {
197 int i;
198 int ret;
199 struct bt_value *copy_obj;
200 struct bt_value_array *typed_array_obj;
201
202 BT_LOGD("Copying array value: addr=%p", array_obj);
203 typed_array_obj = BT_VALUE_TO_ARRAY(array_obj);
204 copy_obj = bt_value_array_create();
205 if (!copy_obj) {
206 BT_LOGE_STR("Cannot create empty array value.");
207 goto end;
208 }
209
210 for (i = 0; i < typed_array_obj->garray->len; ++i) {
211 struct bt_value *element_obj_copy;
212 struct bt_value *element_obj = bt_value_array_get(array_obj, i);
213
214 BT_ASSERT(element_obj);
215 BT_LOGD("Copying array value's element: element-addr=%p, "
216 "index=%d", element_obj, i);
217 element_obj_copy = bt_value_copy(element_obj);
218 BT_PUT(element_obj);
219 if (!element_obj_copy) {
220 BT_LOGE("Cannot copy array value's element: "
221 "array-addr=%p, index=%d",
222 array_obj, i);
223 BT_PUT(copy_obj);
224 goto end;
225 }
226
227 ret = bt_value_array_append(copy_obj, element_obj_copy);
228 BT_PUT(element_obj_copy);
229 if (ret) {
230 BT_LOGE("Cannot append to array value: addr=%p",
231 array_obj);
232 BT_PUT(copy_obj);
233 goto end;
234 }
235 }
236
237 BT_LOGD("Copied array value: original-addr=%p, copy-addr=%p",
238 array_obj, copy_obj);
239
240 end:
241 return copy_obj;
242 }
243
244 static
245 struct bt_value *bt_value_map_copy(const struct bt_value *map_obj)
246 {
247 int ret;
248 GHashTableIter iter;
249 gpointer key, element_obj;
250 struct bt_value *copy_obj;
251 struct bt_value *element_obj_copy;
252 struct bt_value_map *typed_map_obj;
253
254 BT_LOGD("Copying map value: addr=%p", map_obj);
255 typed_map_obj = BT_VALUE_TO_MAP(map_obj);
256 copy_obj = bt_value_map_create();
257 if (!copy_obj) {
258 goto end;
259 }
260
261 g_hash_table_iter_init(&iter, typed_map_obj->ght);
262
263 while (g_hash_table_iter_next(&iter, &key, &element_obj)) {
264 const char *key_str = g_quark_to_string(GPOINTER_TO_UINT(key));
265
266 BT_ASSERT(key_str);
267 BT_LOGD("Copying map value's element: element-addr=%p, "
268 "key=\"%s\"", element_obj, key_str);
269 element_obj_copy = bt_value_copy(element_obj);
270 if (!element_obj_copy) {
271 BT_LOGE("Cannot copy map value's element: "
272 "map-addr=%p, key=\"%s\"",
273 map_obj, key_str);
274 BT_PUT(copy_obj);
275 goto end;
276 }
277
278 ret = bt_value_map_insert(copy_obj, key_str, element_obj_copy);
279 BT_PUT(element_obj_copy);
280 if (ret) {
281 BT_LOGE("Cannot insert into map value: addr=%p, key=\"%s\"",
282 map_obj, key_str);
283 BT_PUT(copy_obj);
284 goto end;
285 }
286 }
287
288 BT_LOGD("Copied map value: addr=%p", map_obj);
289
290 end:
291 return copy_obj;
292 }
293
294 static
295 struct bt_value *(* const copy_funcs[])(const struct bt_value *) = {
296 [BT_VALUE_TYPE_NULL] = bt_value_null_copy,
297 [BT_VALUE_TYPE_BOOL] = bt_value_bool_copy,
298 [BT_VALUE_TYPE_INTEGER] = bt_value_integer_copy,
299 [BT_VALUE_TYPE_FLOAT] = bt_value_float_copy,
300 [BT_VALUE_TYPE_STRING] = bt_value_string_copy,
301 [BT_VALUE_TYPE_ARRAY] = bt_value_array_copy,
302 [BT_VALUE_TYPE_MAP] = bt_value_map_copy,
303 };
304
305 static
306 bt_bool bt_value_null_compare(const struct bt_value *object_a,
307 const struct bt_value *object_b)
308 {
309 /*
310 * Always BT_TRUE since bt_value_compare() already checks if both
311 * object_a and object_b have the same type, and in the case of
312 * null value objects, they're always the same if it is so.
313 */
314 return BT_TRUE;
315 }
316
317 static
318 bt_bool bt_value_bool_compare(const struct bt_value *object_a,
319 const struct bt_value *object_b)
320 {
321 if (BT_VALUE_TO_BOOL(object_a)->value !=
322 BT_VALUE_TO_BOOL(object_b)->value) {
323 BT_LOGV("Boolean value objects are different: "
324 "bool-a-val=%d, bool-b-val=%d",
325 BT_VALUE_TO_BOOL(object_a)->value,
326 BT_VALUE_TO_BOOL(object_b)->value);
327 return BT_FALSE;
328 }
329
330 return BT_TRUE;
331 }
332
333 static
334 bt_bool bt_value_integer_compare(const struct bt_value *object_a,
335 const struct bt_value *object_b)
336 {
337 if (BT_VALUE_TO_INTEGER(object_a)->value !=
338 BT_VALUE_TO_INTEGER(object_b)->value) {
339 BT_LOGV("Integer value objects are different: "
340 "int-a-val=%" PRId64 ", int-b-val=%" PRId64,
341 BT_VALUE_TO_INTEGER(object_a)->value,
342 BT_VALUE_TO_INTEGER(object_b)->value);
343 return BT_FALSE;
344 }
345
346 return BT_TRUE;
347 }
348
349 static
350 bt_bool bt_value_float_compare(const struct bt_value *object_a,
351 const struct bt_value *object_b)
352 {
353 if (BT_VALUE_TO_FLOAT(object_a)->value !=
354 BT_VALUE_TO_FLOAT(object_b)->value) {
355 BT_LOGV("Floating point number value objects are different: "
356 "float-a-val=%f, float-b-val=%f",
357 BT_VALUE_TO_FLOAT(object_a)->value,
358 BT_VALUE_TO_FLOAT(object_b)->value);
359 return BT_FALSE;
360 }
361
362 return BT_TRUE;
363 }
364
365 static
366 bt_bool bt_value_string_compare(const struct bt_value *object_a,
367 const struct bt_value *object_b)
368 {
369 if (strcmp(BT_VALUE_TO_STRING(object_a)->gstr->str,
370 BT_VALUE_TO_STRING(object_b)->gstr->str) != 0) {
371 BT_LOGV("String value objects are different: "
372 "string-a-val=\"%s\", string-b-val=\"%s\"",
373 BT_VALUE_TO_STRING(object_a)->gstr->str,
374 BT_VALUE_TO_STRING(object_b)->gstr->str);
375 return BT_FALSE;
376 }
377
378 return BT_TRUE;
379 }
380
381 static
382 bt_bool bt_value_array_compare(const struct bt_value *object_a,
383 const struct bt_value *object_b)
384 {
385 int i;
386 bt_bool ret = BT_TRUE;
387 const struct bt_value_array *array_obj_a =
388 BT_VALUE_TO_ARRAY(object_a);
389
390 if (bt_value_array_size(object_a) != bt_value_array_size(object_b)) {
391 BT_LOGV("Array values are different: size mismatch "
392 "value-a-addr=%p, value-b-addr=%p, "
393 "value-a-size=%" PRId64 ", value-b-size=%" PRId64,
394 object_a, object_b,
395 bt_value_array_size(object_a),
396 bt_value_array_size(object_b));
397 ret = BT_FALSE;
398 goto end;
399 }
400
401 for (i = 0; i < array_obj_a->garray->len; ++i) {
402 struct bt_value *element_obj_a;
403 struct bt_value *element_obj_b;
404
405 element_obj_a = bt_value_array_get(object_a, i);
406 element_obj_b = bt_value_array_get(object_b, i);
407
408 if (!bt_value_compare(element_obj_a, element_obj_b)) {
409 BT_LOGV("Array values's elements are different: "
410 "value-a-addr=%p, value-b-addr=%p, index=%d",
411 element_obj_a, element_obj_b, i);
412 BT_PUT(element_obj_a);
413 BT_PUT(element_obj_b);
414 ret = BT_FALSE;
415 goto end;
416 }
417
418 BT_PUT(element_obj_a);
419 BT_PUT(element_obj_b);
420 }
421
422 end:
423 return ret;
424 }
425
426 static
427 bt_bool bt_value_map_compare(const struct bt_value *object_a,
428 const struct bt_value *object_b)
429 {
430 bt_bool ret = BT_TRUE;
431 GHashTableIter iter;
432 gpointer key, element_obj_a;
433 const struct bt_value_map *map_obj_a = BT_VALUE_TO_MAP(object_a);
434
435 if (bt_value_map_size(object_a) != bt_value_map_size(object_b)) {
436 BT_LOGV("Map values are different: size mismatch "
437 "value-a-addr=%p, value-b-addr=%p, "
438 "value-a-size=%" PRId64 ", value-b-size=%" PRId64,
439 object_a, object_b,
440 bt_value_map_size(object_a),
441 bt_value_map_size(object_b));
442 ret = BT_FALSE;
443 goto end;
444 }
445
446 g_hash_table_iter_init(&iter, map_obj_a->ght);
447
448 while (g_hash_table_iter_next(&iter, &key, &element_obj_a)) {
449 struct bt_value *element_obj_b;
450 const char *key_str = g_quark_to_string(GPOINTER_TO_UINT(key));
451
452 element_obj_b = bt_value_map_get(object_b, key_str);
453
454 if (!bt_value_compare(element_obj_a, element_obj_b)) {
455 BT_LOGV("Map values's elements are different: "
456 "value-a-addr=%p, value-b-addr=%p, key=\"%s\"",
457 element_obj_a, element_obj_b, key_str);
458 BT_PUT(element_obj_b);
459 ret = BT_FALSE;
460 goto end;
461 }
462
463 BT_PUT(element_obj_b);
464 }
465
466 end:
467 return ret;
468 }
469
470 static
471 bt_bool (* const compare_funcs[])(const struct bt_value *,
472 const struct bt_value *) = {
473 [BT_VALUE_TYPE_NULL] = bt_value_null_compare,
474 [BT_VALUE_TYPE_BOOL] = bt_value_bool_compare,
475 [BT_VALUE_TYPE_INTEGER] = bt_value_integer_compare,
476 [BT_VALUE_TYPE_FLOAT] = bt_value_float_compare,
477 [BT_VALUE_TYPE_STRING] = bt_value_string_compare,
478 [BT_VALUE_TYPE_ARRAY] = bt_value_array_compare,
479 [BT_VALUE_TYPE_MAP] = bt_value_map_compare,
480 };
481
482 static
483 void bt_value_null_freeze(struct bt_value *object)
484 {
485 }
486
487 static
488 void bt_value_generic_freeze(struct bt_value *object)
489 {
490 object->frozen = BT_TRUE;
491 }
492
493 static
494 void bt_value_array_freeze(struct bt_value *object)
495 {
496 int i;
497 struct bt_value_array *typed_array_obj =
498 BT_VALUE_TO_ARRAY(object);
499
500 for (i = 0; i < typed_array_obj->garray->len; ++i) {
501 bt_value_freeze(g_ptr_array_index(typed_array_obj->garray, i));
502 }
503
504 bt_value_generic_freeze(object);
505 }
506
507 static
508 void bt_value_map_freeze(struct bt_value *object)
509 {
510 GHashTableIter iter;
511 gpointer key, element_obj;
512 const struct bt_value_map *map_obj = BT_VALUE_TO_MAP(object);
513
514 g_hash_table_iter_init(&iter, map_obj->ght);
515
516 while (g_hash_table_iter_next(&iter, &key, &element_obj)) {
517 bt_value_freeze(element_obj);
518 }
519
520 bt_value_generic_freeze(object);
521 }
522
523 static
524 void (* const freeze_funcs[])(struct bt_value *) = {
525 [BT_VALUE_TYPE_NULL] = bt_value_null_freeze,
526 [BT_VALUE_TYPE_BOOL] = bt_value_generic_freeze,
527 [BT_VALUE_TYPE_INTEGER] = bt_value_generic_freeze,
528 [BT_VALUE_TYPE_FLOAT] = bt_value_generic_freeze,
529 [BT_VALUE_TYPE_STRING] = bt_value_generic_freeze,
530 [BT_VALUE_TYPE_ARRAY] = bt_value_array_freeze,
531 [BT_VALUE_TYPE_MAP] = bt_value_map_freeze,
532 };
533
534 static
535 void bt_value_destroy(struct bt_object *obj)
536 {
537 struct bt_value *value;
538
539 value = container_of(obj, struct bt_value, base);
540 BT_ASSERT(value->type != BT_VALUE_TYPE_UNKNOWN);
541 BT_LOGD("Destroying value: addr=%p", value);
542
543 if (bt_value_is_null(value)) {
544 BT_LOGD_STR("Not destroying the null value singleton.");
545 return;
546 }
547
548 if (destroy_funcs[value->type]) {
549 destroy_funcs[value->type](value);
550 }
551
552 g_free(value);
553 }
554
555 BT_HIDDEN
556 enum bt_value_status _bt_value_freeze(struct bt_value *object)
557 {
558 enum bt_value_status ret = BT_VALUE_STATUS_OK;
559
560 BT_ASSERT(object);
561
562 if (object->frozen) {
563 goto end;
564 }
565
566 BT_LOGD("Freezing value: addr=%p", object);
567 freeze_funcs[object->type](object);
568
569 end:
570 return ret;
571 }
572
573 enum bt_value_type bt_value_get_type(const struct bt_value *object)
574 {
575 BT_ASSERT_PRE_NON_NULL(object, "Value object");
576 return object->type;
577 }
578
579 static
580 struct bt_value bt_value_create_base(enum bt_value_type type)
581 {
582 struct bt_value base;
583
584 base.type = type;
585 base.frozen = BT_FALSE;
586 bt_object_init(&base, bt_value_destroy);
587 return base;
588 }
589
590 struct bt_value *bt_value_bool_create_init(bt_bool val)
591 {
592 struct bt_value_bool *bool_obj;
593
594 BT_LOGD("Creating boolean value object: val=%d", val);
595 bool_obj = g_new0(struct bt_value_bool, 1);
596 if (!bool_obj) {
597 BT_LOGE_STR("Failed to allocate one boolean value object.");
598 goto end;
599 }
600
601 bool_obj->base = bt_value_create_base(BT_VALUE_TYPE_BOOL);
602 bool_obj->value = val;
603 BT_LOGD("Created boolean value object: addr=%p", bool_obj);
604
605 end:
606 return BT_VALUE_FROM_CONCRETE(bool_obj);
607 }
608
609 struct bt_value *bt_value_bool_create(void)
610 {
611 return bt_value_bool_create_init(BT_FALSE);
612 }
613
614 struct bt_value *bt_value_integer_create_init(int64_t val)
615 {
616 struct bt_value_integer *integer_obj;
617
618 BT_LOGD("Creating integer value object: val=%" PRId64, val);
619 integer_obj = g_new0(struct bt_value_integer, 1);
620 if (!integer_obj) {
621 BT_LOGE_STR("Failed to allocate one integer value object.");
622 goto end;
623 }
624
625 integer_obj->base = bt_value_create_base(BT_VALUE_TYPE_INTEGER);
626 integer_obj->value = val;
627 BT_LOGD("Created integer value object: addr=%p",
628 integer_obj);
629
630 end:
631 return BT_VALUE_FROM_CONCRETE(integer_obj);
632 }
633
634 struct bt_value *bt_value_integer_create(void)
635 {
636 return bt_value_integer_create_init(0);
637 }
638
639 struct bt_value *bt_value_float_create_init(double val)
640 {
641 struct bt_value_float *float_obj;
642
643 BT_LOGD("Creating floating point number value object: val=%f", val);
644 float_obj = g_new0(struct bt_value_float, 1);
645 if (!float_obj) {
646 BT_LOGE_STR("Failed to allocate one floating point number value object.");
647 goto end;
648 }
649
650 float_obj->base = bt_value_create_base(BT_VALUE_TYPE_FLOAT);
651 float_obj->value = val;
652 BT_LOGD("Created floating point number value object: addr=%p",
653 float_obj);
654
655 end:
656 return BT_VALUE_FROM_CONCRETE(float_obj);
657 }
658
659 struct bt_value *bt_value_float_create(void)
660 {
661 return bt_value_float_create_init(0.);
662 }
663
664 struct bt_value *bt_value_string_create_init(const char *val)
665 {
666 struct bt_value_string *string_obj = NULL;
667
668 if (!val) {
669 BT_LOGW_STR("Invalid parameter: value is NULL.");
670 goto end;
671 }
672
673 BT_LOGD("Creating string value object: val-len=%zu", strlen(val));
674 string_obj = g_new0(struct bt_value_string, 1);
675 if (!string_obj) {
676 BT_LOGE_STR("Failed to allocate one string object.");
677 goto end;
678 }
679
680 string_obj->base = bt_value_create_base(BT_VALUE_TYPE_STRING);
681 string_obj->gstr = g_string_new(val);
682 if (!string_obj->gstr) {
683 BT_LOGE_STR("Failed to allocate a GString.");
684 g_free(string_obj);
685 string_obj = NULL;
686 goto end;
687 }
688
689 BT_LOGD("Created string value object: addr=%p",
690 string_obj);
691
692 end:
693 return BT_VALUE_FROM_CONCRETE(string_obj);
694 }
695
696 struct bt_value *bt_value_string_create(void)
697 {
698 return bt_value_string_create_init("");
699 }
700
701 struct bt_value *bt_value_array_create(void)
702 {
703 struct bt_value_array *array_obj;
704
705 BT_LOGD_STR("Creating empty array value object.");
706 array_obj = g_new0(struct bt_value_array, 1);
707 if (!array_obj) {
708 BT_LOGE_STR("Failed to allocate one array object.");
709 goto end;
710 }
711
712 array_obj->base = bt_value_create_base(BT_VALUE_TYPE_ARRAY);
713 array_obj->garray = bt_g_ptr_array_new_full(0,
714 (GDestroyNotify) bt_put);
715 if (!array_obj->garray) {
716 BT_LOGE_STR("Failed to allocate a GPtrArray.");
717 g_free(array_obj);
718 array_obj = NULL;
719 goto end;
720 }
721
722 BT_LOGD("Created array value object: addr=%p",
723 array_obj);
724
725 end:
726 return BT_VALUE_FROM_CONCRETE(array_obj);
727 }
728
729 struct bt_value *bt_value_map_create(void)
730 {
731 struct bt_value_map *map_obj;
732
733 BT_LOGD_STR("Creating empty map value object.");
734 map_obj = g_new0(struct bt_value_map, 1);
735 if (!map_obj) {
736 BT_LOGE_STR("Failed to allocate one map object.");
737 goto end;
738 }
739
740 map_obj->base = bt_value_create_base(BT_VALUE_TYPE_MAP);
741 map_obj->ght = g_hash_table_new_full(g_direct_hash, g_direct_equal,
742 NULL, (GDestroyNotify) bt_put);
743 if (!map_obj->ght) {
744 BT_LOGE_STR("Failed to allocate a GHashTable.");
745 g_free(map_obj);
746 map_obj = NULL;
747 goto end;
748 }
749
750 BT_LOGD("Created map value object: addr=%p",
751 map_obj);
752
753 end:
754 return BT_VALUE_FROM_CONCRETE(map_obj);
755 }
756
757 enum bt_value_status bt_value_bool_get(const struct bt_value *bool_obj,
758 bt_bool *val)
759 {
760 BT_ASSERT_PRE_NON_NULL(bool_obj, "Value object");
761 BT_ASSERT_PRE_NON_NULL(val, "Raw value");
762 BT_ASSERT_PRE_VALUE_IS_TYPE(bool_obj, BT_VALUE_TYPE_BOOL);
763 *val = BT_VALUE_TO_BOOL(bool_obj)->value;
764 return BT_VALUE_STATUS_OK;
765 }
766
767 enum bt_value_status bt_value_bool_set(struct bt_value *bool_obj, bt_bool val)
768 {
769 BT_ASSERT_PRE_NON_NULL(bool_obj, "Value object");
770 BT_ASSERT_PRE_VALUE_IS_TYPE(bool_obj, BT_VALUE_TYPE_BOOL);
771 BT_ASSERT_PRE_VALUE_HOT(bool_obj, "Value object");
772 BT_VALUE_TO_BOOL(bool_obj)->value = val;
773 BT_LOGV("Set boolean value's raw value: value-addr=%p, value=%d",
774 bool_obj, val);
775 return BT_VALUE_STATUS_OK;
776 }
777
778 enum bt_value_status bt_value_integer_get(const struct bt_value *integer_obj,
779 int64_t *val)
780 {
781 BT_ASSERT_PRE_NON_NULL(integer_obj, "Value object");
782 BT_ASSERT_PRE_NON_NULL(val, "Raw value");
783 BT_ASSERT_PRE_VALUE_IS_TYPE(integer_obj, BT_VALUE_TYPE_INTEGER);
784 *val = BT_VALUE_TO_INTEGER(integer_obj)->value;
785 return BT_VALUE_STATUS_OK;
786 }
787
788 enum bt_value_status bt_value_integer_set(struct bt_value *integer_obj,
789 int64_t val)
790 {
791 BT_ASSERT_PRE_NON_NULL(integer_obj, "Value object");
792 BT_ASSERT_PRE_VALUE_IS_TYPE(integer_obj, BT_VALUE_TYPE_INTEGER);
793 BT_ASSERT_PRE_VALUE_HOT(integer_obj, "Value object");
794 BT_VALUE_TO_INTEGER(integer_obj)->value = val;
795 BT_LOGV("Set integer value's raw value: value-addr=%p, value=%" PRId64,
796 integer_obj, val);
797 return BT_VALUE_STATUS_OK;
798 }
799
800 enum bt_value_status bt_value_float_get(const struct bt_value *float_obj,
801 double *val)
802 {
803 BT_ASSERT_PRE_NON_NULL(float_obj, "Value object");
804 BT_ASSERT_PRE_NON_NULL(val, "Raw value");
805 BT_ASSERT_PRE_VALUE_IS_TYPE(float_obj, BT_VALUE_TYPE_FLOAT);
806 *val = BT_VALUE_TO_FLOAT(float_obj)->value;
807 return BT_VALUE_STATUS_OK;
808 }
809
810 enum bt_value_status bt_value_float_set(struct bt_value *float_obj,
811 double val)
812 {
813 BT_ASSERT_PRE_NON_NULL(float_obj, "Value object");
814 BT_ASSERT_PRE_VALUE_IS_TYPE(float_obj, BT_VALUE_TYPE_FLOAT);
815 BT_ASSERT_PRE_VALUE_HOT(float_obj, "Value object");
816 BT_VALUE_TO_FLOAT(float_obj)->value = val;
817 BT_LOGV("Set floating point number value's raw value: value-addr=%p, value=%f",
818 float_obj, val);
819 return BT_VALUE_STATUS_OK;
820 }
821
822 enum bt_value_status bt_value_string_get(const struct bt_value *string_obj,
823 const char **val)
824 {
825 BT_ASSERT_PRE_NON_NULL(string_obj, "Value object");
826 BT_ASSERT_PRE_NON_NULL(val, "Raw value");
827 BT_ASSERT_PRE_VALUE_IS_TYPE(string_obj, BT_VALUE_TYPE_STRING);
828 *val = BT_VALUE_TO_STRING(string_obj)->gstr->str;
829 return BT_VALUE_STATUS_OK;
830 }
831
832 enum bt_value_status bt_value_string_set(struct bt_value *string_obj,
833 const char *val)
834 {
835 BT_ASSERT_PRE_NON_NULL(string_obj, "Value object");
836 BT_ASSERT_PRE_NON_NULL(val, "Raw value");
837 BT_ASSERT_PRE_VALUE_IS_TYPE(string_obj, BT_VALUE_TYPE_STRING);
838 BT_ASSERT_PRE_VALUE_HOT(string_obj, "Value object");
839 g_string_assign(BT_VALUE_TO_STRING(string_obj)->gstr, val);
840 BT_LOGV("Set string value's raw value: value-addr=%p, raw-value-addr=%p",
841 string_obj, val);
842 return BT_VALUE_STATUS_OK;
843 }
844
845 int64_t bt_value_array_size(const struct bt_value *array_obj)
846 {
847 BT_ASSERT_PRE_NON_NULL(array_obj, "Value object");
848 BT_ASSERT_PRE_VALUE_IS_TYPE(array_obj, BT_VALUE_TYPE_ARRAY);
849 return (int64_t) BT_VALUE_TO_ARRAY(array_obj)->garray->len;
850 }
851
852 bt_bool bt_value_array_is_empty(const struct bt_value *array_obj)
853 {
854 return bt_value_array_size(array_obj) == 0;
855 }
856
857 struct bt_value *bt_value_array_get(const struct bt_value *array_obj,
858 uint64_t index)
859 {
860 struct bt_value_array *typed_array_obj =
861 BT_VALUE_TO_ARRAY(array_obj);
862
863 BT_ASSERT_PRE_NON_NULL(array_obj, "Value object");
864 BT_ASSERT_PRE_VALUE_IS_TYPE(array_obj, BT_VALUE_TYPE_ARRAY);
865 BT_ASSERT_PRE_VALUE_INDEX_IN_BOUNDS(index,
866 typed_array_obj->garray->len);
867 return bt_get(g_ptr_array_index(typed_array_obj->garray, index));
868 }
869
870 enum bt_value_status bt_value_array_append(struct bt_value *array_obj,
871 struct bt_value *element_obj)
872 {
873 struct bt_value_array *typed_array_obj =
874 BT_VALUE_TO_ARRAY(array_obj);
875
876 BT_ASSERT_PRE_NON_NULL(array_obj, "Array value object");
877 BT_ASSERT_PRE_NON_NULL(element_obj, "Element value object");
878 BT_ASSERT_PRE_VALUE_IS_TYPE(array_obj, BT_VALUE_TYPE_ARRAY);
879 BT_ASSERT_PRE_VALUE_HOT(array_obj, "Array value object");
880 g_ptr_array_add(typed_array_obj->garray, element_obj);
881 bt_get(element_obj);
882 BT_LOGV("Appended element to array value: array-value-addr=%p, "
883 "element-value-addr=%p, new-size=%u",
884 array_obj, element_obj, typed_array_obj->garray->len);
885 return BT_VALUE_STATUS_OK;
886 }
887
888 enum bt_value_status bt_value_array_append_bool(struct bt_value *array_obj,
889 bt_bool val)
890 {
891 enum bt_value_status ret;
892 struct bt_value *bool_obj = NULL;
893
894 bool_obj = bt_value_bool_create_init(val);
895 ret = bt_value_array_append(array_obj, bool_obj);
896 bt_put(bool_obj);
897 return ret;
898 }
899
900 enum bt_value_status bt_value_array_append_integer(
901 struct bt_value *array_obj, int64_t val)
902 {
903 enum bt_value_status ret;
904 struct bt_value *integer_obj = NULL;
905
906 integer_obj = bt_value_integer_create_init(val);
907 ret = bt_value_array_append(array_obj, integer_obj);
908 bt_put(integer_obj);
909 return ret;
910 }
911
912 enum bt_value_status bt_value_array_append_float(struct bt_value *array_obj,
913 double val)
914 {
915 enum bt_value_status ret;
916 struct bt_value *float_obj = NULL;
917
918 float_obj = bt_value_float_create_init(val);
919 ret = bt_value_array_append(array_obj, float_obj);
920 bt_put(float_obj);
921 return ret;
922 }
923
924 enum bt_value_status bt_value_array_append_string(struct bt_value *array_obj,
925 const char *val)
926 {
927 enum bt_value_status ret;
928 struct bt_value *string_obj = NULL;
929
930 string_obj = bt_value_string_create_init(val);
931 ret = bt_value_array_append(array_obj, string_obj);
932 bt_put(string_obj);
933 return ret;
934 }
935
936 enum bt_value_status bt_value_array_append_empty_array(
937 struct bt_value *array_obj)
938 {
939 enum bt_value_status ret;
940 struct bt_value *empty_array_obj = NULL;
941
942 empty_array_obj = bt_value_array_create();
943 ret = bt_value_array_append(array_obj, empty_array_obj);
944 bt_put(empty_array_obj);
945 return ret;
946 }
947
948 enum bt_value_status bt_value_array_append_empty_map(struct bt_value *array_obj)
949 {
950 enum bt_value_status ret;
951 struct bt_value *map_obj = NULL;
952
953 map_obj = bt_value_map_create();
954 ret = bt_value_array_append(array_obj, map_obj);
955 bt_put(map_obj);
956 return ret;
957 }
958
959 enum bt_value_status bt_value_array_set(struct bt_value *array_obj,
960 uint64_t index, struct bt_value *element_obj)
961 {
962 struct bt_value_array *typed_array_obj =
963 BT_VALUE_TO_ARRAY(array_obj);
964
965 BT_ASSERT_PRE_NON_NULL(array_obj, "Array value object");
966 BT_ASSERT_PRE_NON_NULL(element_obj, "Element value object");
967 BT_ASSERT_PRE_VALUE_IS_TYPE(array_obj, BT_VALUE_TYPE_ARRAY);
968 BT_ASSERT_PRE_VALUE_HOT(array_obj, "Array value object");
969 BT_ASSERT_PRE_VALUE_INDEX_IN_BOUNDS(index,
970 typed_array_obj->garray->len);
971 bt_put(g_ptr_array_index(typed_array_obj->garray, index));
972 g_ptr_array_index(typed_array_obj->garray, index) = element_obj;
973 bt_get(element_obj);
974 BT_LOGV("Set array value's element: array-value-addr=%p, "
975 "index=%" PRIu64 ", element-value-addr=%p",
976 array_obj, index, element_obj);
977 return BT_VALUE_STATUS_OK;
978 }
979
980 int64_t bt_value_map_size(const struct bt_value *map_obj)
981 {
982 BT_ASSERT_PRE_NON_NULL(map_obj, "Value object");
983 BT_ASSERT_PRE_VALUE_IS_TYPE(map_obj, BT_VALUE_TYPE_MAP);
984 return (int64_t) g_hash_table_size(BT_VALUE_TO_MAP(map_obj)->ght);
985 }
986
987 bt_bool bt_value_map_is_empty(const struct bt_value *map_obj)
988 {
989 return bt_value_map_size(map_obj) == 0;
990 }
991
992 struct bt_value *bt_value_map_get(const struct bt_value *map_obj,
993 const char *key)
994 {
995 BT_ASSERT_PRE_NON_NULL(map_obj, "Value object");
996 BT_ASSERT_PRE_NON_NULL(key, "Key");
997 BT_ASSERT_PRE_VALUE_IS_TYPE(map_obj, BT_VALUE_TYPE_MAP);
998 return bt_get(g_hash_table_lookup(BT_VALUE_TO_MAP(map_obj)->ght,
999 GUINT_TO_POINTER(g_quark_from_string(key))));
1000 }
1001
1002 bt_bool bt_value_map_has_key(const struct bt_value *map_obj, const char *key)
1003 {
1004 BT_ASSERT_PRE_NON_NULL(map_obj, "Value object");
1005 BT_ASSERT_PRE_NON_NULL(key, "Key");
1006 BT_ASSERT_PRE_VALUE_IS_TYPE(map_obj, BT_VALUE_TYPE_MAP);
1007 return bt_g_hash_table_contains(BT_VALUE_TO_MAP(map_obj)->ght,
1008 GUINT_TO_POINTER(g_quark_from_string(key)));
1009 }
1010
1011 enum bt_value_status bt_value_map_insert(struct bt_value *map_obj,
1012 const char *key, struct bt_value *element_obj)
1013 {
1014 BT_ASSERT_PRE_NON_NULL(map_obj, "Map value object");
1015 BT_ASSERT_PRE_NON_NULL(key, "Key");
1016 BT_ASSERT_PRE_NON_NULL(element_obj, "Element value object");
1017 BT_ASSERT_PRE_VALUE_IS_TYPE(map_obj, BT_VALUE_TYPE_MAP);
1018 BT_ASSERT_PRE_VALUE_HOT(map_obj, "Map value object");
1019 g_hash_table_insert(BT_VALUE_TO_MAP(map_obj)->ght,
1020 GUINT_TO_POINTER(g_quark_from_string(key)), element_obj);
1021 bt_get(element_obj);
1022 BT_LOGV("Inserted value into map value: map-value-addr=%p, "
1023 "key=\"%s\", element-value-addr=%p",
1024 map_obj, key, element_obj);
1025 return BT_VALUE_STATUS_OK;
1026 }
1027
1028 enum bt_value_status bt_value_map_insert_bool(struct bt_value *map_obj,
1029 const char *key, bt_bool val)
1030 {
1031 enum bt_value_status ret;
1032 struct bt_value *bool_obj = NULL;
1033
1034 bool_obj = bt_value_bool_create_init(val);
1035 ret = bt_value_map_insert(map_obj, key, bool_obj);
1036 bt_put(bool_obj);
1037 return ret;
1038 }
1039
1040 enum bt_value_status bt_value_map_insert_integer(struct bt_value *map_obj,
1041 const char *key, int64_t val)
1042 {
1043 enum bt_value_status ret;
1044 struct bt_value *integer_obj = NULL;
1045
1046 integer_obj = bt_value_integer_create_init(val);
1047 ret = bt_value_map_insert(map_obj, key, integer_obj);
1048 bt_put(integer_obj);
1049 return ret;
1050 }
1051
1052 enum bt_value_status bt_value_map_insert_float(struct bt_value *map_obj,
1053 const char *key, double val)
1054 {
1055 enum bt_value_status ret;
1056 struct bt_value *float_obj = NULL;
1057
1058 float_obj = bt_value_float_create_init(val);
1059 ret = bt_value_map_insert(map_obj, key, float_obj);
1060 bt_put(float_obj);
1061 return ret;
1062 }
1063
1064 enum bt_value_status bt_value_map_insert_string(struct bt_value *map_obj,
1065 const char *key, const char *val)
1066 {
1067 enum bt_value_status ret;
1068 struct bt_value *string_obj = NULL;
1069
1070 string_obj = bt_value_string_create_init(val);
1071 ret = bt_value_map_insert(map_obj, key, string_obj);
1072 bt_put(string_obj);
1073 return ret;
1074 }
1075
1076 enum bt_value_status bt_value_map_insert_empty_array(struct bt_value *map_obj,
1077 const char *key)
1078 {
1079 enum bt_value_status ret;
1080 struct bt_value *array_obj = NULL;
1081
1082 array_obj = bt_value_array_create();
1083 ret = bt_value_map_insert(map_obj, key, array_obj);
1084 bt_put(array_obj);
1085 return ret;
1086 }
1087
1088 enum bt_value_status bt_value_map_insert_empty_map(struct bt_value *map_obj,
1089 const char *key)
1090 {
1091 enum bt_value_status ret;
1092 struct bt_value *empty_map_obj = NULL;
1093
1094 empty_map_obj = bt_value_map_create();
1095 ret = bt_value_map_insert(map_obj, key, empty_map_obj);
1096 bt_put(empty_map_obj);
1097 return ret;
1098 }
1099
1100 enum bt_value_status bt_value_map_foreach(const struct bt_value *map_obj,
1101 bt_value_map_foreach_cb cb, void *data)
1102 {
1103 enum bt_value_status ret = BT_VALUE_STATUS_OK;
1104 gpointer key, element_obj;
1105 GHashTableIter iter;
1106 struct bt_value_map *typed_map_obj = BT_VALUE_TO_MAP(map_obj);
1107
1108 BT_ASSERT_PRE_NON_NULL(map_obj, "Value object");
1109 BT_ASSERT_PRE_NON_NULL(cb, "Callback");
1110 BT_ASSERT_PRE_VALUE_IS_TYPE(map_obj, BT_VALUE_TYPE_MAP);
1111 g_hash_table_iter_init(&iter, typed_map_obj->ght);
1112
1113 while (g_hash_table_iter_next(&iter, &key, &element_obj)) {
1114 const char *key_str = g_quark_to_string(GPOINTER_TO_UINT(key));
1115
1116 if (!cb(key_str, element_obj, data)) {
1117 BT_LOGV("User canceled the loop: key=\"%s\", "
1118 "value-addr=%p, data=%p",
1119 key_str, element_obj, data);
1120 ret = BT_VALUE_STATUS_CANCELED;
1121 break;
1122 }
1123 }
1124
1125 return ret;
1126 }
1127
1128 struct extend_map_element_data {
1129 struct bt_value *extended_obj;
1130 bt_bool got_error;
1131 };
1132
1133 static
1134 bt_bool extend_map_element(const char *key,
1135 struct bt_value *extension_obj_elem, void *data)
1136 {
1137 bt_bool ret = BT_TRUE;
1138
1139 struct extend_map_element_data *extend_data = data;
1140
1141 /* Copy object which is to replace the current one */
1142 struct bt_value *extension_obj_elem_copy =
1143 bt_value_copy(extension_obj_elem);
1144
1145 /* Replace in extended object */
1146 if (bt_value_map_insert(extend_data->extended_obj, key,
1147 extension_obj_elem_copy)) {
1148 BT_LOGE("Cannot replace value in extended value: key=\"%s\", "
1149 "extended-value-addr=%p, element-value-addr=%p",
1150 key, extend_data->extended_obj,
1151 extension_obj_elem_copy);
1152 goto error;
1153 }
1154
1155 goto end;
1156
1157 error:
1158 ret = BT_FALSE;
1159 extend_data->got_error = BT_TRUE;
1160
1161 end:
1162 BT_PUT(extension_obj_elem_copy);
1163 return ret;
1164 }
1165
1166 struct bt_value *bt_value_map_extend(struct bt_value *base_map_obj,
1167 struct bt_value *extension_obj)
1168 {
1169 struct bt_value *extended_obj = NULL;
1170 struct extend_map_element_data extend_data = { 0 };
1171
1172 BT_ASSERT_PRE_NON_NULL(base_map_obj, "Base value object");
1173 BT_ASSERT_PRE_NON_NULL(extension_obj, "Extension value object");
1174 BT_ASSERT_PRE_VALUE_IS_TYPE(base_map_obj, BT_VALUE_TYPE_MAP);
1175 BT_ASSERT_PRE_VALUE_IS_TYPE(extension_obj, BT_VALUE_TYPE_MAP);
1176 BT_LOGD("Extending map value: base-value-addr=%p, extension-value-addr=%p",
1177 base_map_obj, extension_obj);
1178
1179 /* Create copy of base map object to start with */
1180 extended_obj = bt_value_copy(base_map_obj);
1181 if (!extended_obj) {
1182 BT_LOGE("Cannot copy base value: base-value-addr=%p",
1183 base_map_obj);
1184 goto error;
1185 }
1186
1187 /*
1188 * For each key in the extension map object, replace this key
1189 * in the copied map object.
1190 */
1191 extend_data.extended_obj = extended_obj;
1192
1193 if (bt_value_map_foreach(extension_obj, extend_map_element,
1194 &extend_data)) {
1195 BT_LOGE("Cannot iterate on the extension object's elements: "
1196 "extension-value-addr=%p", extension_obj);
1197 goto error;
1198 }
1199
1200 if (extend_data.got_error) {
1201 BT_LOGE("Failed to successfully iterate on the extension object's elements: "
1202 "extension-value-addr=%p", extension_obj);
1203 goto error;
1204 }
1205
1206 BT_LOGD("Extended map value: extended-value-addr=%p",
1207 extended_obj);
1208 goto end;
1209
1210 error:
1211 BT_PUT(extended_obj);
1212
1213 end:
1214 return extended_obj;
1215 }
1216
1217 struct bt_value *bt_value_copy(const struct bt_value *object)
1218 {
1219 struct bt_value *copy_obj = NULL;
1220
1221 BT_ASSERT_PRE_NON_NULL(object, "Value object");
1222 BT_LOGD("Copying value object: addr=%p", object);
1223 copy_obj = copy_funcs[object->type](object);
1224 if (copy_obj) {
1225 BT_LOGD("Copied value object: copy-value-addr=%p",
1226 copy_obj);
1227 } else {
1228 BT_LOGE_STR("Failed to copy value object.");
1229 }
1230
1231 return copy_obj;
1232 }
1233
1234 bt_bool bt_value_compare(const struct bt_value *object_a,
1235 const struct bt_value *object_b)
1236 {
1237 bt_bool ret = BT_FALSE;
1238
1239 BT_ASSERT_PRE_NON_NULL(object_a, "Value object A");
1240 BT_ASSERT_PRE_NON_NULL(object_b, "Value object B");
1241
1242 if (object_a->type != object_b->type) {
1243 BT_LOGV("Values are different: type mismatch: "
1244 "value-a-addr=%p, value-b-addr=%p, "
1245 "value-a-type=%s, value-b-type=%s",
1246 object_a, object_b,
1247 bt_value_type_string(object_a->type),
1248 bt_value_type_string(object_b->type));
1249 goto end;
1250 }
1251
1252 ret = compare_funcs[object_a->type](object_a, object_b);
1253
1254 end:
1255 return ret;
1256 }
BabelTrace - Trace Format Babel Tower
This page took 0.060312 seconds and 5 git commands to generate.