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"
17 #include "cpp-common/string_view.hpp"
19 #include "borrowed-object.hpp"
20 #include "field-class.hpp"
21 #include "internal/utils.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 CommonBoolField<LibObjT> operator=(const Value val) const noexcept
287 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstBoolField`.");
289 bt_field_bool_set_value(this->libObjPtr(), static_cast<bt_bool>(val));
293 Value value() const noexcept
295 return static_cast<Value>(bt_field_bool_get_value(this->libObjPtr()));
298 operator Value() const noexcept
300 return this->value();
304 using BoolField = CommonBoolField<bt_field>;
305 using ConstBoolField = CommonBoolField<const bt_field>;
309 struct BoolFieldTypeDescr
311 using Const = ConstBoolField;
312 using NonConst = BoolField;
316 struct TypeDescr<BoolField> : public BoolFieldTypeDescr
321 struct TypeDescr<ConstBoolField> : public BoolFieldTypeDescr
325 } /* namespace internal */
327 template <typename LibObjT>
328 class CommonBitArrayField final : public CommonField<LibObjT>
331 using typename CommonField<LibObjT>::_LibObjPtr;
332 using typename CommonField<LibObjT>::_ThisCommonField;
335 using Class = internal::DepType<LibObjT, BitArrayFieldClass, ConstBitArrayFieldClass>;
337 explicit CommonBitArrayField(const _LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
339 BT_ASSERT_DBG(this->isBitArray());
342 template <typename OtherLibObjT>
343 CommonBitArrayField(const CommonBitArrayField<OtherLibObjT> val) noexcept :
344 _ThisCommonField {val}
348 template <typename OtherLibObjT>
349 CommonBitArrayField<LibObjT>& operator=(const CommonBitArrayField<OtherLibObjT> val) noexcept
351 _ThisCommonField::operator=(val);
355 CommonBitArrayField<const bt_field> asConst() const noexcept
357 return CommonBitArrayField<const bt_field> {*this};
360 ConstBitArrayFieldClass cls() const noexcept
362 return ConstBitArrayFieldClass {
363 internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
368 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
371 CommonBitArrayField<LibObjT> operator=(const std::uint64_t bits) const noexcept
373 static_assert(!std::is_const<LibObjT>::value,
374 "Not available with `bt2::ConstBitArrayField`.");
376 bt_field_bit_array_set_value_as_integer(this->libObjPtr(), bits);
380 std::uint64_t valueAsInteger() const noexcept
382 return bt_field_bit_array_get_value_as_integer(this->libObjPtr());
385 bool bitValue(const std::uint64_t index) const noexcept
387 BT_ASSERT_DBG(index < this->cls().length());
388 return static_cast<bool>(this->valueAsInteger() & (1ULL << index));
392 using BitArrayField = CommonBitArrayField<bt_field>;
393 using ConstBitArrayField = CommonBitArrayField<const bt_field>;
397 struct BitArrayFieldTypeDescr
399 using Const = ConstBitArrayField;
400 using NonConst = BitArrayField;
404 struct TypeDescr<BitArrayField> : public BitArrayFieldTypeDescr
409 struct TypeDescr<ConstBitArrayField> : public BitArrayFieldTypeDescr
413 } /* namespace internal */
415 template <typename LibObjT>
416 class CommonUnsignedIntegerField : public CommonField<LibObjT>
419 using typename CommonField<LibObjT>::_ThisCommonField;
422 using typename CommonField<LibObjT>::_LibObjPtr;
423 using _ThisCommonUnsignedIntegerField = CommonUnsignedIntegerField<LibObjT>;
426 using Value = std::uint64_t;
427 using Class = internal::DepType<LibObjT, IntegerFieldClass, ConstIntegerFieldClass>;
429 explicit CommonUnsignedIntegerField(const _LibObjPtr libObjPtr) noexcept :
430 _ThisCommonField {libObjPtr}
432 BT_ASSERT_DBG(this->isUnsignedInteger());
435 template <typename OtherLibObjT>
436 CommonUnsignedIntegerField(const CommonUnsignedIntegerField<OtherLibObjT> val) noexcept :
437 _ThisCommonField {val}
441 template <typename OtherLibObjT>
442 _ThisCommonUnsignedIntegerField&
443 operator=(const CommonUnsignedIntegerField<OtherLibObjT> val) noexcept
445 _ThisCommonField::operator=(val);
449 CommonUnsignedIntegerField<const bt_field> asConst() const noexcept
451 return CommonUnsignedIntegerField<const bt_field> {*this};
454 Class cls() const noexcept
456 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
459 CommonUnsignedIntegerField<LibObjT> operator=(const Value val) const noexcept
461 static_assert(!std::is_const<LibObjT>::value,
462 "Not available with `bt2::ConstUnsignedIntegerField`.");
464 bt_field_integer_unsigned_set_value(this->libObjPtr(), val);
468 Value value() const noexcept
470 return bt_field_integer_unsigned_get_value(this->libObjPtr());
473 operator Value() const noexcept
475 return this->value();
479 using UnsignedIntegerField = CommonUnsignedIntegerField<bt_field>;
480 using ConstUnsignedIntegerField = CommonUnsignedIntegerField<const bt_field>;
484 struct UnsignedIntegerFieldTypeDescr
486 using Const = ConstUnsignedIntegerField;
487 using NonConst = UnsignedIntegerField;
491 struct TypeDescr<UnsignedIntegerField> : public UnsignedIntegerFieldTypeDescr
496 struct TypeDescr<ConstUnsignedIntegerField> : public UnsignedIntegerFieldTypeDescr
500 } /* namespace internal */
502 template <typename LibObjT>
503 class CommonSignedIntegerField : public CommonField<LibObjT>
506 using typename CommonField<LibObjT>::_ThisCommonField;
509 using typename CommonField<LibObjT>::_LibObjPtr;
510 using _ThisCommonSignedIntegerField = CommonSignedIntegerField<LibObjT>;
513 using Value = std::int64_t;
514 using Class = internal::DepType<LibObjT, IntegerFieldClass, ConstIntegerFieldClass>;
516 explicit CommonSignedIntegerField(const _LibObjPtr libObjPtr) noexcept :
517 _ThisCommonField {libObjPtr}
519 BT_ASSERT_DBG(this->isSignedInteger());
522 template <typename OtherLibObjT>
523 CommonSignedIntegerField(const CommonSignedIntegerField<OtherLibObjT> val) noexcept :
524 _ThisCommonField {val}
528 template <typename OtherLibObjT>
529 _ThisCommonSignedIntegerField&
530 operator=(const CommonSignedIntegerField<OtherLibObjT> val) noexcept
532 _ThisCommonField::operator=(val);
536 CommonSignedIntegerField<const bt_field> asConst() const noexcept
538 return CommonSignedIntegerField<const bt_field> {*this};
541 Class cls() const noexcept
543 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
546 CommonSignedIntegerField<LibObjT> operator=(const Value val) const noexcept
548 static_assert(!std::is_const<LibObjT>::value,
549 "Not available with `bt2::ConstSignedIntegerField`.");
551 bt_field_integer_signed_set_value(this->libObjPtr(), val);
555 Value value() const noexcept
557 return bt_field_integer_signed_get_value(this->libObjPtr());
560 operator Value() const noexcept
562 return this->value();
566 using SignedIntegerField = CommonSignedIntegerField<bt_field>;
567 using ConstSignedIntegerField = CommonSignedIntegerField<const bt_field>;
571 struct SignedIntegerFieldTypeDescr
573 using Const = ConstSignedIntegerField;
574 using NonConst = SignedIntegerField;
578 struct TypeDescr<SignedIntegerField> : public SignedIntegerFieldTypeDescr
583 struct TypeDescr<ConstSignedIntegerField> : public SignedIntegerFieldTypeDescr
587 } /* namespace internal */
589 class EnumerationFieldClassMappingLabels
592 explicit EnumerationFieldClassMappingLabels(
593 const bt_field_class_enumeration_mapping_label_array labels, const std::uint64_t size) :
599 EnumerationFieldClassMappingLabels(const EnumerationFieldClassMappingLabels&) noexcept =
602 EnumerationFieldClassMappingLabels&
603 operator=(const EnumerationFieldClassMappingLabels&) noexcept = default;
605 std::uint64_t length() const noexcept
610 bpstd::string_view operator[](const std::uint64_t index) const noexcept
612 return _mLabels[index];
616 bt_field_class_enumeration_mapping_label_array _mLabels;
620 template <typename LibObjT>
621 class CommonUnsignedEnumerationField final : public CommonUnsignedIntegerField<LibObjT>
624 using typename CommonUnsignedIntegerField<LibObjT>::_ThisCommonUnsignedIntegerField;
625 using typename CommonField<LibObjT>::_LibObjPtr;
628 using Class = internal::DepType<LibObjT, UnsignedEnumerationFieldClass,
629 ConstUnsignedEnumerationFieldClass>;
631 explicit CommonUnsignedEnumerationField(const _LibObjPtr libObjPtr) noexcept :
632 _ThisCommonUnsignedIntegerField {libObjPtr}
634 BT_ASSERT_DBG(this->isUnsignedEnumeration());
637 template <typename OtherLibObjT>
638 CommonUnsignedEnumerationField(const CommonUnsignedEnumerationField<OtherLibObjT> val) noexcept
640 _ThisCommonUnsignedIntegerField {val}
644 template <typename OtherLibObjT>
645 CommonUnsignedEnumerationField<LibObjT>&
646 operator=(const CommonUnsignedEnumerationField<OtherLibObjT> val) noexcept
648 _ThisCommonUnsignedIntegerField::operator=(val);
652 CommonUnsignedEnumerationField<const bt_field> asConst() const noexcept
654 return CommonUnsignedEnumerationField<const bt_field> {*this};
657 using CommonUnsignedIntegerField<LibObjT>::operator=;
659 Class cls() const noexcept
661 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
664 EnumerationFieldClassMappingLabels labels() const
666 bt_field_class_enumeration_mapping_label_array labelArray;
668 const auto status = bt_field_enumeration_unsigned_get_mapping_labels(this->libObjPtr(),
669 &labelArray, &count);
671 if (status == BT_FIELD_ENUMERATION_GET_MAPPING_LABELS_STATUS_MEMORY_ERROR) {
672 throw MemoryError {};
675 return EnumerationFieldClassMappingLabels {labelArray, count};
679 using UnsignedEnumerationField = CommonUnsignedEnumerationField<bt_field>;
680 using ConstUnsignedEnumerationField = CommonUnsignedEnumerationField<const bt_field>;
684 struct UnsignedEnumerationFieldTypeDescr
686 using Const = ConstUnsignedEnumerationField;
687 using NonConst = UnsignedEnumerationField;
691 struct TypeDescr<UnsignedEnumerationField> : public UnsignedEnumerationFieldTypeDescr
696 struct TypeDescr<ConstUnsignedEnumerationField> : public UnsignedEnumerationFieldTypeDescr
700 } /* namespace internal */
702 template <typename LibObjT>
703 class CommonSignedEnumerationField final : public CommonSignedIntegerField<LibObjT>
706 using typename CommonSignedIntegerField<LibObjT>::_ThisCommonSignedIntegerField;
707 using typename CommonField<LibObjT>::_LibObjPtr;
711 internal::DepType<LibObjT, SignedEnumerationFieldClass, ConstSignedEnumerationFieldClass>;
713 explicit CommonSignedEnumerationField(const _LibObjPtr libObjPtr) noexcept :
714 _ThisCommonSignedIntegerField {libObjPtr}
716 BT_ASSERT_DBG(this->isSignedEnumeration());
719 template <typename OtherLibObjT>
720 CommonSignedEnumerationField(const CommonSignedEnumerationField<OtherLibObjT> val) noexcept :
721 _ThisCommonSignedIntegerField {val}
725 template <typename OtherLibObjT>
726 CommonSignedEnumerationField<LibObjT>&
727 operator=(const CommonSignedEnumerationField<OtherLibObjT> val) noexcept
729 _ThisCommonSignedIntegerField::operator=(val);
733 CommonSignedEnumerationField<const bt_field> asConst() const noexcept
735 return CommonSignedEnumerationField<const bt_field> {*this};
738 using CommonSignedIntegerField<LibObjT>::operator=;
740 Class cls() const noexcept
742 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
745 EnumerationFieldClassMappingLabels labels() const
747 bt_field_class_enumeration_mapping_label_array labelArray;
750 bt_field_enumeration_signed_get_mapping_labels(this->libObjPtr(), &labelArray, &count);
752 if (status == BT_FIELD_ENUMERATION_GET_MAPPING_LABELS_STATUS_MEMORY_ERROR) {
753 throw MemoryError {};
756 return EnumerationFieldClassMappingLabels {labelArray, count};
760 using SignedEnumerationField = CommonSignedEnumerationField<bt_field>;
761 using ConstSignedEnumerationField = CommonSignedEnumerationField<const bt_field>;
765 struct SignedEnumerationFieldTypeDescr
767 using Const = ConstSignedEnumerationField;
768 using NonConst = SignedEnumerationField;
772 struct TypeDescr<SignedEnumerationField> : public SignedEnumerationFieldTypeDescr
777 struct TypeDescr<ConstSignedEnumerationField> : public SignedEnumerationFieldTypeDescr
781 } /* namespace internal */
783 template <typename LibObjT>
784 class CommonSinglePrecisionRealField final : public CommonField<LibObjT>
787 using typename CommonField<LibObjT>::_LibObjPtr;
788 using typename CommonField<LibObjT>::_ThisCommonField;
793 explicit CommonSinglePrecisionRealField(const _LibObjPtr libObjPtr) noexcept :
794 _ThisCommonField {libObjPtr}
796 BT_ASSERT_DBG(this->isSinglePrecisionReal());
799 template <typename OtherLibObjT>
800 CommonSinglePrecisionRealField(const CommonSinglePrecisionRealField<OtherLibObjT> val) noexcept
802 _ThisCommonField {val}
806 template <typename OtherLibObjT>
807 CommonSinglePrecisionRealField<LibObjT>&
808 operator=(const CommonSinglePrecisionRealField<OtherLibObjT> val) noexcept
810 _ThisCommonField::operator=(val);
814 CommonSinglePrecisionRealField<const bt_field> asConst() const noexcept
816 return CommonSinglePrecisionRealField<const bt_field> {*this};
819 CommonSinglePrecisionRealField<LibObjT> operator=(const Value val) const noexcept
821 static_assert(!std::is_const<LibObjT>::value,
822 "Not available with `bt2::ConstSinglePrecisionRealField`.");
824 bt_field_real_single_precision_set_value(this->libObjPtr(), val);
828 Value value() const noexcept
830 return bt_field_real_single_precision_get_value(this->libObjPtr());
833 operator Value() const noexcept
835 return this->value();
839 using SinglePrecisionRealField = CommonSinglePrecisionRealField<bt_field>;
840 using ConstSinglePrecisionRealField = CommonSinglePrecisionRealField<const bt_field>;
844 struct SinglePrecisionRealFieldTypeDescr
846 using Const = ConstSinglePrecisionRealField;
847 using NonConst = SinglePrecisionRealField;
851 struct TypeDescr<SinglePrecisionRealField> : public SinglePrecisionRealFieldTypeDescr
856 struct TypeDescr<ConstSinglePrecisionRealField> : public SinglePrecisionRealFieldTypeDescr
860 } /* namespace internal */
862 template <typename LibObjT>
863 class CommonDoublePrecisionRealField final : public CommonField<LibObjT>
866 using typename CommonField<LibObjT>::_LibObjPtr;
867 using typename CommonField<LibObjT>::_ThisCommonField;
870 using Value = double;
872 explicit CommonDoublePrecisionRealField(const _LibObjPtr libObjPtr) noexcept :
873 _ThisCommonField {libObjPtr}
875 BT_ASSERT_DBG(this->isDoublePrecisionReal());
878 template <typename OtherLibObjT>
879 CommonDoublePrecisionRealField(const CommonDoublePrecisionRealField<OtherLibObjT> val) noexcept
881 _ThisCommonField {val}
885 template <typename OtherLibObjT>
886 CommonDoublePrecisionRealField<LibObjT>&
887 operator=(const CommonDoublePrecisionRealField<OtherLibObjT> val) noexcept
889 _ThisCommonField::operator=(val);
893 CommonDoublePrecisionRealField<const bt_field> asConst() const noexcept
895 return CommonDoublePrecisionRealField<const bt_field> {*this};
898 CommonDoublePrecisionRealField<LibObjT> operator=(const Value val) const noexcept
900 static_assert(!std::is_const<LibObjT>::value,
901 "Not available with `bt2::ConstDoublePrecisionRealField`.");
903 bt_field_real_double_precision_set_value(this->libObjPtr(), val);
907 Value value() const noexcept
909 return bt_field_real_double_precision_get_value(this->libObjPtr());
912 operator Value() const noexcept
914 return this->value();
918 using DoublePrecisionRealField = CommonDoublePrecisionRealField<bt_field>;
919 using ConstDoublePrecisionRealField = CommonDoublePrecisionRealField<const bt_field>;
923 struct DoublePrecisionRealFieldTypeDescr
925 using Const = ConstDoublePrecisionRealField;
926 using NonConst = DoublePrecisionRealField;
930 struct TypeDescr<DoublePrecisionRealField> : public DoublePrecisionRealFieldTypeDescr
935 struct TypeDescr<ConstDoublePrecisionRealField> : public DoublePrecisionRealFieldTypeDescr
939 } /* namespace internal */
941 template <typename LibObjT>
942 class CommonStringField final : public CommonField<LibObjT>
945 using typename CommonField<LibObjT>::_LibObjPtr;
946 using typename CommonField<LibObjT>::_ThisCommonField;
949 explicit CommonStringField(const _LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
951 BT_ASSERT_DBG(this->isString());
954 template <typename OtherLibObjT>
955 CommonStringField(const CommonStringField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
959 template <typename OtherLibObjT>
960 CommonStringField<LibObjT>& operator=(const CommonStringField<OtherLibObjT> val) noexcept
962 _ThisCommonField::operator=(val);
966 CommonStringField<const bt_field> asConst() const noexcept
968 return CommonStringField<const bt_field> {*this};
971 CommonStringField<LibObjT> operator=(const char * const val) const
973 static_assert(!std::is_const<LibObjT>::value,
974 "Not available with `bt2::ConstStringField`.");
976 const auto status = bt_field_string_set_value(this->libObjPtr(), val);
978 if (status == BT_FIELD_STRING_SET_VALUE_STATUS_MEMORY_ERROR) {
979 throw MemoryError {};
985 CommonStringField<LibObjT> operator=(const std::string& val) const
987 return *this = val.data();
990 void append(const char * const begin, const std::uint64_t len) const
992 static_assert(!std::is_const<LibObjT>::value,
993 "Not available with `bt2::ConstStringField`.");
995 const auto status = bt_field_string_append_with_length(this->libObjPtr(), begin, len);
997 if (status == BT_FIELD_STRING_APPEND_STATUS_MEMORY_ERROR) {
998 throw MemoryError {};
1002 void append(const std::string& val) const
1004 this->append(val.data(), val.size());
1007 void clear() const noexcept
1009 static_assert(!std::is_const<LibObjT>::value,
1010 "Not available with `bt2::ConstStringField`.");
1012 bt_field_string_clear(this->libObjPtr());
1015 bpstd::string_view value() const noexcept
1017 return bt_field_string_get_value(this->libObjPtr());
1021 using StringField = CommonStringField<bt_field>;
1022 using ConstStringField = CommonStringField<const bt_field>;
1024 namespace internal {
1026 struct StringFieldTypeDescr
1028 using Const = ConstStringField;
1029 using NonConst = StringField;
1033 struct TypeDescr<StringField> : public StringFieldTypeDescr
1038 struct TypeDescr<ConstStringField> : public StringFieldTypeDescr
1042 template <typename LibObjT>
1043 struct CommonStructureFieldSpec;
1045 /* Functions specific to mutable structure fields */
1047 struct CommonStructureFieldSpec<bt_field> final
1049 static bt_field *memberFieldByIndex(bt_field * const libObjPtr,
1050 const std::uint64_t index) noexcept
1052 return bt_field_structure_borrow_member_field_by_index(libObjPtr, index);
1055 static bt_field *memberFieldByName(bt_field * const libObjPtr, const char * const name) noexcept
1057 return bt_field_structure_borrow_member_field_by_name(libObjPtr, name);
1061 /* Functions specific to constant structure fields */
1063 struct CommonStructureFieldSpec<const bt_field> final
1065 static const bt_field *memberFieldByIndex(const bt_field * const libObjPtr,
1066 const std::uint64_t index) noexcept
1068 return bt_field_structure_borrow_member_field_by_index_const(libObjPtr, index);
1071 static const bt_field *memberFieldByName(const bt_field * const libObjPtr,
1072 const char * const name) noexcept
1074 return bt_field_structure_borrow_member_field_by_name_const(libObjPtr, name);
1078 } /* namespace internal */
1080 template <typename LibObjT>
1081 class CommonStructureField final : public CommonField<LibObjT>
1084 using typename CommonField<LibObjT>::_LibObjPtr;
1085 using typename CommonField<LibObjT>::_ThisCommonField;
1086 using _Spec = internal::CommonStructureFieldSpec<LibObjT>;
1089 using Class = internal::DepType<LibObjT, StructureFieldClass, ConstStructureFieldClass>;
1091 explicit CommonStructureField(const _LibObjPtr libObjPtr) noexcept :
1092 _ThisCommonField {libObjPtr}
1094 BT_ASSERT_DBG(this->isStructure());
1097 template <typename OtherLibObjT>
1098 CommonStructureField(const CommonStructureField<OtherLibObjT> val) noexcept :
1099 _ThisCommonField {val}
1103 template <typename OtherLibObjT>
1104 CommonStructureField<LibObjT>& operator=(const CommonStructureField<OtherLibObjT> val) noexcept
1106 _ThisCommonField::operator=(val);
1110 CommonStructureField<const bt_field> asConst() const noexcept
1112 return CommonStructureField<const bt_field> {*this};
1115 Class cls() const noexcept
1117 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
1120 std::uint64_t length() const noexcept
1122 return this->cls().length();
1125 CommonField<LibObjT> operator[](const std::uint64_t index) const noexcept
1127 return CommonField<LibObjT> {_Spec::memberFieldByIndex(this->libObjPtr(), index)};
1130 nonstd::optional<CommonField<LibObjT>> operator[](const char * const name) const noexcept
1132 const auto libObjPtr = _Spec::memberFieldByName(this->libObjPtr(), name);
1135 return CommonField<LibObjT> {libObjPtr};
1138 return nonstd::nullopt;
1141 nonstd::optional<CommonField<LibObjT>> operator[](const std::string& name) const noexcept
1143 return (*this)[name.data()];
1147 using StructureField = CommonStructureField<bt_field>;
1148 using ConstStructureField = CommonStructureField<const bt_field>;
1150 namespace internal {
1152 struct StructureFieldTypeDescr
1154 using Const = ConstStructureField;
1155 using NonConst = StructureField;
1159 struct TypeDescr<StructureField> : public StructureFieldTypeDescr
1164 struct TypeDescr<ConstStructureField> : public StructureFieldTypeDescr
1168 template <typename LibObjT>
1169 struct CommonArrayFieldSpec;
1171 /* Functions specific to mutable array fields */
1173 struct CommonArrayFieldSpec<bt_field> final
1175 static bt_field *elementFieldByIndex(bt_field * const libObjPtr,
1176 const std::uint64_t index) noexcept
1178 return bt_field_array_borrow_element_field_by_index(libObjPtr, index);
1182 /* Functions specific to constant array fields */
1184 struct CommonArrayFieldSpec<const bt_field> final
1186 static const bt_field *elementFieldByIndex(const bt_field * const libObjPtr,
1187 const std::uint64_t index) noexcept
1189 return bt_field_array_borrow_element_field_by_index_const(libObjPtr, index);
1193 } /* namespace internal */
1195 template <typename LibObjT>
1196 class CommonArrayField : public CommonField<LibObjT>
1199 using typename CommonField<LibObjT>::_ThisCommonField;
1200 using _Spec = internal::CommonArrayFieldSpec<LibObjT>;
1203 using typename CommonField<LibObjT>::_LibObjPtr;
1204 using _ThisCommonArrayField = CommonArrayField<LibObjT>;
1207 using Class = internal::DepType<LibObjT, ArrayFieldClass, ConstArrayFieldClass>;
1209 explicit CommonArrayField(const _LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
1211 BT_ASSERT_DBG(this->isArray());
1214 template <typename OtherLibObjT>
1215 CommonArrayField(const CommonArrayField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
1219 template <typename OtherLibObjT>
1220 _ThisCommonArrayField& operator=(const CommonArrayField<OtherLibObjT> val) noexcept
1222 _ThisCommonField::operator=(val);
1226 CommonArrayField<const bt_field> asConst() const noexcept
1228 return CommonArrayField<const bt_field> {*this};
1231 Class cls() const noexcept
1233 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
1236 std::uint64_t length() const noexcept
1238 return bt_field_array_get_length(this->libObjPtr());
1241 CommonField<LibObjT> operator[](const std::uint64_t index) const noexcept
1243 return CommonField<LibObjT> {_Spec::elementFieldByIndex(this->libObjPtr(), index)};
1247 using ArrayField = CommonArrayField<bt_field>;
1248 using ConstArrayField = CommonArrayField<const bt_field>;
1250 namespace internal {
1252 struct ArrayFieldTypeDescr
1254 using Const = ConstArrayField;
1255 using NonConst = ArrayField;
1259 struct TypeDescr<ArrayField> : public ArrayFieldTypeDescr
1264 struct TypeDescr<ConstArrayField> : public ArrayFieldTypeDescr
1268 } /* namespace internal */
1270 template <typename LibObjT>
1271 class CommonDynamicArrayField : public CommonArrayField<LibObjT>
1274 using typename CommonField<LibObjT>::_LibObjPtr;
1275 using typename CommonArrayField<LibObjT>::_ThisCommonArrayField;
1278 explicit CommonDynamicArrayField(const _LibObjPtr libObjPtr) noexcept :
1279 _ThisCommonArrayField {libObjPtr}
1281 BT_ASSERT_DBG(this->isDynamicArray());
1284 template <typename OtherLibObjT>
1285 CommonDynamicArrayField(const CommonDynamicArrayField<OtherLibObjT> val) noexcept :
1286 _ThisCommonArrayField {val}
1290 template <typename OtherLibObjT>
1291 CommonDynamicArrayField<LibObjT>&
1292 operator=(const CommonDynamicArrayField<OtherLibObjT> val) noexcept
1294 _ThisCommonArrayField::operator=(val);
1298 CommonDynamicArrayField<const bt_field> asConst() const noexcept
1300 return CommonDynamicArrayField<const bt_field> {*this};
1303 std::uint64_t length() const noexcept
1305 return _ThisCommonArrayField::length();
1308 void length(const std::uint64_t length) const
1310 static_assert(!std::is_const<LibObjT>::value,
1311 "Not available with `bt2::ConstDynamicArrayField`.");
1313 const auto status = bt_field_array_dynamic_set_length(this->libObjPtr(), length);
1315 if (status == BT_FIELD_DYNAMIC_ARRAY_SET_LENGTH_STATUS_MEMORY_ERROR) {
1316 throw MemoryError {};
1321 using DynamicArrayField = CommonDynamicArrayField<bt_field>;
1322 using ConstDynamicArrayField = CommonDynamicArrayField<const bt_field>;
1324 namespace internal {
1326 struct DynamicArrayFieldTypeDescr
1328 using Const = ConstDynamicArrayField;
1329 using NonConst = DynamicArrayField;
1333 struct TypeDescr<DynamicArrayField> : public DynamicArrayFieldTypeDescr
1338 struct TypeDescr<ConstDynamicArrayField> : public DynamicArrayFieldTypeDescr
1342 template <typename LibObjT>
1343 struct CommonOptionFieldSpec;
1345 /* Functions specific to mutable option fields */
1347 struct CommonOptionFieldSpec<bt_field> final
1349 static bt_field *field(bt_field * const libObjPtr) noexcept
1351 return bt_field_option_borrow_field(libObjPtr);
1355 /* Functions specific to constant option fields */
1357 struct CommonOptionFieldSpec<const bt_field> final
1359 static const bt_field *field(const bt_field * const libObjPtr) noexcept
1361 return bt_field_option_borrow_field_const(libObjPtr);
1365 } /* namespace internal */
1367 template <typename LibObjT>
1368 class CommonOptionField : public CommonField<LibObjT>
1371 using typename CommonField<LibObjT>::_LibObjPtr;
1372 using typename CommonField<LibObjT>::_ThisCommonField;
1373 using _Spec = internal::CommonOptionFieldSpec<LibObjT>;
1376 using Class = internal::DepType<LibObjT, OptionFieldClass, ConstOptionFieldClass>;
1378 explicit CommonOptionField(const _LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
1380 BT_ASSERT_DBG(this->isOption());
1383 template <typename OtherLibObjT>
1384 CommonOptionField(const CommonOptionField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
1388 template <typename OtherLibObjT>
1389 CommonOptionField<LibObjT>& operator=(const CommonOptionField<OtherLibObjT> val) noexcept
1391 _ThisCommonField::operator=(val);
1395 CommonOptionField<const bt_field> asConst() const noexcept
1397 return CommonOptionField<const bt_field> {*this};
1400 Class cls() const noexcept
1402 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
1405 void hasField(const bool hasField) const noexcept
1407 static_assert(!std::is_const<LibObjT>::value,
1408 "Not available with `bt2::ConstOptionField`.");
1410 bt_field_option_set_has_field(this->libObjPtr(), static_cast<bt_bool>(hasField));
1413 bool hasField() const noexcept
1415 return this->field().has_value();
1418 nonstd::optional<CommonField<LibObjT>> field() const noexcept
1420 const auto libObjPtr = _Spec::field(this->libObjPtr());
1423 return CommonField<LibObjT> {libObjPtr};
1426 return nonstd::nullopt;
1430 using OptionField = CommonOptionField<bt_field>;
1431 using ConstOptionField = CommonOptionField<const bt_field>;
1433 namespace internal {
1435 struct OptionFieldTypeDescr
1437 using Const = ConstOptionField;
1438 using NonConst = OptionField;
1442 struct TypeDescr<OptionField> : public OptionFieldTypeDescr
1447 struct TypeDescr<ConstOptionField> : public OptionFieldTypeDescr
1451 template <typename LibObjT>
1452 struct CommonVariantFieldSpec;
1454 /* Functions specific to mutable variant fields */
1456 struct CommonVariantFieldSpec<bt_field> final
1458 static bt_field *selectedOptionField(bt_field * const libObjPtr) noexcept
1460 return bt_field_variant_borrow_selected_option_field(libObjPtr);
1464 /* Functions specific to constant variant fields */
1466 struct CommonVariantFieldSpec<const bt_field> final
1468 static const bt_field *selectedOptionField(const bt_field * const libObjPtr) noexcept
1470 return bt_field_variant_borrow_selected_option_field_const(libObjPtr);
1474 } /* namespace internal */
1476 template <typename LibObjT>
1477 class CommonVariantField : public CommonField<LibObjT>
1480 using typename CommonField<LibObjT>::_LibObjPtr;
1481 using typename CommonField<LibObjT>::_ThisCommonField;
1482 using _Spec = internal::CommonVariantFieldSpec<LibObjT>;
1485 using Class = internal::DepType<LibObjT, VariantFieldClass, ConstVariantFieldClass>;
1487 explicit CommonVariantField(const _LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
1489 BT_ASSERT_DBG(this->isVariant());
1492 template <typename OtherLibObjT>
1493 CommonVariantField(const CommonVariantField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
1497 template <typename OtherLibObjT>
1498 CommonVariantField<LibObjT>& operator=(const CommonVariantField<OtherLibObjT> val) noexcept
1500 _ThisCommonField::operator=(val);
1504 CommonVariantField<const bt_field> asConst() const noexcept
1506 return CommonVariantField<const bt_field> {*this};
1509 Class cls() const noexcept
1511 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
1514 void selectOption(const std::uint64_t index) const noexcept
1516 static_assert(!std::is_const<LibObjT>::value,
1517 "Not available with `bt2::ConstVariantField`.");
1519 static_cast<void>(bt_field_variant_select_option_by_index(this->libObjPtr(), index));
1522 CommonField<LibObjT> selectedOptionField() const noexcept
1524 return CommonField<LibObjT> {_Spec::selectedOptionField(this->libObjPtr())};
1527 std::uint64_t selectedOptionIndex() const noexcept
1529 return bt_field_variant_get_selected_option_index(this->libObjPtr());
1533 using VariantField = CommonVariantField<bt_field>;
1534 using ConstVariantField = CommonVariantField<const bt_field>;
1536 namespace internal {
1538 struct VariantFieldTypeDescr
1540 using Const = ConstVariantField;
1541 using NonConst = VariantField;
1545 struct TypeDescr<VariantField> : public VariantFieldTypeDescr
1550 struct TypeDescr<ConstVariantField> : public VariantFieldTypeDescr
1554 } /* namespace internal */
1556 template <typename LibObjT>
1557 CommonBoolField<LibObjT> CommonField<LibObjT>::asBool() const noexcept
1559 BT_ASSERT_DBG(this->isBool());
1560 return CommonBoolField<LibObjT> {this->libObjPtr()};
1563 template <typename LibObjT>
1564 CommonBitArrayField<LibObjT> CommonField<LibObjT>::asBitArray() const noexcept
1566 BT_ASSERT_DBG(this->isBitArray());
1567 return CommonBitArrayField<LibObjT> {this->libObjPtr()};
1570 template <typename LibObjT>
1571 CommonUnsignedIntegerField<LibObjT> CommonField<LibObjT>::asUnsignedInteger() const noexcept
1573 BT_ASSERT_DBG(this->isUnsignedInteger());
1574 return CommonUnsignedIntegerField<LibObjT> {this->libObjPtr()};
1577 template <typename LibObjT>
1578 CommonSignedIntegerField<LibObjT> CommonField<LibObjT>::asSignedInteger() const noexcept
1580 BT_ASSERT_DBG(this->isSignedInteger());
1581 return CommonSignedIntegerField<LibObjT> {this->libObjPtr()};
1584 template <typename LibObjT>
1585 CommonUnsignedEnumerationField<LibObjT> CommonField<LibObjT>::asUnsignedEnumeration() const noexcept
1587 BT_ASSERT_DBG(this->isUnsignedEnumeration());
1588 return CommonUnsignedEnumerationField<LibObjT> {this->libObjPtr()};
1591 template <typename LibObjT>
1592 CommonSignedEnumerationField<LibObjT> CommonField<LibObjT>::asSignedEnumeration() const noexcept
1594 BT_ASSERT_DBG(this->isSignedEnumeration());
1595 return CommonSignedEnumerationField<LibObjT> {this->libObjPtr()};
1598 template <typename LibObjT>
1599 CommonSinglePrecisionRealField<LibObjT> CommonField<LibObjT>::asSinglePrecisionReal() const noexcept
1601 BT_ASSERT_DBG(this->isSinglePrecisionReal());
1602 return CommonSinglePrecisionRealField<LibObjT> {this->libObjPtr()};
1605 template <typename LibObjT>
1606 CommonDoublePrecisionRealField<LibObjT> CommonField<LibObjT>::asDoublePrecisionReal() const noexcept
1608 BT_ASSERT_DBG(this->isDoublePrecisionReal());
1609 return CommonDoublePrecisionRealField<LibObjT> {this->libObjPtr()};
1612 template <typename LibObjT>
1613 CommonStringField<LibObjT> CommonField<LibObjT>::asString() const noexcept
1615 BT_ASSERT_DBG(this->isString());
1616 return CommonStringField<LibObjT> {this->libObjPtr()};
1619 template <typename LibObjT>
1620 CommonStructureField<LibObjT> CommonField<LibObjT>::asStructure() const noexcept
1622 BT_ASSERT_DBG(this->isStructure());
1623 return CommonStructureField<LibObjT> {this->libObjPtr()};
1626 template <typename LibObjT>
1627 CommonArrayField<LibObjT> CommonField<LibObjT>::asArray() const noexcept
1629 BT_ASSERT_DBG(this->isArray());
1630 return CommonArrayField<LibObjT> {this->libObjPtr()};
1633 template <typename LibObjT>
1634 CommonDynamicArrayField<LibObjT> CommonField<LibObjT>::asDynamicArray() const noexcept
1636 BT_ASSERT_DBG(this->isDynamicArray());
1637 return CommonDynamicArrayField<LibObjT> {this->libObjPtr()};
1640 template <typename LibObjT>
1641 CommonOptionField<LibObjT> CommonField<LibObjT>::asOption() const noexcept
1643 BT_ASSERT_DBG(this->isOption());
1644 return CommonOptionField<LibObjT> {this->libObjPtr()};
1647 template <typename LibObjT>
1648 CommonVariantField<LibObjT> CommonField<LibObjT>::asVariant() const noexcept
1650 BT_ASSERT_DBG(this->isVariant());
1651 return CommonVariantField<LibObjT> {this->libObjPtr()};
1654 } /* namespace bt2 */
1656 #endif /* BABELTRACE_CPP_COMMON_BT2_FIELD_HPP */