#include "common/assert.h"
#include "cpp-common/bt2/clock-snapshot.hpp"
#include "cpp-common/bt2/trace-ir.hpp"
-#include "cpp-common/optional.hpp"
+#include "cpp-common/bt2s/optional.hpp"
#include "borrowed-object.hpp"
#include "internal/utils.hpp"
-#include "shared-obj.hpp"
+#include "shared-object.hpp"
namespace bt2 {
namespace internal {
struct MessageRefFuncs final
{
- static void get(const bt_message * const libObjPtr)
+ static void get(const bt_message * const libObjPtr) noexcept
{
bt_message_get_ref(libObjPtr);
}
- static void put(const bt_message * const libObjPtr)
+ static void put(const bt_message * const libObjPtr) noexcept
{
bt_message_put_ref(libObjPtr);
}
} /* namespace internal */
template <typename ObjT, typename LibObjT>
-using SharedMessage = SharedObj<ObjT, LibObjT, internal::MessageRefFuncs>;
+using SharedMessage = SharedObject<ObjT, LibObjT, internal::MessageRefFuncs>;
template <typename LibObjT>
class CommonStreamBeginningMessage;
}
template <typename OtherLibObjT>
- _ThisCommonMessage& operator=(const CommonMessage<OtherLibObjT> val) noexcept
+ _ThisCommonMessage operator=(const CommonMessage<OtherLibObjT> val) noexcept
{
_ThisBorrowedObject::operator=(val);
return *this;
}
+ CommonMessage<const bt_message> asConst() const noexcept
+ {
+ return CommonMessage<const bt_message> {*this};
+ }
+
MessageType type() const noexcept
{
return static_cast<MessageType>(bt_message_get_type(this->libObjPtr()));
private:
using typename CommonMessage<LibObjT>::_LibObjPtr;
using typename CommonMessage<LibObjT>::_ThisCommonMessage;
-
- using _Stream =
- typename std::conditional<std::is_const<LibObjT>::value, CommonStream<const bt_stream>,
- CommonStream<bt_stream>>::type;
+ using _Stream = internal::DepStream<LibObjT>;
public:
using Shared = SharedMessage<CommonStreamBeginningMessage<LibObjT>, LibObjT>;
}
template <typename OtherLibObjT>
- CommonStreamBeginningMessage<LibObjT>&
+ CommonStreamBeginningMessage<LibObjT>
operator=(const CommonStreamBeginningMessage<OtherLibObjT> val) noexcept
{
_ThisCommonMessage::operator=(val);
return *this;
}
- ConstStream stream() const noexcept
+ CommonStreamBeginningMessage<const bt_message> asConst() const noexcept
{
- return ConstStream {internal::CommonStreamBeginningMessageSpec<const bt_message>::stream(
- this->libObjPtr())};
+ return CommonStreamBeginningMessage<const bt_message> {*this};
}
- _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`.");
+ static_assert(!std::is_const<LibObjT>::value,
+ "Not available with `bt2::ConstStreamBeginningMessage`.");
bt_message_stream_beginning_set_default_clock_snapshot(this->libObjPtr(), val);
}
- nonstd::optional<ConstClockSnapshot> defaultClockSnapshot() const noexcept
+ bt2s::optional<ConstClockSnapshot> defaultClockSnapshot() const noexcept
{
const bt_clock_snapshot *libObjPtr;
const auto state = bt_message_stream_beginning_borrow_default_clock_snapshot_const(
return ConstClockSnapshot {libObjPtr};
}
- return nonstd::nullopt;
+ return bt2s::nullopt;
}
Shared shared() const noexcept
private:
using typename CommonMessage<LibObjT>::_LibObjPtr;
using typename CommonMessage<LibObjT>::_ThisCommonMessage;
-
- using _Stream =
- typename std::conditional<std::is_const<LibObjT>::value, CommonStream<const bt_stream>,
- CommonStream<bt_stream>>::type;
+ using _Stream = internal::DepStream<LibObjT>;
public:
using Shared = SharedMessage<CommonStreamEndMessage<LibObjT>, LibObjT>;
}
template <typename OtherLibObjT>
- CommonStreamEndMessage<LibObjT>&
+ CommonStreamEndMessage<LibObjT>
operator=(const CommonStreamEndMessage<OtherLibObjT> val) noexcept
{
_ThisCommonMessage::operator=(val);
return *this;
}
- ConstStream stream() const noexcept
+ CommonStreamEndMessage<const bt_message> asConst() const noexcept
{
- return ConstStream {
- internal::CommonStreamEndMessageSpec<const bt_message>::stream(this->libObjPtr())};
+ return CommonStreamEndMessage<const bt_message> {*this};
}
- _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`.");
+ static_assert(!std::is_const<LibObjT>::value,
+ "Not available with `bt2::ConstStreamEndMessage`.");
bt_message_stream_end_set_default_clock_snapshot(this->libObjPtr(), val);
}
- nonstd::optional<ConstClockSnapshot> defaultClockSnapshot() const noexcept
+ bt2s::optional<ConstClockSnapshot> defaultClockSnapshot() const noexcept
{
const bt_clock_snapshot *libObjPtr;
const auto state = bt_message_stream_end_borrow_default_clock_snapshot_const(
return ConstClockSnapshot {libObjPtr};
}
- return nonstd::nullopt;
+ return bt2s::nullopt;
}
Shared shared() const noexcept
private:
using typename CommonMessage<LibObjT>::_LibObjPtr;
using typename CommonMessage<LibObjT>::_ThisCommonMessage;
-
- using _Packet =
- typename std::conditional<std::is_const<LibObjT>::value, CommonPacket<const bt_packet>,
- CommonPacket<bt_packet>>::type;
+ using _Packet = internal::DepPacket<LibObjT>;
public:
using Shared = SharedMessage<CommonPacketBeginningMessage<LibObjT>, LibObjT>;
}
template <typename OtherLibObjT>
- CommonPacketBeginningMessage<LibObjT>&
+ CommonPacketBeginningMessage<LibObjT>
operator=(const CommonPacketBeginningMessage<OtherLibObjT> val) noexcept
{
_ThisCommonMessage::operator=(val);
return *this;
}
- ConstPacket packet() const noexcept
+ CommonPacketBeginningMessage<const bt_message> asConst() const noexcept
{
- return ConstPacket {internal::CommonPacketBeginningMessageSpec<const bt_message>::packet(
- this->libObjPtr())};
+ return CommonPacketBeginningMessage<const bt_message> {*this};
}
- _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`.");
+ static_assert(!std::is_const<LibObjT>::value,
+ "Not available with `bt2::ConstPacketBeginningMessage`.");
bt_message_packet_beginning_set_default_clock_snapshot(this->libObjPtr(), val);
}
private:
using typename CommonMessage<LibObjT>::_LibObjPtr;
using typename CommonMessage<LibObjT>::_ThisCommonMessage;
-
- using _Packet =
- typename std::conditional<std::is_const<LibObjT>::value, CommonPacket<const bt_packet>,
- CommonPacket<bt_packet>>::type;
+ using _Packet = internal::DepPacket<LibObjT>;
public:
using Shared = SharedMessage<CommonPacketEndMessage<LibObjT>, LibObjT>;
}
template <typename OtherLibObjT>
- CommonPacketEndMessage<LibObjT>&
+ CommonPacketEndMessage<LibObjT>
operator=(const CommonPacketEndMessage<OtherLibObjT> val) noexcept
{
_ThisCommonMessage::operator=(val);
return *this;
}
- ConstPacket packet() const noexcept
+ CommonPacketEndMessage<const bt_message> asConst() const noexcept
{
- return ConstPacket {
- internal::CommonPacketEndMessageSpec<const bt_message>::packet(this->libObjPtr())};
+ return CommonPacketEndMessage<const bt_message> {*this};
}
- _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`.");
+ static_assert(!std::is_const<LibObjT>::value,
+ "Not available with `bt2::ConstPacketEndMessage`.");
bt_message_packet_end_set_default_clock_snapshot(this->libObjPtr(), val);
}
private:
using typename CommonMessage<LibObjT>::_LibObjPtr;
using typename CommonMessage<LibObjT>::_ThisCommonMessage;
-
- using _Event =
- typename std::conditional<std::is_const<LibObjT>::value, CommonEvent<const bt_event>,
- CommonEvent<bt_event>>::type;
+ using _Event = internal::DepType<LibObjT, CommonEvent<bt_event>, CommonEvent<const bt_event>>;
public:
using Shared = SharedMessage<CommonEventMessage<LibObjT>, LibObjT>;
}
template <typename OtherLibObjT>
- CommonEventMessage<LibObjT>& operator=(const CommonEventMessage<OtherLibObjT> val) noexcept
+ CommonEventMessage<LibObjT> operator=(const CommonEventMessage<OtherLibObjT> val) noexcept
{
_ThisCommonMessage::operator=(val);
return *this;
}
- ConstEvent event() const noexcept
+ CommonEventMessage<const bt_message> asConst() const noexcept
{
- return ConstEvent {
- internal::CommonEventMessageSpec<const bt_message>::event(this->libObjPtr())};
+ return CommonEventMessage<const bt_message> {*this};
}
- _Event event() noexcept
+ _Event event() const noexcept
{
return _Event {internal::CommonEventMessageSpec<LibObjT>::event(this->libObjPtr())};
}
private:
using typename CommonMessage<LibObjT>::_LibObjPtr;
using typename CommonMessage<LibObjT>::_ThisCommonMessage;
-
- using _Stream =
- typename std::conditional<std::is_const<LibObjT>::value, CommonStream<const bt_stream>,
- CommonStream<bt_stream>>::type;
+ using _Stream = internal::DepStream<LibObjT>;
public:
using Shared = SharedMessage<CommonDiscardedEventsMessage<LibObjT>, LibObjT>;
}
template <typename OtherLibObjT>
- CommonDiscardedEventsMessage<LibObjT>&
+ CommonDiscardedEventsMessage<LibObjT>
operator=(const CommonDiscardedEventsMessage<OtherLibObjT> val) noexcept
{
_ThisCommonMessage::operator=(val);
return *this;
}
- ConstStream stream() const noexcept
+ CommonDiscardedEventsMessage<const bt_message> asConst() const noexcept
{
- return ConstStream {internal::CommonDiscardedEventsMessageSpec<const bt_message>::stream(
- this->libObjPtr())};
+ return CommonDiscardedEventsMessage<const bt_message> {*this};
}
- _Stream stream() noexcept
+ _Stream stream() const noexcept
{
return _Stream {
internal::CommonDiscardedEventsMessageSpec<LibObjT>::stream(this->libObjPtr())};
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`.");
+ static_assert(!std::is_const<LibObjT>::value,
+ "Not available with `bt2::ConstDiscardedEventsMessage`.");
bt_message_discarded_events_set_count(this->libObjPtr(), count);
}
- nonstd::optional<std::uint64_t> count() const noexcept
+ bt2s::optional<std::uint64_t> count() const noexcept
{
std::uint64_t count;
const auto avail = bt_message_discarded_events_get_count(this->libObjPtr(), &count);
return count;
}
- return nonstd::nullopt;
+ return bt2s::nullopt;
}
Shared shared() const noexcept
private:
using typename CommonMessage<LibObjT>::_LibObjPtr;
using typename CommonMessage<LibObjT>::_ThisCommonMessage;
-
- using _Stream =
- typename std::conditional<std::is_const<LibObjT>::value, CommonStream<const bt_stream>,
- CommonStream<bt_stream>>::type;
+ using _Stream = internal::DepStream<LibObjT>;
public:
using Shared = SharedMessage<CommonDiscardedPacketsMessage<LibObjT>, LibObjT>;
}
template <typename OtherLibObjT>
- CommonDiscardedPacketsMessage<LibObjT>&
+ CommonDiscardedPacketsMessage<LibObjT>
operator=(const CommonDiscardedPacketsMessage<OtherLibObjT> val) noexcept
{
_ThisCommonMessage::operator=(val);
return *this;
}
- ConstStream stream() const noexcept
+ CommonDiscardedPacketsMessage<const bt_message> asConst() const noexcept
{
- return ConstStream {internal::CommonDiscardedPacketsMessageSpec<const bt_message>::stream(
- this->libObjPtr())};
+ return CommonDiscardedPacketsMessage<const bt_message> {*this};
}
- _Stream stream() noexcept
+ _Stream stream() const noexcept
{
return _Stream {
internal::CommonDiscardedPacketsMessageSpec<LibObjT>::stream(this->libObjPtr())};
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`.");
+ static_assert(!std::is_const<LibObjT>::value,
+ "Not available with `bt2::ConstDiscardedPacketsMessage`.");
bt_message_discarded_packets_set_count(this->libObjPtr(), count);
}
- nonstd::optional<std::uint64_t> count() const noexcept
+ bt2s::optional<std::uint64_t> count() const noexcept
{
std::uint64_t count;
const auto avail = bt_message_discarded_packets_get_count(this->libObjPtr(), &count);
return count;
}
- return nonstd::nullopt;
+ return bt2s::nullopt;
}
Shared shared() const noexcept
}
template <typename OtherLibObjT>
- CommonMessageIteratorInactivityMessage<LibObjT>&
+ CommonMessageIteratorInactivityMessage<LibObjT>
operator=(const CommonMessageIteratorInactivityMessage<OtherLibObjT> val) noexcept
{
_ThisCommonMessage::operator=(val);
return *this;
}
+ CommonMessageIteratorInactivityMessage<const bt_message> asConst() const noexcept
+ {
+ return CommonMessageIteratorInactivityMessage<const bt_message> {*this};
+ }
+
ConstClockSnapshot clockSnapshot() const noexcept
{
const auto libObjPtr =