X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=bindings%2Fpython%2Fbabeltrace.i.in;h=724ed45d7e5d76351cdf905ca75e2690b57c9253;hb=feb06edba3d4101e55c570e72a93adbf1525d8b0;hp=294177fa5920f76c47e85b2747f9e7b5afaa781f;hpb=5792eb34cf619c28d52da0c55f1053ddcda7cf5e;p=babeltrace.git diff --git a/bindings/python/babeltrace.i.in b/bindings/python/babeltrace.i.in index 294177fa..724ed45d 100644 --- a/bindings/python/babeltrace.i.in +++ b/bindings/python/babeltrace.i.in @@ -33,6 +33,7 @@ trace to it." %module(docstring=DOCSTRING) babeltrace +%include "stdint.i" %include "typemaps.i" %{ #define SWIG_FILE_WITH_INIT @@ -57,8 +58,6 @@ trace to it." #include %} -typedef unsigned long long uint64_t; -typedef long long int64_t; typedef int bt_intern_str; typedef int64_t ssize_t; @@ -67,8 +66,6 @@ typedef int64_t ssize_t; ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ */ -FILE *_bt_file_open(char *file_path, char *mode); -void _bt_file_close(FILE *fp); struct bt_definition **_bt_python_field_listcaller( const struct bt_ctf_event *ctf_event, const struct bt_definition *scope, @@ -93,9 +90,30 @@ 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); +const char *_bt_python_ctf_field_type_enumeration_get_mapping( + struct bt_ctf_field_type *enumeration, size_t index, + int64_t *OUTPUT, int64_t *OUTPUT); +const char *_bt_python_ctf_field_type_enumeration_get_mapping_unsigned( + struct bt_ctf_field_type *enumeration, size_t index, + uint64_t *OUTPUT, uint64_t *OUTPUT); +const char *_bt_python_ctf_field_type_structure_get_field_name( + struct bt_ctf_field_type *structure, size_t index); +struct bt_ctf_field_type *_bt_python_ctf_field_type_structure_get_field_type( + struct bt_ctf_field_type *structure, size_t index); +const char *_bt_python_ctf_field_type_variant_get_field_name( + struct bt_ctf_field_type *variant, size_t index); +struct bt_ctf_field_type *_bt_python_ctf_field_type_variant_get_field_type( + struct bt_ctf_field_type *variant, size_t index); +const char *_bt_python_ctf_event_class_get_field_name( + struct bt_ctf_event_class *event_class, size_t index); +struct bt_ctf_field_type *_bt_python_ctf_event_class_get_field_type( + struct bt_ctf_event_class *event_class, size_t index); /* ================================================================= CONTEXT.H, CONTEXT-INTERNAL.H @@ -208,6 +226,17 @@ class TraceCollection: """ 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() @@ -390,7 +419,7 @@ int bt_ctf_event_get_handle_id(const struct bt_ctf_event *event); %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 @@ -509,6 +538,8 @@ struct bt_ctf_event *bt_ctf_iter_read_event(struct bt_ctf_iter *iter); %rename("_bt_ctf_field_get_error") bt_ctf_field_get_error(void); %rename("_bt_ctf_get_decl_event_name") bt_ctf_get_decl_event_name(const struct bt_ctf_event_decl *event); +%rename("_bt_ctf_get_decl_event_id") bt_ctf_get_decl_event_id(const struct + bt_ctf_event_decl *event); %rename("_bt_ctf_get_decl_field_name") bt_ctf_get_decl_field_name( const struct bt_ctf_field_decl *field); %rename("_bt_ctf_get_decl_from_def") bt_ctf_get_decl_from_def( @@ -551,6 +582,7 @@ double bt_ctf_get_float(const struct bt_definition *field); const struct bt_definition *bt_ctf_get_variant(const struct bt_definition *field); int bt_ctf_field_get_error(void); const char *bt_ctf_get_decl_event_name(const struct bt_ctf_event_decl *event); +uint64_t bt_ctf_get_decl_event_id(const struct bt_ctf_event_decl *event); const char *bt_ctf_get_decl_field_name(const struct bt_ctf_field_decl *field); const struct bt_declaration *bt_ctf_get_decl_from_def(const struct bt_definition *field); const struct bt_declaration *bt_ctf_get_decl_from_field_decl(const struct bt_ctf_field_decl *field); @@ -590,7 +622,6 @@ class CTFTypeId: ARRAY = 8 SEQUENCE = 9 NR_CTF_TYPES = 10 - def type_name(id): name = "UNKNOWN_TYPE" constants = [attr for attr in dir(CTFTypeId) if not callable(getattr(CTFTypeId, attr)) and not attr.startswith("__")] @@ -622,6 +653,7 @@ _scopes = [CTFScope.EVENT_FIELDS, CTFScope.EVENT_CONTEXT, CTFScope.STREAM_EVENT_ CTFScope.STREAM_EVENT_HEADER, CTFScope.STREAM_PACKET_CONTEXT, CTFScope.TRACE_PACKET_HEADER] import collections +from datetime import datetime class Event(collections.Mapping): """ This class represents an event from the trace. @@ -652,6 +684,15 @@ class Event(collections.Mapping): """ return _bt_ctf_get_timestamp(self._e) + @property + def datetime(self): + """ + Return a datetime object based on the event's + timestamp. Note that the datetime class' precision + is limited to microseconds. + """ + return datetime.fromtimestamp(self.timestamp / 1E9) + def field_with_scope(self, field_name, scope): """ Get field_name's value in scope. @@ -779,7 +820,7 @@ class Event(collections.Mapping): 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 @@ -804,6 +845,7 @@ class FieldError(Exception): class EventDeclaration(object): """Event declaration class. Do not instantiate.""" + MAX_UINT64 = 0xFFFFFFFFFFFFFFFF def __init__(self): raise NotImplementedError("EventDeclaration cannot be instantiated") @@ -813,6 +855,14 @@ class EventDeclaration(object): """Return the name of the event or None on error""" return _bt_ctf_get_decl_event_name(self._ed) + @property + def id(self): + """Return the event-ID of the event or -1 on error""" + id = _bt_ctf_get_decl_event_id(self._ed) + if id == self.MAX_UINT64: + id = -1 + return id + @property def fields(self): """ @@ -952,6 +1002,14 @@ class SequenceFieldDeclaration(FieldDeclaration): 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): @@ -1179,11 +1237,17 @@ class _Definition(object): 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: @@ -1217,23 +1281,39 @@ class _Definition(object): ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ */ %rename("_bt_ctf_clock_create") bt_ctf_clock_create(const char *name); +%rename("_bt_ctf_clock_get_name") bt_ctf_clock_get_name(struct bt_ctf_clock *clock); +%rename("_bt_ctf_clock_get_description") bt_ctf_clock_get_description(struct bt_ctf_clock *clock); %rename("_bt_ctf_clock_set_description") bt_ctf_clock_set_description(struct bt_ctf_clock *clock, const char *desc); +%rename("_bt_ctf_clock_get_frequency") bt_ctf_clock_get_frequency(struct bt_ctf_clock *clock); %rename("_bt_ctf_clock_set_frequency") bt_ctf_clock_set_frequency(struct bt_ctf_clock *clock, uint64_t freq); +%rename("_bt_ctf_clock_get_precision") bt_ctf_clock_get_precision(struct bt_ctf_clock *clock); %rename("_bt_ctf_clock_set_precision") bt_ctf_clock_set_precision(struct bt_ctf_clock *clock, uint64_t precision); +%rename("_bt_ctf_clock_get_offset_s") bt_ctf_clock_get_offset_s(struct bt_ctf_clock *clock); %rename("_bt_ctf_clock_set_offset_s") bt_ctf_clock_set_offset_s(struct bt_ctf_clock *clock, uint64_t offset_s); +%rename("_bt_ctf_clock_get_offset") bt_ctf_clock_get_offset(struct bt_ctf_clock *clock); %rename("_bt_ctf_clock_set_offset") bt_ctf_clock_set_offset(struct bt_ctf_clock *clock, uint64_t offset); +%rename("_bt_ctf_clock_get_is_absolute") bt_ctf_clock_get_is_absolute(struct bt_ctf_clock *clock); %rename("_bt_ctf_clock_set_is_absolute") bt_ctf_clock_set_is_absolute(struct bt_ctf_clock *clock, int is_absolute); +%rename("_bt_ctf_clock_get_time") bt_ctf_clock_get_time(struct bt_ctf_clock *clock); %rename("_bt_ctf_clock_set_time") bt_ctf_clock_set_time(struct bt_ctf_clock *clock, uint64_t time); %rename("_bt_ctf_clock_get") bt_ctf_clock_get(struct bt_ctf_clock *clock); %rename("_bt_ctf_clock_put") bt_ctf_clock_put(struct bt_ctf_clock *clock); struct bt_ctf_clock *bt_ctf_clock_create(const char *name); +const char *bt_ctf_clock_get_name(struct bt_ctf_clock *clock); +const char *bt_ctf_clock_get_description(struct bt_ctf_clock *clock); int bt_ctf_clock_set_description(struct bt_ctf_clock *clock, const char *desc); +uint64_t bt_ctf_clock_get_frequency(struct bt_ctf_clock *clock); int bt_ctf_clock_set_frequency(struct bt_ctf_clock *clock, uint64_t freq); +uint64_t bt_ctf_clock_get_precision(struct bt_ctf_clock *clock); int bt_ctf_clock_set_precision(struct bt_ctf_clock *clock, uint64_t precision); +uint64_t bt_ctf_clock_get_offset_s(struct bt_ctf_clock *clock); int bt_ctf_clock_set_offset_s(struct bt_ctf_clock *clock, uint64_t offset_s); +uint64_t bt_ctf_clock_get_offset(struct bt_ctf_clock *clock); int bt_ctf_clock_set_offset(struct bt_ctf_clock *clock, uint64_t offset); +int bt_ctf_clock_get_is_absolute(struct bt_ctf_clock *clock); int bt_ctf_clock_set_is_absolute(struct bt_ctf_clock *clock, int is_absolute); +uint64_t bt_ctf_clock_get_time(struct bt_ctf_clock *clock); int bt_ctf_clock_set_time(struct bt_ctf_clock *clock, uint64_t time); void bt_ctf_clock_get(struct bt_ctf_clock *clock); void bt_ctf_clock_put(struct bt_ctf_clock *clock); @@ -1243,46 +1323,108 @@ void bt_ctf_clock_put(struct bt_ctf_clock *clock); ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ */ %rename("_bt_ctf_field_type_integer_create") bt_ctf_field_type_integer_create(unsigned int size); +%rename("_bt_ctf_field_type_integer_get_size") bt_ctf_field_type_integer_get_size(struct bt_ctf_field_type *integer); +%rename("_bt_ctf_field_type_integer_get_signed") bt_ctf_field_type_integer_get_signed(struct bt_ctf_field_type *integer); %rename("_bt_ctf_field_type_integer_set_signed") bt_ctf_field_type_integer_set_signed(struct bt_ctf_field_type *integer, int is_signed); +%rename("_bt_ctf_field_type_integer_get_base") bt_ctf_field_type_integer_get_base(struct bt_ctf_field_type *integer); %rename("_bt_ctf_field_type_integer_set_base") bt_ctf_field_type_integer_set_base(struct bt_ctf_field_type *integer, enum bt_ctf_integer_base base); +%rename("_bt_ctf_field_type_integer_get_encoding") bt_ctf_field_type_integer_get_encoding(struct bt_ctf_field_type *integer); %rename("_bt_ctf_field_type_integer_set_encoding") bt_ctf_field_type_integer_set_encoding(struct bt_ctf_field_type *integer, enum ctf_string_encoding encoding); %rename("_bt_ctf_field_type_enumeration_create") bt_ctf_field_type_enumeration_create(struct bt_ctf_field_type *integer_container_type); -%rename("_bt_ctf_field_type_enumeration_add_mapping") bt_ctf_field_type_enumeration_add_mapping(struct bt_ctf_field_type *enumeration, const char *string, int64_t range_start, int64_t range_end); +%rename("_bt_ctf_field_type_enumeration_get_container_type") bt_ctf_field_type_enumeration_get_container_type(struct bt_ctf_field_type *enumeration); +%rename("_bt_ctf_field_type_enumeration_add_mapping") bt_ctf_field_type_enumeration_add_mapping(struct bt_ctf_field_type *enumeration, const char *name, int64_t range_start, int64_t range_end); +%rename("_bt_ctf_field_type_enumeration_add_mapping_unsigned") bt_ctf_field_type_enumeration_add_mapping_unsigned(struct bt_ctf_field_type *enumeration, const char *name, uint64_t range_start, uint64_t range_end); +%rename("_bt_ctf_field_type_enumeration_get_mapping_count") bt_ctf_field_type_enumeration_get_mapping_count(struct bt_ctf_field_type *enumeration); +%rename("_bt_ctf_field_type_enumeration_get_mapping") bt_ctf_field_type_enumeration_get_mapping(struct bt_ctf_field_type *enumeration, size_t index, const char **name, int64_t *range_start, int64_t *range_end); +%rename("_bt_ctf_field_type_enumeration_get_mapping_unsigned") bt_ctf_field_type_enumeration_get_mapping_unsigned(struct bt_ctf_field_type *enumeration, size_t index, const char **name, uint64_t *range_start, uint64_t *range_end); +%rename("_bt_ctf_field_type_enumeration_get_mapping_index_by_name") bt_ctf_field_type_enumeration_get_mapping_index_by_name(struct bt_ctf_field_type *enumeration, const char *name, size_t *index); +%rename("_bt_ctf_field_type_enumeration_get_mapping_index_by_value") bt_ctf_field_type_enumeration_get_mapping_index_by_value(struct bt_ctf_field_type *enumeration, int64_t value, size_t *index); +%rename("_bt_ctf_field_type_enumeration_get_mapping_index_by_unsigned_value") bt_ctf_field_type_enumeration_get_mapping_index_by_unsigned_value(struct bt_ctf_field_type *enumeration, uint64_t value, size_t *index); %rename("_bt_ctf_field_type_floating_point_create") bt_ctf_field_type_floating_point_create(void); +%rename("_bt_ctf_field_type_floating_point_get_exponent_digits") bt_ctf_field_type_floating_point_get_exponent_digits(struct bt_ctf_field_type *floating_point); %rename("_bt_ctf_field_type_floating_point_set_exponent_digits") bt_ctf_field_type_floating_point_set_exponent_digits(struct bt_ctf_field_type *floating_point, unsigned int exponent_digits); +%rename("_bt_ctf_field_type_floating_point_get_mantissa_digits") bt_ctf_field_type_floating_point_get_mantissa_digits(struct bt_ctf_field_type *floating_point); %rename("_bt_ctf_field_type_floating_point_set_mantissa_digits") bt_ctf_field_type_floating_point_set_mantissa_digits(struct bt_ctf_field_type *floating_point, unsigned int mantissa_digits); %rename("_bt_ctf_field_type_structure_create") bt_ctf_field_type_structure_create(void); %rename("_bt_ctf_field_type_structure_add_field") bt_ctf_field_type_structure_add_field(struct bt_ctf_field_type *structure, struct bt_ctf_field_type *field_type, const char *field_name); +%rename("_bt_ctf_field_type_structure_get_field_count") bt_ctf_field_type_structure_get_field_count(struct bt_ctf_field_type *structure); +%rename("_bt_ctf_field_type_structure_get_field") bt_ctf_field_type_structure_get_field(struct bt_ctf_field_type *structure, const char **field_name, struct bt_ctf_field_type **field_type, size_t index); +%rename("_bt_ctf_field_type_structure_get_field_type_by_name") bt_ctf_field_type_structure_get_field_type_by_name(struct bt_ctf_field_type *structure, const char *field_name); %rename("_bt_ctf_field_type_variant_create") bt_ctf_field_type_variant_create(struct bt_ctf_field_type *enum_tag, const char *tag_name); +%rename("_bt_ctf_field_type_variant_get_tag_type") bt_ctf_field_type_variant_get_tag_type(struct bt_ctf_field_type *variant); +%rename("_bt_ctf_field_type_variant_get_tag_name") bt_ctf_field_type_variant_get_tag_name(struct bt_ctf_field_type *variant); %rename("_bt_ctf_field_type_variant_add_field") bt_ctf_field_type_variant_add_field(struct bt_ctf_field_type *variant, struct bt_ctf_field_type *field_type, const char *field_name); +%rename("_bt_ctf_field_type_variant_get_field_type_by_name") bt_ctf_field_type_variant_get_field_type_by_name(struct bt_ctf_field_type *variant, const char *field_name); +%rename("_bt_ctf_field_type_variant_get_field_type_from_tag") bt_ctf_field_type_variant_get_field_type_from_tag(struct bt_ctf_field_type *variant, struct bt_ctf_field *tag); +%rename("_bt_ctf_field_type_variant_get_field_count") bt_ctf_field_type_variant_get_field_count(struct bt_ctf_field_type *variant); +%rename("_bt_ctf_field_type_variant_get_field") bt_ctf_field_type_variant_get_field(struct bt_ctf_field_type *variant, const char **field_name, struct bt_ctf_field_type **field_type, size_t index); %rename("_bt_ctf_field_type_array_create") bt_ctf_field_type_array_create(struct bt_ctf_field_type *element_type, unsigned int length); +%rename("_bt_ctf_field_type_array_get_element_type") bt_ctf_field_type_array_get_element_type(struct bt_ctf_field_type *array); +%rename("_bt_ctf_field_type_array_get_length") bt_ctf_field_type_array_get_length(struct bt_ctf_field_type *array); %rename("_bt_ctf_field_type_sequence_create") bt_ctf_field_type_sequence_create(struct bt_ctf_field_type *element_type, const char *length_field_name); +%rename("_bt_ctf_field_type_sequence_get_element_type") bt_ctf_field_type_sequence_get_element_type(struct bt_ctf_field_type *sequence); +%rename("_bt_ctf_field_type_sequence_get_length_field_name") bt_ctf_field_type_sequence_get_length_field_name(struct bt_ctf_field_type *sequence); %rename("_bt_ctf_field_type_string_create") bt_ctf_field_type_string_create(void); -%rename("_bt_ctf_field_type_string_set_encoding") bt_ctf_field_type_string_set_encoding(struct bt_ctf_field_type *string, enum ctf_string_encoding encoding); +%rename("_bt_ctf_field_type_string_get_encoding") bt_ctf_field_type_string_get_encoding(struct bt_ctf_field_type *string_type); +%rename("_bt_ctf_field_type_string_set_encoding") bt_ctf_field_type_string_set_encoding(struct bt_ctf_field_type *string_type, enum ctf_string_encoding encoding); +%rename("_bt_ctf_field_type_get_alignment") bt_ctf_field_type_get_alignment(struct bt_ctf_field_type *type); %rename("_bt_ctf_field_type_set_alignment") bt_ctf_field_type_set_alignment(struct bt_ctf_field_type *type, unsigned int alignment); +%rename("_bt_ctf_field_type_get_byte_order") bt_ctf_field_type_get_byte_order(struct bt_ctf_field_type *type); %rename("_bt_ctf_field_type_set_byte_order") bt_ctf_field_type_set_byte_order(struct bt_ctf_field_type *type, enum bt_ctf_byte_order byte_order); +%rename("_bt_ctf_field_type_get_type_id") bt_ctf_field_type_get_type_id(struct bt_ctf_field_type *type); %rename("_bt_ctf_field_type_get") bt_ctf_field_type_get(struct bt_ctf_field_type *type); %rename("_bt_ctf_field_type_put") bt_ctf_field_type_put(struct bt_ctf_field_type *type); struct bt_ctf_field_type *bt_ctf_field_type_integer_create(unsigned int size); +int bt_ctf_field_type_integer_get_size(struct bt_ctf_field_type *integer); +int bt_ctf_field_type_integer_get_signed(struct bt_ctf_field_type *integer); int bt_ctf_field_type_integer_set_signed(struct bt_ctf_field_type *integer, int is_signed); +enum bt_ctf_integer_base bt_ctf_field_type_integer_get_base(struct bt_ctf_field_type *integer); int bt_ctf_field_type_integer_set_base(struct bt_ctf_field_type *integer, enum bt_ctf_integer_base base); +enum ctf_string_encoding bt_ctf_field_type_integer_get_encoding(struct bt_ctf_field_type *integer); int bt_ctf_field_type_integer_set_encoding(struct bt_ctf_field_type *integer, enum ctf_string_encoding encoding); struct bt_ctf_field_type *bt_ctf_field_type_enumeration_create(struct bt_ctf_field_type *integer_container_type); -int bt_ctf_field_type_enumeration_add_mapping(struct bt_ctf_field_type *enumeration, const char *string, int64_t range_start, int64_t range_end); +struct bt_ctf_field_type *bt_ctf_field_type_enumeration_get_container_type(struct bt_ctf_field_type *enumeration); +int bt_ctf_field_type_enumeration_add_mapping(struct bt_ctf_field_type *enumeration, const char *name, int64_t range_start, int64_t range_end); +int bt_ctf_field_type_enumeration_add_mapping_unsigned(struct bt_ctf_field_type *enumeration, const char *name, uint64_t range_start, uint64_t range_end); +int64_t bt_ctf_field_type_enumeration_get_mapping_count(struct bt_ctf_field_type *enumeration); +int bt_ctf_field_type_enumeration_get_mapping(struct bt_ctf_field_type *enumeration, size_t index, const char **OUTPUT, int64_t *OUTPUT, int64_t *OUTPUT); +int bt_ctf_field_type_enumeration_get_mapping_unsigned(struct bt_ctf_field_type *enumeration, size_t index, const char **OUTPUT, uint64_t *OUTPUT, uint64_t *OUTPUT); +int bt_ctf_field_type_enumeration_get_mapping_index_by_name(struct bt_ctf_field_type *enumeration, const char *name, size_t *OUTPUT); +int bt_ctf_field_type_enumeration_get_mapping_index_by_value(struct bt_ctf_field_type *enumeration, int64_t value, size_t *OUTPUT); +int bt_ctf_field_type_enumeration_get_mapping_index_by_unsigned_value(struct bt_ctf_field_type *enumeration, uint64_t value, size_t *OUTPUT); struct bt_ctf_field_type *bt_ctf_field_type_floating_point_create(void); +int bt_ctf_field_type_floating_point_get_exponent_digits(struct bt_ctf_field_type *floating_point); int bt_ctf_field_type_floating_point_set_exponent_digits(struct bt_ctf_field_type *floating_point, unsigned int exponent_digits); +int bt_ctf_field_type_floating_point_get_mantissa_digits(struct bt_ctf_field_type *floating_point); int bt_ctf_field_type_floating_point_set_mantissa_digits(struct bt_ctf_field_type *floating_point, unsigned int mantissa_digits); struct bt_ctf_field_type *bt_ctf_field_type_structure_create(void); int bt_ctf_field_type_structure_add_field(struct bt_ctf_field_type *structure, struct bt_ctf_field_type *field_type, const char *field_name); +int64_t bt_ctf_field_type_structure_get_field_count(struct bt_ctf_field_type *structure); +int bt_ctf_field_type_structure_get_field(struct bt_ctf_field_type *structure, const char **OUTPUT, struct bt_ctf_field_type **OUTPUT, size_t index); +struct bt_ctf_field_type *bt_ctf_field_type_structure_get_field_type_by_name(struct bt_ctf_field_type *structure, const char *field_name); struct bt_ctf_field_type *bt_ctf_field_type_variant_create(struct bt_ctf_field_type *enum_tag, const char *tag_name); +struct bt_ctf_field_type *bt_ctf_field_type_variant_get_tag_type(struct bt_ctf_field_type *variant); +const char *bt_ctf_field_type_variant_get_tag_name(struct bt_ctf_field_type *variant); int bt_ctf_field_type_variant_add_field(struct bt_ctf_field_type *variant, struct bt_ctf_field_type *field_type, const char *field_name); +struct bt_ctf_field_type *bt_ctf_field_type_variant_get_field_type_by_name(struct bt_ctf_field_type *variant, const char *field_name); +struct bt_ctf_field_type *bt_ctf_field_type_variant_get_field_type_from_tag(struct bt_ctf_field_type *variant, struct bt_ctf_field *tag); +int64_t bt_ctf_field_type_variant_get_field_count(struct bt_ctf_field_type *variant); +int bt_ctf_field_type_variant_get_field(struct bt_ctf_field_type *variant, const char **OUTPUT, struct bt_ctf_field_type **OUTPUT, size_t index); struct bt_ctf_field_type *bt_ctf_field_type_array_create(struct bt_ctf_field_type *element_type, unsigned int length); +struct bt_ctf_field_type *bt_ctf_field_type_array_get_element_type(struct bt_ctf_field_type *array); +int64_t bt_ctf_field_type_array_get_length(struct bt_ctf_field_type *array); struct bt_ctf_field_type *bt_ctf_field_type_sequence_create(struct bt_ctf_field_type *element_type, const char *length_field_name); +struct bt_ctf_field_type *bt_ctf_field_type_sequence_get_element_type(struct bt_ctf_field_type *sequence); +const char *bt_ctf_field_type_sequence_get_length_field_name(struct bt_ctf_field_type *sequence); struct bt_ctf_field_type *bt_ctf_field_type_string_create(void); -int bt_ctf_field_type_string_set_encoding(struct bt_ctf_field_type *string, enum ctf_string_encoding encoding); +enum ctf_string_encoding bt_ctf_field_type_string_get_encoding(struct bt_ctf_field_type *string_type); +int bt_ctf_field_type_string_set_encoding(struct bt_ctf_field_type *string_type, enum ctf_string_encoding encoding); +int bt_ctf_field_type_get_alignment(struct bt_ctf_field_type *type); int bt_ctf_field_type_set_alignment(struct bt_ctf_field_type *type, unsigned int alignment); +enum bt_ctf_byte_order bt_ctf_field_type_get_byte_order(struct bt_ctf_field_type *type); int bt_ctf_field_type_set_byte_order(struct bt_ctf_field_type *type, enum bt_ctf_byte_order byte_order); +enum ctf_type_id bt_ctf_field_type_get_type_id(struct bt_ctf_field_type *type); void bt_ctf_field_type_get(struct bt_ctf_field_type *type); void bt_ctf_field_type_put(struct bt_ctf_field_type *type); @@ -1293,28 +1435,42 @@ void bt_ctf_field_type_put(struct bt_ctf_field_type *type); %rename("_bt_ctf_field_create") bt_ctf_field_create(struct bt_ctf_field_type *type); %rename("_bt_ctf_field_structure_get_field") bt_ctf_field_structure_get_field(struct bt_ctf_field *structure, const char *name); %rename("_bt_ctf_field_array_get_field") bt_ctf_field_array_get_field(struct bt_ctf_field *array, uint64_t index); +%rename("_bt_ctf_field_sequence_get_length") bt_ctf_field_sequence_get_length(struct bt_ctf_field *sequence); %rename("_bt_ctf_field_sequence_set_length") bt_ctf_field_sequence_set_length(struct bt_ctf_field *sequence, struct bt_ctf_field *length_field); %rename("_bt_ctf_field_sequence_get_field") bt_ctf_field_sequence_get_field(struct bt_ctf_field *sequence, uint64_t index); %rename("_bt_ctf_field_variant_get_field") bt_ctf_field_variant_get_field(struct bt_ctf_field *variant, struct bt_ctf_field *tag); %rename("_bt_ctf_field_enumeration_get_container") bt_ctf_field_enumeration_get_container(struct bt_ctf_field *enumeration); +%rename("_bt_ctf_field_enumeration_get_mapping_name") bt_ctf_field_enumeration_get_mapping_name(struct bt_ctf_field *enumeration); +%rename("_bt_ctf_field_signed_integer_get_value") bt_ctf_field_signed_integer_get_value(struct bt_ctf_field *integer, int64_t *value); %rename("_bt_ctf_field_signed_integer_set_value") bt_ctf_field_signed_integer_set_value(struct bt_ctf_field *integer, int64_t value); +%rename("_bt_ctf_field_unsigned_integer_get_value") bt_ctf_field_unsigned_integer_get_value(struct bt_ctf_field *integer, uint64_t *value); %rename("_bt_ctf_field_unsigned_integer_set_value") bt_ctf_field_unsigned_integer_set_value(struct bt_ctf_field *integer, uint64_t value); +%rename("_bt_ctf_field_floating_point_get_value") bt_ctf_field_floating_point_get_value(struct bt_ctf_field *floating_point, double *value); %rename("_bt_ctf_field_floating_point_set_value") bt_ctf_field_floating_point_set_value(struct bt_ctf_field *floating_point, double value); -%rename("_bt_ctf_field_string_set_value") bt_ctf_field_string_set_value(struct bt_ctf_field *string, const char *value); +%rename("_bt_ctf_field_string_get_value") bt_ctf_field_string_get_value(struct bt_ctf_field *string_field); +%rename("_bt_ctf_field_string_set_value") bt_ctf_field_string_set_value(struct bt_ctf_field *string_field, const char *value); +%rename("_bt_ctf_field_get_type") bt_ctf_field_get_type(struct bt_ctf_field *field); %rename("_bt_ctf_field_get") bt_ctf_field_get(struct bt_ctf_field *field); %rename("_bt_ctf_field_put") bt_ctf_field_put(struct bt_ctf_field *field); struct bt_ctf_field *bt_ctf_field_create(struct bt_ctf_field_type *type); struct bt_ctf_field *bt_ctf_field_structure_get_field(struct bt_ctf_field *structure, const char *name); struct bt_ctf_field *bt_ctf_field_array_get_field(struct bt_ctf_field *array, uint64_t index); +struct bt_ctf_field * bt_ctf_field_sequence_get_length(struct bt_ctf_field *sequence); int bt_ctf_field_sequence_set_length(struct bt_ctf_field *sequence, struct bt_ctf_field *length_field); struct bt_ctf_field *bt_ctf_field_sequence_get_field(struct bt_ctf_field *sequence, uint64_t index); struct bt_ctf_field *bt_ctf_field_variant_get_field(struct bt_ctf_field *variant, struct bt_ctf_field *tag); struct bt_ctf_field *bt_ctf_field_enumeration_get_container(struct bt_ctf_field *enumeration); +const char *bt_ctf_field_enumeration_get_mapping_name(struct bt_ctf_field *enumeration); +int bt_ctf_field_signed_integer_get_value(struct bt_ctf_field *integer, int64_t *OUTPUT); int bt_ctf_field_signed_integer_set_value(struct bt_ctf_field *integer, int64_t value); +int bt_ctf_field_unsigned_integer_get_value(struct bt_ctf_field *integer, uint64_t *OUTPUT); int bt_ctf_field_unsigned_integer_set_value(struct bt_ctf_field *integer, uint64_t value); +int bt_ctf_field_floating_point_get_value(struct bt_ctf_field *floating_point, double *OUTPUT); int bt_ctf_field_floating_point_set_value(struct bt_ctf_field *floating_point, double value); -int bt_ctf_field_string_set_value(struct bt_ctf_field *string, const char *value); +const char *bt_ctf_field_string_get_value(struct bt_ctf_field *string_field); +int bt_ctf_field_string_set_value(struct bt_ctf_field *string_field, const char *value); +struct bt_ctf_field_type *bt_ctf_field_get_type(struct bt_ctf_field *field); void bt_ctf_field_get(struct bt_ctf_field *field); void bt_ctf_field_put(struct bt_ctf_field *field); @@ -1323,22 +1479,42 @@ void bt_ctf_field_put(struct bt_ctf_field *field); ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ */ %rename("_bt_ctf_event_class_create") bt_ctf_event_class_create(const char *name); +%rename("_bt_ctf_event_class_get_name") bt_ctf_event_class_get_name(struct bt_ctf_event_class *event_class); +%rename("_bt_ctf_event_class_get_id") bt_ctf_event_class_get_id(struct bt_ctf_event_class *event_class); +%rename("_bt_ctf_event_class_set_id") bt_ctf_event_class_set_id(struct bt_ctf_event_class *event_class, uint32_t id); +%rename("_bt_ctf_event_class_get_stream_class") bt_ctf_event_class_get_stream_class(struct bt_ctf_event_class *event_class); %rename("_bt_ctf_event_class_add_field") bt_ctf_event_class_add_field(struct bt_ctf_event_class *event_class, struct bt_ctf_field_type *type, const char *name); +%rename("_bt_ctf_event_class_get_field_count") bt_ctf_event_class_get_field_count(struct bt_ctf_event_class *event_class); +%rename("_bt_ctf_event_class_get_field") bt_ctf_event_class_get_field(struct bt_ctf_event_class *event_class, const char **field_name, struct bt_ctf_field_type **field_type, size_t index); +%rename("_bt_ctf_event_class_get_field_by_name") bt_ctf_event_class_get_field_by_name(struct bt_ctf_event_class *event_class, const char *name); %rename("_bt_ctf_event_class_get") bt_ctf_event_class_get(struct bt_ctf_event_class *event_class); %rename("_bt_ctf_event_class_put") bt_ctf_event_class_put(struct bt_ctf_event_class *event_class); %rename("_bt_ctf_event_create") bt_ctf_event_create(struct bt_ctf_event_class *event_class); -%rename("_bt_ctf_event_set_payload") bt_ctf_event_set_payload(struct bt_ctf_event *event, const char *name, struct bt_ctf_field *value); +%rename("_bt_ctf_event_get_class") bt_ctf_event_get_class(struct bt_ctf_event *event); +%rename("_bt_ctf_event_get_clock") bt_ctf_event_get_clock(struct bt_ctf_event *event); %rename("_bt_ctf_event_get_payload") bt_ctf_event_get_payload(struct bt_ctf_event *event, const char *name); +%rename("_bt_ctf_event_set_payload") bt_ctf_event_set_payload(struct bt_ctf_event *event, const char *name, struct bt_ctf_field *value); +%rename("_bt_ctf_event_get_payload_by_index") bt_ctf_event_get_payload_by_index(struct bt_ctf_event *event, size_t index); %rename("_bt_ctf_event_get") bt_ctf_event_get(struct bt_ctf_event *event); %rename("_bt_ctf_event_put") bt_ctf_event_put(struct bt_ctf_event *event); struct bt_ctf_event_class *bt_ctf_event_class_create(const char *name); +const char *bt_ctf_event_class_get_name(struct bt_ctf_event_class *event_class); +int64_t bt_ctf_event_class_get_id(struct bt_ctf_event_class *event_class); +int bt_ctf_event_class_set_id(struct bt_ctf_event_class *event_class, uint32_t id); +struct bt_ctf_stream_class *bt_ctf_event_class_get_stream_class(struct bt_ctf_event_class *event_class); int bt_ctf_event_class_add_field(struct bt_ctf_event_class *event_class, struct bt_ctf_field_type *type, const char *name); +int64_t bt_ctf_event_class_get_field_count(struct bt_ctf_event_class *event_class); +int bt_ctf_event_class_get_field(struct bt_ctf_event_class *event_class, const char **field_name, struct bt_ctf_field_type **field_type, size_t index); +struct bt_ctf_field_type *bt_ctf_event_class_get_field_by_name(struct bt_ctf_event_class *event_class, const char *name); void bt_ctf_event_class_get(struct bt_ctf_event_class *event_class); void bt_ctf_event_class_put(struct bt_ctf_event_class *event_class); struct bt_ctf_event *bt_ctf_event_create(struct bt_ctf_event_class *event_class); -int bt_ctf_event_set_payload(struct bt_ctf_event *event, const char *name, struct bt_ctf_field *value); +struct bt_ctf_event_class *bt_ctf_event_get_class(struct bt_ctf_event *event); +struct bt_ctf_clock *bt_ctf_event_get_clock(struct bt_ctf_event *event); struct bt_ctf_field *bt_ctf_event_get_payload(struct bt_ctf_event *event, const char *name); +int bt_ctf_event_set_payload(struct bt_ctf_event *event, const char *name, struct bt_ctf_field *value); +struct bt_ctf_field *bt_ctf_event_get_payload_by_index(struct bt_ctf_event *event, size_t index); void bt_ctf_event_get(struct bt_ctf_event *event); void bt_ctf_event_put(struct bt_ctf_event *event); @@ -1347,10 +1523,18 @@ void bt_ctf_event_put(struct bt_ctf_event *event); ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ */ %rename("_bt_ctf_stream_class_create") bt_ctf_stream_class_create(const char *name); +%rename("_bt_ctf_stream_class_get_name") bt_ctf_stream_class_get_name(struct bt_ctf_stream_class *stream_class); +%rename("_bt_ctf_stream_class_get_clock") bt_ctf_stream_class_get_clock(struct bt_ctf_stream_class *stream_class); %rename("_bt_ctf_stream_class_set_clock") bt_ctf_stream_class_set_clock(struct bt_ctf_stream_class *stream_class, struct bt_ctf_clock *clock); +%rename("_bt_ctf_stream_class_get_id") bt_ctf_stream_class_get_id(struct bt_ctf_stream_class *stream_class); +%rename("_bt_ctf_stream_class_set_id") bt_ctf_stream_class_set_id(struct bt_ctf_stream_class *stream_class, uint32_t id); %rename("_bt_ctf_stream_class_add_event_class") bt_ctf_stream_class_add_event_class(struct bt_ctf_stream_class *stream_class, struct bt_ctf_event_class *event_class); +%rename("_bt_ctf_stream_class_get_event_class_count") bt_ctf_stream_class_get_event_class_count(struct bt_ctf_stream_class *stream_class); +%rename("_bt_ctf_stream_class_get_event_class") bt_ctf_stream_class_get_event_class(struct bt_ctf_stream_class *stream_class, size_t index); +%rename("_bt_ctf_stream_class_get_event_class_by_name") bt_ctf_stream_class_get_event_class_by_name(struct bt_ctf_stream_class *stream_class, const char *name); %rename("_bt_ctf_stream_class_get") bt_ctf_stream_class_get(struct bt_ctf_stream_class *stream_class); %rename("_bt_ctf_stream_class_put") bt_ctf_stream_class_put(struct bt_ctf_stream_class *stream_class); +%rename("_bt_ctf_stream_get_discarded_events_count") bt_ctf_stream_get_discarded_events_count(struct bt_ctf_stream *stream, uint64_t *count); %rename("_bt_ctf_stream_append_discarded_events") bt_ctf_stream_append_discarded_events(struct bt_ctf_stream *stream, uint64_t event_count); %rename("_bt_ctf_stream_append_event") bt_ctf_stream_append_event(struct bt_ctf_stream *stream, struct bt_ctf_event *event); %rename("_bt_ctf_stream_flush") bt_ctf_stream_flush(struct bt_ctf_stream *stream); @@ -1358,10 +1542,18 @@ void bt_ctf_event_put(struct bt_ctf_event *event); %rename("_bt_ctf_stream_put") bt_ctf_stream_put(struct bt_ctf_stream *stream); struct bt_ctf_stream_class *bt_ctf_stream_class_create(const char *name); +const char *bt_ctf_stream_class_get_name(struct bt_ctf_stream_class *stream_class); +struct bt_ctf_clock *bt_ctf_stream_class_get_clock(struct bt_ctf_stream_class *stream_class); int bt_ctf_stream_class_set_clock(struct bt_ctf_stream_class *stream_class, struct bt_ctf_clock *clock); +int64_t bt_ctf_stream_class_get_id(struct bt_ctf_stream_class *stream_class); +int bt_ctf_stream_class_set_id(struct bt_ctf_stream_class *stream_class, uint32_t id); int bt_ctf_stream_class_add_event_class(struct bt_ctf_stream_class *stream_class, struct bt_ctf_event_class *event_class); +int64_t bt_ctf_stream_class_get_event_class_count(struct bt_ctf_stream_class *stream_class); +struct bt_ctf_event_class *bt_ctf_stream_class_get_event_class(struct bt_ctf_stream_class *stream_class, size_t index); +struct bt_ctf_event_class *bt_ctf_stream_class_get_event_class_by_name(struct bt_ctf_stream_class *stream_class, const char *name); void bt_ctf_stream_class_get(struct bt_ctf_stream_class *stream_class); void bt_ctf_stream_class_put(struct bt_ctf_stream_class *stream_class); +int bt_ctf_stream_get_discarded_events_count(struct bt_ctf_stream *stream, uint64_t *OUTPUT); void bt_ctf_stream_append_discarded_events(struct bt_ctf_stream *stream, uint64_t event_count); int bt_ctf_stream_append_event(struct bt_ctf_stream *stream, struct bt_ctf_event *event); int bt_ctf_stream_flush(struct bt_ctf_stream *stream); @@ -1396,6 +1588,17 @@ void bt_ctf_writer_put(struct bt_ctf_writer *writer); %pythoncode %{ class CTFWriter: + # Used to compare to -1ULL in error checks + _MAX_UINT64 = 0xFFFFFFFFFFFFFFFF + + """ + Enumeration mapping class. start and end values are inclusive. + """ + class EnumerationMapping: + def __init__(self, name, start, end): + self.name = name + self.start = start + self.end = end class Clock: def __init__(self, name): @@ -1407,11 +1610,21 @@ class CTFWriter: _bt_ctf_clock_put(self._c) """ - Get the clock's description. + Get the clock's name. + """ + @property + def name(self): + name = _bt_ctf_clock_get_name(self._c) + if name is None: + raise ValueError("Invalid clock instance.") + return name + + """ + Get the clock's description. None if unset. """ @property def description(self): - raise NotImplementedError("Getter not implemented.") + return _bt_ctf_clock_get_description(self._c) """ Set the clock's description. The description appears in the clock's TSDL @@ -1428,7 +1641,10 @@ class CTFWriter: """ @property def frequency(self): - raise NotImplementedError("Getter not implemented.") + freq = _bt_ctf_clock_get_frequency(self._c) + if freq == CTFWriter._MAX_UINT64: + raise ValueError("Invalid clock instance") + return freq """ Set the clock's frequency (Hz). @@ -1444,7 +1660,10 @@ class CTFWriter: """ @property def precision(self): - raise NotImplementedError("Getter not implemented.") + precision = _bt_ctf_clock_get_precision(self._c) + if precision == CTFWriter._MAX_UINT64: + raise ValueError("Invalid clock instance") + return precision """ Set the clock's precision (in clock ticks). @@ -1458,7 +1677,10 @@ class CTFWriter: """ @property def offset_seconds(self): - raise NotImplementedError("Getter not implemented.") + offset_s = _bt_ctf_clock_get_offset_s(self._c) + if offset_s == CTFWriter._MAX_UINT64: + raise ValueError("Invalid clock instance") + return offset_s """ Set the clock's offset in seconds from POSIX.1 Epoch. @@ -1474,7 +1696,10 @@ class CTFWriter: """ @property def offset(self): - raise NotImplementedError("Getter not implemented.") + offset = _bt_ctf_clock_get_offset(self._c) + if offset == CTFWriter._MAX_UINT64: + raise ValueError("Invalid clock instance") + return offset """ Set the clock's offset in ticks from POSIX.1 Epoch + offset in seconds. @@ -1491,7 +1716,10 @@ class CTFWriter: """ @property def absolute(self): - raise NotImplementedError("Getter not implemented.") + is_absolute = _bt_ctf_clock_get_is_absolute(self._c) + if is_absolute == -1: + raise ValueError("Invalid clock instance") + return False if is_absolute == 0 else True """ Set a clock's absolute attribute. A clock is absolute if the clock @@ -1509,7 +1737,10 @@ class CTFWriter: """ @property def time(self): - raise NotImplementedError("Getter not implemented.") + time = _bt_ctf_clock_get_time(self._c) + if time == CTFWriter._MAX_UINT64: + raise ValueError("Invalid clock instance") + return time """ Set the current time in nanoseconds since the clock's origin (offset and @@ -1524,7 +1755,7 @@ class CTFWriter: class FieldDeclaration: """ - FieldDeclaration should not be instantiated directly. Please instantiate + FieldDeclaration should not be instantiated directly. Instantiate one of the concrete FieldDeclaration classes. """ class IntegerBase: @@ -1543,15 +1774,37 @@ class CTFWriter: def __del__(self): _bt_ctf_field_type_put(self._ft) + @staticmethod + def _create_field_declaration_from_native_instance(native_field_declaration): + type_dict = { + CTFTypeId.INTEGER : CTFWriter.IntegerFieldDeclaration, + CTFTypeId.FLOAT : CTFWriter.FloatFieldDeclaration, + CTFTypeId.ENUM : CTFWriter.EnumerationFieldDeclaration, + CTFTypeId.STRING : CTFWriter.StringFieldDeclaration, + CTFTypeId.STRUCT : CTFWriter.StructureFieldDeclaration, + CTFTypeId.VARIANT : CTFWriter.VariantFieldDeclaration, + CTFTypeId.ARRAY : CTFWriter.ArrayFieldDeclaration, + CTFTypeId.SEQUENCE : CTFWriter.SequenceFieldDeclaration + } + + field_type_id = _bt_ctf_field_type_get_type_id(native_field_declaration) + if field_type_id == CTFTypeId.UNKNOWN: + raise TypeError("Invalid field instance") + + declaration = CTFWriter.Field.__new__(CTFWriter.Field) + declaration._ft = native_field_declaration + declaration.__class__ = type_dict[field_type_id] + return declaration + """ - Get the field type's alignment. + Get the field declaration's alignment. Returns -1 on error. """ @property def alignment(self): - raise NotImplementedError("Getter not implemented.") + return _bt_ctf_field_type_get_alignment(self._ft) """ - Set the field type's alignment. Defaults to 1 (bit-aligned). However, + Set the field declaration's alignment. Defaults to 1 (bit-aligned). However, some types, such as structures and string, may impose other alignment constraints. """ @@ -1562,14 +1815,14 @@ class CTFWriter: raise ValueError("Invalid alignment value.") """ - Get the field type's byte order. One of the ByteOrder's constant. + Get the field declaration's byte order. One of the ByteOrder's constant. """ @property def byte_order(self): - raise NotImplementedError("Getter not implemented.") + return _bt_ctf_field_type_get_byte_order(self._ft) """ - Set the field type's byte order. Use constants defined in the ByteOrder + Set the field declaration's byte order. Use constants defined in the ByteOrder class. """ @byte_order.setter @@ -1580,18 +1833,35 @@ class CTFWriter: class IntegerFieldDeclaration(FieldDeclaration): """ - Create a new integer field type of the given size. + Create a new integer field declaration of the given size. """ def __init__(self, size): self._ft = _bt_ctf_field_type_integer_create(size) super().__init__() + """ + Get an integer's size. + """ + @property + def size(self): + ret = _bt_ctf_field_type_integer_get_size(self._ft) + if ret < 0: + raise ValueError("Could not get Integer's size attribute.") + else: + return ret + """ Get an integer's signedness attribute. """ @property def signed(self): - raise NotImplementedError("Getter not implemented.") + ret = _bt_ctf_field_type_integer_get_signed(self._ft) + if ret < 0: + raise ValueError("Could not get Integer's signed attribute.") + elif ret > 0: + return True + else: + return False """ Set an integer's signedness attribute. @@ -1600,32 +1870,34 @@ class CTFWriter: 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.") + raise ValueError("Could not set Integer's signed attribute.") """ Get the integer's base used to pretty-print the resulting trace. + Returns a constant from the FieldDeclaration.IntegerBase class. """ @property def base(self): - raise NotImplementedError("Getter not implemented.") + return _bt_ctf_field_type_integer_get_base(self._ft) """ Set the integer's base used to pretty-print the resulting trace. - The base must be a constant of the IntegerBase class. + The base must be a constant of the FieldDeclarationIntegerBase class. """ @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.") + raise ValueError("Could not set Integer's base.") """ Get the integer's encoding (one of the constants of the CTFStringEncoding class). + Returns a constant from the CTFStringEncoding class. """ @property def encoding(self): - raise NotImplementedError("Getter not implemented.") + return _bt_ctf_field_type_integer_get_encoding(self._ft) """ An integer encoding may be set to signal that the integer must be printed @@ -1635,11 +1907,11 @@ class CTFWriter: 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.") + raise ValueError("Could not set Integer's encoding.") class EnumerationFieldDeclaration(FieldDeclaration): """ - Create a new enumeration field type with the given underlying type. + Create a new enumeration field declaration with the given underlying container type. """ def __init__(self, integer_type): if integer_type is None or not isinstance(integer_type, CTFWriter.IntegerFieldDeclaration): @@ -1648,13 +1920,86 @@ class CTFWriter: self._ft = _bt_ctf_field_type_enumeration_create(integer_type._ft) super().__init__() + """ + Get the enumeration's underlying container type. + """ + @property + def container(self): + ret = _bt_ctf_field_type_enumeration_get_container_type(self._ft) + if ret is None: + raise TypeError("Invalid enumeration declaration") + return CTFWriter.FieldDeclaration._create_field_declaration_from_native_instance(ret) + """ 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, str(name), range_start, range_end) + if range_start < 0 or range_end < 0: + ret = _bt_ctf_field_type_enumeration_add_mapping(self._ft, str(name), range_start, range_end) + else: + ret = _bt_ctf_field_type_enumeration_add_mapping_unsigned(self._ft, str(name), range_start, range_end) + + if ret < 0: + raise ValueError("Could not add mapping to enumeration declaration.") + + """ + Generator returning instances of EnumerationMapping. + """ + @property + def mappings(self): + signed = self.container.signed + + count = _bt_ctf_field_type_enumeration_get_mapping_count(self._ft) + for i in range(count): + if signed: + ret = _bt_python_ctf_field_type_enumeration_get_mapping(self._ft, i) + else: + ret = _bt_python_ctf_field_type_enumeration_get_mapping_unsigned(self._ft, i) + + if len(ret) != 3: + raise TypeError("Could not get Enumeration mapping at index {}".format(i)) + name, range_start, range_end = ret + yield CTFWriter.EnumerationMapping(name, range_start, range_end) + + """ + Get a mapping by name (EnumerationMapping). + """ + def get_mapping_by_name(self, name): + ret, index = _bt_ctf_field_type_enumeration_get_mapping_index_by_name(self._ft, name); + if ret < 0: + return None + + if self.container.signed: + ret = _bt_python_ctf_field_type_enumeration_get_mapping(self._ft, index) + else: + ret = _bt_python_ctf_field_type_enumeration_get_mapping_unsigned(self._ft, index) + + if len(ret) != 3: + raise TypeError("Could not get Enumeration mapping at index {}".format(i)) + name, range_start, range_end = ret + return CTFWriter.EnumerationMapping(name, range_start, range_end) + + """ + Get a mapping by value (EnumerationMapping). + """ + def get_mapping_by_value(self, value): + if value < 0: + ret, index = _bt_ctf_field_type_enumeration_get_mapping_index_by_value(self._ft, value); + else: + ret, index = _bt_ctf_field_type_enumeration_get_mapping_index_by_unsigned_value(self._ft, value); + if ret < 0: - raise ValueError("Could not add mapping to enumeration type.") + return None + + if self.container.signed: + ret = _bt_python_ctf_field_type_enumeration_get_mapping(self._ft, index) + else: + ret = _bt_python_ctf_field_type_enumeration_get_mapping_unsigned(self._ft, index) + + if len(ret) != 3: + raise TypeError("Could not get Enumeration mapping at index {}".format(i)) + name, range_start, range_end = ret + return CTFWriter.EnumerationMapping(name, range_start, range_end) class FloatFieldDeclaration(FieldDeclaration): FLT_EXP_DIG = 8 @@ -1663,18 +2008,21 @@ class CTFWriter: DBL_MANT_DIG = 53 """ - Create a new floating point field type. + Create a new floating point field declaration. """ def __init__(self): self._ft = _bt_ctf_field_type_floating_point_create() super().__init__() """ - Get the number of exponent digits to use to store the floating point field. + Get the number of exponent digits used to store the floating point field. """ @property def exponent_digits(self): - raise NotImplementedError("Getter not implemented.") + ret = _bt_ctf_field_type_floating_point_get_exponent_digits(self._ft) + if ret < 0: + raise TypeError("Could not get Floating point exponent digit count") + return ret """ Set the number of exponent digits to use to store the floating point field. @@ -1688,11 +2036,14 @@ class CTFWriter: raise ValueError("Could not set exponent digit count.") """ - Get the number of mantissa digits to use to store the floating point field. + Get the number of mantissa digits used to store the floating point field. """ @property def mantissa_digits(self): - raise NotImplementedError("Getter not implemented.") + ret = _bt_ctf_field_type_floating_point_get_mantissa_digits(self._ft) + if ret < 0: + raise TypeError("Could not get Floating point mantissa digit count") + return ret """ Set the number of mantissa digits to use to store the floating point field. @@ -1707,7 +2058,7 @@ class CTFWriter: class StructureFieldDeclaration(FieldDeclaration): """ - Create a new structure field type. + Create a new structure field declaration. """ def __init__(self): self._ft = _bt_ctf_field_type_structure_create() @@ -1721,9 +2072,40 @@ class CTFWriter: if ret < 0: raise ValueError("Could not add field to structure.") + """ + Generator returning the structure's field as tuples of (field name, field declaration). + """ + @property + def fields(self): + count = _bt_ctf_field_type_structure_get_field_count(self._ft) + if count < 0: + raise TypeError("Could not get Structure field count") + + for i in range(count): + field_name = _bt_python_ctf_field_type_structure_get_field_name(self._ft, i) + if field_name is None: + raise TypeError("Could not get Structure field name at index {}".format(i)) + + field_type_native = _bt_python_ctf_field_type_structure_get_field_type(self._ft, i) + if field_type_native is None: + raise TypeError("Could not get Structure field type at index {}".format(i)) + + field_type = CTFWriter.FieldDeclaration._create_field_declaration_from_native_instance(field_type_native) + yield (field_name, field_type) + + """ + Get a field declaration by name (FieldDeclaration). + """ + def get_field_by_name(self, name): + field_type_native = _bt_ctf_field_type_structure_get_field_type_by_name(self._ft, name) + if field_type_native is None: + raise TypeError("Could not find Structure field with name {}".format(name)) + + return CTFWriter.FieldDeclaration._create_field_declaration_from_native_instance(field_type_native) + class VariantFieldDeclaration(FieldDeclaration): """ - Create a new variant field type. + Create a new variant field declaration. """ def __init__(self, enum_tag, tag_name): if enum_tag is None or not isinstance(enum_tag, CTFWriter.EnumerationFieldDeclaration): @@ -1732,6 +2114,26 @@ class CTFWriter: self._ft = _bt_ctf_field_type_variant_create(enum_tag._ft, str(tag_name)) super().__init__() + """ + Get the variant's tag name. + """ + @property + def tag_name(self): + ret = _bt_ctf_field_type_variant_get_tag_name(self._ft) + if ret is None: + raise TypeError("Could not get Variant tag name") + return ret + + """ + Get the variant's tag type. + """ + @property + def tag_type(self): + ret = _bt_ctf_field_type_variant_get_tag_type(self._ft) + if ret is None: + raise TypeError("Could not get Variant tag type") + return CTFWriter.FieldDeclaration._create_field_declaration_from_native_instance(ret) + """ Add a field of type "field_type" to the variant. """ @@ -1740,39 +2142,120 @@ class CTFWriter: if ret < 0: raise ValueError("Could not add field to variant.") + """ + Generator returning the variant's field as tuples of (field name, field declaration). + """ + @property + def fields(self): + count = _bt_ctf_field_type_variant_get_field_count(self._ft) + if count < 0: + raise TypeError("Could not get Variant field count") + + for i in range(count): + field_name = _bt_python_ctf_field_type_variant_get_field_name(self._ft, i) + if field_name is None: + raise TypeError("Could not get Variant field name at index {}".format(i)) + + field_type_native = _bt_python_ctf_field_type_variant_get_field_type(self._ft, i) + if field_type_native is None: + raise TypeError("Could not get Variant field type at index {}".format(i)) + + field_type = CTFWriter.FieldDeclaration._create_field_declaration_from_native_instance(field_type_native) + yield (field_name, field_type) + + """ + Get a field declaration by name (FieldDeclaration). + """ + def get_field_by_name(self, name): + field_type_native = _bt_ctf_field_type_variant_get_field_type_by_name(self._ft, name) + if field_type_native is None: + raise TypeError("Could not find Variant field with name {}".format(name)) + + return CTFWriter.FieldDeclaration._create_field_declaration_from_native_instance(field_type_native) + + """ + Get a field declaration from tag (EnumerationField). + """ + def get_field_from_tag(self, tag): + field_type_native = _bt_ctf_field_type_variant_get_field_type_from_tag(self._ft, tag._f) + if field_type_native is None: + raise TypeError("Could not find Variant field with tag value {}".format(tag.value)) + + return CTFWriter.FieldDeclaration._create_field_declaration_from_native_instance(field_type_native) + class ArrayFieldDeclaration(FieldDeclaration): """ - Create a new array field type. + Create a new array field declaration. """ def __init__(self, element_type, length): self._ft = _bt_ctf_field_type_array_create(element_type._ft, length) super().__init__() + """ + Get the array's element type. + """ + @property + def element_type(self): + ret = _bt_ctf_field_type_array_get_element_type(self._ft) + if ret is None: + raise TypeError("Could not get Array element type") + return CTFWriter.FieldDeclaration._create_field_declaration_from_native_instance(ret) + + """ + Get the array's length. + """ + @property + def length(self): + ret = _bt_ctf_field_type_array_get_length(self._ft) + if ret < 0: + raise TypeError("Could not get Array length") + return ret + class SequenceFieldDeclaration(FieldDeclaration): """ - Create a new sequence field type. + Create a new sequence field declaration. """ def __init__(self, element_type, length_field_name): self._ft = _bt_ctf_field_type_sequence_create(element_type._ft, str(length_field_name)) super().__init__() + """ + Get the sequence's element type. + """ + @property + def element_type(self): + ret = _bt_ctf_field_type_sequence_get_element_type(self._ft) + if ret is None: + raise TypeError("Could not get Sequence element type") + return CTFWriter.FieldDeclaration._create_field_declaration_from_native_instance(ret) + + """ + Get the sequence's length field name. + """ + @property + def length_field_name(self): + ret = _bt_ctf_field_type_sequence_get_length_field_name(self._ft) + if ret is None: + raise TypeError("Could not get Sequence length field name") + return ret + class StringFieldDeclaration(FieldDeclaration): """ - Create a new string field type. + Create a new string field declaration. """ def __init__(self): self._ft = _bt_ctf_field_type_string_create() super().__init__() """ - Get a string type's encoding (a constant from the CTFStringEncoding class). + Get a string declaration's encoding (a constant from the CTFStringEncoding class). """ @property def encoding(self): - raise NotImplementedError("Getter not implemented.") + return _bt_ctf_field_type_string_get_encoding(self._ft) """ - Set a string type's encoding. Must be a constant from the CTFStringEncoding class. + Set a string declaration's encoding. Must be a constant from the CTFStringEncoding class. """ @encoding.setter def encoding(self, encoding): @@ -1784,7 +2267,7 @@ class CTFWriter: Create an instance of a field. """ @staticmethod - def create_field(self, field_type): + def create_field(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.") @@ -1842,19 +2325,40 @@ class CTFWriter: field.__class__ = type_dict[field_type] return field + @property + def declaration(self): + native_field_type = _bt_ctf_field_get_type(self._f) + if native_field_type is None: + raise TypeError("Invalid field instance") + return CTFWriter.FieldDeclaration._create_field_declaration_from_native_instance(native_field_type) + class IntegerField(Field): """ Get an integer field's value. """ @property def value(self): - raise NotImplementedError("Getter not implemented.") + signedness = _bt_python_field_integer_get_signedness(self._f) + if signedness < 0: + raise TypeError("Invalid integer instance.") + + if signedness == 0: + ret, value = _bt_ctf_field_unsigned_integer_get_value(self._f) + else: + ret, value = _bt_ctf_field_signed_integer_get_value(self._f) + + if ret < 0: + raise ValueError("Could not get integer field value.") + return value """ Set an integer field's value. """ @value.setter def value(self, value): + if not isinstance(value, int): + raise TypeError("IntegerField's value must be an int") + signedness = _bt_python_field_integer_get_signedness(self._f) if signedness < 0: raise TypeError("Invalid integer instance.") @@ -1879,19 +2383,45 @@ class CTFWriter: raise TypeError("Invalid enumeration field type.") return container + """ + Get the enumeration field's mapping name. + """ + @property + def value(self): + value = _bt_ctf_field_enumeration_get_mapping_name(self._f) + if value is None: + raise ValueError("Could not get enumeration's mapping name.") + return value + + """ + Set the enumeration field's value. Must be an integer as mapping names + may be ambiguous. + """ + @value.setter + def value(self, value): + if not isinstance(value, int): + raise TypeError("EnumerationField value must be an int") + self.container.value = value + class FloatFieldingPoint(Field): """ Get a floating point field's value. """ @property def value(self): - raise NotImplementedError("Getter not implemented.") + ret, value = _bt_ctf_field_floating_point_get_value(self._f) + if ret < 0: + raise ValueError("Could not get floating point field value.") + return value """ Set a floating point field's value. """ @value.setter def value(self, value): + if not isinstance(value, int) and not isinstance(value, float): + raise TypeError("Value must be either a float or an int") + ret = _bt_ctf_field_floating_point_set_value(self._f, float(value)) if ret < 0: raise ValueError("Could not set floating point field value.") @@ -1932,16 +2462,21 @@ class CTFWriter: """ @property def length(self): - raise NotImplementedError("Getter not implemented.") + native_instance = _bt_ctf_field_sequence_get_length(self._f) + if native_instance is None: + length = -1 + return CTFWriter.Field._create_field_from_native_instance(native_instance) """ Set the sequence's length field (IntegerField). """ @length.setter def length(self, length_field): - if not isinstance(length, CTFWriter.IntegerField): + if not isinstance(length_field, CTFWriter.IntegerField): raise TypeError("Invalid length field.") - ret = _bt_ctf_field_sequence_set_length(self._f, length._f) + if length_field.declaration.signed: + raise TypeError("Sequence field length must be unsigned") + ret = _bt_ctf_field_sequence_set_length(self._f, length_field._f) if ret < 0: raise ValueError("Could not set sequence length.") @@ -1960,7 +2495,7 @@ class CTFWriter: """ @property def value(self): - raise NotImplementedError("Getter not implemented.") + return _bt_ctf_field_string_get_value(self._f) """ Set a string field's value. @@ -1991,6 +2526,78 @@ class CTFWriter: if ret < 0: raise ValueError("Could not add field to event class.") + """ + Get the event class' name. + """ + @property + def name(self): + name = _bt_ctf_event_class_get_name(self._ec) + if name is None: + raise TypeError("Could not get EventClass name") + return name + + """ + Get the event class' id. Returns a negative value if unset. + """ + @property + def id(self): + id = _bt_ctf_event_class_get_id(self._ec) + if id < 0: + raise TypeError("Could not get EventClass id") + return id + + """ + Set the event class' id. Throws a TypeError if the event class + is already registered to a stream class. + """ + @id.setter + def id(self, id): + ret = _bt_ctf_event_class_set_id(self._ec, id) + if ret < 0: + raise TypeError("Can't change an Event Class's id after it has been assigned to a stream class") + + """ + Get the event class' stream class. Returns None if unset. + """ + @property + def stream_class(self): + stream_class_native = _bt_ctf_event_class_get_stream_class(self._ec) + if stream_class_native is None: + return None + stream_class = CTFWriter.StreamClass.__new__(CTFWriter.StreamClass) + stream_class._sc = stream_class_native + return stream_class + + """ + Generator returning the event class' fields as tuples of (field name, field declaration). + """ + @property + def fields(self): + count = _bt_ctf_event_class_get_field_count(self._ec) + if count < 0: + raise TypeError("Could not get EventClass' field count") + + for i in range(count): + field_name = _bt_python_ctf_event_class_get_field_name(self._ec, i) + if field_name is None: + raise TypeError("Could not get EventClass' field name at index {}".format(i)) + + field_type_native = _bt_python_ctf_event_class_get_field_type(self._ec, i) + if field_type_native is None: + raise TypeError("Could not get EventClass' field type at index {}".format(i)) + + field_type = CTFWriter.FieldDeclaration._create_field_declaration_from_native_instance(field_type_native) + yield (field_name, field_type) + + """ + Get a field declaration by name (FieldDeclaration). + """ + def get_field_by_name(self, name): + field_type_native = _bt_ctf_event_class_get_field_by_name(self._ec, name) + if field_type_native is None: + raise TypeError("Could not find EventClass field with name {}".format(name)) + return CTFWriter.FieldDeclaration._create_field_declaration_from_native_instance(field_type_native) + class Event: """ Create a new event of the given event class. @@ -2007,14 +2614,28 @@ class CTFWriter: _bt_ctf_event_put(self._e) """ - Set a manually created field as an event's payload. + Get the event's class. """ - 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, str(field_name), value._f) - if ret < 0: - raise ValueError("Could not set event field payload.") + @property + def event_class(self): + event_class_native = _bt_ctf_event_get_class(self._e) + if event_class_native is None: + return None + event_class = CTFWriter.EventClass.__new__(CTFWriter.EventClass) + event_class._ec = event_class_native + return event_class + + """ + Get a clock from event. Returns None if the event's class + is not registered to a stream class. + """ + def clock(self): + clock_instance = _bt_ctf_event_get_clock(self._e) + if clock_instance is None: + return None + clock = CTFWriter.Clock.__new__(CTFWriter.Clock) + clock._c = clock_instance + return clock """ Get a field from event. @@ -2025,6 +2646,16 @@ class CTFWriter: raise ValueError("Could not get event payload.") return CTFWriter.Field._create_field_from_native_instance(native_instance) + """ + Set a manually created field as an event's payload. + """ + 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, str(field_name), value_field._f) + if ret < 0: + raise ValueError("Could not set event field payload.") + class StreamClass: """ Create a new stream class of the given name. @@ -2037,12 +2668,27 @@ class CTFWriter: def __del__(self): _bt_ctf_stream_class_put(self._sc) + """ + Get a stream class' name. + """ + @property + def name(self): + name = _bt_ctf_stream_class_get_name(self._sc) + if name is None: + raise TypeError("Could not get StreamClass name") + return name + """ Get a stream class' clock. """ @property def clock(self): - raise NotImplementedError("Getter not implemented.") + clock_instance = _bt_ctf_stream_class_get_clock(self._sc) + if clock_instance is None: + return None + clock = CTFWriter.Clock.__new__(CTFWriter.Clock) + clock._c = clock_instance + return clock """ Assign a clock to a stream class. @@ -2056,6 +2702,43 @@ class CTFWriter: if ret < 0: raise ValueError("Could not set stream class clock.") + """ + Get a stream class' id. + """ + @property + def id(self): + ret = _bt_ctf_stream_class_get_id(self._sc) + if ret < 0: + raise TypeError("Could not get StreamClass id") + return ret + + """ + Assign an id to a stream class. + """ + @id.setter + def id(self, id): + ret = _bt_ctf_stream_class_set_id(self._sc, id) + if ret < 0: + raise TypeError("Could not set stream class id.") + + """ + Generator returning the stream class' event classes. + """ + @property + def event_classes(self): + count = _bt_ctf_stream_class_get_event_class_count(self._sc) + if count < 0: + raise TypeError("Could not get StreamClass' event class count") + + for i in range(count): + event_class_native = _bt_ctf_stream_class_get_event_class(self._sc, i) + if event_class_native is None: + raise TypeError("Could not get StreamClass' event class at index {}".format(i)) + + event_class = CTFWriter.EventClass.__new__(CTFWriter.EventClass) + event_class._ec = event_class_native + yield event_class + """ Add an event class to a stream class. New events can be added even after a stream has been instantiated and events have been appended. However, a stream @@ -2084,13 +2767,21 @@ class CTFWriter: def __del__(self): _bt_ctf_stream_put(self._s) + """ + Get a stream's discarded event count. + """ + @property + def discarded_events(self): + ret, count = _bt_ctf_stream_get_discarded_events_count(self._s) + if ret < 0: + raise ValueError("Could not get the stream's discarded events count") + return count + """ 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