lib/value.c

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