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"
18 #include "borrowed-object.hpp"
19 #include "field-class.hpp"
20 #include "internal/utils.hpp"
21 #include "optional-borrowed-object.hpp"
22 #include "raw-value-proxy.hpp"
26 template <typename LibObjT>
27 class CommonBoolField;
29 template <typename LibObjT>
30 class CommonBitArrayField;
32 template <typename LibObjT>
33 class CommonUnsignedIntegerField;
35 template <typename LibObjT>
36 class CommonSignedIntegerField;
38 template <typename LibObjT>
39 class CommonUnsignedEnumerationField;
41 template <typename LibObjT>
42 class CommonSignedEnumerationField;
44 template <typename LibObjT>
45 class CommonSinglePrecisionRealField;
47 template <typename LibObjT>
48 class CommonDoublePrecisionRealField;
50 template <typename LibObjT>
51 class CommonStringField;
53 template <typename LibObjT>
54 class CommonStructureField;
56 template <typename LibObjT>
57 class CommonArrayField;
59 template <typename LibObjT>
60 class CommonDynamicArrayField;
62 template <typename LibObjT>
63 class CommonOptionField;
65 template <typename LibObjT>
66 class CommonVariantField;
70 template <typename LibObjT>
71 struct CommonFieldSpec;
73 /* Functions specific to mutable fields */
75 struct CommonFieldSpec<bt_field> final
77 static bt_field_class *cls(bt_field * const libObjPtr) noexcept
79 return bt_field_borrow_class(libObjPtr);
83 /* Functions specific to constant fields */
85 struct CommonFieldSpec<const bt_field> final
87 static const bt_field_class *cls(const bt_field * const libObjPtr) noexcept
89 return bt_field_borrow_class_const(libObjPtr);
93 } /* namespace internal */
95 template <typename LibObjT>
96 class CommonField : public BorrowedObject<LibObjT>
99 using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
102 using _ThisCommonField = CommonField<LibObjT>;
105 using typename BorrowedObject<LibObjT>::LibObjPtr;
106 using Class = internal::DepFc<LibObjT>;
108 explicit CommonField(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
112 template <typename OtherLibObjT>
113 CommonField(const CommonField<OtherLibObjT> val) noexcept : _ThisBorrowedObject {val}
117 template <typename OtherLibObjT>
118 _ThisCommonField operator=(const CommonField<OtherLibObjT> val) noexcept
120 _ThisBorrowedObject::operator=(val);
124 CommonField<const bt_field> asConst() const noexcept
126 return CommonField<const bt_field> {*this};
129 FieldClassType classType() const noexcept
131 return static_cast<FieldClassType>(bt_field_get_class_type(this->libObjPtr()));
134 Class cls() const noexcept
136 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
139 bool isBool() const noexcept
141 return this->cls().isBool();
144 bool isBitArray() const noexcept
146 return this->cls().isBitArray();
149 bool isUnsignedInteger() const noexcept
151 return this->cls().isUnsignedInteger();
154 bool isSignedInteger() const noexcept
156 return this->cls().isSignedInteger();
159 bool isUnsignedEnumeration() const noexcept
161 return this->cls().isUnsignedEnumeration();
164 bool isSignedEnumeration() const noexcept
166 return this->cls().isSignedEnumeration();
169 bool isSinglePrecisionReal() const noexcept
171 return this->cls().isSinglePrecisionReal();
174 bool isDoublePrecisionReal() const noexcept
176 return this->cls().isDoublePrecisionReal();
179 bool isString() const noexcept
181 return this->cls().isString();
184 bool isStructure() const noexcept
186 return this->cls().isStructure();
189 bool isArray() const noexcept
191 return this->cls().isArray();
194 bool isDynamicArray() const noexcept
196 return this->cls().isDynamicArray();
199 bool isOption() const noexcept
201 return this->cls().isOption();
204 bool isVariant() const noexcept
206 return this->cls().isVariant();
209 template <typename FieldT>
210 FieldT as() const noexcept
212 return FieldT {this->libObjPtr()};
215 CommonBoolField<LibObjT> asBool() const noexcept;
216 CommonBitArrayField<LibObjT> asBitArray() const noexcept;
217 CommonUnsignedIntegerField<LibObjT> asUnsignedInteger() const noexcept;
218 CommonSignedIntegerField<LibObjT> asSignedInteger() const noexcept;
219 CommonUnsignedEnumerationField<LibObjT> asUnsignedEnumeration() const noexcept;
220 CommonSignedEnumerationField<LibObjT> asSignedEnumeration() const noexcept;
221 CommonSinglePrecisionRealField<LibObjT> asSinglePrecisionReal() const noexcept;
222 CommonDoublePrecisionRealField<LibObjT> asDoublePrecisionReal() const noexcept;
223 CommonStringField<LibObjT> asString() const noexcept;
224 CommonStructureField<LibObjT> asStructure() const noexcept;
225 CommonArrayField<LibObjT> asArray() const noexcept;
226 CommonDynamicArrayField<LibObjT> asDynamicArray() const noexcept;
227 CommonOptionField<LibObjT> asOption() const noexcept;
228 CommonVariantField<LibObjT> asVariant() const noexcept;
231 using Field = CommonField<bt_field>;
232 using ConstField = CommonField<const bt_field>;
236 struct FieldTypeDescr
238 using Const = ConstField;
239 using NonConst = Field;
243 struct TypeDescr<Field> : public FieldTypeDescr
248 struct TypeDescr<ConstField> : public FieldTypeDescr
252 } /* namespace internal */
254 template <typename LibObjT>
255 class CommonBoolField final : public CommonField<LibObjT>
258 using typename CommonField<LibObjT>::_ThisCommonField;
261 using typename CommonField<LibObjT>::LibObjPtr;
264 explicit CommonBoolField(const LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
266 BT_ASSERT_DBG(this->isBool());
269 template <typename OtherLibObjT>
270 CommonBoolField(const CommonBoolField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
274 template <typename OtherLibObjT>
275 CommonBoolField<LibObjT> operator=(const CommonBoolField<OtherLibObjT> val) noexcept
277 _ThisCommonField::operator=(val);
281 CommonBoolField<const bt_field> asConst() const noexcept
283 return CommonBoolField<const bt_field> {*this};
286 RawValueProxy<CommonBoolField> operator*() const noexcept
288 return RawValueProxy<CommonBoolField> {*this};
291 CommonBoolField value(const Value val) const noexcept
293 static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstBoolField`.");
295 bt_field_bool_set_value(this->libObjPtr(), static_cast<bt_bool>(val));
299 Value value() const noexcept
301 return static_cast<Value>(bt_field_bool_get_value(this->libObjPtr()));
305 using BoolField = CommonBoolField<bt_field>;
306 using ConstBoolField = CommonBoolField<const bt_field>;
310 struct BoolFieldTypeDescr
312 using Const = ConstBoolField;
313 using NonConst = BoolField;
317 struct TypeDescr<BoolField> : public BoolFieldTypeDescr
322 struct TypeDescr<ConstBoolField> : public BoolFieldTypeDescr
326 } /* namespace internal */
328 template <typename LibObjT>
329 class CommonBitArrayField final : public CommonField<LibObjT>
332 using typename CommonField<LibObjT>::_ThisCommonField;
335 using typename CommonField<LibObjT>::LibObjPtr;
336 using Class = internal::DepType<LibObjT, BitArrayFieldClass, ConstBitArrayFieldClass>;
338 explicit CommonBitArrayField(const LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
340 BT_ASSERT_DBG(this->isBitArray());
343 template <typename OtherLibObjT>
344 CommonBitArrayField(const CommonBitArrayField<OtherLibObjT> val) noexcept :
345 _ThisCommonField {val}
349 template <typename OtherLibObjT>
350 CommonBitArrayField<LibObjT> operator=(const CommonBitArrayField<OtherLibObjT> val) noexcept
352 _ThisCommonField::operator=(val);
356 CommonBitArrayField<const bt_field> asConst() const noexcept
358 return CommonBitArrayField<const bt_field> {*this};
361 ConstBitArrayFieldClass cls() const noexcept
363 return ConstBitArrayFieldClass {
364 internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
369 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
372 CommonBitArrayField valueAsInteger(const std::uint64_t bits) const noexcept
374 static_assert(!std::is_const<LibObjT>::value,
375 "Not available with `bt2::ConstBitArrayField`.");
377 bt_field_bit_array_set_value_as_integer(this->libObjPtr(), bits);
381 std::uint64_t valueAsInteger() const noexcept
383 return bt_field_bit_array_get_value_as_integer(this->libObjPtr());
386 bool bitValue(const std::uint64_t index) const noexcept
388 BT_ASSERT_DBG(index < this->cls().length());
389 return static_cast<bool>(this->valueAsInteger() & (1ULL << index));
393 using BitArrayField = CommonBitArrayField<bt_field>;
394 using ConstBitArrayField = CommonBitArrayField<const bt_field>;
398 struct BitArrayFieldTypeDescr
400 using Const = ConstBitArrayField;
401 using NonConst = BitArrayField;
405 struct TypeDescr<BitArrayField> : public BitArrayFieldTypeDescr
410 struct TypeDescr<ConstBitArrayField> : public BitArrayFieldTypeDescr
414 } /* namespace internal */
416 template <typename LibObjT>
417 class CommonUnsignedIntegerField : public CommonField<LibObjT>
420 using typename CommonField<LibObjT>::_ThisCommonField;
423 using _ThisCommonUnsignedIntegerField = CommonUnsignedIntegerField<LibObjT>;
426 using typename CommonField<LibObjT>::LibObjPtr;
427 using Value = std::uint64_t;
428 using Class = internal::DepType<LibObjT, IntegerFieldClass, ConstIntegerFieldClass>;
430 explicit CommonUnsignedIntegerField(const LibObjPtr libObjPtr) noexcept :
431 _ThisCommonField {libObjPtr}
433 BT_ASSERT_DBG(this->isUnsignedInteger());
436 template <typename OtherLibObjT>
437 CommonUnsignedIntegerField(const CommonUnsignedIntegerField<OtherLibObjT> val) noexcept :
438 _ThisCommonField {val}
442 template <typename OtherLibObjT>
443 _ThisCommonUnsignedIntegerField
444 operator=(const CommonUnsignedIntegerField<OtherLibObjT> val) noexcept
446 _ThisCommonField::operator=(val);
450 CommonUnsignedIntegerField<const bt_field> asConst() const noexcept
452 return CommonUnsignedIntegerField<const bt_field> {*this};
455 Class cls() const noexcept
457 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
460 RawValueProxy<CommonUnsignedIntegerField> operator*() const noexcept
462 return RawValueProxy<CommonUnsignedIntegerField> {*this};
465 CommonUnsignedIntegerField value(const Value val) const noexcept
467 static_assert(!std::is_const<LibObjT>::value,
468 "Not available with `bt2::ConstUnsignedIntegerField`.");
470 bt_field_integer_unsigned_set_value(this->libObjPtr(), val);
474 Value value() const noexcept
476 return bt_field_integer_unsigned_get_value(this->libObjPtr());
480 using UnsignedIntegerField = CommonUnsignedIntegerField<bt_field>;
481 using ConstUnsignedIntegerField = CommonUnsignedIntegerField<const bt_field>;
485 struct UnsignedIntegerFieldTypeDescr
487 using Const = ConstUnsignedIntegerField;
488 using NonConst = UnsignedIntegerField;
492 struct TypeDescr<UnsignedIntegerField> : public UnsignedIntegerFieldTypeDescr
497 struct TypeDescr<ConstUnsignedIntegerField> : public UnsignedIntegerFieldTypeDescr
501 } /* namespace internal */
503 template <typename LibObjT>
504 class CommonSignedIntegerField : public CommonField<LibObjT>
507 using typename CommonField<LibObjT>::_ThisCommonField;
510 using _ThisCommonSignedIntegerField = CommonSignedIntegerField<LibObjT>;
513 using typename CommonField<LibObjT>::LibObjPtr;
514 using Value = std::int64_t;
515 using Class = internal::DepType<LibObjT, IntegerFieldClass, ConstIntegerFieldClass>;
517 explicit CommonSignedIntegerField(const LibObjPtr libObjPtr) noexcept :
518 _ThisCommonField {libObjPtr}
520 BT_ASSERT_DBG(this->isSignedInteger());
523 template <typename OtherLibObjT>
524 CommonSignedIntegerField(const CommonSignedIntegerField<OtherLibObjT> val) noexcept :
525 _ThisCommonField {val}
529 template <typename OtherLibObjT>
530 _ThisCommonSignedIntegerField
531 operator=(const CommonSignedIntegerField<OtherLibObjT> val) noexcept
533 _ThisCommonField::operator=(val);
537 CommonSignedIntegerField<const bt_field> asConst() const noexcept
539 return CommonSignedIntegerField<const bt_field> {*this};
542 Class cls() const noexcept
544 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
547 RawValueProxy<CommonSignedIntegerField> operator*() const noexcept
549 return RawValueProxy<CommonSignedIntegerField> {*this};
552 CommonSignedIntegerField value(const Value val) const noexcept
554 static_assert(!std::is_const<LibObjT>::value,
555 "Not available with `bt2::ConstSignedIntegerField`.");
557 bt_field_integer_signed_set_value(this->libObjPtr(), val);
561 Value value() const noexcept
563 return bt_field_integer_signed_get_value(this->libObjPtr());
567 using SignedIntegerField = CommonSignedIntegerField<bt_field>;
568 using ConstSignedIntegerField = CommonSignedIntegerField<const bt_field>;
572 struct SignedIntegerFieldTypeDescr
574 using Const = ConstSignedIntegerField;
575 using NonConst = SignedIntegerField;
579 struct TypeDescr<SignedIntegerField> : public SignedIntegerFieldTypeDescr
584 struct TypeDescr<ConstSignedIntegerField> : public SignedIntegerFieldTypeDescr
588 } /* namespace internal */
590 class EnumerationFieldClassMappingLabels
593 explicit EnumerationFieldClassMappingLabels(
594 const bt_field_class_enumeration_mapping_label_array labels, const std::uint64_t size) :
600 std::uint64_t length() const noexcept
605 bt2c::CStringView operator[](const std::uint64_t index) const noexcept
607 return _mLabels[index];
611 bt_field_class_enumeration_mapping_label_array _mLabels;
615 template <typename LibObjT>
616 class CommonUnsignedEnumerationField final : public CommonUnsignedIntegerField<LibObjT>
619 using typename CommonUnsignedIntegerField<LibObjT>::_ThisCommonUnsignedIntegerField;
622 using typename CommonField<LibObjT>::LibObjPtr;
624 using Class = internal::DepType<LibObjT, UnsignedEnumerationFieldClass,
625 ConstUnsignedEnumerationFieldClass>;
627 explicit CommonUnsignedEnumerationField(const LibObjPtr libObjPtr) noexcept :
628 _ThisCommonUnsignedIntegerField {libObjPtr}
630 BT_ASSERT_DBG(this->isUnsignedEnumeration());
633 template <typename OtherLibObjT>
634 CommonUnsignedEnumerationField(const CommonUnsignedEnumerationField<OtherLibObjT> val) noexcept
636 _ThisCommonUnsignedIntegerField {val}
640 template <typename OtherLibObjT>
641 CommonUnsignedEnumerationField<LibObjT>
642 operator=(const CommonUnsignedEnumerationField<OtherLibObjT> val) noexcept
644 _ThisCommonUnsignedIntegerField::operator=(val);
648 CommonUnsignedEnumerationField<const bt_field> asConst() const noexcept
650 return CommonUnsignedEnumerationField<const bt_field> {*this};
653 Class cls() const noexcept
655 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
658 EnumerationFieldClassMappingLabels labels() const
660 bt_field_class_enumeration_mapping_label_array labelArray;
662 const auto status = bt_field_enumeration_unsigned_get_mapping_labels(this->libObjPtr(),
663 &labelArray, &count);
665 if (status == BT_FIELD_ENUMERATION_GET_MAPPING_LABELS_STATUS_MEMORY_ERROR) {
666 throw MemoryError {};
669 return EnumerationFieldClassMappingLabels {labelArray, count};
673 using UnsignedEnumerationField = CommonUnsignedEnumerationField<bt_field>;
674 using ConstUnsignedEnumerationField = CommonUnsignedEnumerationField<const bt_field>;
678 struct UnsignedEnumerationFieldTypeDescr
680 using Const = ConstUnsignedEnumerationField;
681 using NonConst = UnsignedEnumerationField;
685 struct TypeDescr<UnsignedEnumerationField> : public UnsignedEnumerationFieldTypeDescr
690 struct TypeDescr<ConstUnsignedEnumerationField> : public UnsignedEnumerationFieldTypeDescr
694 } /* namespace internal */
696 template <typename LibObjT>
697 class CommonSignedEnumerationField final : public CommonSignedIntegerField<LibObjT>
700 using typename CommonSignedIntegerField<LibObjT>::_ThisCommonSignedIntegerField;
703 using typename CommonField<LibObjT>::LibObjPtr;
706 internal::DepType<LibObjT, SignedEnumerationFieldClass, ConstSignedEnumerationFieldClass>;
708 explicit CommonSignedEnumerationField(const LibObjPtr libObjPtr) noexcept :
709 _ThisCommonSignedIntegerField {libObjPtr}
711 BT_ASSERT_DBG(this->isSignedEnumeration());
714 template <typename OtherLibObjT>
715 CommonSignedEnumerationField(const CommonSignedEnumerationField<OtherLibObjT> val) noexcept :
716 _ThisCommonSignedIntegerField {val}
720 template <typename OtherLibObjT>
721 CommonSignedEnumerationField<LibObjT>
722 operator=(const CommonSignedEnumerationField<OtherLibObjT> val) noexcept
724 _ThisCommonSignedIntegerField::operator=(val);
728 CommonSignedEnumerationField<const bt_field> asConst() const noexcept
730 return CommonSignedEnumerationField<const bt_field> {*this};
733 Class cls() const noexcept
735 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
738 EnumerationFieldClassMappingLabels labels() const
740 bt_field_class_enumeration_mapping_label_array labelArray;
743 bt_field_enumeration_signed_get_mapping_labels(this->libObjPtr(), &labelArray, &count);
745 if (status == BT_FIELD_ENUMERATION_GET_MAPPING_LABELS_STATUS_MEMORY_ERROR) {
746 throw MemoryError {};
749 return EnumerationFieldClassMappingLabels {labelArray, count};
753 using SignedEnumerationField = CommonSignedEnumerationField<bt_field>;
754 using ConstSignedEnumerationField = CommonSignedEnumerationField<const bt_field>;
758 struct SignedEnumerationFieldTypeDescr
760 using Const = ConstSignedEnumerationField;
761 using NonConst = SignedEnumerationField;
765 struct TypeDescr<SignedEnumerationField> : public SignedEnumerationFieldTypeDescr
770 struct TypeDescr<ConstSignedEnumerationField> : public SignedEnumerationFieldTypeDescr
774 } /* namespace internal */
776 template <typename LibObjT>
777 class CommonSinglePrecisionRealField final : public CommonField<LibObjT>
780 using typename CommonField<LibObjT>::_ThisCommonField;
783 using typename CommonField<LibObjT>::LibObjPtr;
786 explicit CommonSinglePrecisionRealField(const LibObjPtr libObjPtr) noexcept :
787 _ThisCommonField {libObjPtr}
789 BT_ASSERT_DBG(this->isSinglePrecisionReal());
792 template <typename OtherLibObjT>
793 CommonSinglePrecisionRealField(const CommonSinglePrecisionRealField<OtherLibObjT> val) noexcept
795 _ThisCommonField {val}
799 template <typename OtherLibObjT>
800 CommonSinglePrecisionRealField<LibObjT>
801 operator=(const CommonSinglePrecisionRealField<OtherLibObjT> val) noexcept
803 _ThisCommonField::operator=(val);
807 CommonSinglePrecisionRealField<const bt_field> asConst() const noexcept
809 return CommonSinglePrecisionRealField<const bt_field> {*this};
812 RawValueProxy<CommonSinglePrecisionRealField> operator*() const noexcept
814 return RawValueProxy<CommonSinglePrecisionRealField> {*this};
817 CommonSinglePrecisionRealField value(const Value val) const noexcept
819 static_assert(!std::is_const<LibObjT>::value,
820 "Not available with `bt2::ConstSinglePrecisionRealField`.");
822 bt_field_real_single_precision_set_value(this->libObjPtr(), val);
826 Value value() const noexcept
828 return bt_field_real_single_precision_get_value(this->libObjPtr());
832 using SinglePrecisionRealField = CommonSinglePrecisionRealField<bt_field>;
833 using ConstSinglePrecisionRealField = CommonSinglePrecisionRealField<const bt_field>;
837 struct SinglePrecisionRealFieldTypeDescr
839 using Const = ConstSinglePrecisionRealField;
840 using NonConst = SinglePrecisionRealField;
844 struct TypeDescr<SinglePrecisionRealField> : public SinglePrecisionRealFieldTypeDescr
849 struct TypeDescr<ConstSinglePrecisionRealField> : public SinglePrecisionRealFieldTypeDescr
853 } /* namespace internal */
855 template <typename LibObjT>
856 class CommonDoublePrecisionRealField final : public CommonField<LibObjT>
859 using typename CommonField<LibObjT>::_ThisCommonField;
862 using typename CommonField<LibObjT>::LibObjPtr;
863 using Value = double;
865 explicit CommonDoublePrecisionRealField(const LibObjPtr libObjPtr) noexcept :
866 _ThisCommonField {libObjPtr}
868 BT_ASSERT_DBG(this->isDoublePrecisionReal());
871 template <typename OtherLibObjT>
872 CommonDoublePrecisionRealField(const CommonDoublePrecisionRealField<OtherLibObjT> val) noexcept
874 _ThisCommonField {val}
878 template <typename OtherLibObjT>
879 CommonDoublePrecisionRealField<LibObjT>
880 operator=(const CommonDoublePrecisionRealField<OtherLibObjT> val) noexcept
882 _ThisCommonField::operator=(val);
886 CommonDoublePrecisionRealField<const bt_field> asConst() const noexcept
888 return CommonDoublePrecisionRealField<const bt_field> {*this};
891 RawValueProxy<CommonDoublePrecisionRealField> operator*() const noexcept
893 return RawValueProxy<CommonDoublePrecisionRealField> {*this};
896 CommonDoublePrecisionRealField value(const Value val) const noexcept
898 static_assert(!std::is_const<LibObjT>::value,
899 "Not available with `bt2::ConstDoublePrecisionRealField`.");
901 bt_field_real_double_precision_set_value(this->libObjPtr(), val);
905 Value value() const noexcept
907 return bt_field_real_double_precision_get_value(this->libObjPtr());
911 using DoublePrecisionRealField = CommonDoublePrecisionRealField<bt_field>;
912 using ConstDoublePrecisionRealField = CommonDoublePrecisionRealField<const bt_field>;
916 struct DoublePrecisionRealFieldTypeDescr
918 using Const = ConstDoublePrecisionRealField;
919 using NonConst = DoublePrecisionRealField;
923 struct TypeDescr<DoublePrecisionRealField> : public DoublePrecisionRealFieldTypeDescr
928 struct TypeDescr<ConstDoublePrecisionRealField> : public DoublePrecisionRealFieldTypeDescr
932 } /* namespace internal */
934 template <typename LibObjT>
935 class CommonStringField final : public CommonField<LibObjT>
938 using typename CommonField<LibObjT>::_ThisCommonField;
941 using typename CommonField<LibObjT>::LibObjPtr;
942 using Value = bt2c::CStringView;
944 explicit CommonStringField(const LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
946 BT_ASSERT_DBG(this->isString());
949 template <typename OtherLibObjT>
950 CommonStringField(const CommonStringField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
954 template <typename OtherLibObjT>
955 CommonStringField<LibObjT> operator=(const CommonStringField<OtherLibObjT> val) noexcept
957 _ThisCommonField::operator=(val);
961 CommonStringField<const bt_field> asConst() const noexcept
963 return CommonStringField<const bt_field> {*this};
966 RawValueProxy<CommonStringField> operator*() const noexcept
968 return RawValueProxy<CommonStringField> {*this};
971 CommonStringField value(const Value 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 append(const bt2c::CStringView begin, const std::uint64_t len) const
987 static_assert(!std::is_const<LibObjT>::value,
988 "Not available with `bt2::ConstStringField`.");
990 const auto status = bt_field_string_append_with_length(this->libObjPtr(), begin, len);
992 if (status == BT_FIELD_STRING_APPEND_STATUS_MEMORY_ERROR) {
993 throw MemoryError {};
999 CommonStringField append(const bt2c::CStringView val) const
1001 return this->append(val, std::strlen(val));
1004 CommonStringField append(const std::string& val) const
1006 return this->append(val.data(), val.size());
1009 CommonStringField clear() const noexcept
1011 static_assert(!std::is_const<LibObjT>::value,
1012 "Not available with `bt2::ConstStringField`.");
1014 bt_field_string_clear(this->libObjPtr());
1018 Value value() const noexcept
1020 return bt_field_string_get_value(this->libObjPtr());
1023 std::uint64_t length() const noexcept
1025 return bt_field_string_get_length(this->libObjPtr());
1029 using StringField = CommonStringField<bt_field>;
1030 using ConstStringField = CommonStringField<const bt_field>;
1032 namespace internal {
1034 struct StringFieldTypeDescr
1036 using Const = ConstStringField;
1037 using NonConst = StringField;
1041 struct TypeDescr<StringField> : public StringFieldTypeDescr
1046 struct TypeDescr<ConstStringField> : public StringFieldTypeDescr
1050 template <typename LibObjT>
1051 struct CommonStructureFieldSpec;
1053 /* Functions specific to mutable structure fields */
1055 struct CommonStructureFieldSpec<bt_field> final
1057 static bt_field *memberFieldByIndex(bt_field * const libObjPtr,
1058 const std::uint64_t index) noexcept
1060 return bt_field_structure_borrow_member_field_by_index(libObjPtr, index);
1063 static bt_field *memberFieldByName(bt_field * const libObjPtr, const char * const name) noexcept
1065 return bt_field_structure_borrow_member_field_by_name(libObjPtr, name);
1069 /* Functions specific to constant structure fields */
1071 struct CommonStructureFieldSpec<const bt_field> final
1073 static const bt_field *memberFieldByIndex(const bt_field * const libObjPtr,
1074 const std::uint64_t index) noexcept
1076 return bt_field_structure_borrow_member_field_by_index_const(libObjPtr, index);
1079 static const bt_field *memberFieldByName(const bt_field * const libObjPtr,
1080 const char * const name) noexcept
1082 return bt_field_structure_borrow_member_field_by_name_const(libObjPtr, name);
1086 } /* namespace internal */
1088 template <typename LibObjT>
1089 class CommonStructureField final : public CommonField<LibObjT>
1092 using typename CommonField<LibObjT>::_ThisCommonField;
1093 using _Spec = internal::CommonStructureFieldSpec<LibObjT>;
1096 using typename CommonField<LibObjT>::LibObjPtr;
1097 using Class = internal::DepType<LibObjT, StructureFieldClass, ConstStructureFieldClass>;
1099 explicit CommonStructureField(const LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
1101 BT_ASSERT_DBG(this->isStructure());
1104 template <typename OtherLibObjT>
1105 CommonStructureField(const CommonStructureField<OtherLibObjT> val) noexcept :
1106 _ThisCommonField {val}
1110 template <typename OtherLibObjT>
1111 CommonStructureField<LibObjT> operator=(const CommonStructureField<OtherLibObjT> val) noexcept
1113 _ThisCommonField::operator=(val);
1117 CommonStructureField<const bt_field> asConst() const noexcept
1119 return CommonStructureField<const bt_field> {*this};
1122 Class cls() const noexcept
1124 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
1127 std::uint64_t length() const noexcept
1129 return this->cls().length();
1132 CommonField<LibObjT> operator[](const std::uint64_t index) const noexcept
1134 return CommonField<LibObjT> {_Spec::memberFieldByIndex(this->libObjPtr(), index)};
1137 OptionalBorrowedObject<CommonField<LibObjT>>
1138 operator[](const bt2c::CStringView name) const noexcept
1140 return _Spec::memberFieldByName(this->libObjPtr(), name);
1144 using StructureField = CommonStructureField<bt_field>;
1145 using ConstStructureField = CommonStructureField<const bt_field>;
1147 namespace internal {
1149 struct StructureFieldTypeDescr
1151 using Const = ConstStructureField;
1152 using NonConst = StructureField;
1156 struct TypeDescr<StructureField> : public StructureFieldTypeDescr
1161 struct TypeDescr<ConstStructureField> : public StructureFieldTypeDescr
1165 template <typename LibObjT>
1166 struct CommonArrayFieldSpec;
1168 /* Functions specific to mutable array fields */
1170 struct CommonArrayFieldSpec<bt_field> final
1172 static bt_field *elementFieldByIndex(bt_field * const libObjPtr,
1173 const std::uint64_t index) noexcept
1175 return bt_field_array_borrow_element_field_by_index(libObjPtr, index);
1179 /* Functions specific to constant array fields */
1181 struct CommonArrayFieldSpec<const bt_field> final
1183 static const bt_field *elementFieldByIndex(const bt_field * const libObjPtr,
1184 const std::uint64_t index) noexcept
1186 return bt_field_array_borrow_element_field_by_index_const(libObjPtr, index);
1190 } /* namespace internal */
1192 template <typename LibObjT>
1193 class CommonArrayField : public CommonField<LibObjT>
1196 using typename CommonField<LibObjT>::_ThisCommonField;
1197 using _Spec = internal::CommonArrayFieldSpec<LibObjT>;
1200 using _ThisCommonArrayField = CommonArrayField<LibObjT>;
1203 using typename CommonField<LibObjT>::LibObjPtr;
1204 using Class = internal::DepType<LibObjT, ArrayFieldClass, ConstArrayFieldClass>;
1206 explicit CommonArrayField(const LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
1208 BT_ASSERT_DBG(this->isArray());
1211 template <typename OtherLibObjT>
1212 CommonArrayField(const CommonArrayField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
1216 template <typename OtherLibObjT>
1217 _ThisCommonArrayField operator=(const CommonArrayField<OtherLibObjT> val) noexcept
1219 _ThisCommonField::operator=(val);
1223 CommonArrayField<const bt_field> asConst() const noexcept
1225 return CommonArrayField<const bt_field> {*this};
1228 Class cls() const noexcept
1230 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
1233 std::uint64_t length() const noexcept
1235 return bt_field_array_get_length(this->libObjPtr());
1238 CommonField<LibObjT> operator[](const std::uint64_t index) const noexcept
1240 return CommonField<LibObjT> {_Spec::elementFieldByIndex(this->libObjPtr(), index)};
1244 using ArrayField = CommonArrayField<bt_field>;
1245 using ConstArrayField = CommonArrayField<const bt_field>;
1247 namespace internal {
1249 struct ArrayFieldTypeDescr
1251 using Const = ConstArrayField;
1252 using NonConst = ArrayField;
1256 struct TypeDescr<ArrayField> : public ArrayFieldTypeDescr
1261 struct TypeDescr<ConstArrayField> : public ArrayFieldTypeDescr
1265 } /* namespace internal */
1267 template <typename LibObjT>
1268 class CommonDynamicArrayField : public CommonArrayField<LibObjT>
1271 using typename CommonArrayField<LibObjT>::_ThisCommonArrayField;
1274 using typename CommonField<LibObjT>::LibObjPtr;
1276 explicit CommonDynamicArrayField(const LibObjPtr libObjPtr) noexcept :
1277 _ThisCommonArrayField {libObjPtr}
1279 BT_ASSERT_DBG(this->isDynamicArray());
1282 template <typename OtherLibObjT>
1283 CommonDynamicArrayField(const CommonDynamicArrayField<OtherLibObjT> val) noexcept :
1284 _ThisCommonArrayField {val}
1288 template <typename OtherLibObjT>
1289 CommonDynamicArrayField<LibObjT>
1290 operator=(const CommonDynamicArrayField<OtherLibObjT> val) noexcept
1292 _ThisCommonArrayField::operator=(val);
1296 CommonDynamicArrayField<const bt_field> asConst() const noexcept
1298 return CommonDynamicArrayField<const bt_field> {*this};
1301 std::uint64_t length() const noexcept
1303 return _ThisCommonArrayField::length();
1306 CommonDynamicArrayField length(const std::uint64_t length) const
1308 static_assert(!std::is_const<LibObjT>::value,
1309 "Not available with `bt2::ConstDynamicArrayField`.");
1311 const auto status = bt_field_array_dynamic_set_length(this->libObjPtr(), length);
1313 if (status == BT_FIELD_DYNAMIC_ARRAY_SET_LENGTH_STATUS_MEMORY_ERROR) {
1314 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>::_ThisCommonField;
1372 using _Spec = internal::CommonOptionFieldSpec<LibObjT>;
1375 using typename CommonField<LibObjT>::LibObjPtr;
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 CommonOptionField 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));
1414 bool hasField() const noexcept
1416 return this->field();
1419 OptionalBorrowedObject<CommonField<LibObjT>> field() const noexcept
1421 return _Spec::field(this->libObjPtr());
1425 using OptionField = CommonOptionField<bt_field>;
1426 using ConstOptionField = CommonOptionField<const bt_field>;
1428 namespace internal {
1430 struct OptionFieldTypeDescr
1432 using Const = ConstOptionField;
1433 using NonConst = OptionField;
1437 struct TypeDescr<OptionField> : public OptionFieldTypeDescr
1442 struct TypeDescr<ConstOptionField> : public OptionFieldTypeDescr
1446 template <typename LibObjT>
1447 struct CommonVariantFieldSpec;
1449 /* Functions specific to mutable variant fields */
1451 struct CommonVariantFieldSpec<bt_field> final
1453 static bt_field *selectedOptionField(bt_field * const libObjPtr) noexcept
1455 return bt_field_variant_borrow_selected_option_field(libObjPtr);
1459 /* Functions specific to constant variant fields */
1461 struct CommonVariantFieldSpec<const bt_field> final
1463 static const bt_field *selectedOptionField(const bt_field * const libObjPtr) noexcept
1465 return bt_field_variant_borrow_selected_option_field_const(libObjPtr);
1469 } /* namespace internal */
1471 template <typename LibObjT>
1472 class CommonVariantField : public CommonField<LibObjT>
1475 using typename CommonField<LibObjT>::_ThisCommonField;
1476 using _Spec = internal::CommonVariantFieldSpec<LibObjT>;
1479 using typename CommonField<LibObjT>::LibObjPtr;
1480 using Class = internal::DepType<LibObjT, VariantFieldClass, ConstVariantFieldClass>;
1482 explicit CommonVariantField(const LibObjPtr libObjPtr) noexcept : _ThisCommonField {libObjPtr}
1484 BT_ASSERT_DBG(this->isVariant());
1487 template <typename OtherLibObjT>
1488 CommonVariantField(const CommonVariantField<OtherLibObjT> val) noexcept : _ThisCommonField {val}
1492 template <typename OtherLibObjT>
1493 CommonVariantField<LibObjT> operator=(const CommonVariantField<OtherLibObjT> val) noexcept
1495 _ThisCommonField::operator=(val);
1499 CommonVariantField<const bt_field> asConst() const noexcept
1501 return CommonVariantField<const bt_field> {*this};
1504 Class cls() const noexcept
1506 return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
1509 CommonVariantField selectOption(const std::uint64_t index) const noexcept
1511 static_assert(!std::is_const<LibObjT>::value,
1512 "Not available with `bt2::ConstVariantField`.");
1514 const auto status = bt_field_variant_select_option_by_index(this->libObjPtr(), index);
1516 BT_ASSERT_DBG(status == BT_FIELD_VARIANT_SELECT_OPTION_STATUS_OK);
1520 CommonField<LibObjT> selectedOptionField() const noexcept
1522 return CommonField<LibObjT> {_Spec::selectedOptionField(this->libObjPtr())};
1525 std::uint64_t selectedOptionIndex() const noexcept
1527 return bt_field_variant_get_selected_option_index(this->libObjPtr());
1531 using VariantField = CommonVariantField<bt_field>;
1532 using ConstVariantField = CommonVariantField<const bt_field>;
1534 namespace internal {
1536 struct VariantFieldTypeDescr
1538 using Const = ConstVariantField;
1539 using NonConst = VariantField;
1543 struct TypeDescr<VariantField> : public VariantFieldTypeDescr
1548 struct TypeDescr<ConstVariantField> : public VariantFieldTypeDescr
1552 } /* namespace internal */
1554 template <typename LibObjT>
1555 CommonBoolField<LibObjT> CommonField<LibObjT>::asBool() const noexcept
1557 return CommonBoolField<LibObjT> {this->libObjPtr()};
1560 template <typename LibObjT>
1561 CommonBitArrayField<LibObjT> CommonField<LibObjT>::asBitArray() const noexcept
1563 return CommonBitArrayField<LibObjT> {this->libObjPtr()};
1566 template <typename LibObjT>
1567 CommonUnsignedIntegerField<LibObjT> CommonField<LibObjT>::asUnsignedInteger() const noexcept
1569 return CommonUnsignedIntegerField<LibObjT> {this->libObjPtr()};
1572 template <typename LibObjT>
1573 CommonSignedIntegerField<LibObjT> CommonField<LibObjT>::asSignedInteger() const noexcept
1575 return CommonSignedIntegerField<LibObjT> {this->libObjPtr()};
1578 template <typename LibObjT>
1579 CommonUnsignedEnumerationField<LibObjT> CommonField<LibObjT>::asUnsignedEnumeration() const noexcept
1581 return CommonUnsignedEnumerationField<LibObjT> {this->libObjPtr()};
1584 template <typename LibObjT>
1585 CommonSignedEnumerationField<LibObjT> CommonField<LibObjT>::asSignedEnumeration() const noexcept
1587 return CommonSignedEnumerationField<LibObjT> {this->libObjPtr()};
1590 template <typename LibObjT>
1591 CommonSinglePrecisionRealField<LibObjT> CommonField<LibObjT>::asSinglePrecisionReal() const noexcept
1593 return CommonSinglePrecisionRealField<LibObjT> {this->libObjPtr()};
1596 template <typename LibObjT>
1597 CommonDoublePrecisionRealField<LibObjT> CommonField<LibObjT>::asDoublePrecisionReal() const noexcept
1599 return CommonDoublePrecisionRealField<LibObjT> {this->libObjPtr()};
1602 template <typename LibObjT>
1603 CommonStringField<LibObjT> CommonField<LibObjT>::asString() const noexcept
1605 return CommonStringField<LibObjT> {this->libObjPtr()};
1608 template <typename LibObjT>
1609 CommonStructureField<LibObjT> CommonField<LibObjT>::asStructure() const noexcept
1611 return CommonStructureField<LibObjT> {this->libObjPtr()};
1614 template <typename LibObjT>
1615 CommonArrayField<LibObjT> CommonField<LibObjT>::asArray() const noexcept
1617 return CommonArrayField<LibObjT> {this->libObjPtr()};
1620 template <typename LibObjT>
1621 CommonDynamicArrayField<LibObjT> CommonField<LibObjT>::asDynamicArray() const noexcept
1623 return CommonDynamicArrayField<LibObjT> {this->libObjPtr()};
1626 template <typename LibObjT>
1627 CommonOptionField<LibObjT> CommonField<LibObjT>::asOption() const noexcept
1629 return CommonOptionField<LibObjT> {this->libObjPtr()};
1632 template <typename LibObjT>
1633 CommonVariantField<LibObjT> CommonField<LibObjT>::asVariant() const noexcept
1635 return CommonVariantField<LibObjT> {this->libObjPtr()};
1638 } /* namespace bt2 */
1640 #endif /* BABELTRACE_CPP_COMMON_BT2_FIELD_HPP */