From dcb8ae9be121cdae6f6d16757d2233d705df057d Mon Sep 17 00:00:00 2001
From: Philippe Proulx <eeppeliteloop@gmail.com>
Date: Fri, 3 Nov 2023 11:32:49 -0400
Subject: [PATCH] cpp-common/bt2: systematize the `const` method situation

This patch attempts to systematize the `const` situation regarding
methods (member functions and operators).

The current issue is that, because those wrappers are expected to be
passed and returned by copy (they only wrap a libbabeltrace2 pointer),
one cannot rely on the `const` qualifier to ensure immutability at the
library level. For example:

    void f(const bt2::ArrayValue val)
    {
        // Want to modify what `val` wraps? No problem:
        auto newVal = val;

        newVal += 23;
    }

The signature of f() here doesn't guarantee to the caller that what
`val` wraps is immutable. To achieve this, it needs to accept the
`Const` version of the wrapper:

    void f(bt2::ConstArrayValue val)
    {
        // Now there's no way to modify what `val` wraps
    }

Therefore, since using the `const` keyword is so fragile, this patch
makes `const` (almost) all the methods of wrapper classes: those methods
do not modify the wrapped pointer value, therefore they may be `const`.

This makes the wrapping system have this correspondence:

          bt_xyz *                    bt2::Xyz
          bt_xyz * const        const bt2::Xyz
    const bt_xyz *                    bt2::ConstXyz
    const bt_xyz * const        const bt2::ConstXyz

Because there were many overloads to return a `bt2::Const*` instance
when the object is `const`, this patch removes a lot of code, with the
added benefit of reducing code duplication.

Signed-off-by: Philippe Proulx <eeppeliteloop@gmail.com>
Change-Id: Ie633e7e9d67a8eb0138800ad8ae14c8d9bd0ca4c
Reviewed-on: https://review.lttng.org/c/babeltrace/+/11228
Reviewed-by: Simon Marchi <simon.marchi@efficios.com>
---
 src/cpp-common/bt2/clock-class.hpp       |  28 +-
 src/cpp-common/bt2/common-iterator.hpp   |   4 +-
 src/cpp-common/bt2/field-class.hpp       | 150 ++------
 src/cpp-common/bt2/field.hpp             | 159 ++------
 src/cpp-common/bt2/integer-range-set.hpp |   2 +-
 src/cpp-common/bt2/message.hpp           |  68 +---
 src/cpp-common/bt2/trace-ir.hpp          | 459 ++++++-----------------
 src/cpp-common/bt2/value.hpp             | 130 +++----
 8 files changed, 241 insertions(+), 759 deletions(-)

diff --git a/src/cpp-common/bt2/clock-class.hpp b/src/cpp-common/bt2/clock-class.hpp
index 5e0e949d..398f8197 100644
--- a/src/cpp-common/bt2/clock-class.hpp
+++ b/src/cpp-common/bt2/clock-class.hpp
@@ -121,7 +121,7 @@ public:
         return *this;
     }
 
-    void frequency(const std::uint64_t frequency) noexcept
+    void frequency(const std::uint64_t frequency) const noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -133,7 +133,7 @@ public:
         return bt_clock_class_get_frequency(this->libObjPtr());
     }
 
-    void offset(const ClockClassOffset& offset) noexcept
+    void offset(const ClockClassOffset& offset) const noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -149,7 +149,7 @@ public:
         return ClockClassOffset {seconds, cycles};
     }
 
-    void precision(const std::uint64_t precision) noexcept
+    void precision(const std::uint64_t precision) const noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -161,7 +161,7 @@ public:
         return bt_clock_class_get_precision(this->libObjPtr());
     }
 
-    void originIsUnixEpoch(const bool originIsUnixEpoch) noexcept
+    void originIsUnixEpoch(const bool originIsUnixEpoch) const noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -174,7 +174,7 @@ public:
         return static_cast<bool>(bt_clock_class_origin_is_unix_epoch(this->libObjPtr()));
     }
 
-    void name(const char * const name)
+    void name(const char * const name) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -185,7 +185,7 @@ public:
         }
     }
 
-    void name(const std::string& name)
+    void name(const std::string& name) const
     {
         this->name(name.data());
     }
@@ -201,7 +201,7 @@ public:
         return nonstd::nullopt;
     }
 
-    void description(const char * const description)
+    void description(const char * const description) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -212,7 +212,7 @@ public:
         }
     }
 
-    void description(const std::string& description)
+    void description(const std::string& description) const
     {
         this->description(description.data());
     }
@@ -228,7 +228,7 @@ public:
         return nonstd::nullopt;
     }
 
-    void uuid(const std::uint8_t * const uuid) noexcept
+    void uuid(const std::uint8_t * const uuid) const noexcept
     {
         bt_clock_class_set_uuid(this->libObjPtr(), uuid);
     }
@@ -245,20 +245,14 @@ public:
     }
 
     template <typename LibValT>
-    void userAttributes(const CommonMapValue<LibValT> userAttrs)
+    void userAttributes(const CommonMapValue<LibValT> userAttrs) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
         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())};
-    }
-
-    UserAttributes userAttributes() noexcept
+    UserAttributes userAttributes() const noexcept
     {
         return UserAttributes {
             internal::CommonClockClassSpec<LibObjT>::userAttributes(this->libObjPtr())};
diff --git a/src/cpp-common/bt2/common-iterator.hpp b/src/cpp-common/bt2/common-iterator.hpp
index e878b1b9..51b8d8e2 100644
--- a/src/cpp-common/bt2/common-iterator.hpp
+++ b/src/cpp-common/bt2/common-iterator.hpp
@@ -64,12 +64,12 @@ public:
         return !(*this == other);
     }
 
-    reference operator*() noexcept
+    reference operator*() const noexcept
     {
         return *_mCurrVal;
     }
 
-    pointer operator->() noexcept
+    pointer operator->() const noexcept
     {
         return &(*_mCurrVal);
     }
diff --git a/src/cpp-common/bt2/field-class.hpp b/src/cpp-common/bt2/field-class.hpp
index ec5df3c5..d382db1d 100644
--- a/src/cpp-common/bt2/field-class.hpp
+++ b/src/cpp-common/bt2/field-class.hpp
@@ -421,20 +421,14 @@ public:
     asVariantWithSignedIntegerSelector() const noexcept;
 
     template <typename LibValT>
-    void userAttributes(const CommonMapValue<LibValT> userAttrs)
+    void userAttributes(const CommonMapValue<LibValT> userAttrs) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
         bt_field_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
     }
 
-    ConstMapValue userAttributes() const noexcept
-    {
-        return ConstMapValue {internal::CommonFieldClassSpec<const bt_field_class>::userAttributes(
-            this->libObjPtr())};
-    }
-
-    UserAttributes userAttributes() noexcept
+    UserAttributes userAttributes() const noexcept
     {
         return UserAttributes {
             internal::CommonFieldClassSpec<LibObjT>::userAttributes(this->libObjPtr())};
@@ -579,7 +573,7 @@ public:
         return *this;
     }
 
-    void fieldValueRange(const std::uint64_t n) noexcept
+    void fieldValueRange(const std::uint64_t n) const noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -591,7 +585,7 @@ public:
         return bt_field_class_integer_get_field_value_range(this->libObjPtr());
     }
 
-    void preferredDisplayBase(const DisplayBase base) noexcept
+    void preferredDisplayBase(const DisplayBase base) const noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -882,7 +876,7 @@ public:
         return (*this)[label.data()];
     }
 
-    void addMapping(const char * const label, const typename Mapping::RangeSet ranges)
+    void addMapping(const char * const label, const typename Mapping::RangeSet ranges) const
     {
         const auto status = internal::CommonEnumerationFieldClassSpec<MappingT>::addMapping(
             this->libObjPtr(), label, ranges.libObjPtr());
@@ -892,7 +886,7 @@ public:
         }
     }
 
-    void addMapping(const std::string& label, const typename Mapping::RangeSet ranges)
+    void addMapping(const std::string& label, const typename Mapping::RangeSet ranges) const
     {
         this->addMapping(label.data(), ranges);
     }
@@ -1038,20 +1032,14 @@ public:
         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())};
-    }
-
-    _FieldClass fieldClass() noexcept
+    _FieldClass fieldClass() const noexcept
     {
         return _FieldClass {
             internal::CommonStructureFieldClassMemberSpec<LibObjT>::fieldClass(this->libObjPtr())};
     }
 
     template <typename LibValT>
-    void userAttributes(const CommonMapValue<LibValT> userAttrs)
+    void userAttributes(const CommonMapValue<LibValT> userAttrs) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -1059,13 +1047,7 @@ public:
                                                             userAttrs.libObjPtr());
     }
 
-    ConstMapValue userAttributes() const noexcept
-    {
-        return ConstMapValue {internal::CommonStructureFieldClassMemberSpec<
-            const bt_field_class_structure_member>::userAttributes(this->libObjPtr())};
-    }
-
-    UserAttributes userAttributes() noexcept
+    UserAttributes userAttributes() const noexcept
     {
         return UserAttributes {
             internal::CommonStructureFieldClassMemberSpec<LibObjT>::userAttributes(
@@ -1169,7 +1151,7 @@ public:
         return *this;
     }
 
-    void appendMember(const char * const name, const FieldClass fc)
+    void appendMember(const char * const name, const FieldClass fc) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -1181,7 +1163,7 @@ public:
         }
     }
 
-    void appendMember(const std::string& name, const FieldClass fc)
+    void appendMember(const std::string& name, const FieldClass fc) const
     {
         this->appendMember(name.data(), fc);
     }
@@ -1201,40 +1183,13 @@ public:
         return Iterator {*this, this->size()};
     }
 
-    ConstStructureFieldClassMember operator[](const std::uint64_t index) const noexcept
-    {
-        return ConstStructureFieldClassMember {
-            internal::CommonStructureFieldClassSpec<const bt_field_class>::memberByIndex(
-                this->libObjPtr(), index)};
-    }
-
-    Member operator[](const std::uint64_t index) noexcept
+    Member operator[](const std::uint64_t index) const noexcept
     {
         return Member {internal::CommonStructureFieldClassSpec<LibObjT>::memberByIndex(
             this->libObjPtr(), index)};
     }
 
-    nonstd::optional<ConstStructureFieldClassMember>
-    operator[](const char * const name) const noexcept
-    {
-        const auto libObjPtr =
-            internal::CommonStructureFieldClassSpec<const bt_field_class>::memberByName(
-                this->libObjPtr(), name);
-
-        if (libObjPtr) {
-            return ConstStructureFieldClassMember {libObjPtr};
-        }
-
-        return nonstd::nullopt;
-    }
-
-    nonstd::optional<ConstStructureFieldClassMember>
-    operator[](const std::string& name) const noexcept
-    {
-        return (*this)[name.data()];
-    }
-
-    nonstd::optional<Member> operator[](const char * const name) noexcept
+    nonstd::optional<Member> operator[](const char * const name) const noexcept
     {
         const auto libObjPtr =
             internal::CommonStructureFieldClassSpec<LibObjT>::memberByName(this->libObjPtr(), name);
@@ -1246,7 +1201,7 @@ public:
         return nonstd::nullopt;
     }
 
-    nonstd::optional<Member> operator[](const std::string& name) noexcept
+    nonstd::optional<Member> operator[](const std::string& name) const noexcept
     {
         return (*this)[name.data()];
     }
@@ -1338,14 +1293,7 @@ public:
         return *this;
     }
 
-    ConstFieldClass elementFieldClass() const noexcept
-    {
-        return ConstFieldClass {
-            internal::CommonArrayFieldClassSpec<const bt_field_class>::elementFieldClass(
-                this->libObjPtr())};
-    }
-
-    _FieldClass elementFieldClass() noexcept
+    _FieldClass elementFieldClass() const noexcept
     {
         return _FieldClass {
             internal::CommonArrayFieldClassSpec<LibObjT>::elementFieldClass(this->libObjPtr())};
@@ -1573,14 +1521,7 @@ public:
         return *this;
     }
 
-    ConstFieldClass fieldClass() const noexcept
-    {
-        return ConstFieldClass {
-            internal::CommonOptionFieldClassSpec<const bt_field_class>::fieldClass(
-                this->libObjPtr())};
-    }
-
-    _FieldClass fieldClass() noexcept
+    _FieldClass fieldClass() const noexcept
     {
         return _FieldClass {
             internal::CommonOptionFieldClassSpec<LibObjT>::fieldClass(this->libObjPtr())};
@@ -1965,33 +1906,21 @@ public:
         return nonstd::nullopt;
     }
 
-    ConstFieldClass fieldClass() const noexcept
-    {
-        return ConstFieldClass {internal::CommonVariantFieldClassOptionSpec<
-            const bt_field_class_variant_option>::fieldClass(this->libObjPtr())};
-    }
-
-    _FieldClass fieldClass() noexcept
+    _FieldClass fieldClass() const noexcept
     {
         return _FieldClass {
             internal::CommonVariantFieldClassOptionSpec<LibObjT>::fieldClass(this->libObjPtr())};
     }
 
     template <typename LibValT>
-    void userAttributes(const CommonMapValue<LibValT> userAttrs)
+    void userAttributes(const CommonMapValue<LibValT> userAttrs) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
         bt_field_class_variant_option_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
     }
 
-    ConstMapValue userAttributes() const noexcept
-    {
-        return ConstMapValue {internal::CommonVariantFieldClassOptionSpec<
-            const bt_field_class_variant_option>::userAttributes(this->libObjPtr())};
-    }
-
-    UserAttributes userAttributes() noexcept
+    UserAttributes userAttributes() const noexcept
     {
         return UserAttributes {internal::CommonVariantFieldClassOptionSpec<LibObjT>::userAttributes(
             this->libObjPtr())};
@@ -2230,40 +2159,13 @@ public:
         return Iterator {*this, this->size()};
     }
 
-    ConstVariantFieldClassOption operator[](const std::uint64_t index) const noexcept
-    {
-        return ConstVariantFieldClassOption {
-            internal::CommonVariantFieldClassSpec<const bt_field_class>::optionByIndex(
-                this->libObjPtr(), index)};
-    }
-
-    Option operator[](const std::uint64_t index) noexcept
+    Option operator[](const std::uint64_t index) const noexcept
     {
         return Option {internal::CommonVariantFieldClassSpec<LibObjT>::optionByIndex(
             this->libObjPtr(), index)};
     }
 
-    nonstd::optional<ConstVariantFieldClassOption>
-    operator[](const char * const name) const noexcept
-    {
-        const auto libObjPtr =
-            internal::CommonVariantFieldClassSpec<const bt_field_class>::optionByName(
-                this->libObjPtr(), name);
-
-        if (libObjPtr) {
-            return ConstVariantFieldClassOption {libObjPtr};
-        }
-
-        return nonstd::nullopt;
-    }
-
-    nonstd::optional<ConstVariantFieldClassOption>
-    operator[](const std::string& name) const noexcept
-    {
-        return (*this)[name.data()];
-    }
-
-    nonstd::optional<Option> operator[](const char * const name) noexcept
+    nonstd::optional<Option> operator[](const char * const name) const noexcept
     {
         const auto libObjPtr =
             internal::CommonVariantFieldClassSpec<LibObjT>::optionByName(this->libObjPtr(), name);
@@ -2275,7 +2177,7 @@ public:
         return nonstd::nullopt;
     }
 
-    nonstd::optional<Option> operator[](const std::string& name) noexcept
+    nonstd::optional<Option> operator[](const std::string& name) const noexcept
     {
         return (*this)[name.data()];
     }
@@ -2340,7 +2242,7 @@ public:
         return *this;
     }
 
-    void appendOption(const char * const name, const FieldClass fc)
+    void appendOption(const char * const name, const FieldClass fc) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -2353,7 +2255,7 @@ public:
         }
     }
 
-    void appendOption(const nonstd::optional<std::string>& name, const FieldClass fc)
+    void appendOption(const nonstd::optional<std::string>& name, const FieldClass fc) const
     {
         this->appendOption(name ? name->data() : nullptr, fc);
     }
@@ -2567,7 +2469,7 @@ public:
     }
 
     void appendOption(const char * const name, const FieldClass fc,
-                      const typename Option::RangeSet ranges)
+                      const typename Option::RangeSet ranges) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -2581,7 +2483,7 @@ public:
     }
 
     void appendOption(const nonstd::optional<std::string>& name, const FieldClass fc,
-                      const typename Option::RangeSet ranges)
+                      const typename Option::RangeSet ranges) const
     {
         this->appendOption(name ? name->data() : nullptr, fc, ranges);
     }
diff --git a/src/cpp-common/bt2/field.hpp b/src/cpp-common/bt2/field.hpp
index 509e66d2..241c1776 100644
--- a/src/cpp-common/bt2/field.hpp
+++ b/src/cpp-common/bt2/field.hpp
@@ -126,12 +126,7 @@ public:
         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())};
-    }
-
-    Class cls() noexcept
+    Class cls() const noexcept
     {
         return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
     }
@@ -278,7 +273,7 @@ public:
         return *this;
     }
 
-    CommonBoolField<LibObjT>& operator=(const Value val) noexcept
+    CommonBoolField<LibObjT> operator=(const Value val) const noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -360,7 +355,7 @@ public:
         return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
     }
 
-    CommonBitArrayField<LibObjT>& operator=(const std::uint64_t bits) noexcept
+    CommonBitArrayField<LibObjT> operator=(const std::uint64_t bits) const noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -439,18 +434,12 @@ public:
         return *this;
     }
 
-    ConstIntegerFieldClass cls() const noexcept
-    {
-        return ConstIntegerFieldClass {
-            internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
-    }
-
-    Class cls() noexcept
+    Class cls() const noexcept
     {
         return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
     }
 
-    CommonUnsignedIntegerField<LibObjT>& operator=(const Value val) noexcept
+    CommonUnsignedIntegerField<LibObjT> operator=(const Value val) const noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -528,18 +517,12 @@ public:
         return *this;
     }
 
-    ConstIntegerFieldClass cls() const noexcept
-    {
-        return ConstIntegerFieldClass {
-            internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
-    }
-
-    Class cls() noexcept
+    Class cls() const noexcept
     {
         return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
     }
 
-    CommonSignedIntegerField<LibObjT>& operator=(const Value val) noexcept
+    CommonSignedIntegerField<LibObjT> operator=(const Value val) const noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -645,15 +628,9 @@ public:
         return *this;
     }
 
-    ConstUnsignedEnumerationFieldClass cls() const noexcept
-    {
-        return ConstUnsignedEnumerationFieldClass {
-            internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
-    }
-
     using CommonUnsignedIntegerField<LibObjT>::operator=;
 
-    Class cls() noexcept
+    Class cls() const noexcept
     {
         return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
     }
@@ -730,13 +707,7 @@ public:
 
     using CommonSignedIntegerField<LibObjT>::operator=;
 
-    ConstSignedEnumerationFieldClass cls() const noexcept
-    {
-        return ConstSignedEnumerationFieldClass {
-            internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
-    }
-
-    Class cls() noexcept
+    Class cls() const noexcept
     {
         return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
     }
@@ -810,7 +781,7 @@ public:
         return *this;
     }
 
-    CommonSinglePrecisionRealField<LibObjT>& operator=(const Value val) noexcept
+    CommonSinglePrecisionRealField<LibObjT> operator=(const Value val) const noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -883,7 +854,7 @@ public:
         return *this;
     }
 
-    CommonDoublePrecisionRealField<LibObjT>& operator=(const Value val) noexcept
+    CommonDoublePrecisionRealField<LibObjT> operator=(const Value val) const noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -950,7 +921,7 @@ public:
         return *this;
     }
 
-    CommonStringField<LibObjT>& operator=(const char * const val)
+    CommonStringField<LibObjT> operator=(const char * const val) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -963,12 +934,12 @@ public:
         return *this;
     }
 
-    CommonStringField<LibObjT>& operator=(const std::string& val)
+    CommonStringField<LibObjT> operator=(const std::string& val) const
     {
         return *this = val.data();
     }
 
-    void append(const char * const begin, const std::uint64_t len)
+    void append(const char * const begin, const std::uint64_t len) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -979,12 +950,12 @@ public:
         }
     }
 
-    void append(const std::string& val)
+    void append(const std::string& val) const
     {
         this->append(val.data(), val.size());
     }
 
-    void clear() noexcept
+    void clear() const noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -1087,13 +1058,7 @@ public:
         return *this;
     }
 
-    ConstStructureFieldClass cls() const noexcept
-    {
-        return ConstStructureFieldClass {
-            internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
-    }
-
-    Class cls() noexcept
+    Class cls() const noexcept
     {
         return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
     }
@@ -1103,36 +1068,12 @@ public:
         return this->cls().size();
     }
 
-    ConstField operator[](const std::uint64_t index) const noexcept
-    {
-        return ConstField {internal::CommonStructureFieldSpec<const bt_field>::memberFieldByIndex(
-            this->libObjPtr(), index)};
-    }
-
-    CommonField<LibObjT> operator[](const std::uint64_t index) noexcept
+    CommonField<LibObjT> operator[](const std::uint64_t index) const noexcept
     {
         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);
-
-        if (libObjPtr) {
-            return ConstField {libObjPtr};
-        }
-
-        return nonstd::nullopt;
-    }
-
-    nonstd::optional<ConstField> operator[](const std::string& name) const noexcept
-    {
-        return (*this)[name.data()];
-    }
-
-    nonstd::optional<CommonField<LibObjT>> operator[](const char * const name) noexcept
+    nonstd::optional<CommonField<LibObjT>> operator[](const char * const name) const noexcept
     {
         const auto libObjPtr = _Spec::memberFieldByName(this->libObjPtr(), name);
 
@@ -1143,7 +1084,7 @@ public:
         return nonstd::nullopt;
     }
 
-    nonstd::optional<CommonField<LibObjT>> operator[](const std::string& name) noexcept
+    nonstd::optional<CommonField<LibObjT>> operator[](const std::string& name) const noexcept
     {
         return (*this)[name.data()];
     }
@@ -1229,13 +1170,7 @@ public:
         return *this;
     }
 
-    ConstArrayFieldClass cls() const noexcept
-    {
-        return ConstArrayFieldClass {
-            internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
-    }
-
-    Class cls() noexcept
+    Class cls() const noexcept
     {
         return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
     }
@@ -1245,13 +1180,7 @@ public:
         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)};
-    }
-
-    CommonField<LibObjT> operator[](const std::uint64_t index) noexcept
+    CommonField<LibObjT> operator[](const std::uint64_t index) const noexcept
     {
         return CommonField<LibObjT> {_Spec::elementFieldByIndex(this->libObjPtr(), index)};
     }
@@ -1313,7 +1242,7 @@ public:
         return _ThisCommonArrayField::length();
     }
 
-    void length(const std::uint64_t length)
+    void length(const std::uint64_t length) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -1400,18 +1329,12 @@ public:
         return *this;
     }
 
-    ConstOptionFieldClass cls() const noexcept
-    {
-        return ConstOptionFieldClass {
-            internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
-    }
-
-    Class cls() noexcept
+    Class cls() const noexcept
     {
         return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
     }
 
-    void hasField(const bool hasField) noexcept
+    void hasField(const bool hasField) const noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -1423,19 +1346,7 @@ public:
         return this->field().has_value();
     }
 
-    nonstd::optional<ConstField> field() const noexcept
-    {
-        const auto libObjPtr =
-            internal::CommonOptionFieldSpec<const bt_field>::field(this->libObjPtr());
-
-        if (libObjPtr) {
-            return ConstField {libObjPtr};
-        }
-
-        return nonstd::nullopt;
-    }
-
-    nonstd::optional<CommonField<LibObjT>> field() noexcept
+    nonstd::optional<CommonField<LibObjT>> field() const noexcept
     {
         const auto libObjPtr = _Spec::field(this->libObjPtr());
 
@@ -1522,31 +1433,19 @@ public:
         return *this;
     }
 
-    ConstVariantFieldClass cls() const noexcept
-    {
-        return ConstVariantFieldClass {
-            internal::CommonFieldSpec<const bt_field>::cls(this->libObjPtr())};
-    }
-
-    Class cls() noexcept
+    Class cls() const noexcept
     {
         return Class {internal::CommonFieldSpec<LibObjT>::cls(this->libObjPtr())};
     }
 
-    void selectOption(const std::uint64_t index) noexcept
+    void selectOption(const std::uint64_t index) const 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));
     }
 
-    ConstField selectedOptionField() const noexcept
-    {
-        return ConstField {internal::CommonVariantFieldSpec<const bt_field>::selectedOptionField(
-            this->libObjPtr())};
-    }
-
-    CommonField<LibObjT> selectedOptionField() noexcept
+    CommonField<LibObjT> selectedOptionField() const noexcept
     {
         return CommonField<LibObjT> {_Spec::selectedOptionField(this->libObjPtr())};
     }
diff --git a/src/cpp-common/bt2/integer-range-set.hpp b/src/cpp-common/bt2/integer-range-set.hpp
index f542c6a5..974aa600 100644
--- a/src/cpp-common/bt2/integer-range-set.hpp
+++ b/src/cpp-common/bt2/integer-range-set.hpp
@@ -220,7 +220,7 @@ public:
         return !(*this == other);
     }
 
-    void addRange(const Value lower, const Value upper)
+    void addRange(const Value lower, const Value upper) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
diff --git a/src/cpp-common/bt2/message.hpp b/src/cpp-common/bt2/message.hpp
index b74be2c5..5812b06d 100644
--- a/src/cpp-common/bt2/message.hpp
+++ b/src/cpp-common/bt2/message.hpp
@@ -253,19 +253,13 @@ public:
         return *this;
     }
 
-    ConstStream stream() const noexcept
-    {
-        return ConstStream {internal::CommonStreamBeginningMessageSpec<const bt_message>::stream(
-            this->libObjPtr())};
-    }
-
-    _Stream stream() noexcept
+    _Stream stream() const noexcept
     {
         return _Stream {
             internal::CommonStreamBeginningMessageSpec<LibObjT>::stream(this->libObjPtr())};
     }
 
-    void defaultClockSnapshot(const std::uint64_t val) noexcept
+    void defaultClockSnapshot(const std::uint64_t val) const noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -371,18 +365,12 @@ public:
         return *this;
     }
 
-    ConstStream stream() const noexcept
-    {
-        return ConstStream {
-            internal::CommonStreamEndMessageSpec<const bt_message>::stream(this->libObjPtr())};
-    }
-
-    _Stream stream() noexcept
+    _Stream stream() const noexcept
     {
         return _Stream {internal::CommonStreamEndMessageSpec<LibObjT>::stream(this->libObjPtr())};
     }
 
-    void defaultClockSnapshot(const std::uint64_t val) noexcept
+    void defaultClockSnapshot(const std::uint64_t val) const noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -488,19 +476,13 @@ public:
         return *this;
     }
 
-    ConstPacket packet() const noexcept
-    {
-        return ConstPacket {internal::CommonPacketBeginningMessageSpec<const bt_message>::packet(
-            this->libObjPtr())};
-    }
-
-    _Packet packet() noexcept
+    _Packet packet() const noexcept
     {
         return _Packet {
             internal::CommonPacketBeginningMessageSpec<LibObjT>::packet(this->libObjPtr())};
     }
 
-    void defaultClockSnapshot(const std::uint64_t val) noexcept
+    void defaultClockSnapshot(const std::uint64_t val) const noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -601,18 +583,12 @@ public:
         return *this;
     }
 
-    ConstPacket packet() const noexcept
-    {
-        return ConstPacket {
-            internal::CommonPacketEndMessageSpec<const bt_message>::packet(this->libObjPtr())};
-    }
-
-    _Packet packet() noexcept
+    _Packet packet() const noexcept
     {
         return _Packet {internal::CommonPacketEndMessageSpec<LibObjT>::packet(this->libObjPtr())};
     }
 
-    void defaultClockSnapshot(const std::uint64_t val) noexcept
+    void defaultClockSnapshot(const std::uint64_t val) const noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -712,13 +688,7 @@ public:
         return *this;
     }
 
-    ConstEvent event() const noexcept
-    {
-        return ConstEvent {
-            internal::CommonEventMessageSpec<const bt_message>::event(this->libObjPtr())};
-    }
-
-    _Event event() noexcept
+    _Event event() const noexcept
     {
         return _Event {internal::CommonEventMessageSpec<LibObjT>::event(this->libObjPtr())};
     }
@@ -817,13 +787,7 @@ public:
         return *this;
     }
 
-    ConstStream stream() const noexcept
-    {
-        return ConstStream {internal::CommonDiscardedEventsMessageSpec<const bt_message>::stream(
-            this->libObjPtr())};
-    }
-
-    _Stream stream() noexcept
+    _Stream stream() const noexcept
     {
         return _Stream {
             internal::CommonDiscardedEventsMessageSpec<LibObjT>::stream(this->libObjPtr())};
@@ -846,7 +810,7 @@ public:
         return ConstClockSnapshot {libObjPtr};
     }
 
-    void count(const std::uint64_t count) noexcept
+    void count(const std::uint64_t count) const noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -951,13 +915,7 @@ public:
         return *this;
     }
 
-    ConstStream stream() const noexcept
-    {
-        return ConstStream {internal::CommonDiscardedPacketsMessageSpec<const bt_message>::stream(
-            this->libObjPtr())};
-    }
-
-    _Stream stream() noexcept
+    _Stream stream() const noexcept
     {
         return _Stream {
             internal::CommonDiscardedPacketsMessageSpec<LibObjT>::stream(this->libObjPtr())};
@@ -980,7 +938,7 @@ public:
         return ConstClockSnapshot {libObjPtr};
     }
 
-    void count(const std::uint64_t count) noexcept
+    void count(const std::uint64_t count) const noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
diff --git a/src/cpp-common/bt2/trace-ir.hpp b/src/cpp-common/bt2/trace-ir.hpp
index 7a87c1cf..4d058137 100644
--- a/src/cpp-common/bt2/trace-ir.hpp
+++ b/src/cpp-common/bt2/trace-ir.hpp
@@ -129,7 +129,6 @@ class CommonEvent final : public BorrowedObject<LibObjT>
 private:
     using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
     using typename BorrowedObject<LibObjT>::_LibObjPtr;
-    using _ConstSpec = internal::CommonEventSpec<const bt_event>;
     using _Spec = internal::CommonEventSpec<LibObjT>;
 
     using _Packet =
@@ -164,25 +163,11 @@ public:
         return *this;
     }
 
-    CommonEventClass<const bt_event_class> cls() const noexcept;
-    Class cls() noexcept;
-    CommonStream<const bt_stream> stream() const noexcept;
-    _Stream stream() noexcept;
-    nonstd::optional<CommonPacket<const bt_packet>> packet() const noexcept;
-    nonstd::optional<_Packet> packet() noexcept;
+    Class cls() const noexcept;
+    _Stream stream() const noexcept;
+    nonstd::optional<_Packet> packet() const noexcept;
 
-    nonstd::optional<ConstStructureField> payloadField() const noexcept
-    {
-        const auto libObjPtr = _ConstSpec::payloadField(this->libObjPtr());
-
-        if (libObjPtr) {
-            return ConstStructureField {libObjPtr};
-        }
-
-        return nonstd::nullopt;
-    }
-
-    nonstd::optional<_StructureField> payloadField() noexcept
+    nonstd::optional<_StructureField> payloadField() const noexcept
     {
         const auto libObjPtr = _Spec::payloadField(this->libObjPtr());
 
@@ -193,18 +178,7 @@ public:
         return nonstd::nullopt;
     }
 
-    nonstd::optional<ConstStructureField> specificContextField() const noexcept
-    {
-        const auto libObjPtr = _ConstSpec::specificContextField(this->libObjPtr());
-
-        if (libObjPtr) {
-            return ConstStructureField {libObjPtr};
-        }
-
-        return nonstd::nullopt;
-    }
-
-    nonstd::optional<_StructureField> specificContextField() noexcept
+    nonstd::optional<_StructureField> specificContextField() const noexcept
     {
         const auto libObjPtr = _Spec::specificContextField(this->libObjPtr());
 
@@ -215,18 +189,7 @@ public:
         return nonstd::nullopt;
     }
 
-    nonstd::optional<ConstStructureField> commonContextField() const noexcept
-    {
-        const auto libObjPtr = _ConstSpec::commonContextField(this->libObjPtr());
-
-        if (libObjPtr) {
-            return ConstStructureField {libObjPtr};
-        }
-
-        return nonstd::nullopt;
-    }
-
-    nonstd::optional<_StructureField> commonContextField() noexcept
+    nonstd::optional<_StructureField> commonContextField() const noexcept
     {
         const auto libObjPtr = _Spec::commonContextField(this->libObjPtr());
 
@@ -313,7 +276,6 @@ class CommonPacket final : public BorrowedObject<LibObjT>
 private:
     using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
     using typename BorrowedObject<LibObjT>::_LibObjPtr;
-    using _ConstSpec = internal::CommonPacketSpec<const bt_packet>;
     using _Spec = internal::CommonPacketSpec<LibObjT>;
     using _ThisCommonPacket = CommonPacket<LibObjT>;
 
@@ -343,21 +305,9 @@ public:
         return *this;
     }
 
-    CommonStream<const bt_stream> stream() const noexcept;
-    _Stream stream() noexcept;
-
-    nonstd::optional<ConstStructureField> contextField() const noexcept
-    {
-        const auto libObjPtr = _ConstSpec::contextField(this->libObjPtr());
-
-        if (libObjPtr) {
-            return ConstStructureField {libObjPtr};
-        }
-
-        return nonstd::nullopt;
-    }
+    _Stream stream() const noexcept;
 
-    nonstd::optional<_StructureField> contextField() noexcept
+    nonstd::optional<_StructureField> contextField() const noexcept
     {
         const auto libObjPtr = _Spec::contextField(this->libObjPtr());
 
@@ -398,19 +348,8 @@ struct TypeDescr<ConstPacket> : public PacketTypeDescr
 } /* namespace internal */
 
 template <typename LibObjT>
-nonstd::optional<ConstPacket> CommonEvent<LibObjT>::packet() const noexcept
-{
-    const auto libObjPtr = _ConstSpec::packet(this->libObjPtr());
-
-    if (libObjPtr) {
-        return ConstPacket {libObjPtr};
-    }
-
-    return nonstd::nullopt;
-}
-
-template <typename LibObjT>
-nonstd::optional<typename CommonEvent<LibObjT>::_Packet> CommonEvent<LibObjT>::packet() noexcept
+nonstd::optional<typename CommonEvent<LibObjT>::_Packet>
+CommonEvent<LibObjT>::packet() const noexcept
 {
     const auto libObjPtr = _Spec::packet(this->libObjPtr());
 
@@ -487,7 +426,6 @@ class CommonStream final : public BorrowedObject<LibObjT>
 private:
     using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
     using typename BorrowedObject<LibObjT>::_LibObjPtr;
-    using _ConstSpec = internal::CommonStreamSpec<const bt_stream>;
     using _Spec = internal::CommonStreamSpec<LibObjT>;
     using _ThisCommonStream = CommonStream<LibObjT>;
 
@@ -521,7 +459,7 @@ public:
         return *this;
     }
 
-    Packet::Shared createPacket()
+    Packet::Shared createPacket() const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -531,17 +469,15 @@ public:
         return Packet::Shared::createWithoutRef(libObjPtr);
     }
 
-    CommonStreamClass<const bt_stream_class> cls() const noexcept;
-    Class cls() noexcept;
-    CommonTrace<const bt_trace> trace() const noexcept;
-    _Trace trace() noexcept;
+    Class cls() const noexcept;
+    _Trace trace() const noexcept;
 
     std::uint64_t id() const noexcept
     {
         return bt_stream_get_id(this->libObjPtr());
     }
 
-    void name(const char * const name)
+    void name(const char * const name) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -552,7 +488,7 @@ public:
         }
     }
 
-    void name(const std::string& name)
+    void name(const std::string& name) const
     {
         this->name(name.data());
     }
@@ -569,19 +505,14 @@ public:
     }
 
     template <typename LibValT>
-    void userAttributes(const CommonMapValue<LibValT> userAttrs)
+    void userAttributes(const CommonMapValue<LibValT> userAttrs) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
         bt_stream_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
     }
 
-    ConstMapValue userAttributes() const noexcept
-    {
-        return ConstMapValue {_ConstSpec::userAttributes(this->libObjPtr())};
-    }
-
-    UserAttributes userAttributes() noexcept
+    UserAttributes userAttributes() const noexcept
     {
         return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
     }
@@ -616,25 +547,13 @@ struct TypeDescr<ConstStream> : public StreamTypeDescr
 } /* namespace internal */
 
 template <typename LibObjT>
-ConstStream CommonEvent<LibObjT>::stream() const noexcept
-{
-    return ConstStream {_ConstSpec::stream(this->libObjPtr())};
-}
-
-template <typename LibObjT>
-typename CommonEvent<LibObjT>::_Stream CommonEvent<LibObjT>::stream() noexcept
+typename CommonEvent<LibObjT>::_Stream CommonEvent<LibObjT>::stream() const noexcept
 {
     return _Stream {_Spec::stream(this->libObjPtr())};
 }
 
 template <typename LibObjT>
-ConstStream CommonPacket<LibObjT>::stream() const noexcept
-{
-    return ConstStream {_ConstSpec::stream(this->libObjPtr())};
-}
-
-template <typename LibObjT>
-typename CommonPacket<LibObjT>::_Stream CommonPacket<LibObjT>::stream() noexcept
+typename CommonPacket<LibObjT>::_Stream CommonPacket<LibObjT>::stream() const noexcept
 {
     return _Stream {_Spec::stream(this->libObjPtr())};
 }
@@ -720,7 +639,6 @@ class CommonTrace final : public BorrowedObject<LibObjT>
 private:
     using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
     using typename BorrowedObject<LibObjT>::_LibObjPtr;
-    using _ConstSpec = internal::CommonTraceSpec<const bt_trace>;
     using _Spec = internal::CommonTraceSpec<LibObjT>;
     using _ThisCommonTrace = CommonTrace<LibObjT>;
 
@@ -760,10 +678,9 @@ public:
         return *this;
     }
 
-    CommonTraceClass<const bt_trace_class> cls() const noexcept;
-    Class cls() noexcept;
+    Class cls() const noexcept;
 
-    void name(const char * const name)
+    void name(const char * const name) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -774,7 +691,7 @@ public:
         }
     }
 
-    void name(const std::string& name)
+    void name(const std::string& name) const
     {
         this->name(name.data());
     }
@@ -790,7 +707,7 @@ public:
         return nonstd::nullopt;
     }
 
-    void uuid(const bt2_common::UuidView& uuid) noexcept
+    void uuid(const bt2_common::UuidView& uuid) const noexcept
     {
         bt_trace_set_uuid(this->libObjPtr(), uuid.begin());
     }
@@ -811,28 +728,12 @@ public:
         return bt_trace_get_stream_count(this->libObjPtr());
     }
 
-    ConstStream operator[](const std::uint64_t index) const noexcept
-    {
-        return ConstStream {_ConstSpec::streamByIndex(this->libObjPtr(), index)};
-    }
-
-    _Stream operator[](const std::uint64_t index) noexcept
+    _Stream operator[](const std::uint64_t index) const noexcept
     {
         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);
-
-        if (libObjPtr) {
-            return ConstStream {libObjPtr};
-        }
-
-        return nonstd::nullopt;
-    }
-
-    nonstd::optional<_Stream> streamById(const std::uint64_t id) noexcept
+    nonstd::optional<_Stream> streamById(const std::uint64_t id) const noexcept
     {
         const auto libObjPtr = _Spec::streamById(this->libObjPtr(), id);
 
@@ -843,7 +744,7 @@ public:
         return nonstd::nullopt;
     }
 
-    void environmentEntry(const char * const name, const std::int64_t val)
+    void environmentEntry(const char * const name, const std::int64_t val) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -854,12 +755,12 @@ public:
         }
     }
 
-    void environmentEntry(const std::string& name, const std::int64_t val)
+    void environmentEntry(const std::string& name, const std::int64_t val) const
     {
         this->environmentEntry(name.data(), val);
     }
 
-    void environmentEntry(const char * const name, const char * const val)
+    void environmentEntry(const char * const name, const char * const val) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -870,17 +771,17 @@ public:
         }
     }
 
-    void environmentEntry(const std::string& name, const char * const val)
+    void environmentEntry(const std::string& name, const char * const val) const
     {
         this->environmentEntry(name.data(), val);
     }
 
-    void environmentEntry(const char * const name, const std::string& val)
+    void environmentEntry(const char * const name, const std::string& val) const
     {
         this->environmentEntry(name, val.data());
     }
 
-    void environmentEntry(const std::string& name, const std::string& val)
+    void environmentEntry(const std::string& name, const std::string& val) const
     {
         this->environmentEntry(name.data(), val.data());
     }
@@ -918,19 +819,14 @@ public:
     }
 
     template <typename LibValT>
-    void userAttributes(const CommonMapValue<LibValT> userAttrs)
+    void userAttributes(const CommonMapValue<LibValT> userAttrs) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
         bt_trace_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
     }
 
-    ConstMapValue userAttributes() const noexcept
-    {
-        return ConstMapValue {_ConstSpec::userAttributes(this->libObjPtr())};
-    }
-
-    UserAttributes userAttributes() noexcept
+    UserAttributes userAttributes() const noexcept
     {
         return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
     }
@@ -965,13 +861,7 @@ struct TypeDescr<ConstTrace> : public TraceTypeDescr
 } /* namespace internal */
 
 template <typename LibObjT>
-ConstTrace CommonStream<LibObjT>::trace() const noexcept
-{
-    return ConstTrace {_ConstSpec::trace(this->libObjPtr())};
-}
-
-template <typename LibObjT>
-typename CommonStream<LibObjT>::_Trace CommonStream<LibObjT>::trace() noexcept
+typename CommonStream<LibObjT>::_Trace CommonStream<LibObjT>::trace() const noexcept
 {
     return _Trace {_Spec::trace(this->libObjPtr())};
 }
@@ -1053,7 +943,6 @@ class CommonEventClass final : public BorrowedObject<LibObjT>
 private:
     using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
     using typename BorrowedObject<LibObjT>::_LibObjPtr;
-    using _ConstSpec = internal::CommonEventClassSpec<const bt_event_class>;
     using _Spec = internal::CommonEventClassSpec<LibObjT>;
     using _ThisCommonEventClass = CommonEventClass<LibObjT>;
 
@@ -1107,15 +996,14 @@ public:
         return *this;
     }
 
-    CommonStreamClass<const bt_stream_class> streamClass() const noexcept;
-    _StreamClass streamClass() noexcept;
+    _StreamClass streamClass() const noexcept;
 
     std::uint64_t id() const noexcept
     {
         return bt_event_class_get_id(this->libObjPtr());
     }
 
-    void name(const char * const name)
+    void name(const char * const name) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -1126,7 +1014,7 @@ public:
         }
     }
 
-    void name(const std::string& name)
+    void name(const std::string& name) const
     {
         this->name(name.data());
     }
@@ -1142,7 +1030,7 @@ public:
         return nonstd::nullopt;
     }
 
-    void logLevel(const LogLevel logLevel) noexcept
+    void logLevel(const LogLevel logLevel) const noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -1162,7 +1050,7 @@ public:
         return nonstd::nullopt;
     }
 
-    void emfUri(const char * const emfUri)
+    void emfUri(const char * const emfUri) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -1173,7 +1061,7 @@ public:
         }
     }
 
-    void emfUri(const std::string& emfUri)
+    void emfUri(const std::string& emfUri) const
     {
         this->emfUri(emfUri.data());
     }
@@ -1189,7 +1077,7 @@ public:
         return nonstd::nullopt;
     }
 
-    void payloadFieldClass(const StructureFieldClass fc)
+    void payloadFieldClass(const StructureFieldClass fc) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -1201,18 +1089,7 @@ public:
         }
     }
 
-    nonstd::optional<ConstStructureFieldClass> payloadFieldClass() const noexcept
-    {
-        const auto libObjPtr = _ConstSpec::payloadFieldClass(this->libObjPtr());
-
-        if (libObjPtr) {
-            return ConstStructureFieldClass {libObjPtr};
-        }
-
-        return nonstd::nullopt;
-    }
-
-    nonstd::optional<_StructureFieldClass> payloadFieldClass() noexcept
+    nonstd::optional<_StructureFieldClass> payloadFieldClass() const noexcept
     {
         const auto libObjPtr = _Spec::payloadFieldClass(this->libObjPtr());
 
@@ -1223,7 +1100,7 @@ public:
         return nonstd::nullopt;
     }
 
-    void specificContextFieldClass(const StructureFieldClass fc)
+    void specificContextFieldClass(const StructureFieldClass fc) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -1235,18 +1112,7 @@ public:
         }
     }
 
-    nonstd::optional<ConstStructureFieldClass> specificContextFieldClass() const noexcept
-    {
-        const auto libObjPtr = _ConstSpec::specificContextFieldClass(this->libObjPtr());
-
-        if (libObjPtr) {
-            return ConstStructureFieldClass {libObjPtr};
-        }
-
-        return nonstd::nullopt;
-    }
-
-    nonstd::optional<_StructureFieldClass> specificContextFieldClass() noexcept
+    nonstd::optional<_StructureFieldClass> specificContextFieldClass() const noexcept
     {
         const auto libObjPtr = _Spec::specificContextFieldClass(this->libObjPtr());
 
@@ -1258,19 +1124,14 @@ public:
     }
 
     template <typename LibValT>
-    void userAttributes(const CommonMapValue<LibValT> userAttrs)
+    void userAttributes(const CommonMapValue<LibValT> userAttrs) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
         bt_event_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
     }
 
-    ConstMapValue userAttributes() const noexcept
-    {
-        return ConstMapValue {_ConstSpec::userAttributes(this->libObjPtr())};
-    }
-
-    UserAttributes userAttributes() noexcept
+    UserAttributes userAttributes() const noexcept
     {
         return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
     }
@@ -1305,13 +1166,7 @@ struct TypeDescr<ConstEventClass> : public EventClassTypeDescr
 } /* namespace internal */
 
 template <typename LibObjT>
-ConstEventClass CommonEvent<LibObjT>::cls() const noexcept
-{
-    return ConstEventClass {_ConstSpec::cls(this->libObjPtr())};
-}
-
-template <typename LibObjT>
-typename CommonEvent<LibObjT>::Class CommonEvent<LibObjT>::cls() noexcept
+typename CommonEvent<LibObjT>::Class CommonEvent<LibObjT>::cls() const noexcept
 {
     return Class {_Spec::cls(this->libObjPtr())};
 }
@@ -1428,7 +1283,6 @@ class CommonStreamClass final : public BorrowedObject<LibObjT>
 private:
     using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
     using typename BorrowedObject<LibObjT>::_LibObjPtr;
-    using _ConstSpec = internal::CommonStreamClassSpec<const bt_stream_class>;
     using _Spec = internal::CommonStreamClassSpec<LibObjT>;
     using _ThisCommonStreamClass = CommonStreamClass<LibObjT>;
 
@@ -1471,7 +1325,7 @@ public:
         return *this;
     }
 
-    Stream::Shared instantiate(const Trace trace)
+    Stream::Shared instantiate(const Trace trace) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -1481,7 +1335,7 @@ public:
         return Stream::Shared::createWithoutRef(libObjPtr);
     }
 
-    Stream::Shared instantiate(const Trace trace, const std::uint64_t id)
+    Stream::Shared instantiate(const Trace trace, const std::uint64_t id) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -1491,7 +1345,7 @@ public:
         return Stream::Shared::createWithoutRef(libObjPtr);
     }
 
-    EventClass::Shared createEventClass()
+    EventClass::Shared createEventClass() const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -1501,7 +1355,7 @@ public:
         return EventClass::Shared::createWithoutRef(libObjPtr);
     }
 
-    EventClass::Shared createEventClass(const std::uint64_t id)
+    EventClass::Shared createEventClass(const std::uint64_t id) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -1511,15 +1365,14 @@ public:
         return EventClass::Shared::createWithoutRef(libObjPtr);
     }
 
-    CommonTraceClass<const bt_trace_class> traceClass() const noexcept;
-    _TraceClass traceClass() noexcept;
+    _TraceClass traceClass() const noexcept;
 
     std::uint64_t id() const noexcept
     {
         return bt_stream_class_get_id(this->libObjPtr());
     }
 
-    void name(const char * const name)
+    void name(const char * const name) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -1530,7 +1383,7 @@ public:
         }
     }
 
-    void name(const std::string& name)
+    void name(const std::string& name) const
     {
         this->name(name.data());
     }
@@ -1546,7 +1399,7 @@ public:
         return nonstd::nullopt;
     }
 
-    void assignsAutomaticEventClassId(const bool val) noexcept
+    void assignsAutomaticEventClassId(const bool val) const noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -1560,7 +1413,7 @@ public:
             bt_stream_class_assigns_automatic_event_class_id(this->libObjPtr()));
     }
 
-    void assignsAutomaticStreamId(const bool val) noexcept
+    void assignsAutomaticStreamId(const bool val) const noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -1574,7 +1427,7 @@ public:
     }
 
     void supportsPackets(const bool supportsPackets, const bool withBeginningDefaultClkSnapshot,
-                         const bool withEndDefaultClkSnapshot) noexcept
+                         const bool withEndDefaultClkSnapshot) const noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -1602,7 +1455,7 @@ public:
     }
 
     void supportsDiscardedEvents(const bool supportsDiscardedEvents,
-                                 const bool withDefaultClkSnapshots) noexcept
+                                 const bool withDefaultClkSnapshots) const noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -1623,7 +1476,7 @@ public:
     }
 
     void supportsDiscardedPackets(const bool supportsDiscardedPackets,
-                                  const bool withDefaultClkSnapshots) noexcept
+                                  const bool withDefaultClkSnapshots) const noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -1643,7 +1496,7 @@ public:
             bt_stream_class_discarded_packets_have_default_clock_snapshots(this->libObjPtr()));
     }
 
-    void defaultClockClass(const ClockClass clkCls)
+    void defaultClockClass(const ClockClass clkCls) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -1653,18 +1506,7 @@ public:
         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());
-
-        if (libObjPtr) {
-            return ConstClockClass {libObjPtr};
-        }
-
-        return nonstd::nullopt;
-    }
-
-    nonstd::optional<_ClockClass> defaultClockClass() noexcept
+    nonstd::optional<_ClockClass> defaultClockClass() const noexcept
     {
         const auto libObjPtr = _Spec::defaultClockClass(this->libObjPtr());
 
@@ -1680,28 +1522,12 @@ public:
         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)};
-    }
-
-    _EventClass operator[](const std::uint64_t index) noexcept
+    _EventClass operator[](const std::uint64_t index) const noexcept
     {
         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);
-
-        if (libObjPtr) {
-            return ConstEventClass {libObjPtr};
-        }
-
-        return nonstd::nullopt;
-    }
-
-    nonstd::optional<_EventClass> eventClassById(const std::uint64_t id) noexcept
+    nonstd::optional<_EventClass> eventClassById(const std::uint64_t id) const noexcept
     {
         const auto libObjPtr = _Spec::eventClassById(this->libObjPtr(), id);
 
@@ -1712,7 +1538,7 @@ public:
         return nonstd::nullopt;
     }
 
-    void packetContextFieldClass(const StructureFieldClass fc)
+    void packetContextFieldClass(const StructureFieldClass fc) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -1724,18 +1550,7 @@ public:
         }
     }
 
-    nonstd::optional<ConstStructureFieldClass> packetContextFieldClass() const noexcept
-    {
-        const auto libObjPtr = _ConstSpec::packetContextFieldClass(this->libObjPtr());
-
-        if (libObjPtr) {
-            return ConstStructureFieldClass {libObjPtr};
-        }
-
-        return nonstd::nullopt;
-    }
-
-    nonstd::optional<_StructureFieldClass> packetContextFieldClass() noexcept
+    nonstd::optional<_StructureFieldClass> packetContextFieldClass() const noexcept
     {
         const auto libObjPtr = _Spec::packetContextFieldClass(this->libObjPtr());
 
@@ -1746,7 +1561,7 @@ public:
         return nonstd::nullopt;
     }
 
-    void eventCommonContextFieldClass(const StructureFieldClass fc)
+    void eventCommonContextFieldClass(const StructureFieldClass fc) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -1758,18 +1573,7 @@ public:
         }
     }
 
-    nonstd::optional<ConstStructureFieldClass> eventCommonContextFieldClass() const noexcept
-    {
-        const auto libObjPtr = _ConstSpec::eventCommonContextFieldClass(this->libObjPtr());
-
-        if (libObjPtr) {
-            return ConstStructureFieldClass {libObjPtr};
-        }
-
-        return nonstd::nullopt;
-    }
-
-    nonstd::optional<_StructureFieldClass> eventCommonContextFieldClass() noexcept
+    nonstd::optional<_StructureFieldClass> eventCommonContextFieldClass() const noexcept
     {
         const auto libObjPtr = _Spec::eventCommonContextFieldClass(this->libObjPtr());
 
@@ -1781,19 +1585,14 @@ public:
     }
 
     template <typename LibValT>
-    void userAttributes(const CommonMapValue<LibValT> userAttrs)
+    void userAttributes(const CommonMapValue<LibValT> userAttrs) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
         bt_stream_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
     }
 
-    ConstMapValue userAttributes() const noexcept
-    {
-        return ConstMapValue {_ConstSpec::userAttributes(this->libObjPtr())};
-    }
-
-    UserAttributes userAttributes() noexcept
+    UserAttributes userAttributes() const noexcept
     {
         return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
     }
@@ -1828,25 +1627,14 @@ struct TypeDescr<ConstStreamClass> : public StreamClassTypeDescr
 } /* namespace internal */
 
 template <typename LibObjT>
-ConstStreamClass CommonEventClass<LibObjT>::streamClass() const noexcept
-{
-    return ConstStreamClass {_ConstSpec::streamClass(this->libObjPtr())};
-}
-
-template <typename LibObjT>
-typename CommonEventClass<LibObjT>::_StreamClass CommonEventClass<LibObjT>::streamClass() noexcept
+typename CommonEventClass<LibObjT>::_StreamClass
+CommonEventClass<LibObjT>::streamClass() const noexcept
 {
     return _StreamClass {_Spec::streamClass(this->libObjPtr())};
 }
 
 template <typename LibObjT>
-ConstStreamClass CommonStream<LibObjT>::cls() const noexcept
-{
-    return ConstStreamClass {_ConstSpec::cls(this->libObjPtr())};
-}
-
-template <typename LibObjT>
-typename CommonStream<LibObjT>::Class CommonStream<LibObjT>::cls() noexcept
+typename CommonStream<LibObjT>::Class CommonStream<LibObjT>::cls() const noexcept
 {
     return Class {_Spec::cls(this->libObjPtr())};
 }
@@ -1921,7 +1709,6 @@ class CommonTraceClass final : public BorrowedObject<LibObjT>
 private:
     using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
     using typename BorrowedObject<LibObjT>::_LibObjPtr;
-    using _ConstSpec = internal::CommonTraceClassSpec<const bt_trace_class>;
     using _Spec = internal::CommonTraceClassSpec<LibObjT>;
     using _ThisCommonTraceClass = CommonTraceClass<LibObjT>;
 
@@ -1952,7 +1739,7 @@ public:
         return *this;
     }
 
-    Trace::Shared instantiate()
+    Trace::Shared instantiate() const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -1962,7 +1749,7 @@ public:
         return Trace::Shared::createWithoutRef(libObjPtr);
     }
 
-    StreamClass::Shared createStreamClass()
+    StreamClass::Shared createStreamClass() const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -1972,7 +1759,7 @@ public:
         return StreamClass::Shared::createWithoutRef(libObjPtr);
     }
 
-    StreamClass::Shared createStreamClass(const std::uint64_t id)
+    StreamClass::Shared createStreamClass(const std::uint64_t id) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -1982,7 +1769,7 @@ public:
         return StreamClass::Shared::createWithoutRef(libObjPtr);
     }
 
-    FieldClass::Shared createBoolFieldClass()
+    FieldClass::Shared createBoolFieldClass() const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -1992,7 +1779,7 @@ public:
         return FieldClass::Shared::createWithoutRef(libObjPtr);
     }
 
-    BitArrayFieldClass::Shared createBitArrayFieldClass(const std::uint64_t length)
+    BitArrayFieldClass::Shared createBitArrayFieldClass(const std::uint64_t length) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -2002,7 +1789,7 @@ public:
         return BitArrayFieldClass::Shared::createWithoutRef(libObjPtr);
     }
 
-    IntegerFieldClass::Shared createUnsignedIntegerFieldClass()
+    IntegerFieldClass::Shared createUnsignedIntegerFieldClass() const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -2012,7 +1799,7 @@ public:
         return IntegerFieldClass::Shared::createWithoutRef(libObjPtr);
     }
 
-    IntegerFieldClass::Shared createSignedIntegerFieldClass()
+    IntegerFieldClass::Shared createSignedIntegerFieldClass() const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -2022,7 +1809,7 @@ public:
         return IntegerFieldClass::Shared::createWithoutRef(libObjPtr);
     }
 
-    UnsignedEnumerationFieldClass::Shared createUnsignedEnumerationFieldClass()
+    UnsignedEnumerationFieldClass::Shared createUnsignedEnumerationFieldClass() const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -2032,7 +1819,7 @@ public:
         return UnsignedEnumerationFieldClass::Shared::createWithoutRef(libObjPtr);
     }
 
-    SignedEnumerationFieldClass::Shared createSignedEnumerationFieldClass()
+    SignedEnumerationFieldClass::Shared createSignedEnumerationFieldClass() const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -2042,7 +1829,7 @@ public:
         return SignedEnumerationFieldClass::Shared::createWithoutRef(libObjPtr);
     }
 
-    FieldClass::Shared createSinglePrecisionRealFieldClass()
+    FieldClass::Shared createSinglePrecisionRealFieldClass() const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -2052,7 +1839,7 @@ public:
         return FieldClass::Shared::createWithoutRef(libObjPtr);
     }
 
-    FieldClass::Shared createDoublePrecisionRealFieldClass()
+    FieldClass::Shared createDoublePrecisionRealFieldClass() const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -2062,7 +1849,7 @@ public:
         return FieldClass::Shared::createWithoutRef(libObjPtr);
     }
 
-    FieldClass::Shared createStringFieldClass()
+    FieldClass::Shared createStringFieldClass() const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -2073,7 +1860,7 @@ public:
     }
 
     StaticArrayFieldClass::Shared createStaticArrayFieldClass(const FieldClass elementFieldClass,
-                                                              const std::uint64_t length)
+                                                              const std::uint64_t length) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -2084,7 +1871,7 @@ public:
         return StaticArrayFieldClass::Shared::createWithoutRef(libObjPtr);
     }
 
-    ArrayFieldClass::Shared createDynamicArrayFieldClass(const FieldClass elementFieldClass)
+    ArrayFieldClass::Shared createDynamicArrayFieldClass(const FieldClass elementFieldClass) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -2097,7 +1884,7 @@ public:
 
     DynamicArrayWithLengthFieldClass::Shared
     createDynamicArrayFieldClass(const FieldClass elementFieldClass,
-                                 const IntegerFieldClass lengthFieldClass)
+                                 const IntegerFieldClass lengthFieldClass) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -2108,7 +1895,7 @@ public:
         return DynamicArrayWithLengthFieldClass::Shared::createWithoutRef(libObjPtr);
     }
 
-    StructureFieldClass::Shared createStructureFieldClass()
+    StructureFieldClass::Shared createStructureFieldClass() const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -2118,7 +1905,7 @@ public:
         return StructureFieldClass::Shared::createWithoutRef(libObjPtr);
     }
 
-    OptionFieldClass::Shared createOptionFieldClass(const FieldClass optionalFieldClass)
+    OptionFieldClass::Shared createOptionFieldClass(const FieldClass optionalFieldClass) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -2131,7 +1918,7 @@ public:
 
     OptionWithBoolSelectorFieldClass::Shared
     createOptionWithBoolSelectorFieldClass(const FieldClass optionalFieldClass,
-                                           const FieldClass selectorFieldClass)
+                                           const FieldClass selectorFieldClass) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -2143,9 +1930,9 @@ public:
     }
 
     OptionWithUnsignedIntegerSelectorFieldClass::Shared
-    createOptionWithUnsignedIntegerSelectorFieldClass(const FieldClass optionalFieldClass,
-                                                      const IntegerFieldClass selectorFieldClass,
-                                                      const ConstUnsignedIntegerRangeSet ranges)
+    createOptionWithUnsignedIntegerSelectorFieldClass(
+        const FieldClass optionalFieldClass, const IntegerFieldClass selectorFieldClass,
+        const ConstUnsignedIntegerRangeSet ranges) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -2160,7 +1947,7 @@ public:
     OptionWithSignedIntegerSelectorFieldClass::Shared
     createOptionWithSignedIntegerSelectorFieldClass(const FieldClass optionalFieldClass,
                                                     const IntegerFieldClass selectorFieldClass,
-                                                    const ConstSignedIntegerRangeSet ranges)
+                                                    const ConstSignedIntegerRangeSet ranges) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -2172,7 +1959,7 @@ public:
         return OptionWithSignedIntegerSelectorFieldClass::Shared::createWithoutRef(libObjPtr);
     }
 
-    VariantWithoutSelectorFieldClass::Shared createVariantFieldClass()
+    VariantWithoutSelectorFieldClass::Shared createVariantFieldClass() const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -2183,20 +1970,22 @@ public:
     }
 
     VariantWithUnsignedIntegerSelectorFieldClass::Shared
-    createVariantWithUnsignedIntegerSelectorFieldClass(const IntegerFieldClass selectorFieldClass)
+    createVariantWithUnsignedIntegerSelectorFieldClass(
+        const IntegerFieldClass selectorFieldClass) const
     {
         return this->_createVariantWithIntegerSelectorFieldClass<
             VariantWithUnsignedIntegerSelectorFieldClass>(selectorFieldClass);
     }
 
     VariantWithSignedIntegerSelectorFieldClass::Shared
-    createVariantWithSignedIntegerSelectorFieldClass(const IntegerFieldClass selectorFieldClass)
+    createVariantWithSignedIntegerSelectorFieldClass(
+        const IntegerFieldClass selectorFieldClass) const
     {
         return this->_createVariantWithIntegerSelectorFieldClass<
             VariantWithSignedIntegerSelectorFieldClass>(selectorFieldClass);
     }
 
-    void assignsAutomaticStreamClassId(const bool val) noexcept
+    void assignsAutomaticStreamClassId(const bool val) const noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -2215,28 +2004,12 @@ public:
         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)};
-    }
-
-    _StreamClass operator[](const std::uint64_t index) noexcept
+    _StreamClass operator[](const std::uint64_t index) const noexcept
     {
         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);
-
-        if (libObjPtr) {
-            return ConstStreamClass {libObjPtr};
-        }
-
-        return nonstd::nullopt;
-    }
-
-    nonstd::optional<_StreamClass> streamClassById(const std::uint64_t id) noexcept
+    nonstd::optional<_StreamClass> streamClassById(const std::uint64_t id) const noexcept
     {
         const auto libObjPtr = _Spec::streamClassById(this->libObjPtr(), id);
 
@@ -2248,19 +2021,14 @@ public:
     }
 
     template <typename LibValT>
-    void userAttributes(const CommonMapValue<LibValT> userAttrs)
+    void userAttributes(const CommonMapValue<LibValT> userAttrs) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
         bt_trace_class_set_user_attributes(this->libObjPtr(), userAttrs.libObjPtr());
     }
 
-    ConstMapValue userAttributes() const noexcept
-    {
-        return ConstMapValue {_ConstSpec::userAttributes(this->libObjPtr())};
-    }
-
-    UserAttributes userAttributes() noexcept
+    UserAttributes userAttributes() const noexcept
     {
         return UserAttributes {_Spec::userAttributes(this->libObjPtr())};
     }
@@ -2273,7 +2041,7 @@ public:
 private:
     template <typename ObjT>
     typename ObjT::Shared
-    _createVariantWithIntegerSelectorFieldClass(const IntegerFieldClass selectorFieldClass)
+    _createVariantWithIntegerSelectorFieldClass(const IntegerFieldClass selectorFieldClass) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -2309,25 +2077,14 @@ struct TypeDescr<ConstTraceClass> : public TraceClassTypeDescr
 } /* namespace internal */
 
 template <typename LibObjT>
-ConstTraceClass CommonStreamClass<LibObjT>::traceClass() const noexcept
-{
-    return ConstTraceClass {_ConstSpec::traceClass(this->libObjPtr())};
-}
-
-template <typename LibObjT>
-typename CommonStreamClass<LibObjT>::_TraceClass CommonStreamClass<LibObjT>::traceClass() noexcept
+typename CommonStreamClass<LibObjT>::_TraceClass
+CommonStreamClass<LibObjT>::traceClass() const noexcept
 {
     return _TraceClass {_Spec::traceClass(this->libObjPtr())};
 }
 
 template <typename LibObjT>
-ConstTraceClass CommonTrace<LibObjT>::cls() const noexcept
-{
-    return ConstTraceClass {_ConstSpec::cls(this->libObjPtr())};
-}
-
-template <typename LibObjT>
-typename CommonTrace<LibObjT>::Class CommonTrace<LibObjT>::cls() noexcept
+typename CommonTrace<LibObjT>::Class CommonTrace<LibObjT>::cls() const noexcept
 {
     return Class {_Spec::cls(this->libObjPtr())};
 }
diff --git a/src/cpp-common/bt2/value.hpp b/src/cpp-common/bt2/value.hpp
index e83b8aa5..7c4e4a99 100644
--- a/src/cpp-common/bt2/value.hpp
+++ b/src/cpp-common/bt2/value.hpp
@@ -348,7 +348,7 @@ public:
         return *this;
     }
 
-    CommonBoolValue<LibObjT>& operator=(const Value rawVal) noexcept
+    CommonBoolValue<LibObjT> operator=(const Value rawVal) const noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -436,7 +436,7 @@ public:
         return *this;
     }
 
-    CommonUnsignedIntegerValue<LibObjT>& operator=(const Value rawVal) noexcept
+    CommonUnsignedIntegerValue<LibObjT> operator=(const Value rawVal) const noexcept
     {
         bt_value_integer_unsigned_set(this->libObjPtr(), rawVal);
         return *this;
@@ -513,14 +513,14 @@ public:
     }
 
     template <typename OtherLibObjT>
-    CommonSignedIntegerValue<LibObjT>&
+    CommonSignedIntegerValue<LibObjT>
     operator=(const CommonSignedIntegerValue<OtherLibObjT> val) noexcept
     {
         _ThisCommonValue::operator=(val);
         return *this;
     }
 
-    CommonSignedIntegerValue<LibObjT>& operator=(const Value rawVal) noexcept
+    CommonSignedIntegerValue<LibObjT> operator=(const Value rawVal) const noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -603,7 +603,7 @@ public:
         return *this;
     }
 
-    CommonRealValue<LibObjT>& operator=(const Value rawVal) noexcept
+    CommonRealValue<LibObjT> operator=(const Value rawVal) const noexcept
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -690,7 +690,7 @@ public:
         return *this;
     }
 
-    CommonStringValue<LibObjT>& operator=(const char * const rawVal)
+    CommonStringValue<LibObjT> operator=(const char * const rawVal) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -703,7 +703,7 @@ public:
         return *this;
     }
 
-    CommonStringValue<LibObjT>& operator=(const std::string& rawVal) noexcept
+    CommonStringValue<LibObjT> operator=(const std::string& rawVal) const noexcept
     {
         return *this = rawVal.data();
     }
@@ -828,19 +828,13 @@ public:
         return this->length() == 0;
     }
 
-    ConstValue operator[](const std::uint64_t index) const noexcept
-    {
-        return ConstValue {internal::CommonArrayValueSpec<const bt_value>::elementByIndex(
-            this->libObjPtr(), index)};
-    }
-
-    CommonValue<LibObjT> operator[](const std::uint64_t index) noexcept
+    CommonValue<LibObjT> operator[](const std::uint64_t index) const noexcept
     {
         return CommonValue<LibObjT> {
             internal::CommonArrayValueSpec<LibObjT>::elementByIndex(this->libObjPtr(), index)};
     }
 
-    void append(const Value val)
+    void append(const Value val) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -849,7 +843,7 @@ public:
         this->_handleAppendLibStatus(status);
     }
 
-    void append(const bool rawVal)
+    void append(const bool rawVal) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -859,7 +853,7 @@ public:
         this->_handleAppendLibStatus(status);
     }
 
-    void append(const std::uint64_t rawVal)
+    void append(const std::uint64_t rawVal) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -869,7 +863,7 @@ public:
         this->_handleAppendLibStatus(status);
     }
 
-    void append(const std::int64_t rawVal)
+    void append(const std::int64_t rawVal) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -878,7 +872,7 @@ public:
         this->_handleAppendLibStatus(status);
     }
 
-    void append(const double rawVal)
+    void append(const double rawVal) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -887,7 +881,7 @@ public:
         this->_handleAppendLibStatus(status);
     }
 
-    void append(const char * const rawVal)
+    void append(const char * const rawVal) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -896,45 +890,45 @@ public:
         this->_handleAppendLibStatus(status);
     }
 
-    void append(const std::string& rawVal)
+    void append(const std::string& rawVal) const
     {
         this->append(rawVal.data());
     }
 
-    CommonArrayValue<bt_value> appendEmptyArray();
-    CommonMapValue<bt_value> appendEmptyMap();
+    CommonArrayValue<bt_value> appendEmptyArray() const;
+    CommonMapValue<bt_value> appendEmptyMap() const;
 
-    void operator+=(const Value val)
+    void operator+=(const Value val) const
     {
         this->append(val);
     }
 
-    void operator+=(const bool rawVal)
+    void operator+=(const bool rawVal) const
     {
         this->append(rawVal);
     }
 
-    void operator+=(const std::uint64_t rawVal)
+    void operator+=(const std::uint64_t rawVal) const
     {
         this->append(rawVal);
     }
 
-    void operator+=(const std::int64_t rawVal)
+    void operator+=(const std::int64_t rawVal) const
     {
         this->append(rawVal);
     }
 
-    void operator+=(const double rawVal)
+    void operator+=(const double rawVal) const
     {
         this->append(rawVal);
     }
 
-    void operator+=(const char * const rawVal)
+    void operator+=(const char * const rawVal) const
     {
         this->append(rawVal);
     }
 
-    void operator+=(const std::string& rawVal)
+    void operator+=(const std::string& rawVal) const
     {
         this->append(rawVal);
     }
@@ -1122,24 +1116,7 @@ public:
         return this->size() == 0;
     }
 
-    nonstd::optional<ConstValue> operator[](const char * const key) const noexcept
-    {
-        const auto libObjPtr =
-            internal::CommonMapValueSpec<const bt_value>::entryByKey(this->libObjPtr(), key);
-
-        if (!libObjPtr) {
-            return nonstd::nullopt;
-        }
-
-        return ConstValue {libObjPtr};
-    }
-
-    nonstd::optional<ConstValue> operator[](const std::string& key) const noexcept
-    {
-        return (*this)[key.data()];
-    }
-
-    nonstd::optional<CommonValue<LibObjT>> operator[](const char * const key) noexcept
+    nonstd::optional<CommonValue<LibObjT>> operator[](const char * const key) const noexcept
     {
         const auto libObjPtr =
             internal::CommonMapValueSpec<LibObjT>::entryByKey(this->libObjPtr(), key);
@@ -1151,7 +1128,7 @@ public:
         return CommonValue<LibObjT> {libObjPtr};
     }
 
-    nonstd::optional<CommonValue<LibObjT>> operator[](const std::string& key) noexcept
+    nonstd::optional<CommonValue<LibObjT>> operator[](const std::string& key) const noexcept
     {
         return (*this)[key.data()];
     }
@@ -1166,7 +1143,7 @@ public:
         return this->hasEntry(key.data());
     }
 
-    void insert(const char * const key, const Value val)
+    void insert(const char * const key, const Value val) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -1175,12 +1152,12 @@ public:
         this->_handleInsertLibStatus(status);
     }
 
-    void insert(const std::string& key, const Value val)
+    void insert(const std::string& key, const Value val) const
     {
         this->insert(key.data(), val);
     }
 
-    void insert(const char * const key, const bool rawVal)
+    void insert(const char * const key, const bool rawVal) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -1190,12 +1167,12 @@ public:
         this->_handleInsertLibStatus(status);
     }
 
-    void insert(const std::string& key, const bool rawVal)
+    void insert(const std::string& key, const bool rawVal) const
     {
         this->insert(key.data(), rawVal);
     }
 
-    void insert(const char * const key, const std::uint64_t rawVal)
+    void insert(const char * const key, const std::uint64_t rawVal) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -1205,12 +1182,12 @@ public:
         this->_handleInsertLibStatus(status);
     }
 
-    void insert(const std::string& key, const std::uint64_t rawVal)
+    void insert(const std::string& key, const std::uint64_t rawVal) const
     {
         this->insert(key.data(), rawVal);
     }
 
-    void insert(const char * const key, const std::int64_t rawVal)
+    void insert(const char * const key, const std::int64_t rawVal) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -1220,12 +1197,12 @@ public:
         this->_handleInsertLibStatus(status);
     }
 
-    void insert(const std::string& key, const std::int64_t rawVal)
+    void insert(const std::string& key, const std::int64_t rawVal) const
     {
         this->insert(key.data(), rawVal);
     }
 
-    void insert(const char * const key, const double rawVal)
+    void insert(const char * const key, const double rawVal) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -1234,12 +1211,12 @@ public:
         this->_handleInsertLibStatus(status);
     }
 
-    void insert(const std::string& key, const double rawVal)
+    void insert(const std::string& key, const double rawVal) const
     {
         this->insert(key.data(), rawVal);
     }
 
-    void insert(const char * const key, const char * const rawVal)
+    void insert(const char * const key, const char * const rawVal) const
     {
         static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -1248,32 +1225,27 @@ public:
         this->_handleInsertLibStatus(status);
     }
 
-    void insert(const char * const key, const std::string& rawVal)
+    void insert(const char * const key, const std::string& rawVal) const
     {
         this->insert(key, rawVal.data());
     }
 
-    void insert(const std::string& key, const char * const rawVal)
+    void insert(const std::string& key, const char * const rawVal) const
     {
         this->insert(key.data(), rawVal);
     }
 
-    void insert(const std::string& key, const std::string& rawVal)
+    void insert(const std::string& key, const std::string& rawVal) const
     {
         this->insert(key.data(), rawVal.data());
     }
 
-    CommonArrayValue<bt_value> insertEmptyArray(const char *key);
-    CommonArrayValue<bt_value> insertEmptyArray(const std::string& key);
-    CommonMapValue<bt_value> insertEmptyMap(const char *key);
-    CommonMapValue<bt_value> insertEmptyMap(const std::string& key);
-
-    void forEach(const internal::CommonMapValueForEachUserFunc<ConstValue>& func) const
-    {
-        internal::CommonMapValueSpec<const bt_value>::forEach(this->libObjPtr(), func);
-    }
+    CommonArrayValue<bt_value> insertEmptyArray(const char *key) const;
+    CommonArrayValue<bt_value> insertEmptyArray(const std::string& key) const;
+    CommonMapValue<bt_value> insertEmptyMap(const char *key) const;
+    CommonMapValue<bt_value> insertEmptyMap(const std::string& key) const;
 
-    void forEach(const internal::CommonMapValueForEachUserFunc<CommonValue<LibObjT>>& func)
+    void forEach(const internal::CommonMapValueForEachUserFunc<CommonValue<LibObjT>>& func) const
     {
         internal::CommonMapValueSpec<LibObjT>::forEach(this->libObjPtr(), func);
     }
@@ -1372,7 +1344,7 @@ CommonMapValue<LibObjT> CommonValue<LibObjT>::asMap() const noexcept
 }
 
 template <typename LibObjT>
-ArrayValue CommonArrayValue<LibObjT>::appendEmptyArray()
+ArrayValue CommonArrayValue<LibObjT>::appendEmptyArray() const
 {
     static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -1384,7 +1356,7 @@ ArrayValue CommonArrayValue<LibObjT>::appendEmptyArray()
 }
 
 template <typename LibObjT>
-MapValue CommonArrayValue<LibObjT>::appendEmptyMap()
+MapValue CommonArrayValue<LibObjT>::appendEmptyMap() const
 {
     static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -1396,7 +1368,7 @@ MapValue CommonArrayValue<LibObjT>::appendEmptyMap()
 }
 
 template <typename LibObjT>
-ArrayValue CommonMapValue<LibObjT>::insertEmptyArray(const char * const key)
+ArrayValue CommonMapValue<LibObjT>::insertEmptyArray(const char * const key) const
 {
     static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -1408,13 +1380,13 @@ ArrayValue CommonMapValue<LibObjT>::insertEmptyArray(const char * const key)
 }
 
 template <typename LibObjT>
-ArrayValue CommonMapValue<LibObjT>::insertEmptyArray(const std::string& key)
+ArrayValue CommonMapValue<LibObjT>::insertEmptyArray(const std::string& key) const
 {
     return this->insertEmptyArray(key.data());
 }
 
 template <typename LibObjT>
-MapValue CommonMapValue<LibObjT>::insertEmptyMap(const char * const key)
+MapValue CommonMapValue<LibObjT>::insertEmptyMap(const char * const key) const
 {
     static_assert(!std::is_const<LibObjT>::value, "`LibObjT` must NOT be `const`.");
 
@@ -1426,7 +1398,7 @@ MapValue CommonMapValue<LibObjT>::insertEmptyMap(const char * const key)
 }
 
 template <typename LibObjT>
-MapValue CommonMapValue<LibObjT>::insertEmptyMap(const std::string& key)
+MapValue CommonMapValue<LibObjT>::insertEmptyMap(const std::string& key) const
 {
     return this->insertEmptyMap(key.data());
 }
-- 
2.34.1