typedef unsigned long long uint64_t;
typedef long long int64_t;
typedef int bt_intern_str;
+typedef int64_t ssize_t;
/* =================================================================
PYTHON-COMPLEMENTS.H
struct bt_definition *field);
struct definition_sequence *_bt_python_get_sequence_from_def(
struct bt_definition *field);
+struct bt_declaration *_bt_python_get_array_element_declaration(
+ struct bt_declaration *field);
+struct bt_declaration *_bt_python_get_sequence_element_declaration(
+ struct bt_declaration *field);
+const char *_bt_python_get_array_string(struct bt_definition *field);
+const char *_bt_python_get_sequence_string(struct bt_definition *field);
int _bt_python_field_integer_get_signedness(const struct bt_ctf_field *field);
enum ctf_type_id _bt_python_get_field_type(const struct bt_ctf_field *field);
+struct bt_iter_pos *_bt_python_create_iter_pos(void);
+struct bt_ctf_iter *_bt_python_ctf_iter_create_intersect(
+ struct bt_context *ctx,
+ struct bt_iter_pos *inter_begin_pos,
+ struct bt_iter_pos *inter_end_pos);
+int _bt_python_has_intersection(struct bt_context *ctx);
/* =================================================================
CONTEXT.H, CONTEXT-INTERNAL.H
The TraceCollection is the object that contains all currently opened traces.
"""
- def __init__(self):
+ def __init__(self, intersect_mode=False):
self._tc = _bt_context_create()
+ self.intersect_mode = intersect_mode
def __del__(self):
_bt_context_put(self._tc)
"""
Generator function to iterate over the events of open in the current
TraceCollection.
+
+ Due to limitations of the native Babeltrace API, only one event
+ may be "alive" at a time (i.e. a user should never store a copy
+ of the events returned by this function for ulterior use). Users
+ shall make sure to copy the information they need from an event
+ before accessing the next one.
+
+ Furthermore, event objects become invalid when the generator goes
+ out of scope as the underlying iterator will be reclaimed. Using an
+ event after the the generator has gone out of scope may result in a
+ crash or data corruption.
"""
- begin_pos_ptr = _bt_iter_pos()
- end_pos_ptr = _bt_iter_pos()
- begin_pos_ptr.type = SEEK_BEGIN
- end_pos_ptr.type = SEEK_LAST
+ begin_pos_ptr = _bt_python_create_iter_pos()
+ end_pos_ptr = _bt_python_create_iter_pos()
+ if not self.intersection_mode:
+ begin_pos_ptr.type = SEEK_BEGIN
+ end_pos_ptr.type = SEEK_LAST
for event in self._events(begin_pos_ptr, end_pos_ptr):
yield event
+ _bt_iter_free_pos(begin_pos_ptr)
+ _bt_iter_free_pos(end_pos_ptr)
+
def events_timestamps(self, timestamp_begin, timestamp_end):
"""
Generator function to iterate over the events of open in the current
TraceCollection from timestamp_begin to timestamp_end.
"""
- begin_pos_ptr = _bt_iter_pos()
- end_pos_ptr = _bt_iter_pos()
+ begin_pos_ptr = _bt_python_create_iter_pos()
+ end_pos_ptr = _bt_python_create_iter_pos()
begin_pos_ptr.type = end_pos_ptr.type = SEEK_TIME
begin_pos_ptr.u.seek_time = timestamp_begin
end_pos_ptr.u.seek_time = timestamp_end
for event in self._events(begin_pos_ptr, end_pos_ptr):
yield event
+ _bt_iter_free_pos(begin_pos_ptr)
+ _bt_iter_free_pos(end_pos_ptr)
+
@property
def timestamp_begin(self):
pos_ptr = _bt_iter_pos()
ev_ptr = _bt_ctf_iter_read_event(ctf_it_ptr)
_bt_ctf_iter_destroy(ctf_it_ptr)
if ev_ptr is None:
- return None;
+ return None
+ ev = Event.__new__(Event)
+ ev._e = ev_ptr
+ return ev.timestamp
def _events(self, begin_pos_ptr, end_pos_ptr):
- ctf_it_ptr = _bt_ctf_iter_create(self._tc, begin_pos_ptr, end_pos_ptr)
+ if self.intersect_mode:
+ has_intersection = _bt_python_has_intersection(self._tc)
+ if not has_intersection:
+ # There are no events to provide.
+ return
+
+ ctf_it_ptr = _bt_python_ctf_iter_create_intersect(
+ self._tc, begin_pos_ptr, end_pos_ptr
+ )
+ else:
+ ctf_it_ptr = _bt_ctf_iter_create(
+ self._tc, begin_pos_ptr, end_pos_ptr
+ )
+
if ctf_it_ptr is None:
raise NotImplementedError(
"Creation of multiple iterators is unsupported.")
%pythoncode%{
-# Based on enum bt_clock_type in clock-type.h
+# Based on enum bt_clock_type in clock-type.h
class ClockType:
CLOCK_CYCLES = 0
CLOCK_REAL = 1
def _field_list_with_scope(self, scope):
fields = []
scope_ptr = _bt_ctf_get_top_level_scope(self._e, scope)
-
+
# Returns a list [list_ptr, count]. If list_ptr is NULL, SWIG will only
# provide the "count" return value
count = 0
"""
return _bt_ctf_get_array_len(self._fd)
+ @property
+ def element_declaration(self):
+ """
+ Return element declaration.
+ """
+ field_decl_ptr = _bt_python_get_array_element_declaration(self._fd)
+ return _create_field_declaration(field_decl_ptr, "", self.scope)
+
class SequenceFieldDeclaration(FieldDeclaration):
"""Do not instantiate."""
def __init__(self):
raise NotImplementedError("SequenceFieldDeclaration cannot be instantiated")
+ @property
+ def element_declaration(self):
+ """
+ Return element declaration.
+ """
+ field_decl_ptr = _bt_python_get_sequence_element_declaration(self._fd)
+ return _create_field_declaration(field_decl_ptr, "", self.scope)
+
class FloatFieldDeclaration(FieldDeclaration):
"""Do not instantiate."""
def __init__(self):
"""Return the name of a field or None on error."""
return _bt_ctf_field_name(self._d)
- @property
+ @property
def type(self):
"""Return the type of a field or -1 if unknown."""
return _bt_ctf_field_type(_bt_ctf_get_decl_from_def(self._d))
"""
id = self.type
value = None
+
if id == CTFTypeId.STRING:
value = self._get_str()
elif id == CTFTypeId.ARRAY:
- value = []
- for i in range(self.declaration.length):
- element = self._get_array_element_at(i)
- value.append(element.value)
+ element_decl = self.declaration.element_declaration
+ if ((element_decl.type == CTFTypeId.INTEGER
+ and element_decl.length == 8)
+ and (element_decl.encoding == CTFStringEncoding.ASCII or element_decl.encoding == CTFStringEncoding.UTF8)):
+ value = _bt_python_get_array_string(self._d)
+ else:
+ value = []
+ for i in range(self.declaration.length):
+ element = self._get_array_element_at(i)
+ value.append(element.value)
elif id == CTFTypeId.INTEGER:
if self.declaration.signedness == 0:
value = self._get_uint64()
elif id == CTFTypeId.ENUM:
value = self._get_enum_str()
elif id == CTFTypeId.SEQUENCE:
- seq_len = self._get_sequence_len()
- value = []
- for i in range(seq_len):
- evDef = self._get_sequence_element_at(i)
- value.append(evDef.value)
+ element_decl = self.declaration.element_declaration
+ if ((element_decl.type == CTFTypeId.INTEGER
+ and element_decl.length == 8)
+ and (element_decl.encoding == CTFStringEncoding.ASCII or element_decl.encoding == CTFStringEncoding.UTF8)):
+ value = _bt_python_get_sequence_string(self._d)
+ else:
+ seq_len = self._get_sequence_len()
+ value = []
+ for i in range(seq_len):
+ evDef = self._get_sequence_element_at(i)
+ value.append(evDef.value)
elif id == CTFTypeId.FLOAT:
value = self._get_float()
elif id == CTFTypeId.VARIANT:
value[member.name] = member.value
if field_error():
- raise FieldError("Error occurred while accessing field {} of type {}".format(self.name, CTFTypeId.type_name(self.declaration.type)))
+ raise FieldError("Error occurred while accessing field {} of type {}".format(self.name, CTFTypeId.type_name(id)))
return value
@property
def __del__(self):
_bt_ctf_clock_put(self._c)
+ """
+ Get the clock's description.
+ """
+ @property
+ def description(self):
+ raise NotImplementedError("Getter not implemented.")
+
"""
Set the clock's description. The description appears in the clock's TSDL
meta-data.
"""
- def set_description(self, desc):
- ret = _bt_ctf_clock_set_description(self._c, desc)
+ @description.setter
+ def description(self, desc):
+ ret = _bt_ctf_clock_set_description(self._c, str(desc))
if ret < 0:
raise ValueError("Invalid clock description.")
+ """
+ Get the clock's frequency (Hz).
+ """
+ @property
+ def frequency(self):
+ raise NotImplementedError("Getter not implemented.")
+
"""
Set the clock's frequency (Hz).
"""
- def set_frequency(self, freq):
+ @frequency.setter
+ def frequency(self, freq):
ret = _bt_ctf_clock_set_frequency(self._c, freq)
if ret < 0:
raise ValueError("Invalid frequency value.")
+ """
+ Get the clock's precision (in clock ticks).
+ """
+ @property
+ def precision(self):
+ raise NotImplementedError("Getter not implemented.")
+
"""
Set the clock's precision (in clock ticks).
"""
- def set_precision(self, precision):
+ @precision.setter
+ def precision(self, precision):
ret = _bt_ctf_clock_set_precision(self._c, precision)
+ """
+ Get the clock's offset in seconds from POSIX.1 Epoch.
+ """
+ @property
+ def offset_seconds(self):
+ raise NotImplementedError("Getter not implemented.")
+
"""
Set the clock's offset in seconds from POSIX.1 Epoch.
"""
- def set_offset_seconds(self, offset_s):
+ @offset_seconds.setter
+ def offset_seconds(self, offset_s):
ret = _bt_ctf_clock_set_offset_s(self._c, offset_s)
if ret < 0:
raise ValueError("Invalid offset value.")
+ """
+ Get the clock's offset in ticks from POSIX.1 Epoch + offset in seconds.
+ """
+ @property
+ def offset(self):
+ raise NotImplementedError("Getter not implemented.")
+
"""
Set the clock's offset in ticks from POSIX.1 Epoch + offset in seconds.
"""
- def set_offset_seconds(self, offset):
+ @offset.setter
+ def offset(self, offset):
ret = _bt_ctf_clock_set_offset(self._c, offset)
if ret < 0:
raise ValueError("Invalid offset value.")
+ """
+ Get a clock's absolute attribute. A clock is absolute if the clock
+ is a global reference across the trace's other clocks.
+ """
+ @property
+ def absolute(self):
+ raise NotImplementedError("Getter not implemented.")
+
"""
Set a clock's absolute attribute. A clock is absolute if the clock
is a global reference across the trace's other clocks.
"""
- def set_is_absolute(self, is_absolute):
- ret = _bt_ctf_clock_set_is_absolute(self._c, is_absolute)
+ @absolute.setter
+ def absolute(self, is_absolute):
+ ret = _bt_ctf_clock_set_is_absolute(self._c, int(is_absolute))
if ret < 0:
raise ValueError("Could not set the clock's absolute attribute.")
+ """
+ Get the current time in nanoseconds since the clock's origin (offset and
+ offset_s attributes).
+ """
+ @property
+ def time(self):
+ raise NotImplementedError("Getter not implemented.")
+
"""
Set the current time in nanoseconds since the clock's origin (offset and
offset_s attributes). The clock's value will be sampled as events are
appended to a stream.
"""
- def set_time(self, time):
+ @time.setter
+ def time(self, time):
ret = _bt_ctf_clock_set_time(self._c, time)
if ret < 0:
raise ValueError("Invalid time value.")
- class FieldType:
+ class FieldDeclaration:
"""
- FieldType should not be instantiated directly. Please instantiate
- one of the concrete FieldType classes.
+ FieldDeclaration should not be instantiated directly. Please instantiate
+ one of the concrete FieldDeclaration classes.
"""
class IntegerBase:
# These values are based on the bt_ctf_integer_base enum
def __init__(self):
if self._ft is None:
- raise ValueError("FieldType creation failed.")
+ raise ValueError("FieldDeclaration creation failed.")
def __del__(self):
_bt_ctf_field_type_put(self._ft)
+ """
+ Get the field type's alignment.
+ """
+ @property
+ def alignment(self):
+ raise NotImplementedError("Getter not implemented.")
+
"""
Set the field type's alignment. Defaults to 1 (bit-aligned). However,
some types, such as structures and string, may impose other alignment
constraints.
"""
- def set_alignment(self, alignment):
+ @alignment.setter
+ def alignment(self, alignment):
ret = _bt_ctf_field_type_set_alignment(self._ft, alignment)
if ret < 0:
raise ValueError("Invalid alignment value.")
+ """
+ Get the field type's byte order. One of the ByteOrder's constant.
+ """
+ @property
+ def byte_order(self):
+ raise NotImplementedError("Getter not implemented.")
+
"""
Set the field type's byte order. Use constants defined in the ByteOrder
class.
"""
- def set_byte_order(self, byte_order):
+ @byte_order.setter
+ def byte_order(self, byte_order):
ret = _bt_ctf_field_type_set_byte_order(self._ft, byte_order)
if ret < 0:
raise ValueError("Could not set byte order value.")
- class FieldTypeInteger(FieldType):
+ class IntegerFieldDeclaration(FieldDeclaration):
"""
Create a new integer field type of the given size.
"""
super().__init__()
"""
- Set an integer type's signedness attribute.
+ Get an integer's signedness attribute.
+ """
+ @property
+ def signed(self):
+ raise NotImplementedError("Getter not implemented.")
+
"""
- def set_signed(self, signed):
+ Set an integer's signedness attribute.
+ """
+ @signed.setter
+ def signed(self, signed):
ret = _bt_ctf_field_type_integer_set_signed(self._ft, signed)
if ret < 0:
raise ValueError("Could not set signed attribute.")
"""
- Set the integer type's base used to pretty-print the resulting trace.
+ Get the integer's base used to pretty-print the resulting trace.
+ """
+ @property
+ def base(self):
+ raise NotImplementedError("Getter not implemented.")
+
+ """
+ Set the integer's base used to pretty-print the resulting trace.
The base must be a constant of the IntegerBase class.
"""
- def set_base(self, base):
+ @base.setter
+ def base(self, base):
ret = _bt_ctf_field_type_integer_set_base(self._ft, base)
if ret < 0:
raise ValueError("Could not set base value.")
+ """
+ Get the integer's encoding (one of the constants of the
+ CTFStringEncoding class).
+ """
+ @property
+ def encoding(self):
+ raise NotImplementedError("Getter not implemented.")
+
"""
An integer encoding may be set to signal that the integer must be printed
as a text character. Must be a constant from the CTFStringEncoding class.
"""
- def set_encoding(self, encoding):
+ @encoding.setter
+ def encoding(self, encoding):
ret = _bt_ctf_field_type_integer_set_encoding(self._ft, encoding)
if ret < 0:
raise ValueError("Could not set integer encoding.")
- class FieldTypeEnumeration(FieldType):
+ class EnumerationFieldDeclaration(FieldDeclaration):
"""
Create a new enumeration field type with the given underlying type.
"""
def __init__(self, integer_type):
- if integer_type is None or not isinstance(integer_type, CTFWriter.FieldTypeInteger):
+ if integer_type is None or not isinstance(integer_type, CTFWriter.IntegerFieldDeclaration):
raise TypeError("Invalid integer container.")
self._ft = _bt_ctf_field_type_enumeration_create(integer_type._ft)
Add a mapping to the enumeration. The range's values are inclusive.
"""
def add_mapping(self, name, range_start, range_end):
- ret = _bt_ctf_field_type_enumeration_add_mapping(self._ft, name, range_start, range_end)
+ ret = _bt_ctf_field_type_enumeration_add_mapping(self._ft, str(name), range_start, range_end)
if ret < 0:
raise ValueError("Could not add mapping to enumeration type.")
- class FieldTypeFloatingPoint(FieldType):
+ class FloatFieldDeclaration(FieldDeclaration):
FLT_EXP_DIG = 8
DBL_EXP_DIG = 11
FLT_MANT_DIG = 24
super().__init__()
"""
- Set the number of exponent digits to use to store the floatingpoint field.
+ Get the number of exponent digits to use to store the floating point field.
+ """
+ @property
+ def exponent_digits(self):
+ raise NotImplementedError("Getter not implemented.")
+
+ """
+ Set the number of exponent digits to use to store the floating point field.
The only values currently supported are FLT_EXP_DIG and DBL_EXP_DIG which
are defined as constants of this class.
"""
- def set_exponent_digits(self, exponent_digits):
+ @exponent_digits.setter
+ def exponent_digits(self, exponent_digits):
ret = _bt_ctf_field_type_floating_point_set_exponent_digits(self._ft, exponent_digits)
if ret < 0:
raise ValueError("Could not set exponent digit count.")
"""
- Set the numberof mantissa digits to use to store the floatingpoint field.
+ Get the number of mantissa digits to use to store the floating point field.
+ """
+ @property
+ def mantissa_digits(self):
+ raise NotImplementedError("Getter not implemented.")
+
+ """
+ Set the number of mantissa digits to use to store the floating point field.
The only values currently supported are FLT_MANT_DIG and DBL_MANT_DIG which
are defined as constants of this class.
"""
- def set_mantissa_digits(self, mantissa_digits):
+ @mantissa_digits.setter
+ def mantissa_digits(self, mantissa_digits):
ret = _bt_ctf_field_type_floating_point_set_mantissa_digits(self._ft, mantissa_digits)
if ret < 0:
raise ValueError("Could not set mantissa digit count.")
- class FieldTypeStructure(FieldType):
+ class StructureFieldDeclaration(FieldDeclaration):
"""
Create a new structure field type.
"""
Add a field of type "field_type" to the structure.
"""
def add_field(self, field_type, field_name):
- ret = _bt_ctf_field_type_structure_add_field(self._ft, field_type._ft, field_name)
+ ret = _bt_ctf_field_type_structure_add_field(self._ft, field_type._ft, str(field_name))
if ret < 0:
raise ValueError("Could not add field to structure.")
- class FieldTypeVariant(FieldType):
+ class VariantFieldDeclaration(FieldDeclaration):
"""
Create a new variant field type.
"""
def __init__(self, enum_tag, tag_name):
- if enum_tag is None or not isinstance(enum_tag, CTFWriter.FieldTypeEnumeration):
- raise TypeError("Invalid tag type; must be of type FieldTypeEnumeration.")
+ if enum_tag is None or not isinstance(enum_tag, CTFWriter.EnumerationFieldDeclaration):
+ raise TypeError("Invalid tag type; must be of type EnumerationFieldDeclaration.")
- self._ft = _bt_ctf_field_type_variant_create(enum_tag._ft, tag_name)
+ self._ft = _bt_ctf_field_type_variant_create(enum_tag._ft, str(tag_name))
super().__init__()
"""
Add a field of type "field_type" to the variant.
"""
def add_field(self, field_type, field_name):
- ret = _bt_ctf_field_type_variant_add_field(self._ft, field_type._ft, field_name)
+ ret = _bt_ctf_field_type_variant_add_field(self._ft, field_type._ft, str(field_name))
if ret < 0:
raise ValueError("Could not add field to variant.")
- class FieldTypeArray(FieldType):
+ class ArrayFieldDeclaration(FieldDeclaration):
"""
Create a new array field type.
"""
self._ft = _bt_ctf_field_type_array_create(element_type._ft, length)
super().__init__()
- class FieldTypeSequence(FieldType):
+ class SequenceFieldDeclaration(FieldDeclaration):
"""
Create a new sequence field type.
"""
def __init__(self, element_type, length_field_name):
- self._ft = _bt_ctf_field_type_sequence_create(element_type._ft, length_field_name)
+ self._ft = _bt_ctf_field_type_sequence_create(element_type._ft, str(length_field_name))
super().__init__()
- class FieldTypeString(FieldType):
+ class StringFieldDeclaration(FieldDeclaration):
"""
Create a new string field type.
"""
self._ft = _bt_ctf_field_type_string_create()
super().__init__()
+ """
+ Get a string type's encoding (a constant from the CTFStringEncoding class).
+ """
+ @property
+ def encoding(self):
+ raise NotImplementedError("Getter not implemented.")
+
"""
Set a string type's encoding. Must be a constant from the CTFStringEncoding class.
"""
- def set_encoding(self, encoding):
+ @encoding.setter
+ def encoding(self, encoding):
ret = _bt_ctf_field_type_string_set_encoding(self._ft, encoding)
if ret < 0:
raise ValueError("Could not set string encoding.")
"""
@staticmethod
def create_field(self, field_type):
- if field_type is None or not isinstance(field_type, CTFWriter.FieldType):
- raise TypeError("Invalid field_type. Type must be a FieldType-derived class.")
-
- if isinstance(field_type, CTFWriter.FieldTypeInteger):
- return CTFWriter.FieldInteger(field_type)
- elif isinstance(field_type, CTFWriter.FieldTypeEnumeration):
- return CTFWriter.FieldEnumeration(field_type)
- elif isinstance(field_type, CTFWriter.FieldTypeFloatingPoint):
- return CTFWriter.FieldFloatingPoint(field_type)
- elif isinstance(field_type, CTFWriter.FieldTypeStructure):
- return CTFWriter.FieldStructure(field_type)
- elif isinstance(field_type, CTFWriter.FieldTypeVariant):
- return CTFWriter.FieldVariant(field_type)
- elif isinstance(field_type, CTFWriter.FieldTypeArray):
- return CTFWriter.FieldArray(field_type)
- elif isinstance(field_type, CTFWriter.FieldTypeSequence):
- return CTFWriter.FieldSequence(field_type)
- elif isinstance(field_type, CTFWriter.FieldTypeString):
- return CTFWriter.FieldString(field_type)
+ if field_type is None or not isinstance(field_type, CTFWriter.FieldDeclaration):
+ raise TypeError("Invalid field_type. Type must be a FieldDeclaration-derived class.")
+
+ if isinstance(field_type, CTFWriter.IntegerFieldDeclaration):
+ return CTFWriter.IntegerField(field_type)
+ elif isinstance(field_type, CTFWriter.EnumerationFieldDeclaration):
+ return CTFWriter.EnumerationField(field_type)
+ elif isinstance(field_type, CTFWriter.FloatFieldDeclaration):
+ return CTFWriter.FloatFieldingPoint(field_type)
+ elif isinstance(field_type, CTFWriter.StructureFieldDeclaration):
+ return CTFWriter.StructureField(field_type)
+ elif isinstance(field_type, CTFWriter.VariantFieldDeclaration):
+ return CTFWriter.VariantField(field_type)
+ elif isinstance(field_type, CTFWriter.ArrayFieldDeclaration):
+ return CTFWriter.ArrayField(field_type)
+ elif isinstance(field_type, CTFWriter.SequenceFieldDeclaration):
+ return CTFWriter.SequenceField(field_type)
+ elif isinstance(field_type, CTFWriter.StringFieldDeclaration):
+ return CTFWriter.StringField(field_type)
class Field:
"""
Base class, do not instantiate.
"""
def __init__(self, field_type):
- if not isinstance(field_type, CTFWriter.FieldType):
+ if not isinstance(field_type, CTFWriter.FieldDeclaration):
raise TypeError("Invalid field_type argument.")
self._f = _bt_ctf_field_create(field_type._ft)
@staticmethod
def _create_field_from_native_instance(native_field_instance):
type_dict = {
- CTFTypeId.INTEGER : CTFWriter.FieldInteger,
- CTFTypeId.FLOAT : CTFWriter.FieldFloatingPoint,
- CTFTypeId.ENUM : CTFWriter.FieldEnumeration,
- CTFTypeId.STRING : CTFWriter.FieldString,
- CTFTypeId.STRUCT : CTFWriter.FieldStructure,
- CTFTypeId.VARIANT : CTFWriter.FieldVariant,
- CTFTypeId.ARRAY : CTFWriter.FieldArray,
- CTFTypeId.SEQUENCE : CTFWriter.FieldSequence
+ CTFTypeId.INTEGER : CTFWriter.IntegerField,
+ CTFTypeId.FLOAT : CTFWriter.FloatFieldingPoint,
+ CTFTypeId.ENUM : CTFWriter.EnumerationField,
+ CTFTypeId.STRING : CTFWriter.StringField,
+ CTFTypeId.STRUCT : CTFWriter.StructureField,
+ CTFTypeId.VARIANT : CTFWriter.VariantField,
+ CTFTypeId.ARRAY : CTFWriter.ArrayField,
+ CTFTypeId.SEQUENCE : CTFWriter.SequenceField
}
field_type = _bt_python_get_field_type(native_field_instance)
field.__class__ = type_dict[field_type]
return field
- class FieldInteger(Field):
+ class IntegerField(Field):
+ """
+ Get an integer field's value.
+ """
+ @property
+ def value(self):
+ raise NotImplementedError("Getter not implemented.")
+
"""
Set an integer field's value.
"""
- def set_value(self, value):
+ @value.setter
+ def value(self, value):
signedness = _bt_python_field_integer_get_signedness(self._f)
if signedness < 0:
raise TypeError("Invalid integer instance.")
if ret < 0:
raise ValueError("Could not set integer field value.")
- class FieldEnumeration(Field):
+ class EnumerationField(Field):
"""
Return the enumeration's underlying container field (an integer field).
"""
- def get_container(self):
- container = CTFWriter.FieldInteger.__new__(CTFWriter.FieldInteger)
+ @property
+ def container(self):
+ container = CTFWriter.IntegerField.__new__(CTFWriter.IntegerField)
container._f = _bt_ctf_field_enumeration_get_container(self._f)
if container._f is None:
raise TypeError("Invalid enumeration field type.")
return container
- class FieldFloatingPoint(Field):
+ class FloatFieldingPoint(Field):
+ """
+ Get a floating point field's value.
+ """
+ @property
+ def value(self):
+ raise NotImplementedError("Getter not implemented.")
+
"""
Set a floating point field's value.
"""
- def set_value(self, value):
- ret = _bt_ctf_field_floating_point_set_value(self._f, value)
+ @value.setter
+ def value(self, value):
+ ret = _bt_ctf_field_floating_point_set_value(self._f, float(value))
if ret < 0:
raise ValueError("Could not set floating point field value.")
- class FieldStructure(Field):
+ class StructureField(Field):
"""
Get the structure's field corresponding to the provided field name.
"""
- def get_field(self, field_name):
- native_instance = _bt_ctf_field_structure_get_field(self._f, field_name)
+ def field(self, field_name):
+ native_instance = _bt_ctf_field_structure_get_field(self._f, str(field_name))
if native_instance is None:
raise ValueError("Invalid field_name provided.")
return CTFWriter.Field._create_field_from_native_instance(native_instance)
- class FieldVariant(Field):
+ class VariantField(Field):
"""
Return the variant's selected field. The "tag" field is the selector enum field.
"""
- def get_field(self, tag):
+ def field(self, tag):
native_instance = _bt_ctf_field_variant_get_field(self._f, tag._f)
if native_instance is None:
raise ValueError("Invalid tag provided.")
return CTFWriter.Field._create_field_from_native_instance(native_instance)
- class FieldArray(Field):
+ class ArrayField(Field):
"""
Return the array's field at position "index".
"""
- def get_field(self, index):
+ def field(self, index):
native_instance = _bt_ctf_field_array_get_field(self._f, index)
if native_instance is None:
raise IndexError("Invalid index provided.")
return CTFWriter.Field._create_field_from_native_instance(native_instance)
- class FieldSequence(Field):
+ class SequenceField(Field):
+ """
+ Get the sequence's length field (IntegerField).
+ """
+ @property
+ def length(self):
+ raise NotImplementedError("Getter not implemented.")
+
"""
Set the sequence's length field (IntegerField).
"""
- def set_length(self, length):
- if not isinstance(length, CTFWriter.FieldInteger):
+ @length.setter
+ def length(self, length_field):
+ if not isinstance(length_field, CTFWriter.IntegerField):
raise TypeError("Invalid length field.")
- ret = _bt_ctf_field_sequence_set_length(self._f, length._f)
+ ret = _bt_ctf_field_sequence_set_length(self._f, length_field._f)
if ret < 0:
raise ValueError("Could not set sequence length.")
"""
Return the sequence's field at position "index".
"""
- def get_field(self, index):
+ def field(self, index):
native_instance = _bt_ctf_field_sequence_get_field(self._f, index)
if native_instance is None:
raise ValueError("Could not get sequence element at index.")
return CTFWriter.Field._create_field_from_native_instance(native_instance)
- class FieldString(Field):
+ class StringField(Field):
+ """
+ Get a string field's value.
+ """
+ @property
+ def value(self):
+ raise NotImplementedError("Getter not implemented.")
+
"""
Set a string field's value.
"""
- def set_value(self, value):
- ret = _bt_ctf_field_string_set_value(self._f, value)
+ @value.setter
+ def value(self, value):
+ ret = _bt_ctf_field_string_set_value(self._f, str(value))
if ret < 0:
raise ValueError("Could not set string field value.")
Add a field of type "field_type" to the event class.
"""
def add_field(self, field_type, field_name):
- ret = _bt_ctf_event_class_add_field(self._ec, field_type._ft, field_name)
+ ret = _bt_ctf_event_class_add_field(self._ec, field_type._ft, str(field_name))
if ret < 0:
raise ValueError("Could not add field to event class.")
"""
Set a manually created field as an event's payload.
"""
- def set_payload(self, field_name, value):
+ def set_payload(self, field_name, value_field):
if not isinstance(value, CTFWriter.Field):
raise TypeError("Invalid value type.")
- ret = _bt_ctf_event_set_payload(self._e, field_name, value._f)
+ ret = _bt_ctf_event_set_payload(self._e, str(field_name), value_field._f)
if ret < 0:
raise ValueError("Could not set event field payload.")
"""
- Set a manually created field as an event's payload.
+ Get a field from event.
"""
- def get_payload(self, field_name):
- native_instance = _bt_ctf_event_get_payload(self._e, field_name)
+ def payload(self, field_name):
+ native_instance = _bt_ctf_event_get_payload(self._e, str(field_name))
if native_instance is None:
raise ValueError("Could not get event payload.")
return CTFWriter.Field._create_field_from_native_instance(native_instance)
def __del__(self):
_bt_ctf_stream_class_put(self._sc)
+ """
+ Get a stream class' clock.
+ """
+ @property
+ def clock(self):
+ raise NotImplementedError("Getter not implemented.")
+
"""
Assign a clock to a stream class.
"""
- def set_clock(self, clock):
+ @clock.setter
+ def clock(self, clock):
if not isinstance(clock, CTFWriter.Clock):
raise TypeError("Invalid clock type.")
"""
Add an event class to a stream class. New events can be added even after a
- stream has beem instanciated and events have been appended. However, a stream
+ stream has been instantiated and events have been appended. However, a stream
will not accept events of a class that has not been registered beforehand.
"""
def add_event_class(self, event_class):
Increase the current packet's discarded event count.
"""
def append_discarded_events(self, event_count):
- ret = _bt_ctf_stream_append_discarded_events(self._s, event_count)
- if ret < 0:
- raise ValueError("Could not append discarded events.")
+ _bt_ctf_stream_append_discarded_events(self._s, event_count)
"""
Append "event" to the stream's current packet. The stream's associated clock
Add an environment field to the trace.
"""
def add_environment_field(self, name, value):
- ret = _bt_ctf_writer_add_environment_field(self._w, name, value)
+ ret = _bt_ctf_writer_add_environment_field(self._w, str(name), str(value))
if ret < 0:
raise ValueError("Could not add environment field to trace.")
"""
Get the trace's TSDL meta-data.
"""
- def get_metadata(self):
+ @property
+ def metadata(self):
return _bt_ctf_writer_get_metadata_string(self._w)
"""
def flush_metadata(self):
_bt_ctf_writer_flush_metadata(self._w)
+ """
+ Get the trace's byte order. Must be a constant from the ByteOrder
+ class.
+ """
+ @property
+ def byte_order(self):
+ raise NotImplementedError("Getter not implemented.")
+
"""
Set the trace's byte order. Must be a constant from the ByteOrder
class. Defaults to BYTE_ORDER_NATIVE, the host machine's endianness.
"""
- def set_byte_order(self, byte_order):
+ @byte_order.setter
+ def byte_order(self, byte_order):
ret = _bt_ctf_writer_set_byte_order(self._w, byte_order)
if ret < 0:
raise ValueError("Could not set trace's byte order.")