2 * Copyright (c) 2020 Philippe Proulx <pproulx@efficios.com>
4 * SPDX-License-Identifier: MIT
7 #ifndef BABELTRACE_CPP_COMMON_BT2_FIELD_HPP
8 #define BABELTRACE_CPP_COMMON_BT2_FIELD_HPP
11 #include <type_traits>
13 #include <babeltrace2/babeltrace.h>
15 #include "common/assert.h"
16 #include "cpp-common/optional.hpp"
18 #include "borrowed-object.hpp"
19 #include "field-class.hpp"
20 #include "internal/utils.hpp"
21 #include "raw-value-proxy.hpp"
25 template <typename LibObjT>
26 class CommonBoolField;
28 template <typename LibObjT>
29 class CommonBitArrayField;
31 template <typename LibObjT>
32 class CommonUnsignedIntegerField;
34 template <typename LibObjT>
35 class CommonSignedIntegerField;
37 template <typename LibObjT>
38 class CommonUnsignedEnumerationField;
40 template <typename LibObjT>
41 class CommonSignedEnumerationField;
43 template <typename LibObjT>
44 class CommonSinglePrecisionRealField;
46 template <typename LibObjT>
47 class CommonDoublePrecisionRealField;
49 template <typename LibObjT>
50 class CommonStringField;
52 template <typename LibObjT>
53 class CommonStructureField;
55 template <typename LibObjT>
56 class CommonArrayField;
58 template <typename LibObjT>
59 class CommonDynamicArrayField;
61 template <typename LibObjT>
62 class CommonOptionField;
64 template <typename LibObjT>
65 class CommonVariantField;
69 template <typename LibObjT>
70 struct CommonFieldSpec;
72 /* Functions specific to mutable fields */
74 struct CommonFieldSpec<bt_field> final
76 static bt_field_class *cls(bt_field * const libObjPtr) noexcept
78 return bt_field_borrow_class(libObjPtr);
82 /* Functions specific to constant fields */
84 struct CommonFieldSpec<const bt_field> final
86 static const bt_field_class *cls(const bt_field * const libObjPtr) noexcept
88 return bt_field_borrow_class_const(libObjPtr);
92 } /* namespace internal */
94 template <typename LibObjT>
95 class CommonField : public BorrowedObject<LibObjT>
98 using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
101 using typename BorrowedObject<LibObjT>::_LibObjPtr;
102 using _ThisCommonField = CommonField<LibObjT>;
105 using Class = internal::DepFc<LibObjT>;
107 explicit CommonField(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
111 template <typename OtherLibObjT>
112 CommonField(const CommonField<OtherLibObjT> val) noexcept : _ThisBorrowedObject {val}
116 template <typename OtherLibObjT>
117 _ThisCommonField operator=(const CommonField<OtherLibObjT> val) noexcept
119 _ThisBorrowedObject::operator=(val);
123 CommonField<const bt_field> asConst() const noexcept
125 return CommonField<const bt_field> {*this};
128 FieldClassType classType() const noexcept
130 return static_cast<FieldClassType>(bt_field_get_class_type(this->libObjPtr()));
133 Class cls() const noexcept
135 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
138 bool isBool() const noexcept
140 return this->cls().isBool();
143 bool isBitArray() const noexcept
145 return this->cls().isBitArray();
148 bool isUnsignedInteger() const noexcept
150 return this->cls().isUnsignedInteger();
153 bool isSignedInteger() const noexcept
155 return this->cls().isSignedInteger();
158 bool isUnsignedEnumeration() const noexcept
160 return this->cls().isUnsignedEnumeration();
163 bool isSignedEnumeration() const noexcept
165 return this->cls().isSignedEnumeration();
168 bool isSinglePrecisionReal() const noexcept
170 return this->cls().isSinglePrecisionReal();
173 bool isDoublePrecisionReal() const noexcept
175 return this->cls().isDoublePrecisionReal();
178 bool isString() const noexcept
180 return this->cls().isString();
183 bool isStructure() const noexcept
185 return this->cls().isStructure();
188 bool isArray() const noexcept
190 return this->cls().isArray();
193 bool isDynamicArray() const noexcept
195 return this->cls().isDynamicArray();
198 bool isOption() const noexcept
200 return this->cls().isOption();
203 bool isVariant() const noexcept
205 return this->cls().isVariant();
208 template <typename FieldT>
209 FieldT as() const noexcept
211 return FieldT {this->libObjPtr()};
214 CommonBoolField<LibObjT> asBool() const noexcept;
215 CommonBitArrayField<LibObjT> asBitArray() const noexcept;
216 CommonUnsignedIntegerField<LibObjT> asUnsignedInteger() const noexcept;
217 CommonSignedIntegerField<LibObjT> asSignedInteger() const noexcept;
218 CommonUnsignedEnumerationField<LibObjT> asUnsignedEnumeration() const noexcept;
219 CommonSignedEnumerationField<LibObjT> asSignedEnumeration() const noexcept;
220 CommonSinglePrecisionRealField<LibObjT> asSinglePrecisionReal() const noexcept;
221 CommonDoublePrecisionRealField<LibObjT> asDoublePrecisionReal() const noexcept;
222 CommonStringField<LibObjT> asString() const noexcept;
223 CommonStructureField<LibObjT> asStructure() const noexcept;
224 CommonArrayField<LibObjT> asArray() const noexcept;
225 CommonDynamicArrayField<LibObjT> asDynamicArray() const noexcept;
226 CommonOptionField<LibObjT> asOption() const noexcept;
227 CommonVariantField<LibObjT> asVariant() const noexcept;
230 using Field = CommonField<bt_field>;
231 using ConstField = CommonField<const bt_field>;
235 struct FieldTypeDescr
237 using Const = ConstField;
238 using NonConst = Field;
242 struct TypeDescr<Field> : public FieldTypeDescr
247 struct TypeDescr<ConstField> : public FieldTypeDescr
251 } /* namespace internal */
253 template <typename LibObjT>
254 class CommonBoolField final : public CommonField<LibObjT>
257 using typename CommonField<LibObjT>::_LibObjPtr;
258 using typename CommonField<LibObjT>::_ThisCommonField;
263 explicit CommonBoolField(const _LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
265 BT_ASSERT_DBG(this->isBool());
268 template <typename OtherLibObjT>
269 CommonBoolField(const CommonBoolField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
273 template <typename OtherLibObjT>
274 CommonBoolField<LibObjT> operator=(const CommonBoolField<OtherLibObjT> val) noexcept
276 _ThisCommonField::operator=(val);
280 CommonBoolField<const bt_field> asConst() const noexcept
282 return CommonBoolField<const bt_field> {*this};
285 RawValueProxy<CommonBoolField> operator*() const noexcept
287 return RawValueProxy<CommonBoolField> {*this};
290 void value(const Value val) const noexcept
292 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstBoolField`.");
294 bt_field_bool_set_value(this->libObjPtr(), static_cast<bt_bool>(val));
297 Value value() const noexcept
299 return static_cast<Value>(bt_field_bool_get_value(this->libObjPtr()));
303 using BoolField = CommonBoolField<bt_field>;
304 using ConstBoolField = CommonBoolField<const bt_field>;
308 struct BoolFieldTypeDescr
310 using Const = ConstBoolField;
311 using NonConst = BoolField;
315 struct TypeDescr<BoolField> : public BoolFieldTypeDescr
320 struct TypeDescr<ConstBoolField> : public BoolFieldTypeDescr
324 } /* namespace internal */
326 template <typename LibObjT>
327 class CommonBitArrayField final : public CommonField<LibObjT>
330 using typename CommonField<LibObjT>::_LibObjPtr;
331 using typename CommonField<LibObjT>::_ThisCommonField;
334 using Class = internal::DepType<LibObjT, BitArrayFieldClass, ConstBitArrayFieldClass>;
336 explicit CommonBitArrayField(const _LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
338 BT_ASSERT_DBG(this->isBitArray());
341 template <typename OtherLibObjT>
342 CommonBitArrayField(const CommonBitArrayField<OtherLibObjT> val) noexcept :
343 _ThisCommonField {val}
347 template <typename OtherLibObjT>
348 CommonBitArrayField<LibObjT> operator=(const CommonBitArrayField<OtherLibObjT> val) noexcept
350 _ThisCommonField::operator=(val);
354 CommonBitArrayField<const bt_field> asConst() const noexcept
356 return CommonBitArrayField<const bt_field> {*this};
359 ConstBitArrayFieldClass cls() const noexcept
361 return ConstBitArrayFieldClass {
362 internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
367 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
370 void valueAsInteger(const std::uint64_t bits) const noexcept
372 static_assert(!std::is_const<LibObjT>::value,
373 "Not available with `bt2::ConstBitArrayField`.");
375 bt_field_bit_array_set_value_as_integer(this->libObjPtr(), bits);
378 std::uint64_t valueAsInteger() const noexcept
380 return bt_field_bit_array_get_value_as_integer(this->libObjPtr());
383 bool bitValue(const std::uint64_t index) const noexcept
385 BT_ASSERT_DBG(index < this->cls().length());
386 return static_cast<bool>(this->valueAsInteger() & (1ULL << index));
390 using BitArrayField = CommonBitArrayField<bt_field>;
391 using ConstBitArrayField = CommonBitArrayField<const bt_field>;
395 struct BitArrayFieldTypeDescr
397 using Const = ConstBitArrayField;
398 using NonConst = BitArrayField;
402 struct TypeDescr<BitArrayField> : public BitArrayFieldTypeDescr
407 struct TypeDescr<ConstBitArrayField> : public BitArrayFieldTypeDescr
411 } /* namespace internal */
413 template <typename LibObjT>
414 class CommonUnsignedIntegerField : public CommonField<LibObjT>
417 using typename CommonField<LibObjT>::_ThisCommonField;
420 using typename CommonField<LibObjT>::_LibObjPtr;
421 using _ThisCommonUnsignedIntegerField = CommonUnsignedIntegerField<LibObjT>;
424 using Value = std::uint64_t;
425 using Class = internal::DepType<LibObjT, IntegerFieldClass, ConstIntegerFieldClass>;
427 explicit CommonUnsignedIntegerField(const _LibObjPtr libObjPtr) noexcept :
428 _ThisCommonField {libObjPtr}
430 BT_ASSERT_DBG(this->isUnsignedInteger());
433 template <typename OtherLibObjT>
434 CommonUnsignedIntegerField(const CommonUnsignedIntegerField<OtherLibObjT> val) noexcept :
435 _ThisCommonField {val}
439 template <typename OtherLibObjT>
440 _ThisCommonUnsignedIntegerField
441 operator=(const CommonUnsignedIntegerField<OtherLibObjT> val) noexcept
443 _ThisCommonField::operator=(val);
447 CommonUnsignedIntegerField<const bt_field> asConst() const noexcept
449 return CommonUnsignedIntegerField<const bt_field> {*this};
452 Class cls() const noexcept
454 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
457 RawValueProxy<CommonUnsignedIntegerField> operator*() const noexcept
459 return RawValueProxy<CommonUnsignedIntegerField> {*this};
462 void value(const Value val) const noexcept
464 static_assert(!std::is_const<LibObjT>::value,
465 "Not available with `bt2::ConstUnsignedIntegerField`.");
467 bt_field_integer_unsigned_set_value(this->libObjPtr(), val);
470 Value value() const noexcept
472 return bt_field_integer_unsigned_get_value(this->libObjPtr());
476 using UnsignedIntegerField = CommonUnsignedIntegerField<bt_field>;
477 using ConstUnsignedIntegerField = CommonUnsignedIntegerField<const bt_field>;
481 struct UnsignedIntegerFieldTypeDescr
483 using Const = ConstUnsignedIntegerField;
484 using NonConst = UnsignedIntegerField;
488 struct TypeDescr<UnsignedIntegerField> : public UnsignedIntegerFieldTypeDescr
493 struct TypeDescr<ConstUnsignedIntegerField> : public UnsignedIntegerFieldTypeDescr
497 } /* namespace internal */
499 template <typename LibObjT>
500 class CommonSignedIntegerField : public CommonField<LibObjT>
503 using typename CommonField<LibObjT>::_ThisCommonField;
506 using typename CommonField<LibObjT>::_LibObjPtr;
507 using _ThisCommonSignedIntegerField = CommonSignedIntegerField<LibObjT>;
510 using Value = std::int64_t;
511 using Class = internal::DepType<LibObjT, IntegerFieldClass, ConstIntegerFieldClass>;
513 explicit CommonSignedIntegerField(const _LibObjPtr libObjPtr) noexcept :
514 _ThisCommonField {libObjPtr}
516 BT_ASSERT_DBG(this->isSignedInteger());
519 template <typename OtherLibObjT>
520 CommonSignedIntegerField(const CommonSignedIntegerField<OtherLibObjT> val) noexcept :
521 _ThisCommonField {val}
525 template <typename OtherLibObjT>
526 _ThisCommonSignedIntegerField
527 operator=(const CommonSignedIntegerField<OtherLibObjT> val) noexcept
529 _ThisCommonField::operator=(val);
533 CommonSignedIntegerField<const bt_field> asConst() const noexcept
535 return CommonSignedIntegerField<const bt_field> {*this};
538 Class cls() const noexcept
540 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
543 RawValueProxy<CommonSignedIntegerField> operator*() const noexcept
545 return RawValueProxy<CommonSignedIntegerField> {*this};
548 void value(const Value val) const noexcept
550 static_assert(!std::is_const<LibObjT>::value,
551 "Not available with `bt2::ConstSignedIntegerField`.");
553 bt_field_integer_signed_set_value(this->libObjPtr(), val);
556 Value value() const noexcept
558 return bt_field_integer_signed_get_value(this->libObjPtr());
562 using SignedIntegerField = CommonSignedIntegerField<bt_field>;
563 using ConstSignedIntegerField = CommonSignedIntegerField<const bt_field>;
567 struct SignedIntegerFieldTypeDescr
569 using Const = ConstSignedIntegerField;
570 using NonConst = SignedIntegerField;
574 struct TypeDescr<SignedIntegerField> : public SignedIntegerFieldTypeDescr
579 struct TypeDescr<ConstSignedIntegerField> : public SignedIntegerFieldTypeDescr
583 } /* namespace internal */
585 class EnumerationFieldClassMappingLabels
588 explicit EnumerationFieldClassMappingLabels(
589 const bt_field_class_enumeration_mapping_label_array labels, const std::uint64_t size) :
595 std::uint64_t length() const noexcept
600 const char *operator[](const std::uint64_t index) const noexcept
602 return _mLabels[index];
606 bt_field_class_enumeration_mapping_label_array _mLabels;
610 template <typename LibObjT>
611 class CommonUnsignedEnumerationField final : public CommonUnsignedIntegerField<LibObjT>
614 using typename CommonUnsignedIntegerField<LibObjT>::_ThisCommonUnsignedIntegerField;
615 using typename CommonField<LibObjT>::_LibObjPtr;
618 using Class = internal::DepType<LibObjT, UnsignedEnumerationFieldClass,
619 ConstUnsignedEnumerationFieldClass>;
621 explicit CommonUnsignedEnumerationField(const _LibObjPtr libObjPtr) noexcept :
622 _ThisCommonUnsignedIntegerField {libObjPtr}
624 BT_ASSERT_DBG(this->isUnsignedEnumeration());
627 template <typename OtherLibObjT>
628 CommonUnsignedEnumerationField(const CommonUnsignedEnumerationField<OtherLibObjT> val) noexcept
630 _ThisCommonUnsignedIntegerField {val}
634 template <typename OtherLibObjT>
635 CommonUnsignedEnumerationField<LibObjT>
636 operator=(const CommonUnsignedEnumerationField<OtherLibObjT> val) noexcept
638 _ThisCommonUnsignedIntegerField::operator=(val);
642 CommonUnsignedEnumerationField<const bt_field> asConst() const noexcept
644 return CommonUnsignedEnumerationField<const bt_field> {*this};
647 Class cls() const noexcept
649 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
652 EnumerationFieldClassMappingLabels labels() const
654 bt_field_class_enumeration_mapping_label_array labelArray;
656 const auto status = bt_field_enumeration_unsigned_get_mapping_labels(this->libObjPtr(),
657 &labelArray, &count);
659 if (status == BT_FIELD_ENUMERATION_GET_MAPPING_LABELS_STATUS_MEMORY_ERROR) {
660 throw MemoryError {};
663 return EnumerationFieldClassMappingLabels {labelArray, count};
667 using UnsignedEnumerationField = CommonUnsignedEnumerationField<bt_field>;
668 using ConstUnsignedEnumerationField = CommonUnsignedEnumerationField<const bt_field>;
672 struct UnsignedEnumerationFieldTypeDescr
674 using Const = ConstUnsignedEnumerationField;
675 using NonConst = UnsignedEnumerationField;
679 struct TypeDescr<UnsignedEnumerationField> : public UnsignedEnumerationFieldTypeDescr
684 struct TypeDescr<ConstUnsignedEnumerationField> : public UnsignedEnumerationFieldTypeDescr
688 } /* namespace internal */
690 template <typename LibObjT>
691 class CommonSignedEnumerationField final : public CommonSignedIntegerField<LibObjT>
694 using typename CommonSignedIntegerField<LibObjT>::_ThisCommonSignedIntegerField;
695 using typename CommonField<LibObjT>::_LibObjPtr;
699 internal::DepType<LibObjT, SignedEnumerationFieldClass, ConstSignedEnumerationFieldClass>;
701 explicit CommonSignedEnumerationField(const _LibObjPtr libObjPtr) noexcept :
702 _ThisCommonSignedIntegerField {libObjPtr}
704 BT_ASSERT_DBG(this->isSignedEnumeration());
707 template <typename OtherLibObjT>
708 CommonSignedEnumerationField(const CommonSignedEnumerationField<OtherLibObjT> val) noexcept :
709 _ThisCommonSignedIntegerField {val}
713 template <typename OtherLibObjT>
714 CommonSignedEnumerationField<LibObjT>
715 operator=(const CommonSignedEnumerationField<OtherLibObjT> val) noexcept
717 _ThisCommonSignedIntegerField::operator=(val);
721 CommonSignedEnumerationField<const bt_field> asConst() const noexcept
723 return CommonSignedEnumerationField<const bt_field> {*this};
726 Class cls() const noexcept
728 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
731 EnumerationFieldClassMappingLabels labels() const
733 bt_field_class_enumeration_mapping_label_array labelArray;
736 bt_field_enumeration_signed_get_mapping_labels(this->libObjPtr(), &labelArray, &count);
738 if (status == BT_FIELD_ENUMERATION_GET_MAPPING_LABELS_STATUS_MEMORY_ERROR) {
739 throw MemoryError {};
742 return EnumerationFieldClassMappingLabels {labelArray, count};
746 using SignedEnumerationField = CommonSignedEnumerationField<bt_field>;
747 using ConstSignedEnumerationField = CommonSignedEnumerationField<const bt_field>;
751 struct SignedEnumerationFieldTypeDescr
753 using Const = ConstSignedEnumerationField;
754 using NonConst = SignedEnumerationField;
758 struct TypeDescr<SignedEnumerationField> : public SignedEnumerationFieldTypeDescr
763 struct TypeDescr<ConstSignedEnumerationField> : public SignedEnumerationFieldTypeDescr
767 } /* namespace internal */
769 template <typename LibObjT>
770 class CommonSinglePrecisionRealField final : public CommonField<LibObjT>
773 using typename CommonField<LibObjT>::_LibObjPtr;
774 using typename CommonField<LibObjT>::_ThisCommonField;
779 explicit CommonSinglePrecisionRealField(const _LibObjPtr libObjPtr) noexcept :
780 _ThisCommonField {libObjPtr}
782 BT_ASSERT_DBG(this->isSinglePrecisionReal());
785 template <typename OtherLibObjT>
786 CommonSinglePrecisionRealField(const CommonSinglePrecisionRealField<OtherLibObjT> val) noexcept
788 _ThisCommonField {val}
792 template <typename OtherLibObjT>
793 CommonSinglePrecisionRealField<LibObjT>
794 operator=(const CommonSinglePrecisionRealField<OtherLibObjT> val) noexcept
796 _ThisCommonField::operator=(val);
800 CommonSinglePrecisionRealField<const bt_field> asConst() const noexcept
802 return CommonSinglePrecisionRealField<const bt_field> {*this};
805 RawValueProxy<CommonSinglePrecisionRealField> operator*() const noexcept
807 return RawValueProxy<CommonSinglePrecisionRealField> {*this};
810 void value(const Value val) const noexcept
812 static_assert(!std::is_const<LibObjT>::value,
813 "Not available with `bt2::ConstSinglePrecisionRealField`.");
815 bt_field_real_single_precision_set_value(this->libObjPtr(), val);
818 Value value() const noexcept
820 return bt_field_real_single_precision_get_value(this->libObjPtr());
824 using SinglePrecisionRealField = CommonSinglePrecisionRealField<bt_field>;
825 using ConstSinglePrecisionRealField = CommonSinglePrecisionRealField<const bt_field>;
829 struct SinglePrecisionRealFieldTypeDescr
831 using Const = ConstSinglePrecisionRealField;
832 using NonConst = SinglePrecisionRealField;
836 struct TypeDescr<SinglePrecisionRealField> : public SinglePrecisionRealFieldTypeDescr
841 struct TypeDescr<ConstSinglePrecisionRealField> : public SinglePrecisionRealFieldTypeDescr
845 } /* namespace internal */
847 template <typename LibObjT>
848 class CommonDoublePrecisionRealField final : public CommonField<LibObjT>
851 using typename CommonField<LibObjT>::_LibObjPtr;
852 using typename CommonField<LibObjT>::_ThisCommonField;
855 using Value = double;
857 explicit CommonDoublePrecisionRealField(const _LibObjPtr libObjPtr) noexcept :
858 _ThisCommonField {libObjPtr}
860 BT_ASSERT_DBG(this->isDoublePrecisionReal());
863 template <typename OtherLibObjT>
864 CommonDoublePrecisionRealField(const CommonDoublePrecisionRealField<OtherLibObjT> val) noexcept
866 _ThisCommonField {val}
870 template <typename OtherLibObjT>
871 CommonDoublePrecisionRealField<LibObjT>
872 operator=(const CommonDoublePrecisionRealField<OtherLibObjT> val) noexcept
874 _ThisCommonField::operator=(val);
878 CommonDoublePrecisionRealField<const bt_field> asConst() const noexcept
880 return CommonDoublePrecisionRealField<const bt_field> {*this};
883 RawValueProxy<CommonDoublePrecisionRealField> operator*() const noexcept
885 return RawValueProxy<CommonDoublePrecisionRealField> {*this};
888 void value(const Value val) const noexcept
890 static_assert(!std::is_const<LibObjT>::value,
891 "Not available with `bt2::ConstDoublePrecisionRealField`.");
893 bt_field_real_double_precision_set_value(this->libObjPtr(), val);
896 Value value() const noexcept
898 return bt_field_real_double_precision_get_value(this->libObjPtr());
902 using DoublePrecisionRealField = CommonDoublePrecisionRealField<bt_field>;
903 using ConstDoublePrecisionRealField = CommonDoublePrecisionRealField<const bt_field>;
907 struct DoublePrecisionRealFieldTypeDescr
909 using Const = ConstDoublePrecisionRealField;
910 using NonConst = DoublePrecisionRealField;
914 struct TypeDescr<DoublePrecisionRealField> : public DoublePrecisionRealFieldTypeDescr
919 struct TypeDescr<ConstDoublePrecisionRealField> : public DoublePrecisionRealFieldTypeDescr
923 } /* namespace internal */
925 template <typename LibObjT>
926 class CommonStringField final : public CommonField<LibObjT>
929 using typename CommonField<LibObjT>::_LibObjPtr;
930 using typename CommonField<LibObjT>::_ThisCommonField;
933 using Value = const char *;
935 explicit CommonStringField(const _LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
937 BT_ASSERT_DBG(this->isString());
940 template <typename OtherLibObjT>
941 CommonStringField(const CommonStringField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
945 template <typename OtherLibObjT>
946 CommonStringField<LibObjT> operator=(const CommonStringField<OtherLibObjT> val) noexcept
948 _ThisCommonField::operator=(val);
952 CommonStringField<const bt_field> asConst() const noexcept
954 return CommonStringField<const bt_field> {*this};
957 RawStringValueProxy<CommonStringField> operator*() const noexcept
959 return RawStringValueProxy<CommonStringField> {*this};
962 void value(const char * const val) const
964 static_assert(!std::is_const<LibObjT>::value,
965 "Not available with `bt2::ConstStringField`.");
967 const auto status = bt_field_string_set_value(this->libObjPtr(), val);
969 if (status == BT_FIELD_STRING_SET_VALUE_STATUS_MEMORY_ERROR) {
970 throw MemoryError {};
974 void value(const std::string& val) const
976 this->value(val.data());
979 void append(const char * const begin, const std::uint64_t len) const
981 static_assert(!std::is_const<LibObjT>::value,
982 "Not available with `bt2::ConstStringField`.");
984 const auto status = bt_field_string_append_with_length(this->libObjPtr(), begin, len);
986 if (status == BT_FIELD_STRING_APPEND_STATUS_MEMORY_ERROR) {
987 throw MemoryError {};
991 void append(const std::string& val) const
993 this->append(val.data(), val.size());
996 void clear() const noexcept
998 static_assert(!std::is_const<LibObjT>::value,
999 "Not available with `bt2::ConstStringField`.");
1001 bt_field_string_clear(this->libObjPtr());
1004 const char *value() const noexcept
1006 return bt_field_string_get_value(this->libObjPtr());
1010 using StringField = CommonStringField<bt_field>;
1011 using ConstStringField = CommonStringField<const bt_field>;
1013 namespace internal {
1015 struct StringFieldTypeDescr
1017 using Const = ConstStringField;
1018 using NonConst = StringField;
1022 struct TypeDescr<StringField> : public StringFieldTypeDescr
1027 struct TypeDescr<ConstStringField> : public StringFieldTypeDescr
1031 template <typename LibObjT>
1032 struct CommonStructureFieldSpec;
1034 /* Functions specific to mutable structure fields */
1036 struct CommonStructureFieldSpec<bt_field> final
1038 static bt_field *memberFieldByIndex(bt_field * const libObjPtr,
1039 const std::uint64_t index) noexcept
1041 return bt_field_structure_borrow_member_field_by_index(libObjPtr, index);
1044 static bt_field *memberFieldByName(bt_field * const libObjPtr, const char * const name) noexcept
1046 return bt_field_structure_borrow_member_field_by_name(libObjPtr, name);
1050 /* Functions specific to constant structure fields */
1052 struct CommonStructureFieldSpec<const bt_field> final
1054 static const bt_field *memberFieldByIndex(const bt_field * const libObjPtr,
1055 const std::uint64_t index) noexcept
1057 return bt_field_structure_borrow_member_field_by_index_const(libObjPtr, index);
1060 static const bt_field *memberFieldByName(const bt_field * const libObjPtr,
1061 const char * const name) noexcept
1063 return bt_field_structure_borrow_member_field_by_name_const(libObjPtr, name);
1067 } /* namespace internal */
1069 template <typename LibObjT>
1070 class CommonStructureField final : public CommonField<LibObjT>
1073 using typename CommonField<LibObjT>::_LibObjPtr;
1074 using typename CommonField<LibObjT>::_ThisCommonField;
1075 using _Spec = internal::CommonStructureFieldSpec<LibObjT>;
1078 using Class = internal::DepType<LibObjT, StructureFieldClass, ConstStructureFieldClass>;
1080 explicit CommonStructureField(const _LibObjPtr libObjPtr) noexcept :
1081 _ThisCommonField {libObjPtr}
1083 BT_ASSERT_DBG(this->isStructure());
1086 template <typename OtherLibObjT>
1087 CommonStructureField(const CommonStructureField<OtherLibObjT> val) noexcept :
1088 _ThisCommonField {val}
1092 template <typename OtherLibObjT>
1093 CommonStructureField<LibObjT> operator=(const CommonStructureField<OtherLibObjT> val) noexcept
1095 _ThisCommonField::operator=(val);
1099 CommonStructureField<const bt_field> asConst() const noexcept
1101 return CommonStructureField<const bt_field> {*this};
1104 Class cls() const noexcept
1106 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
1109 std::uint64_t length() const noexcept
1111 return this->cls().length();
1114 CommonField<LibObjT> operator[](const std::uint64_t index) const noexcept
1116 return CommonField<LibObjT> {_Spec::memberFieldByIndex(this->libObjPtr(), index)};
1119 nonstd::optional<CommonField<LibObjT>> operator[](const char * const name) const noexcept
1121 const auto libObjPtr = _Spec::memberFieldByName(this->libObjPtr(), name);
1124 return CommonField<LibObjT> {libObjPtr};
1127 return nonstd::nullopt;
1130 nonstd::optional<CommonField<LibObjT>> operator[](const std::string& name) const noexcept
1132 return (*this)[name.data()];
1136 using StructureField = CommonStructureField<bt_field>;
1137 using ConstStructureField = CommonStructureField<const bt_field>;
1139 namespace internal {
1141 struct StructureFieldTypeDescr
1143 using Const = ConstStructureField;
1144 using NonConst = StructureField;
1148 struct TypeDescr<StructureField> : public StructureFieldTypeDescr
1153 struct TypeDescr<ConstStructureField> : public StructureFieldTypeDescr
1157 template <typename LibObjT>
1158 struct CommonArrayFieldSpec;
1160 /* Functions specific to mutable array fields */
1162 struct CommonArrayFieldSpec<bt_field> final
1164 static bt_field *elementFieldByIndex(bt_field * const libObjPtr,
1165 const std::uint64_t index) noexcept
1167 return bt_field_array_borrow_element_field_by_index(libObjPtr, index);
1171 /* Functions specific to constant array fields */
1173 struct CommonArrayFieldSpec<const bt_field> final
1175 static const bt_field *elementFieldByIndex(const bt_field * const libObjPtr,
1176 const std::uint64_t index) noexcept
1178 return bt_field_array_borrow_element_field_by_index_const(libObjPtr, index);
1182 } /* namespace internal */
1184 template <typename LibObjT>
1185 class CommonArrayField : public CommonField<LibObjT>
1188 using typename CommonField<LibObjT>::_ThisCommonField;
1189 using _Spec = internal::CommonArrayFieldSpec<LibObjT>;
1192 using typename CommonField<LibObjT>::_LibObjPtr;
1193 using _ThisCommonArrayField = CommonArrayField<LibObjT>;
1196 using Class = internal::DepType<LibObjT, ArrayFieldClass, ConstArrayFieldClass>;
1198 explicit CommonArrayField(const _LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
1200 BT_ASSERT_DBG(this->isArray());
1203 template <typename OtherLibObjT>
1204 CommonArrayField(const CommonArrayField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
1208 template <typename OtherLibObjT>
1209 _ThisCommonArrayField operator=(const CommonArrayField<OtherLibObjT> val) noexcept
1211 _ThisCommonField::operator=(val);
1215 CommonArrayField<const bt_field> asConst() const noexcept
1217 return CommonArrayField<const bt_field> {*this};
1220 Class cls() const noexcept
1222 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
1225 std::uint64_t length() const noexcept
1227 return bt_field_array_get_length(this->libObjPtr());
1230 CommonField<LibObjT> operator[](const std::uint64_t index) const noexcept
1232 return CommonField<LibObjT> {_Spec::elementFieldByIndex(this->libObjPtr(), index)};
1236 using ArrayField = CommonArrayField<bt_field>;
1237 using ConstArrayField = CommonArrayField<const bt_field>;
1239 namespace internal {
1241 struct ArrayFieldTypeDescr
1243 using Const = ConstArrayField;
1244 using NonConst = ArrayField;
1248 struct TypeDescr<ArrayField> : public ArrayFieldTypeDescr
1253 struct TypeDescr<ConstArrayField> : public ArrayFieldTypeDescr
1257 } /* namespace internal */
1259 template <typename LibObjT>
1260 class CommonDynamicArrayField : public CommonArrayField<LibObjT>
1263 using typename CommonField<LibObjT>::_LibObjPtr;
1264 using typename CommonArrayField<LibObjT>::_ThisCommonArrayField;
1267 explicit CommonDynamicArrayField(const _LibObjPtr libObjPtr) noexcept :
1268 _ThisCommonArrayField {libObjPtr}
1270 BT_ASSERT_DBG(this->isDynamicArray());
1273 template <typename OtherLibObjT>
1274 CommonDynamicArrayField(const CommonDynamicArrayField<OtherLibObjT> val) noexcept :
1275 _ThisCommonArrayField {val}
1279 template <typename OtherLibObjT>
1280 CommonDynamicArrayField<LibObjT>
1281 operator=(const CommonDynamicArrayField<OtherLibObjT> val) noexcept
1283 _ThisCommonArrayField::operator=(val);
1287 CommonDynamicArrayField<const bt_field> asConst() const noexcept
1289 return CommonDynamicArrayField<const bt_field> {*this};
1292 std::uint64_t length() const noexcept
1294 return _ThisCommonArrayField::length();
1297 void length(const std::uint64_t length) const
1299 static_assert(!std::is_const<LibObjT>::value,
1300 "Not available with `bt2::ConstDynamicArrayField`.");
1302 const auto status = bt_field_array_dynamic_set_length(this->libObjPtr(), length);
1304 if (status == BT_FIELD_DYNAMIC_ARRAY_SET_LENGTH_STATUS_MEMORY_ERROR) {
1305 throw MemoryError {};
1310 using DynamicArrayField = CommonDynamicArrayField<bt_field>;
1311 using ConstDynamicArrayField = CommonDynamicArrayField<const bt_field>;
1313 namespace internal {
1315 struct DynamicArrayFieldTypeDescr
1317 using Const = ConstDynamicArrayField;
1318 using NonConst = DynamicArrayField;
1322 struct TypeDescr<DynamicArrayField> : public DynamicArrayFieldTypeDescr
1327 struct TypeDescr<ConstDynamicArrayField> : public DynamicArrayFieldTypeDescr
1331 template <typename LibObjT>
1332 struct CommonOptionFieldSpec;
1334 /* Functions specific to mutable option fields */
1336 struct CommonOptionFieldSpec<bt_field> final
1338 static bt_field *field(bt_field * const libObjPtr) noexcept
1340 return bt_field_option_borrow_field(libObjPtr);
1344 /* Functions specific to constant option fields */
1346 struct CommonOptionFieldSpec<const bt_field> final
1348 static const bt_field *field(const bt_field * const libObjPtr) noexcept
1350 return bt_field_option_borrow_field_const(libObjPtr);
1354 } /* namespace internal */
1356 template <typename LibObjT>
1357 class CommonOptionField : public CommonField<LibObjT>
1360 using typename CommonField<LibObjT>::_LibObjPtr;
1361 using typename CommonField<LibObjT>::_ThisCommonField;
1362 using _Spec = internal::CommonOptionFieldSpec<LibObjT>;
1365 using Class = internal::DepType<LibObjT, OptionFieldClass, ConstOptionFieldClass>;
1367 explicit CommonOptionField(const _LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
1369 BT_ASSERT_DBG(this->isOption());
1372 template <typename OtherLibObjT>
1373 CommonOptionField(const CommonOptionField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
1377 template <typename OtherLibObjT>
1378 CommonOptionField<LibObjT> operator=(const CommonOptionField<OtherLibObjT> val) noexcept
1380 _ThisCommonField::operator=(val);
1384 CommonOptionField<const bt_field> asConst() const noexcept
1386 return CommonOptionField<const bt_field> {*this};
1389 Class cls() const noexcept
1391 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
1394 void hasField(const bool hasField) const noexcept
1396 static_assert(!std::is_const<LibObjT>::value,
1397 "Not available with `bt2::ConstOptionField`.");
1399 bt_field_option_set_has_field(this->libObjPtr(), static_cast<bt_bool>(hasField));
1402 bool hasField() const noexcept
1404 return this->field().has_value();
1407 nonstd::optional<CommonField<LibObjT>> field() const noexcept
1409 const auto libObjPtr = _Spec::field(this->libObjPtr());
1412 return CommonField<LibObjT> {libObjPtr};
1415 return nonstd::nullopt;
1419 using OptionField = CommonOptionField<bt_field>;
1420 using ConstOptionField = CommonOptionField<const bt_field>;
1422 namespace internal {
1424 struct OptionFieldTypeDescr
1426 using Const = ConstOptionField;
1427 using NonConst = OptionField;
1431 struct TypeDescr<OptionField> : public OptionFieldTypeDescr
1436 struct TypeDescr<ConstOptionField> : public OptionFieldTypeDescr
1440 template <typename LibObjT>
1441 struct CommonVariantFieldSpec;
1443 /* Functions specific to mutable variant fields */
1445 struct CommonVariantFieldSpec<bt_field> final
1447 static bt_field *selectedOptionField(bt_field * const libObjPtr) noexcept
1449 return bt_field_variant_borrow_selected_option_field(libObjPtr);
1453 /* Functions specific to constant variant fields */
1455 struct CommonVariantFieldSpec<const bt_field> final
1457 static const bt_field *selectedOptionField(const bt_field * const libObjPtr) noexcept
1459 return bt_field_variant_borrow_selected_option_field_const(libObjPtr);
1463 } /* namespace internal */
1465 template <typename LibObjT>
1466 class CommonVariantField : public CommonField<LibObjT>
1469 using typename CommonField<LibObjT>::_LibObjPtr;
1470 using typename CommonField<LibObjT>::_ThisCommonField;
1471 using _Spec = internal::CommonVariantFieldSpec<LibObjT>;
1474 using Class = internal::DepType<LibObjT, VariantFieldClass, ConstVariantFieldClass>;
1476 explicit CommonVariantField(const _LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
1478 BT_ASSERT_DBG(this->isVariant());
1481 template <typename OtherLibObjT>
1482 CommonVariantField(const CommonVariantField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
1486 template <typename OtherLibObjT>
1487 CommonVariantField<LibObjT> operator=(const CommonVariantField<OtherLibObjT> val) noexcept
1489 _ThisCommonField::operator=(val);
1493 CommonVariantField<const bt_field> asConst() const noexcept
1495 return CommonVariantField<const bt_field> {*this};
1498 Class cls() const noexcept
1500 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
1503 void selectOption(const std::uint64_t index) const noexcept
1505 static_assert(!std::is_const<LibObjT>::value,
1506 "Not available with `bt2::ConstVariantField`.");
1508 static_cast<void>(bt_field_variant_select_option_by_index(this->libObjPtr(), index));
1511 CommonField<LibObjT> selectedOptionField() const noexcept
1513 return CommonField<LibObjT> {_Spec::selectedOptionField(this->libObjPtr())};
1516 std::uint64_t selectedOptionIndex() const noexcept
1518 return bt_field_variant_get_selected_option_index(this->libObjPtr());
1522 using VariantField = CommonVariantField<bt_field>;
1523 using ConstVariantField = CommonVariantField<const bt_field>;
1525 namespace internal {
1527 struct VariantFieldTypeDescr
1529 using Const = ConstVariantField;
1530 using NonConst = VariantField;
1534 struct TypeDescr<VariantField> : public VariantFieldTypeDescr
1539 struct TypeDescr<ConstVariantField> : public VariantFieldTypeDescr
1543 } /* namespace internal */
1545 template <typename LibObjT>
1546 CommonBoolField<LibObjT> CommonField<LibObjT>::asBool() const noexcept
1548 BT_ASSERT_DBG(this->isBool());
1549 return CommonBoolField<LibObjT> {this->libObjPtr()};
1552 template <typename LibObjT>
1553 CommonBitArrayField<LibObjT> CommonField<LibObjT>::asBitArray() const noexcept
1555 BT_ASSERT_DBG(this->isBitArray());
1556 return CommonBitArrayField<LibObjT> {this->libObjPtr()};
1559 template <typename LibObjT>
1560 CommonUnsignedIntegerField<LibObjT> CommonField<LibObjT>::asUnsignedInteger() const noexcept
1562 BT_ASSERT_DBG(this->isUnsignedInteger());
1563 return CommonUnsignedIntegerField<LibObjT> {this->libObjPtr()};
1566 template <typename LibObjT>
1567 CommonSignedIntegerField<LibObjT> CommonField<LibObjT>::asSignedInteger() const noexcept
1569 BT_ASSERT_DBG(this->isSignedInteger());
1570 return CommonSignedIntegerField<LibObjT> {this->libObjPtr()};
1573 template <typename LibObjT>
1574 CommonUnsignedEnumerationField<LibObjT> CommonField<LibObjT>::asUnsignedEnumeration() const noexcept
1576 BT_ASSERT_DBG(this->isUnsignedEnumeration());
1577 return CommonUnsignedEnumerationField<LibObjT> {this->libObjPtr()};
1580 template <typename LibObjT>
1581 CommonSignedEnumerationField<LibObjT> CommonField<LibObjT>::asSignedEnumeration() const noexcept
1583 BT_ASSERT_DBG(this->isSignedEnumeration());
1584 return CommonSignedEnumerationField<LibObjT> {this->libObjPtr()};
1587 template <typename LibObjT>
1588 CommonSinglePrecisionRealField<LibObjT> CommonField<LibObjT>::asSinglePrecisionReal() const noexcept
1590 BT_ASSERT_DBG(this->isSinglePrecisionReal());
1591 return CommonSinglePrecisionRealField<LibObjT> {this->libObjPtr()};
1594 template <typename LibObjT>
1595 CommonDoublePrecisionRealField<LibObjT> CommonField<LibObjT>::asDoublePrecisionReal() const noexcept
1597 BT_ASSERT_DBG(this->isDoublePrecisionReal());
1598 return CommonDoublePrecisionRealField<LibObjT> {this->libObjPtr()};
1601 template <typename LibObjT>
1602 CommonStringField<LibObjT> CommonField<LibObjT>::asString() const noexcept
1604 BT_ASSERT_DBG(this->isString());
1605 return CommonStringField<LibObjT> {this->libObjPtr()};
1608 template <typename LibObjT>
1609 CommonStructureField<LibObjT> CommonField<LibObjT>::asStructure() const noexcept
1611 BT_ASSERT_DBG(this->isStructure());
1612 return CommonStructureField<LibObjT> {this->libObjPtr()};
1615 template <typename LibObjT>
1616 CommonArrayField<LibObjT> CommonField<LibObjT>::asArray() const noexcept
1618 BT_ASSERT_DBG(this->isArray());
1619 return CommonArrayField<LibObjT> {this->libObjPtr()};
1622 template <typename LibObjT>
1623 CommonDynamicArrayField<LibObjT> CommonField<LibObjT>::asDynamicArray() const noexcept
1625 BT_ASSERT_DBG(this->isDynamicArray());
1626 return CommonDynamicArrayField<LibObjT> {this->libObjPtr()};
1629 template <typename LibObjT>
1630 CommonOptionField<LibObjT> CommonField<LibObjT>::asOption() const noexcept
1632 BT_ASSERT_DBG(this->isOption());
1633 return CommonOptionField<LibObjT> {this->libObjPtr()};
1636 template <typename LibObjT>
1637 CommonVariantField<LibObjT> CommonField<LibObjT>::asVariant() const noexcept
1639 BT_ASSERT_DBG(this->isVariant());
1640 return CommonVariantField<LibObjT> {this->libObjPtr()};
1643 } /* namespace bt2 */
1645 #endif /* BABELTRACE_CPP_COMMON_BT2_FIELD_HPP */