From 341a67c453bb283829a0af408a3a8dda89a4da4a Mon Sep 17 00:00:00 2001
From: Francis Deslauriers <francis.deslauriers@efficios.com>
Date: Tue, 26 Apr 2022 11:39:11 -0400
Subject: [PATCH] cpp-common: Expose BorrowedObj::libObjPtr() as public method

This will be useful for component class queries that may use bt2::Value
C++ wrappers but must return a `bt_value` at the moment.

Signed-off-by: Francis Deslauriers <francis.deslauriers@efficios.com>
Change-Id: Iea93caa6b47ce1afeb7977fee26dffdd3f97013e
Reviewed-on: https://review.lttng.org/c/babeltrace/+/7948
Reviewed-by: Philippe Proulx <eeppeliteloop@gmail.com>
Reviewed-on: https://review.lttng.org/c/babeltrace/+/10787
CI-Build: Philippe Proulx <eeppeliteloop@gmail.com>
Tested-by: jenkins <jenkins@lttng.org>
---
 src/cpp-common/bt2/clock-class.hpp           |  36 +--
 src/cpp-common/bt2/clock-snapshot.hpp        |   4 +-
 src/cpp-common/bt2/field-class.hpp           | 144 +++++-----
 src/cpp-common/bt2/field-path.hpp            |  12 +-
 src/cpp-common/bt2/field.hpp                 | 136 ++++-----
 src/cpp-common/bt2/integer-range-set.hpp     |  14 +-
 src/cpp-common/bt2/integer-range.hpp         |   8 +-
 src/cpp-common/bt2/internal/borrowed-obj.hpp |  14 +-
 src/cpp-common/bt2/internal/shared-obj.hpp   |   4 +-
 src/cpp-common/bt2/message.hpp               |  82 +++---
 src/cpp-common/bt2/trace-ir.hpp              | 280 +++++++++----------
 src/cpp-common/bt2/value.hpp                 | 102 ++++---
 12 files changed, 412 insertions(+), 424 deletions(-)

diff --git a/src/cpp-common/bt2/clock-class.hpp b/src/cpp-common/bt2/clock-class.hpp
index c312bdbf..92caa9e4 100644
--- a/src/cpp-common/bt2/clock-class.hpp
+++ b/src/cpp-common/bt2/clock-class.hpp
@@ -124,19 +124,19 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        bt_clock_class_set_frequency(this->_libObjPtr(), frequency);
+        bt_clock_class_set_frequency(this->libObjPtr(), frequency);
     }
 
     std::uint64_t frequency() const noexcept
     {
-        return bt_clock_class_get_frequency(this->_libObjPtr());
+        return bt_clock_class_get_frequency(this->libObjPtr());
     }
 
     void offset(const ClockClassOffset& offset) noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        bt_clock_class_set_offset(this->_libObjPtr(), offset.seconds(), offset.cycles());
+        bt_clock_class_set_offset(this->libObjPtr(), offset.seconds(), offset.cycles());
     }
 
     ClockClassOffset offset() const noexcept
@@ -144,7 +144,7 @@ public:
         std::int64_t seconds;
         std::uint64_t cycles;
 
-        bt_clock_class_get_offset(this->_libObjPtr(), &seconds, &cycles);
+        bt_clock_class_get_offset(this->libObjPtr(), &seconds, &cycles);
         return ClockClassOffset {seconds, cycles};
     }
 
@@ -152,32 +152,32 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        bt_clock_class_set_precision(this->_libObjPtr(), precision);
+        bt_clock_class_set_precision(this->libObjPtr(), precision);
     }
 
     std::uint64_t precision() const noexcept
     {
-        return bt_clock_class_get_precision(this->_libObjPtr());
+        return bt_clock_class_get_precision(this->libObjPtr());
     }
 
     void originIsUnixEpoch(const bool originIsUnixEpoch) noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        bt_clock_class_set_origin_is_unix_epoch(this->_libObjPtr(),
+        bt_clock_class_set_origin_is_unix_epoch(this->libObjPtr(),
                                                 static_cast<bt_bool>(originIsUnixEpoch));
     }
 
     bool originIsUnixEpoch() const noexcept
     {
-        return static_cast<bool>(bt_clock_class_origin_is_unix_epoch(this->_libObjPtr()));
+        return static_cast<bool>(bt_clock_class_origin_is_unix_epoch(this->libObjPtr()));
     }
 
     void name(const char * const name)
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        const auto status = bt_clock_class_set_name(this->_libObjPtr(), name);
+        const auto status = bt_clock_class_set_name(this->libObjPtr(), name);
 
         if (status == BT_CLOCK_CLASS_SET_NAME_STATUS_MEMORY_ERROR) {
             throw LibMemoryError {};
@@ -191,7 +191,7 @@ public:
 
     nonstd::optional<bpstd::string_view> name() const noexcept
     {
-        const auto name = bt_clock_class_get_name(this->_libObjPtr());
+        const auto name = bt_clock_class_get_name(this->libObjPtr());
 
         if (name) {
             return name;
@@ -204,7 +204,7 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        const auto status = bt_clock_class_set_description(this->_libObjPtr(), description);
+        const auto status = bt_clock_class_set_description(this->libObjPtr(), description);
 
         if (status == BT_CLOCK_CLASS_SET_DESCRIPTION_STATUS_MEMORY_ERROR) {
             throw LibMemoryError {};
@@ -218,7 +218,7 @@ public:
 
     nonstd::optional<bpstd::string_view> description() const noexcept
     {
-        const auto description = bt_clock_class_get_description(this->_libObjPtr());
+        const auto description = bt_clock_class_get_description(this->libObjPtr());
 
         if (description) {
             return description;
@@ -229,12 +229,12 @@ public:
 
     void uuid(const std::uint8_t * const uuid) noexcept
     {
-        bt_clock_class_set_uuid(this->_libObjPtr(), uuid);
+        bt_clock_class_set_uuid(this->libObjPtr(), uuid);
     }
 
     nonstd::optional<bt2_common::UuidView> uuid() const noexcept
     {
-        const auto uuid = bt_clock_class_get_uuid(this->_libObjPtr());
+        const auto uuid = bt_clock_class_get_uuid(this->libObjPtr());
 
         if (uuid) {
             return bt2_common::UuidView {uuid};
@@ -248,26 +248,26 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        bt_clock_class_set_user_attributes(this->_libObjPtr(), userAttrs._libObjPtr());
+        bt_clock_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
     }
 
     ConstMapValue userAttributes() const noexcept
     {
         return ConstMapValue {internal::CommonClockClassSpec<const bt_clock_class>::userAttributes(
-            this->_libObjPtr())};
+            this->libObjPtr())};
     }
 
     UserAttributes userAttributes() noexcept
     {
         return UserAttributes {
-            internal::CommonClockClassSpec<LibObjT>::userAttributes(this->_libObjPtr())};
+            internal::CommonClockClassSpec<LibObjT>::userAttributes(this->libObjPtr())};
     }
 
     std::int64_t cyclesToNsFromOrigin(const std::uint64_t value) const
     {
         std::int64_t nsFromOrigin;
         const auto status =
-            bt_clock_class_cycles_to_ns_from_origin(this->_libObjPtr(), value, &nsFromOrigin);
+            bt_clock_class_cycles_to_ns_from_origin(this->libObjPtr(), value, &nsFromOrigin);
 
         if (status == BT_CLOCK_CLASS_CYCLES_TO_NS_FROM_ORIGIN_STATUS_OVERFLOW_ERROR) {
             throw LibOverflowError {};
diff --git a/src/cpp-common/bt2/clock-snapshot.hpp b/src/cpp-common/bt2/clock-snapshot.hpp
index 301931f6..9bd7a6d6 100644
--- a/src/cpp-common/bt2/clock-snapshot.hpp
+++ b/src/cpp-common/bt2/clock-snapshot.hpp
@@ -35,7 +35,7 @@ public:
 
     std::uint64_t value() const noexcept
     {
-        return bt_clock_snapshot_get_value(this->_libObjPtr());
+        return bt_clock_snapshot_get_value(this->libObjPtr());
     }
 
     operator std::uint64_t() const noexcept
@@ -46,7 +46,7 @@ public:
     std::int64_t nsFromOrigin() const
     {
         std::int64_t nsFromOrigin;
-        const auto status = bt_clock_snapshot_get_ns_from_origin(this->_libObjPtr(), &nsFromOrigin);
+        const auto status = bt_clock_snapshot_get_ns_from_origin(this->libObjPtr(), &nsFromOrigin);
 
         if (status == BT_CLOCK_SNAPSHOT_GET_NS_FROM_ORIGIN_STATUS_OVERFLOW_ERROR) {
             throw LibOverflowError {};
diff --git a/src/cpp-common/bt2/field-class.hpp b/src/cpp-common/bt2/field-class.hpp
index dc25d4cf..a7ec0125 100644
--- a/src/cpp-common/bt2/field-class.hpp
+++ b/src/cpp-common/bt2/field-class.hpp
@@ -161,10 +161,10 @@ enum class FieldClassType
 template <typename LibObjT>
 class CommonFieldClass : public internal::BorrowedObj<LibObjT>
 {
-    /* Allow appendMember() to call `fc._libObjPtr()` */
+    /* Allow appendMember() to call `fc.libObjPtr()` */
     friend class CommonStructureFieldClass<bt_field_class>;
 
-    /* Allow appendOption() to call `fc._libObjPtr()` */
+    /* Allow appendOption() to call `fc.libObjPtr()` */
     friend class CommonVariantWithoutSelectorFieldClass<bt_field_class>;
 
     friend class CommonVariantWithIntegerSelectorFieldClass<
@@ -177,11 +177,11 @@ class CommonFieldClass : public internal::BorrowedObj<LibObjT>
         ConstVariantWithIntegerSelectorFieldClassOption<
             const bt_field_class_variant_with_selector_field_integer_signed_option>>;
 
-    /* Allow *FieldClass() to call `fc._libObjPtr()` */
+    /* 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()` */
+    /* Allow create*FieldClass() to call `fc.libObjPtr()` */
     friend class CommonTraceClass<bt_trace_class>;
 
 private:
@@ -215,7 +215,7 @@ public:
 
     FieldClassType type() const noexcept
     {
-        return static_cast<FieldClassType>(bt_field_class_get_type(this->_libObjPtr()));
+        return static_cast<FieldClassType>(bt_field_class_get_type(this->libObjPtr()));
     }
 
     bool isBool() const noexcept
@@ -417,19 +417,19 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        bt_field_class_set_user_attributes(this->_libObjPtr(), userAttrs._libObjPtr());
+        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())};
+            this->libObjPtr())};
     }
 
     UserAttributes userAttributes() noexcept
     {
         return UserAttributes {
-            internal::CommonFieldClassSpec<LibObjT>::userAttributes(this->_libObjPtr())};
+            internal::CommonFieldClassSpec<LibObjT>::userAttributes(this->libObjPtr())};
     }
 
     Shared shared() const noexcept
@@ -440,7 +440,7 @@ public:
 protected:
     bool _libTypeIs(const bt_field_class_type type) const noexcept
     {
-        return bt_field_class_type_is(bt_field_class_get_type(this->_libObjPtr()), type);
+        return bt_field_class_type_is(bt_field_class_get_type(this->libObjPtr()), type);
     }
 };
 
@@ -479,7 +479,7 @@ public:
 
     std::uint64_t length() const noexcept
     {
-        return bt_field_class_bit_array_get_length(this->_libObjPtr());
+        return bt_field_class_bit_array_get_length(this->libObjPtr());
     }
 
     Shared shared() const noexcept
@@ -535,12 +535,12 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        bt_field_class_integer_get_field_value_range(this->_libObjPtr(), n);
+        bt_field_class_integer_get_field_value_range(this->libObjPtr(), n);
     }
 
     std::uint64_t fieldValueRange() const noexcept
     {
-        return bt_field_class_integer_get_field_value_range(this->_libObjPtr());
+        return bt_field_class_integer_get_field_value_range(this->libObjPtr());
     }
 
     void preferredDisplayBase(const DisplayBase base) noexcept
@@ -548,13 +548,13 @@ public:
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
         bt_field_class_integer_set_preferred_display_base(
-            this->_libObjPtr(), static_cast<bt_field_class_integer_preferred_display_base>(base));
+            this->libObjPtr(), static_cast<bt_field_class_integer_preferred_display_base>(base));
     }
 
     DisplayBase preferredDisplayBase() const noexcept
     {
         return static_cast<DisplayBase>(
-            bt_field_class_integer_get_preferred_display_base(this->_libObjPtr()));
+            bt_field_class_integer_get_preferred_display_base(this->libObjPtr()));
     }
 
     Shared shared() const noexcept
@@ -642,12 +642,12 @@ public:
     RangeSet ranges() const noexcept
     {
         return RangeSet {
-            internal::ConstEnumerationFieldClassMappingSpec<LibObjT>::ranges(this->_libObjPtr())};
+            internal::ConstEnumerationFieldClassMappingSpec<LibObjT>::ranges(this->libObjPtr())};
     }
 
     bpstd::string_view label() const noexcept
     {
-        return internal::ConstEnumerationFieldClassMappingSpec<LibObjT>::label(this->_libObjPtr());
+        return internal::ConstEnumerationFieldClassMappingSpec<LibObjT>::label(this->libObjPtr());
     }
 };
 
@@ -734,7 +734,7 @@ public:
 
     std::uint64_t size() const noexcept
     {
-        return bt_field_class_enumeration_get_mapping_count(this->_libObjPtr());
+        return bt_field_class_enumeration_get_mapping_count(this->libObjPtr());
     }
 
     Shared shared() const noexcept
@@ -779,13 +779,13 @@ public:
     Mapping operator[](const std::uint64_t index) const noexcept
     {
         return Mapping {internal::CommonEnumerationFieldClassSpec<MappingT>::mappingByIndex(
-            this->_libObjPtr(), index)};
+            this->libObjPtr(), index)};
     }
 
     nonstd::optional<Mapping> operator[](const char * const label) const noexcept
     {
         const auto libObjPtr = internal::CommonEnumerationFieldClassSpec<MappingT>::mappingByLabel(
-            this->_libObjPtr(), label);
+            this->libObjPtr(), label);
 
         if (libObjPtr) {
             return Mapping {libObjPtr};
@@ -881,19 +881,19 @@ public:
 
     bpstd::string_view name() const noexcept
     {
-        return bt_field_class_structure_member_get_name(this->_libObjPtr());
+        return bt_field_class_structure_member_get_name(this->libObjPtr());
     }
 
     ConstFieldClass fieldClass() const noexcept
     {
         return ConstFieldClass {internal::CommonStructureFieldClassMemberSpec<
-            const bt_field_class_structure_member>::fieldClass(this->_libObjPtr())};
+            const bt_field_class_structure_member>::fieldClass(this->libObjPtr())};
     }
 
     _FieldClass fieldClass() noexcept
     {
         return _FieldClass {
-            internal::CommonStructureFieldClassMemberSpec<LibObjT>::fieldClass(this->_libObjPtr())};
+            internal::CommonStructureFieldClassMemberSpec<LibObjT>::fieldClass(this->libObjPtr())};
     }
 };
 
@@ -982,7 +982,7 @@ public:
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
         const auto status =
-            bt_field_class_structure_append_member(this->_libObjPtr(), name, fc._libObjPtr());
+            bt_field_class_structure_append_member(this->libObjPtr(), name, fc.libObjPtr());
 
         if (status == BT_FIELD_CLASS_STRUCTURE_APPEND_MEMBER_STATUS_MEMORY_ERROR) {
             throw LibMemoryError {};
@@ -996,7 +996,7 @@ public:
 
     std::uint64_t size() const noexcept
     {
-        return bt_field_class_structure_get_member_count(this->_libObjPtr());
+        return bt_field_class_structure_get_member_count(this->libObjPtr());
     }
 
     Iterator begin() const noexcept
@@ -1013,13 +1013,13 @@ public:
     {
         return ConstStructureFieldClassMember {
             internal::CommonStructureFieldClassSpec<const bt_field_class>::memberByIndex(
-                this->_libObjPtr(), index)};
+                this->libObjPtr(), index)};
     }
 
     Member operator[](const std::uint64_t index) noexcept
     {
         return Member {internal::CommonStructureFieldClassSpec<LibObjT>::memberByIndex(
-            this->_libObjPtr(), index)};
+            this->libObjPtr(), index)};
     }
 
     nonstd::optional<ConstStructureFieldClassMember>
@@ -1027,7 +1027,7 @@ public:
     {
         const auto libObjPtr =
             internal::CommonStructureFieldClassSpec<const bt_field_class>::memberByName(
-                this->_libObjPtr(), name);
+                this->libObjPtr(), name);
 
         if (libObjPtr) {
             return ConstStructureFieldClassMember {libObjPtr};
@@ -1044,8 +1044,8 @@ public:
 
     nonstd::optional<Member> operator[](const char * const name) noexcept
     {
-        const auto libObjPtr = internal::CommonStructureFieldClassSpec<LibObjT>::memberByName(
-            this->_libObjPtr(), name);
+        const auto libObjPtr =
+            internal::CommonStructureFieldClassSpec<LibObjT>::memberByName(this->libObjPtr(), name);
 
         if (libObjPtr) {
             return Member {libObjPtr};
@@ -1134,13 +1134,13 @@ public:
     {
         return ConstFieldClass {
             internal::CommonArrayFieldClassSpec<const bt_field_class>::elementFieldClass(
-                this->_libObjPtr())};
+                this->libObjPtr())};
     }
 
     _FieldClass elementFieldClass() noexcept
     {
         return _FieldClass {
-            internal::CommonArrayFieldClassSpec<LibObjT>::elementFieldClass(this->_libObjPtr())};
+            internal::CommonArrayFieldClassSpec<LibObjT>::elementFieldClass(this->libObjPtr())};
     }
 
     Shared shared() const noexcept
@@ -1184,7 +1184,7 @@ public:
 
     std::uint64_t length() const noexcept
     {
-        return bt_field_class_array_static_get_length(this->_libObjPtr());
+        return bt_field_class_array_static_get_length(this->libObjPtr());
     }
 
     Shared shared() const noexcept
@@ -1232,7 +1232,7 @@ public:
     {
         return ConstFieldPath {
             bt_field_class_array_dynamic_with_length_field_borrow_length_field_path_const(
-                this->_libObjPtr())};
+                this->libObjPtr())};
     }
 
     Shared shared() const noexcept
@@ -1312,13 +1312,13 @@ public:
     {
         return ConstFieldClass {
             internal::CommonOptionFieldClassSpec<const bt_field_class>::fieldClass(
-                this->_libObjPtr())};
+                this->libObjPtr())};
     }
 
     _FieldClass fieldClass() noexcept
     {
         return _FieldClass {
-            internal::CommonOptionFieldClassSpec<LibObjT>::fieldClass(this->_libObjPtr())};
+            internal::CommonOptionFieldClassSpec<LibObjT>::fieldClass(this->libObjPtr())};
     }
 
     Shared shared() const noexcept
@@ -1368,7 +1368,7 @@ public:
     {
         return ConstFieldPath {
             bt_field_class_option_with_selector_field_borrow_selector_field_path_const(
-                this->_libObjPtr())};
+                this->libObjPtr())};
     }
 
     Shared shared() const noexcept
@@ -1417,7 +1417,7 @@ public:
     bool selectorIsReversed() const noexcept
     {
         return bt_field_class_option_with_selector_field_bool_selector_is_reversed(
-            this->_libObjPtr());
+            this->libObjPtr());
     }
 
     Shared shared() const noexcept
@@ -1504,7 +1504,7 @@ public:
     RangeSet ranges() const noexcept
     {
         return RangeSet {internal::CommonOptionWithIntegerSelectorFieldClassSpec<RangeSetT>::ranges(
-            this->_libObjPtr())};
+            this->libObjPtr())};
     }
 
     Shared shared() const noexcept
@@ -1585,19 +1585,19 @@ public:
 
     bpstd::string_view name() const noexcept
     {
-        return bt_field_class_variant_option_get_name(this->_libObjPtr());
+        return bt_field_class_variant_option_get_name(this->libObjPtr());
     }
 
     ConstFieldClass fieldClass() const noexcept
     {
         return ConstFieldClass {internal::CommonVariantFieldClassOptionSpec<
-            const bt_field_class_variant_option>::fieldClass(this->_libObjPtr())};
+            const bt_field_class_variant_option>::fieldClass(this->libObjPtr())};
     }
 
     _FieldClass fieldClass() noexcept
     {
         return _FieldClass {
-            internal::CommonVariantFieldClassOptionSpec<LibObjT>::fieldClass(this->_libObjPtr())};
+            internal::CommonVariantFieldClassOptionSpec<LibObjT>::fieldClass(this->libObjPtr())};
     }
 };
 
@@ -1696,7 +1696,7 @@ public:
 
     ConstVariantFieldClassOption asBaseOption() const noexcept
     {
-        return ConstVariantFieldClassOption {_Spec::asBaseOption(this->_libObjPtr())};
+        return ConstVariantFieldClassOption {_Spec::asBaseOption(this->libObjPtr())};
     }
 
     bpstd::string_view name() const noexcept
@@ -1711,7 +1711,7 @@ public:
 
     RangeSet ranges() const noexcept
     {
-        return RangeSet {_Spec::ranges(this->_libObjPtr())};
+        return RangeSet {_Spec::ranges(this->libObjPtr())};
     }
 };
 
@@ -1804,7 +1804,7 @@ public:
 
     std::uint64_t size() const noexcept
     {
-        return bt_field_class_variant_get_option_count(this->_libObjPtr());
+        return bt_field_class_variant_get_option_count(this->libObjPtr());
     }
 
     Iterator begin() const noexcept
@@ -1821,13 +1821,13 @@ public:
     {
         return ConstVariantFieldClassOption {
             internal::CommonVariantFieldClassSpec<const bt_field_class>::optionByIndex(
-                this->_libObjPtr(), index)};
+                this->libObjPtr(), index)};
     }
 
     Option operator[](const std::uint64_t index) noexcept
     {
         return Option {internal::CommonVariantFieldClassSpec<LibObjT>::optionByIndex(
-            this->_libObjPtr(), index)};
+            this->libObjPtr(), index)};
     }
 
     nonstd::optional<ConstVariantFieldClassOption>
@@ -1835,7 +1835,7 @@ public:
     {
         const auto libObjPtr =
             internal::CommonVariantFieldClassSpec<const bt_field_class>::optionByName(
-                this->_libObjPtr(), name);
+                this->libObjPtr(), name);
 
         if (libObjPtr) {
             return ConstVariantFieldClassOption {libObjPtr};
@@ -1853,7 +1853,7 @@ public:
     nonstd::optional<Option> operator[](const char * const name) noexcept
     {
         const auto libObjPtr =
-            internal::CommonVariantFieldClassSpec<LibObjT>::optionByName(this->_libObjPtr(), name);
+            internal::CommonVariantFieldClassSpec<LibObjT>::optionByName(this->libObjPtr(), name);
 
         if (libObjPtr) {
             return Option {libObjPtr};
@@ -1913,7 +1913,7 @@ public:
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
         const auto status = bt_field_class_variant_without_selector_append_option(
-            this->_libObjPtr(), name, fc._libObjPtr());
+            this->libObjPtr(), name, fc.libObjPtr());
 
         if (status ==
             BT_FIELD_CLASS_VARIANT_WITHOUT_SELECTOR_FIELD_APPEND_OPTION_STATUS_MEMORY_ERROR) {
@@ -2041,7 +2041,7 @@ public:
     {
         return ConstFieldPath {
             bt_field_class_variant_with_selector_field_borrow_selector_field_path_const(
-                this->_libObjPtr())};
+                this->libObjPtr())};
     }
 
     Shared shared() const noexcept
@@ -2092,12 +2092,12 @@ public:
 
     Option operator[](const std::uint64_t index) const noexcept
     {
-        return Option {_Spec::optionByIndex(this->_libObjPtr(), index)};
+        return Option {_Spec::optionByIndex(this->libObjPtr(), index)};
     }
 
     nonstd::optional<Option> operator[](const char * const name) const noexcept
     {
-        const auto libObjPtr = _Spec::optionByName(this->_libObjPtr(), name);
+        const auto libObjPtr = _Spec::optionByName(this->libObjPtr(), name);
 
         if (libObjPtr) {
             return Option {libObjPtr};
@@ -2117,7 +2117,7 @@ public:
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
         const auto status =
-            _Spec::appendOption(this->_libObjPtr(), name, fc._libObjPtr(), ranges._libObjPtr());
+            _Spec::appendOption(this->libObjPtr(), name, fc.libObjPtr(), ranges.libObjPtr());
 
         if (status ==
             BT_FIELD_CLASS_VARIANT_WITH_SELECTOR_FIELD_APPEND_OPTION_STATUS_MEMORY_ERROR) {
@@ -2153,21 +2153,21 @@ template <typename LibObjT>
 CommonBitArrayFieldClass<LibObjT> CommonFieldClass<LibObjT>::asBitArray() const noexcept
 {
     BT_ASSERT_DBG(this->isBitArray());
-    return CommonBitArrayFieldClass<LibObjT> {this->_libObjPtr()};
+    return CommonBitArrayFieldClass<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
 CommonIntegerFieldClass<LibObjT> CommonFieldClass<LibObjT>::asInteger() const noexcept
 {
     BT_ASSERT_DBG(this->isInteger());
-    return CommonIntegerFieldClass<LibObjT> {this->_libObjPtr()};
+    return CommonIntegerFieldClass<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
 CommonBaseEnumerationFieldClass<LibObjT> CommonFieldClass<LibObjT>::asEnumeration() const noexcept
 {
     BT_ASSERT_DBG(this->isEnumeration());
-    return CommonBaseEnumerationFieldClass<LibObjT> {this->_libObjPtr()};
+    return CommonBaseEnumerationFieldClass<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
@@ -2176,7 +2176,7 @@ CommonFieldClass<LibObjT>::asUnsignedEnumeration() const noexcept
 {
     BT_ASSERT_DBG(this->isUnsignedEnumeration());
     return CommonEnumerationFieldClass<LibObjT, ConstUnsignedEnumerationFieldClassMapping> {
-        this->_libObjPtr()};
+        this->libObjPtr()};
 }
 
 template <typename LibObjT>
@@ -2185,28 +2185,28 @@ CommonFieldClass<LibObjT>::asSignedEnumeration() const noexcept
 {
     BT_ASSERT_DBG(this->isSignedEnumeration());
     return CommonEnumerationFieldClass<LibObjT, ConstSignedEnumerationFieldClassMapping> {
-        this->_libObjPtr()};
+        this->libObjPtr()};
 }
 
 template <typename LibObjT>
 CommonStructureFieldClass<LibObjT> CommonFieldClass<LibObjT>::asStructure() const noexcept
 {
     BT_ASSERT_DBG(this->isStructure());
-    return CommonStructureFieldClass<LibObjT> {this->_libObjPtr()};
+    return CommonStructureFieldClass<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
 CommonArrayFieldClass<LibObjT> CommonFieldClass<LibObjT>::asArray() const noexcept
 {
     BT_ASSERT_DBG(this->isArray());
-    return CommonArrayFieldClass<LibObjT> {this->_libObjPtr()};
+    return CommonArrayFieldClass<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
 CommonStaticArrayFieldClass<LibObjT> CommonFieldClass<LibObjT>::asStaticArray() const noexcept
 {
     BT_ASSERT_DBG(this->isStaticArray());
-    return CommonStaticArrayFieldClass<LibObjT> {this->_libObjPtr()};
+    return CommonStaticArrayFieldClass<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
@@ -2214,14 +2214,14 @@ CommonDynamicArrayWithLengthFieldClass<LibObjT>
 CommonFieldClass<LibObjT>::asDynamicArrayWithLength() const noexcept
 {
     BT_ASSERT_DBG(this->isDynamicArrayWithLength());
-    return CommonDynamicArrayWithLengthFieldClass<LibObjT> {this->_libObjPtr()};
+    return CommonDynamicArrayWithLengthFieldClass<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
 CommonOptionFieldClass<LibObjT> CommonFieldClass<LibObjT>::asOption() const noexcept
 {
     BT_ASSERT_DBG(this->isOption());
-    return CommonOptionFieldClass<LibObjT> {this->_libObjPtr()};
+    return CommonOptionFieldClass<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
@@ -2229,7 +2229,7 @@ CommonOptionWithSelectorFieldClass<LibObjT>
 CommonFieldClass<LibObjT>::asOptionWithSelector() const noexcept
 {
     BT_ASSERT_DBG(this->isOptionWithSelector());
-    return CommonOptionWithSelectorFieldClass<LibObjT> {this->_libObjPtr()};
+    return CommonOptionWithSelectorFieldClass<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
@@ -2237,7 +2237,7 @@ CommonOptionWithBoolSelectorFieldClass<LibObjT>
 CommonFieldClass<LibObjT>::asOptionWithBoolSelector() const noexcept
 {
     BT_ASSERT_DBG(this->isOptionWithBoolSelector());
-    return CommonOptionWithBoolSelectorFieldClass<LibObjT> {this->_libObjPtr()};
+    return CommonOptionWithBoolSelectorFieldClass<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
@@ -2246,7 +2246,7 @@ CommonFieldClass<LibObjT>::asOptionWithUnsignedIntegerSelector() const noexcept
 {
     BT_ASSERT_DBG(this->isOptionWithUnsignedIntegerSelector());
     return CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstUnsignedIntegerRangeSet> {
-        this->_libObjPtr()};
+        this->libObjPtr()};
 }
 
 template <typename LibObjT>
@@ -2255,14 +2255,14 @@ CommonFieldClass<LibObjT>::asOptionWithSignedIntegerSelector() const noexcept
 {
     BT_ASSERT_DBG(this->isOptionWithSignedIntegerSelector());
     return CommonOptionWithIntegerSelectorFieldClass<LibObjT, ConstSignedIntegerRangeSet> {
-        this->_libObjPtr()};
+        this->libObjPtr()};
 }
 
 template <typename LibObjT>
 CommonVariantFieldClass<LibObjT> CommonFieldClass<LibObjT>::asVariant() const noexcept
 {
     BT_ASSERT_DBG(this->isVariant());
-    return CommonVariantFieldClass<LibObjT> {this->_libObjPtr()};
+    return CommonVariantFieldClass<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
@@ -2270,7 +2270,7 @@ CommonVariantWithoutSelectorFieldClass<LibObjT>
 CommonFieldClass<LibObjT>::asVariantWithoutSelector() const noexcept
 {
     BT_ASSERT_DBG(this->isVariantWithoutSelector());
-    return CommonVariantWithoutSelectorFieldClass<LibObjT> {this->_libObjPtr()};
+    return CommonVariantWithoutSelectorFieldClass<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
@@ -2278,7 +2278,7 @@ CommonVariantWithSelectorFieldClass<LibObjT>
 CommonFieldClass<LibObjT>::asVariantWithSelector() const noexcept
 {
     BT_ASSERT_DBG(this->isVariantWithSelector());
-    return CommonVariantWithSelectorFieldClass<LibObjT> {this->_libObjPtr()};
+    return CommonVariantWithSelectorFieldClass<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
@@ -2288,7 +2288,7 @@ CommonFieldClass<LibObjT>::asVariantWithUnsignedIntegerSelector() const noexcept
 {
     BT_ASSERT_DBG(this->isVariantWithUnsignedIntegerSelector());
     return CommonVariantWithIntegerSelectorFieldClass<
-        LibObjT, ConstVariantWithUnsignedIntegerSelectorFieldClassOption> {this->_libObjPtr()};
+        LibObjT, ConstVariantWithUnsignedIntegerSelectorFieldClassOption> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
@@ -2298,7 +2298,7 @@ CommonFieldClass<LibObjT>::asVariantWithSignedIntegerSelector() const noexcept
 {
     BT_ASSERT_DBG(this->isVariantWithSignedIntegerSelector());
     return CommonVariantWithIntegerSelectorFieldClass<
-        LibObjT, ConstVariantWithSignedIntegerSelectorFieldClassOption> {this->_libObjPtr()};
+        LibObjT, ConstVariantWithSignedIntegerSelectorFieldClassOption> {this->libObjPtr()};
 }
 
 } /* namespace bt2 */
diff --git a/src/cpp-common/bt2/field-path.hpp b/src/cpp-common/bt2/field-path.hpp
index 4031ee0a..6bb91211 100644
--- a/src/cpp-common/bt2/field-path.hpp
+++ b/src/cpp-common/bt2/field-path.hpp
@@ -67,7 +67,7 @@ public:
 private:
     bt_field_path_item_type _libType() const noexcept
     {
-        return bt_field_path_item_get_type(this->_libObjPtr());
+        return bt_field_path_item_get_type(this->libObjPtr());
     }
 };
 
@@ -93,14 +93,14 @@ public:
 
     std::uint64_t index() const noexcept
     {
-        return bt_field_path_item_index_get_index(this->_libObjPtr());
+        return bt_field_path_item_index_get_index(this->libObjPtr());
     }
 };
 
 inline ConstIndexFieldPathItem ConstFieldPathItem::asIndex() const noexcept
 {
     BT_ASSERT_DBG(this->isIndex());
-    return ConstIndexFieldPathItem {this->_libObjPtr()};
+    return ConstIndexFieldPathItem {this->libObjPtr()};
 }
 
 namespace internal {
@@ -150,18 +150,18 @@ public:
 
     Scope rootScope() const noexcept
     {
-        return static_cast<Scope>(bt_field_path_get_root_scope(this->_libObjPtr()));
+        return static_cast<Scope>(bt_field_path_get_root_scope(this->libObjPtr()));
     }
 
     std::uint64_t size() const noexcept
     {
-        return bt_field_path_get_item_count(this->_libObjPtr());
+        return bt_field_path_get_item_count(this->libObjPtr());
     }
 
     ConstFieldPathItem operator[](const std::uint64_t index) const noexcept
     {
         return ConstFieldPathItem {
-            bt_field_path_borrow_item_by_index_const(this->_libObjPtr(), index)};
+            bt_field_path_borrow_item_by_index_const(this->libObjPtr(), index)};
     }
 
     Shared shared() const noexcept
diff --git a/src/cpp-common/bt2/field.hpp b/src/cpp-common/bt2/field.hpp
index 54f3b38a..e075f8e6 100644
--- a/src/cpp-common/bt2/field.hpp
+++ b/src/cpp-common/bt2/field.hpp
@@ -120,17 +120,17 @@ public:
 
     FieldClassType classType() const noexcept
     {
-        return static_cast<FieldClassType>(bt_field_get_class_type(this->_libObjPtr()));
+        return static_cast<FieldClassType>(bt_field_get_class_type(this->libObjPtr()));
     }
 
     ConstFieldClass cls() const noexcept
     {
-        return ConstFieldClass {internal::CommonFieldSpec<const bt_field>::cls(this->_libObjPtr())};
+        return ConstFieldClass {internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
     }
 
     Class cls() noexcept
     {
-        return Class {internal::CommonFieldSpec<LibObjT>::cls(this->_libObjPtr())};
+        return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
     }
 
     bool isBool() const noexcept
@@ -253,13 +253,13 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        bt_field_bool_set_value(this->_libObjPtr(), static_cast<bt_bool>(val));
+        bt_field_bool_set_value(this->libObjPtr(), static_cast<bt_bool>(val));
         return *this;
     }
 
     Value value() const noexcept
     {
-        return static_cast<Value>(bt_field_bool_get_value(this->_libObjPtr()));
+        return static_cast<Value>(bt_field_bool_get_value(this->libObjPtr()));
     }
 
     operator Value() const noexcept
@@ -303,25 +303,25 @@ public:
     ConstBitArrayFieldClass cls() const noexcept
     {
         return ConstBitArrayFieldClass {
-            internal::CommonFieldSpec<const bt_field>::cls(this->_libObjPtr())};
+            internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
     }
 
     Class cls() noexcept
     {
-        return Class {internal::CommonFieldSpec<LibObjT>::cls(this->_libObjPtr())};
+        return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
     }
 
     CommonBitArrayField<LibObjT>& operator=(const std::uint64_t bits) noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        bt_field_bit_array_set_value_as_integer(this->_libObjPtr(), bits);
+        bt_field_bit_array_set_value_as_integer(this->libObjPtr(), bits);
         return *this;
     }
 
     std::uint64_t valueAsInteger() const noexcept
     {
-        return bt_field_bit_array_get_value_as_integer(this->_libObjPtr());
+        return bt_field_bit_array_get_value_as_integer(this->libObjPtr());
     }
 
     bool bitValue(const std::uint64_t index) const noexcept
@@ -373,25 +373,25 @@ public:
     ConstIntegerFieldClass cls() const noexcept
     {
         return ConstIntegerFieldClass {
-            internal::CommonFieldSpec<const bt_field>::cls(this->_libObjPtr())};
+            internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
     }
 
     Class cls() noexcept
     {
-        return Class {internal::CommonFieldSpec<LibObjT>::cls(this->_libObjPtr())};
+        return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
     }
 
     CommonUnsignedIntegerField<LibObjT>& operator=(const Value val) noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        bt_field_integer_unsigned_set_value(this->_libObjPtr(), val);
+        bt_field_integer_unsigned_set_value(this->libObjPtr(), val);
         return *this;
     }
 
     Value value() const noexcept
     {
-        return bt_field_integer_unsigned_get_value(this->_libObjPtr());
+        return bt_field_integer_unsigned_get_value(this->libObjPtr());
     }
 
     operator Value() const noexcept
@@ -442,25 +442,25 @@ public:
     ConstIntegerFieldClass cls() const noexcept
     {
         return ConstIntegerFieldClass {
-            internal::CommonFieldSpec<const bt_field>::cls(this->_libObjPtr())};
+            internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
     }
 
     Class cls() noexcept
     {
-        return Class {internal::CommonFieldSpec<LibObjT>::cls(this->_libObjPtr())};
+        return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
     }
 
     CommonSignedIntegerField<LibObjT>& operator=(const Value val) noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        bt_field_integer_signed_set_value(this->_libObjPtr(), val);
+        bt_field_integer_signed_set_value(this->libObjPtr(), val);
         return *this;
     }
 
     Value value() const noexcept
     {
-        return bt_field_integer_signed_get_value(this->_libObjPtr());
+        return bt_field_integer_signed_get_value(this->libObjPtr());
     }
 
     operator Value() const noexcept
@@ -539,19 +539,19 @@ public:
     ConstUnsignedEnumerationFieldClass cls() const noexcept
     {
         return ConstUnsignedEnumerationFieldClass {
-            internal::CommonFieldSpec<const bt_field>::cls(this->_libObjPtr())};
+            internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
     }
 
     Class cls() noexcept
     {
-        return Class {internal::CommonFieldSpec<LibObjT>::cls(this->_libObjPtr())};
+        return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
     }
 
     EnumerationFieldClassMappingLabels labels() const
     {
         bt_field_class_enumeration_mapping_label_array labelArray;
         std::uint64_t count;
-        const auto status = bt_field_enumeration_unsigned_get_mapping_labels(this->_libObjPtr(),
+        const auto status = bt_field_enumeration_unsigned_get_mapping_labels(this->libObjPtr(),
                                                                              &labelArray, &count);
 
         if (status == BT_FIELD_ENUMERATION_GET_MAPPING_LABELS_STATUS_MEMORY_ERROR) {
@@ -600,12 +600,12 @@ public:
     ConstSignedEnumerationFieldClass cls() const noexcept
     {
         return ConstSignedEnumerationFieldClass {
-            internal::CommonFieldSpec<const bt_field>::cls(this->_libObjPtr())};
+            internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
     }
 
     Class cls() noexcept
     {
-        return Class {internal::CommonFieldSpec<LibObjT>::cls(this->_libObjPtr())};
+        return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
     }
 
     EnumerationFieldClassMappingLabels labels() const
@@ -613,7 +613,7 @@ public:
         bt_field_class_enumeration_mapping_label_array labelArray;
         std::uint64_t count;
         const auto status =
-            bt_field_enumeration_signed_get_mapping_labels(this->_libObjPtr(), &labelArray, &count);
+            bt_field_enumeration_signed_get_mapping_labels(this->libObjPtr(), &labelArray, &count);
 
         if (status == BT_FIELD_ENUMERATION_GET_MAPPING_LABELS_STATUS_MEMORY_ERROR) {
             throw LibMemoryError {};
@@ -661,13 +661,13 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        bt_field_real_single_precision_set_value(this->_libObjPtr(), val);
+        bt_field_real_single_precision_set_value(this->libObjPtr(), val);
         return *this;
     }
 
     Value value() const noexcept
     {
-        return bt_field_real_single_precision_get_value(this->_libObjPtr());
+        return bt_field_real_single_precision_get_value(this->libObjPtr());
     }
 
     operator Value() const noexcept
@@ -714,13 +714,13 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        bt_field_real_single_precision_set_value(this->_libObjPtr(), val);
+        bt_field_real_single_precision_set_value(this->libObjPtr(), val);
         return *this;
     }
 
     Value value() const noexcept
     {
-        return bt_field_real_single_precision_get_value(this->_libObjPtr());
+        return bt_field_real_single_precision_get_value(this->libObjPtr());
     }
 
     operator Value() const noexcept
@@ -761,7 +761,7 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        const auto status = bt_field_string_set_value(this->_libObjPtr(), val);
+        const auto status = bt_field_string_set_value(this->libObjPtr(), val);
 
         if (status == BT_FIELD_STRING_SET_VALUE_STATUS_MEMORY_ERROR) {
             throw LibMemoryError {};
@@ -779,12 +779,12 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        bt_field_string_clear(this->_libObjPtr());
+        bt_field_string_clear(this->libObjPtr());
     }
 
     bpstd::string_view value() const noexcept
     {
-        return bt_field_string_get_value(this->_libObjPtr());
+        return bt_field_string_get_value(this->libObjPtr());
     }
 };
 
@@ -865,12 +865,12 @@ public:
     ConstStructureFieldClass cls() const noexcept
     {
         return ConstStructureFieldClass {
-            internal::CommonFieldSpec<const bt_field>::cls(this->_libObjPtr())};
+            internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
     }
 
     Class cls() noexcept
     {
-        return Class {internal::CommonFieldSpec<LibObjT>::cls(this->_libObjPtr())};
+        return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
     }
 
     std::uint64_t size() const noexcept
@@ -881,19 +881,19 @@ public:
     ConstField operator[](const std::uint64_t index) const noexcept
     {
         return ConstField {internal::CommonStructureFieldSpec<const bt_field>::memberFieldByIndex(
-            this->_libObjPtr(), index)};
+            this->libObjPtr(), index)};
     }
 
     CommonField<LibObjT> operator[](const std::uint64_t index) noexcept
     {
-        return CommonField<LibObjT> {_Spec::memberFieldByIndex(this->_libObjPtr(), index)};
+        return CommonField<LibObjT> {_Spec::memberFieldByIndex(this->libObjPtr(), index)};
     }
 
     nonstd::optional<ConstField> operator[](const char * const name) const noexcept
     {
         const auto libObjPtr =
-            internal::CommonStructureFieldSpec<const bt_field>::memberFieldByName(
-                this->_libObjPtr(), name);
+            internal::CommonStructureFieldSpec<const bt_field>::memberFieldByName(this->libObjPtr(),
+                                                                                  name);
 
         if (libObjPtr) {
             return ConstField {libObjPtr};
@@ -909,7 +909,7 @@ public:
 
     nonstd::optional<CommonField<LibObjT>> operator[](const char * const name) noexcept
     {
-        const auto libObjPtr = _Spec::memberFieldByName(this->_libObjPtr(), name);
+        const auto libObjPtr = _Spec::memberFieldByName(this->libObjPtr(), name);
 
         if (libObjPtr) {
             return CommonField<LibObjT> {libObjPtr};
@@ -991,28 +991,28 @@ public:
     ConstArrayFieldClass cls() const noexcept
     {
         return ConstArrayFieldClass {
-            internal::CommonFieldSpec<const bt_field>::cls(this->_libObjPtr())};
+            internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
     }
 
     Class cls() noexcept
     {
-        return Class {internal::CommonFieldSpec<LibObjT>::cls(this->_libObjPtr())};
+        return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
     }
 
     std::uint64_t length() const noexcept
     {
-        return bt_field_array_get_length(this->_libObjPtr());
+        return bt_field_array_get_length(this->libObjPtr());
     }
 
     ConstField operator[](const std::uint64_t index) const noexcept
     {
         return ConstField {internal::CommonArrayFieldSpec<const bt_field>::elementFieldByIndex(
-            this->_libObjPtr(), index)};
+            this->libObjPtr(), index)};
     }
 
     CommonField<LibObjT> operator[](const std::uint64_t index) noexcept
     {
-        return CommonField<LibObjT> {_Spec::elementFieldByIndex(this->_libObjPtr(), index)};
+        return CommonField<LibObjT> {_Spec::elementFieldByIndex(this->libObjPtr(), index)};
     }
 };
 
@@ -1056,7 +1056,7 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        const auto status = bt_field_array_dynamic_set_length(this->_libObjPtr(), length);
+        const auto status = bt_field_array_dynamic_set_length(this->libObjPtr(), length);
 
         if (status == BT_FIELD_DYNAMIC_ARRAY_SET_LENGTH_STATUS_MEMORY_ERROR) {
             throw LibMemoryError {};
@@ -1126,19 +1126,19 @@ public:
     ConstOptionFieldClass cls() const noexcept
     {
         return ConstOptionFieldClass {
-            internal::CommonFieldSpec<const bt_field>::cls(this->_libObjPtr())};
+            internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
     }
 
     Class cls() noexcept
     {
-        return Class {internal::CommonFieldSpec<LibObjT>::cls(this->_libObjPtr())};
+        return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
     }
 
     void hasField(const bool hasField) noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        bt_field_option_set_has_field(this->_libObjPtr(), static_cast<bt_bool>(hasField));
+        bt_field_option_set_has_field(this->libObjPtr(), static_cast<bt_bool>(hasField));
     }
 
     bool hasField() const noexcept
@@ -1149,7 +1149,7 @@ public:
     nonstd::optional<ConstField> field() const noexcept
     {
         const auto libObjPtr =
-            internal::CommonOptionFieldSpec<const bt_field>::field(this->_libObjPtr());
+            internal::CommonOptionFieldSpec<const bt_field>::field(this->libObjPtr());
 
         if (libObjPtr) {
             return ConstField {libObjPtr};
@@ -1160,7 +1160,7 @@ public:
 
     nonstd::optional<CommonField<LibObjT>> field() noexcept
     {
-        const auto libObjPtr = _Spec::field(this->_libObjPtr());
+        const auto libObjPtr = _Spec::field(this->libObjPtr());
 
         if (libObjPtr) {
             return CommonField<LibObjT> {libObjPtr};
@@ -1233,35 +1233,35 @@ public:
     ConstVariantFieldClass cls() const noexcept
     {
         return ConstVariantFieldClass {
-            internal::CommonFieldSpec<const bt_field>::cls(this->_libObjPtr())};
+            internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
     }
 
     Class cls() noexcept
     {
-        return Class {internal::CommonFieldSpec<LibObjT>::cls(this->_libObjPtr())};
+        return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
     }
 
     void selectOption(const std::uint64_t index) noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        static_cast<void>(bt_field_variant_select_option_by_index(this->_libObjPtr(), index));
+        static_cast<void>(bt_field_variant_select_option_by_index(this->libObjPtr(), index));
     }
 
     ConstField selectedOptionField() const noexcept
     {
         return ConstField {internal::CommonVariantFieldSpec<const bt_field>::selectedOptionField(
-            this->_libObjPtr())};
+            this->libObjPtr())};
     }
 
     CommonField<LibObjT> selectedOptionField() noexcept
     {
-        return CommonField<LibObjT> {_Spec::selectedOptionField(this->_libObjPtr())};
+        return CommonField<LibObjT> {_Spec::selectedOptionField(this->libObjPtr())};
     }
 
     std::uint64_t selectedOptionIndex() const noexcept
     {
-        return bt_field_variant_get_selected_option_index(this->_libObjPtr());
+        return bt_field_variant_get_selected_option_index(this->libObjPtr());
     }
 };
 
@@ -1272,98 +1272,98 @@ template <typename LibObjT>
 CommonBoolField<LibObjT> CommonField<LibObjT>::asBool() const noexcept
 {
     BT_ASSERT_DBG(this->isBool());
-    return CommonBoolField<LibObjT> {this->_libObjPtr()};
+    return CommonBoolField<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
 CommonBitArrayField<LibObjT> CommonField<LibObjT>::asBitArray() const noexcept
 {
     BT_ASSERT_DBG(this->isBitArray());
-    return CommonBitArrayField<LibObjT> {this->_libObjPtr()};
+    return CommonBitArrayField<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
 CommonUnsignedIntegerField<LibObjT> CommonField<LibObjT>::asUnsignedInteger() const noexcept
 {
     BT_ASSERT_DBG(this->isUnsignedInteger());
-    return CommonUnsignedIntegerField<LibObjT> {this->_libObjPtr()};
+    return CommonUnsignedIntegerField<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
 CommonSignedIntegerField<LibObjT> CommonField<LibObjT>::asSignedInteger() const noexcept
 {
     BT_ASSERT_DBG(this->isSignedInteger());
-    return CommonSignedIntegerField<LibObjT> {this->_libObjPtr()};
+    return CommonSignedIntegerField<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
 CommonUnsignedEnumerationField<LibObjT> CommonField<LibObjT>::asUnsignedEnumeration() const noexcept
 {
     BT_ASSERT_DBG(this->isUnsignedEnumeration());
-    return CommonUnsignedEnumerationField<LibObjT> {this->_libObjPtr()};
+    return CommonUnsignedEnumerationField<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
 CommonSignedEnumerationField<LibObjT> CommonField<LibObjT>::asSignedEnumeration() const noexcept
 {
     BT_ASSERT_DBG(this->isSignedEnumeration());
-    return CommonSignedEnumerationField<LibObjT> {this->_libObjPtr()};
+    return CommonSignedEnumerationField<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
 CommonSinglePrecisionRealField<LibObjT> CommonField<LibObjT>::asSinglePrecisionReal() const noexcept
 {
     BT_ASSERT_DBG(this->isSinglePrecisionReal());
-    return CommonSinglePrecisionRealField<LibObjT> {this->_libObjPtr()};
+    return CommonSinglePrecisionRealField<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
 CommonDoublePrecisionRealField<LibObjT> CommonField<LibObjT>::asDoublePrecisionReal() const noexcept
 {
     BT_ASSERT_DBG(this->isDoublePrecisionReal());
-    return CommonDoublePrecisionRealField<LibObjT> {this->_libObjPtr()};
+    return CommonDoublePrecisionRealField<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
 CommonStringField<LibObjT> CommonField<LibObjT>::asString() const noexcept
 {
     BT_ASSERT_DBG(this->isString());
-    return CommonStringField<LibObjT> {this->_libObjPtr()};
+    return CommonStringField<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
 CommonStructureField<LibObjT> CommonField<LibObjT>::asStructure() const noexcept
 {
     BT_ASSERT_DBG(this->isStructure());
-    return CommonStructureField<LibObjT> {this->_libObjPtr()};
+    return CommonStructureField<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
 CommonArrayField<LibObjT> CommonField<LibObjT>::asArray() const noexcept
 {
     BT_ASSERT_DBG(this->isArray());
-    return CommonArrayField<LibObjT> {this->_libObjPtr()};
+    return CommonArrayField<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
 CommonDynamicArrayField<LibObjT> CommonField<LibObjT>::asDynamicArray() const noexcept
 {
     BT_ASSERT_DBG(this->isDynamicArray());
-    return CommonDynamicArrayField<LibObjT> {this->_libObjPtr()};
+    return CommonDynamicArrayField<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
 CommonOptionField<LibObjT> CommonField<LibObjT>::asOption() const noexcept
 {
     BT_ASSERT_DBG(this->isOption());
-    return CommonOptionField<LibObjT> {this->_libObjPtr()};
+    return CommonOptionField<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
 CommonVariantField<LibObjT> CommonField<LibObjT>::asVariant() const noexcept
 {
     BT_ASSERT_DBG(this->isVariant());
-    return CommonVariantField<LibObjT> {this->_libObjPtr()};
+    return CommonVariantField<LibObjT> {this->libObjPtr()};
 }
 
 } /* namespace bt2 */
diff --git a/src/cpp-common/bt2/integer-range-set.hpp b/src/cpp-common/bt2/integer-range-set.hpp
index da6b690f..3e88b61a 100644
--- a/src/cpp-common/bt2/integer-range-set.hpp
+++ b/src/cpp-common/bt2/integer-range-set.hpp
@@ -141,13 +141,13 @@ class CommonTraceClass;
 template <typename LibObjT>
 class CommonIntegerRangeSet final : public internal::BorrowedObj<LibObjT>
 {
-    /* Allow operator==() to call `other._libObjPtr()` */
+    /* Allow operator==() to call `other.libObjPtr()` */
     friend class CommonIntegerRangeSet<bt_integer_range_set_unsigned>;
     friend class CommonIntegerRangeSet<const bt_integer_range_set_unsigned>;
     friend class CommonIntegerRangeSet<bt_integer_range_set_signed>;
     friend class CommonIntegerRangeSet<const bt_integer_range_set_signed>;
 
-    /* Allow appendOption() to call `ranges._libObjPtr()` */
+    /* Allow appendOption() to call `ranges.libObjPtr()` */
     friend class CommonVariantWithIntegerSelectorFieldClass<
         bt_field_class,
         ConstVariantWithIntegerSelectorFieldClassOption<
@@ -158,7 +158,7 @@ class CommonIntegerRangeSet final : public internal::BorrowedObj<LibObjT>
         ConstVariantWithIntegerSelectorFieldClassOption<
             const bt_field_class_variant_with_selector_field_integer_signed_option>>;
 
-    /* Allow create*FieldClass() to call `ranges._libObjPtr()` */
+    /* Allow create*FieldClass() to call `ranges.libObjPtr()` */
     friend class CommonTraceClass<bt_trace_class>;
 
 private:
@@ -208,7 +208,7 @@ public:
     template <typename OtherLibObjT>
     bool operator==(const CommonIntegerRangeSet<OtherLibObjT>& other) const noexcept
     {
-        return _Spec::isEqual(this->_libObjPtr(), other._libObjPtr());
+        return _Spec::isEqual(this->libObjPtr(), other.libObjPtr());
     }
 
     template <typename OtherLibObjT>
@@ -221,7 +221,7 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        const auto status = _Spec::addRange(this->_libObjPtr(), lower, upper);
+        const auto status = _Spec::addRange(this->libObjPtr(), lower, upper);
 
         if (status == BT_INTEGER_RANGE_SET_ADD_RANGE_STATUS_MEMORY_ERROR) {
             throw LibMemoryError {};
@@ -230,12 +230,12 @@ public:
 
     std::uint64_t size() const noexcept
     {
-        return _Spec::size(this->_libObjPtr());
+        return _Spec::size(this->libObjPtr());
     }
 
     Range operator[](const std::uint64_t index) const noexcept
     {
-        return Range {_Spec::rangeByIndex(this->_libObjPtr(), index)};
+        return Range {_Spec::rangeByIndex(this->libObjPtr(), index)};
     }
 
     Shared shared() const noexcept
diff --git a/src/cpp-common/bt2/integer-range.hpp b/src/cpp-common/bt2/integer-range.hpp
index 1dff95aa..7e238992 100644
--- a/src/cpp-common/bt2/integer-range.hpp
+++ b/src/cpp-common/bt2/integer-range.hpp
@@ -94,8 +94,8 @@ public:
 
     bool operator==(const _ThisConstIntegerRange& other) const noexcept
     {
-        return internal::ConstIntegerRangeSpec<LibObjT>::isEqual(this->_libObjPtr(),
-                                                                 other._libObjPtr());
+        return internal::ConstIntegerRangeSpec<LibObjT>::isEqual(this->libObjPtr(),
+                                                                 other.libObjPtr());
     }
 
     bool operator!=(const _ThisConstIntegerRange& other) const noexcept
@@ -105,12 +105,12 @@ public:
 
     Value lower() const noexcept
     {
-        return internal::ConstIntegerRangeSpec<LibObjT>::lower(this->_libObjPtr());
+        return internal::ConstIntegerRangeSpec<LibObjT>::lower(this->libObjPtr());
     }
 
     Value upper() const noexcept
     {
-        return internal::ConstIntegerRangeSpec<LibObjT>::upper(this->_libObjPtr());
+        return internal::ConstIntegerRangeSpec<LibObjT>::upper(this->libObjPtr());
     }
 };
 
diff --git a/src/cpp-common/bt2/internal/borrowed-obj.hpp b/src/cpp-common/bt2/internal/borrowed-obj.hpp
index b064a6b2..9cf7617e 100644
--- a/src/cpp-common/bt2/internal/borrowed-obj.hpp
+++ b/src/cpp-common/bt2/internal/borrowed-obj.hpp
@@ -27,7 +27,7 @@ class SharedObj;
  * `LibObjT` is the direct libbabeltrace2 object type, for example
  * `bt_stream_class` or `const bt_value`.
  *
- * Methods of a derived class can call _libObjPtr() to access the
+ * Methods of a derived class can call libObjPtr() to access the
  * libbabeltrace2 object pointer.
  */
 template <typename LibObjT>
@@ -46,15 +46,6 @@ class BorrowedObj
     template <typename AnyLibObjT>
     friend class BorrowedObj;
 
-    /*
-     * This is to allow a `SharedObj<_ThisBorrowedObj, LibObjT, ...>`
-     * instance containing a `BorrowedObj<LibObjT>` instance to access
-     * _libObjPtr() in order to increment/decrement its libbabeltrace2
-     * reference count.
-     */
-    template <typename ObjT, typename AnyLibObjT, typename RefFuncsT>
-    friend class SharedObj;
-
 protected:
     /* libbabeltrace2 object pointer */
     using _LibObjPtr = LibObjT *;
@@ -128,9 +119,8 @@ public:
         return _mLibObjPtr == other._mLibObjPtr;
     }
 
-protected:
     /* Wrapped libbabeltrace2 object pointer */
-    _LibObjPtr _libObjPtr() const noexcept
+    _LibObjPtr libObjPtr() const noexcept
     {
         return _mLibObjPtr;
     }
diff --git a/src/cpp-common/bt2/internal/shared-obj.hpp b/src/cpp-common/bt2/internal/shared-obj.hpp
index 89d1480d..da8df238 100644
--- a/src/cpp-common/bt2/internal/shared-obj.hpp
+++ b/src/cpp-common/bt2/internal/shared-obj.hpp
@@ -185,7 +185,7 @@ private:
     void _getRef() const noexcept
     {
         if (_mObj) {
-            RefFuncsT::get(_mObj->_libObjPtr());
+            RefFuncsT::get(_mObj->libObjPtr());
         }
     }
 
@@ -196,7 +196,7 @@ private:
     void _putRef() const noexcept
     {
         if (_mObj) {
-            RefFuncsT::put(_mObj->_libObjPtr());
+            RefFuncsT::put(_mObj->libObjPtr());
         }
     }
 
diff --git a/src/cpp-common/bt2/message.hpp b/src/cpp-common/bt2/message.hpp
index 8fd1f1d7..4a25821d 100644
--- a/src/cpp-common/bt2/message.hpp
+++ b/src/cpp-common/bt2/message.hpp
@@ -110,7 +110,7 @@ public:
 
     MessageType type() const noexcept
     {
-        return static_cast<MessageType>(bt_message_get_type(this->_libObjPtr()));
+        return static_cast<MessageType>(bt_message_get_type(this->libObjPtr()));
     }
 
     bool isStreamBeginning() const noexcept
@@ -235,27 +235,27 @@ public:
     ConstStream stream() const noexcept
     {
         return ConstStream {internal::CommonStreamBeginningMessageSpec<const bt_message>::stream(
-            this->_libObjPtr())};
+            this->libObjPtr())};
     }
 
     _Stream stream() noexcept
     {
         return _Stream {
-            internal::CommonStreamBeginningMessageSpec<LibObjT>::stream(this->_libObjPtr())};
+            internal::CommonStreamBeginningMessageSpec<LibObjT>::stream(this->libObjPtr())};
     }
 
     void defaultClockSnapshot(const std::uint64_t val) noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        bt_message_stream_beginning_set_default_clock_snapshot(this->_libObjPtr(), val);
+        bt_message_stream_beginning_set_default_clock_snapshot(this->libObjPtr(), val);
     }
 
     nonstd::optional<ConstClockSnapshot> defaultClockSnapshot() const noexcept
     {
         const bt_clock_snapshot *libObjPtr;
         const auto state = bt_message_stream_beginning_borrow_default_clock_snapshot_const(
-            this->_libObjPtr(), &libObjPtr);
+            this->libObjPtr(), &libObjPtr);
 
         if (state == BT_MESSAGE_STREAM_CLOCK_SNAPSHOT_STATE_KNOWN) {
             return ConstClockSnapshot {libObjPtr};
@@ -337,26 +337,26 @@ public:
     ConstStream stream() const noexcept
     {
         return ConstStream {
-            internal::CommonStreamEndMessageSpec<const bt_message>::stream(this->_libObjPtr())};
+            internal::CommonStreamEndMessageSpec<const bt_message>::stream(this->libObjPtr())};
     }
 
     _Stream stream() noexcept
     {
-        return _Stream {internal::CommonStreamEndMessageSpec<LibObjT>::stream(this->_libObjPtr())};
+        return _Stream {internal::CommonStreamEndMessageSpec<LibObjT>::stream(this->libObjPtr())};
     }
 
     void defaultClockSnapshot(const std::uint64_t val) noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        bt_message_stream_end_set_default_clock_snapshot(this->_libObjPtr(), val);
+        bt_message_stream_end_set_default_clock_snapshot(this->libObjPtr(), val);
     }
 
     nonstd::optional<ConstClockSnapshot> defaultClockSnapshot() const noexcept
     {
         const bt_clock_snapshot *libObjPtr;
         const auto state = bt_message_stream_end_borrow_default_clock_snapshot_const(
-            this->_libObjPtr(), &libObjPtr);
+            this->libObjPtr(), &libObjPtr);
 
         if (state == BT_MESSAGE_STREAM_CLOCK_SNAPSHOT_STATE_KNOWN) {
             return ConstClockSnapshot {libObjPtr};
@@ -438,26 +438,26 @@ public:
     ConstPacket packet() const noexcept
     {
         return ConstPacket {internal::CommonPacketBeginningMessageSpec<const bt_message>::packet(
-            this->_libObjPtr())};
+            this->libObjPtr())};
     }
 
     _Packet packet() noexcept
     {
         return _Packet {
-            internal::CommonPacketBeginningMessageSpec<LibObjT>::packet(this->_libObjPtr())};
+            internal::CommonPacketBeginningMessageSpec<LibObjT>::packet(this->libObjPtr())};
     }
 
     void defaultClockSnapshot(const std::uint64_t val) noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        bt_message_packet_beginning_set_default_clock_snapshot(this->_libObjPtr(), val);
+        bt_message_packet_beginning_set_default_clock_snapshot(this->libObjPtr(), val);
     }
 
     ConstClockSnapshot defaultClockSnapshot() const noexcept
     {
         const auto libObjPtr =
-            bt_message_packet_beginning_borrow_default_clock_snapshot_const(this->_libObjPtr());
+            bt_message_packet_beginning_borrow_default_clock_snapshot_const(this->libObjPtr());
 
         return ConstClockSnapshot {libObjPtr};
     }
@@ -535,25 +535,25 @@ public:
     ConstPacket packet() const noexcept
     {
         return ConstPacket {
-            internal::CommonPacketEndMessageSpec<const bt_message>::packet(this->_libObjPtr())};
+            internal::CommonPacketEndMessageSpec<const bt_message>::packet(this->libObjPtr())};
     }
 
     _Packet packet() noexcept
     {
-        return _Packet {internal::CommonPacketEndMessageSpec<LibObjT>::packet(this->_libObjPtr())};
+        return _Packet {internal::CommonPacketEndMessageSpec<LibObjT>::packet(this->libObjPtr())};
     }
 
     void defaultClockSnapshot(const std::uint64_t val) noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        bt_message_packet_end_set_default_clock_snapshot(this->_libObjPtr(), val);
+        bt_message_packet_end_set_default_clock_snapshot(this->libObjPtr(), val);
     }
 
     ConstClockSnapshot defaultClockSnapshot() const noexcept
     {
         const auto libObjPtr =
-            bt_message_packet_end_borrow_default_clock_snapshot_const(this->_libObjPtr());
+            bt_message_packet_end_borrow_default_clock_snapshot_const(this->libObjPtr());
 
         return ConstClockSnapshot {libObjPtr};
     }
@@ -630,18 +630,18 @@ public:
     ConstEvent event() const noexcept
     {
         return ConstEvent {
-            internal::CommonEventMessageSpec<const bt_message>::event(this->_libObjPtr())};
+            internal::CommonEventMessageSpec<const bt_message>::event(this->libObjPtr())};
     }
 
     _Event event() noexcept
     {
-        return _Event {internal::CommonEventMessageSpec<LibObjT>::event(this->_libObjPtr())};
+        return _Event {internal::CommonEventMessageSpec<LibObjT>::event(this->libObjPtr())};
     }
 
     ConstClockSnapshot defaultClockSnapshot() const noexcept
     {
         const auto libObjPtr =
-            bt_message_event_borrow_default_clock_snapshot_const(this->_libObjPtr());
+            bt_message_event_borrow_default_clock_snapshot_const(this->libObjPtr());
 
         return ConstClockSnapshot {libObjPtr};
     }
@@ -719,20 +719,20 @@ public:
     ConstStream stream() const noexcept
     {
         return ConstStream {internal::CommonDiscardedEventsMessageSpec<const bt_message>::stream(
-            this->_libObjPtr())};
+            this->libObjPtr())};
     }
 
     _Stream stream() noexcept
     {
         return _Stream {
-            internal::CommonDiscardedEventsMessageSpec<LibObjT>::stream(this->_libObjPtr())};
+            internal::CommonDiscardedEventsMessageSpec<LibObjT>::stream(this->libObjPtr())};
     }
 
     ConstClockSnapshot beginningDefaultClockSnapshot() const noexcept
     {
         const auto libObjPtr =
             bt_message_discarded_events_borrow_beginning_default_clock_snapshot_const(
-                this->_libObjPtr());
+                this->libObjPtr());
 
         return ConstClockSnapshot {libObjPtr};
     }
@@ -740,7 +740,7 @@ public:
     ConstClockSnapshot endDefaultClockSnapshot() const noexcept
     {
         const auto libObjPtr =
-            bt_message_discarded_events_borrow_end_default_clock_snapshot_const(this->_libObjPtr());
+            bt_message_discarded_events_borrow_end_default_clock_snapshot_const(this->libObjPtr());
 
         return ConstClockSnapshot {libObjPtr};
     }
@@ -749,13 +749,13 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        bt_message_discarded_events_set_count(this->_libObjPtr(), count);
+        bt_message_discarded_events_set_count(this->libObjPtr(), count);
     }
 
     nonstd::optional<std::uint64_t> count() const noexcept
     {
         std::uint64_t count;
-        const auto avail = bt_message_discarded_events_get_count(this->_libObjPtr(), &count);
+        const auto avail = bt_message_discarded_events_get_count(this->libObjPtr(), &count);
 
         if (avail) {
             return count;
@@ -837,28 +837,28 @@ public:
     ConstStream stream() const noexcept
     {
         return ConstStream {internal::CommonDiscardedPacketsMessageSpec<const bt_message>::stream(
-            this->_libObjPtr())};
+            this->libObjPtr())};
     }
 
     _Stream stream() noexcept
     {
         return _Stream {
-            internal::CommonDiscardedPacketsMessageSpec<LibObjT>::stream(this->_libObjPtr())};
+            internal::CommonDiscardedPacketsMessageSpec<LibObjT>::stream(this->libObjPtr())};
     }
 
     ConstClockSnapshot beginningDefaultClockSnapshot() const noexcept
     {
         const auto libObjPtr =
             bt_message_discarded_packets_borrow_beginning_default_clock_snapshot_const(
-                this->_libObjPtr());
+                this->libObjPtr());
 
         return ConstClockSnapshot {libObjPtr};
     }
 
     ConstClockSnapshot endDefaultClockSnapshot() const noexcept
     {
-        const auto libObjPtr = bt_message_discarded_packets_borrow_end_default_clock_snapshot_const(
-            this->_libObjPtr());
+        const auto libObjPtr =
+            bt_message_discarded_packets_borrow_end_default_clock_snapshot_const(this->libObjPtr());
 
         return ConstClockSnapshot {libObjPtr};
     }
@@ -867,13 +867,13 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        bt_message_discarded_packets_set_count(this->_libObjPtr(), count);
+        bt_message_discarded_packets_set_count(this->libObjPtr(), count);
     }
 
     nonstd::optional<std::uint64_t> count() const noexcept
     {
         std::uint64_t count;
-        const auto avail = bt_message_discarded_packets_get_count(this->_libObjPtr(), &count);
+        const auto avail = bt_message_discarded_packets_get_count(this->libObjPtr(), &count);
 
         if (avail) {
             return count;
@@ -926,7 +926,7 @@ public:
     ConstClockSnapshot clockSnapshot() const noexcept
     {
         const auto libObjPtr =
-            bt_message_message_iterator_inactivity_borrow_clock_snapshot_const(this->_libObjPtr());
+            bt_message_message_iterator_inactivity_borrow_clock_snapshot_const(this->libObjPtr());
 
         return ConstClockSnapshot {libObjPtr};
     }
@@ -945,42 +945,42 @@ template <typename LibObjT>
 CommonStreamBeginningMessage<LibObjT> CommonMessage<LibObjT>::asStreamBeginning() const noexcept
 {
     BT_ASSERT_DBG(this->isStreamBeginning());
-    return CommonStreamBeginningMessage<LibObjT> {this->_libObjPtr()};
+    return CommonStreamBeginningMessage<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
 CommonStreamEndMessage<LibObjT> CommonMessage<LibObjT>::asStreamEnd() const noexcept
 {
     BT_ASSERT_DBG(this->isStreamEnd());
-    return CommonStreamEndMessage<LibObjT> {this->_libObjPtr()};
+    return CommonStreamEndMessage<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
 CommonPacketBeginningMessage<LibObjT> CommonMessage<LibObjT>::asPacketBeginning() const noexcept
 {
     BT_ASSERT_DBG(this->isPacketBeginning());
-    return CommonPacketBeginningMessage<LibObjT> {this->_libObjPtr()};
+    return CommonPacketBeginningMessage<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
 CommonPacketEndMessage<LibObjT> CommonMessage<LibObjT>::asPacketEnd() const noexcept
 {
     BT_ASSERT_DBG(this->isPacketEnd());
-    return CommonPacketEndMessage<LibObjT> {this->_libObjPtr()};
+    return CommonPacketEndMessage<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
 CommonEventMessage<LibObjT> CommonMessage<LibObjT>::asEvent() const noexcept
 {
     BT_ASSERT_DBG(this->isEvent());
-    return CommonEventMessage<LibObjT> {this->_libObjPtr()};
+    return CommonEventMessage<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
 CommonDiscardedEventsMessage<LibObjT> CommonMessage<LibObjT>::asDiscardedEvents() const noexcept
 {
     BT_ASSERT_DBG(this->isDiscardedEvents());
-    return CommonDiscardedEventsMessage<LibObjT> {this->_libObjPtr()};
+    return CommonDiscardedEventsMessage<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
@@ -988,7 +988,7 @@ CommonMessageIteratorInactivityMessage<LibObjT>
 CommonMessage<LibObjT>::asMessageIteratorInactivity() const noexcept
 {
     BT_ASSERT_DBG(this->isMessageIteratorInactivity());
-    return CommonMessageIteratorInactivityMessage<LibObjT> {this->_libObjPtr()};
+    return CommonMessageIteratorInactivityMessage<LibObjT> {this->libObjPtr()};
 }
 
 } /* namespace bt2 */
diff --git a/src/cpp-common/bt2/trace-ir.hpp b/src/cpp-common/bt2/trace-ir.hpp
index 41800d35..94d57dc3 100644
--- a/src/cpp-common/bt2/trace-ir.hpp
+++ b/src/cpp-common/bt2/trace-ir.hpp
@@ -171,7 +171,7 @@ public:
 
     nonstd::optional<ConstStructureField> payloadField() const noexcept
     {
-        const auto libObjPtr = _ConstSpec::payloadField(this->_libObjPtr());
+        const auto libObjPtr = _ConstSpec::payloadField(this->libObjPtr());
 
         if (libObjPtr) {
             return ConstStructureField {libObjPtr};
@@ -182,7 +182,7 @@ public:
 
     nonstd::optional<_StructureField> payloadField() noexcept
     {
-        const auto libObjPtr = _Spec::payloadField(this->_libObjPtr());
+        const auto libObjPtr = _Spec::payloadField(this->libObjPtr());
 
         if (libObjPtr) {
             return _StructureField {libObjPtr};
@@ -193,7 +193,7 @@ public:
 
     nonstd::optional<ConstStructureField> specificContextField() const noexcept
     {
-        const auto libObjPtr = _ConstSpec::specificContextField(this->_libObjPtr());
+        const auto libObjPtr = _ConstSpec::specificContextField(this->libObjPtr());
 
         if (libObjPtr) {
             return ConstStructureField {libObjPtr};
@@ -204,7 +204,7 @@ public:
 
     nonstd::optional<_StructureField> specificContextField() noexcept
     {
-        const auto libObjPtr = _Spec::specificContextField(this->_libObjPtr());
+        const auto libObjPtr = _Spec::specificContextField(this->libObjPtr());
 
         if (libObjPtr) {
             return _StructureField {libObjPtr};
@@ -215,7 +215,7 @@ public:
 
     nonstd::optional<ConstStructureField> commonContextField() const noexcept
     {
-        const auto libObjPtr = _ConstSpec::commonContextField(this->_libObjPtr());
+        const auto libObjPtr = _ConstSpec::commonContextField(this->libObjPtr());
 
         if (libObjPtr) {
             return ConstStructureField {libObjPtr};
@@ -226,7 +226,7 @@ public:
 
     nonstd::optional<_StructureField> commonContextField() noexcept
     {
-        const auto libObjPtr = _Spec::commonContextField(this->_libObjPtr());
+        const auto libObjPtr = _Spec::commonContextField(this->libObjPtr());
 
         if (libObjPtr) {
             return _StructureField {libObjPtr};
@@ -330,7 +330,7 @@ public:
 
     nonstd::optional<ConstStructureField> contextField() const noexcept
     {
-        const auto libObjPtr = _ConstSpec::contextField(this->_libObjPtr());
+        const auto libObjPtr = _ConstSpec::contextField(this->libObjPtr());
 
         if (libObjPtr) {
             return ConstStructureField {libObjPtr};
@@ -341,7 +341,7 @@ public:
 
     nonstd::optional<_StructureField> contextField() noexcept
     {
-        const auto libObjPtr = _Spec::contextField(this->_libObjPtr());
+        const auto libObjPtr = _Spec::contextField(this->libObjPtr());
 
         if (libObjPtr) {
             return _StructureField {libObjPtr};
@@ -362,7 +362,7 @@ using ConstPacket = CommonPacket<const bt_packet>;
 template <typename LibObjT>
 nonstd::optional<ConstPacket> CommonEvent<LibObjT>::packet() const noexcept
 {
-    const auto libObjPtr = _ConstSpec::packet(this->_libObjPtr());
+    const auto libObjPtr = _ConstSpec::packet(this->libObjPtr());
 
     if (libObjPtr) {
         return ConstPacket {libObjPtr};
@@ -374,7 +374,7 @@ nonstd::optional<ConstPacket> CommonEvent<LibObjT>::packet() const noexcept
 template <typename LibObjT>
 nonstd::optional<typename CommonEvent<LibObjT>::_Packet> CommonEvent<LibObjT>::packet() noexcept
 {
-    const auto libObjPtr = _Spec::packet(this->_libObjPtr());
+    const auto libObjPtr = _Spec::packet(this->libObjPtr());
 
     if (libObjPtr) {
         return _Packet {libObjPtr};
@@ -487,7 +487,7 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        const auto libObjPtr = bt_packet_create(this->_libObjPtr());
+        const auto libObjPtr = bt_packet_create(this->libObjPtr());
 
         internal::validateCreatedObjPtr(libObjPtr);
         return Packet::Shared {Packet {libObjPtr}};
@@ -500,14 +500,14 @@ public:
 
     std::uint64_t id() const noexcept
     {
-        return bt_stream_get_id(this->_libObjPtr());
+        return bt_stream_get_id(this->libObjPtr());
     }
 
     void name(const char * const name)
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        const auto status = bt_stream_set_name(this->_libObjPtr(), name);
+        const auto status = bt_stream_set_name(this->libObjPtr(), name);
 
         if (status == BT_STREAM_SET_NAME_STATUS_MEMORY_ERROR) {
             throw LibMemoryError {};
@@ -521,7 +521,7 @@ public:
 
     nonstd::optional<bpstd::string_view> name() const noexcept
     {
-        const auto name = bt_stream_get_name(this->_libObjPtr());
+        const auto name = bt_stream_get_name(this->libObjPtr());
 
         if (name) {
             return name;
@@ -535,17 +535,17 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        bt_stream_set_user_attributes(this->_libObjPtr(), userAttrs._libObjPtr());
+        bt_stream_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
     }
 
     ConstMapValue userAttributes() const noexcept
     {
-        return ConstMapValue {_ConstSpec::userAttributes(this->_libObjPtr())};
+        return ConstMapValue {_ConstSpec::userAttributes(this->libObjPtr())};
     }
 
     UserAttributes userAttributes() noexcept
     {
-        return UserAttributes {_Spec::userAttributes(this->_libObjPtr())};
+        return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
     }
 
     Shared shared() const noexcept
@@ -560,25 +560,25 @@ using ConstStream = CommonStream<const bt_stream>;
 template <typename LibObjT>
 ConstStream CommonEvent<LibObjT>::stream() const noexcept
 {
-    return ConstStream {_ConstSpec::stream(this->_libObjPtr())};
+    return ConstStream {_ConstSpec::stream(this->libObjPtr())};
 }
 
 template <typename LibObjT>
 typename CommonEvent<LibObjT>::_Stream CommonEvent<LibObjT>::stream() noexcept
 {
-    return _Stream {_Spec::stream(this->_libObjPtr())};
+    return _Stream {_Spec::stream(this->libObjPtr())};
 }
 
 template <typename LibObjT>
 ConstStream CommonPacket<LibObjT>::stream() const noexcept
 {
-    return ConstStream {_ConstSpec::stream(this->_libObjPtr())};
+    return ConstStream {_ConstSpec::stream(this->libObjPtr())};
 }
 
 template <typename LibObjT>
 typename CommonPacket<LibObjT>::_Stream CommonPacket<LibObjT>::stream() noexcept
 {
-    return _Stream {_Spec::stream(this->_libObjPtr())};
+    return _Stream {_Spec::stream(this->libObjPtr())};
 }
 
 namespace internal {
@@ -656,7 +656,7 @@ struct CommonTraceSpec<const bt_trace> final
 template <typename LibObjT>
 class CommonTrace final : public internal::BorrowedObj<LibObjT>
 {
-    /* Allow instantiate() to call `trace._libObjPtr()` */
+    /* Allow instantiate() to call `trace.libObjPtr()` */
     friend class CommonStreamClass<bt_stream_class>;
 
 private:
@@ -709,7 +709,7 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        const auto status = bt_trace_set_name(this->_libObjPtr(), name);
+        const auto status = bt_trace_set_name(this->libObjPtr(), name);
 
         if (status == BT_TRACE_SET_NAME_STATUS_MEMORY_ERROR) {
             throw LibMemoryError {};
@@ -723,7 +723,7 @@ public:
 
     nonstd::optional<bpstd::string_view> name() const noexcept
     {
-        const auto name = bt_trace_get_name(this->_libObjPtr());
+        const auto name = bt_trace_get_name(this->libObjPtr());
 
         if (name) {
             return name;
@@ -734,12 +734,12 @@ public:
 
     void uuid(const std::uint8_t * const uuid) noexcept
     {
-        bt_trace_set_uuid(this->_libObjPtr(), uuid);
+        bt_trace_set_uuid(this->libObjPtr(), uuid);
     }
 
     nonstd::optional<bt2_common::UuidView> uuid() const noexcept
     {
-        const auto uuid = bt_trace_get_uuid(this->_libObjPtr());
+        const auto uuid = bt_trace_get_uuid(this->libObjPtr());
 
         if (uuid) {
             return bt2_common::UuidView {uuid};
@@ -750,22 +750,22 @@ public:
 
     std::uint64_t size() const noexcept
     {
-        return bt_trace_get_stream_count(this->_libObjPtr());
+        return bt_trace_get_stream_count(this->libObjPtr());
     }
 
     ConstStream operator[](const std::uint64_t index) const noexcept
     {
-        return ConstStream {_ConstSpec::streamByIndex(this->_libObjPtr(), index)};
+        return ConstStream {_ConstSpec::streamByIndex(this->libObjPtr(), index)};
     }
 
     _Stream operator[](const std::uint64_t index) noexcept
     {
-        return _Stream {_Spec::streamByIndex(this->_libObjPtr(), index)};
+        return _Stream {_Spec::streamByIndex(this->libObjPtr(), index)};
     }
 
     nonstd::optional<ConstStream> streamById(const std::uint64_t id) const noexcept
     {
-        const auto libObjPtr = _ConstSpec::streamById(this->_libObjPtr(), id);
+        const auto libObjPtr = _ConstSpec::streamById(this->libObjPtr(), id);
 
         if (libObjPtr) {
             return ConstStream {libObjPtr};
@@ -776,7 +776,7 @@ public:
 
     nonstd::optional<_Stream> streamById(const std::uint64_t id) noexcept
     {
-        const auto libObjPtr = _Spec::streamById(this->_libObjPtr(), id);
+        const auto libObjPtr = _Spec::streamById(this->libObjPtr(), id);
 
         if (libObjPtr) {
             return _Stream {libObjPtr};
@@ -789,7 +789,7 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        const auto status = bt_trace_set_environment_entry_integer(this->_libObjPtr(), name, val);
+        const auto status = bt_trace_set_environment_entry_integer(this->libObjPtr(), name, val);
 
         if (status == BT_TRACE_SET_ENVIRONMENT_ENTRY_STATUS_MEMORY_ERROR) {
             throw LibMemoryError {};
@@ -805,7 +805,7 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        const auto status = bt_trace_set_environment_entry_string(this->_libObjPtr(), name, val);
+        const auto status = bt_trace_set_environment_entry_string(this->libObjPtr(), name, val);
 
         if (status == BT_TRACE_SET_ENVIRONMENT_ENTRY_STATUS_MEMORY_ERROR) {
             throw LibMemoryError {};
@@ -829,7 +829,7 @@ public:
 
     std::uint64_t environmentSize() const noexcept
     {
-        return bt_trace_get_environment_entry_count(this->_libObjPtr());
+        return bt_trace_get_environment_entry_count(this->libObjPtr());
     }
 
     ConstEnvironmentEntry environmentEntry(const std::uint64_t index) const noexcept
@@ -837,7 +837,7 @@ public:
         const char *name;
         const bt_value *libObjPtr;
 
-        bt_trace_borrow_environment_entry_by_index_const(this->_libObjPtr(), index, &name,
+        bt_trace_borrow_environment_entry_by_index_const(this->libObjPtr(), index, &name,
                                                          &libObjPtr);
         return ConstEnvironmentEntry {name, ConstValue {libObjPtr}};
     }
@@ -845,7 +845,7 @@ public:
     nonstd::optional<ConstValue> environmentEntry(const char * const name) const noexcept
     {
         const auto libObjPtr =
-            bt_trace_borrow_environment_entry_value_by_name_const(this->_libObjPtr(), name);
+            bt_trace_borrow_environment_entry_value_by_name_const(this->libObjPtr(), name);
 
         if (libObjPtr) {
             return ConstValue {libObjPtr};
@@ -864,17 +864,17 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        bt_trace_set_user_attributes(this->_libObjPtr(), userAttrs._libObjPtr());
+        bt_trace_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
     }
 
     ConstMapValue userAttributes() const noexcept
     {
-        return ConstMapValue {_ConstSpec::userAttributes(this->_libObjPtr())};
+        return ConstMapValue {_ConstSpec::userAttributes(this->libObjPtr())};
     }
 
     UserAttributes userAttributes() noexcept
     {
-        return UserAttributes {_Spec::userAttributes(this->_libObjPtr())};
+        return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
     }
 
     Shared shared() const noexcept
@@ -889,13 +889,13 @@ using ConstTrace = CommonTrace<const bt_trace>;
 template <typename LibObjT>
 ConstTrace CommonStream<LibObjT>::trace() const noexcept
 {
-    return ConstTrace {_ConstSpec::trace(this->_libObjPtr())};
+    return ConstTrace {_ConstSpec::trace(this->libObjPtr())};
 }
 
 template <typename LibObjT>
 typename CommonStream<LibObjT>::_Trace CommonStream<LibObjT>::trace() noexcept
 {
-    return _Trace {_Spec::trace(this->_libObjPtr())};
+    return _Trace {_Spec::trace(this->libObjPtr())};
 }
 
 namespace internal {
@@ -1035,14 +1035,14 @@ public:
 
     std::uint64_t id() const noexcept
     {
-        return bt_event_class_get_id(this->_libObjPtr());
+        return bt_event_class_get_id(this->libObjPtr());
     }
 
     void name(const char * const name)
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        const auto status = bt_event_class_set_name(this->_libObjPtr(), name);
+        const auto status = bt_event_class_set_name(this->libObjPtr(), name);
 
         if (status == BT_EVENT_CLASS_SET_NAME_STATUS_MEMORY_ERROR) {
             throw LibMemoryError {};
@@ -1056,7 +1056,7 @@ public:
 
     nonstd::optional<bpstd::string_view> name() const noexcept
     {
-        const auto name = bt_event_class_get_name(this->_libObjPtr());
+        const auto name = bt_event_class_get_name(this->libObjPtr());
 
         if (name) {
             return name;
@@ -1069,14 +1069,14 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        bt_event_class_set_log_level(this->_libObjPtr(),
+        bt_event_class_set_log_level(this->libObjPtr(),
                                      static_cast<bt_event_class_log_level>(logLevel));
     }
 
     nonstd::optional<LogLevel> logLevel() const noexcept
     {
         bt_event_class_log_level libLogLevel;
-        const auto avail = bt_event_class_get_log_level(this->_libObjPtr(), &libLogLevel);
+        const auto avail = bt_event_class_get_log_level(this->libObjPtr(), &libLogLevel);
 
         if (avail == BT_PROPERTY_AVAILABILITY_AVAILABLE) {
             return static_cast<LogLevel>(libLogLevel);
@@ -1089,7 +1089,7 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        const auto status = bt_event_class_set_emf_uri(this->_libObjPtr(), emfUri);
+        const auto status = bt_event_class_set_emf_uri(this->libObjPtr(), emfUri);
 
         if (status == BT_EVENT_CLASS_SET_EMF_URI_STATUS_MEMORY_ERROR) {
             throw LibMemoryError {};
@@ -1103,7 +1103,7 @@ public:
 
     nonstd::optional<bpstd::string_view> emfUri() const noexcept
     {
-        const auto emfUri = bt_event_class_get_emf_uri(this->_libObjPtr());
+        const auto emfUri = bt_event_class_get_emf_uri(this->libObjPtr());
 
         if (emfUri) {
             return emfUri;
@@ -1117,7 +1117,7 @@ public:
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
         const auto status =
-            bt_event_class_set_payload_field_class(this->_libObjPtr(), fc._libObjPtr());
+            bt_event_class_set_payload_field_class(this->libObjPtr(), fc.libObjPtr());
 
         if (status == BT_EVENT_CLASS_SET_FIELD_CLASS_STATUS_MEMORY_ERROR) {
             throw LibMemoryError {};
@@ -1126,7 +1126,7 @@ public:
 
     nonstd::optional<ConstStructureFieldClass> payloadFieldClass() const noexcept
     {
-        const auto libObjPtr = _ConstSpec::payloadFieldClass(this->_libObjPtr());
+        const auto libObjPtr = _ConstSpec::payloadFieldClass(this->libObjPtr());
 
         if (libObjPtr) {
             return ConstStructureFieldClass {libObjPtr};
@@ -1137,7 +1137,7 @@ public:
 
     nonstd::optional<_StructureFieldClass> payloadFieldClass() noexcept
     {
-        const auto libObjPtr = _Spec::payloadFieldClass(this->_libObjPtr());
+        const auto libObjPtr = _Spec::payloadFieldClass(this->libObjPtr());
 
         if (libObjPtr) {
             return _StructureFieldClass {libObjPtr};
@@ -1151,7 +1151,7 @@ public:
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
         const auto status =
-            bt_event_class_set_specific_context_field_class(this->_libObjPtr(), fc._libObjPtr());
+            bt_event_class_set_specific_context_field_class(this->libObjPtr(), fc.libObjPtr());
 
         if (status == BT_EVENT_CLASS_SET_FIELD_CLASS_STATUS_MEMORY_ERROR) {
             throw LibMemoryError {};
@@ -1160,7 +1160,7 @@ public:
 
     nonstd::optional<ConstStructureFieldClass> specificContextFieldClass() const noexcept
     {
-        const auto libObjPtr = _ConstSpec::specificContextFieldClass(this->_libObjPtr());
+        const auto libObjPtr = _ConstSpec::specificContextFieldClass(this->libObjPtr());
 
         if (libObjPtr) {
             return ConstStructureFieldClass {libObjPtr};
@@ -1171,7 +1171,7 @@ public:
 
     nonstd::optional<_StructureFieldClass> specificContextFieldClass() noexcept
     {
-        const auto libObjPtr = _Spec::specificContextFieldClass(this->_libObjPtr());
+        const auto libObjPtr = _Spec::specificContextFieldClass(this->libObjPtr());
 
         if (libObjPtr) {
             return _StructureFieldClass {libObjPtr};
@@ -1185,17 +1185,17 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        bt_event_class_set_user_attributes(this->_libObjPtr(), userAttrs._libObjPtr());
+        bt_event_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
     }
 
     ConstMapValue userAttributes() const noexcept
     {
-        return ConstMapValue {_ConstSpec::userAttributes(this->_libObjPtr())};
+        return ConstMapValue {_ConstSpec::userAttributes(this->libObjPtr())};
     }
 
     UserAttributes userAttributes() noexcept
     {
-        return UserAttributes {_Spec::userAttributes(this->_libObjPtr())};
+        return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
     }
 
     Shared shared() const noexcept
@@ -1210,13 +1210,13 @@ using ConstEventClass = CommonEventClass<const bt_event_class>;
 template <typename LibObjT>
 ConstEventClass CommonEvent<LibObjT>::cls() const noexcept
 {
-    return ConstEventClass {_ConstSpec::cls(this->_libObjPtr())};
+    return ConstEventClass {_ConstSpec::cls(this->libObjPtr())};
 }
 
 template <typename LibObjT>
 typename CommonEvent<LibObjT>::Class CommonEvent<LibObjT>::cls() noexcept
 {
-    return Class {_Spec::cls(this->_libObjPtr())};
+    return Class {_Spec::cls(this->libObjPtr())};
 }
 
 namespace internal {
@@ -1378,7 +1378,7 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        const auto libObjPtr = bt_stream_create(this->_libObjPtr(), trace._libObjPtr());
+        const auto libObjPtr = bt_stream_create(this->libObjPtr(), trace.libObjPtr());
 
         internal::validateCreatedObjPtr(libObjPtr);
         return Stream::Shared {Stream {libObjPtr}};
@@ -1388,7 +1388,7 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        const auto libObjPtr = bt_stream_create_with_id(this->_libObjPtr(), trace._libObjPtr(), id);
+        const auto libObjPtr = bt_stream_create_with_id(this->libObjPtr(), trace.libObjPtr(), id);
 
         internal::validateCreatedObjPtr(libObjPtr);
         return Stream::Shared {Stream {libObjPtr}};
@@ -1398,7 +1398,7 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        const auto libObjPtr = bt_event_class_create(this->_libObjPtr());
+        const auto libObjPtr = bt_event_class_create(this->libObjPtr());
 
         internal::validateCreatedObjPtr(libObjPtr);
         return EventClass::Shared {EventClass {libObjPtr}};
@@ -1408,7 +1408,7 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        const auto libObjPtr = bt_event_class_create_with_id(this->_libObjPtr(), id);
+        const auto libObjPtr = bt_event_class_create_with_id(this->libObjPtr(), id);
 
         internal::validateCreatedObjPtr(libObjPtr);
         return EventClass::Shared {EventClass {libObjPtr}};
@@ -1419,14 +1419,14 @@ public:
 
     std::uint64_t id() const noexcept
     {
-        return bt_stream_class_get_id(this->_libObjPtr());
+        return bt_stream_class_get_id(this->libObjPtr());
     }
 
     void name(const char * const name)
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        const auto status = bt_stream_class_set_name(this->_libObjPtr(), name);
+        const auto status = bt_stream_class_set_name(this->libObjPtr(), name);
 
         if (status == BT_STREAM_CLASS_SET_NAME_STATUS_MEMORY_ERROR) {
             throw LibMemoryError {};
@@ -1440,7 +1440,7 @@ public:
 
     nonstd::optional<bpstd::string_view> name() const noexcept
     {
-        const auto name = bt_stream_class_get_name(this->_libObjPtr());
+        const auto name = bt_stream_class_get_name(this->libObjPtr());
 
         if (name) {
             return name;
@@ -1453,27 +1453,27 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        bt_stream_class_set_assigns_automatic_event_class_id(this->_libObjPtr(),
+        bt_stream_class_set_assigns_automatic_event_class_id(this->libObjPtr(),
                                                              static_cast<bt_bool>(val));
     }
 
     bool assignsAutomaticEventClassId() const noexcept
     {
         return static_cast<bool>(
-            bt_stream_class_assigns_automatic_event_class_id(this->_libObjPtr()));
+            bt_stream_class_assigns_automatic_event_class_id(this->libObjPtr()));
     }
 
     void assignsAutomaticStreamId(const bool val) noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        bt_stream_class_set_assigns_automatic_stream_id(this->_libObjPtr(),
+        bt_stream_class_set_assigns_automatic_stream_id(this->libObjPtr(),
                                                         static_cast<bt_bool>(val));
     }
 
     bool assignsAutomaticStreamId() const noexcept
     {
-        return static_cast<bool>(bt_stream_class_assigns_automatic_stream_id(this->_libObjPtr()));
+        return static_cast<bool>(bt_stream_class_assigns_automatic_stream_id(this->libObjPtr()));
     }
 
     void supportsPackets(const bool supportsPackets, const bool withBeginningDefaultClkSnapshot,
@@ -1481,7 +1481,7 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        bt_stream_class_set_supports_packets(this->_libObjPtr(),
+        bt_stream_class_set_supports_packets(this->libObjPtr(),
                                              static_cast<bt_bool>(supportsPackets),
                                              static_cast<bt_bool>(withBeginningDefaultClkSnapshot),
                                              static_cast<bt_bool>(withEndDefaultClkSnapshot));
@@ -1489,19 +1489,19 @@ public:
 
     bool supportsPackets() const noexcept
     {
-        return static_cast<bool>(bt_stream_class_supports_packets(this->_libObjPtr()));
+        return static_cast<bool>(bt_stream_class_supports_packets(this->libObjPtr()));
     }
 
     bool packetsHaveBeginningClockSnapshot() const noexcept
     {
         return static_cast<bool>(
-            bt_stream_class_packets_have_beginning_default_clock_snapshot(this->_libObjPtr()));
+            bt_stream_class_packets_have_beginning_default_clock_snapshot(this->libObjPtr()));
     }
 
     bool packetsHaveEndClockSnapshot() const noexcept
     {
         return static_cast<bool>(
-            bt_stream_class_packets_have_end_default_clock_snapshot(this->_libObjPtr()));
+            bt_stream_class_packets_have_end_default_clock_snapshot(this->libObjPtr()));
     }
 
     void supportsDiscardedEvents(const bool supportsDiscardedEvents,
@@ -1510,19 +1510,19 @@ public:
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
         bt_stream_class_set_supports_discarded_events(
-            this->_libObjPtr(), static_cast<bt_bool>(supportsPackets),
+            this->libObjPtr(), static_cast<bt_bool>(supportsPackets),
             static_cast<bt_bool>(withDefaultClkSnapshots));
     }
 
     bool supportsDiscardedEvents() const noexcept
     {
-        return static_cast<bool>(bt_stream_class_supports_discarded_events(this->_libObjPtr()));
+        return static_cast<bool>(bt_stream_class_supports_discarded_events(this->libObjPtr()));
     }
 
     bool discardedEventsHaveDefaultClockSnapshots() const noexcept
     {
         return static_cast<bool>(
-            bt_stream_class_discarded_events_have_default_clock_snapshots(this->_libObjPtr()));
+            bt_stream_class_discarded_events_have_default_clock_snapshots(this->libObjPtr()));
     }
 
     void supportsDiscardedPackets(const bool supportsDiscardedPackets,
@@ -1531,19 +1531,19 @@ public:
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
         bt_stream_class_set_supports_discarded_packets(
-            this->_libObjPtr(), static_cast<bt_bool>(supportsPackets),
+            this->libObjPtr(), static_cast<bt_bool>(supportsPackets),
             static_cast<bt_bool>(withDefaultClkSnapshots));
     }
 
     bool supportsDiscardedPackets() const noexcept
     {
-        return static_cast<bool>(bt_stream_class_supports_discarded_packets(this->_libObjPtr()));
+        return static_cast<bool>(bt_stream_class_supports_discarded_packets(this->libObjPtr()));
     }
 
     bool discardedPacketsHaveDefaultClockSnapshots() const noexcept
     {
         return static_cast<bool>(
-            bt_stream_class_discarded_packets_have_default_clock_snapshots(this->_libObjPtr()));
+            bt_stream_class_discarded_packets_have_default_clock_snapshots(this->libObjPtr()));
     }
 
     void defaultClockClass(const ClockClass& clkCls)
@@ -1551,14 +1551,14 @@ public:
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
         const auto status =
-            bt_stream_class_set_default_clock_class(this->_libObjPtr(), clkCls._libObjPtr());
+            bt_stream_class_set_default_clock_class(this->libObjPtr(), clkCls.libObjPtr());
 
         BT_ASSERT(status == BT_STREAM_CLASS_SET_DEFAULT_CLOCK_CLASS_STATUS_OK);
     }
 
     nonstd::optional<ConstClockClass> defaultClockClass() const noexcept
     {
-        const auto libObjPtr = _ConstSpec::defaultClockClass(this->_libObjPtr());
+        const auto libObjPtr = _ConstSpec::defaultClockClass(this->libObjPtr());
 
         if (libObjPtr) {
             return ConstClockClass {libObjPtr};
@@ -1569,7 +1569,7 @@ public:
 
     nonstd::optional<_ClockClass> defaultClockClass() noexcept
     {
-        const auto libObjPtr = _Spec::defaultClockClass(this->_libObjPtr());
+        const auto libObjPtr = _Spec::defaultClockClass(this->libObjPtr());
 
         if (libObjPtr) {
             return _ClockClass {libObjPtr};
@@ -1580,22 +1580,22 @@ public:
 
     std::uint64_t size() const noexcept
     {
-        return bt_stream_class_get_event_class_count(this->_libObjPtr());
+        return bt_stream_class_get_event_class_count(this->libObjPtr());
     }
 
     ConstEventClass operator[](const std::uint64_t index) const noexcept
     {
-        return ConstEventClass {_ConstSpec::eventClassByIndex(this->_libObjPtr(), index)};
+        return ConstEventClass {_ConstSpec::eventClassByIndex(this->libObjPtr(), index)};
     }
 
     _EventClass operator[](const std::uint64_t index) noexcept
     {
-        return _EventClass {_Spec::eventClassByIndex(this->_libObjPtr(), index)};
+        return _EventClass {_Spec::eventClassByIndex(this->libObjPtr(), index)};
     }
 
     nonstd::optional<ConstEventClass> eventClassById(const std::uint64_t id) const noexcept
     {
-        const auto libObjPtr = _ConstSpec::eventClassById(this->_libObjPtr(), id);
+        const auto libObjPtr = _ConstSpec::eventClassById(this->libObjPtr(), id);
 
         if (libObjPtr) {
             return ConstEventClass {libObjPtr};
@@ -1606,7 +1606,7 @@ public:
 
     nonstd::optional<_EventClass> eventClassById(const std::uint64_t id) noexcept
     {
-        const auto libObjPtr = _Spec::eventClassById(this->_libObjPtr(), id);
+        const auto libObjPtr = _Spec::eventClassById(this->libObjPtr(), id);
 
         if (libObjPtr) {
             return _EventClass {libObjPtr};
@@ -1620,7 +1620,7 @@ public:
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
         const auto status =
-            bt_stream_class_set_packet_context_field_class(this->_libObjPtr(), fc._libObjPtr());
+            bt_stream_class_set_packet_context_field_class(this->libObjPtr(), fc.libObjPtr());
 
         if (status == BT_EVENT_CLASS_SET_FIELD_CLASS_STATUS_MEMORY_ERROR) {
             throw LibMemoryError {};
@@ -1629,7 +1629,7 @@ public:
 
     nonstd::optional<ConstStructureFieldClass> packetContextFieldClass() const noexcept
     {
-        const auto libObjPtr = _ConstSpec::packetContextFieldClass(this->_libObjPtr());
+        const auto libObjPtr = _ConstSpec::packetContextFieldClass(this->libObjPtr());
 
         if (libObjPtr) {
             return ConstStructureFieldClass {libObjPtr};
@@ -1640,7 +1640,7 @@ public:
 
     nonstd::optional<_StructureFieldClass> packetContextFieldClass() noexcept
     {
-        const auto libObjPtr = _Spec::packetContextFieldClass(this->_libObjPtr());
+        const auto libObjPtr = _Spec::packetContextFieldClass(this->libObjPtr());
 
         if (libObjPtr) {
             return _StructureFieldClass {libObjPtr};
@@ -1653,8 +1653,8 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        const auto status = bt_stream_class_set_event_common_context_field_class(this->_libObjPtr(),
-                                                                                 fc._libObjPtr());
+        const auto status =
+            bt_stream_class_set_event_common_context_field_class(this->libObjPtr(), fc.libObjPtr());
 
         if (status == BT_EVENT_CLASS_SET_FIELD_CLASS_STATUS_MEMORY_ERROR) {
             throw LibMemoryError {};
@@ -1663,7 +1663,7 @@ public:
 
     nonstd::optional<ConstStructureFieldClass> eventCommonContextFieldClass() const noexcept
     {
-        const auto libObjPtr = _ConstSpec::eventCommonContextFieldClass(this->_libObjPtr());
+        const auto libObjPtr = _ConstSpec::eventCommonContextFieldClass(this->libObjPtr());
 
         if (libObjPtr) {
             return ConstStructureFieldClass {libObjPtr};
@@ -1674,7 +1674,7 @@ public:
 
     nonstd::optional<_StructureFieldClass> eventCommonContextFieldClass() noexcept
     {
-        const auto libObjPtr = _Spec::eventCommonContextFieldClass(this->_libObjPtr());
+        const auto libObjPtr = _Spec::eventCommonContextFieldClass(this->libObjPtr());
 
         if (libObjPtr) {
             return _StructureFieldClass {libObjPtr};
@@ -1688,17 +1688,17 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        bt_stream_class_set_user_attributes(this->_libObjPtr(), userAttrs._libObjPtr());
+        bt_stream_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
     }
 
     ConstMapValue userAttributes() const noexcept
     {
-        return ConstMapValue {_ConstSpec::userAttributes(this->_libObjPtr())};
+        return ConstMapValue {_ConstSpec::userAttributes(this->libObjPtr())};
     }
 
     UserAttributes userAttributes() noexcept
     {
-        return UserAttributes {_Spec::userAttributes(this->_libObjPtr())};
+        return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
     }
 
     Shared shared() const noexcept
@@ -1713,25 +1713,25 @@ using ConstStreamClass = CommonStreamClass<const bt_stream_class>;
 template <typename LibObjT>
 ConstStreamClass CommonEventClass<LibObjT>::streamClass() const noexcept
 {
-    return ConstStreamClass {_ConstSpec::streamClass(this->_libObjPtr())};
+    return ConstStreamClass {_ConstSpec::streamClass(this->libObjPtr())};
 }
 
 template <typename LibObjT>
 typename CommonEventClass<LibObjT>::_StreamClass CommonEventClass<LibObjT>::streamClass() noexcept
 {
-    return _StreamClass {_Spec::streamClass(this->_libObjPtr())};
+    return _StreamClass {_Spec::streamClass(this->libObjPtr())};
 }
 
 template <typename LibObjT>
 ConstStreamClass CommonStream<LibObjT>::cls() const noexcept
 {
-    return ConstStreamClass {_ConstSpec::cls(this->_libObjPtr())};
+    return ConstStreamClass {_ConstSpec::cls(this->libObjPtr())};
 }
 
 template <typename LibObjT>
 typename CommonStream<LibObjT>::Class CommonStream<LibObjT>::cls() noexcept
 {
-    return Class {_Spec::cls(this->_libObjPtr())};
+    return Class {_Spec::cls(this->libObjPtr())};
 }
 
 namespace internal {
@@ -1840,7 +1840,7 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        const auto libObjPtr = bt_trace_create(this->_libObjPtr());
+        const auto libObjPtr = bt_trace_create(this->libObjPtr());
 
         internal::validateCreatedObjPtr(libObjPtr);
         return Trace::Shared {Trace {libObjPtr}};
@@ -1850,7 +1850,7 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        const auto libObjPtr = bt_stream_class_create(this->_libObjPtr());
+        const auto libObjPtr = bt_stream_class_create(this->libObjPtr());
 
         internal::validateCreatedObjPtr(libObjPtr);
         return StreamClass::Shared {StreamClass {libObjPtr}};
@@ -1860,7 +1860,7 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        const auto libObjPtr = bt_stream_class_create_with_id(this->_libObjPtr(), id);
+        const auto libObjPtr = bt_stream_class_create_with_id(this->libObjPtr(), id);
 
         internal::validateCreatedObjPtr(libObjPtr);
         return StreamClass::Shared {StreamClass {libObjPtr}};
@@ -1870,7 +1870,7 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        const auto libObjPtr = bt_field_class_bool_create(this->_libObjPtr());
+        const auto libObjPtr = bt_field_class_bool_create(this->libObjPtr());
 
         internal::validateCreatedObjPtr(libObjPtr);
         return FieldClass::Shared {FieldClass {libObjPtr}};
@@ -1880,7 +1880,7 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        const auto libObjPtr = bt_field_class_bit_array_create(this->_libObjPtr(), length);
+        const auto libObjPtr = bt_field_class_bit_array_create(this->libObjPtr(), length);
 
         internal::validateCreatedObjPtr(libObjPtr);
         return BitArrayFieldClass::Shared {BitArrayFieldClass {libObjPtr}};
@@ -1890,7 +1890,7 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        const auto libObjPtr = bt_field_class_integer_unsigned_create(this->_libObjPtr());
+        const auto libObjPtr = bt_field_class_integer_unsigned_create(this->libObjPtr());
 
         internal::validateCreatedObjPtr(libObjPtr);
         return IntegerFieldClass::Shared {IntegerFieldClass {libObjPtr}};
@@ -1900,7 +1900,7 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        const auto libObjPtr = bt_field_class_integer_signed_create(this->_libObjPtr());
+        const auto libObjPtr = bt_field_class_integer_signed_create(this->libObjPtr());
 
         internal::validateCreatedObjPtr(libObjPtr);
         return IntegerFieldClass::Shared {IntegerFieldClass {libObjPtr}};
@@ -1910,7 +1910,7 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        const auto libObjPtr = bt_field_class_enumeration_unsigned_create(this->_libObjPtr());
+        const auto libObjPtr = bt_field_class_enumeration_unsigned_create(this->libObjPtr());
 
         internal::validateCreatedObjPtr(libObjPtr);
         return UnsignedEnumerationFieldClass::Shared {UnsignedEnumerationFieldClass {libObjPtr}};
@@ -1920,7 +1920,7 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        const auto libObjPtr = bt_field_class_enumeration_signed_create(this->_libObjPtr());
+        const auto libObjPtr = bt_field_class_enumeration_signed_create(this->libObjPtr());
 
         internal::validateCreatedObjPtr(libObjPtr);
         return SignedEnumerationFieldClass::Shared {SignedEnumerationFieldClass {libObjPtr}};
@@ -1930,7 +1930,7 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        const auto libObjPtr = bt_field_class_real_single_precision_create(this->_libObjPtr());
+        const auto libObjPtr = bt_field_class_real_single_precision_create(this->libObjPtr());
 
         internal::validateCreatedObjPtr(libObjPtr);
         return FieldClass::Shared {FieldClass {libObjPtr}};
@@ -1940,7 +1940,7 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        const auto libObjPtr = bt_field_class_real_double_precision_create(this->_libObjPtr());
+        const auto libObjPtr = bt_field_class_real_double_precision_create(this->libObjPtr());
 
         internal::validateCreatedObjPtr(libObjPtr);
         return FieldClass::Shared {FieldClass {libObjPtr}};
@@ -1950,7 +1950,7 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        const auto libObjPtr = bt_field_class_string_create(this->_libObjPtr());
+        const auto libObjPtr = bt_field_class_string_create(this->libObjPtr());
 
         internal::validateCreatedObjPtr(libObjPtr);
         return FieldClass::Shared {FieldClass {libObjPtr}};
@@ -1962,7 +1962,7 @@ public:
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
         const auto libObjPtr = bt_field_class_array_static_create(
-            this->_libObjPtr(), elementFieldClass._libObjPtr(), length);
+            this->libObjPtr(), elementFieldClass.libObjPtr(), length);
 
         internal::validateCreatedObjPtr(libObjPtr);
         return StaticArrayFieldClass::Shared {StaticArrayFieldClass {libObjPtr}};
@@ -1973,7 +1973,7 @@ public:
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
         const auto libObjPtr = bt_field_class_array_dynamic_create(
-            this->_libObjPtr(), elementFieldClass._libObjPtr(), nullptr);
+            this->libObjPtr(), elementFieldClass.libObjPtr(), nullptr);
 
         internal::validateCreatedObjPtr(libObjPtr);
         return ArrayFieldClass::Shared {ArrayFieldClass {libObjPtr}};
@@ -1986,7 +1986,7 @@ public:
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
         const auto libObjPtr = bt_field_class_array_dynamic_create(
-            this->_libObjPtr(), elementFieldClass._libObjPtr(), lengthFieldClass._libObjPtr());
+            this->libObjPtr(), elementFieldClass.libObjPtr(), lengthFieldClass.libObjPtr());
 
         internal::validateCreatedObjPtr(libObjPtr);
         return DynamicArrayWithLengthFieldClass::Shared {
@@ -1997,7 +1997,7 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        const auto libObjPtr = bt_field_class_structure_create(this->_libObjPtr());
+        const auto libObjPtr = bt_field_class_structure_create(this->libObjPtr());
 
         internal::validateCreatedObjPtr(libObjPtr);
         return StructureFieldClass::Shared {StructureFieldClass {libObjPtr}};
@@ -2008,7 +2008,7 @@ public:
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
         const auto libObjPtr = bt_field_class_option_without_selector_create(
-            this->_libObjPtr(), optionalFieldClass._libObjPtr());
+            this->libObjPtr(), optionalFieldClass.libObjPtr());
 
         internal::validateCreatedObjPtr(libObjPtr);
         return OptionFieldClass::Shared {OptionFieldClass {libObjPtr}};
@@ -2021,7 +2021,7 @@ public:
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
         const auto libObjPtr = bt_field_class_option_with_selector_field_bool_create(
-            this->_libObjPtr(), optionalFieldClass._libObjPtr(), selectorFieldClass._libObjPtr());
+            this->libObjPtr(), optionalFieldClass.libObjPtr(), selectorFieldClass.libObjPtr());
 
         internal::validateCreatedObjPtr(libObjPtr);
         return OptionWithBoolSelectorFieldClass::Shared {
@@ -2036,8 +2036,8 @@ public:
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
         const auto libObjPtr = bt_field_class_option_with_selector_field_integer_unsigned_create(
-            this->_libObjPtr(), optionalFieldClass._libObjPtr(), selectorFieldClass._libObjPtr(),
-            ranges._libObjPtr());
+            this->libObjPtr(), optionalFieldClass.libObjPtr(), selectorFieldClass.libObjPtr(),
+            ranges.libObjPtr());
 
         internal::validateCreatedObjPtr(libObjPtr);
         return OptionWithUnsignedIntegerSelectorFieldClass::Shared {
@@ -2052,8 +2052,8 @@ public:
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
         const auto libObjPtr = bt_field_class_option_with_selector_field_integer_signed_create(
-            this->_libObjPtr(), optionalFieldClass._libObjPtr(), selectorFieldClass._libObjPtr(),
-            ranges._libObjPtr());
+            this->libObjPtr(), optionalFieldClass.libObjPtr(), selectorFieldClass.libObjPtr(),
+            ranges.libObjPtr());
 
         internal::validateCreatedObjPtr(libObjPtr);
         return OptionWithSignedIntegerSelectorFieldClass::Shared {
@@ -2064,7 +2064,7 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        const auto libObjPtr = bt_field_class_variant_create(this->_libObjPtr(), nullptr);
+        const auto libObjPtr = bt_field_class_variant_create(this->libObjPtr(), nullptr);
 
         internal::validateCreatedObjPtr(libObjPtr);
         return VariantWithoutSelectorFieldClass::Shared {
@@ -2091,34 +2091,34 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        bt_trace_class_set_assigns_automatic_stream_class_id(this->_libObjPtr(),
+        bt_trace_class_set_assigns_automatic_stream_class_id(this->libObjPtr(),
                                                              static_cast<bt_bool>(val));
     }
 
     bool assignsAutomaticStreamClassId() const noexcept
     {
         return static_cast<bool>(
-            bt_trace_class_assigns_automatic_stream_class_id(this->_libObjPtr()));
+            bt_trace_class_assigns_automatic_stream_class_id(this->libObjPtr()));
     }
 
     std::uint64_t size() const noexcept
     {
-        return bt_trace_class_get_stream_class_count(this->_libObjPtr());
+        return bt_trace_class_get_stream_class_count(this->libObjPtr());
     }
 
     ConstStreamClass operator[](const std::uint64_t index) const noexcept
     {
-        return ConstStreamClass {_ConstSpec::streamClassByIndex(this->_libObjPtr(), index)};
+        return ConstStreamClass {_ConstSpec::streamClassByIndex(this->libObjPtr(), index)};
     }
 
     _StreamClass operator[](const std::uint64_t index) noexcept
     {
-        return _StreamClass {_Spec::streamClassByIndex(this->_libObjPtr(), index)};
+        return _StreamClass {_Spec::streamClassByIndex(this->libObjPtr(), index)};
     }
 
     nonstd::optional<ConstStreamClass> streamClassById(const std::uint64_t id) const noexcept
     {
-        const auto libObjPtr = _ConstSpec::streamClassById(this->_libObjPtr(), id);
+        const auto libObjPtr = _ConstSpec::streamClassById(this->libObjPtr(), id);
 
         if (libObjPtr) {
             return ConstStreamClass {libObjPtr};
@@ -2129,7 +2129,7 @@ public:
 
     nonstd::optional<_StreamClass> streamClassById(const std::uint64_t id) noexcept
     {
-        const auto libObjPtr = _Spec::streamClassById(this->_libObjPtr(), id);
+        const auto libObjPtr = _Spec::streamClassById(this->libObjPtr(), id);
 
         if (libObjPtr) {
             return _StreamClass {libObjPtr};
@@ -2143,17 +2143,17 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        bt_trace_class_set_user_attributes(this->_libObjPtr(), userAttrs._libObjPtr());
+        bt_trace_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
     }
 
     ConstMapValue userAttributes() const noexcept
     {
-        return ConstMapValue {_ConstSpec::userAttributes(this->_libObjPtr())};
+        return ConstMapValue {_ConstSpec::userAttributes(this->libObjPtr())};
     }
 
     UserAttributes userAttributes() noexcept
     {
-        return UserAttributes {_Spec::userAttributes(this->_libObjPtr())};
+        return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
     }
 
     Shared shared() const noexcept
@@ -2168,7 +2168,7 @@ private:
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
         const auto libObjPtr =
-            bt_field_class_variant_create(this->_libObjPtr(), selectorFieldClass._libObjPtr());
+            bt_field_class_variant_create(this->libObjPtr(), selectorFieldClass.libObjPtr());
 
         internal::validateCreatedObjPtr(libObjPtr);
         return libObjPtr;
@@ -2181,25 +2181,25 @@ using ConstTraceClass = CommonTraceClass<const bt_trace_class>;
 template <typename LibObjT>
 ConstTraceClass CommonStreamClass<LibObjT>::traceClass() const noexcept
 {
-    return ConstTraceClass {_ConstSpec::traceClass(this->_libObjPtr())};
+    return ConstTraceClass {_ConstSpec::traceClass(this->libObjPtr())};
 }
 
 template <typename LibObjT>
 typename CommonStreamClass<LibObjT>::_TraceClass CommonStreamClass<LibObjT>::traceClass() noexcept
 {
-    return _TraceClass {_Spec::traceClass(this->_libObjPtr())};
+    return _TraceClass {_Spec::traceClass(this->libObjPtr())};
 }
 
 template <typename LibObjT>
 ConstTraceClass CommonTrace<LibObjT>::cls() const noexcept
 {
-    return ConstTraceClass {_ConstSpec::cls(this->_libObjPtr())};
+    return ConstTraceClass {_ConstSpec::cls(this->libObjPtr())};
 }
 
 template <typename LibObjT>
 typename CommonTrace<LibObjT>::Class CommonTrace<LibObjT>::cls() noexcept
 {
-    return Class {_Spec::cls(this->_libObjPtr())};
+    return Class {_Spec::cls(this->libObjPtr())};
 }
 
 } /* namespace bt2 */
diff --git a/src/cpp-common/bt2/value.hpp b/src/cpp-common/bt2/value.hpp
index fab17ca3..dd05fea5 100644
--- a/src/cpp-common/bt2/value.hpp
+++ b/src/cpp-common/bt2/value.hpp
@@ -102,13 +102,13 @@ class CommonStream;
 template <typename LibObjT>
 class CommonValue : public internal::BorrowedObj<LibObjT>
 {
-    /* Allow append() to call `val._libObjPtr()` */
+    /* Allow append() to call `val.libObjPtr()` */
     friend class CommonArrayValue<bt_value>;
 
-    /* Allow insert() to call `val._libObjPtr()` */
+    /* Allow insert() to call `val.libObjPtr()` */
     friend class CommonMapValue<bt_value>;
 
-    /* Allow userAttributes() to call `val._libObjPtr()` */
+    /* Allow userAttributes() to call `val.libObjPtr()` */
     friend class CommonClockClass<bt_clock_class>;
     friend class CommonFieldClass<bt_field_class>;
     friend class CommonTraceClass<bt_trace_class>;
@@ -116,7 +116,7 @@ class CommonValue : public internal::BorrowedObj<LibObjT>
     friend class CommonEventClass<bt_event_class>;
     friend class CommonStream<bt_stream>;
 
-    /* Allow operator==() to call `other._libObjPtr()` */
+    /* Allow operator==() to call `other.libObjPtr()` */
     friend class CommonValue<bt_value>;
     friend class CommonValue<const bt_value>;
 
@@ -148,7 +148,7 @@ public:
 
     ValueType type() const noexcept
     {
-        return static_cast<ValueType>(bt_value_get_type(this->_libObjPtr()));
+        return static_cast<ValueType>(bt_value_get_type(this->libObjPtr()));
     }
 
     bool isNull() const noexcept
@@ -199,7 +199,7 @@ public:
     template <typename OtherLibObjT>
     bool operator==(const CommonValue<OtherLibObjT>& other) const noexcept
     {
-        return static_cast<bool>(bt_value_is_equal(this->_libObjPtr(), other._libObjPtr()));
+        return static_cast<bool>(bt_value_is_equal(this->libObjPtr(), other.libObjPtr()));
     }
 
     template <typename OtherLibObjT>
@@ -225,7 +225,7 @@ public:
 protected:
     bool _libTypeIs(const bt_value_type type) const noexcept
     {
-        return bt_value_type_is(bt_value_get_type(this->_libObjPtr()), type);
+        return bt_value_type_is(bt_value_get_type(this->libObjPtr()), type);
     }
 };
 
@@ -306,13 +306,13 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        bt_value_bool_set(this->_libObjPtr(), static_cast<bt_bool>(rawVal));
+        bt_value_bool_set(this->libObjPtr(), static_cast<bt_bool>(rawVal));
         return *this;
     }
 
     Value value() const noexcept
     {
-        return static_cast<Value>(bt_value_bool_get(this->_libObjPtr()));
+        return static_cast<Value>(bt_value_bool_get(this->libObjPtr()));
     }
 
     operator Value() const noexcept
@@ -372,13 +372,13 @@ public:
 
     CommonUnsignedIntegerValue<LibObjT>& operator=(const Value rawVal) noexcept
     {
-        bt_value_integer_unsigned_set(this->_libObjPtr(), rawVal);
+        bt_value_integer_unsigned_set(this->libObjPtr(), rawVal);
         return *this;
     }
 
     Value value() const noexcept
     {
-        return bt_value_integer_unsigned_get(this->_libObjPtr());
+        return bt_value_integer_unsigned_get(this->libObjPtr());
     }
 
     operator Value() const noexcept
@@ -438,13 +438,13 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        bt_value_integer_signed_set(this->_libObjPtr(), rawVal);
+        bt_value_integer_signed_set(this->libObjPtr(), rawVal);
         return *this;
     }
 
     Value value() const noexcept
     {
-        return bt_value_integer_signed_get(this->_libObjPtr());
+        return bt_value_integer_signed_get(this->libObjPtr());
     }
 
     operator Value() const noexcept
@@ -501,13 +501,13 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        bt_value_real_set(this->_libObjPtr(), rawVal);
+        bt_value_real_set(this->libObjPtr(), rawVal);
         return *this;
     }
 
     Value value() const noexcept
     {
-        return bt_value_real_get(this->_libObjPtr());
+        return bt_value_real_get(this->libObjPtr());
     }
 
     operator Value() const noexcept
@@ -568,7 +568,7 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        const auto status = bt_value_string_set(this->_libObjPtr(), rawVal);
+        const auto status = bt_value_string_set(this->libObjPtr(), rawVal);
 
         if (status == BT_VALUE_STRING_SET_STATUS_MEMORY_ERROR) {
             throw LibMemoryError {};
@@ -584,7 +584,7 @@ public:
 
     bpstd::string_view value() const noexcept
     {
-        return bt_value_string_get(this->_libObjPtr());
+        return bt_value_string_get(this->libObjPtr());
     }
 
     Shared shared() const noexcept
@@ -662,7 +662,7 @@ public:
 
     std::uint64_t length() const noexcept
     {
-        return bt_value_array_get_length(this->_libObjPtr());
+        return bt_value_array_get_length(this->libObjPtr());
     }
 
     /* Required by the `CommonIterator` template class */
@@ -689,20 +689,20 @@ public:
     ConstValue operator[](const std::uint64_t index) const noexcept
     {
         return ConstValue {internal::CommonArrayValueSpec<const bt_value>::elementByIndex(
-            this->_libObjPtr(), index)};
+            this->libObjPtr(), index)};
     }
 
     CommonValue<LibObjT> operator[](const std::uint64_t index) noexcept
     {
         return CommonValue<LibObjT> {
-            internal::CommonArrayValueSpec<LibObjT>::elementByIndex(this->_libObjPtr(), index)};
+            internal::CommonArrayValueSpec<LibObjT>::elementByIndex(this->libObjPtr(), index)};
     }
 
     void append(const Value& val)
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        const auto status = bt_value_array_append_element(this->_libObjPtr(), val._libObjPtr());
+        const auto status = bt_value_array_append_element(this->libObjPtr(), val.libObjPtr());
 
         this->_handleAppendLibStatus(status);
     }
@@ -712,7 +712,7 @@ public:
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
         const auto status =
-            bt_value_array_append_bool_element(this->_libObjPtr(), static_cast<bt_bool>(rawVal));
+            bt_value_array_append_bool_element(this->libObjPtr(), static_cast<bt_bool>(rawVal));
 
         this->_handleAppendLibStatus(status);
     }
@@ -722,7 +722,7 @@ public:
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
         const auto status =
-            bt_value_array_append_unsigned_integer_element(this->_libObjPtr(), rawVal);
+            bt_value_array_append_unsigned_integer_element(this->libObjPtr(), rawVal);
 
         this->_handleAppendLibStatus(status);
     }
@@ -731,8 +731,7 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        const auto status =
-            bt_value_array_append_signed_integer_element(this->_libObjPtr(), rawVal);
+        const auto status = bt_value_array_append_signed_integer_element(this->libObjPtr(), rawVal);
 
         this->_handleAppendLibStatus(status);
     }
@@ -741,7 +740,7 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        const auto status = bt_value_array_append_real_element(this->_libObjPtr(), rawVal);
+        const auto status = bt_value_array_append_real_element(this->libObjPtr(), rawVal);
 
         this->_handleAppendLibStatus(status);
     }
@@ -750,7 +749,7 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        const auto status = bt_value_array_append_string_element(this->_libObjPtr(), rawVal);
+        const auto status = bt_value_array_append_string_element(this->libObjPtr(), rawVal);
 
         this->_handleAppendLibStatus(status);
     }
@@ -957,7 +956,7 @@ public:
 
     std::uint64_t size() const noexcept
     {
-        return bt_value_map_get_size(this->_libObjPtr());
+        return bt_value_map_get_size(this->libObjPtr());
     }
 
     bool isEmpty() const noexcept
@@ -968,7 +967,7 @@ public:
     nonstd::optional<ConstValue> operator[](const char * const key) const noexcept
     {
         const auto libObjPtr =
-            internal::CommonMapValueSpec<const bt_value>::entryByKey(this->_libObjPtr(), key);
+            internal::CommonMapValueSpec<const bt_value>::entryByKey(this->libObjPtr(), key);
 
         if (!libObjPtr) {
             return nonstd::nullopt;
@@ -985,7 +984,7 @@ public:
     nonstd::optional<CommonValue<LibObjT>> operator[](const char * const key) noexcept
     {
         const auto libObjPtr =
-            internal::CommonMapValueSpec<LibObjT>::entryByKey(this->_libObjPtr(), key);
+            internal::CommonMapValueSpec<LibObjT>::entryByKey(this->libObjPtr(), key);
 
         if (!libObjPtr) {
             return nonstd::nullopt;
@@ -1001,7 +1000,7 @@ public:
 
     bool hasEntry(const char * const key) const noexcept
     {
-        return static_cast<bool>(bt_value_map_has_entry(this->_libObjPtr(), key));
+        return static_cast<bool>(bt_value_map_has_entry(this->libObjPtr(), key));
     }
 
     bool hasEntry(const std::string& key) const noexcept
@@ -1013,7 +1012,7 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        const auto status = bt_value_map_insert_entry(this->_libObjPtr(), key, val._libObjPtr());
+        const auto status = bt_value_map_insert_entry(this->libObjPtr(), key, val.libObjPtr());
 
         this->_handleInsertLibStatus(status);
     }
@@ -1028,7 +1027,7 @@ public:
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
         const auto status =
-            bt_value_map_insert_bool_entry(this->_libObjPtr(), key, static_cast<bt_bool>(rawVal));
+            bt_value_map_insert_bool_entry(this->libObjPtr(), key, static_cast<bt_bool>(rawVal));
 
         this->_handleInsertLibStatus(status);
     }
@@ -1043,7 +1042,7 @@ public:
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
         const auto status =
-            bt_value_map_insert_unsigned_integer_entry(this->_libObjPtr(), key, rawVal);
+            bt_value_map_insert_unsigned_integer_entry(this->libObjPtr(), key, rawVal);
 
         this->_handleInsertLibStatus(status);
     }
@@ -1058,7 +1057,7 @@ public:
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
         const auto status =
-            bt_value_map_insert_signed_integer_entry(this->_libObjPtr(), key, rawVal);
+            bt_value_map_insert_signed_integer_entry(this->libObjPtr(), key, rawVal);
 
         this->_handleInsertLibStatus(status);
     }
@@ -1072,7 +1071,7 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        const auto status = bt_value_map_insert_real_entry(this->_libObjPtr(), key, rawVal);
+        const auto status = bt_value_map_insert_real_entry(this->libObjPtr(), key, rawVal);
 
         this->_handleInsertLibStatus(status);
     }
@@ -1086,7 +1085,7 @@ public:
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
-        const auto status = bt_value_map_insert_string_entry(this->_libObjPtr(), key, rawVal);
+        const auto status = bt_value_map_insert_string_entry(this->libObjPtr(), key, rawVal);
 
         this->_handleInsertLibStatus(status);
     }
@@ -1113,12 +1112,12 @@ public:
 
     void forEach(const internal::CommonMapValueForEachUserFunc<ConstValue>& func) const
     {
-        internal::CommonMapValueSpec<const bt_value>::forEach(this->_libObjPtr(), func);
+        internal::CommonMapValueSpec<const bt_value>::forEach(this->libObjPtr(), func);
     }
 
     void forEach(const internal::CommonMapValueForEachUserFunc<CommonValue<LibObjT>>& func)
     {
-        internal::CommonMapValueSpec<LibObjT>::forEach(this->_libObjPtr(), func);
+        internal::CommonMapValueSpec<LibObjT>::forEach(this->libObjPtr(), func);
     }
 
     Shared shared() const noexcept
@@ -1142,56 +1141,56 @@ template <typename LibObjT>
 CommonNullValue<LibObjT> CommonValue<LibObjT>::asNull() const noexcept
 {
     BT_ASSERT_DBG(this->isNull());
-    return CommonNullValue<LibObjT> {this->_libObjPtr()};
+    return CommonNullValue<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
 CommonBoolValue<LibObjT> CommonValue<LibObjT>::asBool() const noexcept
 {
     BT_ASSERT_DBG(this->isBool());
-    return CommonBoolValue<LibObjT> {this->_libObjPtr()};
+    return CommonBoolValue<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
 CommonSignedIntegerValue<LibObjT> CommonValue<LibObjT>::asSignedInteger() const noexcept
 {
     BT_ASSERT_DBG(this->isSignedInteger());
-    return CommonSignedIntegerValue<LibObjT> {this->_libObjPtr()};
+    return CommonSignedIntegerValue<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
 CommonUnsignedIntegerValue<LibObjT> CommonValue<LibObjT>::asUnsignedInteger() const noexcept
 {
     BT_ASSERT_DBG(this->isUnsignedInteger());
-    return CommonUnsignedIntegerValue<LibObjT> {this->_libObjPtr()};
+    return CommonUnsignedIntegerValue<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
 CommonRealValue<LibObjT> CommonValue<LibObjT>::asReal() const noexcept
 {
     BT_ASSERT_DBG(this->isReal());
-    return CommonRealValue<LibObjT> {this->_libObjPtr()};
+    return CommonRealValue<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
 CommonStringValue<LibObjT> CommonValue<LibObjT>::asString() const noexcept
 {
     BT_ASSERT_DBG(this->isString());
-    return CommonStringValue<LibObjT> {this->_libObjPtr()};
+    return CommonStringValue<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
 CommonArrayValue<LibObjT> CommonValue<LibObjT>::asArray() const noexcept
 {
     BT_ASSERT_DBG(this->isArray());
-    return CommonArrayValue<LibObjT> {this->_libObjPtr()};
+    return CommonArrayValue<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
 CommonMapValue<LibObjT> CommonValue<LibObjT>::asMap() const noexcept
 {
     BT_ASSERT_DBG(this->isMap());
-    return CommonMapValue<LibObjT> {this->_libObjPtr()};
+    return CommonMapValue<LibObjT> {this->libObjPtr()};
 }
 
 template <typename LibObjT>
@@ -1200,7 +1199,7 @@ ArrayValue CommonArrayValue<LibObjT>::appendEmptyArray()
     static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
     bt_value *libElemPtr;
-    const auto status = bt_value_array_append_empty_array_element(this->_libObjPtr(), &libElemPtr);
+    const auto status = bt_value_array_append_empty_array_element(this->libObjPtr(), &libElemPtr);
 
     this->_handleAppendLibStatus(status);
     return ArrayValue {libElemPtr};
@@ -1212,7 +1211,7 @@ MapValue CommonArrayValue<LibObjT>::appendEmptyMap()
     static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
     bt_value *libElemPtr;
-    const auto status = bt_value_array_append_empty_map_element(this->_libObjPtr(), &libElemPtr);
+    const auto status = bt_value_array_append_empty_map_element(this->libObjPtr(), &libElemPtr);
 
     this->_handleAppendLibStatus(status);
     return MapValue {libElemPtr};
@@ -1224,8 +1223,7 @@ ArrayValue CommonMapValue<LibObjT>::insertEmptyArray(const char * const key)
     static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
     bt_value *libEntryPtr;
-    const auto status =
-        bt_value_map_insert_empty_array_entry(this->_libObjPtr(), key, &libEntryPtr);
+    const auto status = bt_value_map_insert_empty_array_entry(this->libObjPtr(), key, &libEntryPtr);
 
     this->_handleInsertLibStatus(status);
     return ArrayValue {libEntryPtr};
@@ -1243,7 +1241,7 @@ MapValue CommonMapValue<LibObjT>::insertEmptyMap(const char * const key)
     static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
     bt_value *libEntryPtr;
-    const auto status = bt_value_map_insert_empty_map_entry(this->_libObjPtr(), key, &libEntryPtr);
+    const auto status = bt_value_map_insert_empty_map_entry(this->libObjPtr(), key, &libEntryPtr);
 
     this->_handleInsertLibStatus(status);
     return MapValue {libEntryPtr};
-- 
2.34.1