cpp-common/bt2: remove unnecessary mentions of `bt2::`

Don't use `bt2::` when already inside the `bt2` namespace.

Change-Id: I63444e141ae13b6e508d4508488fb562ae9403d7
Signed-off-by: Simon Marchi <simon.marchi@efficios.com>
Reviewed-on: https://review.lttng.org/c/babeltrace/+/12047
Reviewed-by: Philippe Proulx <eeppeliteloop@gmail.com>
Tested-by: jenkins <jenkins@lttng.org>

diff --git a/src/cpp-common/bt2/component-class-dev.hpp b/src/cpp-common/bt2/component-class-dev.hpp
index 37a655c85ca6826e1675d1304510c6d1db6c703f..d7a46edd8dd9f46ba9f466e15ae5cc68a8a437b4 100644 (file)
--- a/src/cpp-common/bt2/component-class-dev.hpp
+++ b/src/cpp-common/bt2/component-class-dev.hpp
@@ -486,7 +486,7 @@ protected:
     }
 
 public:
-    void next(bt2::ConstMessageArray& messages)
+    void next(ConstMessageArray& messages)
     {
         /* Any saved error? Now is the time to throw */
         if (G_UNLIKELY(_mExcToThrowType != _ExcToThrowType::NONE)) {
@@ -497,10 +497,10 @@ public:
 
             /* Throw the corresponding exception */
             if (_mExcToThrowType == _ExcToThrowType::ERROR) {
-                throw bt2::Error {};
+                throw Error {};
             } else {
                 BT_ASSERT(_mExcToThrowType == _ExcToThrowType::MEM_ERROR);
-                throw bt2::MemoryError {};
+                throw MemoryError {};
             }
         }
 
@@ -520,7 +520,7 @@ public:
 
             /* We're done: everything below is exception handling */
             return;
-        } catch (const bt2::TryAgain&) {
+        } catch (const TryAgain&) {
             if (messages.isEmpty()) {
                 throw;
             }
@@ -530,7 +530,7 @@ public:
             }
 
             _mExcToThrowType = _ExcToThrowType::MEM_ERROR;
-        } catch (const bt2::Error&) {
+        } catch (const Error&) {
             if (messages.isEmpty()) {
                 throw;
             }

diff --git a/src/cpp-common/bt2/internal/comp-cls-bridge.hpp b/src/cpp-common/bt2/internal/comp-cls-bridge.hpp
index 99d5bf777861f0defa9a26b254722eb781f84e90..6b16e733a38aa3bce63b6c30ee0e8d7adbdd0805 100644 (file)
--- a/src/cpp-common/bt2/internal/comp-cls-bridge.hpp
+++ b/src/cpp-common/bt2/internal/comp-cls-bridge.hpp
@@ -283,7 +283,7 @@ public:
     static UserMsgIterT&
     userMsgIterFromLibSelfMsgIterPtr(bt_self_message_iterator * const libSelfMsgIterPtr) noexcept
     {
-        return bt2::wrap(libSelfMsgIterPtr).data<UserMsgIterT>();
+        return wrap(libSelfMsgIterPtr).data<UserMsgIterT>();
     }
 
     static bt_message_iterator_class_initialize_method_status
@@ -291,16 +291,16 @@ public:
          bt_self_message_iterator_configuration * const libSelfMsgIterConfigPtr,
          bt_self_component_port_output * const libSelfCompPortPtr) noexcept
     {
-        const auto selfMsgIter = bt2::wrap(libSelfMsgIterPtr);
+        const auto selfMsgIter = wrap(libSelfMsgIterPtr);
 
         try {
-            const auto msgIter = new UserMsgIterT {selfMsgIter, bt2::wrap(libSelfMsgIterConfigPtr),
-                                                   bt2::wrap(libSelfCompPortPtr)};
+            const auto msgIter = new UserMsgIterT {selfMsgIter, wrap(libSelfMsgIterConfigPtr),
+                                                   wrap(libSelfCompPortPtr)};
 
             selfMsgIter.data(*msgIter);
         } catch (const std::bad_alloc&) {
             return BT_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_STATUS_MEMORY_ERROR;
-        } catch (const bt2::Error&) {
+        } catch (const Error&) {
             return BT_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_STATUS_ERROR;
         } catch (...) {
             BT_LOG_WRITE_CUR_LVL(
@@ -323,7 +323,7 @@ public:
          const uint64_t capacity, uint64_t * const count) noexcept
     {
         try {
-            auto msgArray = bt2::ConstMessageArray::wrapEmpty(libMsgsPtr, capacity);
+            auto msgArray = ConstMessageArray::wrapEmpty(libMsgsPtr, capacity);
             auto& msgIter = userMsgIterFromLibSelfMsgIterPtr(libSelfMsgIterPtr);
 
             msgIter.next(msgArray);
@@ -334,11 +334,11 @@ public:
             } else {
                 return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_END;
             }
-        } catch (const bt2::TryAgain&) {
+        } catch (const TryAgain&) {
             return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_AGAIN;
         } catch (const std::bad_alloc&) {
             return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_MEMORY_ERROR;
-        } catch (const bt2::Error&) {
+        } catch (const Error&) {
             return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_ERROR;
         } catch (...) {
             BT_LOG_WRITE_CUR_LVL(
@@ -356,11 +356,11 @@ public:
         try {
             *canSeek = static_cast<bt_bool>(
                 userMsgIterFromLibSelfMsgIterPtr(libSelfMsgIterPtr).canSeekBeginning());
-        } catch (const bt2::TryAgain&) {
+        } catch (const TryAgain&) {
             return BT_MESSAGE_ITERATOR_CLASS_CAN_SEEK_BEGINNING_METHOD_STATUS_AGAIN;
         } catch (const std::bad_alloc&) {
             return BT_MESSAGE_ITERATOR_CLASS_CAN_SEEK_BEGINNING_METHOD_STATUS_MEMORY_ERROR;
-        } catch (const bt2::Error&) {
+        } catch (const Error&) {
             return BT_MESSAGE_ITERATOR_CLASS_CAN_SEEK_BEGINNING_METHOD_STATUS_ERROR;
         } catch (...) {
             BT_LOG_WRITE_CUR_LVL(
@@ -378,11 +378,11 @@ public:
     {
         try {
             userMsgIterFromLibSelfMsgIterPtr(libSelfMsgIterPtr).seekBeginning();
-        } catch (const bt2::TryAgain&) {
+        } catch (const TryAgain&) {
             return BT_MESSAGE_ITERATOR_CLASS_SEEK_BEGINNING_METHOD_STATUS_AGAIN;
         } catch (const std::bad_alloc&) {
             return BT_MESSAGE_ITERATOR_CLASS_SEEK_BEGINNING_METHOD_STATUS_MEMORY_ERROR;
-        } catch (const bt2::Error&) {
+        } catch (const Error&) {
             return BT_MESSAGE_ITERATOR_CLASS_SEEK_BEGINNING_METHOD_STATUS_ERROR;
         } catch (...) {
             BT_LOG_WRITE_CUR_LVL(
@@ -402,11 +402,11 @@ public:
         try {
             *canSeek = static_cast<bt_bool>(userMsgIterFromLibSelfMsgIterPtr(libSelfMsgIterPtr)
                                                 .canSeekNsFromOrigin(nsFromOrigin));
-        } catch (const bt2::TryAgain&) {
+        } catch (const TryAgain&) {
             return BT_MESSAGE_ITERATOR_CLASS_CAN_SEEK_NS_FROM_ORIGIN_METHOD_STATUS_AGAIN;
         } catch (const std::bad_alloc&) {
             return BT_MESSAGE_ITERATOR_CLASS_CAN_SEEK_NS_FROM_ORIGIN_METHOD_STATUS_MEMORY_ERROR;
-        } catch (const bt2::Error&) {
+        } catch (const Error&) {
             return BT_MESSAGE_ITERATOR_CLASS_CAN_SEEK_NS_FROM_ORIGIN_METHOD_STATUS_ERROR;
         } catch (...) {
             BT_LOG_WRITE_CUR_LVL(
@@ -425,11 +425,11 @@ public:
     {
         try {
             userMsgIterFromLibSelfMsgIterPtr(libSelfMsgIterPtr).seekNsFromOrigin(nsFromOrigin);
-        } catch (const bt2::TryAgain&) {
+        } catch (const TryAgain&) {
             return BT_MESSAGE_ITERATOR_CLASS_SEEK_NS_FROM_ORIGIN_METHOD_STATUS_AGAIN;
         } catch (const std::bad_alloc&) {
             return BT_MESSAGE_ITERATOR_CLASS_SEEK_NS_FROM_ORIGIN_METHOD_STATUS_MEMORY_ERROR;
-        } catch (const bt2::Error&) {
+        } catch (const Error&) {
             return BT_MESSAGE_ITERATOR_CLASS_SEEK_NS_FROM_ORIGIN_METHOD_STATUS_ERROR;
         } catch (...) {
             BT_LOG_WRITE_CUR_LVL(

diff --git a/src/cpp-common/bt2/private-query-executor.hpp b/src/cpp-common/bt2/private-query-executor.hpp
index 016b9a429314567ef12bafee3ce969c470fa4168..95264a11880cd07c3316471e219194ad58c49f25 100644 (file)
--- a/src/cpp-common/bt2/private-query-executor.hpp
+++ b/src/cpp-common/bt2/private-query-executor.hpp
@@ -23,9 +23,9 @@ public:
     {
     }
 
-    bt2::LoggingLevel loggingLevel() const noexcept
+    LoggingLevel loggingLevel() const noexcept
     {
-        return static_cast<bt2::LoggingLevel>(bt_query_executor_get_logging_level(
+        return static_cast<LoggingLevel>(bt_query_executor_get_logging_level(
             bt_private_query_executor_as_query_executor_const(this->libObjPtr())));
     }
 

diff --git a/src/cpp-common/bt2/self-component-port.hpp b/src/cpp-common/bt2/self-component-port.hpp
index e1ab809859461f618510b9e9526ee2637e057aee..10a73bb4bd3a021c58a5cd4722d4fa133a7ec3f5 100644 (file)
--- a/src/cpp-common/bt2/self-component-port.hpp
+++ b/src/cpp-common/bt2/self-component-port.hpp
@@ -106,7 +106,7 @@ public:
         return *this;
     }
 
-    bt2::TraceClass::Shared createTraceClass() const
+    TraceClass::Shared createTraceClass() const
     {
         const auto libObjPtr = bt_trace_class_create(this->libObjPtr());
 
@@ -114,10 +114,10 @@ public:
             throw MemoryError {};
         }
 
-        return bt2::TraceClass::Shared::createWithoutRef(libObjPtr);
+        return TraceClass::Shared::createWithoutRef(libObjPtr);
     }
 
-    bt2::ClockClass::Shared createClockClass() const
+    ClockClass::Shared createClockClass() const
     {
         const auto libObjPtr = bt_clock_class_create(this->libObjPtr());
 
@@ -125,7 +125,7 @@ public:
             throw MemoryError {};
         }
 
-        return bt2::ClockClass::Shared::createWithoutRef(libObjPtr);
+        return ClockClass::Shared::createWithoutRef(libObjPtr);
     }
 };
 

diff --git a/src/cpp-common/bt2/self-message-iterator.hpp b/src/cpp-common/bt2/self-message-iterator.hpp
index 7ad212c11b4b6e0144b4f774d00202faa78e1055..609514543aa286d47c51b7d794ae2057523c1390 100644 (file)
--- a/src/cpp-common/bt2/self-message-iterator.hpp
+++ b/src/cpp-common/bt2/self-message-iterator.hpp
@@ -72,8 +72,7 @@ public:
         return *this;
     }
 
-    bt2::StreamBeginningMessage::Shared
-    createStreamBeginningMessage(const bt2::ConstStream stream) const
+    StreamBeginningMessage::Shared createStreamBeginningMessage(const ConstStream stream) const
     {
         const auto libObjPtr =
             bt_message_stream_beginning_create(this->libObjPtr(), stream.libObjPtr());
@@ -82,10 +81,10 @@ public:
             throw MemoryError {};
         }
 
-        return bt2::StreamBeginningMessage::Shared::createWithoutRef(libObjPtr);
+        return StreamBeginningMessage::Shared::createWithoutRef(libObjPtr);
     }
 
-    bt2::StreamEndMessage::Shared createStreamEndMessage(const bt2::ConstStream stream) const
+    StreamEndMessage::Shared createStreamEndMessage(const ConstStream stream) const
     {
         const auto libObjPtr = bt_message_stream_end_create(this->libObjPtr(), stream.libObjPtr());
 
@@ -93,11 +92,11 @@ public:
             throw MemoryError {};
         }
 
-        return bt2::StreamEndMessage::Shared::createWithoutRef(libObjPtr);
+        return StreamEndMessage::Shared::createWithoutRef(libObjPtr);
     }
 
-    bt2::EventMessage::Shared createEventMessage(const bt2::ConstEventClass eventCls,
-                                                 const bt2::ConstStream stream) const
+    EventMessage::Shared createEventMessage(const ConstEventClass eventCls,
+                                            const ConstStream stream) const
     {
         const auto libObjPtr =
             bt_message_event_create(this->libObjPtr(), eventCls.libObjPtr(), stream.libObjPtr());
@@ -106,12 +105,12 @@ public:
             throw MemoryError {};
         }
 
-        return bt2::EventMessage::Shared::createWithoutRef(libObjPtr);
+        return EventMessage::Shared::createWithoutRef(libObjPtr);
     }
 
-    bt2::EventMessage::Shared createEventMessage(const bt2::ConstEventClass eventCls,
-                                                 const bt2::ConstStream stream,
-                                                 const std::uint64_t clockSnapshotValue) const
+    EventMessage::Shared createEventMessage(const ConstEventClass eventCls,
+                                            const ConstStream stream,
+                                            const std::uint64_t clockSnapshotValue) const
     {
         const auto libObjPtr = bt_message_event_create_with_default_clock_snapshot(
             this->libObjPtr(), eventCls.libObjPtr(), stream.libObjPtr(), clockSnapshotValue);
@@ -120,11 +119,11 @@ public:
             throw MemoryError {};
         }
 
-        return bt2::EventMessage::Shared::createWithoutRef(libObjPtr);
+        return EventMessage::Shared::createWithoutRef(libObjPtr);
     }
 
-    bt2::EventMessage::Shared createEventMessage(const bt2::ConstEventClass eventCls,
-                                                 const bt2::ConstPacket packet) const
+    EventMessage::Shared createEventMessage(const ConstEventClass eventCls,
+                                            const ConstPacket packet) const
     {
         const auto libObjPtr = bt_message_event_create_with_packet(
             this->libObjPtr(), eventCls.libObjPtr(), packet.libObjPtr());
@@ -133,12 +132,12 @@ public:
             throw MemoryError {};
         }
 
-        return bt2::EventMessage::Shared::createWithoutRef(libObjPtr);
+        return EventMessage::Shared::createWithoutRef(libObjPtr);
     }
 
-    bt2::EventMessage::Shared createEventMessage(const bt2::ConstEventClass eventCls,
-                                                 const bt2::ConstPacket packet,
-                                                 const std::uint64_t clockSnapshotValue) const
+    EventMessage::Shared createEventMessage(const ConstEventClass eventCls,
+                                            const ConstPacket packet,
+                                            const std::uint64_t clockSnapshotValue) const
     {
         const auto libObjPtr = bt_message_event_create_with_packet_and_default_clock_snapshot(
             this->libObjPtr(), eventCls.libObjPtr(), packet.libObjPtr(), clockSnapshotValue);
@@ -147,11 +146,10 @@ public:
             throw MemoryError {};
         }
 
-        return bt2::EventMessage::Shared::createWithoutRef(libObjPtr);
+        return EventMessage::Shared::createWithoutRef(libObjPtr);
     }
 
-    bt2::PacketBeginningMessage::Shared
-    createPacketBeginningMessage(const bt2::ConstPacket packet) const
+    PacketBeginningMessage::Shared createPacketBeginningMessage(const ConstPacket packet) const
     {
         const auto libObjPtr =
             bt_message_packet_beginning_create(this->libObjPtr(), packet.libObjPtr());
@@ -160,11 +158,11 @@ public:
             throw MemoryError {};
         }
 
-        return bt2::PacketBeginningMessage::Shared::createWithoutRef(libObjPtr);
+        return PacketBeginningMessage::Shared::createWithoutRef(libObjPtr);
     }
 
-    bt2::PacketBeginningMessage::Shared
-    createPacketBeginningMessage(const bt2::ConstPacket packet,
+    PacketBeginningMessage::Shared
+    createPacketBeginningMessage(const ConstPacket packet,
                                  const std::uint64_t clockSnapshotValue) const
     {
         const auto libObjPtr = bt_message_packet_beginning_create_with_default_clock_snapshot(
@@ -174,10 +172,10 @@ public:
             throw MemoryError {};
         }
 
-        return bt2::PacketBeginningMessage::Shared::createWithoutRef(libObjPtr);
+        return PacketBeginningMessage::Shared::createWithoutRef(libObjPtr);
     }
 
-    bt2::PacketEndMessage::Shared createPacketEndMessage(const bt2::ConstPacket packet) const
+    PacketEndMessage::Shared createPacketEndMessage(const ConstPacket packet) const
     {
         const auto libObjPtr = bt_message_packet_end_create(this->libObjPtr(), packet.libObjPtr());
 
@@ -185,12 +183,11 @@ public:
             throw MemoryError {};
         }
 
-        return bt2::PacketEndMessage::Shared::createWithoutRef(libObjPtr);
+        return PacketEndMessage::Shared::createWithoutRef(libObjPtr);
     }
 
-    bt2::PacketEndMessage::Shared
-    createPacketEndMessage(const bt2::ConstPacket packet,
-                           const std::uint64_t clockSnapshotValue) const
+    PacketEndMessage::Shared createPacketEndMessage(const ConstPacket packet,
+                                                    const std::uint64_t clockSnapshotValue) const
     {
         const auto libObjPtr = bt_message_packet_end_create_with_default_clock_snapshot(
             this->libObjPtr(), packet.libObjPtr(), clockSnapshotValue);
@@ -199,10 +196,10 @@ public:
             throw MemoryError {};
         }
 
-        return bt2::PacketEndMessage::Shared::createWithoutRef(libObjPtr);
+        return PacketEndMessage::Shared::createWithoutRef(libObjPtr);
     }
 
-    bt2::DiscardedEventsMessage::Shared createDiscardedEventsMessage(const bt2::ConstStream stream)
+    DiscardedEventsMessage::Shared createDiscardedEventsMessage(const ConstStream stream)
     {
         const auto libObjPtr =
             bt_message_discarded_events_create(this->libObjPtr(), stream.libObjPtr());
@@ -211,11 +208,11 @@ public:
             throw MemoryError {};
         }
 
-        return bt2::DiscardedEventsMessage::Shared::createWithoutRef(libObjPtr);
+        return DiscardedEventsMessage::Shared::createWithoutRef(libObjPtr);
     }
 
-    bt2::DiscardedEventsMessage::Shared
-    createDiscardedEventsMessage(const bt2::ConstStream stream,
+    DiscardedEventsMessage::Shared
+    createDiscardedEventsMessage(const ConstStream stream,
                                  const std::uint64_t beginningClockSnapshotValue,
                                  const std::uint64_t endClockSnapshotValue) const
     {
@@ -227,11 +224,10 @@ public:
             throw MemoryError {};
         }
 
-        return bt2::DiscardedEventsMessage::Shared::createWithoutRef(libObjPtr);
+        return DiscardedEventsMessage::Shared::createWithoutRef(libObjPtr);
     }
 
-    bt2::DiscardedPacketsMessage::Shared
-    createDiscardedPacketsMessage(const bt2::ConstStream stream) const
+    DiscardedPacketsMessage::Shared createDiscardedPacketsMessage(const ConstStream stream) const
     {
         const auto libObjPtr =
             bt_message_discarded_packets_create(this->libObjPtr(), stream.libObjPtr());
@@ -240,11 +236,11 @@ public:
             throw MemoryError {};
         }
 
-        return bt2::DiscardedPacketsMessage::Shared::createWithoutRef(libObjPtr);
+        return DiscardedPacketsMessage::Shared::createWithoutRef(libObjPtr);
     }
 
-    bt2::DiscardedPacketsMessage::Shared
-    createDiscardedPacketsMessage(const bt2::ConstStream stream,
+    DiscardedPacketsMessage::Shared
+    createDiscardedPacketsMessage(const ConstStream stream,
                                   const std::uint64_t beginningClockSnapshotValue,
                                   const std::uint64_t endClockSnapshotValue) const
     {
@@ -256,11 +252,11 @@ public:
             throw MemoryError {};
         }
 
-        return bt2::DiscardedPacketsMessage::Shared::createWithoutRef(libObjPtr);
+        return DiscardedPacketsMessage::Shared::createWithoutRef(libObjPtr);
     }
 
-    bt2::MessageIteratorInactivityMessage::Shared
-    createMessageIteratorInactivityMessage(const bt2::ConstClockClass clockClass,
+    MessageIteratorInactivityMessage::Shared
+    createMessageIteratorInactivityMessage(const ConstClockClass clockClass,
                                            const std::uint64_t clockSnapshotValue) const
     {
         const auto libObjPtr = bt_message_message_iterator_inactivity_create(
@@ -270,7 +266,7 @@ public:
             throw MemoryError {};
         }
 
-        return bt2::MessageIteratorInactivityMessage::Shared::createWithoutRef(libObjPtr);
+        return MessageIteratorInactivityMessage::Shared::createWithoutRef(libObjPtr);
     }
 };