* Use camel case with an uppercase first letter for:
** Types: `Pistachio`, `NutManager`.
** Template parameters: `PlanetT`, `TotalSize`.
+** Enumerators: `Type::SignedInt`, `Scope::Function`.
* Use snake case with uppercase letters for:
** Definition/macro names: `MARK_AS_UNUSED()`, `SOME_FEATURE_EXISTS`.
-** Enumerators: `Type::SIGNED_INT`, `Scope::FUNCTION`.
* Use only lowercase letters and digits for namespaces: `mylib`, `bt2`.
enum class Gender
{
- MALE,
- FEMALE,
- OTHER,
+ Male,
+ Female,
+ Other,
};
explicit Baby() = default;
bt2::OptionalBorrowedObject<bt2::ConstStreamClass> streamCls;
switch (msg.type()) {
- case bt2::MessageType::STREAM_BEGINNING:
+ case bt2::MessageType::StreamBeginning:
streamCls = msg.asStreamBeginning().stream().cls();
clockCls = streamCls->defaultClockClass();
break;
- case bt2::MessageType::MESSAGE_ITERATOR_INACTIVITY:
+ case bt2::MessageType::MessageIteratorInactivity:
clockCls = msg.asMessageIteratorInactivity().clockSnapshot().clockClass();
break;
}
switch (_mExpectation) {
- case PropsExpectation::UNSET:
+ case PropsExpectation::Unset:
/*
* This is the first analysis of a message with a clock
* snapshot: record the properties of that clock, against which
* we'll compare the clock properties of the following messages.
*/
if (!clockCls) {
- _mExpectation = PropsExpectation::NONE;
+ _mExpectation = PropsExpectation::None;
} else if (clockCls->originIsUnixEpoch()) {
- _mExpectation = PropsExpectation::ORIGIN_UNIX;
+ _mExpectation = PropsExpectation::OriginUnix;
} else if (const auto uuid = clockCls->uuid()) {
- _mExpectation = PropsExpectation::ORIGIN_OTHER_UUID;
+ _mExpectation = PropsExpectation::OriginOtherUuid;
_mUuid = *uuid;
} else {
- _mExpectation = PropsExpectation::ORIGIN_OTHER_NO_UUID;
+ _mExpectation = PropsExpectation::OriginOtherNoUuid;
_mClockClass = clockCls->shared();
}
break;
- case PropsExpectation::NONE:
+ case PropsExpectation::None:
if (clockCls) {
- throw ClockCorrelationError {
- ClockCorrelationError::Type::EXPECTING_NO_CLOCK_CLASS_GOT_ONE,
- bt2s::nullopt,
- *clockCls,
- {},
- streamCls};
+ throw ClockCorrelationError {ClockCorrelationError::Type::ExpectingNoClockClassGotOne,
+ bt2s::nullopt,
+ *clockCls,
+ {},
+ streamCls};
}
break;
- case PropsExpectation::ORIGIN_UNIX:
+ case PropsExpectation::OriginUnix:
if (!clockCls) {
- throw ClockCorrelationError {
- ClockCorrelationError::Type::EXPECTING_ORIGIN_UNIX_GOT_NONE,
- bt2s::nullopt,
- {},
- {},
- streamCls};
+ throw ClockCorrelationError {ClockCorrelationError::Type::ExpectingOriginUnixGotNone,
+ bt2s::nullopt,
+ {},
+ {},
+ streamCls};
}
if (!clockCls->originIsUnixEpoch()) {
- throw ClockCorrelationError {
- ClockCorrelationError::Type::EXPECTING_ORIGIN_UNIX_GOT_OTHER,
- bt2s::nullopt,
- *clockCls,
- {},
- streamCls};
+ throw ClockCorrelationError {ClockCorrelationError::Type::ExpectingOriginUnixGotOther,
+ bt2s::nullopt,
+ *clockCls,
+ {},
+ streamCls};
}
break;
- case PropsExpectation::ORIGIN_OTHER_UUID:
+ case PropsExpectation::OriginOtherUuid:
{
if (!clockCls) {
- throw ClockCorrelationError {
- ClockCorrelationError::Type::EXPECTING_ORIGIN_UUID_GOT_NONE,
- bt2s::nullopt,
- {},
- {},
- streamCls};
+ throw ClockCorrelationError {ClockCorrelationError::Type::ExpectingOriginUuidGotNone,
+ bt2s::nullopt,
+ {},
+ {},
+ streamCls};
}
if (clockCls->originIsUnixEpoch()) {
- throw ClockCorrelationError {
- ClockCorrelationError::Type::EXPECTING_ORIGIN_UUID_GOT_UNIX,
- bt2s::nullopt,
- *clockCls,
- {},
- streamCls};
+ throw ClockCorrelationError {ClockCorrelationError::Type::ExpectingOriginUuidGotUnix,
+ bt2s::nullopt,
+ *clockCls,
+ {},
+ streamCls};
}
const auto uuid = clockCls->uuid();
if (!uuid) {
- throw ClockCorrelationError {
- ClockCorrelationError::Type::EXPECTING_ORIGIN_UUID_GOT_NO_UUID,
- bt2s::nullopt,
- *clockCls,
- {},
- streamCls};
+ throw ClockCorrelationError {ClockCorrelationError::Type::ExpectingOriginUuidGotNoUuid,
+ bt2s::nullopt,
+ *clockCls,
+ {},
+ streamCls};
}
if (*uuid != _mUuid) {
throw ClockCorrelationError {
- ClockCorrelationError::Type::EXPECTING_ORIGIN_UUID_GOT_OTHER_UUID,
+ ClockCorrelationError::Type::ExpectingOriginUuidGotOtherUuid,
_mUuid,
*clockCls,
{},
break;
}
- case PropsExpectation::ORIGIN_OTHER_NO_UUID:
+ case PropsExpectation::OriginOtherNoUuid:
if (!clockCls) {
- throw ClockCorrelationError {
- ClockCorrelationError::Type::EXPECTING_ORIGIN_NO_UUID_GOT_NONE,
- bt2s::nullopt,
- {},
- {},
- streamCls};
+ throw ClockCorrelationError {ClockCorrelationError::Type::ExpectingOriginNoUuidGotNone,
+ bt2s::nullopt,
+ {},
+ {},
+ streamCls};
}
if (clockCls->libObjPtr() != _mClockClass->libObjPtr()) {
- throw ClockCorrelationError {
- ClockCorrelationError::Type::EXPECTING_ORIGIN_NO_UUID_GOT_OTHER, bt2s::nullopt,
- *clockCls, *_mClockClass, streamCls};
+ throw ClockCorrelationError {ClockCorrelationError::Type::ExpectingOriginNoUuidGotOther,
+ bt2s::nullopt, *clockCls, *_mClockClass, streamCls};
}
break;
public:
enum class Type
{
- EXPECTING_NO_CLOCK_CLASS_GOT_ONE =
+ ExpectingNoClockClassGotOne =
BT_CLOCK_CORRELATION_VALIDATOR_ERROR_TYPE_EXPECTING_NO_CLOCK_CLASS_GOT_ONE,
- EXPECTING_ORIGIN_UNIX_GOT_NONE =
+ ExpectingOriginUnixGotNone =
BT_CLOCK_CORRELATION_VALIDATOR_ERROR_TYPE_EXPECTING_ORIGIN_UNIX_GOT_NONE,
- EXPECTING_ORIGIN_UNIX_GOT_OTHER =
+ ExpectingOriginUnixGotOther =
BT_CLOCK_CORRELATION_VALIDATOR_ERROR_TYPE_EXPECTING_ORIGIN_UNIX_GOT_OTHER,
- EXPECTING_ORIGIN_UUID_GOT_NONE =
+ ExpectingOriginUuidGotNone =
BT_CLOCK_CORRELATION_VALIDATOR_ERROR_TYPE_EXPECTING_ORIGIN_UUID_GOT_NONE,
- EXPECTING_ORIGIN_UUID_GOT_UNIX =
+ ExpectingOriginUuidGotUnix =
BT_CLOCK_CORRELATION_VALIDATOR_ERROR_TYPE_EXPECTING_ORIGIN_UUID_GOT_UNIX,
- EXPECTING_ORIGIN_UUID_GOT_NO_UUID =
+ ExpectingOriginUuidGotNoUuid =
BT_CLOCK_CORRELATION_VALIDATOR_ERROR_TYPE_EXPECTING_ORIGIN_UUID_GOT_NO_UUID,
- EXPECTING_ORIGIN_UUID_GOT_OTHER_UUID =
+ ExpectingOriginUuidGotOtherUuid =
BT_CLOCK_CORRELATION_VALIDATOR_ERROR_TYPE_EXPECTING_ORIGIN_UUID_GOT_OTHER_UUID,
- EXPECTING_ORIGIN_NO_UUID_GOT_NONE =
+ ExpectingOriginNoUuidGotNone =
BT_CLOCK_CORRELATION_VALIDATOR_ERROR_TYPE_EXPECTING_ORIGIN_NO_UUID_GOT_NONE,
- EXPECTING_ORIGIN_NO_UUID_GOT_OTHER =
+ ExpectingOriginNoUuidGotOther =
BT_CLOCK_CORRELATION_VALIDATOR_ERROR_TYPE_EXPECTING_ORIGIN_NO_UUID_GOT_OTHER,
};
enum class PropsExpectation
{
/* We haven't recorded clock properties yet. */
- UNSET,
+ Unset,
/* Expect to have no clock. */
- NONE,
+ None,
/* Expect a clock with a Unix epoch origin. */
- ORIGIN_UNIX,
+ OriginUnix,
/* Expect a clock without a Unix epoch origin, but with a UUID. */
- ORIGIN_OTHER_UUID,
+ OriginOtherUuid,
/* Expect a clock without a Unix epoch origin and without a UUID. */
- ORIGIN_OTHER_NO_UUID,
+ OriginOtherNoUuid,
};
public:
private:
void _validate(const bt2::ConstMessage msg);
- PropsExpectation _mExpectation = PropsExpectation::UNSET;
+ PropsExpectation _mExpectation = PropsExpectation::Unset;
/*
* Expected UUID of the clock, if `_mExpectation` is
((void) sizeof((void) (_expr1), (void) (_expr2), \
(void) (_expr3), (void) (_expr4), (void) (_expr5), 0))
+#define BT_DIAG_PUSH _Pragma ("GCC diagnostic push")
+#define BT_DIAG_POP _Pragma ("GCC diagnostic push")
+
+#define BT_DIAG_IGNORE_SHADOW _Pragma("GCC diagnostic ignored \"-Wshadow\"")
+
#if defined __clang__
# if __has_warning("-Wunused-but-set-variable")
# define BT_DIAG_IGNORE_UNUSED_BUT_SET_VARIABLE \
/* Type of `_mExcToThrowType` */
enum class _ExcToThrowType
{
- NONE,
- ERROR,
- MEM_ERROR,
+ None,
+ Error,
+ MemError,
};
protected:
void next(ConstMessageArray& messages)
{
/* Any saved error? Now is the time to throw */
- if (G_UNLIKELY(_mExcToThrowType != _ExcToThrowType::NONE)) {
+ if (G_UNLIKELY(_mExcToThrowType != _ExcToThrowType::None)) {
/* Move `_mSavedLibError`, if any, as current thread error */
if (_mSavedLibError) {
bt_current_thread_move_error(_mSavedLibError.release());
}
/* Throw the corresponding exception */
- if (_mExcToThrowType == _ExcToThrowType::ERROR) {
+ if (_mExcToThrowType == _ExcToThrowType::Error) {
throw Error {};
} else {
- BT_ASSERT(_mExcToThrowType == _ExcToThrowType::MEM_ERROR);
+ BT_ASSERT(_mExcToThrowType == _ExcToThrowType::MemError);
throw MemoryError {};
}
}
* if any, so that we can restore it later (see the beginning of
* this method).
*/
- BT_ASSERT_DBG(_mExcToThrowType == _ExcToThrowType::NONE);
+ BT_ASSERT_DBG(_mExcToThrowType == _ExcToThrowType::None);
try {
this->_userObj()._next(messages);
throw;
}
- _mExcToThrowType = _ExcToThrowType::MEM_ERROR;
+ _mExcToThrowType = _ExcToThrowType::MemError;
} catch (const Error&) {
if (messages.isEmpty()) {
throw;
}
- _mExcToThrowType = _ExcToThrowType::ERROR;
+ _mExcToThrowType = _ExcToThrowType::Error;
}
- if (_mExcToThrowType != _ExcToThrowType::NONE) {
+ if (_mExcToThrowType != _ExcToThrowType::None) {
BT_CPPLOGE(
"An error occurred, but there are {} messages to return: delaying the error reporting.",
messages.length());
void _resetError() noexcept
{
- _mExcToThrowType = _ExcToThrowType::NONE;
+ _mExcToThrowType = _ExcToThrowType::None;
_mSavedLibError.reset();
}
*
* It also saves the type of the exception to throw the next time.
*/
- _ExcToThrowType _mExcToThrowType = _ExcToThrowType::NONE;
+ _ExcToThrowType _mExcToThrowType = _ExcToThrowType::None;
struct LibErrorDeleter final
{
enum class Type
{
- SOURCE = BT_COMPONENT_CLASS_TYPE_SOURCE,
- FILTER = BT_COMPONENT_CLASS_TYPE_FILTER,
- SINK = BT_COMPONENT_CLASS_TYPE_SINK,
+ Source = BT_COMPONENT_CLASS_TYPE_SOURCE,
+ Filter = BT_COMPONENT_CLASS_TYPE_FILTER,
+ Sink = BT_COMPONENT_CLASS_TYPE_SINK,
};
explicit CommonComponentClass(const LibObjPtr libObjPtr) noexcept :
public:
enum class ActorType
{
- UNKNOWN = BT_ERROR_CAUSE_ACTOR_TYPE_UNKNOWN,
- COMPONENT = BT_ERROR_CAUSE_ACTOR_TYPE_COMPONENT,
- COMPONENT_CLASS = BT_ERROR_CAUSE_ACTOR_TYPE_COMPONENT_CLASS,
- MESSAGE_ITERATOR = BT_ERROR_CAUSE_ACTOR_TYPE_MESSAGE_ITERATOR,
+ Unknown = BT_ERROR_CAUSE_ACTOR_TYPE_UNKNOWN,
+ Component = BT_ERROR_CAUSE_ACTOR_TYPE_COMPONENT,
+ ComponentClass = BT_ERROR_CAUSE_ACTOR_TYPE_COMPONENT_CLASS,
+ MessageIterator = BT_ERROR_CAUSE_ACTOR_TYPE_MESSAGE_ITERATOR,
};
explicit ConstErrorCause(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
bool actorTypeIsComponentClass() const noexcept
{
- return this->actorType() == ActorType::COMPONENT_CLASS;
+ return this->actorType() == ActorType::ComponentClass;
}
bool actorTypeIsComponent() const noexcept
{
- return this->actorType() == ActorType::COMPONENT;
+ return this->actorType() == ActorType::Component;
}
bool actorTypeIsMessageIterator() const noexcept
{
- return this->actorType() == ActorType::MESSAGE_ITERATOR;
+ return this->actorType() == ActorType::MessageIterator;
}
ConstComponentClassErrorCause asComponentClass() const noexcept;
enum class FieldClassType
{
- BOOL = BT_FIELD_CLASS_TYPE_BOOL,
- BIT_ARRAY = BT_FIELD_CLASS_TYPE_BIT_ARRAY,
- UNSIGNED_INTEGER = BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER,
- SIGNED_INTEGER = BT_FIELD_CLASS_TYPE_SIGNED_INTEGER,
- UNSIGNED_ENUMERATION = BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION,
- SIGNED_ENUMERATION = BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION,
- SINGLE_PRECISION_REAL = BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL,
- DOUBLE_PRECISION_REAL = BT_FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL,
- STRING = BT_FIELD_CLASS_TYPE_STRING,
- STRUCTURE = BT_FIELD_CLASS_TYPE_STRUCTURE,
- STATIC_ARRAY = BT_FIELD_CLASS_TYPE_STATIC_ARRAY,
- DYNAMIC_ARRAY_WITHOUT_LENGTH = BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD,
- DYNAMIC_ARRAY_WITH_LENGTH = BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD,
- OPTION_WITHOUT_SELECTOR = BT_FIELD_CLASS_TYPE_OPTION_WITHOUT_SELECTOR_FIELD,
- OPTION_WITH_BOOL_SELECTOR = BT_FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR_FIELD,
- OPTION_WITH_UNSIGNED_INTEGER_SELECTOR =
+ Bool = BT_FIELD_CLASS_TYPE_BOOL,
+ BitArray = BT_FIELD_CLASS_TYPE_BIT_ARRAY,
+ UnsignedInteger = BT_FIELD_CLASS_TYPE_UNSIGNED_INTEGER,
+ SignedInteger = BT_FIELD_CLASS_TYPE_SIGNED_INTEGER,
+ UnsignedEnumeration = BT_FIELD_CLASS_TYPE_UNSIGNED_ENUMERATION,
+ SignedEnumeration = BT_FIELD_CLASS_TYPE_SIGNED_ENUMERATION,
+ SinglePrecisionReal = BT_FIELD_CLASS_TYPE_SINGLE_PRECISION_REAL,
+ DoublePrecisionReal = BT_FIELD_CLASS_TYPE_DOUBLE_PRECISION_REAL,
+ String = BT_FIELD_CLASS_TYPE_STRING,
+ Structure = BT_FIELD_CLASS_TYPE_STRUCTURE,
+ StaticArray = BT_FIELD_CLASS_TYPE_STATIC_ARRAY,
+ DynamicArrayWithoutLength = BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITHOUT_LENGTH_FIELD,
+ DynamicArrayWithLength = BT_FIELD_CLASS_TYPE_DYNAMIC_ARRAY_WITH_LENGTH_FIELD,
+ OptionWithoutSelector = BT_FIELD_CLASS_TYPE_OPTION_WITHOUT_SELECTOR_FIELD,
+ OptionWithBoolSelector = BT_FIELD_CLASS_TYPE_OPTION_WITH_BOOL_SELECTOR_FIELD,
+ OptionWithUnsignedIntegerSelector =
BT_FIELD_CLASS_TYPE_OPTION_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD,
- OPTION_WITH_SIGNED_INTEGER_SELECTOR =
- BT_FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR_FIELD,
- VARIANT_WITHOUT_SELECTOR = BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD,
- VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR =
+ OptionWithSignedIntegerSelector = BT_FIELD_CLASS_TYPE_OPTION_WITH_SIGNED_INTEGER_SELECTOR_FIELD,
+ VariantWithoutSelector = BT_FIELD_CLASS_TYPE_VARIANT_WITHOUT_SELECTOR_FIELD,
+ VariantWithUnsignedIntegerSelector =
BT_FIELD_CLASS_TYPE_VARIANT_WITH_UNSIGNED_INTEGER_SELECTOR_FIELD,
- VARIANT_WITH_SIGNED_INTEGER_SELECTOR =
+ VariantWithSignedIntegerSelector =
BT_FIELD_CLASS_TYPE_VARIANT_WITH_SIGNED_INTEGER_SELECTOR_FIELD,
};
enum class DisplayBase
{
- BINARY = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_BINARY,
- OCTAL = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_OCTAL,
- DECIMAL = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_DECIMAL,
- HEXADECIMAL = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_HEXADECIMAL,
+ Binary = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_BINARY,
+ Octal = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_OCTAL,
+ Decimal = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_DECIMAL,
+ Hexadecimal = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_HEXADECIMAL,
};
template <typename LibObjT>
enum class FieldPathItemType
{
- INDEX = BT_FIELD_PATH_ITEM_TYPE_INDEX,
- CURRENT_ARRAY_ELEMENT = BT_FIELD_PATH_ITEM_TYPE_CURRENT_ARRAY_ELEMENT,
- CURRENT_OPTION_CONTENT = BT_FIELD_PATH_ITEM_TYPE_CURRENT_OPTION_CONTENT,
+ Index = BT_FIELD_PATH_ITEM_TYPE_INDEX,
+ CurrentArrayElement = BT_FIELD_PATH_ITEM_TYPE_CURRENT_ARRAY_ELEMENT,
+ CurrentOptionContent = BT_FIELD_PATH_ITEM_TYPE_CURRENT_OPTION_CONTENT,
};
class ConstFieldPathItem : public BorrowedObject<const bt_field_path_item>
enum class Scope
{
- PACKET_CONTEXT = BT_FIELD_PATH_SCOPE_PACKET_CONTEXT,
- EVENT_COMMON_CONTEXT = BT_FIELD_PATH_SCOPE_EVENT_COMMON_CONTEXT,
- EVENT_SPECIFIC_CONTEXT = BT_FIELD_PATH_SCOPE_EVENT_SPECIFIC_CONTEXT,
- EVENT_PAYLOAD = BT_FIELD_PATH_SCOPE_EVENT_PAYLOAD,
+ PacketContext = BT_FIELD_PATH_SCOPE_PACKET_CONTEXT,
+ EventCommonContext = BT_FIELD_PATH_SCOPE_EVENT_COMMON_CONTEXT,
+ EventSpecificContext = BT_FIELD_PATH_SCOPE_EVENT_SPECIFIC_CONTEXT,
+ EventPayload = BT_FIELD_PATH_SCOPE_EVENT_PAYLOAD,
};
explicit ConstFieldPath(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
ConstSourceComponent addComponent(const ConstSourceComponentClass componentClass,
const bt2c::CStringView name,
const OptionalBorrowedObject<ConstMapValue> params = {},
- const LoggingLevel loggingLevel = LoggingLevel::NONE) const
+ const LoggingLevel loggingLevel = LoggingLevel::None) const
{
return this->_addComponent<ConstSourceComponent>(
componentClass, name, params, static_cast<void *>(nullptr), loggingLevel,
ConstSourceComponent addComponent(const ConstSourceComponentClass componentClass,
const bt2c::CStringView name, InitDataT&& initData,
const OptionalBorrowedObject<ConstMapValue> params = {},
- const LoggingLevel loggingLevel = LoggingLevel::NONE) const
+ const LoggingLevel loggingLevel = LoggingLevel::None) const
{
return this->_addComponent<ConstSourceComponent>(
componentClass, name, params, &initData, loggingLevel,
ConstFilterComponent addComponent(const ConstFilterComponentClass componentClass,
const bt2c::CStringView name,
const OptionalBorrowedObject<ConstMapValue> params = {},
- const LoggingLevel loggingLevel = LoggingLevel::NONE) const
+ const LoggingLevel loggingLevel = LoggingLevel::None) const
{
return this->_addComponent<ConstFilterComponent>(
componentClass, name, params, static_cast<void *>(nullptr), loggingLevel,
ConstFilterComponent addComponent(const ConstFilterComponentClass componentClass,
const bt2c::CStringView name, InitDataT&& initData,
const OptionalBorrowedObject<ConstMapValue> params = {},
- const LoggingLevel loggingLevel = LoggingLevel::NONE) const
+ const LoggingLevel loggingLevel = LoggingLevel::None) const
{
return this->_addComponent<ConstFilterComponent>(
componentClass, name, params, &initData, loggingLevel,
ConstSinkComponent addComponent(const ConstSinkComponentClass componentClass,
const bt2c::CStringView name,
const OptionalBorrowedObject<ConstMapValue> params = {},
- const LoggingLevel loggingLevel = LoggingLevel::NONE) const
+ const LoggingLevel loggingLevel = LoggingLevel::None) const
{
return this->_addComponent<ConstSinkComponent>(
componentClass, name, params, static_cast<void *>(nullptr), loggingLevel,
ConstSinkComponent addComponent(const ConstSinkComponentClass componentClass,
const bt2c::CStringView name, InitDataT&& initData,
const OptionalBorrowedObject<ConstMapValue> params = {},
- const LoggingLevel loggingLevel = LoggingLevel::NONE) const
+ const LoggingLevel loggingLevel = LoggingLevel::None) const
{
return this->_addComponent<ConstSinkComponent>(
componentClass, name, params, &initData, loggingLevel,
#include <babeltrace2/babeltrace.h>
+#include "common/macros.h"
+
namespace bt2 {
+/* Avoid `-Wshadow` error on GCC, conflicting with `bt2::Error` */
+BT_DIAG_PUSH
+BT_DIAG_IGNORE_SHADOW
+
enum class LoggingLevel
{
- TRACE = BT_LOGGING_LEVEL_TRACE,
- DEBUG = BT_LOGGING_LEVEL_DEBUG,
- INFO = BT_LOGGING_LEVEL_INFO,
- WARNING = BT_LOGGING_LEVEL_WARNING,
- ERROR = BT_LOGGING_LEVEL_ERROR,
- FATAL = BT_LOGGING_LEVEL_FATAL,
- NONE = BT_LOGGING_LEVEL_NONE,
+ Trace = BT_LOGGING_LEVEL_TRACE,
+ Debug = BT_LOGGING_LEVEL_DEBUG,
+ Info = BT_LOGGING_LEVEL_INFO,
+ Warning = BT_LOGGING_LEVEL_WARNING,
+ Error = BT_LOGGING_LEVEL_ERROR,
+ Fatal = BT_LOGGING_LEVEL_FATAL,
+ None = BT_LOGGING_LEVEL_NONE,
};
+BT_DIAG_POP
+
} /* namespace bt2 */
#endif /* BABELTRACE_CPP_COMMON_BT2_LOGGING_HPP */
enum class MessageType
{
- STREAM_BEGINNING = BT_MESSAGE_TYPE_STREAM_BEGINNING,
- STREAM_END = BT_MESSAGE_TYPE_STREAM_END,
- EVENT = BT_MESSAGE_TYPE_EVENT,
- PACKET_BEGINNING = BT_MESSAGE_TYPE_PACKET_BEGINNING,
- PACKET_END = BT_MESSAGE_TYPE_PACKET_END,
- DISCARDED_EVENTS = BT_MESSAGE_TYPE_DISCARDED_EVENTS,
- DISCARDED_PACKETS = BT_MESSAGE_TYPE_DISCARDED_PACKETS,
- MESSAGE_ITERATOR_INACTIVITY = BT_MESSAGE_TYPE_MESSAGE_ITERATOR_INACTIVITY,
+ StreamBeginning = BT_MESSAGE_TYPE_STREAM_BEGINNING,
+ StreamEnd = BT_MESSAGE_TYPE_STREAM_END,
+ Event = BT_MESSAGE_TYPE_EVENT,
+ PacketBeginning = BT_MESSAGE_TYPE_PACKET_BEGINNING,
+ PacketEnd = BT_MESSAGE_TYPE_PACKET_END,
+ DiscardedEvents = BT_MESSAGE_TYPE_DISCARDED_EVENTS,
+ DiscardedPackets = BT_MESSAGE_TYPE_DISCARDED_PACKETS,
+ MessageIteratorInactivity = BT_MESSAGE_TYPE_MESSAGE_ITERATOR_INACTIVITY,
};
template <typename LibObjT>
bool isStreamBeginning() const noexcept
{
- return this->type() == MessageType::STREAM_BEGINNING;
+ return this->type() == MessageType::StreamBeginning;
}
bool isStreamEnd() const noexcept
{
- return this->type() == MessageType::STREAM_END;
+ return this->type() == MessageType::StreamEnd;
}
bool isEvent() const noexcept
{
- return this->type() == MessageType::EVENT;
+ return this->type() == MessageType::Event;
}
bool isPacketBeginning() const noexcept
{
- return this->type() == MessageType::PACKET_BEGINNING;
+ return this->type() == MessageType::PacketBeginning;
}
bool isPacketEnd() const noexcept
{
- return this->type() == MessageType::PACKET_END;
+ return this->type() == MessageType::PacketEnd;
}
bool isDiscardedEvents() const noexcept
{
- return this->type() == MessageType::DISCARDED_EVENTS;
+ return this->type() == MessageType::DiscardedEvents;
}
bool isDiscardedPackets() const noexcept
{
- return this->type() == MessageType::DISCARDED_PACKETS;
+ return this->type() == MessageType::DiscardedPackets;
}
bool isMessageIteratorInactivity() const noexcept
{
- return this->type() == MessageType::MESSAGE_ITERATOR_INACTIVITY;
+ return this->type() == MessageType::MessageIteratorInactivity;
}
Shared shared() const noexcept
#include <babeltrace2/babeltrace.h>
+#include "common/macros.h"
#include "cpp-common/bt2c/c-string-view.hpp"
#include "cpp-common/bt2s/optional.hpp"
using Shared = SharedObject<CommonEventClass, LibObjT, internal::EventClassRefFuncs>;
using UserAttributes = internal::DepUserAttrs<LibObjT>;
+ /* Avoid `-Wshadow` error on GCC, conflicting with `bt2::Error` */
+ BT_DIAG_PUSH
+ BT_DIAG_IGNORE_SHADOW
+
enum class LogLevel
{
- EMERGENCY = BT_EVENT_CLASS_LOG_LEVEL_EMERGENCY,
- ALERT = BT_EVENT_CLASS_LOG_LEVEL_ALERT,
- CRITICAL = BT_EVENT_CLASS_LOG_LEVEL_CRITICAL,
- ERR = BT_EVENT_CLASS_LOG_LEVEL_ERROR,
- WARNING = BT_EVENT_CLASS_LOG_LEVEL_WARNING,
- NOTICE = BT_EVENT_CLASS_LOG_LEVEL_NOTICE,
- INFO = BT_EVENT_CLASS_LOG_LEVEL_INFO,
- DEBUG_SYSTEM = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_SYSTEM,
- DEBUG_PROGRAM = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_PROGRAM,
- DEBUG_PROC = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_PROCESS,
- DEBUG_MODULE = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_MODULE,
- DEBUG_UNIT = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_UNIT,
- DEBUG_FUNCTION = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_FUNCTION,
- DEBUG_LINE = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_LINE,
- DEBUG = BT_EVENT_CLASS_LOG_LEVEL_DEBUG,
+ Emergency = BT_EVENT_CLASS_LOG_LEVEL_EMERGENCY,
+ Alert = BT_EVENT_CLASS_LOG_LEVEL_ALERT,
+ Critical = BT_EVENT_CLASS_LOG_LEVEL_CRITICAL,
+ Error = BT_EVENT_CLASS_LOG_LEVEL_ERROR,
+ Warning = BT_EVENT_CLASS_LOG_LEVEL_WARNING,
+ Notice = BT_EVENT_CLASS_LOG_LEVEL_NOTICE,
+ Info = BT_EVENT_CLASS_LOG_LEVEL_INFO,
+ DebugSystem = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_SYSTEM,
+ DebugProgram = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_PROGRAM,
+ DebugProcess = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_PROCESS,
+ DebugModule = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_MODULE,
+ DebugUnit = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_UNIT,
+ DebugFunction = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_FUNCTION,
+ DebugLine = BT_EVENT_CLASS_LOG_LEVEL_DEBUG_LINE,
+ Debug = BT_EVENT_CLASS_LOG_LEVEL_DEBUG,
};
+ BT_DIAG_POP
+
explicit CommonEventClass(const LibObjPtr libObjPtr) noexcept : _ThisBorrowedObject {libObjPtr}
{
}
enum class ValueType
{
- NUL = BT_VALUE_TYPE_NULL,
- BOOL = BT_VALUE_TYPE_BOOL,
- UNSIGNED_INTEGER = BT_VALUE_TYPE_UNSIGNED_INTEGER,
- SIGNED_INTEGER = BT_VALUE_TYPE_SIGNED_INTEGER,
- REAL = BT_VALUE_TYPE_REAL,
- STRING = BT_VALUE_TYPE_STRING,
- ARRAY = BT_VALUE_TYPE_ARRAY,
- MAP = BT_VALUE_TYPE_MAP,
+ Null = BT_VALUE_TYPE_NULL,
+ Bool = BT_VALUE_TYPE_BOOL,
+ UnsignedInteger = BT_VALUE_TYPE_UNSIGNED_INTEGER,
+ SignedInteger = BT_VALUE_TYPE_SIGNED_INTEGER,
+ Real = BT_VALUE_TYPE_REAL,
+ String = BT_VALUE_TYPE_STRING,
+ Array = BT_VALUE_TYPE_ARRAY,
+ Map = BT_VALUE_TYPE_MAP,
};
template <typename ValueObjT>
/* Available log levels */
enum class Level
{
- TRACE = BT_LOG_TRACE,
- DEBUG = BT_LOG_DEBUG,
- INFO = BT_LOG_INFO,
- WARNING = BT_LOG_WARNING,
- ERROR = BT_LOG_ERROR,
- FATAL = BT_LOG_FATAL,
- NONE = BT_LOG_NONE,
+ Trace = BT_LOG_TRACE,
+ Debug = BT_LOG_DEBUG,
+ Info = BT_LOG_INFO,
+ Warning = BT_LOG_WARNING,
+ Error = BT_LOG_ERROR,
+ Fatal = BT_LOG_FATAL,
+ None = BT_LOG_NONE,
};
/*
*/
bool wouldLogT() const noexcept
{
- return this->wouldLog(Level::TRACE);
+ return this->wouldLog(Level::Trace);
}
/*
*/
bool wouldLogD() const noexcept
{
- return this->wouldLog(Level::DEBUG);
+ return this->wouldLog(Level::Debug);
}
/*
*/
bool wouldLogI() const noexcept
{
- return this->wouldLog(Level::INFO);
+ return this->wouldLog(Level::Info);
}
/*
*/
bool wouldLogW() const noexcept
{
- return this->wouldLog(Level::WARNING);
+ return this->wouldLog(Level::Warning);
}
/*
*/
bool wouldLogE() const noexcept
{
- return this->wouldLog(Level::ERROR);
+ return this->wouldLog(Level::Error);
}
/*
*/
bool wouldLogF() const noexcept
{
- return this->wouldLog(Level::FATAL);
+ return this->wouldLog(Level::Fatal);
}
/*
}
/*
- * Like logAndNoThrow() with the `Level::ERROR` level, but also
+ * Like logAndNoThrow() with the `Level::Error` level, but also
* throws a default-constructed instance of `ExcT`.
*/
template <bool AppendCauseV, typename ExcT, typename... ArgTs>
const unsigned int lineNo, const char * const fmt,
ArgTs&&...args) const
{
- this->logNoThrow<Level::ERROR, AppendCauseV>(fileName, funcName, lineNo, fmt,
+ this->logNoThrow<Level::Error, AppendCauseV>(fileName, funcName, lineNo, fmt,
std::forward<ArgTs>(args)...);
throw ExcT {};
}
/*
- * Like logStrAndNoThrow() with the `Level::ERROR` level, but also
+ * Like logStrAndNoThrow() with the `Level::Error` level, but also
* throws a default-constructed instance of `ExcT`.
*/
template <bool AppendCauseV, typename ExcT>
[[noreturn]] void logErrorStrAndThrow(const char * const fileName, const char * const funcName,
const unsigned int lineNo, const char * const msg) const
{
- this->logStrNoThrow<Level::ERROR, AppendCauseV>(fileName, funcName, lineNo, msg);
+ this->logStrNoThrow<Level::Error, AppendCauseV>(fileName, funcName, lineNo, msg);
throw ExcT {};
}
/*
- * Like logAndNoThrow() with the `Level::ERROR` level, but also
+ * Like logAndNoThrow() with the `Level::Error` level, but also
* rethrows.
*/
template <bool AppendCauseV, typename... ArgTs>
const unsigned int lineNo, const char * const fmt,
ArgTs&&...args) const
{
- this->logNoThrow<Level::ERROR, AppendCauseV>(fileName, funcName, lineNo, fmt,
+ this->logNoThrow<Level::Error, AppendCauseV>(fileName, funcName, lineNo, fmt,
std::forward<ArgTs>(args)...);
throw;
}
/*
- * Like logStrAndNoThrow() with the `Level::ERROR` level, but also
+ * Like logStrAndNoThrow() with the `Level::Error` level, but also
* rethrows.
*/
template <bool AppendCauseV>
const char * const funcName, const unsigned int lineNo,
const char * const msg) const
{
- this->logStrNoThrow<Level::ERROR, AppendCauseV>(fileName, funcName, lineNo, msg);
+ this->logStrNoThrow<Level::Error, AppendCauseV>(fileName, funcName, lineNo, msg);
throw;
}
}
/*
- * Like logErrnoNoThrow() with the `Level::ERROR` level, but also
+ * Like logErrnoNoThrow() with the `Level::Error` level, but also
* throws a default-constructed instance of `ExcT`.
*/
template <bool AppendCauseV, typename ExcT, typename... ArgTs>
const char * const initMsg, const char * const fmt,
ArgTs&&...args) const
{
- this->logErrnoNoThrow<Level::ERROR, AppendCauseV>(fileName, funcName, lineNo, initMsg, fmt,
+ this->logErrnoNoThrow<Level::Error, AppendCauseV>(fileName, funcName, lineNo, initMsg, fmt,
std::forward<ArgTs>(args)...);
throw ExcT {};
}
/*
- * Like logErrnoStrNoThrow() with the `Level::ERROR` level, but also
+ * Like logErrnoStrNoThrow() with the `Level::Error` level, but also
* throws a default-constructed instance of `ExcT`.
*/
template <bool AppendCauseV, typename ExcT>
const unsigned int lineNo, const char * const initMsg,
const char * const msg) const
{
- this->logErrnoStrNoThrow<Level::ERROR, AppendCauseV>(fileName, funcName, lineNo, initMsg,
+ this->logErrnoStrNoThrow<Level::Error, AppendCauseV>(fileName, funcName, lineNo, initMsg,
msg);
throw ExcT {};
}
/*
- * Like logErrnoNoThrow() with the `Level::ERROR` level, but also
+ * Like logErrnoNoThrow() with the `Level::Error` level, but also
* rethrows.
*/
template <bool AppendCauseV, typename... ArgTs>
const unsigned int lineNo, const char * const initMsg,
const char * const fmt, ArgTs&&...args) const
{
- this->logErrnoNoThrow<Level::ERROR, AppendCauseV>(fileName, funcName, lineNo, initMsg, fmt,
+ this->logErrnoNoThrow<Level::Error, AppendCauseV>(fileName, funcName, lineNo, initMsg, fmt,
std::forward<ArgTs>(args)...);
throw;
}
/*
- * Like logErrnoStrNoThrow() with the `Level::ERROR` level, but also
+ * Like logErrnoStrNoThrow() with the `Level::Error` level, but also
* rethrows.
*/
template <bool AppendCauseV>
const unsigned int lineNo, const char * const initMsg,
const char * const msg) const
{
- this->logErrnoStrNoThrow<Level::ERROR, AppendCauseV>(fileName, funcName, lineNo, initMsg,
+ this->logErrnoStrNoThrow<Level::Error, AppendCauseV>(fileName, funcName, lineNo, initMsg,
msg);
throw;
}
* BT_CPPLOG_EX() with specific logging levels.
*/
#define BT_CPPLOGT_SPEC(_logger, _fmt, ...) \
- BT_CPPLOG_EX(bt2c::Logger::Level::TRACE, (_logger), (_fmt), ##__VA_ARGS__)
+ BT_CPPLOG_EX(bt2c::Logger::Level::Trace, (_logger), (_fmt), ##__VA_ARGS__)
#define BT_CPPLOGD_SPEC(_logger, _fmt, ...) \
- BT_CPPLOG_EX(bt2c::Logger::Level::DEBUG, (_logger), (_fmt), ##__VA_ARGS__)
+ BT_CPPLOG_EX(bt2c::Logger::Level::Debug, (_logger), (_fmt), ##__VA_ARGS__)
#define BT_CPPLOGI_SPEC(_logger, _fmt, ...) \
- BT_CPPLOG_EX(bt2c::Logger::Level::INFO, (_logger), (_fmt), ##__VA_ARGS__)
+ BT_CPPLOG_EX(bt2c::Logger::Level::Info, (_logger), (_fmt), ##__VA_ARGS__)
#define BT_CPPLOGW_SPEC(_logger, _fmt, ...) \
- BT_CPPLOG_EX(bt2c::Logger::Level::WARNING, (_logger), (_fmt), ##__VA_ARGS__)
+ BT_CPPLOG_EX(bt2c::Logger::Level::Warning, (_logger), (_fmt), ##__VA_ARGS__)
#define BT_CPPLOGE_SPEC(_logger, _fmt, ...) \
- BT_CPPLOG_EX(bt2c::Logger::Level::ERROR, (_logger), (_fmt), ##__VA_ARGS__)
+ BT_CPPLOG_EX(bt2c::Logger::Level::Error, (_logger), (_fmt), ##__VA_ARGS__)
#define BT_CPPLOGF_SPEC(_logger, _fmt, ...) \
- BT_CPPLOG_EX(bt2c::Logger::Level::FATAL, (_logger), (_fmt), ##__VA_ARGS__)
+ BT_CPPLOG_EX(bt2c::Logger::Level::Fatal, (_logger), (_fmt), ##__VA_ARGS__)
/*
* BT_CPPLOG_EX() with specific logging levels and using the default
* BT_CPPLOG_STR_EX() with specific logging levels.
*/
#define BT_CPPLOGT_STR_SPEC(_logger, _msg) \
- BT_CPPLOG_STR_EX(bt2c::Logger::Level::TRACE, (_logger), (_msg))
+ BT_CPPLOG_STR_EX(bt2c::Logger::Level::Trace, (_logger), (_msg))
#define BT_CPPLOGD_STR_SPEC(_logger, _msg) \
- BT_CPPLOG_STR_EX(bt2c::Logger::Level::DEBUG, (_logger), (_msg))
+ BT_CPPLOG_STR_EX(bt2c::Logger::Level::Debug, (_logger), (_msg))
#define BT_CPPLOGI_STR_SPEC(_logger, _msg) \
- BT_CPPLOG_STR_EX(bt2c::Logger::Level::INFO, (_logger), (_msg))
+ BT_CPPLOG_STR_EX(bt2c::Logger::Level::Info, (_logger), (_msg))
#define BT_CPPLOGW_STR_SPEC(_logger, _msg) \
- BT_CPPLOG_STR_EX(bt2c::Logger::Level::WARNING, (_logger), (_msg))
+ BT_CPPLOG_STR_EX(bt2c::Logger::Level::Warning, (_logger), (_msg))
#define BT_CPPLOGE_STR_SPEC(_logger, _msg) \
- BT_CPPLOG_STR_EX(bt2c::Logger::Level::ERROR, (_logger), (_msg))
+ BT_CPPLOG_STR_EX(bt2c::Logger::Level::Error, (_logger), (_msg))
#define BT_CPPLOGF_STR_SPEC(_logger, _msg) \
- BT_CPPLOG_STR_EX(bt2c::Logger::Level::FATAL, (_logger), (_msg))
+ BT_CPPLOG_STR_EX(bt2c::Logger::Level::Fatal, (_logger), (_msg))
/*
* BT_CPPLOG_STR_EX() with specific logging levels and using the default
* BT_CPPLOG_MEM_EX() with specific logging levels.
*/
#define BT_CPPLOGT_MEM_SPEC(_logger, _mem_data, _mem_len, _fmt, ...) \
- BT_CPPLOG_MEM_EX(bt2c::Logger::Level::TRACE, (_logger), (_mem_data), (_mem_len), (_fmt), \
+ BT_CPPLOG_MEM_EX(bt2c::Logger::Level::Trace, (_logger), (_mem_data), (_mem_len), (_fmt), \
##__VA_ARGS__)
#define BT_CPPLOGD_MEM_SPEC(_logger, _mem_data, _mem_len, _fmt, ...) \
- BT_CPPLOG_MEM_EX(bt2c::Logger::Level::DEBUG, (_logger), (_mem_data), (_mem_len), (_fmt), \
+ BT_CPPLOG_MEM_EX(bt2c::Logger::Level::Debug, (_logger), (_mem_data), (_mem_len), (_fmt), \
##__VA_ARGS__)
#define BT_CPPLOGI_MEM_SPEC(_logger, _mem_data, _mem_len, _fmt, ...) \
- BT_CPPLOG_MEM_EX(bt2c::Logger::Level::INFO, (_logger), (_mem_data), (_mem_len), (_fmt), \
+ BT_CPPLOG_MEM_EX(bt2c::Logger::Level::Info, (_logger), (_mem_data), (_mem_len), (_fmt), \
##__VA_ARGS__)
#define BT_CPPLOGW_MEM_SPEC(_logger, _mem_data, _mem_len, _fmt, ...) \
- BT_CPPLOG_MEM_EX(bt2c::Logger::Level::WARNING, (_logger), (_mem_data), (_mem_len), (_fmt), \
+ BT_CPPLOG_MEM_EX(bt2c::Logger::Level::Warning, (_logger), (_mem_data), (_mem_len), (_fmt), \
##__VA_ARGS__)
#define BT_CPPLOGE_MEM_SPEC(_logger, _mem_data, _mem_len, _fmt, ...) \
- BT_CPPLOG_MEM_EX(bt2c::Logger::Level::ERROR, (_logger), (_mem_data), (_mem_len), (_fmt), \
+ BT_CPPLOG_MEM_EX(bt2c::Logger::Level::Error, (_logger), (_mem_data), (_mem_len), (_fmt), \
##__VA_ARGS__)
#define BT_CPPLOGF_MEM_SPEC(_logger, _mem_data, _mem_len, _fmt, ...) \
- BT_CPPLOG_MEM_EX(bt2c::Logger::Level::FATAL, (_logger), (_mem_data), (_mem_len), (_fmt), \
+ BT_CPPLOG_MEM_EX(bt2c::Logger::Level::Fatal, (_logger), (_mem_data), (_mem_len), (_fmt), \
##__VA_ARGS__)
/*
#define BT_CPPLOGW_MEM_STR_SPEC(_logger, _mem_data, _mem_len, _msg) \
BT_CPPLOG_MEM_STR_EX(bt2c::Logger::Level::WARNING, (_logger), (_mem_data), (_mem_len), (_msg))
#define BT_CPPLOGE_MEM_STR_SPEC(_logger, _mem_data, _mem_len, _msg) \
- BT_CPPLOG_MEM_STR_EX(bt2c::Logger::Level::ERROR, (_logger), (_mem_data), (_mem_len), (_msg))
+ BT_CPPLOG_MEM_STR_EX(bt2c::Logger::Level::Error, (_logger), (_mem_data), (_mem_len), (_msg))
#define BT_CPPLOGF_MEM_STR_SPEC(_logger, _mem_data, _mem_len, _msg) \
BT_CPPLOG_MEM_STR_EX(bt2c::Logger::Level::FATAL, (_logger), (_mem_data), (_mem_len), (_msg))
* BT_CPPLOG_ERRNO_EX() with specific logging levels.
*/
#define BT_CPPLOGT_ERRNO_SPEC(_logger, _init_msg, _fmt, ...) \
- BT_CPPLOG_ERRNO_EX(bt2c::Logger::Level::TRACE, (_logger), (_init_msg), (_fmt), ##__VA_ARGS__)
+ BT_CPPLOG_ERRNO_EX(bt2c::Logger::Level::Trace, (_logger), (_init_msg), (_fmt), ##__VA_ARGS__)
#define BT_CPPLOGD_ERRNO_SPEC(_logger, _init_msg, _fmt, ...) \
- BT_CPPLOG_ERRNO_EX(bt2c::Logger::Level::DEBUG, (_logger), (_init_msg), (_fmt), ##__VA_ARGS__)
+ BT_CPPLOG_ERRNO_EX(bt2c::Logger::Level::Debug, (_logger), (_init_msg), (_fmt), ##__VA_ARGS__)
#define BT_CPPLOGI_ERRNO_SPEC(_logger, _init_msg, _fmt, ...) \
- BT_CPPLOG_ERRNO_EX(bt2c::Logger::Level::INFO, (_logger), (_init_msg), (_fmt), ##__VA_ARGS__)
+ BT_CPPLOG_ERRNO_EX(bt2c::Logger::Level::Info, (_logger), (_init_msg), (_fmt), ##__VA_ARGS__)
#define BT_CPPLOGW_ERRNO_SPEC(_logger, _init_msg, _fmt, ...) \
- BT_CPPLOG_ERRNO_EX(bt2c::Logger::Level::WARNING, (_logger), (_init_msg), (_fmt), ##__VA_ARGS__)
+ BT_CPPLOG_ERRNO_EX(bt2c::Logger::Level::Warning, (_logger), (_init_msg), (_fmt), ##__VA_ARGS__)
#define BT_CPPLOGE_ERRNO_SPEC(_logger, _init_msg, _fmt, ...) \
- BT_CPPLOG_ERRNO_EX(bt2c::Logger::Level::ERROR, (_logger), (_init_msg), (_fmt), ##__VA_ARGS__)
+ BT_CPPLOG_ERRNO_EX(bt2c::Logger::Level::Error, (_logger), (_init_msg), (_fmt), ##__VA_ARGS__)
#define BT_CPPLOGF_ERRNO_SPEC(_logger, _init_msg, _fmt, ...) \
- BT_CPPLOG_ERRNO_EX(bt2c::Logger::Level::FATAL, (_logger), (_init_msg), (_fmt), ##__VA_ARGS__)
+ BT_CPPLOG_ERRNO_EX(bt2c::Logger::Level::Fatal, (_logger), (_init_msg), (_fmt), ##__VA_ARGS__)
/*
* BT_CPPLOG_ERRNO_EX() with specific logging levels and using the
* BT_CPPLOG_ERRNO_STR_EX() with specific logging levels.
*/
#define BT_CPPLOGT_ERRNO_STR_SPEC(_logger, _init_msg, _msg) \
- BT_CPPLOG_ERRNO_STR_EX(bt2c::Logger::Level::TRACE, (_logger), (_init_msg), (_msg))
+ BT_CPPLOG_ERRNO_STR_EX(bt2c::Logger::Level::Trace, (_logger), (_init_msg), (_msg))
#define BT_CPPLOGD_ERRNO_STR_SPEC(_logger, _init_msg, _msg) \
- BT_CPPLOG_ERRNO_STR_EX(bt2c::Logger::Level::DEBUG, (_logger), (_init_msg), (_msg))
+ BT_CPPLOG_ERRNO_STR_EX(bt2c::Logger::Level::Debug, (_logger), (_init_msg), (_msg))
#define BT_CPPLOGI_ERRNO_STR_SPEC(_logger, _init_msg, _msg) \
- BT_CPPLOG_ERRNO_STR_EX(bt2c::Logger::Level::INFO, (_logger), (_init_msg), (_msg))
+ BT_CPPLOG_ERRNO_STR_EX(bt2c::Logger::Level::Info, (_logger), (_init_msg), (_msg))
#define BT_CPPLOGW_ERRNO_STR_SPEC(_logger, _init_msg, _msg) \
- BT_CPPLOG_ERRNO_STR_EX(bt2c::Logger::Level::WARNING, (_logger), (_init_msg), (_msg))
+ BT_CPPLOG_ERRNO_STR_EX(bt2c::Logger::Level::Warning, (_logger), (_init_msg), (_msg))
#define BT_CPPLOGE_ERRNO_STR_SPEC(_logger, _init_msg, _msg) \
- BT_CPPLOG_ERRNO_STR_EX(bt2c::Logger::Level::ERROR, (_logger), (_init_msg), (_msg))
+ BT_CPPLOG_ERRNO_STR_EX(bt2c::Logger::Level::Error, (_logger), (_init_msg), (_msg))
#define BT_CPPLOGF_ERRNO_STR_SPEC(_logger, _init_msg, _msg) \
- BT_CPPLOG_ERRNO_STR_EX(bt2c::Logger::Level::FATAL, (_logger), (_init_msg), (_msg))
+ BT_CPPLOG_ERRNO_STR_EX(bt2c::Logger::Level::Fatal, (_logger), (_init_msg), (_msg))
/*
* BT_CPPLOG_ERRNO_STR_EX() with specific logging levels and using the
oldestUpstreamMsgIter.portName());
try {
- if (G_LIKELY(oldestUpstreamMsgIter.reload() == UpstreamMsgIter::ReloadStatus::MORE)) {
+ if (G_LIKELY(oldestUpstreamMsgIter.reload() == UpstreamMsgIter::ReloadStatus::More)) {
/* New current message: update heap */
_mHeap.replaceTop(&oldestUpstreamMsgIter);
BT_CPPLOGD("More messages available; updated heap: port-name={}, heap-len={}",
"port-name={}, heap-len={}, to-reload-len={}",
upstreamMsgIter.portName(), _mHeap.len(), _mUpstreamMsgItersToReload.size());
- if (G_LIKELY(upstreamMsgIter.reload() == UpstreamMsgIter::ReloadStatus::MORE)) {
+ if (G_LIKELY(upstreamMsgIter.reload() == UpstreamMsgIter::ReloadStatus::More)) {
/* New current message: move to heap */
_mHeap.insert(&upstreamMsgIter);
BT_CPPLOGD("More messages available; "
const auto actualClockCls = error.actualClockCls();
switch (error.type()) {
- case Type::EXPECTING_NO_CLOCK_CLASS_GOT_ONE:
+ case Type::ExpectingNoClockClassGotOne:
BT_CPPLOGE_APPEND_CAUSE_AND_THROW(bt2::Error,
"Expecting no clock class, but got one: "
"clock-class-addr={}, clock-class-name={}",
fmt::ptr(actualClockCls->libObjPtr()),
actualClockCls->name());
- case Type::EXPECTING_ORIGIN_UNIX_GOT_NONE:
- case Type::EXPECTING_ORIGIN_UUID_GOT_NONE:
- case Type::EXPECTING_ORIGIN_NO_UUID_GOT_NONE:
+ case Type::ExpectingOriginUnixGotNone:
+ case Type::ExpectingOriginUuidGotNone:
+ case Type::ExpectingOriginNoUuidGotNone:
{
const auto streamCls = *error.streamCls();
streamCls.id());
}
- case Type::EXPECTING_ORIGIN_UNIX_GOT_OTHER:
+ case Type::ExpectingOriginUnixGotOther:
BT_CPPLOGE_APPEND_CAUSE_AND_THROW(bt2::Error,
"Expecting a clock class having a Unix epoch origin, "
"but got one not having a Unix epoch origin: "
fmt::ptr(actualClockCls->libObjPtr()),
actualClockCls->name());
- case Type::EXPECTING_ORIGIN_UUID_GOT_UNIX:
+ case Type::ExpectingOriginUuidGotUnix:
BT_CPPLOGE_APPEND_CAUSE_AND_THROW(
bt2::Error,
"Expecting a clock class not having a Unix epoch origin, "
"clock-class-addr={}, clock-class-name={}",
fmt::ptr(actualClockCls->libObjPtr()), actualClockCls->name());
- case Type::EXPECTING_ORIGIN_UUID_GOT_NO_UUID:
+ case Type::ExpectingOriginUuidGotNoUuid:
BT_CPPLOGE_APPEND_CAUSE_AND_THROW(
bt2::Error,
"Expecting a clock class with a UUID, but got one without a UUID: "
"clock-class-addr={}, clock-class-name={}",
fmt::ptr(actualClockCls->libObjPtr()), actualClockCls->name());
- case Type::EXPECTING_ORIGIN_UUID_GOT_OTHER_UUID:
+ case Type::ExpectingOriginUuidGotOtherUuid:
BT_CPPLOGE_APPEND_CAUSE_AND_THROW(bt2::Error,
"Expecting a clock class with a specific UUID, "
"but got one with a different UUID: "
actualClockCls->name(), *error.expectedUuid(),
*actualClockCls->uuid());
- case Type::EXPECTING_ORIGIN_NO_UUID_GOT_OTHER:
+ case Type::ExpectingOriginNoUuidGotOther:
{
const auto expectedClockCls = error.expectedClockCls();
bt2::OptionalBorrowedObject<bt2::ConstClockSnapshot> msgCs(const bt2::ConstMessage msg) noexcept
{
switch (msg.type()) {
- case bt2::MessageType::EVENT:
+ case bt2::MessageType::Event:
if (msg.asEvent().streamClassDefaultClockClass()) {
return msg.asEvent().defaultClockSnapshot();
}
break;
- case bt2::MessageType::PACKET_BEGINNING:
+ case bt2::MessageType::PacketBeginning:
if (msg.asPacketBeginning().packet().stream().cls().packetsHaveBeginningClockSnapshot()) {
return msg.asPacketBeginning().defaultClockSnapshot();
}
break;
- case bt2::MessageType::PACKET_END:
+ case bt2::MessageType::PacketEnd:
if (msg.asPacketEnd().packet().stream().cls().packetsHaveEndClockSnapshot()) {
return msg.asPacketEnd().defaultClockSnapshot();
}
break;
- case bt2::MessageType::DISCARDED_EVENTS:
+ case bt2::MessageType::DiscardedEvents:
if (msg.asDiscardedEvents().stream().cls().discardedEventsHaveDefaultClockSnapshots()) {
return msg.asDiscardedEvents().beginningDefaultClockSnapshot();
}
break;
- case bt2::MessageType::DISCARDED_PACKETS:
+ case bt2::MessageType::DiscardedPackets:
if (msg.asDiscardedPackets().stream().cls().discardedPacketsHaveDefaultClockSnapshots()) {
return msg.asDiscardedPackets().beginningDefaultClockSnapshot();
}
break;
- case bt2::MessageType::MESSAGE_ITERATOR_INACTIVITY:
+ case bt2::MessageType::MessageIteratorInactivity:
return msg.asMessageIteratorInactivity().clockSnapshot();
- case bt2::MessageType::STREAM_BEGINNING:
+ case bt2::MessageType::StreamBeginning:
if (msg.asStreamBeginning().streamClassDefaultClockClass()) {
return msg.asStreamBeginning().defaultClockSnapshot();
}
break;
- case bt2::MessageType::STREAM_END:
+ case bt2::MessageType::StreamEnd:
if (msg.asStreamEnd().streamClassDefaultClockClass()) {
return msg.asStreamEnd().defaultClockSnapshot();
}
if (G_UNLIKELY(!_mMsgs.msgs)) {
/* Still none: no more */
_mMsgTs.reset();
- return ReloadStatus::NO_MORE;
+ return ReloadStatus::NoMore;
} else {
if (const auto cs = msgCs(this->msg())) {
_mMsgTs = cs->nsFromOrigin();
}
_mDiscardRequired = true;
- return ReloadStatus::MORE;
+ return ReloadStatus::More;
}
}
/* Return type of reload() */
enum class ReloadStatus
{
- MORE,
- NO_MORE,
+ More,
+ NoMore,
};
/*
public:
enum class MsgType
{
- STREAM_BEG,
- MSG_ITER_INACTIVITY,
+ StreamBeg,
+ MsgIterInactivity,
};
using CreateClockCls = bt2::ClockClass::Shared (*)(bt2::SelfComponent);
const auto clockCls = createClockCls(self.component());
switch (msgType) {
- case MsgType::STREAM_BEG:
+ case MsgType::StreamBeg:
{
const auto streamCls = trace.cls().createStreamClass();
return self.createStreamBeginningMessage(*streamCls->instantiate(trace));
}
- case MsgType::MSG_ITER_INACTIVITY:
+ case MsgType::MsgIterInactivity:
BT_ASSERT(clockCls);
return self.createMessageIteratorInactivityMessage(*clockCls, 12);
};
__attribute__((used)) const char *format_as(const ClockClsCompatRunIn::MsgType msgType)
{
switch (msgType) {
- case ClockClsCompatRunIn::MsgType::STREAM_BEG:
+ case ClockClsCompatRunIn::MsgType::StreamBeg:
return "sb";
- case ClockClsCompatRunIn::MsgType::MSG_ITER_INACTIVITY:
+ case ClockClsCompatRunIn::MsgType::MsgIterInactivity:
return "mii";
}
* without a clock class.
*/
static constexpr std::array<ClockClsCompatRunIn::MsgType, 2> msgTypes {
- ClockClsCompatRunIn::MsgType::STREAM_BEG,
- ClockClsCompatRunIn::MsgType::MSG_ITER_INACTIVITY,
+ ClockClsCompatRunIn::MsgType::StreamBeg,
+ ClockClsCompatRunIn::MsgType::MsgIterInactivity,
};
const auto isInvalidCase = [](const ClockClsCompatRunIn::MsgType msgType,
const ClockClsCompatRunIn::CreateClockCls createClockCls) {
- return msgType == ClockClsCompatRunIn::MsgType::MSG_ITER_INACTIVITY &&
+ return msgType == ClockClsCompatRunIn::MsgType::MsgIterInactivity &&
createClockCls == noClockClass;
};
triggers.emplace_back(bt2s::make_unique<RunInCondTrigger<ClockClsCompatRunIn>>(
ClockClsCompatRunIn {msgType1, createClockCls1, msgType2, createClockCls2},
- CondTrigger::Type::POST, condId, fmt::format("{}-{}", msgType1, msgType2)));
+ CondTrigger::Type::Post, condId, fmt::format("{}-{}", msgType1, msgType2)));
}
}
};
[] {
bt2::Graph::create(292);
},
- CondTrigger::Type::PRE, "graph-create:valid-mip-version"));
+ CondTrigger::Type::Pre, "graph-create:valid-mip-version"));
triggers.emplace_back(makeRunInCompInitTrigger(
[](const bt2::SelfComponent self) {
createUIntFc(self)->fieldValueRange(0);
},
- CondTrigger::Type::PRE, "field-class-integer-set-field-value-range:valid-n", "0"));
+ CondTrigger::Type::Pre, "field-class-integer-set-field-value-range:valid-n", "0"));
triggers.emplace_back(makeRunInCompInitTrigger(
[](const bt2::SelfComponent self) {
createUIntFc(self)->fieldValueRange(65);
},
- CondTrigger::Type::PRE, "field-class-integer-set-field-value-range:valid-n", "gt-64"));
+ CondTrigger::Type::Pre, "field-class-integer-set-field-value-range:valid-n", "gt-64"));
triggers.emplace_back(makeSimpleTrigger(
[] {
bt_field_class_integer_set_field_value_range(nullptr, 23);
},
- CondTrigger::Type::PRE, "field-class-integer-set-field-value-range:not-null:field-class"));
+ CondTrigger::Type::Pre, "field-class-integer-set-field-value-range:not-null:field-class"));
addClkClsCompatTriggers(triggers);
condMain(bt2c::makeSpan(argv, argc), triggers);
CondTrigger::CondTrigger(const Type type, const std::string& condId,
const bt2c::CStringView nameSuffix) noexcept :
_mType {type},
- _mCondId {fmt::format("{}:{}", type == Type::PRE ? "pre" : "post", condId)},
+ _mCondId {fmt::format("{}:{}", type == Type::Pre ? "pre" : "post", condId)},
_mName {fmt::format("{}{}{}", condId, nameSuffix ? "-" : "", nameSuffix ? nameSuffix : "")}
{
}
*/
enum class Type
{
- PRE,
- POST,
+ Pre,
+ Post,
};
protected:
enum class MsgType
{
/* Send stream beginning and stream end messages. */
- STREAM,
+ Stream,
/* Send a message iterator inactivity message. */
- MSG_ITER_INACTIVITY,
+ MsgIterInactivity,
};
__attribute__((used)) const char *format_as(MsgType msgType) noexcept
{
switch (msgType) {
- case MsgType::STREAM:
+ case MsgType::Stream:
return "stream beginning/end";
- case MsgType::MSG_ITER_INACTIVITY:
+ case MsgType::MsgIterInactivity:
return "message iterator inactivity";
}
const auto clockCls = _mData->createClockClass(_mSelf.component());
switch (_mData->msgType) {
- case MsgType::STREAM:
+ case MsgType::Stream:
{
const auto traceCls = _mSelf.component().createTraceClass();
const auto streamCls = traceCls->createStreamClass();
break;
}
- case MsgType::MSG_ITER_INACTIVITY:
+ case MsgType::MsgIterInactivity:
msgs.append(
this->_createMessageIteratorInactivityMessage(*clockCls, *_mData->clockSnapshot));
break;
void ErrorTestCase::run() const noexcept
{
static constexpr std::array<MsgType, 2> msgTypes {
- MsgType::STREAM,
- MsgType::MSG_ITER_INACTIVITY,
+ MsgType::Stream,
+ MsgType::MsgIterInactivity,
};
for (const auto msgType1 : msgTypes) {
* It's not possible to create message iterator inactivity
* messages without a clock class. Skip those cases.
*/
- if ((msgType1 == MsgType::MSG_ITER_INACTIVITY && _mCreateClockClass1 == noClockClass) ||
- (msgType2 == MsgType::MSG_ITER_INACTIVITY && _mCreateClockClass2 == noClockClass)) {
+ if ((msgType1 == MsgType::MsgIterInactivity && _mCreateClockClass1 == noClockClass) ||
+ (msgType2 == MsgType::MsgIterInactivity && _mCreateClockClass2 == noClockClass)) {
continue;
}
*
* Skip those cases.
*/
- if (msgType1 == MsgType::MSG_ITER_INACTIVITY && _mCreateClockClass2 == noClockClass) {
+ if (msgType1 == MsgType::MsgIterInactivity && _mCreateClockClass2 == noClockClass) {
continue;
}
const auto srcComp1 =
graph->addComponent(*srcCompCls, "source-1",
TestSourceData {_mCreateClockClass1, msgType1,
- msgType1 == MsgType::MSG_ITER_INACTIVITY ?
+ msgType1 == MsgType::MsgIterInactivity ?
bt2s::optional<std::uint64_t> {10} :
bt2s::nullopt});
const auto srcComp2 =