4 * Babeltrace Python Module interface file
6 * Copyright 2012 EfficiOS Inc.
8 * Author: Danny Serres <danny.serres@efficios.com>
10 * Permission is hereby granted, free of charge, to any person obtaining a copy
11 * of this software and associated documentation files (the "Software"), to deal
12 * in the Software without restriction, including without limitation the rights
13 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
14 * copies of the Software, and to permit persons to whom the Software is
15 * furnished to do so, subject to the following conditions:
17 * The above copyright notice and this permission notice shall be included in
18 * all copies or substantial portions of the Software.
23 "BABELTRACE_VERSION_STR
25 Babeltrace is a trace viewer and converter reading and writing the
26 Common Trace Format (CTF). Its main use is to pretty-print CTF
27 traces into a human-readable text output.
29 To use this module, the first step is to create a Context and add a
33 %module(docstring=DOCSTRING) babeltrace
37 #define SWIG_FILE_WITH_INIT
38 #include <babeltrace/babeltrace.h>
39 #include <babeltrace/babeltrace-internal.h>
40 #include <babeltrace/trace-handle.h>
41 #include <babeltrace/trace-handle-internal.h>
42 #include <babeltrace/context.h>
43 #include <babeltrace/context-internal.h>
44 #include <babeltrace/iterator.h>
45 #include <babeltrace/iterator-internal.h>
46 #include <babeltrace/format.h>
47 #include <babeltrace/list.h>
48 #include <babeltrace/types.h>
49 #include <babeltrace/ctf/iterator.h>
50 #include "python-complements.h"
53 typedef unsigned long long uint64_t;
54 typedef long long int64_t;
55 typedef int bt_intern_str;
57 /* =================================================================
58 CONTEXT.H, CONTEXT-INTERNAL.H
59 ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
62 %rename("_bt_context_create") bt_context_create(void);
63 %rename("_bt_context_add_trace") bt_context_add_trace(
64 struct bt_context *ctx, const char *path, const char *format,
65 void (*packet_seek)(struct bt_stream_pos *pos, size_t index, int whence),
66 struct bt_mmap_stream_list *stream_list, FILE *metadata);
67 %rename("_bt_context_remove_trace") bt_context_remove_trace(
68 struct bt_context *ctx, int trace_id);
69 %rename("_bt_context_get") bt_context_get(struct bt_context *ctx);
70 %rename("_bt_context_put") bt_context_put(struct bt_context *ctx);
71 %rename("_bt_ctf_event_get_context") bt_ctf_event_get_context(
72 const struct bt_ctf_event *event);
74 struct bt_context *bt_context_create(void);
75 int bt_context_add_trace(struct bt_context *ctx, const char *path, const char *format,
76 void (*packet_seek)(struct bt_stream_pos *pos, size_t index, int whence),
77 struct bt_mmap_stream_list *stream_list, FILE *metadata);
78 void bt_context_remove_trace(struct bt_context *ctx, int trace_id);
79 void bt_context_get(struct bt_context *ctx);
80 void bt_context_put(struct bt_context *ctx);
81 struct bt_context *bt_ctf_event_get_context(const struct bt_ctf_event *event);
83 // class Context to prevent direct access to struct bt_context
87 The context represents the object in which a trace_collection is
88 open. As long as this structure is allocated, the trace_collection
89 is open and the traces it contains can be read and seeked by the
90 iterators and callbacks.
94 self._c = _bt_context_create()
97 _bt_context_put(self._c)
99 def add_trace(self, path, format_str,
100 packet_seek=None, stream_list=None, metadata=None):
102 Add a trace by path to the context.
106 path is the path to the trace, it is not recursive.
107 If "path" is None, stream_list is used instead as a list
108 of mmap streams to open for the trace.
110 format is a string containing the format name in which the trace was
113 packet_seek is not implemented for Python. Should be left None to
114 use the default packet_seek handler provided by the trace format.
116 stream_list is a linked list of streams, it is used to open a trace
117 where the trace data is located in memory mapped areas instead of
118 trace files, this argument should be None when path is not None.
120 The metadata parameter acts as a metadata override when not None,
121 otherwise the format handles the metadata opening.
123 Return: the corresponding TraceHandle on success or None on error.
125 if metadata is not None:
126 metadata = metadata._file
128 ret = _bt_context_add_trace(self._c, path, format_str, packet_seek,
129 stream_list, metadata)
133 th = TraceHandle.__new__(TraceHandle)
137 def add_traces_recursive(self, path, format_str):
139 Open a trace recursively.
141 Find each trace present in the subdirectory starting from the given
142 path, and add them to the context.
144 Return a dict of TraceHandle instances (the full path is the key).
145 Return None on error.
155 for fullpath, dirs, files in os.walk(path):
156 if "metadata" in files:
157 trace_handle = self.add_trace(fullpath, format_str)
158 if trace_handle is None:
162 trace_handles[fullpath] = trace_handle
165 if noTrace and error:
169 def remove_trace(self, trace_handle):
171 Remove a trace from the context.
172 Effectively closing the trace.
175 _bt_context_remove_trace(self._c, trace_handle._id)
176 except AttributeError:
177 raise TypeError("in remove_trace, "
178 "argument 2 must be a TraceHandle instance")
183 /* =================================================================
188 %rename("lookup_format") bt_lookup_format(bt_intern_str qname);
189 %rename("_bt_print_format_list") bt_fprintf_format_list(FILE *fp);
190 %rename("register_format") bt_register_format(struct format *format);
192 extern struct format *bt_lookup_format(bt_intern_str qname);
193 extern void bt_fprintf_format_list(FILE *fp);
194 extern int bt_register_format(struct bt_format *format);
198 def print_format_list(babeltrace_file):
200 Print a list of available formats to file.
202 babeltrace_file must be a File instance opened in write mode.
205 if babeltrace_file._file is not None:
206 _bt_print_format_list(babeltrace_file._file)
207 except AttributeError:
208 raise TypeError("in print_format_list, "
209 "argument 1 must be a File instance")
214 /* =================================================================
215 ITERATOR.H, ITERATOR-INTERNAL.H
216 ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
219 %rename("_bt_iter_create") bt_iter_create(struct bt_context *ctx,
220 const struct bt_iter_pos *begin_pos, const struct bt_iter_pos *end_pos);
221 %rename("_bt_iter_destroy") bt_iter_destroy(struct bt_iter *iter);
222 %rename("_bt_iter_next") bt_iter_next(struct bt_iter *iter);
223 %rename("_bt_iter_get_pos") bt_iter_get_pos(struct bt_iter *iter);
224 %rename("_bt_iter_free_pos") bt_iter_free_pos(struct bt_iter_pos *pos);
225 %rename("_bt_iter_set_pos") bt_iter_set_pos(struct bt_iter *iter,
226 const struct bt_iter_pos *pos);
227 %rename("_bt_iter_create_time_pos") bt_iter_create_time_pos(struct bt_iter *iter,
230 struct bt_iter *bt_iter_create(struct bt_context *ctx,
231 const struct bt_iter_pos *begin_pos, const struct bt_iter_pos *end_pos);
232 void bt_iter_destroy(struct bt_iter *iter);
233 int bt_iter_next(struct bt_iter *iter);
234 struct bt_iter_pos *bt_iter_get_pos(struct bt_iter *iter);
235 void bt_iter_free_pos(struct bt_iter_pos *pos);
236 int bt_iter_set_pos(struct bt_iter *iter, const struct bt_iter_pos *pos);
237 struct bt_iter_pos *bt_iter_create_time_pos(struct bt_iter *iter, uint64_t timestamp);
239 %rename("_bt_iter_pos") bt_iter_pos;
240 %rename("SEEK_TIME") BT_SEEK_TIME;
241 %rename("SEEK_RESTORE") BT_SEEK_RESTORE;
242 %rename("SEEK_CUR") BT_SEEK_CUR;
243 %rename("SEEK_BEGIN") BT_SEEK_BEGIN;
244 %rename("SEEK_LAST") BT_SEEK_LAST;
246 // This struct is taken from iterator.h
247 // All changes to the struct must also be made here
250 BT_SEEK_TIME, /* uses u.seek_time */
251 BT_SEEK_RESTORE, /* uses u.restore */
258 struct bt_saved_pos *restore;
266 """This class represents the position where to set an iterator."""
270 def __init__(self, seek_type, seek_time = None):
272 seek_type represents the type of seek to use.
273 seek_time is the timestamp to seek to when using SEEK_TIME, it
274 is expressed in nanoseconds
275 Only use SEEK_RESTORE on IterPos obtained from the get_pos function
279 self._pos = _bt_iter_pos()
280 self._pos.type = seek_type
281 if seek_time and seek_type == SEEK_TIME:
282 self._pos.u.seek_time = seek_time
283 self.__can_access = True
286 if not self.__can_access:
287 _bt_iter_free_pos(self._pos)
291 raise AttributeError("seek_type is not available")
292 return self._pos.type
294 def _set_type(self, seek_type):
296 raise AttributeError("seek_type is not available")
297 self._pos.type = seek_type
301 raise AttributeError("seek_time is not available")
303 elif self._pos.type is not SEEK_TIME:
304 raise TypeError("seek_type is not SEEK_TIME")
306 return self._pos.u.seek_time
308 def _set_time(self, time):
310 raise AttributeError("seek_time is not available")
312 elif self._pos.type is not SEEK_TIME:
313 raise TypeError("seek_type is not SEEK_TIME")
315 self._pos.u.seek_time = time
321 seek_type = property(_get_type, _set_type)
322 seek_time = property(_get_time, _set_time)
329 def __init__(self, context, begin_pos = None, end_pos = None, _no_init = None):
331 Allocate a trace collection iterator.
333 begin_pos and end_pos are optional parameters to specify the
334 position at which the trace collection should be seeked upon
335 iterator creation, and the position at which iteration will
336 start returning "EOF".
338 By default, if begin_pos is None, a BT_SEEK_CUR is performed at
339 creation. By default, if end_pos is None, a BT_SEEK_END (end of
340 trace) is the EOF criterion.
343 if begin_pos is None:
348 except AttributeError:
349 raise TypeError("in __init__, "
350 "argument 3 must be a IterPos instance")
357 except AttributeError:
358 raise TypeError("in __init__, "
359 "argument 4 must be a IterPos instance")
362 self._bi = _bt_iter_create(context._c, bp, ep)
363 except AttributeError:
364 raise TypeError("in __init__, "
365 "argument 2 must be a Context instance")
367 self.__with_init = True
374 _bt_iter_destroy(self._bi)
378 Move trace collection position to the next event.
379 Returns 0 on success, a negative value on error.
381 return _bt_iter_next(self._bi)
384 """Return a IterPos class of the current iterator position."""
386 ret.__can_access = False
387 ret._pos = _bt_iter_get_pos(self._bi)
390 def set_pos(self, pos):
392 Move the iterator to a given position.
394 On error, the stream_heap is reinitialized and returned empty.
395 Return 0 for success.
396 Return EOF if the position requested is after the last event of the
398 Return -EINVAL when called with invalid parameter.
399 Return -ENOMEM if the stream_heap could not be properly initialized.
402 return _bt_iter_set_pos(self._bi, pos._pos)
403 except AttributeError:
404 raise TypeError("in set_pos, "
405 "argument 2 must be a IterPos instance")
407 def create_time_pos(self, timestamp):
409 Create a position based on time
410 This function allocates and returns a new IterPos to be able to
411 restore an iterator position based on a timestamp.
415 raise TypeError("timestamp must be an unsigned int")
418 ret.__can_access = False
419 ret._pos = _bt_iter_create_time_pos(self._bi, timestamp)
424 /* =================================================================
427 *** Enum copied from clock-type.h
428 All changes must also be made here
430 %rename("CLOCK_CYCLES") BT_CLOCK_CYCLES;
431 %rename("CLOCK_REAL") BT_CLOCK_REAL;
438 /* =================================================================
439 TRACE-HANDLE.H, TRACE-HANDLE-INTERNAL.H
440 ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
443 %rename("_bt_trace_handle_create") bt_trace_handle_create(struct bt_context *ctx);
444 %rename("_bt_trace_handle_destroy") bt_trace_handle_destroy(struct bt_trace_handle *bt);
445 struct bt_trace_handle *bt_trace_handle_create(struct bt_context *ctx);
446 void bt_trace_handle_destroy(struct bt_trace_handle *bt);
448 %rename("_bt_trace_handle_get_path") bt_trace_handle_get_path(struct bt_context *ctx,
450 %rename("_bt_trace_handle_get_timestamp_begin") bt_trace_handle_get_timestamp_begin(
451 struct bt_context *ctx, int handle_id, enum bt_clock_type type);
452 %rename("_bt_trace_handle_get_timestamp_end") bt_trace_handle_get_timestamp_end(
453 struct bt_context *ctx, int handle_id, enum bt_clock_type type);
454 const char *bt_trace_handle_get_path(struct bt_context *ctx, int handle_id);
455 uint64_t bt_trace_handle_get_timestamp_begin(struct bt_context *ctx, int handle_id,
456 enum bt_clock_type type);
457 uint64_t bt_trace_handle_get_timestamp_end(struct bt_context *ctx, int handle_id,
458 enum bt_clock_type type);
460 %rename("_bt_ctf_event_get_handle_id") bt_ctf_event_get_handle_id(
461 const struct bt_ctf_event *event);
462 int bt_ctf_event_get_handle_id(const struct bt_ctf_event *event);
467 class TraceHandle(object):
469 The TraceHandle allows the user to manipulate a trace file directly.
470 It is a unique identifier representing a trace file.
475 raise NotImplementedError("TraceHandle cannot be instantiated")
478 return "Babeltrace TraceHandle: trace_id('{}')".format(self._id)
481 """Return the TraceHandle id."""
484 def get_path(self, context):
485 """Return the path of a TraceHandle."""
487 return _bt_trace_handle_get_path(context._c, self._id)
488 except AttributeError:
489 raise TypeError("in get_path, "
490 "argument 2 must be a Context instance")
492 def get_timestamp_begin(self, context, clock_type):
493 """Return the creation time of the buffers of a trace."""
495 return _bt_trace_handle_get_timestamp_begin(
496 context._c, self._id,clock_type)
497 except AttributeError:
498 raise TypeError("in get_timestamp_begin, "
499 "argument 2 must be a Context instance")
501 def get_timestamp_end(self, context, clock_type):
502 """Return the destruction timestamp of the buffers of a trace."""
504 return _bt_trace_handle_get_timestamp_end(
505 context._c, self._id, clock_type)
506 except AttributeError:
507 raise TypeError("in get_timestamp_end, "
508 "argument 2 must be a Context instance")
514 // =================================================================
516 // =================================================================
518 /* =================================================================
524 %rename("_bt_ctf_iter_create") bt_ctf_iter_create(struct bt_context *ctx,
525 const struct bt_iter_pos *begin_pos,
526 const struct bt_iter_pos *end_pos);
527 %rename("_bt_ctf_get_iter") bt_ctf_get_iter(struct bt_ctf_iter *iter);
528 %rename("_bt_ctf_iter_destroy") bt_ctf_iter_destroy(struct bt_ctf_iter *iter);
529 %rename("_bt_ctf_iter_read_event") bt_ctf_iter_read_event(struct bt_ctf_iter *iter);
531 struct bt_ctf_iter *bt_ctf_iter_create(struct bt_context *ctx,
532 const struct bt_iter_pos *begin_pos,
533 const struct bt_iter_pos *end_pos);
534 struct bt_iter *bt_ctf_get_iter(struct bt_ctf_iter *iter);
535 void bt_ctf_iter_destroy(struct bt_ctf_iter *iter);
536 struct bt_ctf_event *bt_ctf_iter_read_event(struct bt_ctf_iter *iter);
541 %rename("_bt_ctf_get_top_level_scope") bt_ctf_get_top_level_scope(const struct
542 bt_ctf_event *event, enum bt_ctf_scope scope);
543 %rename("_bt_ctf_event_name") bt_ctf_event_name(const struct bt_ctf_event *ctf_event);
544 %rename("_bt_ctf_get_timestamp") bt_ctf_get_timestamp(
545 const struct bt_ctf_event *ctf_event);
546 %rename("_bt_ctf_get_cycles") bt_ctf_get_cycles(
547 const struct bt_ctf_event *ctf_event);
549 %rename("_bt_ctf_get_field") bt_ctf_get_field(const struct bt_ctf_event *ctf_event,
550 const struct bt_definition *scope, const char *field);
551 %rename("_bt_ctf_get_index") bt_ctf_get_index(const struct bt_ctf_event *ctf_event,
552 const struct bt_definition *field, unsigned int index);
553 %rename("_bt_ctf_field_name") bt_ctf_field_name(const struct bt_definition *field);
554 %rename("_bt_ctf_field_type") bt_ctf_field_type(const struct bt_declaration *field);
555 %rename("_bt_ctf_get_int_signedness") bt_ctf_get_int_signedness(
556 const struct bt_declaration *field);
557 %rename("_bt_ctf_get_int_base") bt_ctf_get_int_base(const struct bt_declaration *field);
558 %rename("_bt_ctf_get_int_byte_order") bt_ctf_get_int_byte_order(
559 const struct bt_declaration *field);
560 %rename("_bt_ctf_get_int_len") bt_ctf_get_int_len(const struct bt_declaration *field);
561 %rename("_bt_ctf_get_encoding") bt_ctf_get_encoding(const struct bt_declaration *field);
562 %rename("_bt_ctf_get_array_len") bt_ctf_get_array_len(const struct bt_declaration *field);
563 %rename("_bt_ctf_get_uint64") bt_ctf_get_uint64(const struct bt_definition *field);
564 %rename("_bt_ctf_get_int64") bt_ctf_get_int64(const struct bt_definition *field);
565 %rename("_bt_ctf_get_char_array") bt_ctf_get_char_array(const struct bt_definition *field);
566 %rename("_bt_ctf_get_string") bt_ctf_get_string(const struct bt_definition *field);
567 %rename("_bt_ctf_field_get_error") bt_ctf_field_get_error(void);
568 %rename("_bt_ctf_get_decl_event_name") bt_ctf_get_decl_event_name(const struct
569 bt_ctf_event_decl *event);
570 %rename("_bt_ctf_get_decl_field_name") bt_ctf_get_decl_field_name(
571 const struct bt_ctf_field_decl *field);
572 %rename("_bt_ctf_get_decl_from_def") bt_ctf_get_decl_from_def(
573 const struct bt_definition *field);
575 const struct bt_definition *bt_ctf_get_top_level_scope(const struct bt_ctf_event *ctf_event,
576 enum bt_ctf_scope scope);
577 const char *bt_ctf_event_name(const struct bt_ctf_event *ctf_event);
578 uint64_t bt_ctf_get_timestamp(const struct bt_ctf_event *ctf_event);
579 uint64_t bt_ctf_get_cycles(const struct bt_ctf_event *ctf_event);
580 const struct bt_definition *bt_ctf_get_field(const struct bt_ctf_event *ctf_event,
581 const struct bt_definition *scope,
583 const struct bt_definition *bt_ctf_get_index(const struct bt_ctf_event *ctf_event,
584 const struct bt_definition *field,
586 const char *bt_ctf_field_name(const struct bt_definition *field);
587 enum ctf_type_id bt_ctf_field_type(const struct bt_declaration *field);
588 int bt_ctf_get_int_signedness(const struct bt_declaration *field);
589 int bt_ctf_get_int_base(const struct bt_declaration *field);
590 int bt_ctf_get_int_byte_order(const struct bt_declaration *field);
591 ssize_t bt_ctf_get_int_len(const struct bt_declaration *field);
592 enum ctf_string_encoding bt_ctf_get_encoding(const struct bt_declaration *field);
593 int bt_ctf_get_array_len(const struct bt_declaration *field);
594 uint64_t bt_ctf_get_uint64(const struct bt_definition *field);
595 int64_t bt_ctf_get_int64(const struct bt_definition *field);
596 char *bt_ctf_get_char_array(const struct bt_definition *field);
597 char *bt_ctf_get_string(const struct bt_definition *field);
598 int bt_ctf_field_get_error(void);
599 const char *bt_ctf_get_decl_event_name(const struct bt_ctf_event_decl *event);
600 const char *bt_ctf_get_decl_field_name(const struct bt_ctf_field_decl *field);
601 const struct bt_declaration *bt_ctf_get_decl_from_def(const struct bt_definition *field);
607 #enum equivalent, accessible constants
608 #These are taken directly from ctf/events.h
609 #All changes to enums must also be made here
624 TRACE_PACKET_HEADER = 0
625 STREAM_PACKET_CONTEXT = 1
626 STREAM_EVENT_HEADER = 2
627 STREAM_EVENT_CONTEXT = 3
631 class string_encoding:
637 class Iterator(Iterator, object):
639 Allocate a CTF trace collection iterator.
641 begin_pos and end_pos are optional parameters to specify the
642 position at which the trace collection should be seeked upon
643 iterator creation, and the position at which iteration will
644 start returning "EOF".
646 By default, if begin_pos is None, a SEEK_CUR is performed at
647 creation. By default, if end_pos is None, a SEEK_END (end of
648 trace) is the EOF criterion.
650 Only one iterator can be created against a context. If more than one
651 iterator is being created for the same context, the second creation
652 will return None. The previous iterator must be destroyed before
653 creation of the new iterator for this function to succeed.
656 def __new__(cls, context, begin_pos = None, end_pos = None):
657 # __new__ is used to control the return value
658 # as the ctf.Iterator class should return None
659 # if bt_ctf_iter_create returns NULL
661 if begin_pos is None:
670 it = _bt_ctf_iter_create(context._c, bp, ep)
671 except AttributeError:
672 raise TypeError("in __init__, "
673 "argument 2 must be a Context instance")
677 ret_class = super(ctf.Iterator, cls).__new__(cls)
681 def __init__(self, context, begin_pos = None, end_pos = None):
682 Iterator.__init__(self, None, None, None,
683 _bt_ctf_get_iter(self._i))
686 _bt_ctf_iter_destroy(self._i)
688 def read_event(self):
690 Read the iterator's current event data.
691 Return current event on success, None on end of trace.
693 ret = _bt_ctf_iter_read_event(self._i)
696 ev = ctf.Event.__new__(ctf.Event)
703 This class represents an event from the trace.
704 It is obtained with read_event() from ctf.Iterator.
709 raise NotImplementedError("ctf.Event cannot be instantiated")
711 def get_top_level_scope(self, scope):
713 Return a definition of the top-level scope
714 Top-level scopes are defined in ctf.scope.
715 In order to get a field or a field list, the user needs to pass a
716 scope as argument, this scope can be a top-level scope or a scope
717 relative to an arbitrary field. This function provides the mapping
718 between the scope and the actual definition of top-level scopes.
719 On error return None.
721 evDef = ctf.Definition.__new__(ctf.Definition)
722 evDef._d = _bt_ctf_get_top_level_scope(self._e, scope)
728 """Return the name of the event or None on error."""
729 return _bt_ctf_event_name(self._e)
731 def get_cycles(self):
733 Return the timestamp of the event as written in
734 the packet (in cycles) or -1ULL on error.
736 return _bt_ctf_get_cycles(self._e)
738 def get_timestamp(self):
740 Return the timestamp of the event offsetted with the
741 system clock source or -1ULL on error.
743 return _bt_ctf_get_timestamp(self._e)
745 def get_field(self, scope, field):
746 """Return the definition of a specific field."""
747 evDef = ctf.Definition.__new__(ctf.Definition)
749 evDef._d = _bt_ctf_get_field(self._e, scope._d, field)
750 except AttributeError:
751 raise TypeError("in get_field, argument 2 must be a "
752 "Definition (scope) instance")
755 def get_field_list(self, scope):
757 Return a list of Definitions
758 Return None on error.
761 field_lc = _bt_python_field_listcaller(self._e, scope._d)
762 except AttributeError:
763 raise TypeError("in get_field_list, argument 2 must be a "
764 "Definition (scope) instance")
772 tmp = ctf.Definition.__new__(ctf.Definition)
773 tmp._d = _bt_python_field_one_from_list(field_lc, i)
776 #Last item of list is None, assured in
777 #_bt_python_field_listcaller
784 def get_index(self, field, index):
786 If the field is an array or a sequence, return the element
787 at position index, otherwise return None
789 evDef = ctf.Definition.__new__(ctf.Definition)
791 evDef._d = _bt_ctf_get_index(self._e, field._d, index)
792 except AttributeError:
793 raise TypeError("in get_index, argument 2 must be a "
794 "Definition (field) instance")
800 def get_handle(self):
802 Get the TraceHandle associated with an event
805 ret = _bt_ctf_event_get_handle_id(self._e)
809 th = TraceHandle.__new__(TraceHandle)
813 def get_context(self):
815 Get the context associated with an event.
816 Return None on error.
819 ctx._c = _bt_ctf_event_get_context(self._e);
826 class Definition(object):
827 """Definition class. Do not instantiate."""
830 raise NotImplementedError("ctf.Definition cannot be instantiated")
833 return "Babeltrace Definition: name('{}'), type({})".format(
834 self.field_name(), self.field_type())
836 def field_name(self):
837 """Return the name of a field or None on error."""
838 return _bt_ctf_field_name(self._d)
840 def field_type(self):
841 """Return the type of a field or -1 if unknown."""
842 return _bt_ctf_field_type(_bt_ctf_get_decl_from_def(self._d))
844 def get_int_signedness(self):
846 Return the signedness of an integer:
847 0 if unsigned; 1 if signed; -1 on error.
849 return _bt_ctf_get_int_signedness(_bt_ctf_get_decl_from_def(self._d))
851 def get_int_base(self):
852 """Return the base of an int or a negative value on error."""
853 return _bt_ctf_get_int_base(_bt_ctf_get_decl_from_def(self._d))
855 def get_int_byte_order(self):
857 Return the byte order of an int or a negative
860 return _bt_ctf_get_int_byte_order(_bt_ctf_get_decl_from_def(self._d))
862 def get_int_len(self):
864 Return the size, in bits, of an int or a negative
867 return _bt_ctf_get_int_len(self._d)
869 def get_encoding(self):
871 Return the encoding of an int or a string.
872 Return a negative value on error.
874 return _bt_ctf_get_encoding(_bt_ctf_get_decl_from_def(self._d))
876 def get_array_len(self):
878 Return the len of an array or a negative
881 return _bt_ctf_get_array_len(_bt_ctf_get_decl_from_def(self._d))
883 def get_uint64(self):
885 Return the value associated with the field.
886 If the field does not exist or is not of the type requested,
887 the value returned is undefined. To check if an error occured,
888 use the ctf.field_error() function after accessing a field.
890 return _bt_ctf_get_uint64(self._d)
894 Return the value associated with the field.
895 If the field does not exist or is not of the type requested,
896 the value returned is undefined. To check if an error occured,
897 use the ctf.field_error() function after accessing a field.
899 return _bt_ctf_get_int64(self._d)
901 def get_char_array(self):
903 Return the value associated with the field.
904 If the field does not exist or is not of the type requested,
905 the value returned is undefined. To check if an error occured,
906 use the ctf.field_error() function after accessing a field.
908 return _bt_ctf_get_char_array(self._d)
912 Return the value associated with the field.
913 If the field does not exist or is not of the type requested,
914 the value returned is undefined. To check if an error occured,
915 use the ctf.field_error() function after accessing a field.
917 return _bt_ctf_get_string(self._d)
920 class EventDecl(object):
921 """Event declaration class. Do not instantiate."""
924 raise NotImplementedError("ctf.EventDecl cannot be instantiated")
927 return "Babeltrace EventDecl: name {}".format(self.get_name())
930 """Return the name of the event or None on error"""
931 return _bt_ctf_get_decl_event_name(self._d)
933 def get_decl_fields(self, scope):
935 Return a list of ctf.FieldDecl
936 Return None on error.
938 ptr_list = _by_python_field_decl_listcaller(self._d, scope)
946 tmp = ctf.FieldDecl.__new__(ctf.FieldDecl)
947 tmp._d = _bt_python_field_decl_one_from_list(
951 #Last item of list is None
954 decl_list.append(tmp)
959 class FieldDecl(object):
960 """Field declaration class. Do not instantiate."""
963 raise NotImplementedError("ctf.FieldDecl cannot be instantiated")
966 return "Babeltrace FieldDecl: name {}".format(self.get_name())
969 """Return the name of a FieldDecl or None on error"""
970 return _bt_ctf_get_decl_field_name(self._d)
976 Return the last error code encountered while
977 accessing a field and reset the error flag.
978 Return 0 if no error, a negative value otherwise.
980 return _bt_ctf_field_get_error()
983 def get_event_decl_list(trace_handle, context):
985 Return a list of ctf.EventDecl
986 Return None on error.
989 handle_id = trace_handle._id
990 except AttributeError:
991 raise TypeError("in get_event_decl_list, "
992 "argument 1 must be a TraceHandle instance")
994 ptr_list = _bt_python_event_decl_listcaller(handle_id, context._c)
995 except AttributeError:
996 raise TypeError("in get_event_decl_list, "
997 "argument 2 must be a Context instance")
1005 tmp = ctf.EventDecl.__new__(ctf.EventDecl)
1006 tmp._d = _bt_python_decl_one_from_list(ptr_list, i)
1009 #Last item of list is None
1012 decl_list.append(tmp)
1020 // =================================================================
1022 // File and list-related
1023 // python-complements.h
1024 // =================================================================
1026 %include python-complements.c
1032 Open a file for babeltrace.
1034 file_path is a string containing the path or None to use the
1035 standard output in writing mode.
1037 The mode can be 'r', 'w' or 'a' for reading (default), writing or
1038 appending. The file will be created if it doesn't exist when
1039 opened for writing or appending; it will be truncated when opened
1040 for writing. Add a 'b' to the mode for binary files. Add a '+'
1041 to the mode to allow simultaneous reading and writing.
1044 def __new__(cls, file_path, mode='r'):
1045 # __new__ is used to control the return value
1046 # as the File class should return None
1047 # if _bt_file_open returns NULL
1050 if file_path is not None and type(file_path) is not str:
1051 raise TypeError("in method __init__, argument 2 of type 'str'")
1052 if type(mode) is not str:
1053 raise TypeError("in method __init__, argument 3 of type 'str'")
1056 file_ptr = _bt_file_open(file_path, mode)
1057 if file_ptr is None:
1060 # Class instantiation
1061 file_inst = super(File, cls).__new__(cls)
1062 file_inst._file = file_ptr
1065 def __init__(self, file_path, mode='r'):
1067 self._use_stdout = False
1069 if file_path is None:
1071 file_path = "stdout"
1073 self._use_stdout = True
1075 self._file_path = file_path
1086 return "{} babeltrace File; file_path('{}'), mode('{}')".format(
1087 stat, self._file_path, self._mode)
1090 """Close the file. Is also called using del."""
1091 if self._opened and not self._use_stdout:
1092 _bt_file_close(self._file)
1093 self._opened = False