src/cpp-common/bt2/value.hpp

   1 /*
   2  * Copyright (c) 2020 Philippe Proulx <pproulx@efficios.com>
   3  *
   4  * SPDX-License-Identifier: MIT
   5  */
   6
   7 #ifndef BABELTRACE_CPP_COMMON_BT2_VALUE_HPP
   8 #define BABELTRACE_CPP_COMMON_BT2_VALUE_HPP
   9
  10 #include <cstdint>
  11 #include <functional>
  12 #include <type_traits>
  13
  14 #include <babeltrace2/babeltrace.h>
  15
  16 #include "common/assert.h"
  17 #include "common/common.h"
  18 #include "cpp-common/optional.hpp"
  19 #include "cpp-common/string_view.hpp"
  20
  21 #include "borrowed-object.hpp"
  22 #include "common-iterator.hpp"
  23 #include "exc.hpp"
  24 #include "internal/utils.hpp"
  25 #include "shared-object.hpp"
  26
  27 namespace bt2 {
  28 namespace internal {
  29
  30 struct ValueRefFuncs final
  31 {
  32     static void get(const bt_value * const libObjPtr) noexcept
  33     {
  34         bt_value_get_ref(libObjPtr);
  35     }
  36
  37     static void put(const bt_value * const libObjPtr) noexcept
  38     {
  39         bt_value_put_ref(libObjPtr);
  40     }
  41 };
  42
  43 } /* namespace internal */
  44
  45 template <typename ObjT, typename LibObjT>
  46 using SharedValue = SharedObject<ObjT, LibObjT, internal::ValueRefFuncs>;
  47
  48 template <typename LibObjT>
  49 class CommonNullValue;
  50
  51 template <typename LibObjT>
  52 class CommonBoolValue;
  53
  54 template <typename LibObjT>
  55 class CommonUnsignedIntegerValue;
  56
  57 template <typename LibObjT>
  58 class CommonSignedIntegerValue;
  59
  60 template <typename LibObjT>
  61 class CommonRealValue;
  62
  63 template <typename LibObjT>
  64 class CommonStringValue;
  65
  66 template <typename LibObjT>
  67 class CommonArrayValue;
  68
  69 template <typename LibObjT>
  70 class CommonMapValue;
  71
  72 enum class ValueType
  73 {
  74     NUL = BT_VALUE_TYPE_NULL,
  75     BOOL = BT_VALUE_TYPE_BOOL,
  76     UNSIGNED_INTEGER = BT_VALUE_TYPE_UNSIGNED_INTEGER,
  77     SIGNED_INTEGER = BT_VALUE_TYPE_SIGNED_INTEGER,
  78     REAL = BT_VALUE_TYPE_REAL,
  79     STRING = BT_VALUE_TYPE_STRING,
  80     ARRAY = BT_VALUE_TYPE_ARRAY,
  81     MAP = BT_VALUE_TYPE_MAP,
  82 };
  83
  84 template <typename LibObjT>
  85 class CommonValue : public BorrowedObject<LibObjT>
  86 {
  87 private:
  88     using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
  89
  90 protected:
  91     using typename BorrowedObject<LibObjT>::_LibObjPtr;
  92     using _ThisCommonValue = CommonValue<LibObjT>;
  93
  94 public:
  95     using Shared = SharedValue<CommonValue<LibObjT>, LibObjT>;
  96
  97     explicit CommonValue(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
  98     {
  99     }
 100
 101     template <typename OtherLibObjT>
 102     CommonValue(const CommonValue<OtherLibObjT> val) noexcept : _ThisBorrowedObject {val}
 103     {
 104     }
 105
 106     template <typename OtherLibObjT>
 107     _ThisCommonValue& operator=(const CommonValue<OtherLibObjT> val) noexcept
 108     {
 109         _ThisBorrowedObject::operator=(val);
 110         return *this;
 111     }
 112
 113     ValueType type() const noexcept
 114     {
 115         return static_cast<ValueType>(bt_value_get_type(this->libObjPtr()));
 116     }
 117
 118     bool isNull() const noexcept
 119     {
 120         return this->_libTypeIs(BT_VALUE_TYPE_NULL);
 121     }
 122
 123     bool isBool() const noexcept
 124     {
 125         return this->_libTypeIs(BT_VALUE_TYPE_BOOL);
 126     }
 127
 128     bool isInteger() const noexcept
 129     {
 130         return this->_libTypeIs(BT_VALUE_TYPE_INTEGER);
 131     }
 132
 133     bool isUnsignedInteger() const noexcept
 134     {
 135         return this->_libTypeIs(BT_VALUE_TYPE_UNSIGNED_INTEGER);
 136     }
 137
 138     bool isSignedInteger() const noexcept
 139     {
 140         return this->_libTypeIs(BT_VALUE_TYPE_SIGNED_INTEGER);
 141     }
 142
 143     bool isReal() const noexcept
 144     {
 145         return this->_libTypeIs(BT_VALUE_TYPE_REAL);
 146     }
 147
 148     bool isString() const noexcept
 149     {
 150         return this->_libTypeIs(BT_VALUE_TYPE_STRING);
 151     }
 152
 153     bool isArray() const noexcept
 154     {
 155         return this->_libTypeIs(BT_VALUE_TYPE_ARRAY);
 156     }
 157
 158     bool isMap() const noexcept
 159     {
 160         return this->_libTypeIs(BT_VALUE_TYPE_MAP);
 161     }
 162
 163     template <typename OtherLibObjT>
 164     bool operator==(const CommonValue<OtherLibObjT> other) const noexcept
 165     {
 166         return static_cast<bool>(bt_value_is_equal(this->libObjPtr(), other.libObjPtr()));
 167     }
 168
 169     template <typename OtherLibObjT>
 170     bool operator!=(const CommonValue<OtherLibObjT> other) const noexcept
 171     {
 172         return !(*this == other);
 173     }
 174
 175     Shared shared() const noexcept
 176     {
 177         return Shared::createWithRef(*this);
 178     }
 179
 180     template <typename ValueT>
 181     ValueT as() const noexcept
 182     {
 183         return ValueT {this->libObjPtr()};
 184     }
 185
 186     CommonNullValue<LibObjT> asNull() const noexcept;
 187     CommonBoolValue<LibObjT> asBool() const noexcept;
 188     CommonSignedIntegerValue<LibObjT> asSignedInteger() const noexcept;
 189     CommonUnsignedIntegerValue<LibObjT> asUnsignedInteger() const noexcept;
 190     CommonRealValue<LibObjT> asReal() const noexcept;
 191     CommonStringValue<LibObjT> asString() const noexcept;
 192     CommonArrayValue<LibObjT> asArray() const noexcept;
 193     CommonMapValue<LibObjT> asMap() const noexcept;
 194
 195 protected:
 196     bool _libTypeIs(const bt_value_type type) const noexcept
 197     {
 198         return bt_value_type_is(bt_value_get_type(this->libObjPtr()), type);
 199     }
 200 };
 201
 202 using Value = CommonValue<bt_value>;
 203 using ConstValue = CommonValue<const bt_value>;
 204
 205 namespace internal {
 206
 207 struct ValueTypeDescr
 208 {
 209     using Const = ConstValue;
 210     using NonConst = Value;
 211 };
 212
 213 template <>
 214 struct TypeDescr<Value> : public ValueTypeDescr
 215 {
 216 };
 217
 218 template <>
 219 struct TypeDescr<ConstValue> : public ValueTypeDescr
 220 {
 221 };
 222
 223 } /* namespace internal */
 224
 225 template <typename LibObjT>
 226 class CommonNullValue final : public CommonValue<LibObjT>
 227 {
 228 private:
 229     using typename CommonValue<LibObjT>::_ThisCommonValue;
 230
 231 public:
 232     using Shared = SharedValue<CommonNullValue<LibObjT>, LibObjT>;
 233
 234     CommonNullValue() noexcept : _ThisCommonValue {bt_value_null}
 235     {
 236     }
 237
 238     template <typename OtherLibObjT>
 239     CommonNullValue(const CommonNullValue<OtherLibObjT> val) noexcept : _ThisCommonValue {val}
 240     {
 241     }
 242
 243     template <typename OtherLibObjT>
 244     CommonNullValue<LibObjT>& operator=(const CommonNullValue<OtherLibObjT> val) noexcept
 245     {
 246         _ThisCommonValue::operator=(val);
 247         return *this;
 248     }
 249
 250     Shared shared() const noexcept
 251     {
 252         return Shared::createWithRef(*this);
 253     }
 254 };
 255
 256 using NullValue = CommonNullValue<bt_value>;
 257 using ConstNullValue = CommonNullValue<const bt_value>;
 258
 259 namespace internal {
 260
 261 struct NullValueTypeDescr
 262 {
 263     using Const = ConstNullValue;
 264     using NonConst = NullValue;
 265 };
 266
 267 template <>
 268 struct TypeDescr<NullValue> : public NullValueTypeDescr
 269 {
 270 };
 271
 272 template <>
 273 struct TypeDescr<ConstNullValue> : public NullValueTypeDescr
 274 {
 275 };
 276
 277 } /* namespace internal */
 278
 279 template <typename LibObjT>
 280 class CommonBoolValue final : public CommonValue<LibObjT>
 281 {
 282 private:
 283     using typename CommonValue<LibObjT>::_LibObjPtr;
 284     using typename CommonValue<LibObjT>::_ThisCommonValue;
 285
 286 public:
 287     using Shared = SharedValue<CommonBoolValue<LibObjT>, LibObjT>;
 288     using Value = bool;
 289
 290     explicit CommonBoolValue(const _LibObjPtr libObjPtr) noexcept : _ThisCommonValue {libObjPtr}
 291     {
 292         BT_ASSERT_DBG(this->isBool());
 293     }
 294
 295     template <typename OtherLibObjT>
 296     CommonBoolValue(const CommonBoolValue<OtherLibObjT> val) noexcept : _ThisCommonValue {val}
 297     {
 298     }
 299
 300     static Shared create(const Value rawVal = false)
 301     {
 302         const auto libObjPtr = bt_value_bool_create_init(static_cast<bt_bool>(rawVal));
 303
 304         internal::validateCreatedObjPtr(libObjPtr);
 305         return CommonBoolValue::Shared::createWithoutRef(libObjPtr);
 306     }
 307
 308     template <typename OtherLibObjT>
 309     CommonBoolValue<LibObjT>& operator=(const CommonBoolValue<OtherLibObjT> val) noexcept
 310     {
 311         _ThisCommonValue::operator=(val);
 312         return *this;
 313     }
 314
 315     CommonBoolValue<LibObjT> operator=(const Value rawVal) const noexcept
 316     {
 317         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 318
 319         bt_value_bool_set(this->libObjPtr(), static_cast<bt_bool>(rawVal));
 320         return *this;
 321     }
 322
 323     Value value() const noexcept
 324     {
 325         return static_cast<Value>(bt_value_bool_get(this->libObjPtr()));
 326     }
 327
 328     operator Value() const noexcept
 329     {
 330         return this->value();
 331     }
 332
 333     Shared shared() const noexcept
 334     {
 335         return Shared::createWithRef(*this);
 336     }
 337 };
 338
 339 using BoolValue = CommonBoolValue<bt_value>;
 340 using ConstBoolValue = CommonBoolValue<const bt_value>;
 341
 342 namespace internal {
 343
 344 struct BoolValueTypeDescr
 345 {
 346     using Const = ConstBoolValue;
 347     using NonConst = BoolValue;
 348 };
 349
 350 template <>
 351 struct TypeDescr<BoolValue> : public BoolValueTypeDescr
 352 {
 353 };
 354
 355 template <>
 356 struct TypeDescr<ConstBoolValue> : public BoolValueTypeDescr
 357 {
 358 };
 359
 360 } /* namespace internal */
 361
 362 template <typename LibObjT>
 363 class CommonUnsignedIntegerValue final : public CommonValue<LibObjT>
 364 {
 365 private:
 366     using typename CommonValue<LibObjT>::_LibObjPtr;
 367     using typename CommonValue<LibObjT>::_ThisCommonValue;
 368
 369 public:
 370     using Shared = SharedValue<CommonUnsignedIntegerValue<LibObjT>, LibObjT>;
 371     using Value = std::uint64_t;
 372
 373     explicit CommonUnsignedIntegerValue(const _LibObjPtr libObjPtr) noexcept :
 374         _ThisCommonValue {libObjPtr}
 375     {
 376         BT_ASSERT_DBG(this->isUnsignedInteger());
 377     }
 378
 379     static Shared create(const Value rawVal = 0)
 380     {
 381         const auto libObjPtr = bt_value_integer_unsigned_create_init(rawVal);
 382
 383         internal::validateCreatedObjPtr(libObjPtr);
 384         return CommonUnsignedIntegerValue::Shared::createWithoutRef(libObjPtr);
 385     }
 386
 387     template <typename OtherLibObjT>
 388     CommonUnsignedIntegerValue(const CommonUnsignedIntegerValue<OtherLibObjT> val) noexcept :
 389         _ThisCommonValue {val}
 390     {
 391     }
 392
 393     template <typename OtherLibObjT>
 394     CommonUnsignedIntegerValue<LibObjT>&
 395     operator=(const CommonUnsignedIntegerValue<OtherLibObjT> val) noexcept
 396     {
 397         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 398
 399         _ThisCommonValue::operator=(val);
 400         return *this;
 401     }
 402
 403     CommonUnsignedIntegerValue<LibObjT> operator=(const Value rawVal) const noexcept
 404     {
 405         bt_value_integer_unsigned_set(this->libObjPtr(), rawVal);
 406         return *this;
 407     }
 408
 409     Value value() const noexcept
 410     {
 411         return bt_value_integer_unsigned_get(this->libObjPtr());
 412     }
 413
 414     operator Value() const noexcept
 415     {
 416         return this->value();
 417     }
 418
 419     Shared shared() const noexcept
 420     {
 421         return Shared::createWithRef(*this);
 422     }
 423 };
 424
 425 using UnsignedIntegerValue = CommonUnsignedIntegerValue<bt_value>;
 426 using ConstUnsignedIntegerValue = CommonUnsignedIntegerValue<const bt_value>;
 427
 428 namespace internal {
 429
 430 struct UnsignedIntegerValueTypeDescr
 431 {
 432     using Const = ConstUnsignedIntegerValue;
 433     using NonConst = UnsignedIntegerValue;
 434 };
 435
 436 template <>
 437 struct TypeDescr<UnsignedIntegerValue> : public UnsignedIntegerValueTypeDescr
 438 {
 439 };
 440
 441 template <>
 442 struct TypeDescr<ConstUnsignedIntegerValue> : public UnsignedIntegerValueTypeDescr
 443 {
 444 };
 445
 446 } /* namespace internal */
 447
 448 template <typename LibObjT>
 449 class CommonSignedIntegerValue final : public CommonValue<LibObjT>
 450 {
 451 private:
 452     using typename CommonValue<LibObjT>::_LibObjPtr;
 453     using typename CommonValue<LibObjT>::_ThisCommonValue;
 454
 455 public:
 456     using Shared = SharedValue<CommonSignedIntegerValue<LibObjT>, LibObjT>;
 457     using Value = std::int64_t;
 458
 459     explicit CommonSignedIntegerValue(const _LibObjPtr libObjPtr) noexcept :
 460         _ThisCommonValue {libObjPtr}
 461     {
 462         BT_ASSERT_DBG(this->isSignedInteger());
 463     }
 464
 465     static Shared create(const Value rawVal = 0)
 466     {
 467         const auto libObjPtr = bt_value_integer_signed_create_init(rawVal);
 468
 469         internal::validateCreatedObjPtr(libObjPtr);
 470         return CommonSignedIntegerValue::Shared::createWithoutRef(libObjPtr);
 471     }
 472
 473     template <typename OtherLibObjT>
 474     CommonSignedIntegerValue(const CommonSignedIntegerValue<OtherLibObjT> val) noexcept :
 475         _ThisCommonValue {val}
 476     {
 477     }
 478
 479     template <typename OtherLibObjT>
 480     CommonSignedIntegerValue<LibObjT>
 481     operator=(const CommonSignedIntegerValue<OtherLibObjT> val) noexcept
 482     {
 483         _ThisCommonValue::operator=(val);
 484         return *this;
 485     }
 486
 487     CommonSignedIntegerValue<LibObjT> operator=(const Value rawVal) const noexcept
 488     {
 489         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 490
 491         bt_value_integer_signed_set(this->libObjPtr(), rawVal);
 492         return *this;
 493     }
 494
 495     Value value() const noexcept
 496     {
 497         return bt_value_integer_signed_get(this->libObjPtr());
 498     }
 499
 500     operator Value() const noexcept
 501     {
 502         return this->value();
 503     }
 504
 505     Shared shared() const noexcept
 506     {
 507         return Shared::createWithRef(*this);
 508     }
 509 };
 510
 511 using SignedIntegerValue = CommonSignedIntegerValue<bt_value>;
 512 using ConstSignedIntegerValue = CommonSignedIntegerValue<const bt_value>;
 513
 514 namespace internal {
 515
 516 struct SignedIntegerValueTypeDescr
 517 {
 518     using Const = ConstSignedIntegerValue;
 519     using NonConst = SignedIntegerValue;
 520 };
 521
 522 template <>
 523 struct TypeDescr<SignedIntegerValue> : public SignedIntegerValueTypeDescr
 524 {
 525 };
 526
 527 template <>
 528 struct TypeDescr<ConstSignedIntegerValue> : public SignedIntegerValueTypeDescr
 529 {
 530 };
 531
 532 } /* namespace internal */
 533
 534 template <typename LibObjT>
 535 class CommonRealValue final : public CommonValue<LibObjT>
 536 {
 537 private:
 538     using typename CommonValue<LibObjT>::_LibObjPtr;
 539     using typename CommonValue<LibObjT>::_ThisCommonValue;
 540
 541 public:
 542     using Shared = SharedValue<CommonRealValue<LibObjT>, LibObjT>;
 543     using Value = double;
 544
 545     explicit CommonRealValue(const _LibObjPtr libObjPtr) noexcept : _ThisCommonValue {libObjPtr}
 546     {
 547         BT_ASSERT_DBG(this->isReal());
 548     }
 549
 550     static Shared create(const Value rawVal = 0)
 551     {
 552         const auto libObjPtr = bt_value_real_create_init(rawVal);
 553
 554         internal::validateCreatedObjPtr(libObjPtr);
 555         return CommonRealValue::Shared::createWithoutRef(libObjPtr);
 556     }
 557
 558     template <typename OtherLibObjT>
 559     CommonRealValue(const CommonRealValue<OtherLibObjT> val) noexcept : _ThisCommonValue {val}
 560     {
 561     }
 562
 563     template <typename OtherLibObjT>
 564     CommonRealValue<LibObjT>& operator=(const CommonRealValue<OtherLibObjT> val) noexcept
 565     {
 566         _ThisCommonValue::operator=(val);
 567         return *this;
 568     }
 569
 570     CommonRealValue<LibObjT> operator=(const Value rawVal) const noexcept
 571     {
 572         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 573
 574         bt_value_real_set(this->libObjPtr(), rawVal);
 575         return *this;
 576     }
 577
 578     Value value() const noexcept
 579     {
 580         return bt_value_real_get(this->libObjPtr());
 581     }
 582
 583     operator Value() const noexcept
 584     {
 585         return this->value();
 586     }
 587
 588     Shared shared() const noexcept
 589     {
 590         return Shared::createWithRef(*this);
 591     }
 592 };
 593
 594 using RealValue = CommonRealValue<bt_value>;
 595 using ConstRealValue = CommonRealValue<const bt_value>;
 596
 597 namespace internal {
 598
 599 struct RealValueTypeDescr
 600 {
 601     using Const = ConstRealValue;
 602     using NonConst = RealValue;
 603 };
 604
 605 template <>
 606 struct TypeDescr<RealValue> : public RealValueTypeDescr
 607 {
 608 };
 609
 610 template <>
 611 struct TypeDescr<ConstRealValue> : public RealValueTypeDescr
 612 {
 613 };
 614
 615 } /* namespace internal */
 616
 617 template <typename LibObjT>
 618 class CommonStringValue final : public CommonValue<LibObjT>
 619 {
 620 private:
 621     using typename CommonValue<LibObjT>::_LibObjPtr;
 622     using typename CommonValue<LibObjT>::_ThisCommonValue;
 623
 624 public:
 625     using Shared = SharedValue<CommonStringValue<LibObjT>, LibObjT>;
 626
 627     explicit CommonStringValue(const _LibObjPtr libObjPtr) noexcept : _ThisCommonValue {libObjPtr}
 628     {
 629         BT_ASSERT_DBG(this->isString());
 630     }
 631
 632     static Shared create(const char * const rawVal = "")
 633     {
 634         const auto libObjPtr = bt_value_string_create_init(rawVal);
 635
 636         internal::validateCreatedObjPtr(libObjPtr);
 637         return CommonStringValue::Shared::createWithoutRef(libObjPtr);
 638     }
 639
 640     static Shared create(const std::string& rawVal)
 641     {
 642         return CommonStringValue::create(rawVal.data());
 643     }
 644
 645     template <typename OtherLibObjT>
 646     CommonStringValue(const CommonStringValue<OtherLibObjT> val) noexcept : _ThisCommonValue {val}
 647     {
 648     }
 649
 650     template <typename OtherLibObjT>
 651     CommonStringValue<LibObjT>& operator=(const CommonStringValue<OtherLibObjT> val) noexcept
 652     {
 653         _ThisCommonValue::operator=(val);
 654         return *this;
 655     }
 656
 657     CommonStringValue<LibObjT> operator=(const char * const rawVal) const
 658     {
 659         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 660
 661         const auto status = bt_value_string_set(this->libObjPtr(), rawVal);
 662
 663         if (status == BT_VALUE_STRING_SET_STATUS_MEMORY_ERROR) {
 664             throw MemoryError {};
 665         }
 666
 667         return *this;
 668     }
 669
 670     CommonStringValue<LibObjT> operator=(const std::string& rawVal) const noexcept
 671     {
 672         return *this = rawVal.data();
 673     }
 674
 675     bpstd::string_view value() const noexcept
 676     {
 677         return bt_value_string_get(this->libObjPtr());
 678     }
 679
 680     Shared shared() const noexcept
 681     {
 682         return Shared::createWithRef(*this);
 683     }
 684 };
 685
 686 using StringValue = CommonStringValue<bt_value>;
 687 using ConstStringValue = CommonStringValue<const bt_value>;
 688
 689 namespace internal {
 690
 691 struct StringValueTypeDescr
 692 {
 693     using Const = ConstStringValue;
 694     using NonConst = StringValue;
 695 };
 696
 697 template <>
 698 struct TypeDescr<StringValue> : public StringValueTypeDescr
 699 {
 700 };
 701
 702 template <>
 703 struct TypeDescr<ConstStringValue> : public StringValueTypeDescr
 704 {
 705 };
 706
 707 template <typename LibObjT>
 708 struct CommonArrayValueSpec;
 709
 710 /* Functions specific to mutable array values */
 711 template <>
 712 struct CommonArrayValueSpec<bt_value> final
 713 {
 714     static bt_value *elementByIndex(bt_value * const libValPtr, const std::uint64_t index) noexcept
 715     {
 716         return bt_value_array_borrow_element_by_index(libValPtr, index);
 717     }
 718 };
 719
 720 /* Functions specific to constant array values */
 721 template <>
 722 struct CommonArrayValueSpec<const bt_value> final
 723 {
 724     static const bt_value *elementByIndex(const bt_value * const libValPtr,
 725                                           const std::uint64_t index) noexcept
 726     {
 727         return bt_value_array_borrow_element_by_index_const(libValPtr, index);
 728     }
 729 };
 730
 731 } /* namespace internal */
 732
 733 template <typename LibObjT>
 734 class CommonArrayValue final : public CommonValue<LibObjT>
 735 {
 736 private:
 737     using typename CommonValue<LibObjT>::_LibObjPtr;
 738     using typename CommonValue<LibObjT>::_ThisCommonValue;
 739
 740 public:
 741     using Shared = SharedValue<CommonArrayValue<LibObjT>, LibObjT>;
 742     using Iterator = CommonIterator<CommonArrayValue<LibObjT>, CommonValue<LibObjT>>;
 743
 744     explicit CommonArrayValue(const _LibObjPtr libObjPtr) noexcept : _ThisCommonValue {libObjPtr}
 745     {
 746         BT_ASSERT_DBG(this->isArray());
 747     }
 748
 749     static Shared create()
 750     {
 751         const auto libObjPtr = bt_value_array_create();
 752
 753         internal::validateCreatedObjPtr(libObjPtr);
 754         return CommonArrayValue::Shared::createWithoutRef(libObjPtr);
 755     }
 756
 757     template <typename OtherLibObjT>
 758     CommonArrayValue(const CommonArrayValue<OtherLibObjT> val) noexcept : _ThisCommonValue {val}
 759     {
 760     }
 761
 762     template <typename OtherLibObjT>
 763     CommonArrayValue<LibObjT>& operator=(const CommonArrayValue<OtherLibObjT> val) noexcept
 764     {
 765         _ThisCommonValue::operator=(val);
 766         return *this;
 767     }
 768
 769     std::uint64_t length() const noexcept
 770     {
 771         return bt_value_array_get_length(this->libObjPtr());
 772     }
 773
 774     /* Required by the `CommonIterator` template class */
 775     std::uint64_t size() const noexcept
 776     {
 777         return this->length();
 778     }
 779
 780     Iterator begin() const noexcept
 781     {
 782         return Iterator {*this, 0};
 783     }
 784
 785     Iterator end() const noexcept
 786     {
 787         return Iterator {*this, this->length()};
 788     }
 789
 790     bool isEmpty() const noexcept
 791     {
 792         return this->length() == 0;
 793     }
 794
 795     CommonValue<LibObjT> operator[](const std::uint64_t index) const noexcept
 796     {
 797         return CommonValue<LibObjT> {
 798             internal::CommonArrayValueSpec<LibObjT>::elementByIndex(this->libObjPtr(), index)};
 799     }
 800
 801     void append(const Value val) const
 802     {
 803         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 804
 805         const auto status = bt_value_array_append_element(this->libObjPtr(), val.libObjPtr());
 806
 807         this->_handleAppendLibStatus(status);
 808     }
 809
 810     void append(const bool rawVal) const
 811     {
 812         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 813
 814         const auto status =
 815             bt_value_array_append_bool_element(this->libObjPtr(), static_cast<bt_bool>(rawVal));
 816
 817         this->_handleAppendLibStatus(status);
 818     }
 819
 820     void append(const std::uint64_t rawVal) const
 821     {
 822         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 823
 824         const auto status =
 825             bt_value_array_append_unsigned_integer_element(this->libObjPtr(), rawVal);
 826
 827         this->_handleAppendLibStatus(status);
 828     }
 829
 830     void append(const std::int64_t rawVal) const
 831     {
 832         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 833
 834         const auto status = bt_value_array_append_signed_integer_element(this->libObjPtr(), rawVal);
 835
 836         this->_handleAppendLibStatus(status);
 837     }
 838
 839     void append(const double rawVal) const
 840     {
 841         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 842
 843         const auto status = bt_value_array_append_real_element(this->libObjPtr(), rawVal);
 844
 845         this->_handleAppendLibStatus(status);
 846     }
 847
 848     void append(const char * const rawVal) const
 849     {
 850         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 851
 852         const auto status = bt_value_array_append_string_element(this->libObjPtr(), rawVal);
 853
 854         this->_handleAppendLibStatus(status);
 855     }
 856
 857     void append(const std::string& rawVal) const
 858     {
 859         this->append(rawVal.data());
 860     }
 861
 862     CommonArrayValue<bt_value> appendEmptyArray() const;
 863     CommonMapValue<bt_value> appendEmptyMap() const;
 864
 865     void operator+=(const Value val) const
 866     {
 867         this->append(val);
 868     }
 869
 870     void operator+=(const bool rawVal) const
 871     {
 872         this->append(rawVal);
 873     }
 874
 875     void operator+=(const std::uint64_t rawVal) const
 876     {
 877         this->append(rawVal);
 878     }
 879
 880     void operator+=(const std::int64_t rawVal) const
 881     {
 882         this->append(rawVal);
 883     }
 884
 885     void operator+=(const double rawVal) const
 886     {
 887         this->append(rawVal);
 888     }
 889
 890     void operator+=(const char * const rawVal) const
 891     {
 892         this->append(rawVal);
 893     }
 894
 895     void operator+=(const std::string& rawVal) const
 896     {
 897         this->append(rawVal);
 898     }
 899
 900     Shared shared() const noexcept
 901     {
 902         return Shared::createWithRef(*this);
 903     }
 904
 905 private:
 906     void _handleAppendLibStatus(const bt_value_array_append_element_status status) const
 907     {
 908         if (status == BT_VALUE_ARRAY_APPEND_ELEMENT_STATUS_MEMORY_ERROR) {
 909             throw MemoryError {};
 910         }
 911     }
 912 };
 913
 914 using ArrayValue = CommonArrayValue<bt_value>;
 915 using ConstArrayValue = CommonArrayValue<const bt_value>;
 916
 917 namespace internal {
 918
 919 struct ArrayValueTypeDescr
 920 {
 921     using Const = ConstArrayValue;
 922     using NonConst = ArrayValue;
 923 };
 924
 925 template <>
 926 struct TypeDescr<ArrayValue> : public ArrayValueTypeDescr
 927 {
 928 };
 929
 930 template <>
 931 struct TypeDescr<ConstArrayValue> : public ArrayValueTypeDescr
 932 {
 933 };
 934
 935 /*
 936  * Type of a user function passed to `CommonMapValue<ObjT>::forEach()`.
 937  *
 938  * First argument is the entry's key, second is its value.
 939  */
 940 template <typename ObjT>
 941 using CommonMapValueForEachUserFunc = std::function<void(const bpstd::string_view&, ObjT)>;
 942
 943 /*
 944  * Template of a function to be passed to bt_value_map_foreach_entry()
 945  * for bt_value_map_foreach_entry_const() which calls a user function.
 946  *
 947  * `userData` is casted to a `const` pointer to
 948  * `CommonMapValueForEachUserFunc<ObjT>` (the user function to call).
 949  *
 950  * This function catches any exception which the user function throws
 951  * and returns the `ErrorStatus` value. If there's no execption, this
 952  * function returns the `OkStatus` value.
 953  */
 954 template <typename ObjT, typename LibObjT, typename LibStatusT, int OkStatus, int ErrorStatus>
 955 LibStatusT mapValueForEachLibFunc(const char * const key, LibObjT * const libObjPtr,
 956                                   void * const userData)
 957 {
 958     const auto& userFunc = *reinterpret_cast<const CommonMapValueForEachUserFunc<ObjT> *>(userData);
 959
 960     try {
 961         userFunc(key, ObjT {libObjPtr});
 962     } catch (...) {
 963         return static_cast<LibStatusT>(ErrorStatus);
 964     }
 965
 966     return static_cast<LibStatusT>(OkStatus);
 967 }
 968
 969 template <typename LibObjT>
 970 struct CommonMapValueSpec;
 971
 972 /* Functions specific to mutable map values */
 973 template <>
 974 struct CommonMapValueSpec<bt_value> final
 975 {
 976     static bt_value *entryByKey(bt_value * const libValPtr, const char * const key) noexcept
 977     {
 978         return bt_value_map_borrow_entry_value(libValPtr, key);
 979     }
 980
 981     static void forEach(bt_value * const libValPtr,
 982                         const CommonMapValueForEachUserFunc<Value>& func)
 983     {
 984         const auto status = bt_value_map_foreach_entry(
 985             libValPtr,
 986             mapValueForEachLibFunc<Value, bt_value, bt_value_map_foreach_entry_func_status,
 987                                    BT_VALUE_MAP_FOREACH_ENTRY_FUNC_STATUS_OK,
 988                                    BT_VALUE_MAP_FOREACH_ENTRY_FUNC_STATUS_ERROR>,
 989             const_cast<void *>(reinterpret_cast<const void *>(&func)));
 990
 991         switch (status) {
 992         case BT_VALUE_MAP_FOREACH_ENTRY_STATUS_OK:
 993             return;
 994         case BT_VALUE_MAP_FOREACH_ENTRY_STATUS_USER_ERROR:
 995         case BT_VALUE_MAP_FOREACH_ENTRY_STATUS_ERROR:
 996             throw Error {};
 997         default:
 998             bt_common_abort();
 999         }
1000     }
1001 };
1002
1003 /* Functions specific to constant map values */
1004 template <>
1005 struct CommonMapValueSpec<const bt_value> final
1006 {
1007     static const bt_value *entryByKey(const bt_value * const libValPtr,
1008                                       const char * const key) noexcept
1009     {
1010         return bt_value_map_borrow_entry_value_const(libValPtr, key);
1011     }
1012
1013     static void forEach(const bt_value * const libValPtr,
1014                         const CommonMapValueForEachUserFunc<ConstValue>& func)
1015     {
1016         const auto status = bt_value_map_foreach_entry_const(
1017             libValPtr,
1018             mapValueForEachLibFunc<ConstValue, const bt_value,
1019                                    bt_value_map_foreach_entry_const_func_status,
1020                                    BT_VALUE_MAP_FOREACH_ENTRY_CONST_FUNC_STATUS_OK,
1021                                    BT_VALUE_MAP_FOREACH_ENTRY_CONST_FUNC_STATUS_ERROR>,
1022             const_cast<void *>(reinterpret_cast<const void *>(&func)));
1023
1024         switch (status) {
1025         case BT_VALUE_MAP_FOREACH_ENTRY_CONST_STATUS_OK:
1026             return;
1027         case BT_VALUE_MAP_FOREACH_ENTRY_CONST_STATUS_USER_ERROR:
1028         case BT_VALUE_MAP_FOREACH_ENTRY_CONST_STATUS_ERROR:
1029             throw Error {};
1030         default:
1031             bt_common_abort();
1032         }
1033     }
1034 };
1035
1036 } /* namespace internal */
1037
1038 template <typename LibObjT>
1039 class CommonMapValue final : public CommonValue<LibObjT>
1040 {
1041 private:
1042     using typename CommonValue<LibObjT>::_LibObjPtr;
1043     using typename CommonValue<LibObjT>::_ThisCommonValue;
1044
1045 public:
1046     using Shared = SharedValue<CommonMapValue<LibObjT>, LibObjT>;
1047
1048     explicit CommonMapValue(const _LibObjPtr libObjPtr) noexcept : _ThisCommonValue {libObjPtr}
1049     {
1050         BT_ASSERT_DBG(this->isMap());
1051     }
1052
1053     static Shared create()
1054     {
1055         const auto libObjPtr = bt_value_map_create();
1056
1057         internal::validateCreatedObjPtr(libObjPtr);
1058         return CommonMapValue::Shared::createWithoutRef(libObjPtr);
1059     }
1060
1061     template <typename OtherLibObjT>
1062     CommonMapValue(const CommonMapValue<OtherLibObjT> val) noexcept : _ThisCommonValue {val}
1063     {
1064     }
1065
1066     template <typename OtherLibObjT>
1067     CommonMapValue<LibObjT>& operator=(const CommonMapValue<OtherLibObjT> val) noexcept
1068     {
1069         _ThisCommonValue::operator=(val);
1070         return *this;
1071     }
1072
1073     std::uint64_t size() const noexcept
1074     {
1075         return bt_value_map_get_size(this->libObjPtr());
1076     }
1077
1078     bool isEmpty() const noexcept
1079     {
1080         return this->size() == 0;
1081     }
1082
1083     nonstd::optional<CommonValue<LibObjT>> operator[](const char * const key) const noexcept
1084     {
1085         const auto libObjPtr =
1086             internal::CommonMapValueSpec<LibObjT>::entryByKey(this->libObjPtr(), key);
1087
1088         if (!libObjPtr) {
1089             return nonstd::nullopt;
1090         }
1091
1092         return CommonValue<LibObjT> {libObjPtr};
1093     }
1094
1095     nonstd::optional<CommonValue<LibObjT>> operator[](const std::string& key) const noexcept
1096     {
1097         return (*this)[key.data()];
1098     }
1099
1100     bool hasEntry(const char * const key) const noexcept
1101     {
1102         return static_cast<bool>(bt_value_map_has_entry(this->libObjPtr(), key));
1103     }
1104
1105     bool hasEntry(const std::string& key) const noexcept
1106     {
1107         return this->hasEntry(key.data());
1108     }
1109
1110     void insert(const char * const key, const Value val) const
1111     {
1112         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
1113
1114         const auto status = bt_value_map_insert_entry(this->libObjPtr(), key, val.libObjPtr());
1115
1116         this->_handleInsertLibStatus(status);
1117     }
1118
1119     void insert(const std::string& key, const Value val) const
1120     {
1121         this->insert(key.data(), val);
1122     }
1123
1124     void insert(const char * const key, const bool rawVal) const
1125     {
1126         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
1127
1128         const auto status =
1129             bt_value_map_insert_bool_entry(this->libObjPtr(), key, static_cast<bt_bool>(rawVal));
1130
1131         this->_handleInsertLibStatus(status);
1132     }
1133
1134     void insert(const std::string& key, const bool rawVal) const
1135     {
1136         this->insert(key.data(), rawVal);
1137     }
1138
1139     void insert(const char * const key, const std::uint64_t rawVal) const
1140     {
1141         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
1142
1143         const auto status =
1144             bt_value_map_insert_unsigned_integer_entry(this->libObjPtr(), key, rawVal);
1145
1146         this->_handleInsertLibStatus(status);
1147     }
1148
1149     void insert(const std::string& key, const std::uint64_t rawVal) const
1150     {
1151         this->insert(key.data(), rawVal);
1152     }
1153
1154     void insert(const char * const key, const std::int64_t rawVal) const
1155     {
1156         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
1157
1158         const auto status =
1159             bt_value_map_insert_signed_integer_entry(this->libObjPtr(), key, rawVal);
1160
1161         this->_handleInsertLibStatus(status);
1162     }
1163
1164     void insert(const std::string& key, const std::int64_t rawVal) const
1165     {
1166         this->insert(key.data(), rawVal);
1167     }
1168
1169     void insert(const char * const key, const double rawVal) const
1170     {
1171         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
1172
1173         const auto status = bt_value_map_insert_real_entry(this->libObjPtr(), key, rawVal);
1174
1175         this->_handleInsertLibStatus(status);
1176     }
1177
1178     void insert(const std::string& key, const double rawVal) const
1179     {
1180         this->insert(key.data(), rawVal);
1181     }
1182
1183     void insert(const char * const key, const char * const rawVal) const
1184     {
1185         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
1186
1187         const auto status = bt_value_map_insert_string_entry(this->libObjPtr(), key, rawVal);
1188
1189         this->_handleInsertLibStatus(status);
1190     }
1191
1192     void insert(const char * const key, const std::string& rawVal) const
1193     {
1194         this->insert(key, rawVal.data());
1195     }
1196
1197     void insert(const std::string& key, const char * const rawVal) const
1198     {
1199         this->insert(key.data(), rawVal);
1200     }
1201
1202     void insert(const std::string& key, const std::string& rawVal) const
1203     {
1204         this->insert(key.data(), rawVal.data());
1205     }
1206
1207     CommonArrayValue<bt_value> insertEmptyArray(const char *key) const;
1208     CommonArrayValue<bt_value> insertEmptyArray(const std::string& key) const;
1209     CommonMapValue<bt_value> insertEmptyMap(const char *key) const;
1210     CommonMapValue<bt_value> insertEmptyMap(const std::string& key) const;
1211
1212     void forEach(const internal::CommonMapValueForEachUserFunc<CommonValue<LibObjT>>& func) const
1213     {
1214         internal::CommonMapValueSpec<LibObjT>::forEach(this->libObjPtr(), func);
1215     }
1216
1217     Shared shared() const noexcept
1218     {
1219         return Shared::createWithRef(*this);
1220     }
1221
1222 private:
1223     void _handleInsertLibStatus(const bt_value_map_insert_entry_status status) const
1224     {
1225         if (status == BT_VALUE_MAP_INSERT_ENTRY_STATUS_MEMORY_ERROR) {
1226             throw MemoryError {};
1227         }
1228     }
1229 };
1230
1231 using MapValue = CommonMapValue<bt_value>;
1232 using ConstMapValue = CommonMapValue<const bt_value>;
1233
1234 namespace internal {
1235
1236 struct MapValueTypeDescr
1237 {
1238     using Const = ConstMapValue;
1239     using NonConst = MapValue;
1240 };
1241
1242 template <>
1243 struct TypeDescr<MapValue> : public MapValueTypeDescr
1244 {
1245 };
1246
1247 template <>
1248 struct TypeDescr<ConstMapValue> : public MapValueTypeDescr
1249 {
1250 };
1251
1252 } /* namespace internal */
1253
1254 template <typename LibObjT>
1255 CommonNullValue<LibObjT> CommonValue<LibObjT>::asNull() const noexcept
1256 {
1257     BT_ASSERT_DBG(this->isNull());
1258     return CommonNullValue<LibObjT> {this->libObjPtr()};
1259 }
1260
1261 template <typename LibObjT>
1262 CommonBoolValue<LibObjT> CommonValue<LibObjT>::asBool() const noexcept
1263 {
1264     BT_ASSERT_DBG(this->isBool());
1265     return CommonBoolValue<LibObjT> {this->libObjPtr()};
1266 }
1267
1268 template <typename LibObjT>
1269 CommonSignedIntegerValue<LibObjT> CommonValue<LibObjT>::asSignedInteger() const noexcept
1270 {
1271     BT_ASSERT_DBG(this->isSignedInteger());
1272     return CommonSignedIntegerValue<LibObjT> {this->libObjPtr()};
1273 }
1274
1275 template <typename LibObjT>
1276 CommonUnsignedIntegerValue<LibObjT> CommonValue<LibObjT>::asUnsignedInteger() const noexcept
1277 {
1278     BT_ASSERT_DBG(this->isUnsignedInteger());
1279     return CommonUnsignedIntegerValue<LibObjT> {this->libObjPtr()};
1280 }
1281
1282 template <typename LibObjT>
1283 CommonRealValue<LibObjT> CommonValue<LibObjT>::asReal() const noexcept
1284 {
1285     BT_ASSERT_DBG(this->isReal());
1286     return CommonRealValue<LibObjT> {this->libObjPtr()};
1287 }
1288
1289 template <typename LibObjT>
1290 CommonStringValue<LibObjT> CommonValue<LibObjT>::asString() const noexcept
1291 {
1292     BT_ASSERT_DBG(this->isString());
1293     return CommonStringValue<LibObjT> {this->libObjPtr()};
1294 }
1295
1296 template <typename LibObjT>
1297 CommonArrayValue<LibObjT> CommonValue<LibObjT>::asArray() const noexcept
1298 {
1299     BT_ASSERT_DBG(this->isArray());
1300     return CommonArrayValue<LibObjT> {this->libObjPtr()};
1301 }
1302
1303 template <typename LibObjT>
1304 CommonMapValue<LibObjT> CommonValue<LibObjT>::asMap() const noexcept
1305 {
1306     BT_ASSERT_DBG(this->isMap());
1307     return CommonMapValue<LibObjT> {this->libObjPtr()};
1308 }
1309
1310 template <typename LibObjT>
1311 ArrayValue CommonArrayValue<LibObjT>::appendEmptyArray() const
1312 {
1313     static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
1314
1315     bt_value *libElemPtr;
1316     const auto status = bt_value_array_append_empty_array_element(this->libObjPtr(), &libElemPtr);
1317
1318     this->_handleAppendLibStatus(status);
1319     return ArrayValue {libElemPtr};
1320 }
1321
1322 template <typename LibObjT>
1323 MapValue CommonArrayValue<LibObjT>::appendEmptyMap() const
1324 {
1325     static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
1326
1327     bt_value *libElemPtr;
1328     const auto status = bt_value_array_append_empty_map_element(this->libObjPtr(), &libElemPtr);
1329
1330     this->_handleAppendLibStatus(status);
1331     return MapValue {libElemPtr};
1332 }
1333
1334 template <typename LibObjT>
1335 ArrayValue CommonMapValue<LibObjT>::insertEmptyArray(const char * const key) const
1336 {
1337     static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
1338
1339     bt_value *libEntryPtr;
1340     const auto status = bt_value_map_insert_empty_array_entry(this->libObjPtr(), key, &libEntryPtr);
1341
1342     this->_handleInsertLibStatus(status);
1343     return ArrayValue {libEntryPtr};
1344 }
1345
1346 template <typename LibObjT>
1347 ArrayValue CommonMapValue<LibObjT>::insertEmptyArray(const std::string& key) const
1348 {
1349     return this->insertEmptyArray(key.data());
1350 }
1351
1352 template <typename LibObjT>
1353 MapValue CommonMapValue<LibObjT>::insertEmptyMap(const char * const key) const
1354 {
1355     static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
1356
1357     bt_value *libEntryPtr;
1358     const auto status = bt_value_map_insert_empty_map_entry(this->libObjPtr(), key, &libEntryPtr);
1359
1360     this->_handleInsertLibStatus(status);
1361     return MapValue {libEntryPtr};
1362 }
1363
1364 template <typename LibObjT>
1365 MapValue CommonMapValue<LibObjT>::insertEmptyMap(const std::string& key) const
1366 {
1367     return this->insertEmptyMap(key.data());
1368 }
1369
1370 inline BoolValue::Shared createValue(const bool rawVal)
1371 {
1372     return BoolValue::create(rawVal);
1373 }
1374
1375 inline UnsignedIntegerValue::Shared createValue(const std::uint64_t rawVal)
1376 {
1377     return UnsignedIntegerValue::create(rawVal);
1378 }
1379
1380 inline SignedIntegerValue::Shared createValue(const std::int64_t rawVal)
1381 {
1382     return SignedIntegerValue::create(rawVal);
1383 }
1384
1385 inline RealValue::Shared createValue(const double rawVal)
1386 {
1387     return RealValue::create(rawVal);
1388 }
1389
1390 inline StringValue::Shared createValue(const char * const rawVal)
1391 {
1392     return StringValue::create(rawVal);
1393 }
1394
1395 inline StringValue::Shared createValue(const std::string& rawVal)
1396 {
1397     return StringValue::create(rawVal);
1398 }
1399
1400 } /* namespace bt2 */
1401
1402 #endif /* BABELTRACE_CPP_COMMON_BT2_VALUE_HPP */