cpp-common/bt2: remove superfluous NL

[babeltrace.git] / src / cpp-common / bt2 / field-class.hpp

diff --git a/src/cpp-common/bt2/field-class.hpp b/src/cpp-common/bt2/field-class.hpp
index a8bbb3c462c5f8193810d0496e5d5c5bbd1a6d28..168af69c6f4601e0b79774986936b53535e857ae 100644 (file)
--- a/src/cpp-common/bt2/field-class.hpp
+++ b/src/cpp-common/bt2/field-class.hpp
@@ -16,13 +16,13 @@
 #include "cpp-common/optional.hpp"
 #include "cpp-common/string_view.hpp"
 
-#include "borrowed-obj.hpp"
+#include "borrowed-object.hpp"
 #include "common-iter.hpp"
 #include "exc.hpp"
 #include "field-path.hpp"
 #include "integer-range-set.hpp"
-#include "internal/shared-obj.hpp"
 #include "internal/utils.hpp"
+#include "shared-object.hpp"
 #include "value.hpp"
 
 namespace bt2 {
@@ -41,9 +41,6 @@ struct FieldClassRefFuncs final
     }
 };
 
-template <typename ObjT, typename LibObjT>
-using SharedFieldClass = internal::SharedObj<ObjT, LibObjT, internal::FieldClassRefFuncs>;
-
 template <typename LibObjT>
 struct CommonFieldClassSpec;
 
@@ -69,6 +66,9 @@ struct CommonFieldClassSpec<const bt_field_class> final
 
 } /* namespace internal */
 
+template <typename ObjT, typename LibObjT>
+using SharedFieldClass = SharedObject<ObjT, LibObjT, internal::FieldClassRefFuncs>;
+
 template <typename LibObjT>
 class CommonBitArrayFieldClass;
 
@@ -161,7 +161,7 @@ enum class FieldClassType
 };
 
 template <typename LibObjT>
-class CommonFieldClass : public BorrowedObj<LibObjT>
+class CommonFieldClass : public BorrowedObject<LibObjT>
 {
     /* Allow appendMember() to call `fc.libObjPtr()` */
     friend class CommonStructureFieldClass<bt_field_class>;
@@ -187,31 +187,31 @@ class CommonFieldClass : public BorrowedObj<LibObjT>
     friend class CommonTraceClass<bt_trace_class>;
 
 private:
-    using typename BorrowedObj<LibObjT>::_ThisBorrowedObj;
+    using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
 
 protected:
-    using typename BorrowedObj<LibObjT>::_LibObjPtr;
+    using typename BorrowedObject<LibObjT>::_LibObjPtr;
     using _ThisCommonFieldClass = CommonFieldClass<LibObjT>;
 
 public:
-    using Shared = internal::SharedFieldClass<CommonFieldClass<LibObjT>, LibObjT>;
+    using Shared = SharedFieldClass<CommonFieldClass<LibObjT>, LibObjT>;
 
     using UserAttributes =
         typename std::conditional<std::is_const<LibObjT>::value, ConstMapValue, MapValue>::type;
 
-    explicit CommonFieldClass(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObj {libObjPtr}
+    explicit CommonFieldClass(const _LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
     {
     }
 
     template <typename OtherLibObjT>
-    CommonFieldClass(const CommonFieldClass<OtherLibObjT> fc) noexcept : _ThisBorrowedObj {fc}
+    CommonFieldClass(const CommonFieldClass<OtherLibObjT> fc) noexcept : _ThisBorrowedObject {fc}
     {
     }
 
     template <typename OtherLibObjT>
     CommonFieldClass& operator=(const CommonFieldClass<OtherLibObjT> fc) noexcept
     {
-        _ThisBorrowedObj::operator=(fc);
+        _ThisBorrowedObject::operator=(fc);
         return *this;
     }
 
@@ -483,7 +483,7 @@ private:
     using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
 
 public:
-    using Shared = internal::SharedFieldClass<CommonBitArrayFieldClass<LibObjT>, LibObjT>;
+    using Shared = SharedFieldClass<CommonBitArrayFieldClass<LibObjT>, LibObjT>;
 
     explicit CommonBitArrayFieldClass(const _LibObjPtr libObjPtr) noexcept :
         _ThisCommonFieldClass {libObjPtr}
@@ -558,7 +558,7 @@ protected:
     using _ThisCommonIntegerFieldClass = CommonIntegerFieldClass<LibObjT>;
 
 public:
-    using Shared = internal::SharedFieldClass<CommonIntegerFieldClass<LibObjT>, LibObjT>;
+    using Shared = SharedFieldClass<CommonIntegerFieldClass<LibObjT>, LibObjT>;
 
     explicit CommonIntegerFieldClass(const _LibObjPtr libObjPtr) noexcept :
         _ThisCommonFieldClass {libObjPtr}
@@ -679,11 +679,11 @@ struct ConstEnumerationFieldClassMappingSpec<const bt_field_class_enumeration_si
 } /* namespace internal */
 
 template <typename LibObjT>
-class ConstEnumerationFieldClassMapping final : public BorrowedObj<LibObjT>
+class ConstEnumerationFieldClassMapping final : public BorrowedObject<LibObjT>
 {
 private:
-    using typename BorrowedObj<LibObjT>::_ThisBorrowedObj;
-    using typename BorrowedObj<LibObjT>::_LibObjPtr;
+    using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
+    using typename BorrowedObject<LibObjT>::_LibObjPtr;
 
 public:
     using RangeSet = typename std::conditional<
@@ -691,19 +691,19 @@ public:
         ConstUnsignedIntegerRangeSet, ConstSignedIntegerRangeSet>::type;
 
     explicit ConstEnumerationFieldClassMapping(const _LibObjPtr libObjPtr) noexcept :
-        _ThisBorrowedObj {libObjPtr}
+        _ThisBorrowedObject {libObjPtr}
     {
     }
 
     ConstEnumerationFieldClassMapping(const ConstEnumerationFieldClassMapping& mapping) noexcept :
-        _ThisBorrowedObj {mapping}
+        _ThisBorrowedObject {mapping}
     {
     }
 
     ConstEnumerationFieldClassMapping&
     operator=(const ConstEnumerationFieldClassMapping& mapping) noexcept
     {
-        _ThisBorrowedObj::operator=(mapping);
+        _ThisBorrowedObject::operator=(mapping);
         return *this;
     }
 
@@ -791,7 +791,7 @@ protected:
     using _ThisCommonBaseEnumerationFieldClass = CommonBaseEnumerationFieldClass<LibObjT>;
 
 public:
-    using Shared = internal::SharedFieldClass<_ThisCommonBaseEnumerationFieldClass, LibObjT>;
+    using Shared = SharedFieldClass<_ThisCommonBaseEnumerationFieldClass, LibObjT>;
 
     explicit CommonBaseEnumerationFieldClass(const _LibObjPtr libObjPtr) noexcept :
         _ThisCommonIntegerFieldClass {libObjPtr}
@@ -834,7 +834,7 @@ private:
     using _ThisCommonEnumerationFieldClass = CommonEnumerationFieldClass<LibObjT, MappingT>;
 
 public:
-    using Shared = internal::SharedFieldClass<_ThisCommonEnumerationFieldClass, LibObjT>;
+    using Shared = SharedFieldClass<_ThisCommonEnumerationFieldClass, LibObjT>;
     using Iterator = CommonIterator<CommonEnumerationFieldClass, MappingT>;
     using Mapping = MappingT;
 
@@ -1000,11 +1000,11 @@ struct CommonStructureFieldClassMemberSpec<const bt_field_class_structure_member
 } /* namespace internal */
 
 template <typename LibObjT>
-class CommonStructureFieldClassMember final : public BorrowedObj<LibObjT>
+class CommonStructureFieldClassMember final : public BorrowedObject<LibObjT>
 {
 private:
-    using typename BorrowedObj<LibObjT>::_LibObjPtr;
-    using typename BorrowedObj<LibObjT>::_ThisBorrowedObj;
+    using typename BorrowedObject<LibObjT>::_LibObjPtr;
+    using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
 
     using _FieldClass =
         typename std::conditional<std::is_const<LibObjT>::value, ConstFieldClass, FieldClass>::type;
@@ -1014,14 +1014,14 @@ public:
         typename std::conditional<std::is_const<LibObjT>::value, ConstMapValue, MapValue>::type;
 
     explicit CommonStructureFieldClassMember(const _LibObjPtr libObjPtr) noexcept :
-        _ThisBorrowedObj {libObjPtr}
+        _ThisBorrowedObject {libObjPtr}
     {
     }
 
     template <typename OtherLibObjT>
     CommonStructureFieldClassMember(const CommonStructureFieldClassMember<OtherLibObjT> fc) noexcept
         :
-        _ThisBorrowedObj {fc}
+        _ThisBorrowedObject {fc}
     {
     }
 
@@ -1029,7 +1029,7 @@ public:
     CommonStructureFieldClassMember<LibObjT>&
     operator=(const CommonStructureFieldClassMember<OtherLibObjT> fc) noexcept
     {
-        _ThisBorrowedObj::operator=(fc);
+        _ThisBorrowedObject::operator=(fc);
         return *this;
     }
 
@@ -1143,7 +1143,7 @@ private:
     using typename CommonFieldClass<LibObjT>::_ThisCommonFieldClass;
 
 public:
-    using Shared = internal::SharedFieldClass<CommonStructureFieldClass<LibObjT>, LibObjT>;
+    using Shared = SharedFieldClass<CommonStructureFieldClass<LibObjT>, LibObjT>;
     using Member =
         typename std::conditional<std::is_const<LibObjT>::value, ConstStructureFieldClassMember,
                                   StructureFieldClassMember>::type;
@@ -1317,7 +1317,7 @@ protected:
     using _ThisCommonArrayFieldClass = CommonArrayFieldClass<LibObjT>;
 
 public:
-    using Shared = internal::SharedFieldClass<CommonArrayFieldClass<LibObjT>, LibObjT>;
+    using Shared = SharedFieldClass<CommonArrayFieldClass<LibObjT>, LibObjT>;
 
     explicit CommonArrayFieldClass(const _LibObjPtr libObjPtr) noexcept :
         _ThisCommonFieldClass {libObjPtr}
@@ -1388,7 +1388,7 @@ private:
     using typename CommonFieldClass<LibObjT>::_LibObjPtr;
 
 public:
-    using Shared = internal::SharedFieldClass<CommonStaticArrayFieldClass<LibObjT>, LibObjT>;
+    using Shared = SharedFieldClass<CommonStaticArrayFieldClass<LibObjT>, LibObjT>;
 
     explicit CommonStaticArrayFieldClass(const _LibObjPtr libObjPtr) noexcept :
         _ThisCommonArrayFieldClass {libObjPtr}
@@ -1452,8 +1452,7 @@ private:
     using typename CommonFieldClass<LibObjT>::_LibObjPtr;
 
 public:
-    using Shared =
-        internal::SharedFieldClass<CommonDynamicArrayWithLengthFieldClass<LibObjT>, LibObjT>;
+    using Shared = SharedFieldClass<CommonDynamicArrayWithLengthFieldClass<LibObjT>, LibObjT>;
 
     explicit CommonDynamicArrayWithLengthFieldClass(const _LibObjPtr libObjPtr) noexcept :
         _ThisCommonArrayFieldClass {libObjPtr}
@@ -1553,7 +1552,7 @@ protected:
     using _ThisCommonOptionFieldClass = CommonOptionFieldClass<LibObjT>;
 
 public:
-    using Shared = internal::SharedFieldClass<CommonOptionFieldClass<LibObjT>, LibObjT>;
+    using Shared = SharedFieldClass<CommonOptionFieldClass<LibObjT>, LibObjT>;
 
     explicit CommonOptionFieldClass(const _LibObjPtr libObjPtr) noexcept :
         _ThisCommonFieldClass {libObjPtr}
@@ -1627,7 +1626,7 @@ protected:
     using _ThisCommonOptionWithSelectorFieldClass = CommonOptionWithSelectorFieldClass<LibObjT>;
 
 public:
-    using Shared = internal::SharedFieldClass<CommonOptionWithSelectorFieldClass<LibObjT>, LibObjT>;
+    using Shared = SharedFieldClass<CommonOptionWithSelectorFieldClass<LibObjT>, LibObjT>;
 
     explicit CommonOptionWithSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
         _ThisCommonOptionFieldClass {libObjPtr}
@@ -1696,8 +1695,7 @@ private:
         LibObjT>::_ThisCommonOptionWithSelectorFieldClass;
 
 public:
-    using Shared =
-        internal::SharedFieldClass<CommonOptionWithBoolSelectorFieldClass<LibObjT>, LibObjT>;
+    using Shared = SharedFieldClass<CommonOptionWithBoolSelectorFieldClass<LibObjT>, LibObjT>;
 
     explicit CommonOptionWithBoolSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
         _ThisCommonOptionWithSelectorFieldClass {libObjPtr}
@@ -1799,8 +1797,7 @@ private:
         CommonOptionWithIntegerSelectorFieldClass<LibObjT, RangeSetT>;
 
 public:
-    using Shared =
-        internal::SharedFieldClass<_ThisCommonOptionWithIntegerSelectorFieldClass, LibObjT>;
+    using Shared = SharedFieldClass<_ThisCommonOptionWithIntegerSelectorFieldClass, LibObjT>;
 
     using RangeSet = RangeSetT;
 
@@ -1925,11 +1922,11 @@ struct CommonVariantFieldClassOptionSpec<const bt_field_class_variant_option> fi
 } /* namespace internal */
 
 template <typename LibObjT>
-class CommonVariantFieldClassOption : public BorrowedObj<LibObjT>
+class CommonVariantFieldClassOption : public BorrowedObject<LibObjT>
 {
 private:
-    using typename BorrowedObj<LibObjT>::_ThisBorrowedObj;
-    using typename BorrowedObj<LibObjT>::_LibObjPtr;
+    using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
+    using typename BorrowedObject<LibObjT>::_LibObjPtr;
 
     using _FieldClass =
         typename std::conditional<std::is_const<LibObjT>::value, ConstFieldClass, FieldClass>::type;
@@ -1939,13 +1936,13 @@ public:
         typename std::conditional<std::is_const<LibObjT>::value, ConstMapValue, MapValue>::type;
 
     explicit CommonVariantFieldClassOption(const _LibObjPtr libObjPtr) noexcept :
-        _ThisBorrowedObj {libObjPtr}
+        _ThisBorrowedObject {libObjPtr}
     {
     }
 
     template <typename OtherLibObjT>
     CommonVariantFieldClassOption(const CommonVariantFieldClassOption<OtherLibObjT> fc) noexcept :
-        _ThisBorrowedObj {fc}
+        _ThisBorrowedObject {fc}
     {
     }
 
@@ -1953,7 +1950,7 @@ public:
     CommonVariantFieldClassOption&
     operator=(const CommonVariantFieldClassOption<OtherLibObjT> fc) noexcept
     {
-        _ThisBorrowedObj::operator=(fc);
+        _ThisBorrowedObject::operator=(fc);
         return *this;
     }
 
@@ -2076,11 +2073,11 @@ struct ConstVariantWithIntegerSelectorFieldClassOptionSpec<
 } /* namespace internal */
 
 template <typename LibObjT>
-class ConstVariantWithIntegerSelectorFieldClassOption : public BorrowedObj<LibObjT>
+class ConstVariantWithIntegerSelectorFieldClassOption : public BorrowedObject<LibObjT>
 {
 private:
-    using typename BorrowedObj<LibObjT>::_ThisBorrowedObj;
-    using typename BorrowedObj<LibObjT>::_LibObjPtr;
+    using typename BorrowedObject<LibObjT>::_ThisBorrowedObject;
+    using typename BorrowedObject<LibObjT>::_LibObjPtr;
     using _Spec = internal::ConstVariantWithIntegerSelectorFieldClassOptionSpec<LibObjT>;
 
 public:
@@ -2091,14 +2088,14 @@ public:
         ConstUnsignedIntegerRangeSet, ConstSignedIntegerRangeSet>::type;
 
     explicit ConstVariantWithIntegerSelectorFieldClassOption(const _LibObjPtr libObjPtr) noexcept :
-        _ThisBorrowedObj {libObjPtr}
+        _ThisBorrowedObject {libObjPtr}
     {
     }
 
     template <typename OtherLibObjT>
     ConstVariantWithIntegerSelectorFieldClassOption(
         const ConstVariantWithIntegerSelectorFieldClassOption<OtherLibObjT> fc) noexcept :
-        _ThisBorrowedObj {fc}
+        _ThisBorrowedObject {fc}
     {
     }
 
@@ -2106,7 +2103,7 @@ public:
     ConstVariantWithIntegerSelectorFieldClassOption&
     operator=(const ConstVariantWithIntegerSelectorFieldClassOption<OtherLibObjT> fc) noexcept
     {
-        _ThisBorrowedObj::operator=(fc);
+        _ThisBorrowedObject::operator=(fc);
         return *this;
     }
 
@@ -2191,7 +2188,7 @@ protected:
     using _ThisCommonVariantFieldClass = CommonVariantFieldClass<LibObjT>;
 
 public:
-    using Shared = internal::SharedFieldClass<CommonVariantFieldClass<LibObjT>, LibObjT>;
+    using Shared = SharedFieldClass<CommonVariantFieldClass<LibObjT>, LibObjT>;
 
     using Option =
         typename std::conditional<std::is_const<LibObjT>::value, ConstVariantFieldClassOption,
@@ -2320,8 +2317,7 @@ private:
     using typename CommonFieldClass<LibObjT>::_LibObjPtr;
 
 public:
-    using Shared =
-        internal::SharedFieldClass<CommonVariantWithoutSelectorFieldClass<LibObjT>, LibObjT>;
+    using Shared = SharedFieldClass<CommonVariantWithoutSelectorFieldClass<LibObjT>, LibObjT>;
 
     explicit CommonVariantWithoutSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
         _ThisCommonVariantFieldClass {libObjPtr}
@@ -2468,7 +2464,7 @@ protected:
     using _ThisCommonVariantWithSelectorFieldClass = CommonVariantWithSelectorFieldClass<LibObjT>;
 
 public:
-    using Shared = internal::SharedFieldClass<_ThisCommonVariantWithSelectorFieldClass, LibObjT>;
+    using Shared = SharedFieldClass<_ThisCommonVariantWithSelectorFieldClass, LibObjT>;
 
     explicit CommonVariantWithSelectorFieldClass(const _LibObjPtr libObjPtr) noexcept :
         _ThisCommonVariantFieldClass {libObjPtr}
@@ -2522,8 +2518,7 @@ private:
     using _Spec = internal::CommonVariantWithIntegerSelectorFieldClassSpec<OptionT>;
 
 public:
-    using Shared =
-        internal::SharedFieldClass<_ThisCommonVariantWithIntegerSelectorFieldClass, LibObjT>;
+    using Shared = SharedFieldClass<_ThisCommonVariantWithIntegerSelectorFieldClass, LibObjT>;
 
     using Option = OptionT;
     using Iterator =