#include "internal/borrowed-obj.hpp"
#include "internal/shared-obj.hpp"
+#include "internal/utils.hpp"
#include "cpp-common/optional.hpp"
#include "cpp-common/string_view.hpp"
#include "cpp-common/uuid-view.hpp"
using ClockClass = CommonClockClass<bt_clock_class>;
using ConstClockClass = CommonClockClass<const bt_clock_class>;
+namespace internal {
+
+struct ClockClassTypeDescr
+{
+ using Const = ConstClockClass;
+ using NonConst = ClockClass;
+};
+
+template <>
+struct TypeDescr<ClockClass> : public ClockClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstClockClass> : public ClockClassTypeDescr
+{
+};
+
+} /* namespace internal */
} /* namespace bt2 */
#endif /* BABELTRACE_CPP_COMMON_BT2_CLOCK_CLASS_HPP */
#include "common/assert.h"
#include "internal/borrowed-obj.hpp"
#include "internal/shared-obj.hpp"
+#include "internal/utils.hpp"
#include "cpp-common/optional.hpp"
#include "cpp-common/string_view.hpp"
#include "common-iter.hpp"
#include "value.hpp"
namespace bt2 {
-
namespace internal {
struct FieldClassRefFuncs final
using FieldClass = CommonFieldClass<bt_field_class>;
using ConstFieldClass = CommonFieldClass<const bt_field_class>;
+namespace internal {
+
+struct FieldClassTypeDescr
+{
+ using Const = ConstFieldClass;
+ using NonConst = FieldClass;
+};
+
+template <>
+struct TypeDescr<FieldClass> : public FieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstFieldClass> : public FieldClassTypeDescr
+{
+};
+
+} /* namespace internal */
+
template <typename LibObjT>
class CommonBitArrayFieldClass final : public CommonFieldClass<LibObjT>
{
using BitArrayFieldClass = CommonBitArrayFieldClass<bt_field_class>;
using ConstBitArrayFieldClass = CommonBitArrayFieldClass<const bt_field_class>;
+namespace internal {
+
+struct BitArrayFieldClassTypeDescr
+{
+ using Const = ConstBitArrayFieldClass;
+ using NonConst = BitArrayFieldClass;
+};
+
+template <>
+struct TypeDescr<BitArrayFieldClass> : public BitArrayFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstBitArrayFieldClass> : public BitArrayFieldClassTypeDescr
+{
+};
+
+} /* namespace internal */
+
enum class DisplayBase
{
BINARY = BT_FIELD_CLASS_INTEGER_PREFERRED_DISPLAY_BASE_BINARY,
namespace internal {
+struct IntegerFieldClassTypeDescr
+{
+ using Const = ConstIntegerFieldClass;
+ using NonConst = IntegerFieldClass;
+};
+
+template <>
+struct TypeDescr<IntegerFieldClass> : public IntegerFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstIntegerFieldClass> : public IntegerFieldClassTypeDescr
+{
+};
+
+} /* namespace internal */
+
+namespace internal {
+
template <typename LibObjT>
struct ConstEnumerationFieldClassMappingSpec;
namespace internal {
+struct UnsignedEnumerationFieldClassTypeDescr
+{
+ using Const = ConstUnsignedEnumerationFieldClass;
+ using NonConst = UnsignedEnumerationFieldClass;
+};
+
+template <>
+struct TypeDescr<UnsignedEnumerationFieldClass> : public UnsignedEnumerationFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstUnsignedEnumerationFieldClass> : public UnsignedEnumerationFieldClassTypeDescr
+{
+};
+
+struct SignedEnumerationFieldClassTypeDescr
+{
+ using Const = ConstSignedEnumerationFieldClass;
+ using NonConst = SignedEnumerationFieldClass;
+};
+
+template <>
+struct TypeDescr<SignedEnumerationFieldClass> : public SignedEnumerationFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstSignedEnumerationFieldClass> : public SignedEnumerationFieldClassTypeDescr
+{
+};
+
template <typename LibObjT>
struct CommonStructureFieldClassMemberSpec;
namespace internal {
+struct StructureFieldClassMemberTypeDescr
+{
+ using Const = ConstStructureFieldClassMember;
+ using NonConst = StructureFieldClassMember;
+};
+
+template <>
+struct TypeDescr<StructureFieldClassMember> : public StructureFieldClassMemberTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstStructureFieldClassMember> : public StructureFieldClassMemberTypeDescr
+{
+};
+
template <typename LibObjT>
struct CommonStructureFieldClassSpec;
namespace internal {
+struct StructureFieldClassTypeDescr
+{
+ using Const = ConstStructureFieldClass;
+ using NonConst = StructureFieldClass;
+};
+
+template <>
+struct TypeDescr<StructureFieldClass> : public StructureFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstStructureFieldClass> : public StructureFieldClassTypeDescr
+{
+};
+
template <typename LibObjT>
struct CommonArrayFieldClassSpec;
using ArrayFieldClass = CommonArrayFieldClass<bt_field_class>;
using ConstArrayFieldClass = CommonArrayFieldClass<const bt_field_class>;
+namespace internal {
+
+struct ArrayFieldClassTypeDescr
+{
+ using Const = ConstArrayFieldClass;
+ using NonConst = ArrayFieldClass;
+};
+
+template <>
+struct TypeDescr<ArrayFieldClass> : public ArrayFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstArrayFieldClass> : public ArrayFieldClassTypeDescr
+{
+};
+
+} /* namespace internal */
+
template <typename LibObjT>
class CommonStaticArrayFieldClass final : public CommonArrayFieldClass<LibObjT>
{
using StaticArrayFieldClass = CommonStaticArrayFieldClass<bt_field_class>;
using ConstStaticArrayFieldClass = CommonStaticArrayFieldClass<const bt_field_class>;
+namespace internal {
+
+struct StaticArrayFieldClassTypeDescr
+{
+ using Const = ConstStaticArrayFieldClass;
+ using NonConst = StaticArrayFieldClass;
+};
+
+template <>
+struct TypeDescr<StaticArrayFieldClass> : public StaticArrayFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstStaticArrayFieldClass> : public StaticArrayFieldClassTypeDescr
+{
+};
+
+} /* namespace internal */
+
template <typename LibObjT>
class CommonDynamicArrayWithLengthFieldClass final : public CommonArrayFieldClass<LibObjT>
{
namespace internal {
+struct DynamicArrayWithLengthFieldClassTypeDescr
+{
+ using Const = ConstDynamicArrayWithLengthFieldClass;
+ using NonConst = DynamicArrayWithLengthFieldClass;
+};
+
+template <>
+struct TypeDescr<DynamicArrayWithLengthFieldClass> :
+ public DynamicArrayWithLengthFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstDynamicArrayWithLengthFieldClass> :
+ public DynamicArrayWithLengthFieldClassTypeDescr
+{
+};
+
template <typename LibObjT>
struct CommonOptionFieldClassSpec;
using OptionFieldClass = CommonOptionFieldClass<bt_field_class>;
using ConstOptionFieldClass = CommonOptionFieldClass<const bt_field_class>;
+namespace internal {
+
+struct OptionFieldClassTypeDescr
+{
+ using Const = ConstOptionFieldClass;
+ using NonConst = OptionFieldClass;
+};
+
+template <>
+struct TypeDescr<OptionFieldClass> : public OptionFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstOptionFieldClass> : public OptionFieldClassTypeDescr
+{
+};
+
+} /* namespace internal */
+
template <typename LibObjT>
class CommonOptionWithSelectorFieldClass : public CommonOptionFieldClass<LibObjT>
{
using OptionWithSelectorFieldClass = CommonOptionWithSelectorFieldClass<bt_field_class>;
using ConstOptionWithSelectorFieldClass = CommonOptionWithSelectorFieldClass<const bt_field_class>;
+namespace internal {
+
+struct OptionWithSelectorFieldClassTypeDescr
+{
+ using Const = ConstOptionWithSelectorFieldClass;
+ using NonConst = OptionWithSelectorFieldClass;
+};
+
+template <>
+struct TypeDescr<OptionWithSelectorFieldClass> : public OptionWithSelectorFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstOptionWithSelectorFieldClass> : public OptionWithSelectorFieldClassTypeDescr
+{
+};
+
+} /* namespace internal */
+
template <typename LibObjT>
class CommonOptionWithBoolSelectorFieldClass : public CommonOptionWithSelectorFieldClass<LibObjT>
{
namespace internal {
+struct OptionWithBoolSelectorFieldClassTypeDescr
+{
+ using Const = ConstOptionWithBoolSelectorFieldClass;
+ using NonConst = OptionWithBoolSelectorFieldClass;
+};
+
+template <>
+struct TypeDescr<OptionWithBoolSelectorFieldClass> :
+ public OptionWithBoolSelectorFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstOptionWithBoolSelectorFieldClass> :
+ public OptionWithBoolSelectorFieldClassTypeDescr
+{
+};
+
template <typename RangeSetT>
struct CommonOptionWithIntegerSelectorFieldClassSpec;
namespace internal {
+struct OptionWithUnsignedIntegerSelectorFieldClassTypeDescr
+{
+ using Const = ConstOptionWithUnsignedIntegerSelectorFieldClass;
+ using NonConst = OptionWithUnsignedIntegerSelectorFieldClass;
+};
+
+template <>
+struct TypeDescr<OptionWithUnsignedIntegerSelectorFieldClass> :
+ public OptionWithUnsignedIntegerSelectorFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstOptionWithUnsignedIntegerSelectorFieldClass> :
+ public OptionWithUnsignedIntegerSelectorFieldClassTypeDescr
+{
+};
+
+struct OptionWithSignedIntegerSelectorFieldClassTypeDescr
+{
+ using Const = ConstOptionWithSignedIntegerSelectorFieldClass;
+ using NonConst = OptionWithSignedIntegerSelectorFieldClass;
+};
+
+template <>
+struct TypeDescr<OptionWithSignedIntegerSelectorFieldClass> :
+ public OptionWithSignedIntegerSelectorFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstOptionWithSignedIntegerSelectorFieldClass> :
+ public OptionWithSignedIntegerSelectorFieldClassTypeDescr
+{
+};
+
template <typename LibObjT>
struct CommonVariantFieldClassOptionSpec;
namespace internal {
+struct VariantFieldClassOptionTypeDescr
+{
+ using Const = ConstVariantFieldClassOption;
+ using NonConst = VariantFieldClassOption;
+};
+
+template <>
+struct TypeDescr<VariantFieldClassOption> : public VariantFieldClassOptionTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstVariantFieldClassOption> : public VariantFieldClassOptionTypeDescr
+{
+};
+
template <typename LibObjT>
struct ConstVariantWithIntegerSelectorFieldClassOptionSpec;
using VariantFieldClass = CommonVariantFieldClass<bt_field_class>;
using ConstVariantFieldClass = CommonVariantFieldClass<const bt_field_class>;
+namespace internal {
+
+struct VariantFieldClassTypeDescr
+{
+ using Const = ConstVariantFieldClass;
+ using NonConst = VariantFieldClass;
+};
+
+template <>
+struct TypeDescr<VariantFieldClass> : public VariantFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstVariantFieldClass> : public VariantFieldClassTypeDescr
+{
+};
+
+} /* namespace internal */
+
template <typename LibObjT>
class CommonVariantWithoutSelectorFieldClass : public CommonVariantFieldClass<LibObjT>
{
namespace internal {
+struct VariantWithoutSelectorFieldClassTypeDescr
+{
+ using Const = ConstVariantWithoutSelectorFieldClass;
+ using NonConst = VariantWithoutSelectorFieldClass;
+};
+
+template <>
+struct TypeDescr<VariantWithoutSelectorFieldClass> :
+ public VariantWithoutSelectorFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstVariantWithoutSelectorFieldClass> :
+ public VariantWithoutSelectorFieldClassTypeDescr
+{
+};
+
template <typename OptionT>
struct CommonVariantWithIntegerSelectorFieldClassSpec;
using ConstVariantWithSignedIntegerSelectorFieldClass = CommonVariantWithIntegerSelectorFieldClass<
const bt_field_class, ConstVariantWithSignedIntegerSelectorFieldClassOption>;
+namespace internal {
+
+struct VariantWithUnsignedIntegerSelectorFieldClassTypeDescr
+{
+ using Const = ConstVariantWithUnsignedIntegerSelectorFieldClass;
+ using NonConst = VariantWithUnsignedIntegerSelectorFieldClass;
+};
+
+template <>
+struct TypeDescr<VariantWithUnsignedIntegerSelectorFieldClass> :
+ public VariantWithUnsignedIntegerSelectorFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstVariantWithUnsignedIntegerSelectorFieldClass> :
+ public VariantWithUnsignedIntegerSelectorFieldClassTypeDescr
+{
+};
+
+struct VariantWithSignedIntegerSelectorFieldClassTypeDescr
+{
+ using Const = ConstVariantWithSignedIntegerSelectorFieldClass;
+ using NonConst = VariantWithSignedIntegerSelectorFieldClass;
+};
+
+template <>
+struct TypeDescr<VariantWithSignedIntegerSelectorFieldClass> :
+ public VariantWithSignedIntegerSelectorFieldClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstVariantWithSignedIntegerSelectorFieldClass> :
+ public VariantWithSignedIntegerSelectorFieldClassTypeDescr
+{
+};
+
+} /* namespace internal */
+
template <typename LibObjT>
CommonBitArrayFieldClass<LibObjT> CommonFieldClass<LibObjT>::asBitArray() const noexcept
{
#include "common/assert.h"
#include "internal/borrowed-obj.hpp"
+#include "internal/utils.hpp"
#include "cpp-common/optional.hpp"
#include "cpp-common/string_view.hpp"
#include "field-class.hpp"
using Field = CommonField<bt_field>;
using ConstField = CommonField<const bt_field>;
+namespace internal {
+
+struct FieldTypeDescr
+{
+ using Const = ConstField;
+ using NonConst = Field;
+};
+
+template <>
+struct TypeDescr<Field> : public FieldTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstField> : public FieldTypeDescr
+{
+};
+
+} /* namespace internal */
+
template <typename LibObjT>
class CommonBoolField final : public CommonField<LibObjT>
{
using BoolField = CommonBoolField<bt_field>;
using ConstBoolField = CommonBoolField<const bt_field>;
+namespace internal {
+
+struct BoolFieldTypeDescr
+{
+ using Const = ConstBoolField;
+ using NonConst = BoolField;
+};
+
+template <>
+struct TypeDescr<BoolField> : public BoolFieldTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstBoolField> : public BoolFieldTypeDescr
+{
+};
+
+} /* namespace internal */
+
template <typename LibObjT>
class CommonBitArrayField final : public CommonField<LibObjT>
{
using BitArrayField = CommonBitArrayField<bt_field>;
using ConstBitArrayField = CommonBitArrayField<const bt_field>;
+namespace internal {
+
+struct BitArrayFieldTypeDescr
+{
+ using Const = ConstBitArrayField;
+ using NonConst = BitArrayField;
+};
+
+template <>
+struct TypeDescr<BitArrayField> : public BitArrayFieldTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstBitArrayField> : public BitArrayFieldTypeDescr
+{
+};
+
+} /* namespace internal */
+
template <typename LibObjT>
class CommonUnsignedIntegerField final : public CommonField<LibObjT>
{
using UnsignedIntegerField = CommonUnsignedIntegerField<bt_field>;
using ConstUnsignedIntegerField = CommonUnsignedIntegerField<const bt_field>;
+namespace internal {
+
+struct UnsignedIntegerFieldTypeDescr
+{
+ using Const = ConstUnsignedIntegerField;
+ using NonConst = UnsignedIntegerField;
+};
+
+template <>
+struct TypeDescr<UnsignedIntegerField> : public UnsignedIntegerFieldTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstUnsignedIntegerField> : public UnsignedIntegerFieldTypeDescr
+{
+};
+
+} /* namespace internal */
+
template <typename LibObjT>
class CommonSignedIntegerField final : public CommonField<LibObjT>
{
using SignedIntegerField = CommonSignedIntegerField<bt_field>;
using ConstSignedIntegerField = CommonSignedIntegerField<const bt_field>;
+namespace internal {
+
+struct SignedIntegerFieldTypeDescr
+{
+ using Const = ConstSignedIntegerField;
+ using NonConst = SignedIntegerField;
+};
+
+template <>
+struct TypeDescr<SignedIntegerField> : public SignedIntegerFieldTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstSignedIntegerField> : public SignedIntegerFieldTypeDescr
+{
+};
+
+} /* namespace internal */
+
class EnumerationFieldClassMappingLabels
{
public:
using UnsignedEnumerationField = CommonUnsignedEnumerationField<bt_field>;
using ConstUnsignedEnumerationField = CommonUnsignedEnumerationField<const bt_field>;
+namespace internal {
+
+struct UnsignedEnumerationFieldTypeDescr
+{
+ using Const = ConstUnsignedEnumerationField;
+ using NonConst = UnsignedEnumerationField;
+};
+
+template <>
+struct TypeDescr<UnsignedEnumerationField> : public UnsignedEnumerationFieldTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstUnsignedEnumerationField> : public UnsignedEnumerationFieldTypeDescr
+{
+};
+
+} /* namespace internal */
+
template <typename LibObjT>
class CommonSignedEnumerationField final : public CommonSignedIntegerField<LibObjT>
{
using SignedEnumerationField = CommonSignedEnumerationField<bt_field>;
using ConstSignedEnumerationField = CommonSignedEnumerationField<const bt_field>;
+namespace internal {
+
+struct SignedEnumerationFieldTypeDescr
+{
+ using Const = ConstSignedEnumerationField;
+ using NonConst = SignedEnumerationField;
+};
+
+template <>
+struct TypeDescr<SignedEnumerationField> : public SignedEnumerationFieldTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstSignedEnumerationField> : public SignedEnumerationFieldTypeDescr
+{
+};
+
+} /* namespace internal */
+
template <typename LibObjT>
class CommonSinglePrecisionRealField final : public CommonField<LibObjT>
{
using SinglePrecisionRealField = CommonSinglePrecisionRealField<bt_field>;
using ConstSinglePrecisionRealField = CommonSinglePrecisionRealField<const bt_field>;
+namespace internal {
+
+struct SinglePrecisionRealFieldTypeDescr
+{
+ using Const = ConstSinglePrecisionRealField;
+ using NonConst = SinglePrecisionRealField;
+};
+
+template <>
+struct TypeDescr<SinglePrecisionRealField> : public SinglePrecisionRealFieldTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstSinglePrecisionRealField> : public SinglePrecisionRealFieldTypeDescr
+{
+};
+
+} /* namespace internal */
+
template <typename LibObjT>
class CommonDoublePrecisionRealField final : public CommonField<LibObjT>
{
using DoublePrecisionRealField = CommonDoublePrecisionRealField<bt_field>;
using ConstDoublePrecisionRealField = CommonDoublePrecisionRealField<const bt_field>;
+namespace internal {
+
+struct DoublePrecisionRealFieldTypeDescr
+{
+ using Const = ConstDoublePrecisionRealField;
+ using NonConst = DoublePrecisionRealField;
+};
+
+template <>
+struct TypeDescr<DoublePrecisionRealField> : public DoublePrecisionRealFieldTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstDoublePrecisionRealField> : public DoublePrecisionRealFieldTypeDescr
+{
+};
+
+} /* namespace internal */
+
template <typename LibObjT>
class CommonStringField final : public CommonField<LibObjT>
{
namespace internal {
+struct StringFieldTypeDescr
+{
+ using Const = ConstStringField;
+ using NonConst = StringField;
+};
+
+template <>
+struct TypeDescr<StringField> : public StringFieldTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstStringField> : public StringFieldTypeDescr
+{
+};
+
template <typename LibObjT>
struct CommonStructureFieldSpec;
namespace internal {
+struct StructureFieldTypeDescr
+{
+ using Const = ConstStructureField;
+ using NonConst = StructureField;
+};
+
+template <>
+struct TypeDescr<StructureField> : public StructureFieldTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstStructureField> : public StructureFieldTypeDescr
+{
+};
+
template <typename LibObjT>
struct CommonArrayFieldSpec;
using ArrayField = CommonArrayField<bt_field>;
using ConstArrayField = CommonArrayField<const bt_field>;
+namespace internal {
+
+struct ArrayFieldTypeDescr
+{
+ using Const = ConstArrayField;
+ using NonConst = ArrayField;
+};
+
+template <>
+struct TypeDescr<ArrayField> : public ArrayFieldTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstArrayField> : public ArrayFieldTypeDescr
+{
+};
+
+} /* namespace internal */
+
template <typename LibObjT>
class CommonDynamicArrayField : public CommonArrayField<LibObjT>
{
namespace internal {
+struct DynamicArrayFieldTypeDescr
+{
+ using Const = ConstDynamicArrayField;
+ using NonConst = DynamicArrayField;
+};
+
+template <>
+struct TypeDescr<DynamicArrayField> : public DynamicArrayFieldTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstDynamicArrayField> : public DynamicArrayFieldTypeDescr
+{
+};
+
template <typename LibObjT>
struct CommonOptionFieldSpec;
namespace internal {
+struct OptionFieldTypeDescr
+{
+ using Const = ConstOptionField;
+ using NonConst = OptionField;
+};
+
+template <>
+struct TypeDescr<OptionField> : public OptionFieldTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstOptionField> : public OptionFieldTypeDescr
+{
+};
+
template <typename LibObjT>
struct CommonVariantFieldSpec;
using VariantField = CommonVariantField<bt_field>;
using ConstVariantField = CommonVariantField<const bt_field>;
+namespace internal {
+
+struct VariantFieldTypeDescr
+{
+ using Const = ConstVariantField;
+ using NonConst = VariantField;
+};
+
+template <>
+struct TypeDescr<VariantField> : public VariantFieldTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstVariantField> : public VariantFieldTypeDescr
+{
+};
+
+} /* namespace internal */
+
template <typename LibObjT>
CommonBoolField<LibObjT> CommonField<LibObjT>::asBool() const noexcept
{
using SignedIntegerRangeSet = CommonIntegerRangeSet<bt_integer_range_set_signed>;
using ConstSignedIntegerRangeSet = CommonIntegerRangeSet<const bt_integer_range_set_signed>;
+namespace internal {
+
+struct UnsignedIntegerRangeSetTypeDescr
+{
+ using Const = ConstUnsignedIntegerRangeSet;
+ using NonConst = UnsignedIntegerRangeSet;
+};
+
+template <>
+struct TypeDescr<UnsignedIntegerRangeSet> : public UnsignedIntegerRangeSetTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstUnsignedIntegerRangeSet> : public UnsignedIntegerRangeSetTypeDescr
+{
+};
+
+struct SignedIntegerRangeSetTypeDescr
+{
+ using Const = ConstSignedIntegerRangeSet;
+ using NonConst = SignedIntegerRangeSet;
+};
+
+template <>
+struct TypeDescr<SignedIntegerRangeSet> : public SignedIntegerRangeSetTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstSignedIntegerRangeSet> : public SignedIntegerRangeSetTypeDescr
+{
+};
+
+} /* namespace internal */
} /* namespace bt2 */
#endif /* BABELTRACE_CPP_COMMON_BT2_INTEGER_RANGE_SET_HPP */
}
}
+template <typename ObjT>
+struct TypeDescr;
+
} /* namespace internal */
} /* namespace bt2 */
#include "lib-error.hpp"
namespace bt2 {
-
namespace internal {
struct MessageRefFuncs final
namespace internal {
+struct MessageTypeDescr
+{
+ using Const = ConstMessage;
+ using NonConst = Message;
+};
+
+template <>
+struct TypeDescr<Message> : public MessageTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstMessage> : public MessageTypeDescr
+{
+};
+
template <typename LibObjT>
struct CommonStreamBeginningMessageSpec;
namespace internal {
+struct StreamBeginningMessageTypeDescr
+{
+ using Const = ConstStreamBeginningMessage;
+ using NonConst = StreamBeginningMessage;
+};
+
+template <>
+struct TypeDescr<StreamBeginningMessage> : public StreamBeginningMessageTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstStreamBeginningMessage> : public StreamBeginningMessageTypeDescr
+{
+};
+
template <typename LibObjT>
struct CommonStreamEndMessageSpec;
namespace internal {
+struct StreamEndMessageTypeDescr
+{
+ using Const = ConstStreamEndMessage;
+ using NonConst = StreamEndMessage;
+};
+
+template <>
+struct TypeDescr<StreamEndMessage> : public StreamEndMessageTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstStreamEndMessage> : public StreamEndMessageTypeDescr
+{
+};
+
template <typename LibObjT>
struct CommonPacketBeginningMessageSpec;
namespace internal {
+struct PacketBeginningMessageTypeDescr
+{
+ using Const = ConstPacketBeginningMessage;
+ using NonConst = PacketBeginningMessage;
+};
+
+template <>
+struct TypeDescr<PacketBeginningMessage> : public PacketBeginningMessageTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstPacketBeginningMessage> : public PacketBeginningMessageTypeDescr
+{
+};
+
template <typename LibObjT>
struct CommonPacketEndMessageSpec;
namespace internal {
+struct PacketEndMessageTypeDescr
+{
+ using Const = ConstPacketEndMessage;
+ using NonConst = PacketEndMessage;
+};
+
+template <>
+struct TypeDescr<PacketEndMessage> : public PacketEndMessageTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstPacketEndMessage> : public PacketEndMessageTypeDescr
+{
+};
+
template <typename LibObjT>
struct CommonEventMessageSpec;
namespace internal {
+struct EventMessageTypeDescr
+{
+ using Const = ConstEventMessage;
+ using NonConst = EventMessage;
+};
+
+template <>
+struct TypeDescr<EventMessage> : public EventMessageTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstEventMessage> : public EventMessageTypeDescr
+{
+};
+
template <typename LibObjT>
struct CommonDiscardedEventsMessageSpec;
namespace internal {
+struct DiscardedEventsMessageTypeDescr
+{
+ using Const = ConstDiscardedEventsMessage;
+ using NonConst = DiscardedEventsMessage;
+};
+
+template <>
+struct TypeDescr<DiscardedEventsMessage> : public DiscardedEventsMessageTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstDiscardedEventsMessage> : public DiscardedEventsMessageTypeDescr
+{
+};
+
template <typename LibObjT>
struct CommonDiscardedPacketsMessageSpec;
using DiscardedPacketsMessage = CommonDiscardedPacketsMessage<bt_message>;
using ConstDiscardedPacketsMessage = CommonDiscardedPacketsMessage<const bt_message>;
+namespace internal {
+
+struct DiscardedPacketsMessageTypeDescr
+{
+ using Const = ConstDiscardedPacketsMessage;
+ using NonConst = DiscardedPacketsMessage;
+};
+
+template <>
+struct TypeDescr<DiscardedPacketsMessage> : public DiscardedPacketsMessageTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstDiscardedPacketsMessage> : public DiscardedPacketsMessageTypeDescr
+{
+};
+
+} /* namespace internal */
+
template <typename LibObjT>
class CommonMessageIteratorInactivityMessage final : public CommonMessage<LibObjT>
{
using ConstMessageIteratorInactivityMessage =
CommonMessageIteratorInactivityMessage<const bt_message>;
+namespace internal {
+
+struct MessageIteratorInactivityMessageTypeDescr
+{
+ using Const = ConstMessageIteratorInactivityMessage;
+ using NonConst = MessageIteratorInactivityMessage;
+};
+
+template <>
+struct TypeDescr<MessageIteratorInactivityMessage> :
+ public MessageIteratorInactivityMessageTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstMessageIteratorInactivityMessage> :
+ public MessageIteratorInactivityMessageTypeDescr
+{
+};
+
+} /* namespace internal */
+
template <typename LibObjT>
CommonStreamBeginningMessage<LibObjT> CommonMessage<LibObjT>::asStreamBeginning() const noexcept
{
namespace internal {
+struct EventTypeDescr
+{
+ using Const = ConstEvent;
+ using NonConst = Event;
+};
+
+template <>
+struct TypeDescr<Event> : public EventTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstEvent> : public EventTypeDescr
+{
+};
+
struct PacketRefFuncs final
{
static void get(const bt_packet * const libObjPtr)
using Packet = CommonPacket<bt_packet>;
using ConstPacket = CommonPacket<const bt_packet>;
+namespace internal {
+
+struct PacketTypeDescr
+{
+ using Const = ConstPacket;
+ using NonConst = Packet;
+};
+
+template <>
+struct TypeDescr<Packet> : public PacketTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstPacket> : public PacketTypeDescr
+{
+};
+
+} /* namespace internal */
+
template <typename LibObjT>
nonstd::optional<ConstPacket> CommonEvent<LibObjT>::packet() const noexcept
{
using Stream = CommonStream<bt_stream>;
using ConstStream = CommonStream<const bt_stream>;
+namespace internal {
+
+struct StreamTypeDescr
+{
+ using Const = ConstStream;
+ using NonConst = Stream;
+};
+
+template <>
+struct TypeDescr<Stream> : public StreamTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstStream> : public StreamTypeDescr
+{
+};
+
+} /* namespace internal */
+
template <typename LibObjT>
ConstStream CommonEvent<LibObjT>::stream() const noexcept
{
using Trace = CommonTrace<bt_trace>;
using ConstTrace = CommonTrace<const bt_trace>;
+namespace internal {
+
+struct TraceTypeDescr
+{
+ using Const = ConstTrace;
+ using NonConst = Trace;
+};
+
+template <>
+struct TypeDescr<Trace> : public TraceTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstTrace> : public TraceTypeDescr
+{
+};
+
+} /* namespace internal */
+
template <typename LibObjT>
ConstTrace CommonStream<LibObjT>::trace() const noexcept
{
using EventClass = CommonEventClass<bt_event_class>;
using ConstEventClass = CommonEventClass<const bt_event_class>;
+namespace internal {
+
+struct EventClassTypeDescr
+{
+ using Const = ConstEventClass;
+ using NonConst = EventClass;
+};
+
+template <>
+struct TypeDescr<EventClass> : public EventClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstEventClass> : public EventClassTypeDescr
+{
+};
+
+} /* namespace internal */
+
template <typename LibObjT>
ConstEventClass CommonEvent<LibObjT>::cls() const noexcept
{
using StreamClass = CommonStreamClass<bt_stream_class>;
using ConstStreamClass = CommonStreamClass<const bt_stream_class>;
+namespace internal {
+
+struct StreamClassTypeDescr
+{
+ using Const = ConstStreamClass;
+ using NonConst = StreamClass;
+};
+
+template <>
+struct TypeDescr<StreamClass> : public StreamClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstStreamClass> : public StreamClassTypeDescr
+{
+};
+
+} /* namespace internal */
+
template <typename LibObjT>
ConstStreamClass CommonEventClass<LibObjT>::streamClass() const noexcept
{
using TraceClass = CommonTraceClass<bt_trace_class>;
using ConstTraceClass = CommonTraceClass<const bt_trace_class>;
+namespace internal {
+
+struct TraceClassTypeDescr
+{
+ using Const = ConstTraceClass;
+ using NonConst = TraceClass;
+};
+
+template <>
+struct TypeDescr<TraceClass> : public TraceClassTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstTraceClass> : public TraceClassTypeDescr
+{
+};
+
+} /* namespace internal */
+
template <typename LibObjT>
ConstTraceClass CommonStreamClass<LibObjT>::traceClass() const noexcept
{
--- /dev/null
+/*
+ * Copyright (c) 2020 Philippe Proulx <pproulx@efficios.com>
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#ifndef BABELTRACE_CPP_COMMON_BT2_TYPE_TRAITS_HPP
+#define BABELTRACE_CPP_COMMON_BT2_TYPE_TRAITS_HPP
+
+#include "internal/utils.hpp"
+
+namespace bt2 {
+
+template <typename ObjT>
+struct AddConst
+{
+ using Type = typename internal::TypeDescr<ObjT>::Const;
+};
+
+template <typename ObjT>
+struct RemoveConst
+{
+ using Type = typename internal::TypeDescr<ObjT>::NonConst;
+};
+
+} /* namespace bt2 */
+
+#endif /* BABELTRACE_CPP_COMMON_BT2_TYPE_TRAITS_HPP */
#include "lib-error.hpp"
namespace bt2 {
-
namespace internal {
struct ValueRefFuncs final
using Value = CommonValue<bt_value>;
using ConstValue = CommonValue<const bt_value>;
+namespace internal {
+
+struct ValueTypeDescr
+{
+ using Const = ConstValue;
+ using NonConst = Value;
+};
+
+template <>
+struct TypeDescr<Value> : public ValueTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstValue> : public ValueTypeDescr
+{
+};
+
+} /* namespace internal */
+
template <typename LibObjT>
class CommonNullValue final : public CommonValue<LibObjT>
{
using NullValue = CommonNullValue<bt_value>;
using ConstNullValue = CommonNullValue<const bt_value>;
+namespace internal {
+
+struct NullValueTypeDescr
+{
+ using Const = ConstNullValue;
+ using NonConst = NullValue;
+};
+
+template <>
+struct TypeDescr<NullValue> : public NullValueTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstNullValue> : public NullValueTypeDescr
+{
+};
+
+} /* namespace internal */
+
template <typename LibObjT>
class CommonBoolValue final : public CommonValue<LibObjT>
{
using BoolValue = CommonBoolValue<bt_value>;
using ConstBoolValue = CommonBoolValue<const bt_value>;
+namespace internal {
+
+struct BoolValueTypeDescr
+{
+ using Const = ConstBoolValue;
+ using NonConst = BoolValue;
+};
+
+template <>
+struct TypeDescr<BoolValue> : public BoolValueTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstBoolValue> : public BoolValueTypeDescr
+{
+};
+
+} /* namespace internal */
+
template <typename LibObjT>
class CommonUnsignedIntegerValue final : public CommonValue<LibObjT>
{
using UnsignedIntegerValue = CommonUnsignedIntegerValue<bt_value>;
using ConstUnsignedIntegerValue = CommonUnsignedIntegerValue<const bt_value>;
+namespace internal {
+
+struct UnsignedIntegerValueTypeDescr
+{
+ using Const = ConstUnsignedIntegerValue;
+ using NonConst = UnsignedIntegerValue;
+};
+
+template <>
+struct TypeDescr<UnsignedIntegerValue> : public UnsignedIntegerValueTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstUnsignedIntegerValue> : public UnsignedIntegerValueTypeDescr
+{
+};
+
+} /* namespace internal */
+
template <typename LibObjT>
class CommonSignedIntegerValue final : public CommonValue<LibObjT>
{
using SignedIntegerValue = CommonSignedIntegerValue<bt_value>;
using ConstSignedIntegerValue = CommonSignedIntegerValue<const bt_value>;
+namespace internal {
+
+struct SignedIntegerValueTypeDescr
+{
+ using Const = ConstSignedIntegerValue;
+ using NonConst = SignedIntegerValue;
+};
+
+template <>
+struct TypeDescr<SignedIntegerValue> : public SignedIntegerValueTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstSignedIntegerValue> : public SignedIntegerValueTypeDescr
+{
+};
+
+} /* namespace internal */
+
template <typename LibObjT>
class CommonRealValue final : public CommonValue<LibObjT>
{
using RealValue = CommonRealValue<bt_value>;
using ConstRealValue = CommonRealValue<const bt_value>;
+namespace internal {
+
+struct RealValueTypeDescr
+{
+ using Const = ConstRealValue;
+ using NonConst = RealValue;
+};
+
+template <>
+struct TypeDescr<RealValue> : public RealValueTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstRealValue> : public RealValueTypeDescr
+{
+};
+
+} /* namespace internal */
+
template <typename LibObjT>
class CommonStringValue final : public CommonValue<LibObjT>
{
namespace internal {
+struct StringValueTypeDescr
+{
+ using Const = ConstStringValue;
+ using NonConst = StringValue;
+};
+
+template <>
+struct TypeDescr<StringValue> : public StringValueTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstStringValue> : public StringValueTypeDescr
+{
+};
+
template <typename LibObjT>
struct CommonArrayValueSpec;
namespace internal {
+struct ArrayValueTypeDescr
+{
+ using Const = ConstArrayValue;
+ using NonConst = ArrayValue;
+};
+
+template <>
+struct TypeDescr<ArrayValue> : public ArrayValueTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstArrayValue> : public ArrayValueTypeDescr
+{
+};
+
/*
* Type of a user function passed to `CommonMapValue<ObjT>::forEach()`.
*
using MapValue = CommonMapValue<bt_value>;
using ConstMapValue = CommonMapValue<const bt_value>;
+namespace internal {
+
+struct MapValueTypeDescr
+{
+ using Const = ConstMapValue;
+ using NonConst = MapValue;
+};
+
+template <>
+struct TypeDescr<MapValue> : public MapValueTypeDescr
+{
+};
+
+template <>
+struct TypeDescr<ConstMapValue> : public MapValueTypeDescr
+{
+};
+
+} /* namespace internal */
+
template <typename LibObjT>
CommonNullValue<LibObjT> CommonValue<LibObjT>::asNull() const noexcept
{