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/uuid.h>
49 #include <babeltrace/types.h>
50 #include <babeltrace/ctf/iterator.h>
51 #include "python-complements.h"
54 typedef unsigned long long uint64_t;
55 typedef long long int64_t;
56 typedef int bt_intern_str;
58 /* =================================================================
59 CONTEXT.H, CONTEXT-INTERNAL.H
60 ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
63 %rename("_bt_context_create") bt_context_create(void);
64 %rename("_bt_context_add_trace") bt_context_add_trace(
65 struct bt_context *ctx, const char *path, const char *format,
66 void (*packet_seek)(struct stream_pos *pos, size_t index, int whence),
67 struct mmap_stream_list *stream_list, FILE *metadata);
68 %rename("_bt_context_remove_trace") bt_context_remove_trace(
69 struct bt_context *ctx, int trace_id);
70 %rename("_bt_context_get") bt_context_get(struct bt_context *ctx);
71 %rename("_bt_context_put") bt_context_put(struct bt_context *ctx);
72 %rename("_bt_ctf_event_get_context") bt_ctf_event_get_context(
73 const struct bt_ctf_event *event);
75 struct bt_context *bt_context_create(void);
76 int bt_context_add_trace(struct bt_context *ctx, const char *path, const char *format,
77 void (*packet_seek)(struct stream_pos *pos, size_t index, int whence),
78 struct mmap_stream_list *stream_list, FILE *metadata);
79 void bt_context_remove_trace(struct bt_context *ctx, int trace_id);
80 void bt_context_get(struct bt_context *ctx);
81 void bt_context_put(struct bt_context *ctx);
82 struct bt_context *bt_ctf_event_get_context(const struct bt_ctf_event *event);
84 // class Context to prevent direct access to struct bt_context
88 The context represents the object in which a trace_collection is
89 open. As long as this structure is allocated, the trace_collection
90 is open and the traces it contains can be read and seeked by the
91 iterators and callbacks.
95 self._c = _bt_context_create()
98 _bt_context_put(self._c)
100 def add_trace(self, path, format_str,
101 packet_seek=None, stream_list=None, metadata=None):
103 Add a trace by path to the context.
107 path is the path to the trace, it is not recursive.
108 If "path" is None, stream_list is used instead as a list
109 of mmap streams to open for the trace.
111 format is a string containing the format name in which the trace was
114 packet_seek is not implemented for Python. Should be left None to
115 use the default packet_seek handler provided by the trace format.
117 stream_list is a linked list of streams, it is used to open a trace
118 where the trace data is located in memory mapped areas instead of
119 trace files, this argument should be None when path is not None.
121 The metadata parameter acts as a metadata override when not None,
122 otherwise the format handles the metadata opening.
124 Return: the corresponding TraceHandle on success or None on error.
126 if metadata is not None:
127 metadata = metadata._file
129 ret = _bt_context_add_trace(self._c, path, format_str, packet_seek,
130 stream_list, metadata)
134 th = TraceHandle.__new__(TraceHandle)
138 def add_traces_recursive(self, path, format_str):
140 Open a trace recursively.
142 Find each trace present in the subdirectory starting from the given
143 path, and add them to the context.
145 Return a dict of TraceHandle instances (the full path is the key).
146 Return None on error.
156 for fullpath, dirs, files in os.walk(path):
157 if "metadata" in files:
158 trace_handle = self.add_trace(fullpath, format_str)
159 if trace_handle is None:
163 trace_handles[fullpath] = trace_handle
166 if noTrace and error:
170 def remove_trace(self, trace_handle):
172 Remove a trace from the context.
173 Effectively closing the trace.
176 _bt_context_remove_trace(self._c, trace_handle._id)
177 except AttributeError:
178 raise TypeError("in remove_trace, "
179 "argument 2 must be a TraceHandle instance")
184 /* =================================================================
189 %rename("lookup_format") bt_lookup_format(bt_intern_str qname);
190 %rename("_bt_print_format_list") bt_fprintf_format_list(FILE *fp);
191 %rename("register_format") bt_register_format(struct format *format);
193 extern struct format *bt_lookup_format(bt_intern_str qname);
194 extern void bt_fprintf_format_list(FILE *fp);
195 extern int bt_register_format(struct format *format);
199 def print_format_list(babeltrace_file):
201 Print a list of available formats to file.
203 babeltrace_file must be a File instance opened in write mode.
206 if babeltrace_file._file is not None:
207 _bt_print_format_list(babeltrace_file._file)
208 except AttributeError:
209 raise TypeError("in print_format_list, "
210 "argument 1 must be a File instance")
215 /* =================================================================
216 ITERATOR.H, ITERATOR-INTERNAL.H
217 ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
220 %rename("_bt_iter_create") bt_iter_create(struct bt_context *ctx,
221 const struct bt_iter_pos *begin_pos, const struct bt_iter_pos *end_pos);
222 %rename("_bt_iter_destroy") bt_iter_destroy(struct bt_iter *iter);
223 %rename("_bt_iter_next") bt_iter_next(struct bt_iter *iter);
224 %rename("_bt_iter_get_pos") bt_iter_get_pos(struct bt_iter *iter);
225 %rename("_bt_iter_free_pos") bt_iter_free_pos(struct bt_iter_pos *pos);
226 %rename("_bt_iter_set_pos") bt_iter_set_pos(struct bt_iter *iter,
227 const struct bt_iter_pos *pos);
228 %rename("_bt_iter_create_time_pos") bt_iter_create_time_pos(struct bt_iter *iter,
231 struct bt_iter *bt_iter_create(struct bt_context *ctx,
232 const struct bt_iter_pos *begin_pos, const struct bt_iter_pos *end_pos);
233 void bt_iter_destroy(struct bt_iter *iter);
234 int bt_iter_next(struct bt_iter *iter);
235 struct bt_iter_pos *bt_iter_get_pos(struct bt_iter *iter);
236 void bt_iter_free_pos(struct bt_iter_pos *pos);
237 int bt_iter_set_pos(struct bt_iter *iter, const struct bt_iter_pos *pos);
238 struct bt_iter_pos *bt_iter_create_time_pos(struct bt_iter *iter, uint64_t timestamp);
240 %rename("_bt_iter_pos") bt_iter_pos;
241 %rename("SEEK_TIME") BT_SEEK_TIME;
242 %rename("SEEK_RESTORE") BT_SEEK_RESTORE;
243 %rename("SEEK_CUR") BT_SEEK_CUR;
244 %rename("SEEK_BEGIN") BT_SEEK_BEGIN;
245 %rename("SEEK_LAST") BT_SEEK_LAST;
247 // This struct is taken from iterator.h
248 // All changes to the struct must also be made here
251 BT_SEEK_TIME, /* uses u.seek_time */
252 BT_SEEK_RESTORE, /* uses u.restore */
259 struct bt_saved_pos *restore;
267 """This class represents the position where to set an iterator."""
271 def __init__(self, seek_type, seek_time = None):
273 seek_type represents the type of seek to use.
274 seek_time is the timestamp to seek to when using SEEK_TIME, it
275 is expressed in nanoseconds
276 Only use SEEK_RESTORE on IterPos obtained from the get_pos function
280 self._pos = _bt_iter_pos()
281 self._pos.type = seek_type
282 if seek_time and seek_type == SEEK_TIME:
283 self._pos.u.seek_time = seek_time
284 self.__can_access = True
287 if not self.__can_access:
288 _bt_iter_free_pos(self._pos)
292 raise AttributeError("seek_type is not available")
293 return self._pos.type
295 def _set_type(self, seek_type):
297 raise AttributeError("seek_type is not available")
298 self._pos.type = seek_type
302 raise AttributeError("seek_time is not available")
304 elif self._pos.type is not SEEK_TIME:
305 raise TypeError("seek_type is not SEEK_TIME")
307 return self._pos.u.seek_time
309 def _set_time(self, time):
311 raise AttributeError("seek_time is not available")
313 elif self._pos.type is not SEEK_TIME:
314 raise TypeError("seek_type is not SEEK_TIME")
316 self._pos.u.seek_time = time
322 seek_type = property(_get_type, _set_type)
323 seek_time = property(_get_time, _set_time)
330 def __init__(self, context, begin_pos = None, end_pos = None, _no_init = None):
332 Allocate a trace collection iterator.
334 begin_pos and end_pos are optional parameters to specify the
335 position at which the trace collection should be seeked upon
336 iterator creation, and the position at which iteration will
337 start returning "EOF".
339 By default, if begin_pos is None, a BT_SEEK_CUR is performed at
340 creation. By default, if end_pos is None, a BT_SEEK_END (end of
341 trace) is the EOF criterion.
344 if begin_pos is None:
349 except AttributeError:
350 raise TypeError("in __init__, "
351 "argument 3 must be a IterPos instance")
358 except AttributeError:
359 raise TypeError("in __init__, "
360 "argument 4 must be a IterPos instance")
363 self._bi = _bt_iter_create(context._c, bp, ep)
364 except AttributeError:
365 raise TypeError("in __init__, "
366 "argument 2 must be a Context instance")
368 self.__with_init = True
375 _bt_iter_destroy(self._bi)
379 Move trace collection position to the next event.
380 Returns 0 on success, a negative value on error.
382 return _bt_iter_next(self._bi)
385 """Return a IterPos class of the current iterator position."""
387 ret.__can_access = False
388 ret._pos = _bt_iter_get_pos(self._bi)
391 def set_pos(self, pos):
393 Move the iterator to a given position.
395 On error, the stream_heap is reinitialized and returned empty.
396 Return 0 for success.
397 Return EOF if the position requested is after the last event of the
399 Return -EINVAL when called with invalid parameter.
400 Return -ENOMEM if the stream_heap could not be properly initialized.
403 return _bt_iter_set_pos(self._bi, pos._pos)
404 except AttributeError:
405 raise TypeError("in set_pos, "
406 "argument 2 must be a IterPos instance")
408 def create_time_pos(self, timestamp):
410 Create a position based on time
411 This function allocates and returns a new IterPos to be able to
412 restore an iterator position based on a timestamp.
416 raise TypeError("timestamp must be an unsigned int")
419 ret.__can_access = False
420 ret._pos = _bt_iter_create_time_pos(self._bi, timestamp)
425 /* =================================================================
428 *** Enum copied from clock-type.h
429 All changes must also be made here
431 %rename("CLOCK_CYCLES") BT_CLOCK_CYCLES;
432 %rename("CLOCK_REAL") BT_CLOCK_REAL;
439 /* =================================================================
440 TRACE-HANDLE.H, TRACE-HANDLE-INTERNAL.H
441 ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
444 %rename("_bt_trace_handle_create") bt_trace_handle_create(struct bt_context *ctx);
445 %rename("_bt_trace_handle_destroy") bt_trace_handle_destroy(struct bt_trace_handle *bt);
446 struct bt_trace_handle *bt_trace_handle_create(struct bt_context *ctx);
447 void bt_trace_handle_destroy(struct bt_trace_handle *bt);
449 %rename("_bt_trace_handle_get_path") bt_trace_handle_get_path(struct bt_context *ctx,
451 %rename("_bt_trace_handle_get_timestamp_begin") bt_trace_handle_get_timestamp_begin(
452 struct bt_context *ctx, int handle_id, enum bt_clock_type type);
453 %rename("_bt_trace_handle_get_timestamp_end") bt_trace_handle_get_timestamp_end(
454 struct bt_context *ctx, int handle_id, enum bt_clock_type type);
455 %rename("_bt_trace_handle_get_id") bt_trace_handle_get_id(struct bt_trace_handle *th);
456 int bt_trace_handle_get_id(struct bt_trace_handle *th);
457 const char *bt_trace_handle_get_path(struct bt_context *ctx, int handle_id);
458 uint64_t bt_trace_handle_get_timestamp_begin(struct bt_context *ctx, int handle_id,
459 enum bt_clock_type type);
460 uint64_t bt_trace_handle_get_timestamp_end(struct bt_context *ctx, int handle_id,
461 enum bt_clock_type type);
463 %rename("_bt_ctf_event_get_handle_id") bt_ctf_event_get_handle_id(
464 const struct bt_ctf_event *event);
465 int bt_ctf_event_get_handle_id(const struct bt_ctf_event *event);
470 class TraceHandle(object):
472 The TraceHandle allows the user to manipulate a trace file directly.
473 It is a unique identifier representing a trace file.
478 raise NotImplementedError("TraceHandle cannot be instantiated")
481 return "Babeltrace TraceHandle: trace_id('{}')".format(self._id)
484 """Return the TraceHandle id."""
487 def get_path(self, context):
488 """Return the path of a TraceHandle."""
490 return _bt_trace_handle_get_path(context._c, self._id)
491 except AttributeError:
492 raise TypeError("in get_path, "
493 "argument 2 must be a Context instance")
495 def get_timestamp_begin(self, context, clock_type):
496 """Return the creation time of the buffers of a trace."""
498 return _bt_trace_handle_get_timestamp_begin(
499 context._c, self._id,clock_type)
500 except AttributeError:
501 raise TypeError("in get_timestamp_begin, "
502 "argument 2 must be a Context instance")
504 def get_timestamp_end(self, context, clock_type):
505 """Return the destruction timestamp of the buffers of a trace."""
507 return _bt_trace_handle_get_timestamp_end(
508 context._c, self._id, clock_type)
509 except AttributeError:
510 raise TypeError("in get_timestamp_end, "
511 "argument 2 must be a Context instance")
517 // =================================================================
519 // =================================================================
521 /* =================================================================
527 %rename("_bt_ctf_iter_create") bt_ctf_iter_create(struct bt_context *ctx,
528 const struct bt_iter_pos *begin_pos,
529 const struct bt_iter_pos *end_pos);
530 %rename("_bt_ctf_get_iter") bt_ctf_get_iter(struct bt_ctf_iter *iter);
531 %rename("_bt_ctf_iter_destroy") bt_ctf_iter_destroy(struct bt_ctf_iter *iter);
532 %rename("_bt_ctf_iter_read_event") bt_ctf_iter_read_event(struct bt_ctf_iter *iter);
534 struct bt_ctf_iter *bt_ctf_iter_create(struct bt_context *ctx,
535 const struct bt_iter_pos *begin_pos,
536 const struct bt_iter_pos *end_pos);
537 struct bt_iter *bt_ctf_get_iter(struct bt_ctf_iter *iter);
538 void bt_ctf_iter_destroy(struct bt_ctf_iter *iter);
539 struct bt_ctf_event *bt_ctf_iter_read_event(struct bt_ctf_iter *iter);
544 %rename("_bt_ctf_get_top_level_scope") bt_ctf_get_top_level_scope(const struct
545 bt_ctf_event *event, enum bt_ctf_scope scope);
546 %rename("_bt_ctf_event_name") bt_ctf_event_name(const struct bt_ctf_event *ctf_event);
547 %rename("_bt_ctf_get_timestamp") bt_ctf_get_timestamp(
548 const struct bt_ctf_event *ctf_event);
549 %rename("_bt_ctf_get_cycles") bt_ctf_get_cycles(
550 const struct bt_ctf_event *ctf_event);
552 %rename("_bt_ctf_get_field") bt_ctf_get_field(const struct bt_ctf_event *ctf_event,
553 const struct definition *scope, const char *field);
554 %rename("_bt_ctf_get_index") bt_ctf_get_index(const struct bt_ctf_event *ctf_event,
555 const struct definition *field, unsigned int index);
556 %rename("_bt_ctf_field_name") bt_ctf_field_name(const struct definition *def);
557 %rename("_bt_ctf_field_type") bt_ctf_field_type(const struct declaration *def);
558 %rename("_bt_ctf_get_int_signedness") bt_ctf_get_int_signedness(
559 const struct declaration *field);
560 %rename("_bt_ctf_get_int_base") bt_ctf_get_int_base(const struct declaration *field);
561 %rename("_bt_ctf_get_int_byte_order") bt_ctf_get_int_byte_order(
562 const struct declaration *field);
563 %rename("_bt_ctf_get_int_len") bt_ctf_get_int_len(const struct declaration *field);
564 %rename("_bt_ctf_get_encoding") bt_ctf_get_encoding(const struct declaration *field);
565 %rename("_bt_ctf_get_array_len") bt_ctf_get_array_len(const struct declaration *field);
566 %rename("_bt_ctf_get_uint64") bt_ctf_get_uint64(const struct definition *field);
567 %rename("_bt_ctf_get_int64") bt_ctf_get_int64(const struct definition *field);
568 %rename("_bt_ctf_get_char_array") bt_ctf_get_char_array(const struct definition *field);
569 %rename("_bt_ctf_get_string") bt_ctf_get_string(const struct definition *field);
570 %rename("_bt_ctf_field_get_error") bt_ctf_field_get_error(void);
571 %rename("_bt_ctf_get_decl_event_name") bt_ctf_get_decl_event_name(const struct
572 bt_ctf_event_decl *event);
573 %rename("_bt_ctf_get_decl_field_name") bt_ctf_get_decl_field_name(
574 const struct bt_ctf_field_decl *field);
576 const struct definition *bt_ctf_get_top_level_scope(const struct bt_ctf_event *ctf_event,
577 enum bt_ctf_scope scope);
578 const char *bt_ctf_event_name(const struct bt_ctf_event *ctf_event);
579 uint64_t bt_ctf_get_timestamp(const struct bt_ctf_event *ctf_event);
580 uint64_t bt_ctf_get_cycles(const struct bt_ctf_event *ctf_event);
581 const struct definition *bt_ctf_get_field(const struct bt_ctf_event *ctf_event,
582 const struct definition *scope,
584 const struct definition *bt_ctf_get_index(const struct bt_ctf_event *ctf_event,
585 const struct definition *field,
587 const char *bt_ctf_field_name(const struct definition *def);
588 enum ctf_type_id bt_ctf_field_type(const struct declaration *def);
589 int bt_ctf_get_int_signedness(const struct declaration *field);
590 int bt_ctf_get_int_base(const struct declaration *field);
591 int bt_ctf_get_int_byte_order(const struct declaration *field);
592 ssize_t bt_ctf_get_int_len(const struct declaration *field);
593 enum ctf_string_encoding bt_ctf_get_encoding(const struct declaration *field);
594 int bt_ctf_get_array_len(const struct declaration *field);
595 uint64_t bt_ctf_get_uint64(const struct definition *field);
596 int64_t bt_ctf_get_int64(const struct definition *field);
597 char *bt_ctf_get_char_array(const struct definition *field);
598 char *bt_ctf_get_string(const struct definition *field);
599 int bt_ctf_field_get_error(void);
600 const char *bt_ctf_get_decl_event_name(const struct bt_ctf_event_decl *event);
601 const char *bt_ctf_get_decl_field_name(const struct bt_ctf_field_decl *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(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(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(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(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(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(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