#include <babeltrace2/babeltrace.h>
#include "common/assert.h"
-#include "cpp-common/optional.hpp"
-#include "cpp-common/string_view.hpp"
+#include "cpp-common/bt2s/optional.hpp"
+#include "borrowed-object-iterator.hpp"
#include "borrowed-object.hpp"
-#include "common-iter.hpp"
#include "exc.hpp"
#include "field-path.hpp"
#include "integer-range-set.hpp"
#include "internal/utils.hpp"
-#include "shared-obj.hpp"
+#include "shared-object.hpp"
#include "value.hpp"
namespace bt2 {
struct FieldClassRefFuncs final
{
- static void get(const bt_field_class * const libObjPtr)
+ static void get(const bt_field_class * const libObjPtr) noexcept
{
bt_field_class_get_ref(libObjPtr);
}
- static void put(const bt_field_class * const libObjPtr)
+ static void put(const bt_field_class * const libObjPtr) noexcept
{
bt_field_class_put_ref(libObjPtr);
}
} /* namespace internal */
template <typename ObjT, typename LibObjT>
-using SharedFieldClass = SharedObj<ObjT, LibObjT, internal::FieldClassRefFuncs>;
+using SharedFieldClass = SharedObject<ObjT, LibObjT, internal::FieldClassRefFuncs>;
template <typename LibObjT>
class CommonBitArrayFieldClass;
template <typename LibObjT>
class CommonFieldClass : public BorrowedObject<LibObjT>
{
- /* Allow appendMember() to call `fc.libObjPtr()` */
- friend class CommonStructureFieldClass<bt_field_class>;
-
- /* Allow appendOption() to call `fc.libObjPtr()` */
- friend class CommonVariantWithoutSelectorFieldClass<bt_field_class>;
-
- friend class CommonVariantWithIntegerSelectorFieldClass<
- bt_field_class,
- ConstVariantWithIntegerSelectorFieldClassOption<
- const bt_field_class_variant_with_selector_field_integer_unsigned_option>>;
-
- friend class CommonVariantWithIntegerSelectorFieldClass<
- bt_field_class,
- ConstVariantWithIntegerSelectorFieldClassOption<
- const bt_field_class_variant_with_selector_field_integer_signed_option>>;
-
- /* Allow *FieldClass() to call `fc.libObjPtr()` */
- friend class CommonEventClass<bt_event_class>;
- friend class CommonStreamClass<bt_stream_class>;
-
- /* Allow create*FieldClass() to call `fc.libObjPtr()` */
- friend class CommonTraceClass<bt_trace_class>;
-
private:
using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
public:
using Shared = SharedFieldClass<CommonFieldClass<LibObjT>, LibObjT>;
-
- using UserAttributes =
- typename std::conditional<std::is_const<LibObjT>::value, ConstMapValue, MapValue>::type;
+ using UserAttributes = internal::DepUserAttrs<LibObjT>;
explicit CommonFieldClass(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
{
}
template <typename OtherLibObjT>
- CommonFieldClass& operator=(const CommonFieldClass<OtherLibObjT> fc) noexcept
+ CommonFieldClass operator=(const CommonFieldClass<OtherLibObjT> fc) noexcept
{
_ThisBorrowedObject::operator=(fc);
return *this;
}
+ CommonFieldClass<const bt_field_class> asConst() const noexcept
+ {
+ return CommonFieldClass<const bt_field_class> {*this};
+ }
+
FieldClassType type() const noexcept
{
return static_cast<FieldClassType>(bt_field_class_get_type(this->libObjPtr()));
asVariantWithSignedIntegerSelector() const noexcept;
template <typename LibValT>
- void userAttributes(const CommonMapValue<LibValT> userAttrs)
+ void userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value, "Not available with `bt2::ConstFieldClass`.");
bt_field_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
}
- ConstMapValue userAttributes() const noexcept
- {
- return ConstMapValue {internal::CommonFieldClassSpec<const bt_field_class>::userAttributes(
- this->libObjPtr())};
- }
-
- UserAttributes userAttributes() noexcept
+ UserAttributes userAttributes() const noexcept
{
return UserAttributes {
internal::CommonFieldClassSpec<LibObjT>::userAttributes(this->libObjPtr())};
}
template <typename OtherLibObjT>
- CommonBitArrayFieldClass<LibObjT>&
+ CommonBitArrayFieldClass<LibObjT>
operator=(const CommonBitArrayFieldClass<OtherLibObjT> fc) noexcept
{
_ThisCommonFieldClass::operator=(fc);
return *this;
}
+ CommonBitArrayFieldClass<const bt_field_class> asConst() const noexcept
+ {
+ return CommonBitArrayFieldClass<const bt_field_class> {*this};
+ }
+
std::uint64_t length() const noexcept
{
return bt_field_class_bit_array_get_length(this->libObjPtr());
}
template <typename OtherLibObjT>
- CommonIntegerFieldClass& operator=(const CommonIntegerFieldClass<OtherLibObjT> fc) noexcept
+ CommonIntegerFieldClass operator=(const CommonIntegerFieldClass<OtherLibObjT> fc) noexcept
{
_ThisCommonFieldClass::operator=(fc);
return *this;
}
- void fieldValueRange(const std::uint64_t n) noexcept
+ CommonIntegerFieldClass<const bt_field_class> asConst() const noexcept
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ return CommonIntegerFieldClass<const bt_field_class> {*this};
+ }
+
+ void fieldValueRange(const std::uint64_t n) const noexcept
+ {
+ static_assert(!std::is_const<LibObjT>::value,
+ "Not available with `bt2::ConstIntegerFieldClass`.");
bt_field_class_integer_set_field_value_range(this->libObjPtr(), n);
}
return bt_field_class_integer_get_field_value_range(this->libObjPtr());
}
- void preferredDisplayBase(const DisplayBase base) noexcept
+ void preferredDisplayBase(const DisplayBase base) const noexcept
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value,
+ "Not available with `bt2::ConstIntegerFieldClass`.");
bt_field_class_integer_set_preferred_display_base(
this->libObjPtr(), static_cast<bt_field_class_integer_preferred_display_base>(base));
{
};
-} /* namespace internal */
-
-namespace internal {
-
template <typename LibObjT>
struct ConstEnumerationFieldClassMappingSpec;
{
}
- ConstEnumerationFieldClassMapping&
+ ConstEnumerationFieldClassMapping
operator=(const ConstEnumerationFieldClassMapping& mapping) noexcept
{
_ThisBorrowedObject::operator=(mapping);
internal::ConstEnumerationFieldClassMappingSpec<LibObjT>::ranges(this->libObjPtr())};
}
- bpstd::string_view label() const noexcept
+ const char *label() const noexcept
{
return internal::ConstEnumerationFieldClassMappingSpec<LibObjT>::label(this->libObjPtr());
}
}
template <typename OtherLibObjT>
- CommonBaseEnumerationFieldClass&
+ CommonBaseEnumerationFieldClass
operator=(const CommonBaseEnumerationFieldClass<OtherLibObjT> fc) noexcept
{
_ThisCommonIntegerFieldClass::operator=(fc);
return *this;
}
- std::uint64_t size() const noexcept
+ CommonBaseEnumerationFieldClass<const bt_field_class> asConst() const noexcept
+ {
+ return CommonBaseEnumerationFieldClass<const bt_field_class> {*this};
+ }
+
+ std::uint64_t length() const noexcept
{
return bt_field_class_enumeration_get_mapping_count(this->libObjPtr());
}
private:
using typename CommonFieldClass<LibObjT>::_LibObjPtr;
using typename CommonBaseEnumerationFieldClass<LibObjT>::_ThisCommonBaseEnumerationFieldClass;
- using _ThisCommonEnumerationFieldClass = CommonEnumerationFieldClass<LibObjT, MappingT>;
public:
- using Shared = SharedFieldClass<_ThisCommonEnumerationFieldClass, LibObjT>;
- using Iterator = CommonIterator<CommonEnumerationFieldClass, MappingT>;
+ using Shared = SharedFieldClass<CommonEnumerationFieldClass, LibObjT>;
+ using Iterator = BorrowedObjectIterator<CommonEnumerationFieldClass>;
using Mapping = MappingT;
explicit CommonEnumerationFieldClass(const _LibObjPtr libObjPtr) noexcept :
template <typename OtherLibObjT>
CommonEnumerationFieldClass(
const CommonEnumerationFieldClass<OtherLibObjT, MappingT> fc) noexcept :
- _ThisCommonEnumerationFieldClass {fc}
+ CommonEnumerationFieldClass {fc}
{
}
template <typename OtherLibObjT>
- CommonEnumerationFieldClass&
+ CommonEnumerationFieldClass
operator=(const CommonEnumerationFieldClass<OtherLibObjT, MappingT> fc) noexcept
{
- _ThisCommonEnumerationFieldClass::operator=(fc);
+ CommonEnumerationFieldClass::operator=(fc);
return *this;
}
this->libObjPtr(), index)};
}
- nonstd::optional<Mapping> operator[](const char * const label) const noexcept
+ bt2s::optional<Mapping> operator[](const char * const label) const noexcept
{
const auto libObjPtr = internal::CommonEnumerationFieldClassSpec<MappingT>::mappingByLabel(
this->libObjPtr(), label);
return Mapping {libObjPtr};
}
- return nonstd::nullopt;
+ return bt2s::nullopt;
}
- nonstd::optional<Mapping> operator[](const std::string& label) const noexcept
+ bt2s::optional<Mapping> operator[](const std::string& label) const noexcept
{
return (*this)[label.data()];
}
- void addMapping(const char * const label, const typename Mapping::RangeSet ranges)
+ void addMapping(const char * const label, const typename Mapping::RangeSet ranges) const
{
const auto status = internal::CommonEnumerationFieldClassSpec<MappingT>::addMapping(
this->libObjPtr(), label, ranges.libObjPtr());
}
}
- void addMapping(const std::string& label, const typename Mapping::RangeSet ranges)
+ void addMapping(const std::string& label, const typename Mapping::RangeSet ranges) const
{
this->addMapping(label.data(), ranges);
}
Iterator end() const noexcept
{
- return Iterator {*this, this->size()};
+ return Iterator {*this, this->length()};
}
Shared shared() const noexcept
private:
using typename BorrowedObject<LibObjT>::_LibObjPtr;
using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
-
- using _FieldClass =
- typename std::conditional<std::is_const<LibObjT>::value, ConstFieldClass, FieldClass>::type;
+ using _FieldClass = internal::DepFc<LibObjT>;
public:
- using UserAttributes =
- typename std::conditional<std::is_const<LibObjT>::value, ConstMapValue, MapValue>::type;
+ using UserAttributes = internal::DepUserAttrs<LibObjT>;
explicit CommonStructureFieldClassMember(const _LibObjPtr libObjPtr) noexcept :
_ThisBorrowedObject {libObjPtr}
}
template <typename OtherLibObjT>
- CommonStructureFieldClassMember<LibObjT>&
+ CommonStructureFieldClassMember<LibObjT>
operator=(const CommonStructureFieldClassMember<OtherLibObjT> fc) noexcept
{
_ThisBorrowedObject::operator=(fc);
return *this;
}
- bpstd::string_view name() const noexcept
+ CommonStructureFieldClassMember<const bt_field_class_structure_member> asConst() const noexcept
{
- return bt_field_class_structure_member_get_name(this->libObjPtr());
+ return CommonStructureFieldClassMember<const bt_field_class_structure_member> {*this};
}
- ConstFieldClass fieldClass() const noexcept
+ const char *name() const noexcept
{
- return ConstFieldClass {internal::CommonStructureFieldClassMemberSpec<
- const bt_field_class_structure_member>::fieldClass(this->libObjPtr())};
+ return bt_field_class_structure_member_get_name(this->libObjPtr());
}
- _FieldClass fieldClass() noexcept
+ _FieldClass fieldClass() const noexcept
{
return _FieldClass {
internal::CommonStructureFieldClassMemberSpec<LibObjT>::fieldClass(this->libObjPtr())};
}
template <typename LibValT>
- void userAttributes(const CommonMapValue<LibValT> userAttrs)
+ void userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value,
+ "Not available with `bt2::ConstStructureFieldClassMember`.");
bt_field_class_structure_member_set_user_attributes(this->libObjPtr(),
userAttrs.libObjPtr());
}
- ConstMapValue userAttributes() const noexcept
- {
- return ConstMapValue {internal::CommonStructureFieldClassMemberSpec<
- const bt_field_class_structure_member>::userAttributes(this->libObjPtr())};
- }
-
- UserAttributes userAttributes() noexcept
+ UserAttributes userAttributes() const noexcept
{
return UserAttributes {
internal::CommonStructureFieldClassMemberSpec<LibObjT>::userAttributes(
public:
using Shared = SharedFieldClass<CommonStructureFieldClass<LibObjT>, LibObjT>;
- using Member =
- typename std::conditional<std::is_const<LibObjT>::value, ConstStructureFieldClassMember,
- StructureFieldClassMember>::type;
+ using Iterator = BorrowedObjectIterator<CommonStructureFieldClass<LibObjT>>;
- using Iterator = CommonIterator<CommonStructureFieldClass<LibObjT>, Member>;
+ using Member =
+ internal::DepType<LibObjT, StructureFieldClassMember, ConstStructureFieldClassMember>;
explicit CommonStructureFieldClass(const _LibObjPtr libObjPtr) noexcept :
_ThisCommonFieldClass {libObjPtr}
}
template <typename OtherLibObjT>
- CommonStructureFieldClass& operator=(const CommonStructureFieldClass<OtherLibObjT> fc) noexcept
+ CommonStructureFieldClass operator=(const CommonStructureFieldClass<OtherLibObjT> fc) noexcept
{
_ThisCommonFieldClass::operator=(fc);
return *this;
}
- void appendMember(const char * const name, const FieldClass fc)
+ CommonStructureFieldClass<const bt_field_class> asConst() const noexcept
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ return CommonStructureFieldClass<const bt_field_class> {*this};
+ }
+
+ void appendMember(const char * const name, const FieldClass fc) const
+ {
+ static_assert(!std::is_const<LibObjT>::value,
+ "Not available with `bt2::ConstStructureFieldClass`.");
const auto status =
bt_field_class_structure_append_member(this->libObjPtr(), name, fc.libObjPtr());
}
}
- void appendMember(const std::string& name, const FieldClass fc)
+ void appendMember(const std::string& name, const FieldClass fc) const
{
this->appendMember(name.data(), fc);
}
- std::uint64_t size() const noexcept
+ std::uint64_t length() const noexcept
{
return bt_field_class_structure_get_member_count(this->libObjPtr());
}
Iterator end() const noexcept
{
- return Iterator {*this, this->size()};
- }
-
- ConstStructureFieldClassMember operator[](const std::uint64_t index) const noexcept
- {
- return ConstStructureFieldClassMember {
- internal::CommonStructureFieldClassSpec<const bt_field_class>::memberByIndex(
- this->libObjPtr(), index)};
+ return Iterator {*this, this->length()};
}
- Member operator[](const std::uint64_t index) noexcept
+ Member operator[](const std::uint64_t index) const noexcept
{
return Member {internal::CommonStructureFieldClassSpec<LibObjT>::memberByIndex(
this->libObjPtr(), index)};
}
- nonstd::optional<ConstStructureFieldClassMember>
- operator[](const char * const name) const noexcept
- {
- const auto libObjPtr =
- internal::CommonStructureFieldClassSpec<const bt_field_class>::memberByName(
- this->libObjPtr(), name);
-
- if (libObjPtr) {
- return ConstStructureFieldClassMember {libObjPtr};
- }
-
- return nonstd::nullopt;
- }
-
- nonstd::optional<ConstStructureFieldClassMember>
- operator[](const std::string& name) const noexcept
- {
- return (*this)[name.data()];
- }
-
- nonstd::optional<Member> operator[](const char * const name) noexcept
+ bt2s::optional<Member> operator[](const char * const name) const noexcept
{
const auto libObjPtr =
internal::CommonStructureFieldClassSpec<LibObjT>::memberByName(this->libObjPtr(), name);
return Member {libObjPtr};
}
- return nonstd::nullopt;
+ return bt2s::nullopt;
}
- nonstd::optional<Member> operator[](const std::string& name) noexcept
+ bt2s::optional<Member> operator[](const std::string& name) const noexcept
{
return (*this)[name.data()];
}
{
private:
using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
-
- using _FieldClass =
- typename std::conditional<std::is_const<LibObjT>::value, ConstFieldClass, FieldClass>::type;
+ using _FieldClass = internal::DepFc<LibObjT>;
protected:
using typename CommonFieldClass<LibObjT>::_LibObjPtr;
}
template <typename OtherLibObjT>
- CommonArrayFieldClass& operator=(const CommonArrayFieldClass<OtherLibObjT> fc) noexcept
+ CommonArrayFieldClass operator=(const CommonArrayFieldClass<OtherLibObjT> fc) noexcept
{
_ThisCommonFieldClass::operator=(fc);
return *this;
}
- ConstFieldClass elementFieldClass() const noexcept
+ CommonArrayFieldClass<const bt_field_class> asConst() const noexcept
{
- return ConstFieldClass {
- internal::CommonArrayFieldClassSpec<const bt_field_class>::elementFieldClass(
- this->libObjPtr())};
+ return CommonArrayFieldClass<const bt_field_class> {*this};
}
- _FieldClass elementFieldClass() noexcept
+ _FieldClass elementFieldClass() const noexcept
{
return _FieldClass {
internal::CommonArrayFieldClassSpec<LibObjT>::elementFieldClass(this->libObjPtr())};
}
template <typename OtherLibObjT>
- CommonStaticArrayFieldClass&
+ CommonStaticArrayFieldClass
operator=(const CommonStaticArrayFieldClass<OtherLibObjT> fc) noexcept
{
_ThisCommonArrayFieldClass::operator=(fc);
return *this;
}
+ CommonStaticArrayFieldClass<const bt_field_class> asConst() const noexcept
+ {
+ return CommonStaticArrayFieldClass<const bt_field_class> {*this};
+ }
+
std::uint64_t length() const noexcept
{
return bt_field_class_array_static_get_length(this->libObjPtr());
}
template <typename OtherLibObjT>
- CommonDynamicArrayWithLengthFieldClass&
+ CommonDynamicArrayWithLengthFieldClass
operator=(const CommonDynamicArrayWithLengthFieldClass<OtherLibObjT> fc) noexcept
{
_ThisCommonArrayFieldClass::operator=(fc);
return *this;
}
+ CommonDynamicArrayWithLengthFieldClass<const bt_field_class> asConst() const noexcept
+ {
+ return CommonDynamicArrayWithLengthFieldClass<const bt_field_class> {*this};
+ }
+
ConstFieldPath lengthFieldPath() const noexcept
{
return ConstFieldPath {
{
private:
using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
-
- using _FieldClass =
- typename std::conditional<std::is_const<LibObjT>::value, ConstFieldClass, FieldClass>::type;
+ using _FieldClass = internal::DepFc<LibObjT>;
protected:
using typename CommonFieldClass<LibObjT>::_LibObjPtr;
}
template <typename OtherLibObjT>
- CommonOptionFieldClass& operator=(const CommonOptionFieldClass<OtherLibObjT> fc) noexcept
+ CommonOptionFieldClass operator=(const CommonOptionFieldClass<OtherLibObjT> fc) noexcept
{
_ThisCommonFieldClass::operator=(fc);
return *this;
}
- ConstFieldClass fieldClass() const noexcept
+ CommonOptionFieldClass<const bt_field_class> asConst() const noexcept
{
- return ConstFieldClass {
- internal::CommonOptionFieldClassSpec<const bt_field_class>::fieldClass(
- this->libObjPtr())};
+ return CommonOptionFieldClass<const bt_field_class> {*this};
}
- _FieldClass fieldClass() noexcept
+ _FieldClass fieldClass() const noexcept
{
return _FieldClass {
internal::CommonOptionFieldClassSpec<LibObjT>::fieldClass(this->libObjPtr())};
}
template <typename OtherLibObjT>
- CommonOptionWithSelectorFieldClass&
+ CommonOptionWithSelectorFieldClass
operator=(const CommonOptionWithSelectorFieldClass<OtherLibObjT> fc) noexcept
{
_ThisCommonOptionFieldClass::operator=(fc);
return *this;
}
+ CommonOptionWithSelectorFieldClass<const bt_field_class> asConst() const noexcept
+ {
+ return CommonOptionWithSelectorFieldClass<const bt_field_class> {*this};
+ }
+
ConstFieldPath selectorFieldPath() const noexcept
{
return ConstFieldPath {
}
template <typename OtherLibObjT>
- CommonOptionWithBoolSelectorFieldClass&
+ CommonOptionWithBoolSelectorFieldClass
operator=(const CommonOptionWithBoolSelectorFieldClass<OtherLibObjT> fc) noexcept
{
_ThisCommonOptionWithSelectorFieldClass::operator=(fc);
return *this;
}
+ CommonOptionWithBoolSelectorFieldClass<const bt_field_class> asConst() const noexcept
+ {
+ return CommonOptionWithBoolSelectorFieldClass<const bt_field_class> {*this};
+ }
+
bool selectorIsReversed() const noexcept
{
return bt_field_class_option_with_selector_field_bool_selector_is_reversed(
using typename CommonOptionWithSelectorFieldClass<
LibObjT>::_ThisCommonOptionWithSelectorFieldClass;
- using _ThisCommonOptionWithIntegerSelectorFieldClass =
- CommonOptionWithIntegerSelectorFieldClass<LibObjT, RangeSetT>;
-
public:
- using Shared = SharedFieldClass<_ThisCommonOptionWithIntegerSelectorFieldClass, LibObjT>;
-
+ using Shared = SharedFieldClass<CommonOptionWithIntegerSelectorFieldClass, LibObjT>;
using RangeSet = RangeSetT;
explicit CommonOptionWithIntegerSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
}
template <typename OtherLibObjT>
- CommonOptionWithIntegerSelectorFieldClass&
+ CommonOptionWithIntegerSelectorFieldClass
operator=(const CommonOptionWithIntegerSelectorFieldClass<OtherLibObjT, RangeSetT> fc) noexcept
{
_ThisCommonOptionWithSelectorFieldClass::operator=(fc);
private:
using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
using typename BorrowedObject<LibObjT>::_LibObjPtr;
-
- using _FieldClass =
- typename std::conditional<std::is_const<LibObjT>::value, ConstFieldClass, FieldClass>::type;
+ using _FieldClass = internal::DepFc<LibObjT>;
public:
- using UserAttributes =
- typename std::conditional<std::is_const<LibObjT>::value, ConstMapValue, MapValue>::type;
+ using UserAttributes = internal::DepUserAttrs<LibObjT>;
explicit CommonVariantFieldClassOption(const _LibObjPtr libObjPtr) noexcept :
_ThisBorrowedObject {libObjPtr}
}
template <typename OtherLibObjT>
- CommonVariantFieldClassOption&
+ CommonVariantFieldClassOption
operator=(const CommonVariantFieldClassOption<OtherLibObjT> fc) noexcept
{
_ThisBorrowedObject::operator=(fc);
return *this;
}
- nonstd::optional<bpstd::string_view> name() const noexcept
+ CommonVariantFieldClassOption<const bt_field_class_variant_option> asConst() const noexcept
{
- const auto name = bt_field_class_variant_option_get_name(this->libObjPtr());
-
- if (name) {
- return name;
- }
-
- return nonstd::nullopt;
+ return CommonVariantFieldClassOption<const bt_field_class_variant_option> {*this};
}
- ConstFieldClass fieldClass() const noexcept
+ const char *name() const noexcept
{
- return ConstFieldClass {internal::CommonVariantFieldClassOptionSpec<
- const bt_field_class_variant_option>::fieldClass(this->libObjPtr())};
+ return bt_field_class_variant_option_get_name(this->libObjPtr());
}
- _FieldClass fieldClass() noexcept
+ _FieldClass fieldClass() const noexcept
{
return _FieldClass {
internal::CommonVariantFieldClassOptionSpec<LibObjT>::fieldClass(this->libObjPtr())};
}
template <typename LibValT>
- void userAttributes(const CommonMapValue<LibValT> userAttrs)
+ void userAttributes(const CommonMapValue<LibValT> userAttrs) const noexcept
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value,
+ "Not available with `bt2::ConstVariantFieldClassOption`.");
bt_field_class_variant_option_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
}
- ConstMapValue userAttributes() const noexcept
- {
- return ConstMapValue {internal::CommonVariantFieldClassOptionSpec<
- const bt_field_class_variant_option>::userAttributes(this->libObjPtr())};
- }
-
- UserAttributes userAttributes() noexcept
+ UserAttributes userAttributes() const noexcept
{
return UserAttributes {internal::CommonVariantFieldClassOptionSpec<LibObjT>::userAttributes(
this->libObjPtr())};
}
template <typename OtherLibObjT>
- ConstVariantWithIntegerSelectorFieldClassOption&
+ ConstVariantWithIntegerSelectorFieldClassOption
operator=(const ConstVariantWithIntegerSelectorFieldClassOption<OtherLibObjT> fc) noexcept
{
_ThisBorrowedObject::operator=(fc);
return ConstVariantFieldClassOption {_Spec::asBaseOption(this->libObjPtr())};
}
- nonstd::optional<bpstd::string_view> name() const noexcept
+ const char *name() const noexcept
{
return this->asBaseOption().name();
}
public:
using Shared = SharedFieldClass<CommonVariantFieldClass<LibObjT>, LibObjT>;
+ using Iterator = BorrowedObjectIterator<CommonVariantFieldClass>;
using Option =
- typename std::conditional<std::is_const<LibObjT>::value, ConstVariantFieldClassOption,
- VariantFieldClassOption>::type;
-
- using Iterator = CommonIterator<CommonVariantFieldClass, Option>;
+ internal::DepType<LibObjT, VariantFieldClassOption, ConstVariantFieldClassOption>;
explicit CommonVariantFieldClass(const _LibObjPtr libObjPtr) noexcept :
_ThisCommonFieldClass {libObjPtr}
}
template <typename OtherLibObjT>
- CommonVariantFieldClass& operator=(const CommonVariantFieldClass<OtherLibObjT> fc) noexcept
+ CommonVariantFieldClass operator=(const CommonVariantFieldClass<OtherLibObjT> fc) noexcept
{
_ThisCommonFieldClass::operator=(fc);
return *this;
}
- std::uint64_t size() const noexcept
+ CommonVariantFieldClass<const bt_field_class> asConst() const noexcept
+ {
+ return CommonVariantFieldClass<const bt_field_class> {*this};
+ }
+
+ std::uint64_t length() const noexcept
{
return bt_field_class_variant_get_option_count(this->libObjPtr());
}
Iterator end() const noexcept
{
- return Iterator {*this, this->size()};
- }
-
- ConstVariantFieldClassOption operator[](const std::uint64_t index) const noexcept
- {
- return ConstVariantFieldClassOption {
- internal::CommonVariantFieldClassSpec<const bt_field_class>::optionByIndex(
- this->libObjPtr(), index)};
+ return Iterator {*this, this->length()};
}
- Option operator[](const std::uint64_t index) noexcept
+ Option operator[](const std::uint64_t index) const noexcept
{
return Option {internal::CommonVariantFieldClassSpec<LibObjT>::optionByIndex(
this->libObjPtr(), index)};
}
- nonstd::optional<ConstVariantFieldClassOption>
- operator[](const char * const name) const noexcept
- {
- const auto libObjPtr =
- internal::CommonVariantFieldClassSpec<const bt_field_class>::optionByName(
- this->libObjPtr(), name);
-
- if (libObjPtr) {
- return ConstVariantFieldClassOption {libObjPtr};
- }
-
- return nonstd::nullopt;
- }
-
- nonstd::optional<ConstVariantFieldClassOption>
- operator[](const std::string& name) const noexcept
- {
- return (*this)[name.data()];
- }
-
- nonstd::optional<Option> operator[](const char * const name) noexcept
+ bt2s::optional<Option> operator[](const char * const name) const noexcept
{
const auto libObjPtr =
internal::CommonVariantFieldClassSpec<LibObjT>::optionByName(this->libObjPtr(), name);
return Option {libObjPtr};
}
- return nonstd::nullopt;
+ return bt2s::nullopt;
}
- nonstd::optional<Option> operator[](const std::string& name) noexcept
+ bt2s::optional<Option> operator[](const std::string& name) const noexcept
{
return (*this)[name.data()];
}
}
template <typename OtherLibObjT>
- CommonVariantWithoutSelectorFieldClass&
+ CommonVariantWithoutSelectorFieldClass
operator=(const CommonVariantWithoutSelectorFieldClass<OtherLibObjT> fc) noexcept
{
_ThisCommonVariantFieldClass::operator=(fc);
return *this;
}
- void appendOption(const char * const name, const FieldClass fc)
+ CommonVariantWithoutSelectorFieldClass<const bt_field_class> asConst() const noexcept
+ {
+ return CommonVariantWithoutSelectorFieldClass<const bt_field_class> {*this};
+ }
+
+ void appendOption(const char * const name, const FieldClass fc) const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(!std::is_const<LibObjT>::value,
+ "Not available with `bt2::ConstVariantWithoutSelectorFieldClass`.");
const auto status = bt_field_class_variant_without_selector_append_option(
this->libObjPtr(), name, fc.libObjPtr());
}
}
- void appendOption(const nonstd::optional<std::string>& name, const FieldClass fc)
+ void appendOption(const bt2s::optional<std::string>& name, const FieldClass fc) const
{
this->appendOption(name ? name->data() : nullptr, fc);
}
}
template <typename OtherLibObjT>
- CommonVariantWithSelectorFieldClass&
+ CommonVariantWithSelectorFieldClass
operator=(const CommonVariantWithSelectorFieldClass<OtherLibObjT> fc) noexcept
{
_ThisCommonVariantFieldClass::operator=(fc);
return *this;
}
+ CommonVariantWithSelectorFieldClass<const bt_field_class> asConst() const noexcept
+ {
+ return CommonVariantWithSelectorFieldClass<const bt_field_class> {*this};
+ }
+
ConstFieldPath selectorFieldPath() const noexcept
{
return ConstFieldPath {
using typename CommonVariantWithSelectorFieldClass<
LibObjT>::_ThisCommonVariantWithSelectorFieldClass;
using typename CommonFieldClass<LibObjT>::_LibObjPtr;
- using _ThisCommonVariantWithIntegerSelectorFieldClass =
- CommonVariantWithIntegerSelectorFieldClass<LibObjT, OptionT>;
using _Spec = internal::CommonVariantWithIntegerSelectorFieldClassSpec<OptionT>;
public:
- using Shared = SharedFieldClass<_ThisCommonVariantWithIntegerSelectorFieldClass, LibObjT>;
-
+ using Shared = SharedFieldClass<CommonVariantWithIntegerSelectorFieldClass, LibObjT>;
using Option = OptionT;
+
using Iterator =
- CommonIterator<CommonVariantWithIntegerSelectorFieldClass<LibObjT, Option>, Option>;
+ BorrowedObjectIterator<CommonVariantWithIntegerSelectorFieldClass<LibObjT, Option>>;
explicit CommonVariantWithIntegerSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
_ThisCommonVariantWithSelectorFieldClass {libObjPtr}
}
template <typename OtherLibObjT>
- CommonVariantWithIntegerSelectorFieldClass&
+ CommonVariantWithIntegerSelectorFieldClass
operator=(const CommonVariantWithIntegerSelectorFieldClass<OtherLibObjT, OptionT> fc) noexcept
{
_ThisCommonVariantWithSelectorFieldClass::operator=(fc);
return Option {_Spec::optionByIndex(this->libObjPtr(), index)};
}
- nonstd::optional<Option> operator[](const char * const name) const noexcept
+ bt2s::optional<Option> operator[](const char * const name) const noexcept
{
const auto libObjPtr = _Spec::optionByName(this->libObjPtr(), name);
return Option {libObjPtr};
}
- return nonstd::nullopt;
+ return bt2s::nullopt;
}
- nonstd::optional<Option> operator[](const std::string& name) const noexcept
+ bt2s::optional<Option> operator[](const std::string& name) const noexcept
{
return (*this)[name.data()];
}
void appendOption(const char * const name, const FieldClass fc,
- const typename Option::RangeSet ranges)
+ const typename Option::RangeSet ranges) const
{
- static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
+ static_assert(
+ !std::is_const<LibObjT>::value,
+ "Not available with `bt2::ConstVariantWithUnsignedIntegerSelectorFieldClass`.");
const auto status =
_Spec::appendOption(this->libObjPtr(), name, fc.libObjPtr(), ranges.libObjPtr());
}
}
- void appendOption(const nonstd::optional<std::string>& name, const FieldClass fc,
- const typename Option::RangeSet ranges)
+ void appendOption(const bt2s::optional<std::string>& name, const FieldClass fc,
+ const typename Option::RangeSet ranges) const
{
this->appendOption(name ? name->data() : nullptr, fc, ranges);
}
Iterator end() const noexcept
{
- return Iterator {*this, this->size()};
+ return Iterator {*this, this->length()};
}
Shared shared() const noexcept