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/bt2c/c-string-view.hpp"
17 #include "cpp-common/bt2s/span.hpp"
19 #include "borrowed-object.hpp"
20 #include "field-class.hpp"
21 #include "internal/utils.hpp"
22 #include "optional-borrowed-object.hpp"
23 #include "raw-value-proxy.hpp"
27 template <typename LibObjT>
28 class CommonBoolField;
30 template <typename LibObjT>
31 class CommonBitArrayField;
33 template <typename LibObjT>
34 class CommonUnsignedIntegerField;
36 template <typename LibObjT>
37 class CommonSignedIntegerField;
39 template <typename LibObjT>
40 class CommonUnsignedEnumerationField;
42 template <typename LibObjT>
43 class CommonSignedEnumerationField;
45 template <typename LibObjT>
46 class CommonSinglePrecisionRealField;
48 template <typename LibObjT>
49 class CommonDoublePrecisionRealField;
51 template <typename LibObjT>
52 class CommonStringField;
54 template <typename LibObjT>
55 class CommonBlobField;
57 template <typename LibObjT>
58 class CommonDynamicBlobField;
60 template <typename LibObjT>
61 class CommonStructureField;
63 template <typename LibObjT>
64 class CommonArrayField;
66 template <typename LibObjT>
67 class CommonDynamicArrayField;
69 template <typename LibObjT>
70 class CommonOptionField;
72 template <typename LibObjT>
73 class CommonVariantField;
77 template <typename LibObjT>
78 struct CommonFieldSpec;
80 /* Functions specific to mutable fields */
82 struct CommonFieldSpec<bt_field> final
84 static bt_field_class *cls(bt_field * const libObjPtr) noexcept
86 return bt_field_borrow_class(libObjPtr);
90 /* Functions specific to constant fields */
92 struct CommonFieldSpec<const bt_field> final
94 static const bt_field_class *cls(const bt_field * const libObjPtr) noexcept
96 return bt_field_borrow_class_const(libObjPtr);
100 } /* namespace internal */
102 template <typename LibObjT>
103 class CommonField : public BorrowedObject<LibObjT>
106 using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
109 using _ThisCommonField = CommonField<LibObjT>;
112 using typename BorrowedObject<LibObjT>::LibObjPtr;
113 using Class = internal::DepFc<LibObjT>;
115 explicit CommonField(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
119 template <typename OtherLibObjT>
120 CommonField(const CommonField<OtherLibObjT> val) noexcept : _ThisBorrowedObject {val}
124 template <typename OtherLibObjT>
125 _ThisCommonField operator=(const CommonField<OtherLibObjT> val) noexcept
127 _ThisBorrowedObject::operator=(val);
131 CommonField<const bt_field> asConst() const noexcept
133 return CommonField<const bt_field> {*this};
136 FieldClassType classType() const noexcept
138 return static_cast<FieldClassType>(bt_field_get_class_type(this->libObjPtr()));
141 Class cls() const noexcept
143 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
146 bool isBool() const noexcept
148 return this->cls().isBool();
151 bool isBitArray() const noexcept
153 return this->cls().isBitArray();
156 bool isUnsignedInteger() const noexcept
158 return this->cls().isUnsignedInteger();
161 bool isSignedInteger() const noexcept
163 return this->cls().isSignedInteger();
166 bool isUnsignedEnumeration() const noexcept
168 return this->cls().isUnsignedEnumeration();
171 bool isSignedEnumeration() const noexcept
173 return this->cls().isSignedEnumeration();
176 bool isSinglePrecisionReal() const noexcept
178 return this->cls().isSinglePrecisionReal();
181 bool isDoublePrecisionReal() const noexcept
183 return this->cls().isDoublePrecisionReal();
186 bool isString() const noexcept
188 return this->cls().isString();
191 bool isBlob() const noexcept
193 return this->cls().isBlob();
196 bool isDynamicBlob() const noexcept
198 return this->cls().isDynamicBlob();
201 bool isStructure() const noexcept
203 return this->cls().isStructure();
206 bool isArray() const noexcept
208 return this->cls().isArray();
211 bool isDynamicArray() const noexcept
213 return this->cls().isDynamicArray();
216 bool isOption() const noexcept
218 return this->cls().isOption();
221 bool isVariant() const noexcept
223 return this->cls().isVariant();
226 template <typename FieldT>
227 FieldT as() const noexcept
229 return FieldT {this->libObjPtr()};
232 CommonBoolField<LibObjT> asBool() const noexcept;
233 CommonBitArrayField<LibObjT> asBitArray() const noexcept;
234 CommonUnsignedIntegerField<LibObjT> asUnsignedInteger() const noexcept;
235 CommonSignedIntegerField<LibObjT> asSignedInteger() const noexcept;
236 CommonUnsignedEnumerationField<LibObjT> asUnsignedEnumeration() const noexcept;
237 CommonSignedEnumerationField<LibObjT> asSignedEnumeration() const noexcept;
238 CommonSinglePrecisionRealField<LibObjT> asSinglePrecisionReal() const noexcept;
239 CommonDoublePrecisionRealField<LibObjT> asDoublePrecisionReal() const noexcept;
240 CommonStringField<LibObjT> asString() const noexcept;
241 CommonBlobField<LibObjT> asBlob() const noexcept;
242 CommonDynamicBlobField<LibObjT> asDynamicBlob() const noexcept;
243 CommonStructureField<LibObjT> asStructure() const noexcept;
244 CommonArrayField<LibObjT> asArray() const noexcept;
245 CommonDynamicArrayField<LibObjT> asDynamicArray() const noexcept;
246 CommonOptionField<LibObjT> asOption() const noexcept;
247 CommonVariantField<LibObjT> asVariant() const noexcept;
250 using Field = CommonField<bt_field>;
251 using ConstField = CommonField<const bt_field>;
255 struct FieldTypeDescr
257 using Const = ConstField;
258 using NonConst = Field;
262 struct TypeDescr<Field> : public FieldTypeDescr
267 struct TypeDescr<ConstField> : public FieldTypeDescr
271 } /* namespace internal */
273 template <typename LibObjT>
274 class CommonBoolField final : public CommonField<LibObjT>
277 using typename CommonField<LibObjT>::_ThisCommonField;
280 using typename CommonField<LibObjT>::LibObjPtr;
283 explicit CommonBoolField(const LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
285 BT_ASSERT_DBG(this->isBool());
288 template <typename OtherLibObjT>
289 CommonBoolField(const CommonBoolField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
293 template <typename OtherLibObjT>
294 CommonBoolField<LibObjT> operator=(const CommonBoolField<OtherLibObjT> val) noexcept
296 _ThisCommonField::operator=(val);
300 CommonBoolField<const bt_field> asConst() const noexcept
302 return CommonBoolField<const bt_field> {*this};
305 RawValueProxy<CommonBoolField> operator*() const noexcept
307 return RawValueProxy<CommonBoolField> {*this};
310 CommonBoolField value(const Value val) const noexcept
312 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstBoolField`.");
314 bt_field_bool_set_value(this->libObjPtr(), static_cast<bt_bool>(val));
318 Value value() const noexcept
320 return static_cast<Value>(bt_field_bool_get_value(this->libObjPtr()));
324 using BoolField = CommonBoolField<bt_field>;
325 using ConstBoolField = CommonBoolField<const bt_field>;
329 struct BoolFieldTypeDescr
331 using Const = ConstBoolField;
332 using NonConst = BoolField;
336 struct TypeDescr<BoolField> : public BoolFieldTypeDescr
341 struct TypeDescr<ConstBoolField> : public BoolFieldTypeDescr
345 } /* namespace internal */
347 template <typename LibLabelArrayT>
351 explicit Labels(const LibLabelArrayT labels, const std::uint64_t size) :
352 _mLabels {labels}, _mLen {size}
356 std::uint64_t length() const noexcept
361 bt2c::CStringView operator[](const std::uint64_t index) const noexcept
363 return _mLabels[index];
367 LibLabelArrayT _mLabels;
371 template <typename LibObjT>
372 class CommonBitArrayField final : public CommonField<LibObjT>
375 using typename CommonField<LibObjT>::_ThisCommonField;
378 using typename CommonField<LibObjT>::LibObjPtr;
379 using Class = internal::DepType<LibObjT, BitArrayFieldClass, ConstBitArrayFieldClass>;
381 explicit CommonBitArrayField(const LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
383 BT_ASSERT_DBG(this->isBitArray());
386 template <typename OtherLibObjT>
387 CommonBitArrayField(const CommonBitArrayField<OtherLibObjT> val) noexcept :
388 _ThisCommonField {val}
392 template <typename OtherLibObjT>
393 CommonBitArrayField<LibObjT> operator=(const CommonBitArrayField<OtherLibObjT> val) noexcept
395 _ThisCommonField::operator=(val);
399 CommonBitArrayField<const bt_field> asConst() const noexcept
401 return CommonBitArrayField<const bt_field> {*this};
404 Class cls() const noexcept
406 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
409 CommonBitArrayField valueAsInteger(const std::uint64_t bits) const noexcept
411 static_assert(!std::is_const<LibObjT>::value,
412 "Not available with `bt2::ConstBitArrayField`.");
414 bt_field_bit_array_set_value_as_integer(this->libObjPtr(), bits);
418 std::uint64_t valueAsInteger() const noexcept
420 return bt_field_bit_array_get_value_as_integer(this->libObjPtr());
423 bool bitValue(const std::uint64_t index) const noexcept
425 BT_ASSERT_DBG(index < this->cls().length());
426 return static_cast<bool>(this->valueAsInteger() & (1ULL << index));
429 Labels<bt_field_class_bit_array_flag_label_array> activeFlagLabels() const
431 bt_field_class_bit_array_flag_label_array labelArray;
434 if (bt_field_bit_array_get_active_flag_labels(this->libObjPtr(), &labelArray, &count) ==
435 BT_FIELD_BIT_ARRAY_GET_ACTIVE_FLAG_LABELS_STATUS_MEMORY_ERROR) {
436 throw MemoryError {};
439 return Labels<bt_field_class_bit_array_flag_label_array> {labelArray, count};
443 using BitArrayField = CommonBitArrayField<bt_field>;
444 using ConstBitArrayField = CommonBitArrayField<const bt_field>;
448 struct BitArrayFieldTypeDescr
450 using Const = ConstBitArrayField;
451 using NonConst = BitArrayField;
455 struct TypeDescr<BitArrayField> : public BitArrayFieldTypeDescr
460 struct TypeDescr<ConstBitArrayField> : public BitArrayFieldTypeDescr
464 } /* namespace internal */
466 template <typename LibObjT>
467 class CommonUnsignedIntegerField : public CommonField<LibObjT>
470 using typename CommonField<LibObjT>::_ThisCommonField;
473 using _ThisCommonUnsignedIntegerField = CommonUnsignedIntegerField<LibObjT>;
476 using typename CommonField<LibObjT>::LibObjPtr;
477 using Value = std::uint64_t;
478 using Class = internal::DepType<LibObjT, IntegerFieldClass, ConstIntegerFieldClass>;
480 explicit CommonUnsignedIntegerField(const LibObjPtr libObjPtr) noexcept :
481 _ThisCommonField {libObjPtr}
483 BT_ASSERT_DBG(this->isUnsignedInteger());
486 template <typename OtherLibObjT>
487 CommonUnsignedIntegerField(const CommonUnsignedIntegerField<OtherLibObjT> val) noexcept :
488 _ThisCommonField {val}
492 template <typename OtherLibObjT>
493 _ThisCommonUnsignedIntegerField
494 operator=(const CommonUnsignedIntegerField<OtherLibObjT> val) noexcept
496 _ThisCommonField::operator=(val);
500 CommonUnsignedIntegerField<const bt_field> asConst() const noexcept
502 return CommonUnsignedIntegerField<const bt_field> {*this};
505 Class cls() const noexcept
507 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
510 RawValueProxy<CommonUnsignedIntegerField> operator*() const noexcept
512 return RawValueProxy<CommonUnsignedIntegerField> {*this};
515 CommonUnsignedIntegerField value(const Value val) const noexcept
517 static_assert(!std::is_const<LibObjT>::value,
518 "Not available with `bt2::ConstUnsignedIntegerField`.");
520 bt_field_integer_unsigned_set_value(this->libObjPtr(), val);
524 Value value() const noexcept
526 return bt_field_integer_unsigned_get_value(this->libObjPtr());
530 using UnsignedIntegerField = CommonUnsignedIntegerField<bt_field>;
531 using ConstUnsignedIntegerField = CommonUnsignedIntegerField<const bt_field>;
535 struct UnsignedIntegerFieldTypeDescr
537 using Const = ConstUnsignedIntegerField;
538 using NonConst = UnsignedIntegerField;
542 struct TypeDescr<UnsignedIntegerField> : public UnsignedIntegerFieldTypeDescr
547 struct TypeDescr<ConstUnsignedIntegerField> : public UnsignedIntegerFieldTypeDescr
551 } /* namespace internal */
553 template <typename LibObjT>
554 class CommonSignedIntegerField : public CommonField<LibObjT>
557 using typename CommonField<LibObjT>::_ThisCommonField;
560 using _ThisCommonSignedIntegerField = CommonSignedIntegerField<LibObjT>;
563 using typename CommonField<LibObjT>::LibObjPtr;
564 using Value = std::int64_t;
565 using Class = internal::DepType<LibObjT, IntegerFieldClass, ConstIntegerFieldClass>;
567 explicit CommonSignedIntegerField(const LibObjPtr libObjPtr) noexcept :
568 _ThisCommonField {libObjPtr}
570 BT_ASSERT_DBG(this->isSignedInteger());
573 template <typename OtherLibObjT>
574 CommonSignedIntegerField(const CommonSignedIntegerField<OtherLibObjT> val) noexcept :
575 _ThisCommonField {val}
579 template <typename OtherLibObjT>
580 _ThisCommonSignedIntegerField
581 operator=(const CommonSignedIntegerField<OtherLibObjT> val) noexcept
583 _ThisCommonField::operator=(val);
587 CommonSignedIntegerField<const bt_field> asConst() const noexcept
589 return CommonSignedIntegerField<const bt_field> {*this};
592 Class cls() const noexcept
594 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
597 RawValueProxy<CommonSignedIntegerField> operator*() const noexcept
599 return RawValueProxy<CommonSignedIntegerField> {*this};
602 CommonSignedIntegerField value(const Value val) const noexcept
604 static_assert(!std::is_const<LibObjT>::value,
605 "Not available with `bt2::ConstSignedIntegerField`.");
607 bt_field_integer_signed_set_value(this->libObjPtr(), val);
611 Value value() const noexcept
613 return bt_field_integer_signed_get_value(this->libObjPtr());
617 using SignedIntegerField = CommonSignedIntegerField<bt_field>;
618 using ConstSignedIntegerField = CommonSignedIntegerField<const bt_field>;
622 struct SignedIntegerFieldTypeDescr
624 using Const = ConstSignedIntegerField;
625 using NonConst = SignedIntegerField;
629 struct TypeDescr<SignedIntegerField> : public SignedIntegerFieldTypeDescr
634 struct TypeDescr<ConstSignedIntegerField> : public SignedIntegerFieldTypeDescr
638 } /* namespace internal */
640 template <typename LibObjT>
641 class CommonUnsignedEnumerationField final : public CommonUnsignedIntegerField<LibObjT>
644 using typename CommonUnsignedIntegerField<LibObjT>::_ThisCommonUnsignedIntegerField;
647 using typename CommonField<LibObjT>::LibObjPtr;
649 using Class = internal::DepType<LibObjT, UnsignedEnumerationFieldClass,
650 ConstUnsignedEnumerationFieldClass>;
652 explicit CommonUnsignedEnumerationField(const LibObjPtr libObjPtr) noexcept :
653 _ThisCommonUnsignedIntegerField {libObjPtr}
655 BT_ASSERT_DBG(this->isUnsignedEnumeration());
658 template <typename OtherLibObjT>
659 CommonUnsignedEnumerationField(const CommonUnsignedEnumerationField<OtherLibObjT> val) noexcept
661 _ThisCommonUnsignedIntegerField {val}
665 template <typename OtherLibObjT>
666 CommonUnsignedEnumerationField<LibObjT>
667 operator=(const CommonUnsignedEnumerationField<OtherLibObjT> val) noexcept
669 _ThisCommonUnsignedIntegerField::operator=(val);
673 CommonUnsignedEnumerationField<const bt_field> asConst() const noexcept
675 return CommonUnsignedEnumerationField<const bt_field> {*this};
678 Class cls() const noexcept
680 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
683 Labels<bt_field_class_enumeration_mapping_label_array> labels() const
685 bt_field_class_enumeration_mapping_label_array labelArray;
687 const auto status = bt_field_enumeration_unsigned_get_mapping_labels(this->libObjPtr(),
688 &labelArray, &count);
690 if (status == BT_FIELD_ENUMERATION_GET_MAPPING_LABELS_STATUS_MEMORY_ERROR) {
691 throw MemoryError {};
694 return Labels<bt_field_class_enumeration_mapping_label_array> {labelArray, count};
698 using UnsignedEnumerationField = CommonUnsignedEnumerationField<bt_field>;
699 using ConstUnsignedEnumerationField = CommonUnsignedEnumerationField<const bt_field>;
703 struct UnsignedEnumerationFieldTypeDescr
705 using Const = ConstUnsignedEnumerationField;
706 using NonConst = UnsignedEnumerationField;
710 struct TypeDescr<UnsignedEnumerationField> : public UnsignedEnumerationFieldTypeDescr
715 struct TypeDescr<ConstUnsignedEnumerationField> : public UnsignedEnumerationFieldTypeDescr
719 } /* namespace internal */
721 template <typename LibObjT>
722 class CommonSignedEnumerationField final : public CommonSignedIntegerField<LibObjT>
725 using typename CommonSignedIntegerField<LibObjT>::_ThisCommonSignedIntegerField;
728 using typename CommonField<LibObjT>::LibObjPtr;
731 internal::DepType<LibObjT, SignedEnumerationFieldClass, ConstSignedEnumerationFieldClass>;
733 explicit CommonSignedEnumerationField(const LibObjPtr libObjPtr) noexcept :
734 _ThisCommonSignedIntegerField {libObjPtr}
736 BT_ASSERT_DBG(this->isSignedEnumeration());
739 template <typename OtherLibObjT>
740 CommonSignedEnumerationField(const CommonSignedEnumerationField<OtherLibObjT> val) noexcept :
741 _ThisCommonSignedIntegerField {val}
745 template <typename OtherLibObjT>
746 CommonSignedEnumerationField<LibObjT>
747 operator=(const CommonSignedEnumerationField<OtherLibObjT> val) noexcept
749 _ThisCommonSignedIntegerField::operator=(val);
753 CommonSignedEnumerationField<const bt_field> asConst() const noexcept
755 return CommonSignedEnumerationField<const bt_field> {*this};
758 Class cls() const noexcept
760 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
763 Labels<bt_field_class_enumeration_mapping_label_array> mappingLabels() const
765 bt_field_class_enumeration_mapping_label_array labelArray;
768 bt_field_enumeration_signed_get_mapping_labels(this->libObjPtr(), &labelArray, &count);
770 if (status == BT_FIELD_ENUMERATION_GET_MAPPING_LABELS_STATUS_MEMORY_ERROR) {
771 throw MemoryError {};
774 return Labels<bt_field_class_enumeration_mapping_label_array> {labelArray, count};
778 using SignedEnumerationField = CommonSignedEnumerationField<bt_field>;
779 using ConstSignedEnumerationField = CommonSignedEnumerationField<const bt_field>;
783 struct SignedEnumerationFieldTypeDescr
785 using Const = ConstSignedEnumerationField;
786 using NonConst = SignedEnumerationField;
790 struct TypeDescr<SignedEnumerationField> : public SignedEnumerationFieldTypeDescr
795 struct TypeDescr<ConstSignedEnumerationField> : public SignedEnumerationFieldTypeDescr
799 } /* namespace internal */
801 template <typename LibObjT>
802 class CommonSinglePrecisionRealField final : public CommonField<LibObjT>
805 using typename CommonField<LibObjT>::_ThisCommonField;
808 using typename CommonField<LibObjT>::LibObjPtr;
811 explicit CommonSinglePrecisionRealField(const LibObjPtr libObjPtr) noexcept :
812 _ThisCommonField {libObjPtr}
814 BT_ASSERT_DBG(this->isSinglePrecisionReal());
817 template <typename OtherLibObjT>
818 CommonSinglePrecisionRealField(const CommonSinglePrecisionRealField<OtherLibObjT> val) noexcept
820 _ThisCommonField {val}
824 template <typename OtherLibObjT>
825 CommonSinglePrecisionRealField<LibObjT>
826 operator=(const CommonSinglePrecisionRealField<OtherLibObjT> val) noexcept
828 _ThisCommonField::operator=(val);
832 CommonSinglePrecisionRealField<const bt_field> asConst() const noexcept
834 return CommonSinglePrecisionRealField<const bt_field> {*this};
837 RawValueProxy<CommonSinglePrecisionRealField> operator*() const noexcept
839 return RawValueProxy<CommonSinglePrecisionRealField> {*this};
842 CommonSinglePrecisionRealField value(const Value val) const noexcept
844 static_assert(!std::is_const<LibObjT>::value,
845 "Not available with `bt2::ConstSinglePrecisionRealField`.");
847 bt_field_real_single_precision_set_value(this->libObjPtr(), val);
851 Value value() const noexcept
853 return bt_field_real_single_precision_get_value(this->libObjPtr());
857 using SinglePrecisionRealField = CommonSinglePrecisionRealField<bt_field>;
858 using ConstSinglePrecisionRealField = CommonSinglePrecisionRealField<const bt_field>;
862 struct SinglePrecisionRealFieldTypeDescr
864 using Const = ConstSinglePrecisionRealField;
865 using NonConst = SinglePrecisionRealField;
869 struct TypeDescr<SinglePrecisionRealField> : public SinglePrecisionRealFieldTypeDescr
874 struct TypeDescr<ConstSinglePrecisionRealField> : public SinglePrecisionRealFieldTypeDescr
878 } /* namespace internal */
880 template <typename LibObjT>
881 class CommonDoublePrecisionRealField final : public CommonField<LibObjT>
884 using typename CommonField<LibObjT>::_ThisCommonField;
887 using typename CommonField<LibObjT>::LibObjPtr;
888 using Value = double;
890 explicit CommonDoublePrecisionRealField(const LibObjPtr libObjPtr) noexcept :
891 _ThisCommonField {libObjPtr}
893 BT_ASSERT_DBG(this->isDoublePrecisionReal());
896 template <typename OtherLibObjT>
897 CommonDoublePrecisionRealField(const CommonDoublePrecisionRealField<OtherLibObjT> val) noexcept
899 _ThisCommonField {val}
903 template <typename OtherLibObjT>
904 CommonDoublePrecisionRealField<LibObjT>
905 operator=(const CommonDoublePrecisionRealField<OtherLibObjT> val) noexcept
907 _ThisCommonField::operator=(val);
911 CommonDoublePrecisionRealField<const bt_field> asConst() const noexcept
913 return CommonDoublePrecisionRealField<const bt_field> {*this};
916 RawValueProxy<CommonDoublePrecisionRealField> operator*() const noexcept
918 return RawValueProxy<CommonDoublePrecisionRealField> {*this};
921 CommonDoublePrecisionRealField value(const Value val) const noexcept
923 static_assert(!std::is_const<LibObjT>::value,
924 "Not available with `bt2::ConstDoublePrecisionRealField`.");
926 bt_field_real_double_precision_set_value(this->libObjPtr(), val);
930 Value value() const noexcept
932 return bt_field_real_double_precision_get_value(this->libObjPtr());
936 using DoublePrecisionRealField = CommonDoublePrecisionRealField<bt_field>;
937 using ConstDoublePrecisionRealField = CommonDoublePrecisionRealField<const bt_field>;
941 struct DoublePrecisionRealFieldTypeDescr
943 using Const = ConstDoublePrecisionRealField;
944 using NonConst = DoublePrecisionRealField;
948 struct TypeDescr<DoublePrecisionRealField> : public DoublePrecisionRealFieldTypeDescr
953 struct TypeDescr<ConstDoublePrecisionRealField> : public DoublePrecisionRealFieldTypeDescr
957 } /* namespace internal */
959 template <typename LibObjT>
960 class CommonStringField final : public CommonField<LibObjT>
963 using typename CommonField<LibObjT>::_ThisCommonField;
966 using typename CommonField<LibObjT>::LibObjPtr;
967 using Value = bt2c::CStringView;
969 explicit CommonStringField(const LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
971 BT_ASSERT_DBG(this->isString());
974 template <typename OtherLibObjT>
975 CommonStringField(const CommonStringField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
979 template <typename OtherLibObjT>
980 CommonStringField<LibObjT> operator=(const CommonStringField<OtherLibObjT> val) noexcept
982 _ThisCommonField::operator=(val);
986 CommonStringField<const bt_field> asConst() const noexcept
988 return CommonStringField<const bt_field> {*this};
991 RawValueProxy<CommonStringField> operator*() const noexcept
993 return RawValueProxy<CommonStringField> {*this};
996 CommonStringField value(const Value val) const
998 static_assert(!std::is_const<LibObjT>::value,
999 "Not available with `bt2::ConstStringField`.");
1001 const auto status = bt_field_string_set_value(this->libObjPtr(), *val);
1003 if (status == BT_FIELD_STRING_SET_VALUE_STATUS_MEMORY_ERROR) {
1004 throw MemoryError {};
1010 CommonStringField append(const bt2c::CStringView begin, const std::uint64_t len) const
1012 static_assert(!std::is_const<LibObjT>::value,
1013 "Not available with `bt2::ConstStringField`.");
1015 const auto status = bt_field_string_append_with_length(this->libObjPtr(), begin, len);
1017 if (status == BT_FIELD_STRING_APPEND_STATUS_MEMORY_ERROR) {
1018 throw MemoryError {};
1024 CommonStringField append(const bt2c::CStringView val) const
1026 return this->append(val, std::strlen(val));
1029 CommonStringField append(const std::string& val) const
1031 return this->append(val.data(), val.size());
1034 CommonStringField clear() const noexcept
1036 static_assert(!std::is_const<LibObjT>::value,
1037 "Not available with `bt2::ConstStringField`.");
1039 bt_field_string_clear(this->libObjPtr());
1043 Value value() const noexcept
1045 return bt_field_string_get_value(this->libObjPtr());
1048 std::uint64_t length() const noexcept
1050 return bt_field_string_get_length(this->libObjPtr());
1054 using StringField = CommonStringField<bt_field>;
1055 using ConstStringField = CommonStringField<const bt_field>;
1057 namespace internal {
1059 struct StringFieldTypeDescr
1061 using Const = ConstStringField;
1062 using NonConst = StringField;
1066 struct TypeDescr<StringField> : public StringFieldTypeDescr
1071 struct TypeDescr<ConstStringField> : public StringFieldTypeDescr
1075 template <typename LibObjT>
1076 struct CommonBlobFieldSpec;
1079 struct CommonBlobFieldSpec<bt_field> final
1081 using Data = std::uint8_t;
1083 static Data *data(bt_field * const libObjPtr) noexcept
1085 return bt_field_blob_get_data(libObjPtr);
1090 struct CommonBlobFieldSpec<const bt_field> final
1092 using Data = const std::uint8_t;
1094 static Data *data(const bt_field * const libObjPtr) noexcept
1096 return bt_field_blob_get_data_const(libObjPtr);
1100 } /* namespace internal */
1102 template <typename LibObjT>
1103 class CommonBlobField : public CommonField<LibObjT>
1106 using typename CommonField<LibObjT>::_ThisCommonField;
1109 using _ThisCommonBlobField = CommonBlobField<LibObjT>;
1112 using typename CommonField<LibObjT>::LibObjPtr;
1115 explicit CommonBlobField(const LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
1117 BT_ASSERT_DBG(this->isBlob());
1120 template <typename OtherLibObjT>
1121 CommonBlobField(const CommonBlobField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
1125 template <typename OtherLibObjT>
1126 CommonBlobField operator=(const CommonBlobField<OtherLibObjT> val) noexcept
1128 _ThisCommonField::operator=(val);
1132 CommonBlobField<const bt_field> asConst() const noexcept
1134 return CommonBlobField<const bt_field> {*this};
1137 bt2s::span<typename internal::CommonBlobFieldSpec<LibObjT>::Data> data() const noexcept
1139 return {internal::CommonBlobFieldSpec<LibObjT>::data(this->libObjPtr()), this->length()};
1142 std::uint64_t length() const noexcept
1144 return bt_field_blob_get_length(this->libObjPtr());
1148 using BlobField = CommonBlobField<bt_field>;
1149 using ConstBlobField = CommonBlobField<const bt_field>;
1151 namespace internal {
1153 struct BlobFieldTypeDescr
1155 using Const = ConstBlobField;
1156 using NonConst = BlobField;
1160 struct TypeDescr<BlobField> : public BlobFieldTypeDescr
1165 struct TypeDescr<ConstBlobField> : public BlobFieldTypeDescr
1169 } /* namespace internal */
1171 template <typename LibObjT>
1172 class CommonDynamicBlobField final : public CommonBlobField<LibObjT>
1175 using typename CommonBlobField<LibObjT>::_ThisCommonBlobField;
1178 using typename CommonBlobField<LibObjT>::LibObjPtr;
1181 explicit CommonDynamicBlobField(const LibObjPtr libObjPtr) noexcept :
1182 _ThisCommonBlobField {libObjPtr}
1184 BT_ASSERT_DBG(this->isDynamicBlob());
1187 template <typename OtherLibObjT>
1188 CommonDynamicBlobField(const CommonDynamicBlobField<OtherLibObjT> val) noexcept :
1189 _ThisCommonBlobField {val}
1193 template <typename OtherLibObjT>
1194 CommonDynamicBlobField operator=(const CommonDynamicBlobField<OtherLibObjT> val) noexcept
1196 _ThisCommonBlobField::operator=(val);
1200 std::uint64_t length() const noexcept
1202 return _ThisCommonBlobField::length();
1205 CommonDynamicBlobField length(const std::uint64_t length) const
1207 static_assert(!std::is_const<LibObjT>::value,
1208 "Not available with `bt2::ConstDynamicBlobField`.");
1210 if (bt_field_blob_dynamic_set_length(this->libObjPtr(), length) ==
1211 BT_FIELD_DYNAMIC_BLOB_SET_LENGTH_STATUS_MEMORY_ERROR) {
1212 throw MemoryError {};
1219 using DynamicBlobField = CommonDynamicBlobField<bt_field>;
1220 using ConstDynamicBlobField = CommonDynamicBlobField<const bt_field>;
1222 namespace internal {
1224 struct DynamicBlobFieldTypeDescr
1226 using Const = ConstDynamicBlobField;
1227 using NonConst = DynamicBlobField;
1231 struct TypeDescr<DynamicBlobField> : public DynamicBlobFieldTypeDescr
1236 struct TypeDescr<ConstDynamicBlobField> : public DynamicBlobFieldTypeDescr
1240 template <typename LibObjT>
1241 struct CommonStructureFieldSpec;
1243 /* Functions specific to mutable structure fields */
1245 struct CommonStructureFieldSpec<bt_field> final
1247 static bt_field *memberFieldByIndex(bt_field * const libObjPtr,
1248 const std::uint64_t index) noexcept
1250 return bt_field_structure_borrow_member_field_by_index(libObjPtr, index);
1253 static bt_field *memberFieldByName(bt_field * const libObjPtr, const char * const name) noexcept
1255 return bt_field_structure_borrow_member_field_by_name(libObjPtr, name);
1259 /* Functions specific to constant structure fields */
1261 struct CommonStructureFieldSpec<const bt_field> final
1263 static const bt_field *memberFieldByIndex(const bt_field * const libObjPtr,
1264 const std::uint64_t index) noexcept
1266 return bt_field_structure_borrow_member_field_by_index_const(libObjPtr, index);
1269 static const bt_field *memberFieldByName(const bt_field * const libObjPtr,
1270 const char * const name) noexcept
1272 return bt_field_structure_borrow_member_field_by_name_const(libObjPtr, name);
1276 } /* namespace internal */
1278 template <typename LibObjT>
1279 class CommonStructureField final : public CommonField<LibObjT>
1282 using typename CommonField<LibObjT>::_ThisCommonField;
1283 using _Spec = internal::CommonStructureFieldSpec<LibObjT>;
1286 using typename CommonField<LibObjT>::LibObjPtr;
1287 using Class = internal::DepType<LibObjT, StructureFieldClass, ConstStructureFieldClass>;
1289 explicit CommonStructureField(const LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
1291 BT_ASSERT_DBG(this->isStructure());
1294 template <typename OtherLibObjT>
1295 CommonStructureField(const CommonStructureField<OtherLibObjT> val) noexcept :
1296 _ThisCommonField {val}
1300 template <typename OtherLibObjT>
1301 CommonStructureField<LibObjT> operator=(const CommonStructureField<OtherLibObjT> val) noexcept
1303 _ThisCommonField::operator=(val);
1307 CommonStructureField<const bt_field> asConst() const noexcept
1309 return CommonStructureField<const bt_field> {*this};
1312 Class cls() const noexcept
1314 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
1317 std::uint64_t length() const noexcept
1319 return this->cls().length();
1322 CommonField<LibObjT> operator[](const std::uint64_t index) const noexcept
1324 return CommonField<LibObjT> {_Spec::memberFieldByIndex(this->libObjPtr(), index)};
1327 OptionalBorrowedObject<CommonField<LibObjT>>
1328 operator[](const bt2c::CStringView name) const noexcept
1330 return _Spec::memberFieldByName(this->libObjPtr(), name);
1334 using StructureField = CommonStructureField<bt_field>;
1335 using ConstStructureField = CommonStructureField<const bt_field>;
1337 namespace internal {
1339 struct StructureFieldTypeDescr
1341 using Const = ConstStructureField;
1342 using NonConst = StructureField;
1346 struct TypeDescr<StructureField> : public StructureFieldTypeDescr
1351 struct TypeDescr<ConstStructureField> : public StructureFieldTypeDescr
1355 template <typename LibObjT>
1356 struct CommonArrayFieldSpec;
1358 /* Functions specific to mutable array fields */
1360 struct CommonArrayFieldSpec<bt_field> final
1362 static bt_field *elementFieldByIndex(bt_field * const libObjPtr,
1363 const std::uint64_t index) noexcept
1365 return bt_field_array_borrow_element_field_by_index(libObjPtr, index);
1369 /* Functions specific to constant array fields */
1371 struct CommonArrayFieldSpec<const bt_field> final
1373 static const bt_field *elementFieldByIndex(const bt_field * const libObjPtr,
1374 const std::uint64_t index) noexcept
1376 return bt_field_array_borrow_element_field_by_index_const(libObjPtr, index);
1380 } /* namespace internal */
1382 template <typename LibObjT>
1383 class CommonArrayField : public CommonField<LibObjT>
1386 using typename CommonField<LibObjT>::_ThisCommonField;
1387 using _Spec = internal::CommonArrayFieldSpec<LibObjT>;
1390 using _ThisCommonArrayField = CommonArrayField<LibObjT>;
1393 using typename CommonField<LibObjT>::LibObjPtr;
1394 using Class = internal::DepType<LibObjT, ArrayFieldClass, ConstArrayFieldClass>;
1396 explicit CommonArrayField(const LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
1398 BT_ASSERT_DBG(this->isArray());
1401 template <typename OtherLibObjT>
1402 CommonArrayField(const CommonArrayField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
1406 template <typename OtherLibObjT>
1407 _ThisCommonArrayField operator=(const CommonArrayField<OtherLibObjT> val) noexcept
1409 _ThisCommonField::operator=(val);
1413 CommonArrayField<const bt_field> asConst() const noexcept
1415 return CommonArrayField<const bt_field> {*this};
1418 Class cls() const noexcept
1420 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
1423 std::uint64_t length() const noexcept
1425 return bt_field_array_get_length(this->libObjPtr());
1428 CommonField<LibObjT> operator[](const std::uint64_t index) const noexcept
1430 return CommonField<LibObjT> {_Spec::elementFieldByIndex(this->libObjPtr(), index)};
1434 using ArrayField = CommonArrayField<bt_field>;
1435 using ConstArrayField = CommonArrayField<const bt_field>;
1437 namespace internal {
1439 struct ArrayFieldTypeDescr
1441 using Const = ConstArrayField;
1442 using NonConst = ArrayField;
1446 struct TypeDescr<ArrayField> : public ArrayFieldTypeDescr
1451 struct TypeDescr<ConstArrayField> : public ArrayFieldTypeDescr
1455 } /* namespace internal */
1457 template <typename LibObjT>
1458 class CommonDynamicArrayField : public CommonArrayField<LibObjT>
1461 using typename CommonArrayField<LibObjT>::_ThisCommonArrayField;
1464 using typename CommonField<LibObjT>::LibObjPtr;
1466 explicit CommonDynamicArrayField(const LibObjPtr libObjPtr) noexcept :
1467 _ThisCommonArrayField {libObjPtr}
1469 BT_ASSERT_DBG(this->isDynamicArray());
1472 template <typename OtherLibObjT>
1473 CommonDynamicArrayField(const CommonDynamicArrayField<OtherLibObjT> val) noexcept :
1474 _ThisCommonArrayField {val}
1478 template <typename OtherLibObjT>
1479 CommonDynamicArrayField<LibObjT>
1480 operator=(const CommonDynamicArrayField<OtherLibObjT> val) noexcept
1482 _ThisCommonArrayField::operator=(val);
1486 CommonDynamicArrayField<const bt_field> asConst() const noexcept
1488 return CommonDynamicArrayField<const bt_field> {*this};
1491 std::uint64_t length() const noexcept
1493 return _ThisCommonArrayField::length();
1496 CommonDynamicArrayField length(const std::uint64_t length) const
1498 static_assert(!std::is_const<LibObjT>::value,
1499 "Not available with `bt2::ConstDynamicArrayField`.");
1501 const auto status = bt_field_array_dynamic_set_length(this->libObjPtr(), length);
1503 if (status == BT_FIELD_DYNAMIC_ARRAY_SET_LENGTH_STATUS_MEMORY_ERROR) {
1504 throw MemoryError {};
1511 using DynamicArrayField = CommonDynamicArrayField<bt_field>;
1512 using ConstDynamicArrayField = CommonDynamicArrayField<const bt_field>;
1514 namespace internal {
1516 struct DynamicArrayFieldTypeDescr
1518 using Const = ConstDynamicArrayField;
1519 using NonConst = DynamicArrayField;
1523 struct TypeDescr<DynamicArrayField> : public DynamicArrayFieldTypeDescr
1528 struct TypeDescr<ConstDynamicArrayField> : public DynamicArrayFieldTypeDescr
1532 template <typename LibObjT>
1533 struct CommonOptionFieldSpec;
1535 /* Functions specific to mutable option fields */
1537 struct CommonOptionFieldSpec<bt_field> final
1539 static bt_field *field(bt_field * const libObjPtr) noexcept
1541 return bt_field_option_borrow_field(libObjPtr);
1545 /* Functions specific to constant option fields */
1547 struct CommonOptionFieldSpec<const bt_field> final
1549 static const bt_field *field(const bt_field * const libObjPtr) noexcept
1551 return bt_field_option_borrow_field_const(libObjPtr);
1555 } /* namespace internal */
1557 template <typename LibObjT>
1558 class CommonOptionField : public CommonField<LibObjT>
1561 using typename CommonField<LibObjT>::_ThisCommonField;
1562 using _Spec = internal::CommonOptionFieldSpec<LibObjT>;
1565 using typename CommonField<LibObjT>::LibObjPtr;
1566 using Class = internal::DepType<LibObjT, OptionFieldClass, ConstOptionFieldClass>;
1568 explicit CommonOptionField(const LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
1570 BT_ASSERT_DBG(this->isOption());
1573 template <typename OtherLibObjT>
1574 CommonOptionField(const CommonOptionField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
1578 template <typename OtherLibObjT>
1579 CommonOptionField<LibObjT> operator=(const CommonOptionField<OtherLibObjT> val) noexcept
1581 _ThisCommonField::operator=(val);
1585 CommonOptionField<const bt_field> asConst() const noexcept
1587 return CommonOptionField<const bt_field> {*this};
1590 Class cls() const noexcept
1592 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
1595 CommonOptionField hasField(const bool hasField) const noexcept
1597 static_assert(!std::is_const<LibObjT>::value,
1598 "Not available with `bt2::ConstOptionField`.");
1600 bt_field_option_set_has_field(this->libObjPtr(), static_cast<bt_bool>(hasField));
1604 bool hasField() const noexcept
1606 return this->field().hasObject();
1609 OptionalBorrowedObject<CommonField<LibObjT>> field() const noexcept
1611 return _Spec::field(this->libObjPtr());
1615 using OptionField = CommonOptionField<bt_field>;
1616 using ConstOptionField = CommonOptionField<const bt_field>;
1618 namespace internal {
1620 struct OptionFieldTypeDescr
1622 using Const = ConstOptionField;
1623 using NonConst = OptionField;
1627 struct TypeDescr<OptionField> : public OptionFieldTypeDescr
1632 struct TypeDescr<ConstOptionField> : public OptionFieldTypeDescr
1636 template <typename LibObjT>
1637 struct CommonVariantFieldSpec;
1639 /* Functions specific to mutable variant fields */
1641 struct CommonVariantFieldSpec<bt_field> final
1643 static bt_field *selectedOptionField(bt_field * const libObjPtr) noexcept
1645 return bt_field_variant_borrow_selected_option_field(libObjPtr);
1649 /* Functions specific to constant variant fields */
1651 struct CommonVariantFieldSpec<const bt_field> final
1653 static const bt_field *selectedOptionField(const bt_field * const libObjPtr) noexcept
1655 return bt_field_variant_borrow_selected_option_field_const(libObjPtr);
1659 } /* namespace internal */
1661 template <typename LibObjT>
1662 class CommonVariantField : public CommonField<LibObjT>
1665 using typename CommonField<LibObjT>::_ThisCommonField;
1666 using _Spec = internal::CommonVariantFieldSpec<LibObjT>;
1669 using typename CommonField<LibObjT>::LibObjPtr;
1670 using Class = internal::DepType<LibObjT, VariantFieldClass, ConstVariantFieldClass>;
1672 explicit CommonVariantField(const LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
1674 BT_ASSERT_DBG(this->isVariant());
1677 template <typename OtherLibObjT>
1678 CommonVariantField(const CommonVariantField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
1682 template <typename OtherLibObjT>
1683 CommonVariantField<LibObjT> operator=(const CommonVariantField<OtherLibObjT> val) noexcept
1685 _ThisCommonField::operator=(val);
1689 CommonVariantField<const bt_field> asConst() const noexcept
1691 return CommonVariantField<const bt_field> {*this};
1694 Class cls() const noexcept
1696 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
1699 CommonVariantField selectOption(const std::uint64_t index) const noexcept
1701 static_assert(!std::is_const<LibObjT>::value,
1702 "Not available with `bt2::ConstVariantField`.");
1704 const auto status = bt_field_variant_select_option_by_index(this->libObjPtr(), index);
1706 BT_ASSERT_DBG(status == BT_FIELD_VARIANT_SELECT_OPTION_STATUS_OK);
1710 CommonField<LibObjT> selectedOptionField() const noexcept
1712 return CommonField<LibObjT> {_Spec::selectedOptionField(this->libObjPtr())};
1715 std::uint64_t selectedOptionIndex() const noexcept
1717 return bt_field_variant_get_selected_option_index(this->libObjPtr());
1721 using VariantField = CommonVariantField<bt_field>;
1722 using ConstVariantField = CommonVariantField<const bt_field>;
1724 namespace internal {
1726 struct VariantFieldTypeDescr
1728 using Const = ConstVariantField;
1729 using NonConst = VariantField;
1733 struct TypeDescr<VariantField> : public VariantFieldTypeDescr
1738 struct TypeDescr<ConstVariantField> : public VariantFieldTypeDescr
1742 } /* namespace internal */
1744 template <typename LibObjT>
1745 CommonBoolField<LibObjT> CommonField<LibObjT>::asBool() const noexcept
1747 return CommonBoolField<LibObjT> {this->libObjPtr()};
1750 template <typename LibObjT>
1751 CommonBitArrayField<LibObjT> CommonField<LibObjT>::asBitArray() const noexcept
1753 return CommonBitArrayField<LibObjT> {this->libObjPtr()};
1756 template <typename LibObjT>
1757 CommonUnsignedIntegerField<LibObjT> CommonField<LibObjT>::asUnsignedInteger() const noexcept
1759 return CommonUnsignedIntegerField<LibObjT> {this->libObjPtr()};
1762 template <typename LibObjT>
1763 CommonSignedIntegerField<LibObjT> CommonField<LibObjT>::asSignedInteger() const noexcept
1765 return CommonSignedIntegerField<LibObjT> {this->libObjPtr()};
1768 template <typename LibObjT>
1769 CommonUnsignedEnumerationField<LibObjT> CommonField<LibObjT>::asUnsignedEnumeration() const noexcept
1771 return CommonUnsignedEnumerationField<LibObjT> {this->libObjPtr()};
1774 template <typename LibObjT>
1775 CommonSignedEnumerationField<LibObjT> CommonField<LibObjT>::asSignedEnumeration() const noexcept
1777 return CommonSignedEnumerationField<LibObjT> {this->libObjPtr()};
1780 template <typename LibObjT>
1781 CommonSinglePrecisionRealField<LibObjT> CommonField<LibObjT>::asSinglePrecisionReal() const noexcept
1783 return CommonSinglePrecisionRealField<LibObjT> {this->libObjPtr()};
1786 template <typename LibObjT>
1787 CommonDoublePrecisionRealField<LibObjT> CommonField<LibObjT>::asDoublePrecisionReal() const noexcept
1789 return CommonDoublePrecisionRealField<LibObjT> {this->libObjPtr()};
1792 template <typename LibObjT>
1793 CommonStringField<LibObjT> CommonField<LibObjT>::asString() const noexcept
1795 return CommonStringField<LibObjT> {this->libObjPtr()};
1798 template <typename LibObjT>
1799 CommonBlobField<LibObjT> CommonField<LibObjT>::asBlob() const noexcept
1801 BT_ASSERT_DBG(this->isBlob());
1802 return CommonBlobField<LibObjT> {this->libObjPtr()};
1805 template <typename LibObjT>
1806 CommonDynamicBlobField<LibObjT> CommonField<LibObjT>::asDynamicBlob() const noexcept
1808 BT_ASSERT_DBG(this->isDynamicBlob());
1809 return CommonDynamicBlobField<LibObjT> {this->libObjPtr()};
1812 template <typename LibObjT>
1813 CommonStructureField<LibObjT> CommonField<LibObjT>::asStructure() const noexcept
1815 return CommonStructureField<LibObjT> {this->libObjPtr()};
1818 template <typename LibObjT>
1819 CommonArrayField<LibObjT> CommonField<LibObjT>::asArray() const noexcept
1821 return CommonArrayField<LibObjT> {this->libObjPtr()};
1824 template <typename LibObjT>
1825 CommonDynamicArrayField<LibObjT> CommonField<LibObjT>::asDynamicArray() const noexcept
1827 return CommonDynamicArrayField<LibObjT> {this->libObjPtr()};
1830 template <typename LibObjT>
1831 CommonOptionField<LibObjT> CommonField<LibObjT>::asOption() const noexcept
1833 return CommonOptionField<LibObjT> {this->libObjPtr()};
1836 template <typename LibObjT>
1837 CommonVariantField<LibObjT> CommonField<LibObjT>::asVariant() const noexcept
1839 return CommonVariantField<LibObjT> {this->libObjPtr()};
1842 } /* namespace bt2 */
1844 #endif /* BABELTRACE_CPP_COMMON_BT2_FIELD_HPP */