#include <babeltrace/iterator-internal.h>
#include <babeltrace/format.h>
#include <babeltrace/list.h>
-#include <babeltrace/uuid.h>
#include <babeltrace/types.h>
#include <babeltrace/ctf/iterator.h>
#include "python-complements.h"
typedef long long int64_t;
typedef int bt_intern_str;
+/* =================================================================
+ PYTHON-COMPLEMENTS.H
+ ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
+*/
+
+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,
+ unsigned int *OUTPUT);
+struct bt_definition *_bt_python_field_one_from_list(
+ struct bt_definition **list, int index);
+struct bt_ctf_event_decl **_bt_python_event_decl_listcaller(
+ int handle_id,
+ struct bt_context *ctx,
+ unsigned int *OUTPUT);
+struct bt_ctf_event_decl *_bt_python_decl_one_from_list(
+ struct bt_ctf_event_decl **list, int index);
+struct bt_ctf_field_decl **_by_python_field_decl_listcaller(
+ struct bt_ctf_event_decl *event_decl,
+ enum bt_ctf_scope scope,
+ unsigned int *OUTPUT);
+struct bt_ctf_field_decl *_bt_python_field_decl_one_from_list(
+ struct bt_ctf_field_decl **list, int index);
+struct definition_array *_bt_python_get_array_from_def(
+ struct bt_definition *field);
+struct definition_sequence *_bt_python_get_sequence_from_def(
+ struct bt_definition *field);
+
/* =================================================================
CONTEXT.H, CONTEXT-INTERNAL.H
¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
%rename("_bt_context_create") bt_context_create(void);
%rename("_bt_context_add_trace") bt_context_add_trace(
struct bt_context *ctx, const char *path, const char *format,
- void (*packet_seek)(struct stream_pos *pos, size_t index, int whence),
- struct mmap_stream_list *stream_list, FILE *metadata);
+ void (*packet_seek)(struct bt_stream_pos *pos, size_t index, int whence),
+ struct bt_mmap_stream_list *stream_list, FILE *metadata);
%rename("_bt_context_remove_trace") bt_context_remove_trace(
struct bt_context *ctx, int trace_id);
%rename("_bt_context_get") bt_context_get(struct bt_context *ctx);
struct bt_context *bt_context_create(void);
int bt_context_add_trace(struct bt_context *ctx, const char *path, const char *format,
- void (*packet_seek)(struct stream_pos *pos, size_t index, int whence),
- struct mmap_stream_list *stream_list, FILE *metadata);
+ void (*packet_seek)(struct bt_stream_pos *pos, size_t index, int whence),
+ struct bt_mmap_stream_list *stream_list, FILE *metadata);
void bt_context_remove_trace(struct bt_context *ctx, int trace_id);
void bt_context_get(struct bt_context *ctx);
void bt_context_put(struct bt_context *ctx);
%rename("lookup_format") bt_lookup_format(bt_intern_str qname);
%rename("_bt_print_format_list") bt_fprintf_format_list(FILE *fp);
%rename("register_format") bt_register_format(struct format *format);
+%rename("unregister_format") bt_unregister_format(struct bt_format *format);
extern struct format *bt_lookup_format(bt_intern_str qname);
extern void bt_fprintf_format_list(FILE *fp);
-extern int bt_register_format(struct format *format);
-
-void format_init(void);
-void format_finalize(void);
+extern int bt_register_format(struct bt_format *format);
+extern void bt_unregister_format(struct bt_format *format);
%pythoncode %{
%rename("SEEK_RESTORE") BT_SEEK_RESTORE;
%rename("SEEK_CUR") BT_SEEK_CUR;
%rename("SEEK_BEGIN") BT_SEEK_BEGIN;
-%rename("SEEK_END") BT_SEEK_END;
-
+%rename("SEEK_LAST") BT_SEEK_LAST;
// This struct is taken from iterator.h
// All changes to the struct must also be made here
BT_SEEK_RESTORE, /* uses u.restore */
BT_SEEK_CUR,
BT_SEEK_BEGIN,
- BT_SEEK_END,
+ BT_SEEK_LAST
} type;
union {
uint64_t seek_time;
struct bt_context *ctx, int handle_id, enum bt_clock_type type);
%rename("_bt_trace_handle_get_timestamp_end") bt_trace_handle_get_timestamp_end(
struct bt_context *ctx, int handle_id, enum bt_clock_type type);
-%rename("_bt_trace_handle_get_id") bt_trace_handle_get_id(struct bt_trace_handle *th);
-int bt_trace_handle_get_id(struct bt_trace_handle *th);
const char *bt_trace_handle_get_path(struct bt_context *ctx, int handle_id);
uint64_t bt_trace_handle_get_timestamp_begin(struct bt_context *ctx, int handle_id,
enum bt_clock_type type);
raise NotImplementedError("TraceHandle cannot be instantiated")
def __repr__(self):
- return "Babeltrace TraceHandle: trace_id('{}')".format(self._id)
+ return "Babeltrace TraceHandle: trace_id('{0}')".format(self._id)
def get_id(self):
"""Return the TraceHandle id."""
const struct bt_ctf_event *ctf_event);
%rename("_bt_ctf_get_field") bt_ctf_get_field(const struct bt_ctf_event *ctf_event,
- const struct definition *scope, const char *field);
+ const struct bt_definition *scope, const char *field);
%rename("_bt_ctf_get_index") bt_ctf_get_index(const struct bt_ctf_event *ctf_event,
- const struct definition *field, unsigned int index);
-%rename("_bt_ctf_field_name") bt_ctf_field_name(const struct definition *def);
-%rename("_bt_ctf_field_type") bt_ctf_field_type(const struct definition *def);
+ const struct bt_definition *field, unsigned int index);
+%rename("_bt_ctf_field_name") bt_ctf_field_name(const struct bt_definition *field);
+%rename("_bt_ctf_field_type") bt_ctf_field_type(const struct bt_declaration *field);
%rename("_bt_ctf_get_int_signedness") bt_ctf_get_int_signedness(
- const struct definition *field);
-%rename("_bt_ctf_get_int_base") bt_ctf_get_int_base(const struct definition *field);
+ const struct bt_declaration *field);
+%rename("_bt_ctf_get_int_base") bt_ctf_get_int_base(const struct bt_declaration *field);
%rename("_bt_ctf_get_int_byte_order") bt_ctf_get_int_byte_order(
- const struct definition *field);
-%rename("_bt_ctf_get_int_len") bt_ctf_get_int_len(const struct definition *field);
-%rename("_bt_ctf_get_encoding") bt_ctf_get_encoding(const struct definition *field);
-%rename("_bt_ctf_get_array_len") bt_ctf_get_array_len(const struct definition *field);
-%rename("_bt_ctf_get_uint64") bt_ctf_get_uint64(const struct definition *field);
-%rename("_bt_ctf_get_int64") bt_ctf_get_int64(const struct definition *field);
-%rename("_bt_ctf_get_char_array") bt_ctf_get_char_array(const struct definition *field);
-%rename("_bt_ctf_get_string") bt_ctf_get_string(const struct definition *field);
+ const struct bt_declaration *field);
+%rename("_bt_ctf_get_int_len") bt_ctf_get_int_len(const struct bt_declaration *field);
+%rename("_bt_ctf_get_enum_int") bt_ctf_get_enum_int(const struct bt_definition *field);
+%rename("_bt_ctf_get_enum_str") bt_ctf_get_enum_str(const struct bt_definition *field);
+%rename("_bt_ctf_get_encoding") bt_ctf_get_encoding(const struct bt_declaration *field);
+%rename("_bt_ctf_get_array_len") bt_ctf_get_array_len(const struct bt_declaration *field);
+%rename("_bt_ctf_get_uint64") bt_ctf_get_uint64(const struct bt_definition *field);
+%rename("_bt_ctf_get_int64") bt_ctf_get_int64(const struct bt_definition *field);
+%rename("_bt_ctf_get_char_array") bt_ctf_get_char_array(const struct bt_definition *field);
+%rename("_bt_ctf_get_string") bt_ctf_get_string(const struct bt_definition *field);
+%rename("_bt_ctf_get_float") bt_ctf_get_float(const struct bt_definition *field);
+%rename("_bt_ctf_get_variant") bt_ctf_get_variant(const struct bt_definition *field);
%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_field_name") bt_ctf_get_decl_field_name(
const struct bt_ctf_field_decl *field);
-
-const struct definition *bt_ctf_get_top_level_scope(const struct bt_ctf_event *ctf_event,
+%rename("_bt_ctf_get_decl_from_def") bt_ctf_get_decl_from_def(
+ const struct bt_definition *field);
+%rename("_bt_array_index") bt_array_index(struct definition_array *array, uint64_t i);
+%rename("_bt_sequence_len") bt_sequence_len(struct definition_sequence *sequence);
+%rename("_bt_sequence_index") bt_sequence_index(struct definition_sequence *sequence, uint64_t i);
+%rename("_bt_ctf_get_struct_field_count") bt_ctf_get_struct_field_count(const struct bt_definition *structure);
+%rename("_bt_ctf_get_struct_field_index") bt_ctf_get_struct_field_index(const struct bt_definition *structure, uint64_t i);
+
+const struct bt_definition *bt_ctf_get_top_level_scope(const struct bt_ctf_event *ctf_event,
enum bt_ctf_scope scope);
const char *bt_ctf_event_name(const struct bt_ctf_event *ctf_event);
uint64_t bt_ctf_get_timestamp(const struct bt_ctf_event *ctf_event);
uint64_t bt_ctf_get_cycles(const struct bt_ctf_event *ctf_event);
-const struct definition *bt_ctf_get_field(const struct bt_ctf_event *ctf_event,
- const struct definition *scope,
+const struct bt_definition *bt_ctf_get_field(const struct bt_ctf_event *ctf_event,
+ const struct bt_definition *scope,
const char *field);
-const struct definition *bt_ctf_get_index(const struct bt_ctf_event *ctf_event,
- const struct definition *field,
+const struct bt_definition *bt_ctf_get_index(const struct bt_ctf_event *ctf_event,
+ const struct bt_definition *field,
unsigned int index);
-const char *bt_ctf_field_name(const struct definition *def);
-enum ctf_type_id bt_ctf_field_type(const struct definition *def);
-int bt_ctf_get_int_signedness(const struct definition *field);
-int bt_ctf_get_int_base(const struct definition *field);
-int bt_ctf_get_int_byte_order(const struct definition *field);
-ssize_t bt_ctf_get_int_len(const struct definition *field);
-enum ctf_string_encoding bt_ctf_get_encoding(const struct definition *field);
-int bt_ctf_get_array_len(const struct definition *field);
-uint64_t bt_ctf_get_uint64(const struct definition *field);
-int64_t bt_ctf_get_int64(const struct definition *field);
-char *bt_ctf_get_char_array(const struct definition *field);
-char *bt_ctf_get_string(const struct definition *field);
+const char *bt_ctf_field_name(const struct bt_definition *field);
+enum ctf_type_id bt_ctf_field_type(const struct bt_declaration *field);
+int bt_ctf_get_int_signedness(const struct bt_declaration *field);
+int bt_ctf_get_int_base(const struct bt_declaration *field);
+int bt_ctf_get_int_byte_order(const struct bt_declaration *field);
+ssize_t bt_ctf_get_int_len(const struct bt_declaration *field);
+const struct bt_definition *bt_ctf_get_enum_int(const struct bt_definition *field);
+const char *bt_ctf_get_enum_str(const struct bt_definition *field);
+enum ctf_string_encoding bt_ctf_get_encoding(const struct bt_declaration *field);
+int bt_ctf_get_array_len(const struct bt_declaration *field);
+struct bt_definition *bt_array_index(struct definition_array *array, uint64_t i);
+uint64_t bt_ctf_get_uint64(const struct bt_definition *field);
+int64_t bt_ctf_get_int64(const struct bt_definition *field);
+char *bt_ctf_get_char_array(const struct bt_definition *field);
+char *bt_ctf_get_string(const struct bt_definition *field);
+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);
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);
+uint64_t bt_sequence_len(struct definition_sequence *sequence);
+struct bt_definition *bt_sequence_index(struct definition_sequence *sequence, uint64_t i);
+uint64_t bt_ctf_get_struct_field_count(const struct bt_definition *structure);
+const struct bt_definition *bt_ctf_get_struct_field_index(const struct bt_definition *structure, uint64_t i);
%pythoncode%{
-class ctf:
-
- #enum equivalent, accessible constants
- #These are taken directly from ctf/events.h
- #All changes to enums must also be made here
- class type_id:
- UNKNOWN = 0
- INTEGER = 1
- FLOAT = 2
- ENUM = 3
- STRING = 4
- STRUCT = 5
- UNTAGGED_VARIANT = 6
- VARIANT = 7
- ARRAY = 8
- SEQUENCE = 9
- NR_CTF_TYPES = 10
+class CTFStringEncoding:
+ NONE = 0
+ UTF8 = 1
+ ASCII = 2
+ UNKNOWN = 3
+
+#enum equivalent, accessible constants
+#These are taken directly from ctf/events.h
+#All changes to enums must also be made here
+class CTFTypeId:
+ UNKNOWN = 0
+ INTEGER = 1
+ FLOAT = 2
+ ENUM = 3
+ STRING = 4
+ STRUCT = 5
+ UNTAGGED_VARIANT = 6
+ VARIANT = 7
+ ARRAY = 8
+ SEQUENCE = 9
+ NR_CTF_TYPES = 10
+
+ def get_type_name(id):
+ name = "UNKNOWN"
+ constants = [attr for attr in dir(CTFTypeId) if not callable(getattr(CTFTypeId, attr)) and not attr.startswith("__")]
+ for attr in constants:
+ if getattr(CTFTypeId, attr) == id:
+ name = attr
+ break
+ return name
+class CTFReader:
class scope:
TRACE_PACKET_HEADER = 0
STREAM_PACKET_CONTEXT = 1
def __new__(cls, context, begin_pos = None, end_pos = None):
# __new__ is used to control the return value
- # as the ctf.Iterator class should return None
+ # as the CTFReader.Iterator class should return None
# if bt_ctf_iter_create returns NULL
if begin_pos is None:
if it is None:
return None
- ret_class = super(ctf.Iterator, cls).__new__(cls)
+ ret_class = super(CTFReader.Iterator, cls).__new__(cls)
ret_class._i = it
return ret_class
ret = _bt_ctf_iter_read_event(self._i)
if ret is None:
return ret
- ev = ctf.Event.__new__(ctf.Event)
+ ev = CTFReader.Event.__new__(CTFReader.Event)
ev._e = ret
return ev
class Event(object):
"""
This class represents an event from the trace.
- It is obtained with read_event() from ctf.Iterator.
+ It is obtained with read_event() from CTFReader.Iterator.
Do not instantiate.
"""
def __init__(self):
- raise NotImplementedError("ctf.Event cannot be instantiated")
+ raise NotImplementedError("CTFReader.Event cannot be instantiated")
def get_top_level_scope(self, scope):
"""
Return a definition of the top-level scope
- Top-level scopes are defined in ctf.scope.
+ Top-level scopes are defined in CTFReader.scope.
In order to get a field or a field list, the user needs to pass a
scope as argument, this scope can be a top-level scope or a scope
relative to an arbitrary field. This function provides the mapping
between the scope and the actual definition of top-level scopes.
On error return None.
"""
- evDef = ctf.Definition.__new__(ctf.Definition)
+ evDef = CTFReader.Definition.__new__(CTFReader.Definition)
evDef._d = _bt_ctf_get_top_level_scope(self._e, scope)
if evDef._d is None:
return None
"""
return _bt_ctf_get_timestamp(self._e)
- def get_field(self, scope, field):
- """Return the definition of a specific field."""
- evDef = ctf.Definition.__new__(ctf.Definition)
+ def get_field_with_scope(self, scope, field):
+ """
+ Return the definition of a specific field.
+ Return None on error.
+ """
+ evDef = CTFReader.Definition.__new__(CTFReader.Definition)
try:
evDef._d = _bt_ctf_get_field(self._e, scope._d, field)
except AttributeError:
raise TypeError("in get_field, argument 2 must be a "
"Definition (scope) instance")
+ if evDef._d is None:
+ return None
+ evDef._s = scope
return evDef
- def get_field_list(self, scope):
+ def get_field(self, field):
+ """
+ Return the definition of fields by a name
+ Return None on error
+ """
+ eventScope = self.get_top_level_scope(CTFReader.scope.EVENT_FIELDS)
+ streamScope = self.get_top_level_scope(CTFReader.scope.STREAM_EVENT_CONTEXT)
+ fields_by_name = []
+
+ if eventScope is not None:
+ evDef = self.get_field_with_scope(eventScope, field)
+ if evDef is not None:
+ fields_by_name.append(evDef)
+
+ if streamScope is not None:
+ evDef = self.get_field_with_scope(streamScope, field)
+ if evDef is not None:
+ fields_by_name.append(evDef);
+
+ if not fields_by_name:
+ return None
+ return fields_by_name
+
+ def get_field_list_with_scope(self, scope):
"""
- Return a list of Definitions
+ Return a list of Definitions associated with the scope
Return None on error.
"""
try:
- field_lc = _bt_python_field_listcaller(self._e, scope._d)
+ field_lc, count = _bt_python_field_listcaller(self._e, scope._d)
except AttributeError:
raise TypeError("in get_field_list, argument 2 must be a "
"Definition (scope) instance")
return None
def_list = []
- i = 0
- while True:
- tmp = ctf.Definition.__new__(ctf.Definition)
+ for i in range(count):
+ tmp = CTFReader.Definition.__new__(CTFReader.Definition)
tmp._d = _bt_python_field_one_from_list(field_lc, i)
+ tmp._s = scope
+ def_list.append(tmp)
- if tmp._d is None:
- #Last item of list is None, assured in
- #_bt_python_field_listcaller
- break
+ return def_list
- def_list.append(tmp)
- i += 1
+ def get_field_list(self):
+ """Return a list of Definitions or None on error."""
+ eventScope = self.get_top_level_scope(CTFReader.scope.EVENT_FIELDS)
+ streamScope = self.get_top_level_scope(CTFReader.scope.STREAM_EVENT_CONTEXT)
+
+ def_list = []
+ if eventScope is not None:
+ event_field_list = self.get_field_list_with_scope(eventScope)
+ if event_field_list is not None:
+ def_list = event_field_list
+
+ if streamScope is not None:
+ event_field_list = self.get_field_list_with_scope(streamScope)
+ if event_field_list is not None:
+ def_list.extend(event_field_list)
+
+ if not def_list:
+ return None
return def_list
def get_index(self, field, index):
If the field is an array or a sequence, return the element
at position index, otherwise return None
"""
- evDef = ctf.Definition.__new__(ctf.Definition)
+ evDef = CTFReader.Definition.__new__(CTFReader.Definition)
try:
evDef._d = _bt_ctf_get_index(self._e, field._d, index)
except AttributeError:
else:
return ctx
+ class FieldError(Exception):
+ def __init__(self, value):
+ self.value = value
+
+ def __str__(self):
+ return repr(self.value)
class Definition(object):
"""Definition class. Do not instantiate."""
def __init__(self):
- raise NotImplementedError("ctf.Definition cannot be instantiated")
+ raise NotImplementedError("CTFReader.Definition cannot be instantiated")
def __repr__(self):
- return "Babeltrace Definition: name('{}'), type({})".format(
+ return "Babeltrace Definition: name('{0}'), type({1})".format(
self.field_name(), self.field_type())
def field_name(self):
def field_type(self):
"""Return the type of a field or -1 if unknown."""
- return _bt_ctf_field_type(self._d)
+ return _bt_ctf_field_type(_bt_ctf_get_decl_from_def(self._d))
def get_int_signedness(self):
"""
Return the signedness of an integer:
0 if unsigned; 1 if signed; -1 on error.
"""
- return _bt_ctf_get_int_signedness(self._d)
+ return _bt_ctf_get_int_signedness(_bt_ctf_get_decl_from_def(self._d))
def get_int_base(self):
"""Return the base of an int or a negative value on error."""
- return _bt_ctf_get_int_base(self._d)
+ return _bt_ctf_get_int_base(_bt_ctf_get_decl_from_def(self._d))
def get_int_byte_order(self):
"""
Return the byte order of an int or a negative
value on error.
"""
- return _bt_ctf_get_int_byte_order(self._d)
+ return _bt_ctf_get_int_byte_order(_bt_ctf_get_decl_from_def(self._d))
def get_int_len(self):
"""
Return the size, in bits, of an int or a negative
value on error.
"""
- return _bt_ctf_get_int_len(self._d)
+ return _bt_ctf_get_int_len(_bt_ctf_get_decl_from_def(self._d))
+
+ def get_enum_str(self):
+ """
+ Return the string matching the current enumeration.
+ Return None on error.
+ """
+ return _bt_ctf_get_enum_str(self._d)
def get_encoding(self):
"""
Return the encoding of an int or a string.
Return a negative value on error.
"""
- return _bt_ctf_get_encoding(self._d)
+ return _bt_ctf_get_encoding(_bt_ctf_get_decl_from_def(self._d))
def get_array_len(self):
"""
Return the len of an array or a negative
value on error.
"""
- return _bt_ctf_get_array_len(self._d)
+ return _bt_ctf_get_array_len(_bt_ctf_get_decl_from_def(self._d))
+
+ def get_array_element_at(self, index):
+ """
+ Return the array's element at position index.
+ Return None on error
+ """
+ array = _bt_python_get_array_from_def(self._d)
+ if array is None:
+ return None
+
+ element = CTFReader.Definition.__new__(CTFReader.Definition)
+ element._d = _bt_array_index(array, index)
+ if element._d is None:
+ return None
+ return element
+
+ def get_sequence_len(self):
+ """
+ Return the len of a sequence or a negative
+ value on error.
+ """
+ seq = _bt_python_get_sequence_from_def(self._d)
+ return _bt_sequence_len(seq)
+
+ def get_sequence_element_at(self, index):
+ """
+ Return the sequence's element at position index,
+ otherwise return None
+ """
+ seq = _bt_python_get_sequence_from_def(self._d)
+ if seq is not None:
+ element = CTFReader.Definition.__new__(CTFReader.Definition)
+ element._d = _bt_sequence_index(seq, index)
+ if element._d is not None:
+ return element
+ return None
def get_uint64(self):
"""
Return the value associated with the field.
If the field does not exist or is not of the type requested,
the value returned is undefined. To check if an error occured,
- use the ctf.field_error() function after accessing a field.
+ use the CTFReader.field_error() function after accessing a field.
"""
return _bt_ctf_get_uint64(self._d)
Return the value associated with the field.
If the field does not exist or is not of the type requested,
the value returned is undefined. To check if an error occured,
- use the ctf.field_error() function after accessing a field.
+ use the CTFReader.field_error() function after accessing a field.
"""
return _bt_ctf_get_int64(self._d)
Return the value associated with the field.
If the field does not exist or is not of the type requested,
the value returned is undefined. To check if an error occured,
- use the ctf.field_error() function after accessing a field.
+ use the CTFReader.field_error() function after accessing a field.
"""
return _bt_ctf_get_char_array(self._d)
Return the value associated with the field.
If the field does not exist or is not of the type requested,
the value returned is undefined. To check if an error occured,
- use the ctf.field_error() function after accessing a field.
+ use the CTFReader.field_error() function after accessing a field.
"""
return _bt_ctf_get_string(self._d)
+ def get_float(self):
+ """
+ Return the value associated with the field.
+ If the field does not exist or is not of the type requested,
+ the value returned is undefined. To check if an error occured,
+ use the CTFReader.field_error() function after accessing a field.
+ """
+ return _bt_ctf_get_float(self._d)
+
+ def get_variant(self):
+ """
+ Return the variant's selected field.
+ If the field does not exist or is not of the type requested,
+ the value returned is undefined. To check if an error occured,
+ use the CTFReader.field_error() function after accessing a field.
+ """
+ return _bt_ctf_get_variant(self._d)
+
+ def get_struct_field_count(self):
+ """
+ Return the number of fields contained in the structure.
+ If the field does not exist or is not of the type requested,
+ the value returned is undefined.
+ """
+ return _bt_ctf_get_struct_field_count(self._d)
+
+ def get_struct_field_at(self, i):
+ """
+ Return the structure's field at position i.
+ If the field does not exist or is not of the type requested,
+ the value returned is undefined. To check if an error occured,
+ use the CTFReader.field_error() function after accessing a field.
+ """
+ return _bt_ctf_get_struct_field_index(self._d, i)
+
+ def get_value(self):
+ """
+ Return the value associated with the field according to its type.
+ Return None on error.
+ """
+ id = self.field_type()
+ value = None
+ if id == CTFTypeId.STRING:
+ value = self.get_str()
+ elif id == CTFTypeId.ARRAY:
+ value = []
+ for i in range(self.get_array_len()):
+ element = self.get_array_element_at(i)
+ value.append(element.get_value())
+ elif id == CTFTypeId.INTEGER:
+ if self.get_int_signedness() == 0:
+ value = self.get_uint64()
+ else:
+ value = self.get_int64()
+ 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.get_value())
+ elif id == CTFTypeId.FLOAT:
+ value = self.get_float()
+ elif id == CTFTypeId.VARIANT:
+ variant = CTFReader.Definition.__new__(CTFReader.Definition)
+ variant._d = self.get_variant();
+ value = variant.get_value()
+ elif id == CTFTypeId.STRUCT:
+ value = {}
+ for i in range(self.get_struct_field_count()):
+ member = CTFReader.Definition.__new__(CTFReader.Definition)
+ member._d = self.get_struct_field_at(i);
+ value[member.field_name()] = member.get_value()
+
+ if CTFReader.field_error():
+ raise CTFReader.FieldError("Error occured while accessing field {} of type {}".format(self.field_name(), CTFTypeId.get_type_name(self.field_type())))
+ return value
+
+ def get_scope(self):
+ """Return the scope of a field or None on error."""
+ return self._s
class EventDecl(object):
"""Event declaration class. Do not instantiate."""
def __init__(self):
- raise NotImplementedError("ctf.EventDecl cannot be instantiated")
+ raise NotImplementedError("CTFReader.EventDecl cannot be instantiated")
def __repr__(self):
- return "Babeltrace EventDecl: name {}".format(self.get_name())
+ return "Babeltrace EventDecl: name {0}".format(self.get_name())
def get_name(self):
"""Return the name of the event or None on error"""
def get_decl_fields(self, scope):
"""
- Return a list of ctf.FieldDecl
+ Return a list of CTFReader.FieldDecl
Return None on error.
"""
ptr_list = _by_python_field_decl_listcaller(self._d, scope)
decl_list = []
i = 0
while True:
- tmp = ctf.FieldDecl.__new__(ctf.FieldDecl)
+ tmp = CTFReader.FieldDecl.__new__(CTFReader.FieldDecl)
tmp._d = _bt_python_field_decl_one_from_list(
ptr_list, i)
"""Field declaration class. Do not instantiate."""
def __init__(self):
- raise NotImplementedError("ctf.FieldDecl cannot be instantiated")
+ raise NotImplementedError("CTFReader.FieldDecl cannot be instantiated")
def __repr__(self):
- return "Babeltrace FieldDecl: name {}".format(self.get_name())
+ return "Babeltrace FieldDecl: name {0}".format(self.get_name())
def get_name(self):
"""Return the name of a FieldDecl or None on error"""
@staticmethod
def get_event_decl_list(trace_handle, context):
"""
- Return a list of ctf.EventDecl
+ Return a list of CTFReader.EventDecl
Return None on error.
"""
try:
raise TypeError("in get_event_decl_list, "
"argument 1 must be a TraceHandle instance")
try:
- ptr_list = _bt_python_event_decl_listcaller(handle_id, context._c)
+ ptr_list, count = _bt_python_event_decl_listcaller(handle_id, context._c)
except AttributeError:
raise TypeError("in get_event_decl_list, "
"argument 2 must be a Context instance")
return None
decl_list = []
- i = 0
- while True:
- tmp = ctf.EventDecl.__new__(ctf.EventDecl)
+ for i in range(count):
+ tmp = CTFReader.EventDecl.__new__(CTFReader.EventDecl)
tmp._d = _bt_python_decl_one_from_list(ptr_list, i)
-
- if tmp._d is None:
- #Last item of list is None
- break
-
decl_list.append(tmp)
- i += 1
+
return decl_list
%}
// python-complements.h
// =================================================================
-%include python-complements.c
-
%pythoncode %{
class File(object):
stat = 'opened'
else:
stat = 'closed'
- return "{} babeltrace File; file_path('{}'), mode('{}')".format(
+ return "{0} babeltrace File; file_path('{1}'), mode('{2}')".format(
stat, self._file_path, self._mode)
def close(self):
projects / babeltrace.git / blobdiff