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
10 #include <type_traits>
12 #include <babeltrace2/babeltrace.h>
14 #include "common/assert.h"
15 #include "internal/borrowed-obj.hpp"
16 #include "cpp-common/optional.hpp"
17 #include "cpp-common/string_view.hpp"
18 #include "field-class.hpp"
22 template <typename LibObjT>
23 class CommonBoolField;
25 template <typename LibObjT>
26 class CommonBitArrayField;
28 template <typename LibObjT>
29 class CommonUnsignedIntegerField;
31 template <typename LibObjT>
32 class CommonSignedIntegerField;
34 template <typename LibObjT>
35 class CommonUnsignedEnumerationField;
37 template <typename LibObjT>
38 class CommonSignedEnumerationField;
40 template <typename LibObjT>
41 class CommonSinglePrecisionRealField;
43 template <typename LibObjT>
44 class CommonDoublePrecisionRealField;
46 template <typename LibObjT>
47 class CommonStringField;
49 template <typename LibObjT>
50 class CommonStructureField;
52 template <typename LibObjT>
53 class CommonArrayField;
55 template <typename LibObjT>
56 class CommonDynamicArrayField;
58 template <typename LibObjT>
59 class CommonOptionField;
61 template <typename LibObjT>
62 class CommonVariantField;
66 template <typename LibObjT>
67 struct CommonFieldSpec;
69 // Functions specific to mutable fields
71 struct CommonFieldSpec<bt_field> final
73 static bt_field_class *cls(bt_field * const libObjPtr) noexcept
75 return bt_field_borrow_class(libObjPtr);
79 // Functions specific to constant fields
81 struct CommonFieldSpec<const bt_field> final
83 static const bt_field_class *cls(const bt_field * const libObjPtr) noexcept
85 return bt_field_borrow_class_const(libObjPtr);
89 } // namespace internal
91 template <typename LibObjT>
92 class CommonField : public internal::BorrowedObj<LibObjT>
95 using typename internal::BorrowedObj<LibObjT>::_ThisBorrowedObj;
98 using typename internal::BorrowedObj<LibObjT>::_LibObjPtr;
99 using _ThisCommonField = CommonField<LibObjT>;
103 typename std::conditional<std::is_const<LibObjT>::value, ConstFieldClass, FieldClass>::type;
105 explicit CommonField(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObj {libObjPtr}
109 template <typename OtherLibObjT>
110 CommonField(const CommonField<OtherLibObjT>& val) noexcept : _ThisBorrowedObj {val}
114 template <typename OtherLibObjT>
115 _ThisCommonField& operator=(const CommonField<OtherLibObjT>& val) noexcept
117 _ThisBorrowedObj::operator=(val);
121 FieldClassType classType() const noexcept
123 return static_cast<FieldClassType>(bt_field_get_class_type(this->_libObjPtr()));
126 ConstFieldClass cls() const noexcept
128 return ConstFieldClass {internal::CommonFieldSpec<const bt_field>::cls(this->_libObjPtr())};
133 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->_libObjPtr())};
136 bool isBool() const noexcept
138 return this->cls().isBool();
141 bool isBitArray() const noexcept
143 return this->cls().isBitArray();
146 bool isUnsignedInteger() const noexcept
148 return this->cls().isUnsignedInteger();
151 bool isSignedInteger() const noexcept
153 return this->cls().isSignedInteger();
156 bool isUnsignedEnumeration() const noexcept
158 return this->cls().isUnsignedEnumeration();
161 bool isSignedEnumeration() const noexcept
163 return this->cls().isSignedEnumeration();
166 bool isSinglePrecisionReal() const noexcept
168 return this->cls().isSinglePrecisionReal();
171 bool isDoublePrecisionReal() const noexcept
173 return this->cls().isDoublePrecisionReal();
176 bool isString() const noexcept
178 return this->cls().isString();
181 bool isStructure() const noexcept
183 return this->cls().isStructure();
186 bool isArray() const noexcept
188 return this->cls().isArray();
191 bool isDynamicArray() const noexcept
193 return this->cls().isDynamicArray();
196 bool isOption() const noexcept
198 return this->cls().isOption();
201 bool isVariant() const noexcept
203 return this->cls().isVariant();
206 CommonBoolField<LibObjT> asBool() const noexcept;
207 CommonBitArrayField<LibObjT> asBitArray() const noexcept;
208 CommonUnsignedIntegerField<LibObjT> asUnsignedInteger() const noexcept;
209 CommonSignedIntegerField<LibObjT> asSignedInteger() const noexcept;
210 CommonUnsignedEnumerationField<LibObjT> asUnsignedEnumeration() const noexcept;
211 CommonSignedEnumerationField<LibObjT> asSignedEnumeration() const noexcept;
212 CommonSinglePrecisionRealField<LibObjT> asSinglePrecisionReal() const noexcept;
213 CommonDoublePrecisionRealField<LibObjT> asDoublePrecisionReal() const noexcept;
214 CommonStringField<LibObjT> asString() const noexcept;
215 CommonStructureField<LibObjT> asStructure() const noexcept;
216 CommonArrayField<LibObjT> asArray() const noexcept;
217 CommonDynamicArrayField<LibObjT> asDynamicArray() const noexcept;
218 CommonOptionField<LibObjT> asOption() const noexcept;
219 CommonVariantField<LibObjT> asVariant() const noexcept;
222 using Field = CommonField<bt_field>;
223 using ConstField = CommonField<const bt_field>;
225 template <typename LibObjT>
226 class CommonBoolField final : public CommonField<LibObjT>
229 using typename CommonField<LibObjT>::_LibObjPtr;
230 using typename CommonField<LibObjT>::_ThisCommonField;
235 explicit CommonBoolField(const _LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
237 BT_ASSERT_DBG(this->isBool());
240 template <typename OtherLibObjT>
241 CommonBoolField(const CommonBoolField<OtherLibObjT>& val) noexcept : _ThisCommonField {val}
245 template <typename OtherLibObjT>
246 CommonBoolField<LibObjT>& operator=(const CommonBoolField<OtherLibObjT>& val) noexcept
248 _ThisCommonField::operator=(val);
252 CommonBoolField<LibObjT>& operator=(const Value val) noexcept
254 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
256 bt_field_bool_set_value(this->_libObjPtr(), static_cast<bt_bool>(val));
260 Value value() const noexcept
262 return static_cast<Value>(bt_field_bool_get_value(this->_libObjPtr()));
265 operator Value() const noexcept
267 return this->value();
271 using BoolField = CommonBoolField<bt_field>;
272 using ConstBoolField = CommonBoolField<const bt_field>;
274 template <typename LibObjT>
275 class CommonBitArrayField final : public CommonField<LibObjT>
278 using typename CommonField<LibObjT>::_LibObjPtr;
279 using typename CommonField<LibObjT>::_ThisCommonField;
282 using Class = typename std::conditional<std::is_const<LibObjT>::value, ConstBitArrayFieldClass,
283 BitArrayFieldClass>::type;
285 explicit CommonBitArrayField(const _LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
287 BT_ASSERT_DBG(this->isBitArray());
290 template <typename OtherLibObjT>
291 CommonBitArrayField(const CommonBitArrayField<OtherLibObjT>& val) noexcept :
292 _ThisCommonField {val}
296 template <typename OtherLibObjT>
297 CommonBitArrayField<LibObjT>& operator=(const CommonBitArrayField<OtherLibObjT>& val) noexcept
299 _ThisCommonField::operator=(val);
303 ConstBitArrayFieldClass cls() const noexcept
305 return ConstBitArrayFieldClass {
306 internal::CommonFieldSpec<const bt_field>::cls(this->_libObjPtr())};
311 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->_libObjPtr())};
314 CommonBitArrayField<LibObjT>& operator=(const std::uint64_t bits) noexcept
316 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
318 bt_field_bit_array_set_value_as_integer(this->_libObjPtr(), bits);
322 std::uint64_t valueAsInteger() const noexcept
324 return bt_field_bit_array_get_value_as_integer(this->_libObjPtr());
327 bool bitValue(const std::uint64_t index) const noexcept
329 BT_ASSERT_DBG(index < this->cls().length());
330 return static_cast<bool>(this->valueAsInteger() & (1ULL << index));
334 using BitArrayField = CommonBitArrayField<bt_field>;
335 using ConstBitArrayField = CommonBitArrayField<const bt_field>;
337 template <typename LibObjT>
338 class CommonUnsignedIntegerField final : public CommonField<LibObjT>
341 using typename CommonField<LibObjT>::_ThisCommonField;
344 using typename CommonField<LibObjT>::_LibObjPtr;
345 using _ThisCommonUnsignedIntegerField = CommonUnsignedIntegerField<LibObjT>;
348 using Value = std::uint64_t;
350 using Class = typename std::conditional<std::is_const<LibObjT>::value, ConstIntegerFieldClass,
351 IntegerFieldClass>::type;
353 explicit CommonUnsignedIntegerField(const _LibObjPtr libObjPtr) noexcept :
354 _ThisCommonField {libObjPtr}
356 BT_ASSERT_DBG(this->isUnsignedInteger());
359 template <typename OtherLibObjT>
360 CommonUnsignedIntegerField(const CommonUnsignedIntegerField<OtherLibObjT>& val) noexcept :
361 _ThisCommonField {val}
365 template <typename OtherLibObjT>
366 _ThisCommonUnsignedIntegerField&
367 operator=(const CommonUnsignedIntegerField<OtherLibObjT>& val) noexcept
369 _ThisCommonField::operator=(val);
373 ConstIntegerFieldClass cls() const noexcept
375 return ConstIntegerFieldClass {
376 internal::CommonFieldSpec<const bt_field>::cls(this->_libObjPtr())};
381 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->_libObjPtr())};
384 CommonUnsignedIntegerField<LibObjT>& operator=(const Value val) noexcept
386 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
388 bt_field_integer_unsigned_set_value(this->_libObjPtr(), val);
392 Value value() const noexcept
394 return bt_field_integer_unsigned_get_value(this->_libObjPtr());
397 operator Value() const noexcept
399 return this->value();
403 using UnsignedIntegerField = CommonUnsignedIntegerField<bt_field>;
404 using ConstUnsignedIntegerField = CommonUnsignedIntegerField<const bt_field>;
406 template <typename LibObjT>
407 class CommonSignedIntegerField final : public CommonField<LibObjT>
410 using typename CommonField<LibObjT>::_ThisCommonField;
413 using typename CommonField<LibObjT>::_LibObjPtr;
414 using _ThisCommonSignedIntegerField = CommonSignedIntegerField<LibObjT>;
417 using Value = std::uint64_t;
419 using Class = typename std::conditional<std::is_const<LibObjT>::value, ConstIntegerFieldClass,
420 IntegerFieldClass>::type;
422 explicit CommonSignedIntegerField(const _LibObjPtr libObjPtr) noexcept :
423 _ThisCommonField {libObjPtr}
425 BT_ASSERT_DBG(this->isSignedInteger());
428 template <typename OtherLibObjT>
429 CommonSignedIntegerField(const CommonSignedIntegerField<OtherLibObjT>& val) noexcept :
430 _ThisCommonField {val}
434 template <typename OtherLibObjT>
435 _ThisCommonSignedIntegerField&
436 operator=(const CommonSignedIntegerField<OtherLibObjT>& val) noexcept
438 _ThisCommonField::operator=(val);
442 ConstIntegerFieldClass cls() const noexcept
444 return ConstIntegerFieldClass {
445 internal::CommonFieldSpec<const bt_field>::cls(this->_libObjPtr())};
450 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->_libObjPtr())};
453 CommonSignedIntegerField<LibObjT>& operator=(const Value val) noexcept
455 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
457 bt_field_integer_signed_set_value(this->_libObjPtr(), val);
461 Value value() const noexcept
463 return bt_field_integer_signed_get_value(this->_libObjPtr());
466 operator Value() const noexcept
468 return this->value();
472 using SignedIntegerField = CommonSignedIntegerField<bt_field>;
473 using ConstSignedIntegerField = CommonSignedIntegerField<const bt_field>;
475 class EnumerationFieldClassMappingLabels
478 explicit EnumerationFieldClassMappingLabels(
479 const bt_field_class_enumeration_mapping_label_array labels, const std::uint64_t size) :
485 EnumerationFieldClassMappingLabels(const EnumerationFieldClassMappingLabels&) noexcept =
488 EnumerationFieldClassMappingLabels&
489 operator=(const EnumerationFieldClassMappingLabels&) noexcept = default;
491 std::uint64_t size() const noexcept
496 bpstd::string_view operator[](const std::uint64_t index) const noexcept
498 return _mLabels[index];
502 bt_field_class_enumeration_mapping_label_array _mLabels;
503 std::uint64_t _mSize;
506 template <typename LibObjT>
507 class CommonUnsignedEnumerationField final : public CommonUnsignedIntegerField<LibObjT>
510 using typename CommonUnsignedIntegerField<LibObjT>::_ThisCommonUnsignedIntegerField;
511 using typename CommonField<LibObjT>::_LibObjPtr;
515 typename std::conditional<std::is_const<LibObjT>::value, ConstUnsignedEnumerationFieldClass,
516 UnsignedEnumerationFieldClass>::type;
518 explicit CommonUnsignedEnumerationField(const _LibObjPtr libObjPtr) noexcept :
519 _ThisCommonUnsignedIntegerField {libObjPtr}
521 BT_ASSERT_DBG(this->isUnsignedEnumeration());
524 template <typename OtherLibObjT>
525 CommonUnsignedEnumerationField(const CommonUnsignedEnumerationField<OtherLibObjT>& val) noexcept
527 _ThisCommonUnsignedIntegerField {val}
531 template <typename OtherLibObjT>
532 CommonUnsignedEnumerationField<LibObjT>&
533 operator=(const CommonUnsignedEnumerationField<OtherLibObjT>& val) noexcept
535 _ThisCommonUnsignedIntegerField::operator=(val);
539 ConstUnsignedEnumerationFieldClass cls() const noexcept
541 return ConstUnsignedEnumerationFieldClass {
542 internal::CommonFieldSpec<const bt_field>::cls(this->_libObjPtr())};
547 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->_libObjPtr())};
550 EnumerationFieldClassMappingLabels labels() const
552 bt_field_class_enumeration_mapping_label_array labelArray;
554 const auto status = bt_field_enumeration_unsigned_get_mapping_labels(this->_libObjPtr(),
555 &labelArray, &count);
557 if (status == BT_FIELD_ENUMERATION_GET_MAPPING_LABELS_STATUS_MEMORY_ERROR) {
558 throw LibMemoryError {};
561 return EnumerationFieldClassMappingLabels {labelArray, count};
565 using UnsignedEnumerationField = CommonUnsignedEnumerationField<bt_field>;
566 using ConstUnsignedEnumerationField = CommonUnsignedEnumerationField<const bt_field>;
568 template <typename LibObjT>
569 class CommonSignedEnumerationField final : public CommonSignedIntegerField<LibObjT>
572 using typename CommonSignedIntegerField<LibObjT>::_ThisCommonSignedIntegerField;
573 using typename CommonField<LibObjT>::_LibObjPtr;
577 typename std::conditional<std::is_const<LibObjT>::value, ConstSignedEnumerationFieldClass,
578 SignedEnumerationFieldClass>::type;
580 explicit CommonSignedEnumerationField(const _LibObjPtr libObjPtr) noexcept :
581 _ThisCommonSignedIntegerField {libObjPtr}
583 BT_ASSERT_DBG(this->isSignedEnumeration());
586 template <typename OtherLibObjT>
587 CommonSignedEnumerationField(const CommonSignedEnumerationField<OtherLibObjT>& val) noexcept :
588 _ThisCommonSignedIntegerField {val}
592 template <typename OtherLibObjT>
593 CommonSignedEnumerationField<LibObjT>&
594 operator=(const CommonSignedEnumerationField<OtherLibObjT>& val) noexcept
596 _ThisCommonSignedIntegerField::operator=(val);
600 ConstSignedEnumerationFieldClass cls() const noexcept
602 return ConstSignedEnumerationFieldClass {
603 internal::CommonFieldSpec<const bt_field>::cls(this->_libObjPtr())};
608 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->_libObjPtr())};
611 EnumerationFieldClassMappingLabels labels() const
613 bt_field_class_enumeration_mapping_label_array labelArray;
616 bt_field_enumeration_signed_get_mapping_labels(this->_libObjPtr(), &labelArray, &count);
618 if (status == BT_FIELD_ENUMERATION_GET_MAPPING_LABELS_STATUS_MEMORY_ERROR) {
619 throw LibMemoryError {};
622 return EnumerationFieldClassMappingLabels {labelArray, count};
626 using SignedEnumerationField = CommonSignedEnumerationField<bt_field>;
627 using ConstSignedEnumerationField = CommonSignedEnumerationField<const bt_field>;
629 template <typename LibObjT>
630 class CommonSinglePrecisionRealField final : public CommonField<LibObjT>
633 using typename CommonField<LibObjT>::_LibObjPtr;
634 using typename CommonField<LibObjT>::_ThisCommonField;
639 explicit CommonSinglePrecisionRealField(const _LibObjPtr libObjPtr) noexcept :
640 _ThisCommonField {libObjPtr}
642 BT_ASSERT_DBG(this->isSinglePrecisionReal());
645 template <typename OtherLibObjT>
646 CommonSinglePrecisionRealField(const CommonSinglePrecisionRealField<OtherLibObjT>& val) noexcept
648 _ThisCommonField {val}
652 template <typename OtherLibObjT>
653 CommonSinglePrecisionRealField<LibObjT>&
654 operator=(const CommonSinglePrecisionRealField<OtherLibObjT>& val) noexcept
656 _ThisCommonField::operator=(val);
660 CommonSinglePrecisionRealField<LibObjT>& operator=(const Value val) noexcept
662 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
664 bt_field_real_single_precision_set_value(this->_libObjPtr(), val);
668 Value value() const noexcept
670 return bt_field_real_single_precision_get_value(this->_libObjPtr());
673 operator Value() const noexcept
675 return this->value();
679 using SinglePrecisionRealField = CommonSinglePrecisionRealField<bt_field>;
680 using ConstSinglePrecisionRealField = CommonSinglePrecisionRealField<const bt_field>;
682 template <typename LibObjT>
683 class CommonDoublePrecisionRealField final : public CommonField<LibObjT>
686 using typename CommonField<LibObjT>::_LibObjPtr;
687 using typename CommonField<LibObjT>::_ThisCommonField;
690 using Value = double;
692 explicit CommonDoublePrecisionRealField(const _LibObjPtr libObjPtr) noexcept :
693 _ThisCommonField {libObjPtr}
695 BT_ASSERT_DBG(this->isDoublePrecisionReal());
698 template <typename OtherLibObjT>
699 CommonDoublePrecisionRealField(const CommonDoublePrecisionRealField<OtherLibObjT>& val) noexcept
701 _ThisCommonField {val}
705 template <typename OtherLibObjT>
706 CommonDoublePrecisionRealField<LibObjT>&
707 operator=(const CommonDoublePrecisionRealField<OtherLibObjT>& val) noexcept
709 _ThisCommonField::operator=(val);
713 CommonDoublePrecisionRealField<LibObjT>& operator=(const Value val) noexcept
715 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
717 bt_field_real_single_precision_set_value(this->_libObjPtr(), val);
721 Value value() const noexcept
723 return bt_field_real_single_precision_get_value(this->_libObjPtr());
726 operator Value() const noexcept
728 return this->value();
732 using DoublePrecisionRealField = CommonDoublePrecisionRealField<bt_field>;
733 using ConstDoublePrecisionRealField = CommonDoublePrecisionRealField<const bt_field>;
735 template <typename LibObjT>
736 class CommonStringField final : public CommonField<LibObjT>
739 using typename CommonField<LibObjT>::_LibObjPtr;
740 using typename CommonField<LibObjT>::_ThisCommonField;
743 explicit CommonStringField(const _LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
745 BT_ASSERT_DBG(this->isString());
748 template <typename OtherLibObjT>
749 CommonStringField(const CommonStringField<OtherLibObjT>& val) noexcept : _ThisCommonField {val}
753 template <typename OtherLibObjT>
754 CommonStringField<LibObjT>& operator=(const CommonStringField<OtherLibObjT>& val) noexcept
756 _ThisCommonField::operator=(val);
760 CommonStringField<LibObjT>& operator=(const char * const val) noexcept
762 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
764 const auto status = bt_field_string_set_value(this->_libObjPtr(), val);
766 if (status == BT_FIELD_STRING_SET_VALUE_STATUS_MEMORY_ERROR) {
767 throw LibMemoryError {};
773 CommonStringField<LibObjT>& operator=(const std::string& val) noexcept
775 return *this = val.data();
778 void clear() noexcept
780 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
782 bt_field_string_clear(this->_libObjPtr());
785 bpstd::string_view value() const noexcept
787 return bt_field_string_get_value(this->_libObjPtr());
791 using StringField = CommonStringField<bt_field>;
792 using ConstStringField = CommonStringField<const bt_field>;
796 template <typename LibObjT>
797 struct CommonStructureFieldSpec;
799 // Functions specific to mutable structure fields
801 struct CommonStructureFieldSpec<bt_field> final
803 static bt_field *memberFieldByIndex(bt_field * const libObjPtr,
804 const std::uint64_t index) noexcept
806 return bt_field_structure_borrow_member_field_by_index(libObjPtr, index);
809 static bt_field *memberFieldByName(bt_field * const libObjPtr, const char * const name) noexcept
811 return bt_field_structure_borrow_member_field_by_name(libObjPtr, name);
815 // Functions specific to constant structure fields
817 struct CommonStructureFieldSpec<const bt_field> final
819 static const bt_field *memberFieldByIndex(const bt_field * const libObjPtr,
820 const std::uint64_t index) noexcept
822 return bt_field_structure_borrow_member_field_by_index_const(libObjPtr, index);
825 static const bt_field *memberFieldByName(const bt_field * const libObjPtr,
826 const char * const name) noexcept
828 return bt_field_structure_borrow_member_field_by_name_const(libObjPtr, name);
832 } // namespace internal
834 template <typename LibObjT>
835 class CommonStructureField final : public CommonField<LibObjT>
838 using typename CommonField<LibObjT>::_LibObjPtr;
839 using typename CommonField<LibObjT>::_ThisCommonField;
840 using _Spec = internal::CommonStructureFieldSpec<LibObjT>;
843 using Class = typename std::conditional<std::is_const<LibObjT>::value, ConstStructureFieldClass,
844 StructureFieldClass>::type;
846 explicit CommonStructureField(const _LibObjPtr libObjPtr) noexcept :
847 _ThisCommonField {libObjPtr}
849 BT_ASSERT_DBG(this->isStructure());
852 template <typename OtherLibObjT>
853 CommonStructureField(const CommonStructureField<OtherLibObjT>& val) noexcept :
854 _ThisCommonField {val}
858 template <typename OtherLibObjT>
859 CommonStructureField<LibObjT>& operator=(const CommonStructureField<OtherLibObjT>& val) noexcept
861 _ThisCommonField::operator=(val);
865 ConstStructureFieldClass cls() const noexcept
867 return ConstStructureFieldClass {
868 internal::CommonFieldSpec<const bt_field>::cls(this->_libObjPtr())};
873 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->_libObjPtr())};
876 std::uint64_t size() const noexcept
878 return this->cls().size();
881 ConstField operator[](const std::uint64_t index) const noexcept
883 return ConstField {internal::CommonStructureFieldSpec<const bt_field>::memberFieldByIndex(
884 this->_libObjPtr(), index)};
887 CommonField<LibObjT> operator[](const std::uint64_t index) noexcept
889 return CommonField<LibObjT> {_Spec::memberFieldByIndex(this->_libObjPtr(), index)};
892 nonstd::optional<ConstField> operator[](const char * const name) const noexcept
894 const auto libObjPtr =
895 internal::CommonStructureFieldSpec<const bt_field>::memberFieldByName(
896 this->_libObjPtr(), name);
899 return ConstField {libObjPtr};
902 return nonstd::nullopt;
905 nonstd::optional<ConstField> operator[](const std::string& name) const noexcept
907 return (*this)[name.data()];
910 nonstd::optional<CommonField<LibObjT>> operator[](const char * const name) noexcept
912 const auto libObjPtr = _Spec::memberFieldByName(this->_libObjPtr(), name);
915 return CommonField<LibObjT> {libObjPtr};
918 return nonstd::nullopt;
921 nonstd::optional<CommonField<LibObjT>> operator[](const std::string& name) noexcept
923 return (*this)[name.data()];
927 using StructureField = CommonStructureField<bt_field>;
928 using ConstStructureField = CommonStructureField<const bt_field>;
932 template <typename LibObjT>
933 struct CommonArrayFieldSpec;
935 // Functions specific to mutable array fields
937 struct CommonArrayFieldSpec<bt_field> final
939 static bt_field *elementFieldByIndex(bt_field * const libObjPtr,
940 const std::uint64_t index) noexcept
942 return bt_field_array_borrow_element_field_by_index(libObjPtr, index);
946 // Functions specific to constant array fields
948 struct CommonArrayFieldSpec<const bt_field> final
950 static const bt_field *elementFieldByIndex(const bt_field * const libObjPtr,
951 const std::uint64_t index) noexcept
953 return bt_field_array_borrow_element_field_by_index_const(libObjPtr, index);
957 } // namespace internal
959 template <typename LibObjT>
960 class CommonArrayField : public CommonField<LibObjT>
963 using typename CommonField<LibObjT>::_ThisCommonField;
964 using _Spec = internal::CommonArrayFieldSpec<LibObjT>;
967 using typename CommonField<LibObjT>::_LibObjPtr;
968 using _ThisCommonArrayField = CommonArrayField<LibObjT>;
971 using Class = typename std::conditional<std::is_const<LibObjT>::value, ConstArrayFieldClass,
972 ArrayFieldClass>::type;
974 explicit CommonArrayField(const _LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
976 BT_ASSERT_DBG(this->isArray());
979 template <typename OtherLibObjT>
980 CommonArrayField(const CommonArrayField<OtherLibObjT>& val) noexcept : _ThisCommonField {val}
984 template <typename OtherLibObjT>
985 _ThisCommonArrayField& operator=(const CommonArrayField<OtherLibObjT>& val) noexcept
987 _ThisCommonField::operator=(val);
991 ConstArrayFieldClass cls() const noexcept
993 return ConstArrayFieldClass {
994 internal::CommonFieldSpec<const bt_field>::cls(this->_libObjPtr())};
999 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->_libObjPtr())};
1002 std::uint64_t length() const noexcept
1004 return bt_field_array_get_length(this->_libObjPtr());
1007 ConstField operator[](const std::uint64_t index) const noexcept
1009 return ConstField {internal::CommonArrayFieldSpec<const bt_field>::elementFieldByIndex(
1010 this->_libObjPtr(), index)};
1013 CommonField<LibObjT> operator[](const std::uint64_t index) noexcept
1015 return CommonField<LibObjT> {_Spec::elementFieldByIndex(this->_libObjPtr(), index)};
1019 using ArrayField = CommonArrayField<bt_field>;
1020 using ConstArrayField = CommonArrayField<const bt_field>;
1022 template <typename LibObjT>
1023 class CommonDynamicArrayField : public CommonArrayField<LibObjT>
1026 using typename CommonField<LibObjT>::_LibObjPtr;
1027 using typename CommonArrayField<LibObjT>::_ThisCommonArrayField;
1030 explicit CommonDynamicArrayField(const _LibObjPtr libObjPtr) noexcept :
1031 _ThisCommonArrayField {libObjPtr}
1033 BT_ASSERT_DBG(this->isDynamicArray());
1036 template <typename OtherLibObjT>
1037 CommonDynamicArrayField(const CommonDynamicArrayField<OtherLibObjT>& val) noexcept :
1038 _ThisCommonArrayField {val}
1042 template <typename OtherLibObjT>
1043 CommonDynamicArrayField<LibObjT>&
1044 operator=(const CommonDynamicArrayField<OtherLibObjT>& val) noexcept
1046 _ThisCommonArrayField::operator=(val);
1050 std::uint64_t length() const noexcept
1052 return _ThisCommonArrayField::length();
1055 void length(const std::uint64_t length)
1057 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
1059 const auto status = bt_field_array_dynamic_set_length(this->_libObjPtr(), length);
1061 if (status == BT_FIELD_DYNAMIC_ARRAY_SET_LENGTH_STATUS_MEMORY_ERROR) {
1062 throw LibMemoryError {};
1067 using DynamicArrayField = CommonDynamicArrayField<bt_field>;
1068 using ConstDynamicArrayField = CommonDynamicArrayField<const bt_field>;
1070 namespace internal {
1072 template <typename LibObjT>
1073 struct CommonOptionFieldSpec;
1075 // Functions specific to mutable option fields
1077 struct CommonOptionFieldSpec<bt_field> final
1079 static bt_field *field(bt_field * const libObjPtr) noexcept
1081 return bt_field_option_borrow_field(libObjPtr);
1085 // Functions specific to constant option fields
1087 struct CommonOptionFieldSpec<const bt_field> final
1089 static const bt_field *field(const bt_field * const libObjPtr) noexcept
1091 return bt_field_option_borrow_field_const(libObjPtr);
1095 } // namespace internal
1097 template <typename LibObjT>
1098 class CommonOptionField : public CommonField<LibObjT>
1101 using typename CommonField<LibObjT>::_LibObjPtr;
1102 using typename CommonField<LibObjT>::_ThisCommonField;
1103 using _Spec = internal::CommonOptionFieldSpec<LibObjT>;
1106 using Class = typename std::conditional<std::is_const<LibObjT>::value, ConstOptionFieldClass,
1107 OptionFieldClass>::type;
1109 explicit CommonOptionField(const _LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
1111 BT_ASSERT_DBG(this->isOption());
1114 template <typename OtherLibObjT>
1115 CommonOptionField(const CommonOptionField<OtherLibObjT>& val) noexcept : _ThisCommonField {val}
1119 template <typename OtherLibObjT>
1120 CommonOptionField<LibObjT>& operator=(const CommonOptionField<OtherLibObjT>& val) noexcept
1122 _ThisCommonField::operator=(val);
1126 ConstOptionFieldClass cls() const noexcept
1128 return ConstOptionFieldClass {
1129 internal::CommonFieldSpec<const bt_field>::cls(this->_libObjPtr())};
1132 Class cls() noexcept
1134 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->_libObjPtr())};
1137 void hasField(const bool hasField) noexcept
1139 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
1141 bt_field_option_set_has_field(this->_libObjPtr(), static_cast<bt_bool>(hasField));
1144 bool hasField() const noexcept
1146 return this->field();
1149 nonstd::optional<ConstField> field() const noexcept
1151 const auto libObjPtr =
1152 internal::CommonOptionFieldSpec<const bt_field>::field(this->_libObjPtr());
1155 return ConstField {libObjPtr};
1158 return nonstd::nullopt;
1161 nonstd::optional<CommonField<LibObjT>> field() noexcept
1163 const auto libObjPtr = _Spec::field(this->_libObjPtr());
1166 return CommonField<LibObjT> {libObjPtr};
1169 return nonstd::nullopt;
1173 using OptionField = CommonOptionField<bt_field>;
1174 using ConstOptionField = CommonOptionField<const bt_field>;
1176 namespace internal {
1178 template <typename LibObjT>
1179 struct CommonVariantFieldSpec;
1181 // Functions specific to mutable variant fields
1183 struct CommonVariantFieldSpec<bt_field> final
1185 static bt_field *selectedOptionField(bt_field * const libObjPtr) noexcept
1187 return bt_field_variant_borrow_selected_option_field(libObjPtr);
1191 // Functions specific to constant variant fields
1193 struct CommonVariantFieldSpec<const bt_field> final
1195 static const bt_field *selectedOptionField(const bt_field * const libObjPtr) noexcept
1197 return bt_field_variant_borrow_selected_option_field_const(libObjPtr);
1201 } // namespace internal
1203 template <typename LibObjT>
1204 class CommonVariantField : public CommonField<LibObjT>
1207 using typename CommonField<LibObjT>::_LibObjPtr;
1208 using typename CommonField<LibObjT>::_ThisCommonField;
1209 using _Spec = internal::CommonVariantFieldSpec<LibObjT>;
1212 using Class = typename std::conditional<std::is_const<LibObjT>::value, ConstVariantFieldClass,
1213 VariantFieldClass>::type;
1215 explicit CommonVariantField(const _LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
1217 BT_ASSERT_DBG(this->isVariant());
1220 template <typename OtherLibObjT>
1221 CommonVariantField(const CommonVariantField<OtherLibObjT>& val) noexcept :
1222 _ThisCommonField {val}
1226 template <typename OtherLibObjT>
1227 CommonVariantField<LibObjT>& operator=(const CommonVariantField<OtherLibObjT>& val) noexcept
1229 _ThisCommonField::operator=(val);
1233 ConstVariantFieldClass cls() const noexcept
1235 return ConstVariantFieldClass {
1236 internal::CommonFieldSpec<const bt_field>::cls(this->_libObjPtr())};
1239 Class cls() noexcept
1241 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->_libObjPtr())};
1244 void selectOption(const std::uint64_t index) noexcept
1246 static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
1248 static_cast<void>(bt_field_variant_select_option_by_index(this->_libObjPtr(), index));
1251 ConstField selectedOptionField() const noexcept
1253 return ConstField {internal::CommonVariantFieldSpec<const bt_field>::selectedOptionField(
1254 this->_libObjPtr())};
1257 CommonField<LibObjT> selectedOptionField() noexcept
1259 return CommonField<LibObjT> {_Spec::selectedOptionField(this->_libObjPtr())};
1262 std::uint64_t selectedOptionIndex() const noexcept
1264 return bt_field_variant_get_selected_option_index(this->_libObjPtr());
1268 using VariantField = CommonVariantField<bt_field>;
1269 using ConstVariantField = CommonVariantField<const bt_field>;
1271 template <typename LibObjT>
1272 CommonBoolField<LibObjT> CommonField<LibObjT>::asBool() const noexcept
1274 BT_ASSERT_DBG(this->isBool());
1275 return CommonBoolField<LibObjT> {this->_libObjPtr()};
1278 template <typename LibObjT>
1279 CommonBitArrayField<LibObjT> CommonField<LibObjT>::asBitArray() const noexcept
1281 BT_ASSERT_DBG(this->isBitArray());
1282 return CommonBitArrayField<LibObjT> {this->_libObjPtr()};
1285 template <typename LibObjT>
1286 CommonUnsignedIntegerField<LibObjT> CommonField<LibObjT>::asUnsignedInteger() const noexcept
1288 BT_ASSERT_DBG(this->isUnsignedInteger());
1289 return CommonUnsignedIntegerField<LibObjT> {this->_libObjPtr()};
1292 template <typename LibObjT>
1293 CommonSignedIntegerField<LibObjT> CommonField<LibObjT>::asSignedInteger() const noexcept
1295 BT_ASSERT_DBG(this->isSignedInteger());
1296 return CommonSignedIntegerField<LibObjT> {this->_libObjPtr()};
1299 template <typename LibObjT>
1300 CommonUnsignedEnumerationField<LibObjT> CommonField<LibObjT>::asUnsignedEnumeration() const noexcept
1302 BT_ASSERT_DBG(this->isUnsignedEnumeration());
1303 return CommonUnsignedEnumerationField<LibObjT> {this->_libObjPtr()};
1306 template <typename LibObjT>
1307 CommonSignedEnumerationField<LibObjT> CommonField<LibObjT>::asSignedEnumeration() const noexcept
1309 BT_ASSERT_DBG(this->isSignedEnumeration());
1310 return CommonSignedEnumerationField<LibObjT> {this->_libObjPtr()};
1313 template <typename LibObjT>
1314 CommonSinglePrecisionRealField<LibObjT> CommonField<LibObjT>::asSinglePrecisionReal() const noexcept
1316 BT_ASSERT_DBG(this->isSinglePrecisionReal());
1317 return CommonSinglePrecisionRealField<LibObjT> {this->_libObjPtr()};
1320 template <typename LibObjT>
1321 CommonDoublePrecisionRealField<LibObjT> CommonField<LibObjT>::asDoublePrecisionReal() const noexcept
1323 BT_ASSERT_DBG(this->isDoublePrecisionReal());
1324 return CommonDoublePrecisionRealField<LibObjT> {this->_libObjPtr()};
1327 template <typename LibObjT>
1328 CommonStringField<LibObjT> CommonField<LibObjT>::asString() const noexcept
1330 BT_ASSERT_DBG(this->isString());
1331 return CommonStringField<LibObjT> {this->_libObjPtr()};
1334 template <typename LibObjT>
1335 CommonStructureField<LibObjT> CommonField<LibObjT>::asStructure() const noexcept
1337 BT_ASSERT_DBG(this->isStructure());
1338 return CommonStructureField<LibObjT> {this->_libObjPtr()};
1341 template <typename LibObjT>
1342 CommonArrayField<LibObjT> CommonField<LibObjT>::asArray() const noexcept
1344 BT_ASSERT_DBG(this->isArray());
1345 return CommonArrayField<LibObjT> {this->_libObjPtr()};
1348 template <typename LibObjT>
1349 CommonDynamicArrayField<LibObjT> CommonField<LibObjT>::asDynamicArray() const noexcept
1351 BT_ASSERT_DBG(this->isDynamicArray());
1352 return CommonDynamicArrayField<LibObjT> {this->_libObjPtr()};
1355 template <typename LibObjT>
1356 CommonOptionField<LibObjT> CommonField<LibObjT>::asOption() const noexcept
1358 BT_ASSERT_DBG(this->isOption());
1359 return CommonOptionField<LibObjT> {this->_libObjPtr()};
1362 template <typename LibObjT>
1363 CommonVariantField<LibObjT> CommonField<LibObjT>::asVariant() const noexcept
1365 BT_ASSERT_DBG(this->isVariant());
1366 return CommonVariantField<LibObjT> {this->_libObjPtr()};
1371 #endif // BABELTRACE_CPP_COMMON_BT2_FIELD_HPP