From 4927bae7b89dff01618509f362c9400ee1993e94 Mon Sep 17 00:00:00 2001
From: Philippe Proulx <eeppeliteloop@gmail.com>
Date: Mon, 9 May 2022 16:08:23 -0400
Subject: [PATCH] src/cpp-common/bt2: add `bt2::AddConst` and
 `bt2::RemoveConst`

This patch adds the `bt2::AddConst` and `bt2::RemoveConst` structure
templates in `src/cpp-common/bt2/type-traits.hpp` which both provide the
`Type` type alias to transform a const object type into a non-const
object type and vice versa.

For example, `bt2::AddConst<bt2::ClockClass>::Type` is
`bt2::ConstClockClass` and `bt2::RemoveConst<bt2::ConstMapValue>::Type`
is `bt2::MapValue`.

I needed this to call something like

    bt2::RemoveConst<typename LibFcT::Mapping::RangeSet>::Type::create()

where `LibFcT` is some non-const enumeration field class, but I decided
to implement it for all the types right now.

Internally, we add something like this for all type pairs:

    namespace internal {

    struct XyzTypeDescr
    {
        using Const = ConstXyz;
        using NonConst = Xyz;
    };

    template <>
    struct TypeDescr<Xyz> : public XyzTypeDescr
    {
    };

    template <>
    struct TypeDescr<ConstXyz> : public XyzTypeDescr
    {
    };

    } /* namespace internal */

The type trait structure templates in `type-traits.hpp` just use
`internal::TypeDescr`, for example:

    template <typename ObjT>
    struct RemoveConst
    {
        using Type = typename internal::TypeDescr<ObjT>::NonConst;
    };

Signed-off-by: Philippe Proulx <eeppeliteloop@gmail.com>
Change-Id: Ia4d44a286fd836dcdb2a0f37c5a08a43bad5508e
Reviewed-on: https://review.lttng.org/c/babeltrace/+/8008
Reviewed-on: https://review.lttng.org/c/babeltrace/+/10791
Tested-by: jenkins <jenkins@lttng.org>
---
 src/cpp-common/bt2/clock-class.hpp       |  20 ++
 src/cpp-common/bt2/field-class.hpp       | 372 ++++++++++++++++++++++-
 src/cpp-common/bt2/field.hpp             | 285 +++++++++++++++++
 src/cpp-common/bt2/integer-range-set.hpp |  35 +++
 src/cpp-common/bt2/internal/utils.hpp    |   3 +
 src/cpp-common/bt2/message.hpp           | 155 +++++++++-
 src/cpp-common/bt2/trace-ir.hpp          | 136 +++++++++
 src/cpp-common/bt2/type-traits.hpp       |  28 ++
 src/cpp-common/bt2/value.hpp             | 173 ++++++++++-
 9 files changed, 1204 insertions(+), 3 deletions(-)
 create mode 100644 src/cpp-common/bt2/type-traits.hpp

diff --git a/src/cpp-common/bt2/clock-class.hpp b/src/cpp-common/bt2/clock-class.hpp
index 92caa9e4..15273164 100644
--- a/src/cpp-common/bt2/clock-class.hpp
+++ b/src/cpp-common/bt2/clock-class.hpp
@@ -14,6 +14,7 @@
 
 #include "internal/borrowed-obj.hpp"
 #include "internal/shared-obj.hpp"
+#include "internal/utils.hpp"
 #include "cpp-common/optional.hpp"
 #include "cpp-common/string_view.hpp"
 #include "cpp-common/uuid-view.hpp"
@@ -285,6 +286,25 @@ public:
 using ClockClass = CommonClockClass<bt_clock_class>;
 using ConstClockClass = CommonClockClass<const bt_clock_class>;
 
+namespace internal {
+
+struct ClockClassTypeDescr
+{
+    using Const = ConstClockClass;
+    using NonConst = ClockClass;
+};
+
+template <>
+struct TypeDescr<ClockClass> : public ClockClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstClockClass> : public ClockClassTypeDescr
+{
+};
+
+} /* namespace internal */
 } /* namespace bt2 */
 
 #endif /* BABELTRACE_CPP_COMMON_BT2_CLOCK_CLASS_HPP */
diff --git a/src/cpp-common/bt2/field-class.hpp b/src/cpp-common/bt2/field-class.hpp
index 4dbdee60..22dfa47b 100644
--- a/src/cpp-common/bt2/field-class.hpp
+++ b/src/cpp-common/bt2/field-class.hpp
@@ -14,6 +14,7 @@
 #include "common/assert.h"
 #include "internal/borrowed-obj.hpp"
 #include "internal/shared-obj.hpp"
+#include "internal/utils.hpp"
 #include "cpp-common/optional.hpp"
 #include "cpp-common/string_view.hpp"
 #include "common-iter.hpp"
@@ -23,7 +24,6 @@
 #include "value.hpp"
 
 namespace bt2 {
-
 namespace internal {
 
 struct FieldClassRefFuncs final
@@ -447,6 +447,26 @@ protected:
 using FieldClass = CommonFieldClass<bt_field_class>;
 using ConstFieldClass = CommonFieldClass<const bt_field_class>;
 
+namespace internal {
+
+struct FieldClassTypeDescr
+{
+    using Const = ConstFieldClass;
+    using NonConst = FieldClass;
+};
+
+template <>
+struct TypeDescr<FieldClass> : public FieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstFieldClass> : public FieldClassTypeDescr
+{
+};
+
+} /* namespace internal */
+
 template <typename LibObjT>
 class CommonBitArrayFieldClass final : public CommonFieldClass<LibObjT>
 {
@@ -491,6 +511,26 @@ public:
 using BitArrayFieldClass = CommonBitArrayFieldClass<bt_field_class>;
 using ConstBitArrayFieldClass = CommonBitArrayFieldClass<const bt_field_class>;
 
+namespace internal {
+
+struct BitArrayFieldClassTypeDescr
+{
+    using Const = ConstBitArrayFieldClass;
+    using NonConst = BitArrayFieldClass;
+};
+
+template <>
+struct TypeDescr<BitArrayFieldClass> : public BitArrayFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstBitArrayFieldClass> : public BitArrayFieldClassTypeDescr
+{
+};
+
+} /* namespace internal */
+
 enum class DisplayBase
 {
     BINARY = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_BINARY,
@@ -568,6 +608,26 @@ using ConstIntegerFieldClass = CommonIntegerFieldClass<const bt_field_class>;
 
 namespace internal {
 
+struct IntegerFieldClassTypeDescr
+{
+    using Const = ConstIntegerFieldClass;
+    using NonConst = IntegerFieldClass;
+};
+
+template <>
+struct TypeDescr<IntegerFieldClass> : public IntegerFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstIntegerFieldClass> : public IntegerFieldClassTypeDescr
+{
+};
+
+} /* namespace internal */
+
+namespace internal {
+
 template <typename LibObjT>
 struct ConstEnumerationFieldClassMappingSpec;
 
@@ -851,6 +911,38 @@ using ConstSignedEnumerationFieldClass =
 
 namespace internal {
 
+struct UnsignedEnumerationFieldClassTypeDescr
+{
+    using Const = ConstUnsignedEnumerationFieldClass;
+    using NonConst = UnsignedEnumerationFieldClass;
+};
+
+template <>
+struct TypeDescr<UnsignedEnumerationFieldClass> : public UnsignedEnumerationFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstUnsignedEnumerationFieldClass> : public UnsignedEnumerationFieldClassTypeDescr
+{
+};
+
+struct SignedEnumerationFieldClassTypeDescr
+{
+    using Const = ConstSignedEnumerationFieldClass;
+    using NonConst = SignedEnumerationFieldClass;
+};
+
+template <>
+struct TypeDescr<SignedEnumerationFieldClass> : public SignedEnumerationFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstSignedEnumerationFieldClass> : public SignedEnumerationFieldClassTypeDescr
+{
+};
+
 template <typename LibObjT>
 struct CommonStructureFieldClassMemberSpec;
 
@@ -933,6 +1025,22 @@ using ConstStructureFieldClassMember =
 
 namespace internal {
 
+struct StructureFieldClassMemberTypeDescr
+{
+    using Const = ConstStructureFieldClassMember;
+    using NonConst = StructureFieldClassMember;
+};
+
+template <>
+struct TypeDescr<StructureFieldClassMember> : public StructureFieldClassMemberTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstStructureFieldClassMember> : public StructureFieldClassMemberTypeDescr
+{
+};
+
 template <typename LibObjT>
 struct CommonStructureFieldClassSpec;
 
@@ -1099,6 +1207,22 @@ using ConstStructureFieldClass = CommonStructureFieldClass<const bt_field_class>
 
 namespace internal {
 
+struct StructureFieldClassTypeDescr
+{
+    using Const = ConstStructureFieldClass;
+    using NonConst = StructureFieldClass;
+};
+
+template <>
+struct TypeDescr<StructureFieldClass> : public StructureFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstStructureFieldClass> : public StructureFieldClassTypeDescr
+{
+};
+
 template <typename LibObjT>
 struct CommonArrayFieldClassSpec;
 
@@ -1181,6 +1305,26 @@ public:
 using ArrayFieldClass = CommonArrayFieldClass<bt_field_class>;
 using ConstArrayFieldClass = CommonArrayFieldClass<const bt_field_class>;
 
+namespace internal {
+
+struct ArrayFieldClassTypeDescr
+{
+    using Const = ConstArrayFieldClass;
+    using NonConst = ArrayFieldClass;
+};
+
+template <>
+struct TypeDescr<ArrayFieldClass> : public ArrayFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstArrayFieldClass> : public ArrayFieldClassTypeDescr
+{
+};
+
+} /* namespace internal */
+
 template <typename LibObjT>
 class CommonStaticArrayFieldClass final : public CommonArrayFieldClass<LibObjT>
 {
@@ -1225,6 +1369,26 @@ public:
 using StaticArrayFieldClass = CommonStaticArrayFieldClass<bt_field_class>;
 using ConstStaticArrayFieldClass = CommonStaticArrayFieldClass<const bt_field_class>;
 
+namespace internal {
+
+struct StaticArrayFieldClassTypeDescr
+{
+    using Const = ConstStaticArrayFieldClass;
+    using NonConst = StaticArrayFieldClass;
+};
+
+template <>
+struct TypeDescr<StaticArrayFieldClass> : public StaticArrayFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstStaticArrayFieldClass> : public StaticArrayFieldClassTypeDescr
+{
+};
+
+} /* namespace internal */
+
 template <typename LibObjT>
 class CommonDynamicArrayWithLengthFieldClass final : public CommonArrayFieldClass<LibObjT>
 {
@@ -1277,6 +1441,24 @@ using ConstDynamicArrayWithLengthFieldClass =
 
 namespace internal {
 
+struct DynamicArrayWithLengthFieldClassTypeDescr
+{
+    using Const = ConstDynamicArrayWithLengthFieldClass;
+    using NonConst = DynamicArrayWithLengthFieldClass;
+};
+
+template <>
+struct TypeDescr<DynamicArrayWithLengthFieldClass> :
+    public DynamicArrayWithLengthFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstDynamicArrayWithLengthFieldClass> :
+    public DynamicArrayWithLengthFieldClassTypeDescr
+{
+};
+
 template <typename LibObjT>
 struct CommonOptionFieldClassSpec;
 
@@ -1359,6 +1541,26 @@ public:
 using OptionFieldClass = CommonOptionFieldClass<bt_field_class>;
 using ConstOptionFieldClass = CommonOptionFieldClass<const bt_field_class>;
 
+namespace internal {
+
+struct OptionFieldClassTypeDescr
+{
+    using Const = ConstOptionFieldClass;
+    using NonConst = OptionFieldClass;
+};
+
+template <>
+struct TypeDescr<OptionFieldClass> : public OptionFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstOptionFieldClass> : public OptionFieldClassTypeDescr
+{
+};
+
+} /* namespace internal */
+
 template <typename LibObjT>
 class CommonOptionWithSelectorFieldClass : public CommonOptionFieldClass<LibObjT>
 {
@@ -1409,6 +1611,26 @@ public:
 using OptionWithSelectorFieldClass = CommonOptionWithSelectorFieldClass<bt_field_class>;
 using ConstOptionWithSelectorFieldClass = CommonOptionWithSelectorFieldClass<const bt_field_class>;
 
+namespace internal {
+
+struct OptionWithSelectorFieldClassTypeDescr
+{
+    using Const = ConstOptionWithSelectorFieldClass;
+    using NonConst = OptionWithSelectorFieldClass;
+};
+
+template <>
+struct TypeDescr<OptionWithSelectorFieldClass> : public OptionWithSelectorFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstOptionWithSelectorFieldClass> : public OptionWithSelectorFieldClassTypeDescr
+{
+};
+
+} /* namespace internal */
+
 template <typename LibObjT>
 class CommonOptionWithBoolSelectorFieldClass : public CommonOptionWithSelectorFieldClass<LibObjT>
 {
@@ -1462,6 +1684,24 @@ using ConstOptionWithBoolSelectorFieldClass =
 
 namespace internal {
 
+struct OptionWithBoolSelectorFieldClassTypeDescr
+{
+    using Const = ConstOptionWithBoolSelectorFieldClass;
+    using NonConst = OptionWithBoolSelectorFieldClass;
+};
+
+template <>
+struct TypeDescr<OptionWithBoolSelectorFieldClass> :
+    public OptionWithBoolSelectorFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstOptionWithBoolSelectorFieldClass> :
+    public OptionWithBoolSelectorFieldClassTypeDescr
+{
+};
+
 template <typename RangeSetT>
 struct CommonOptionWithIntegerSelectorFieldClassSpec;
 
@@ -1556,6 +1796,42 @@ using ConstOptionWithSignedIntegerSelectorFieldClass =
 
 namespace internal {
 
+struct OptionWithUnsignedIntegerSelectorFieldClassTypeDescr
+{
+    using Const = ConstOptionWithUnsignedIntegerSelectorFieldClass;
+    using NonConst = OptionWithUnsignedIntegerSelectorFieldClass;
+};
+
+template <>
+struct TypeDescr<OptionWithUnsignedIntegerSelectorFieldClass> :
+    public OptionWithUnsignedIntegerSelectorFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstOptionWithUnsignedIntegerSelectorFieldClass> :
+    public OptionWithUnsignedIntegerSelectorFieldClassTypeDescr
+{
+};
+
+struct OptionWithSignedIntegerSelectorFieldClassTypeDescr
+{
+    using Const = ConstOptionWithSignedIntegerSelectorFieldClass;
+    using NonConst = OptionWithSignedIntegerSelectorFieldClass;
+};
+
+template <>
+struct TypeDescr<OptionWithSignedIntegerSelectorFieldClass> :
+    public OptionWithSignedIntegerSelectorFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstOptionWithSignedIntegerSelectorFieldClass> :
+    public OptionWithSignedIntegerSelectorFieldClassTypeDescr
+{
+};
+
 template <typename LibObjT>
 struct CommonVariantFieldClassOptionSpec;
 
@@ -1637,6 +1913,22 @@ using ConstVariantFieldClassOption =
 
 namespace internal {
 
+struct VariantFieldClassOptionTypeDescr
+{
+    using Const = ConstVariantFieldClassOption;
+    using NonConst = VariantFieldClassOption;
+};
+
+template <>
+struct TypeDescr<VariantFieldClassOption> : public VariantFieldClassOptionTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstVariantFieldClassOption> : public VariantFieldClassOptionTypeDescr
+{
+};
+
 template <typename LibObjT>
 struct ConstVariantWithIntegerSelectorFieldClassOptionSpec;
 
@@ -1905,6 +2197,26 @@ public:
 using VariantFieldClass = CommonVariantFieldClass<bt_field_class>;
 using ConstVariantFieldClass = CommonVariantFieldClass<const bt_field_class>;
 
+namespace internal {
+
+struct VariantFieldClassTypeDescr
+{
+    using Const = ConstVariantFieldClass;
+    using NonConst = VariantFieldClass;
+};
+
+template <>
+struct TypeDescr<VariantFieldClass> : public VariantFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstVariantFieldClass> : public VariantFieldClassTypeDescr
+{
+};
+
+} /* namespace internal */
+
 template <typename LibObjT>
 class CommonVariantWithoutSelectorFieldClass : public CommonVariantFieldClass<LibObjT>
 {
@@ -1967,6 +2279,24 @@ using ConstVariantWithoutSelectorFieldClass =
 
 namespace internal {
 
+struct VariantWithoutSelectorFieldClassTypeDescr
+{
+    using Const = ConstVariantWithoutSelectorFieldClass;
+    using NonConst = VariantWithoutSelectorFieldClass;
+};
+
+template <>
+struct TypeDescr<VariantWithoutSelectorFieldClass> :
+    public VariantWithoutSelectorFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstVariantWithoutSelectorFieldClass> :
+    public VariantWithoutSelectorFieldClassTypeDescr
+{
+};
+
 template <typename OptionT>
 struct CommonVariantWithIntegerSelectorFieldClassSpec;
 
@@ -2178,6 +2508,46 @@ using VariantWithSignedIntegerSelectorFieldClass = CommonVariantWithIntegerSelec
 using ConstVariantWithSignedIntegerSelectorFieldClass = CommonVariantWithIntegerSelectorFieldClass<
     const bt_field_class, ConstVariantWithSignedIntegerSelectorFieldClassOption>;
 
+namespace internal {
+
+struct VariantWithUnsignedIntegerSelectorFieldClassTypeDescr
+{
+    using Const = ConstVariantWithUnsignedIntegerSelectorFieldClass;
+    using NonConst = VariantWithUnsignedIntegerSelectorFieldClass;
+};
+
+template <>
+struct TypeDescr<VariantWithUnsignedIntegerSelectorFieldClass> :
+    public VariantWithUnsignedIntegerSelectorFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstVariantWithUnsignedIntegerSelectorFieldClass> :
+    public VariantWithUnsignedIntegerSelectorFieldClassTypeDescr
+{
+};
+
+struct VariantWithSignedIntegerSelectorFieldClassTypeDescr
+{
+    using Const = ConstVariantWithSignedIntegerSelectorFieldClass;
+    using NonConst = VariantWithSignedIntegerSelectorFieldClass;
+};
+
+template <>
+struct TypeDescr<VariantWithSignedIntegerSelectorFieldClass> :
+    public VariantWithSignedIntegerSelectorFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstVariantWithSignedIntegerSelectorFieldClass> :
+    public VariantWithSignedIntegerSelectorFieldClassTypeDescr
+{
+};
+
+} /* namespace internal */
+
 template <typename LibObjT>
 CommonBitArrayFieldClass<LibObjT> CommonFieldClass<LibObjT>::asBitArray() const noexcept
 {
diff --git a/src/cpp-common/bt2/field.hpp b/src/cpp-common/bt2/field.hpp
index e075f8e6..25d0034f 100644
--- a/src/cpp-common/bt2/field.hpp
+++ b/src/cpp-common/bt2/field.hpp
@@ -13,6 +13,7 @@
 
 #include "common/assert.h"
 #include "internal/borrowed-obj.hpp"
+#include "internal/utils.hpp"
 #include "cpp-common/optional.hpp"
 #include "cpp-common/string_view.hpp"
 #include "field-class.hpp"
@@ -222,6 +223,26 @@ public:
 using Field = CommonField<bt_field>;
 using ConstField = CommonField<const bt_field>;
 
+namespace internal {
+
+struct FieldTypeDescr
+{
+    using Const = ConstField;
+    using NonConst = Field;
+};
+
+template <>
+struct TypeDescr<Field> : public FieldTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstField> : public FieldTypeDescr
+{
+};
+
+} /* namespace internal */
+
 template <typename LibObjT>
 class CommonBoolField final : public CommonField<LibObjT>
 {
@@ -271,6 +292,26 @@ public:
 using BoolField = CommonBoolField<bt_field>;
 using ConstBoolField = CommonBoolField<const bt_field>;
 
+namespace internal {
+
+struct BoolFieldTypeDescr
+{
+    using Const = ConstBoolField;
+    using NonConst = BoolField;
+};
+
+template <>
+struct TypeDescr<BoolField> : public BoolFieldTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstBoolField> : public BoolFieldTypeDescr
+{
+};
+
+} /* namespace internal */
+
 template <typename LibObjT>
 class CommonBitArrayField final : public CommonField<LibObjT>
 {
@@ -334,6 +375,26 @@ public:
 using BitArrayField = CommonBitArrayField<bt_field>;
 using ConstBitArrayField = CommonBitArrayField<const bt_field>;
 
+namespace internal {
+
+struct BitArrayFieldTypeDescr
+{
+    using Const = ConstBitArrayField;
+    using NonConst = BitArrayField;
+};
+
+template <>
+struct TypeDescr<BitArrayField> : public BitArrayFieldTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstBitArrayField> : public BitArrayFieldTypeDescr
+{
+};
+
+} /* namespace internal */
+
 template <typename LibObjT>
 class CommonUnsignedIntegerField final : public CommonField<LibObjT>
 {
@@ -403,6 +464,26 @@ public:
 using UnsignedIntegerField = CommonUnsignedIntegerField<bt_field>;
 using ConstUnsignedIntegerField = CommonUnsignedIntegerField<const bt_field>;
 
+namespace internal {
+
+struct UnsignedIntegerFieldTypeDescr
+{
+    using Const = ConstUnsignedIntegerField;
+    using NonConst = UnsignedIntegerField;
+};
+
+template <>
+struct TypeDescr<UnsignedIntegerField> : public UnsignedIntegerFieldTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstUnsignedIntegerField> : public UnsignedIntegerFieldTypeDescr
+{
+};
+
+} /* namespace internal */
+
 template <typename LibObjT>
 class CommonSignedIntegerField final : public CommonField<LibObjT>
 {
@@ -472,6 +553,26 @@ public:
 using SignedIntegerField = CommonSignedIntegerField<bt_field>;
 using ConstSignedIntegerField = CommonSignedIntegerField<const bt_field>;
 
+namespace internal {
+
+struct SignedIntegerFieldTypeDescr
+{
+    using Const = ConstSignedIntegerField;
+    using NonConst = SignedIntegerField;
+};
+
+template <>
+struct TypeDescr<SignedIntegerField> : public SignedIntegerFieldTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstSignedIntegerField> : public SignedIntegerFieldTypeDescr
+{
+};
+
+} /* namespace internal */
+
 class EnumerationFieldClassMappingLabels
 {
 public:
@@ -565,6 +666,26 @@ public:
 using UnsignedEnumerationField = CommonUnsignedEnumerationField<bt_field>;
 using ConstUnsignedEnumerationField = CommonUnsignedEnumerationField<const bt_field>;
 
+namespace internal {
+
+struct UnsignedEnumerationFieldTypeDescr
+{
+    using Const = ConstUnsignedEnumerationField;
+    using NonConst = UnsignedEnumerationField;
+};
+
+template <>
+struct TypeDescr<UnsignedEnumerationField> : public UnsignedEnumerationFieldTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstUnsignedEnumerationField> : public UnsignedEnumerationFieldTypeDescr
+{
+};
+
+} /* namespace internal */
+
 template <typename LibObjT>
 class CommonSignedEnumerationField final : public CommonSignedIntegerField<LibObjT>
 {
@@ -626,6 +747,26 @@ public:
 using SignedEnumerationField = CommonSignedEnumerationField<bt_field>;
 using ConstSignedEnumerationField = CommonSignedEnumerationField<const bt_field>;
 
+namespace internal {
+
+struct SignedEnumerationFieldTypeDescr
+{
+    using Const = ConstSignedEnumerationField;
+    using NonConst = SignedEnumerationField;
+};
+
+template <>
+struct TypeDescr<SignedEnumerationField> : public SignedEnumerationFieldTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstSignedEnumerationField> : public SignedEnumerationFieldTypeDescr
+{
+};
+
+} /* namespace internal */
+
 template <typename LibObjT>
 class CommonSinglePrecisionRealField final : public CommonField<LibObjT>
 {
@@ -679,6 +820,26 @@ public:
 using SinglePrecisionRealField = CommonSinglePrecisionRealField<bt_field>;
 using ConstSinglePrecisionRealField = CommonSinglePrecisionRealField<const bt_field>;
 
+namespace internal {
+
+struct SinglePrecisionRealFieldTypeDescr
+{
+    using Const = ConstSinglePrecisionRealField;
+    using NonConst = SinglePrecisionRealField;
+};
+
+template <>
+struct TypeDescr<SinglePrecisionRealField> : public SinglePrecisionRealFieldTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstSinglePrecisionRealField> : public SinglePrecisionRealFieldTypeDescr
+{
+};
+
+} /* namespace internal */
+
 template <typename LibObjT>
 class CommonDoublePrecisionRealField final : public CommonField<LibObjT>
 {
@@ -732,6 +893,26 @@ public:
 using DoublePrecisionRealField = CommonDoublePrecisionRealField<bt_field>;
 using ConstDoublePrecisionRealField = CommonDoublePrecisionRealField<const bt_field>;
 
+namespace internal {
+
+struct DoublePrecisionRealFieldTypeDescr
+{
+    using Const = ConstDoublePrecisionRealField;
+    using NonConst = DoublePrecisionRealField;
+};
+
+template <>
+struct TypeDescr<DoublePrecisionRealField> : public DoublePrecisionRealFieldTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstDoublePrecisionRealField> : public DoublePrecisionRealFieldTypeDescr
+{
+};
+
+} /* namespace internal */
+
 template <typename LibObjT>
 class CommonStringField final : public CommonField<LibObjT>
 {
@@ -793,6 +974,22 @@ using ConstStringField = CommonStringField<const bt_field>;
 
 namespace internal {
 
+struct StringFieldTypeDescr
+{
+    using Const = ConstStringField;
+    using NonConst = StringField;
+};
+
+template <>
+struct TypeDescr<StringField> : public StringFieldTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstStringField> : public StringFieldTypeDescr
+{
+};
+
 template <typename LibObjT>
 struct CommonStructureFieldSpec;
 
@@ -929,6 +1126,22 @@ using ConstStructureField = CommonStructureField<const bt_field>;
 
 namespace internal {
 
+struct StructureFieldTypeDescr
+{
+    using Const = ConstStructureField;
+    using NonConst = StructureField;
+};
+
+template <>
+struct TypeDescr<StructureField> : public StructureFieldTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstStructureField> : public StructureFieldTypeDescr
+{
+};
+
 template <typename LibObjT>
 struct CommonArrayFieldSpec;
 
@@ -1019,6 +1232,26 @@ public:
 using ArrayField = CommonArrayField<bt_field>;
 using ConstArrayField = CommonArrayField<const bt_field>;
 
+namespace internal {
+
+struct ArrayFieldTypeDescr
+{
+    using Const = ConstArrayField;
+    using NonConst = ArrayField;
+};
+
+template <>
+struct TypeDescr<ArrayField> : public ArrayFieldTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstArrayField> : public ArrayFieldTypeDescr
+{
+};
+
+} /* namespace internal */
+
 template <typename LibObjT>
 class CommonDynamicArrayField : public CommonArrayField<LibObjT>
 {
@@ -1069,6 +1302,22 @@ using ConstDynamicArrayField = CommonDynamicArrayField<const bt_field>;
 
 namespace internal {
 
+struct DynamicArrayFieldTypeDescr
+{
+    using Const = ConstDynamicArrayField;
+    using NonConst = DynamicArrayField;
+};
+
+template <>
+struct TypeDescr<DynamicArrayField> : public DynamicArrayFieldTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstDynamicArrayField> : public DynamicArrayFieldTypeDescr
+{
+};
+
 template <typename LibObjT>
 struct CommonOptionFieldSpec;
 
@@ -1175,6 +1424,22 @@ using ConstOptionField = CommonOptionField<const bt_field>;
 
 namespace internal {
 
+struct OptionFieldTypeDescr
+{
+    using Const = ConstOptionField;
+    using NonConst = OptionField;
+};
+
+template <>
+struct TypeDescr<OptionField> : public OptionFieldTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstOptionField> : public OptionFieldTypeDescr
+{
+};
+
 template <typename LibObjT>
 struct CommonVariantFieldSpec;
 
@@ -1268,6 +1533,26 @@ public:
 using VariantField = CommonVariantField<bt_field>;
 using ConstVariantField = CommonVariantField<const bt_field>;
 
+namespace internal {
+
+struct VariantFieldTypeDescr
+{
+    using Const = ConstVariantField;
+    using NonConst = VariantField;
+};
+
+template <>
+struct TypeDescr<VariantField> : public VariantFieldTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstVariantField> : public VariantFieldTypeDescr
+{
+};
+
+} /* namespace internal */
+
 template <typename LibObjT>
 CommonBoolField<LibObjT> CommonField<LibObjT>::asBool() const noexcept
 {
diff --git a/src/cpp-common/bt2/integer-range-set.hpp b/src/cpp-common/bt2/integer-range-set.hpp
index 3e88b61a..6cb17af0 100644
--- a/src/cpp-common/bt2/integer-range-set.hpp
+++ b/src/cpp-common/bt2/integer-range-set.hpp
@@ -249,6 +249,41 @@ using ConstUnsignedIntegerRangeSet = CommonIntegerRangeSet<const bt_integer_rang
 using SignedIntegerRangeSet = CommonIntegerRangeSet<bt_integer_range_set_signed>;
 using ConstSignedIntegerRangeSet = CommonIntegerRangeSet<const bt_integer_range_set_signed>;
 
+namespace internal {
+
+struct UnsignedIntegerRangeSetTypeDescr
+{
+    using Const = ConstUnsignedIntegerRangeSet;
+    using NonConst = UnsignedIntegerRangeSet;
+};
+
+template <>
+struct TypeDescr<UnsignedIntegerRangeSet> : public UnsignedIntegerRangeSetTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstUnsignedIntegerRangeSet> : public UnsignedIntegerRangeSetTypeDescr
+{
+};
+
+struct SignedIntegerRangeSetTypeDescr
+{
+    using Const = ConstSignedIntegerRangeSet;
+    using NonConst = SignedIntegerRangeSet;
+};
+
+template <>
+struct TypeDescr<SignedIntegerRangeSet> : public SignedIntegerRangeSetTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstSignedIntegerRangeSet> : public SignedIntegerRangeSetTypeDescr
+{
+};
+
+} /* namespace internal */
 } /* namespace bt2 */
 
 #endif /* BABELTRACE_CPP_COMMON_BT2_INTEGER_RANGE_SET_HPP */
diff --git a/src/cpp-common/bt2/internal/utils.hpp b/src/cpp-common/bt2/internal/utils.hpp
index cbf761b0..34c52fff 100644
--- a/src/cpp-common/bt2/internal/utils.hpp
+++ b/src/cpp-common/bt2/internal/utils.hpp
@@ -22,6 +22,9 @@ void validateCreatedObjPtr(const LibObjPtrT libOjbPtr)
     }
 }
 
+template <typename ObjT>
+struct TypeDescr;
+
 } /* namespace internal */
 } /* namespace bt2 */
 
diff --git a/src/cpp-common/bt2/message.hpp b/src/cpp-common/bt2/message.hpp
index 4a25821d..4e575722 100644
--- a/src/cpp-common/bt2/message.hpp
+++ b/src/cpp-common/bt2/message.hpp
@@ -22,7 +22,6 @@
 #include "lib-error.hpp"
 
 namespace bt2 {
-
 namespace internal {
 
 struct MessageRefFuncs final
@@ -173,6 +172,22 @@ using ConstMessage = CommonMessage<const bt_message>;
 
 namespace internal {
 
+struct MessageTypeDescr
+{
+    using Const = ConstMessage;
+    using NonConst = Message;
+};
+
+template <>
+struct TypeDescr<Message> : public MessageTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstMessage> : public MessageTypeDescr
+{
+};
+
 template <typename LibObjT>
 struct CommonStreamBeginningMessageSpec;
 
@@ -275,6 +290,22 @@ using ConstStreamBeginningMessage = CommonStreamBeginningMessage<const bt_messag
 
 namespace internal {
 
+struct StreamBeginningMessageTypeDescr
+{
+    using Const = ConstStreamBeginningMessage;
+    using NonConst = StreamBeginningMessage;
+};
+
+template <>
+struct TypeDescr<StreamBeginningMessage> : public StreamBeginningMessageTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstStreamBeginningMessage> : public StreamBeginningMessageTypeDescr
+{
+};
+
 template <typename LibObjT>
 struct CommonStreamEndMessageSpec;
 
@@ -376,6 +407,22 @@ using ConstStreamEndMessage = CommonStreamEndMessage<const bt_message>;
 
 namespace internal {
 
+struct StreamEndMessageTypeDescr
+{
+    using Const = ConstStreamEndMessage;
+    using NonConst = StreamEndMessage;
+};
+
+template <>
+struct TypeDescr<StreamEndMessage> : public StreamEndMessageTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstStreamEndMessage> : public StreamEndMessageTypeDescr
+{
+};
+
 template <typename LibObjT>
 struct CommonPacketBeginningMessageSpec;
 
@@ -473,6 +520,22 @@ using ConstPacketBeginningMessage = CommonPacketBeginningMessage<const bt_messag
 
 namespace internal {
 
+struct PacketBeginningMessageTypeDescr
+{
+    using Const = ConstPacketBeginningMessage;
+    using NonConst = PacketBeginningMessage;
+};
+
+template <>
+struct TypeDescr<PacketBeginningMessage> : public PacketBeginningMessageTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstPacketBeginningMessage> : public PacketBeginningMessageTypeDescr
+{
+};
+
 template <typename LibObjT>
 struct CommonPacketEndMessageSpec;
 
@@ -569,6 +632,22 @@ using ConstPacketEndMessage = CommonPacketEndMessage<const bt_message>;
 
 namespace internal {
 
+struct PacketEndMessageTypeDescr
+{
+    using Const = ConstPacketEndMessage;
+    using NonConst = PacketEndMessage;
+};
+
+template <>
+struct TypeDescr<PacketEndMessage> : public PacketEndMessageTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstPacketEndMessage> : public PacketEndMessageTypeDescr
+{
+};
+
 template <typename LibObjT>
 struct CommonEventMessageSpec;
 
@@ -657,6 +736,22 @@ using ConstEventMessage = CommonEventMessage<const bt_message>;
 
 namespace internal {
 
+struct EventMessageTypeDescr
+{
+    using Const = ConstEventMessage;
+    using NonConst = EventMessage;
+};
+
+template <>
+struct TypeDescr<EventMessage> : public EventMessageTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstEventMessage> : public EventMessageTypeDescr
+{
+};
+
 template <typename LibObjT>
 struct CommonDiscardedEventsMessageSpec;
 
@@ -775,6 +870,22 @@ using ConstDiscardedEventsMessage = CommonDiscardedEventsMessage<const bt_messag
 
 namespace internal {
 
+struct DiscardedEventsMessageTypeDescr
+{
+    using Const = ConstDiscardedEventsMessage;
+    using NonConst = DiscardedEventsMessage;
+};
+
+template <>
+struct TypeDescr<DiscardedEventsMessage> : public DiscardedEventsMessageTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstDiscardedEventsMessage> : public DiscardedEventsMessageTypeDescr
+{
+};
+
 template <typename LibObjT>
 struct CommonDiscardedPacketsMessageSpec;
 
@@ -891,6 +1002,26 @@ public:
 using DiscardedPacketsMessage = CommonDiscardedPacketsMessage<bt_message>;
 using ConstDiscardedPacketsMessage = CommonDiscardedPacketsMessage<const bt_message>;
 
+namespace internal {
+
+struct DiscardedPacketsMessageTypeDescr
+{
+    using Const = ConstDiscardedPacketsMessage;
+    using NonConst = DiscardedPacketsMessage;
+};
+
+template <>
+struct TypeDescr<DiscardedPacketsMessage> : public DiscardedPacketsMessageTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstDiscardedPacketsMessage> : public DiscardedPacketsMessageTypeDescr
+{
+};
+
+} /* namespace internal */
+
 template <typename LibObjT>
 class CommonMessageIteratorInactivityMessage final : public CommonMessage<LibObjT>
 {
@@ -941,6 +1072,28 @@ using MessageIteratorInactivityMessage = CommonMessageIteratorInactivityMessage<
 using ConstMessageIteratorInactivityMessage =
     CommonMessageIteratorInactivityMessage<const bt_message>;
 
+namespace internal {
+
+struct MessageIteratorInactivityMessageTypeDescr
+{
+    using Const = ConstMessageIteratorInactivityMessage;
+    using NonConst = MessageIteratorInactivityMessage;
+};
+
+template <>
+struct TypeDescr<MessageIteratorInactivityMessage> :
+    public MessageIteratorInactivityMessageTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstMessageIteratorInactivityMessage> :
+    public MessageIteratorInactivityMessageTypeDescr
+{
+};
+
+} /* namespace internal */
+
 template <typename LibObjT>
 CommonStreamBeginningMessage<LibObjT> CommonMessage<LibObjT>::asStreamBeginning() const noexcept
 {
diff --git a/src/cpp-common/bt2/trace-ir.hpp b/src/cpp-common/bt2/trace-ir.hpp
index 33f77105..8677fde2 100644
--- a/src/cpp-common/bt2/trace-ir.hpp
+++ b/src/cpp-common/bt2/trace-ir.hpp
@@ -241,6 +241,22 @@ using ConstEvent = CommonEvent<const bt_event>;
 
 namespace internal {
 
+struct EventTypeDescr
+{
+    using Const = ConstEvent;
+    using NonConst = Event;
+};
+
+template <>
+struct TypeDescr<Event> : public EventTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstEvent> : public EventTypeDescr
+{
+};
+
 struct PacketRefFuncs final
 {
     static void get(const bt_packet * const libObjPtr)
@@ -359,6 +375,26 @@ public:
 using Packet = CommonPacket<bt_packet>;
 using ConstPacket = CommonPacket<const bt_packet>;
 
+namespace internal {
+
+struct PacketTypeDescr
+{
+    using Const = ConstPacket;
+    using NonConst = Packet;
+};
+
+template <>
+struct TypeDescr<Packet> : public PacketTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstPacket> : public PacketTypeDescr
+{
+};
+
+} /* namespace internal */
+
 template <typename LibObjT>
 nonstd::optional<ConstPacket> CommonEvent<LibObjT>::packet() const noexcept
 {
@@ -557,6 +593,26 @@ public:
 using Stream = CommonStream<bt_stream>;
 using ConstStream = CommonStream<const bt_stream>;
 
+namespace internal {
+
+struct StreamTypeDescr
+{
+    using Const = ConstStream;
+    using NonConst = Stream;
+};
+
+template <>
+struct TypeDescr<Stream> : public StreamTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstStream> : public StreamTypeDescr
+{
+};
+
+} /* namespace internal */
+
 template <typename LibObjT>
 ConstStream CommonEvent<LibObjT>::stream() const noexcept
 {
@@ -886,6 +942,26 @@ public:
 using Trace = CommonTrace<bt_trace>;
 using ConstTrace = CommonTrace<const bt_trace>;
 
+namespace internal {
+
+struct TraceTypeDescr
+{
+    using Const = ConstTrace;
+    using NonConst = Trace;
+};
+
+template <>
+struct TypeDescr<Trace> : public TraceTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstTrace> : public TraceTypeDescr
+{
+};
+
+} /* namespace internal */
+
 template <typename LibObjT>
 ConstTrace CommonStream<LibObjT>::trace() const noexcept
 {
@@ -1207,6 +1283,26 @@ public:
 using EventClass = CommonEventClass<bt_event_class>;
 using ConstEventClass = CommonEventClass<const bt_event_class>;
 
+namespace internal {
+
+struct EventClassTypeDescr
+{
+    using Const = ConstEventClass;
+    using NonConst = EventClass;
+};
+
+template <>
+struct TypeDescr<EventClass> : public EventClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstEventClass> : public EventClassTypeDescr
+{
+};
+
+} /* namespace internal */
+
 template <typename LibObjT>
 ConstEventClass CommonEvent<LibObjT>::cls() const noexcept
 {
@@ -1710,6 +1806,26 @@ public:
 using StreamClass = CommonStreamClass<bt_stream_class>;
 using ConstStreamClass = CommonStreamClass<const bt_stream_class>;
 
+namespace internal {
+
+struct StreamClassTypeDescr
+{
+    using Const = ConstStreamClass;
+    using NonConst = StreamClass;
+};
+
+template <>
+struct TypeDescr<StreamClass> : public StreamClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstStreamClass> : public StreamClassTypeDescr
+{
+};
+
+} /* namespace internal */
+
 template <typename LibObjT>
 ConstStreamClass CommonEventClass<LibObjT>::streamClass() const noexcept
 {
@@ -2178,6 +2294,26 @@ private:
 using TraceClass = CommonTraceClass<bt_trace_class>;
 using ConstTraceClass = CommonTraceClass<const bt_trace_class>;
 
+namespace internal {
+
+struct TraceClassTypeDescr
+{
+    using Const = ConstTraceClass;
+    using NonConst = TraceClass;
+};
+
+template <>
+struct TypeDescr<TraceClass> : public TraceClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstTraceClass> : public TraceClassTypeDescr
+{
+};
+
+} /* namespace internal */
+
 template <typename LibObjT>
 ConstTraceClass CommonStreamClass<LibObjT>::traceClass() const noexcept
 {
diff --git a/src/cpp-common/bt2/type-traits.hpp b/src/cpp-common/bt2/type-traits.hpp
new file mode 100644
index 00000000..53db3332
--- /dev/null
+++ b/src/cpp-common/bt2/type-traits.hpp
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2020 Philippe Proulx <pproulx@efficios.com>
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef BABELTRACE_CPP_COMMON_BT2_TYPE_TRAITS_HPP
+#define BABELTRACE_CPP_COMMON_BT2_TYPE_TRAITS_HPP
+
+#include "internal/utils.hpp"
+
+namespace bt2 {
+
+template <typename ObjT>
+struct AddConst
+{
+    using Type = typename internal::TypeDescr<ObjT>::Const;
+};
+
+template <typename ObjT>
+struct RemoveConst
+{
+    using Type = typename internal::TypeDescr<ObjT>::NonConst;
+};
+
+} /* namespace bt2 */
+
+#endif /* BABELTRACE_CPP_COMMON_BT2_TYPE_TRAITS_HPP */
diff --git a/src/cpp-common/bt2/value.hpp b/src/cpp-common/bt2/value.hpp
index dd05fea5..e9b61b13 100644
--- a/src/cpp-common/bt2/value.hpp
+++ b/src/cpp-common/bt2/value.hpp
@@ -24,7 +24,6 @@
 #include "lib-error.hpp"
 
 namespace bt2 {
-
 namespace internal {
 
 struct ValueRefFuncs final
@@ -232,6 +231,26 @@ protected:
 using Value = CommonValue<bt_value>;
 using ConstValue = CommonValue<const bt_value>;
 
+namespace internal {
+
+struct ValueTypeDescr
+{
+    using Const = ConstValue;
+    using NonConst = Value;
+};
+
+template <>
+struct TypeDescr<Value> : public ValueTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstValue> : public ValueTypeDescr
+{
+};
+
+} /* namespace internal */
+
 template <typename LibObjT>
 class CommonNullValue final : public CommonValue<LibObjT>
 {
@@ -266,6 +285,26 @@ public:
 using NullValue = CommonNullValue<bt_value>;
 using ConstNullValue = CommonNullValue<const bt_value>;
 
+namespace internal {
+
+struct NullValueTypeDescr
+{
+    using Const = ConstNullValue;
+    using NonConst = NullValue;
+};
+
+template <>
+struct TypeDescr<NullValue> : public NullValueTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstNullValue> : public NullValueTypeDescr
+{
+};
+
+} /* namespace internal */
+
 template <typename LibObjT>
 class CommonBoolValue final : public CommonValue<LibObjT>
 {
@@ -329,6 +368,26 @@ public:
 using BoolValue = CommonBoolValue<bt_value>;
 using ConstBoolValue = CommonBoolValue<const bt_value>;
 
+namespace internal {
+
+struct BoolValueTypeDescr
+{
+    using Const = ConstBoolValue;
+    using NonConst = BoolValue;
+};
+
+template <>
+struct TypeDescr<BoolValue> : public BoolValueTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstBoolValue> : public BoolValueTypeDescr
+{
+};
+
+} /* namespace internal */
+
 template <typename LibObjT>
 class CommonUnsignedIntegerValue final : public CommonValue<LibObjT>
 {
@@ -395,6 +454,26 @@ public:
 using UnsignedIntegerValue = CommonUnsignedIntegerValue<bt_value>;
 using ConstUnsignedIntegerValue = CommonUnsignedIntegerValue<const bt_value>;
 
+namespace internal {
+
+struct UnsignedIntegerValueTypeDescr
+{
+    using Const = ConstUnsignedIntegerValue;
+    using NonConst = UnsignedIntegerValue;
+};
+
+template <>
+struct TypeDescr<UnsignedIntegerValue> : public UnsignedIntegerValueTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstUnsignedIntegerValue> : public UnsignedIntegerValueTypeDescr
+{
+};
+
+} /* namespace internal */
+
 template <typename LibObjT>
 class CommonSignedIntegerValue final : public CommonValue<LibObjT>
 {
@@ -461,6 +540,26 @@ public:
 using SignedIntegerValue = CommonSignedIntegerValue<bt_value>;
 using ConstSignedIntegerValue = CommonSignedIntegerValue<const bt_value>;
 
+namespace internal {
+
+struct SignedIntegerValueTypeDescr
+{
+    using Const = ConstSignedIntegerValue;
+    using NonConst = SignedIntegerValue;
+};
+
+template <>
+struct TypeDescr<SignedIntegerValue> : public SignedIntegerValueTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstSignedIntegerValue> : public SignedIntegerValueTypeDescr
+{
+};
+
+} /* namespace internal */
+
 template <typename LibObjT>
 class CommonRealValue final : public CommonValue<LibObjT>
 {
@@ -524,6 +623,26 @@ public:
 using RealValue = CommonRealValue<bt_value>;
 using ConstRealValue = CommonRealValue<const bt_value>;
 
+namespace internal {
+
+struct RealValueTypeDescr
+{
+    using Const = ConstRealValue;
+    using NonConst = RealValue;
+};
+
+template <>
+struct TypeDescr<RealValue> : public RealValueTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstRealValue> : public RealValueTypeDescr
+{
+};
+
+} /* namespace internal */
+
 template <typename LibObjT>
 class CommonStringValue final : public CommonValue<LibObjT>
 {
@@ -598,6 +717,22 @@ using ConstStringValue = CommonStringValue<const bt_value>;
 
 namespace internal {
 
+struct StringValueTypeDescr
+{
+    using Const = ConstStringValue;
+    using NonConst = StringValue;
+};
+
+template <>
+struct TypeDescr<StringValue> : public StringValueTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstStringValue> : public StringValueTypeDescr
+{
+};
+
 template <typename LibObjT>
 struct CommonArrayValueSpec;
 
@@ -816,6 +951,22 @@ using ConstArrayValue = CommonArrayValue<const bt_value>;
 
 namespace internal {
 
+struct ArrayValueTypeDescr
+{
+    using Const = ConstArrayValue;
+    using NonConst = ArrayValue;
+};
+
+template <>
+struct TypeDescr<ArrayValue> : public ArrayValueTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstArrayValue> : public ArrayValueTypeDescr
+{
+};
+
 /*
  * Type of a user function passed to `CommonMapValue<ObjT>::forEach()`.
  *
@@ -1137,6 +1288,26 @@ private:
 using MapValue = CommonMapValue<bt_value>;
 using ConstMapValue = CommonMapValue<const bt_value>;
 
+namespace internal {
+
+struct MapValueTypeDescr
+{
+    using Const = ConstMapValue;
+    using NonConst = MapValue;
+};
+
+template <>
+struct TypeDescr<MapValue> : public MapValueTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstMapValue> : public MapValueTypeDescr
+{
+};
+
+} /* namespace internal */
+
 template <typename LibObjT>
 CommonNullValue<LibObjT> CommonValue<LibObjT>::asNull() const noexcept
 {
-- 
2.34.1