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);
197 void format_init(void);
198 void format_finalize(void);
202 def print_format_list(babeltrace_file):
204 Print a list of available formats to file.
206 babeltrace_file must be a File instance opened in write mode.
209 if babeltrace_file._file is not None:
210 _bt_print_format_list(babeltrace_file._file)
211 except AttributeError:
212 raise TypeError("in print_format_list, "
213 "argument 1 must be a File instance")
218 /* =================================================================
219 ITERATOR.H, ITERATOR-INTERNAL.H
220 ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
223 %rename("_bt_iter_create") bt_iter_create(struct bt_context *ctx,
224 const struct bt_iter_pos *begin_pos, const struct bt_iter_pos *end_pos);
225 %rename("_bt_iter_destroy") bt_iter_destroy(struct bt_iter *iter);
226 %rename("_bt_iter_next") bt_iter_next(struct bt_iter *iter);
227 %rename("_bt_iter_get_pos") bt_iter_get_pos(struct bt_iter *iter);
228 %rename("_bt_iter_free_pos") bt_iter_free_pos(struct bt_iter_pos *pos);
229 %rename("_bt_iter_set_pos") bt_iter_set_pos(struct bt_iter *iter,
230 const struct bt_iter_pos *pos);
231 %rename("_bt_iter_create_time_pos") bt_iter_create_time_pos(struct bt_iter *iter,
234 struct bt_iter *bt_iter_create(struct bt_context *ctx,
235 const struct bt_iter_pos *begin_pos, const struct bt_iter_pos *end_pos);
236 void bt_iter_destroy(struct bt_iter *iter);
237 int bt_iter_next(struct bt_iter *iter);
238 struct bt_iter_pos *bt_iter_get_pos(struct bt_iter *iter);
239 void bt_iter_free_pos(struct bt_iter_pos *pos);
240 int bt_iter_set_pos(struct bt_iter *iter, const struct bt_iter_pos *pos);
241 struct bt_iter_pos *bt_iter_create_time_pos(struct bt_iter *iter, uint64_t timestamp);
243 %rename("_bt_iter_pos") bt_iter_pos;
244 %rename("SEEK_TIME") BT_SEEK_TIME;
245 %rename("SEEK_RESTORE") BT_SEEK_RESTORE;
246 %rename("SEEK_CUR") BT_SEEK_CUR;
247 %rename("SEEK_BEGIN") BT_SEEK_BEGIN;
248 %rename("SEEK_LAST") BT_SEEK_LAST;
250 // This struct is taken from iterator.h
251 // All changes to the struct must also be made here
254 BT_SEEK_TIME, /* uses u.seek_time */
255 BT_SEEK_RESTORE, /* uses u.restore */
262 struct bt_saved_pos *restore;
270 """This class represents the position where to set an iterator."""
274 def __init__(self, seek_type, seek_time = None):
276 seek_type represents the type of seek to use.
277 seek_time is the timestamp to seek to when using SEEK_TIME, it
278 is expressed in nanoseconds
279 Only use SEEK_RESTORE on IterPos obtained from the get_pos function
283 self._pos = _bt_iter_pos()
284 self._pos.type = seek_type
285 if seek_time and seek_type == SEEK_TIME:
286 self._pos.u.seek_time = seek_time
287 self.__can_access = True
290 if not self.__can_access:
291 _bt_iter_free_pos(self._pos)
295 raise AttributeError("seek_type is not available")
296 return self._pos.type
298 def _set_type(self, seek_type):
300 raise AttributeError("seek_type is not available")
301 self._pos.type = seek_type
305 raise AttributeError("seek_time is not available")
307 elif self._pos.type is not SEEK_TIME:
308 raise TypeError("seek_type is not SEEK_TIME")
310 return self._pos.u.seek_time
312 def _set_time(self, time):
314 raise AttributeError("seek_time is not available")
316 elif self._pos.type is not SEEK_TIME:
317 raise TypeError("seek_type is not SEEK_TIME")
319 self._pos.u.seek_time = time
325 seek_type = property(_get_type, _set_type)
326 seek_time = property(_get_time, _set_time)
333 def __init__(self, context, begin_pos = None, end_pos = None, _no_init = None):
335 Allocate a trace collection iterator.
337 begin_pos and end_pos are optional parameters to specify the
338 position at which the trace collection should be seeked upon
339 iterator creation, and the position at which iteration will
340 start returning "EOF".
342 By default, if begin_pos is None, a BT_SEEK_CUR is performed at
343 creation. By default, if end_pos is None, a BT_SEEK_END (end of
344 trace) is the EOF criterion.
347 if begin_pos is None:
352 except AttributeError:
353 raise TypeError("in __init__, "
354 "argument 3 must be a IterPos instance")
361 except AttributeError:
362 raise TypeError("in __init__, "
363 "argument 4 must be a IterPos instance")
366 self._bi = _bt_iter_create(context._c, bp, ep)
367 except AttributeError:
368 raise TypeError("in __init__, "
369 "argument 2 must be a Context instance")
371 self.__with_init = True
378 _bt_iter_destroy(self._bi)
382 Move trace collection position to the next event.
383 Returns 0 on success, a negative value on error.
385 return _bt_iter_next(self._bi)
388 """Return a IterPos class of the current iterator position."""
390 ret.__can_access = False
391 ret._pos = _bt_iter_get_pos(self._bi)
394 def set_pos(self, pos):
396 Move the iterator to a given position.
398 On error, the stream_heap is reinitialized and returned empty.
399 Return 0 for success.
400 Return EOF if the position requested is after the last event of the
402 Return -EINVAL when called with invalid parameter.
403 Return -ENOMEM if the stream_heap could not be properly initialized.
406 return _bt_iter_set_pos(self._bi, pos._pos)
407 except AttributeError:
408 raise TypeError("in set_pos, "
409 "argument 2 must be a IterPos instance")
411 def create_time_pos(self, timestamp):
413 Create a position based on time
414 This function allocates and returns a new IterPos to be able to
415 restore an iterator position based on a timestamp.
419 raise TypeError("timestamp must be an unsigned int")
422 ret.__can_access = False
423 ret._pos = _bt_iter_create_time_pos(self._bi, timestamp)
428 /* =================================================================
431 *** Enum copied from clock-type.h
432 All changes must also be made here
434 %rename("CLOCK_CYCLES") BT_CLOCK_CYCLES;
435 %rename("CLOCK_REAL") BT_CLOCK_REAL;
442 /* =================================================================
443 TRACE-HANDLE.H, TRACE-HANDLE-INTERNAL.H
444 ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
447 %rename("_bt_trace_handle_create") bt_trace_handle_create(struct bt_context *ctx);
448 %rename("_bt_trace_handle_destroy") bt_trace_handle_destroy(struct bt_trace_handle *bt);
449 struct bt_trace_handle *bt_trace_handle_create(struct bt_context *ctx);
450 void bt_trace_handle_destroy(struct bt_trace_handle *bt);
452 %rename("_bt_trace_handle_get_path") bt_trace_handle_get_path(struct bt_context *ctx,
454 %rename("_bt_trace_handle_get_timestamp_begin") bt_trace_handle_get_timestamp_begin(
455 struct bt_context *ctx, int handle_id, enum bt_clock_type type);
456 %rename("_bt_trace_handle_get_timestamp_end") bt_trace_handle_get_timestamp_end(
457 struct bt_context *ctx, int handle_id, enum bt_clock_type type);
458 %rename("_bt_trace_handle_get_id") bt_trace_handle_get_id(struct bt_trace_handle *th);
459 int bt_trace_handle_get_id(struct bt_trace_handle *th);
460 const char *bt_trace_handle_get_path(struct bt_context *ctx, int handle_id);
461 uint64_t bt_trace_handle_get_timestamp_begin(struct bt_context *ctx, int handle_id,
462 enum bt_clock_type type);
463 uint64_t bt_trace_handle_get_timestamp_end(struct bt_context *ctx, int handle_id,
464 enum bt_clock_type type);
466 %rename("_bt_ctf_event_get_handle_id") bt_ctf_event_get_handle_id(
467 const struct bt_ctf_event *event);
468 int bt_ctf_event_get_handle_id(const struct bt_ctf_event *event);
473 class TraceHandle(object):
475 The TraceHandle allows the user to manipulate a trace file directly.
476 It is a unique identifier representing a trace file.
481 raise NotImplementedError("TraceHandle cannot be instantiated")
484 return "Babeltrace TraceHandle: trace_id('{}')".format(self._id)
487 """Return the TraceHandle id."""
490 def get_path(self, context):
491 """Return the path of a TraceHandle."""
493 return _bt_trace_handle_get_path(context._c, self._id)
494 except AttributeError:
495 raise TypeError("in get_path, "
496 "argument 2 must be a Context instance")
498 def get_timestamp_begin(self, context, clock_type):
499 """Return the creation time of the buffers of a trace."""
501 return _bt_trace_handle_get_timestamp_begin(
502 context._c, self._id,clock_type)
503 except AttributeError:
504 raise TypeError("in get_timestamp_begin, "
505 "argument 2 must be a Context instance")
507 def get_timestamp_end(self, context, clock_type):
508 """Return the destruction timestamp of the buffers of a trace."""
510 return _bt_trace_handle_get_timestamp_end(
511 context._c, self._id, clock_type)
512 except AttributeError:
513 raise TypeError("in get_timestamp_end, "
514 "argument 2 must be a Context instance")
520 // =================================================================
522 // =================================================================
524 /* =================================================================
530 %rename("_bt_ctf_iter_create") bt_ctf_iter_create(struct bt_context *ctx,
531 const struct bt_iter_pos *begin_pos,
532 const struct bt_iter_pos *end_pos);
533 %rename("_bt_ctf_get_iter") bt_ctf_get_iter(struct bt_ctf_iter *iter);
534 %rename("_bt_ctf_iter_destroy") bt_ctf_iter_destroy(struct bt_ctf_iter *iter);
535 %rename("_bt_ctf_iter_read_event") bt_ctf_iter_read_event(struct bt_ctf_iter *iter);
537 struct bt_ctf_iter *bt_ctf_iter_create(struct bt_context *ctx,
538 const struct bt_iter_pos *begin_pos,
539 const struct bt_iter_pos *end_pos);
540 struct bt_iter *bt_ctf_get_iter(struct bt_ctf_iter *iter);
541 void bt_ctf_iter_destroy(struct bt_ctf_iter *iter);
542 struct bt_ctf_event *bt_ctf_iter_read_event(struct bt_ctf_iter *iter);
547 %rename("_bt_ctf_get_top_level_scope") bt_ctf_get_top_level_scope(const struct
548 bt_ctf_event *event, enum bt_ctf_scope scope);
549 %rename("_bt_ctf_event_name") bt_ctf_event_name(const struct bt_ctf_event *ctf_event);
550 %rename("_bt_ctf_get_timestamp") bt_ctf_get_timestamp(
551 const struct bt_ctf_event *ctf_event);
552 %rename("_bt_ctf_get_cycles") bt_ctf_get_cycles(
553 const struct bt_ctf_event *ctf_event);
555 %rename("_bt_ctf_get_field") bt_ctf_get_field(const struct bt_ctf_event *ctf_event,
556 const struct definition *scope, const char *field);
557 %rename("_bt_ctf_get_index") bt_ctf_get_index(const struct bt_ctf_event *ctf_event,
558 const struct definition *field, unsigned int index);
559 %rename("_bt_ctf_field_name") bt_ctf_field_name(const struct definition *def);
560 %rename("_bt_ctf_field_type") bt_ctf_field_type(const struct definition *def);
561 %rename("_bt_ctf_get_int_signedness") bt_ctf_get_int_signedness(
562 const struct definition *field);
563 %rename("_bt_ctf_get_int_base") bt_ctf_get_int_base(const struct definition *field);
564 %rename("_bt_ctf_get_int_byte_order") bt_ctf_get_int_byte_order(
565 const struct definition *field);
566 %rename("_bt_ctf_get_int_len") bt_ctf_get_int_len(const struct definition *field);
567 %rename("_bt_ctf_get_encoding") bt_ctf_get_encoding(const struct definition *field);
568 %rename("_bt_ctf_get_array_len") bt_ctf_get_array_len(const struct definition *field);
569 %rename("_bt_ctf_get_uint64") bt_ctf_get_uint64(const struct definition *field);
570 %rename("_bt_ctf_get_int64") bt_ctf_get_int64(const struct definition *field);
571 %rename("_bt_ctf_get_char_array") bt_ctf_get_char_array(const struct definition *field);
572 %rename("_bt_ctf_get_string") bt_ctf_get_string(const struct definition *field);
573 %rename("_bt_ctf_field_get_error") bt_ctf_field_get_error(void);
574 %rename("_bt_ctf_get_decl_event_name") bt_ctf_get_decl_event_name(const struct
575 bt_ctf_event_decl *event);
576 %rename("_bt_ctf_get_decl_field_name") bt_ctf_get_decl_field_name(
577 const struct bt_ctf_field_decl *field);
579 const struct definition *bt_ctf_get_top_level_scope(const struct bt_ctf_event *ctf_event,
580 enum bt_ctf_scope scope);
581 const char *bt_ctf_event_name(const struct bt_ctf_event *ctf_event);
582 uint64_t bt_ctf_get_timestamp(const struct bt_ctf_event *ctf_event);
583 uint64_t bt_ctf_get_cycles(const struct bt_ctf_event *ctf_event);
584 const struct definition *bt_ctf_get_field(const struct bt_ctf_event *ctf_event,
585 const struct definition *scope,
587 const struct definition *bt_ctf_get_index(const struct bt_ctf_event *ctf_event,
588 const struct definition *field,
590 const char *bt_ctf_field_name(const struct definition *def);
591 enum ctf_type_id bt_ctf_field_type(const struct definition *def);
592 int bt_ctf_get_int_signedness(const struct definition *field);
593 int bt_ctf_get_int_base(const struct definition *field);
594 int bt_ctf_get_int_byte_order(const struct definition *field);
595 ssize_t bt_ctf_get_int_len(const struct definition *field);
596 enum ctf_string_encoding bt_ctf_get_encoding(const struct definition *field);
597 int bt_ctf_get_array_len(const struct definition *field);
598 uint64_t bt_ctf_get_uint64(const struct definition *field);
599 int64_t bt_ctf_get_int64(const struct definition *field);
600 char *bt_ctf_get_char_array(const struct definition *field);
601 char *bt_ctf_get_string(const struct definition *field);
602 int bt_ctf_field_get_error(void);
603 const char *bt_ctf_get_decl_event_name(const struct bt_ctf_event_decl *event);
604 const char *bt_ctf_get_decl_field_name(const struct bt_ctf_field_decl *field);
610 #enum equivalent, accessible constants
611 #These are taken directly from ctf/events.h
612 #All changes to enums must also be made here
627 TRACE_PACKET_HEADER = 0
628 STREAM_PACKET_CONTEXT = 1
629 STREAM_EVENT_HEADER = 2
630 STREAM_EVENT_CONTEXT = 3
634 class string_encoding:
640 class Iterator(Iterator, object):
642 Allocate a CTF trace collection iterator.
644 begin_pos and end_pos are optional parameters to specify the
645 position at which the trace collection should be seeked upon
646 iterator creation, and the position at which iteration will
647 start returning "EOF".
649 By default, if begin_pos is None, a SEEK_CUR is performed at
650 creation. By default, if end_pos is None, a SEEK_END (end of
651 trace) is the EOF criterion.
653 Only one iterator can be created against a context. If more than one
654 iterator is being created for the same context, the second creation
655 will return None. The previous iterator must be destroyed before
656 creation of the new iterator for this function to succeed.
659 def __new__(cls, context, begin_pos = None, end_pos = None):
660 # __new__ is used to control the return value
661 # as the ctf.Iterator class should return None
662 # if bt_ctf_iter_create returns NULL
664 if begin_pos is None:
673 it = _bt_ctf_iter_create(context._c, bp, ep)
674 except AttributeError:
675 raise TypeError("in __init__, "
676 "argument 2 must be a Context instance")
680 ret_class = super(ctf.Iterator, cls).__new__(cls)
684 def __init__(self, context, begin_pos = None, end_pos = None):
685 Iterator.__init__(self, None, None, None,
686 _bt_ctf_get_iter(self._i))
689 _bt_ctf_iter_destroy(self._i)
691 def read_event(self):
693 Read the iterator's current event data.
694 Return current event on success, None on end of trace.
696 ret = _bt_ctf_iter_read_event(self._i)
699 ev = ctf.Event.__new__(ctf.Event)
706 This class represents an event from the trace.
707 It is obtained with read_event() from ctf.Iterator.
712 raise NotImplementedError("ctf.Event cannot be instantiated")
714 def get_top_level_scope(self, scope):
716 Return a definition of the top-level scope
717 Top-level scopes are defined in ctf.scope.
718 In order to get a field or a field list, the user needs to pass a
719 scope as argument, this scope can be a top-level scope or a scope
720 relative to an arbitrary field. This function provides the mapping
721 between the scope and the actual definition of top-level scopes.
722 On error return None.
724 evDef = ctf.Definition.__new__(ctf.Definition)
725 evDef._d = _bt_ctf_get_top_level_scope(self._e, scope)
731 """Return the name of the event or None on error."""
732 return _bt_ctf_event_name(self._e)
734 def get_cycles(self):
736 Return the timestamp of the event as written in
737 the packet (in cycles) or -1ULL on error.
739 return _bt_ctf_get_cycles(self._e)
741 def get_timestamp(self):
743 Return the timestamp of the event offsetted with the
744 system clock source or -1ULL on error.
746 return _bt_ctf_get_timestamp(self._e)
748 def get_field(self, scope, field):
749 """Return the definition of a specific field."""
750 evDef = ctf.Definition.__new__(ctf.Definition)
752 evDef._d = _bt_ctf_get_field(self._e, scope._d, field)
753 except AttributeError:
754 raise TypeError("in get_field, argument 2 must be a "
755 "Definition (scope) instance")
758 def get_field_list(self, scope):
760 Return a list of Definitions
761 Return None on error.
764 field_lc = _bt_python_field_listcaller(self._e, scope._d)
765 except AttributeError:
766 raise TypeError("in get_field_list, argument 2 must be a "
767 "Definition (scope) instance")
775 tmp = ctf.Definition.__new__(ctf.Definition)
776 tmp._d = _bt_python_field_one_from_list(field_lc, i)
779 #Last item of list is None, assured in
780 #_bt_python_field_listcaller
787 def get_index(self, field, index):
789 If the field is an array or a sequence, return the element
790 at position index, otherwise return None
792 evDef = ctf.Definition.__new__(ctf.Definition)
794 evDef._d = _bt_ctf_get_index(self._e, field._d, index)
795 except AttributeError:
796 raise TypeError("in get_index, argument 2 must be a "
797 "Definition (field) instance")
803 def get_handle(self):
805 Get the TraceHandle associated with an event
808 ret = _bt_ctf_event_get_handle_id(self._e)
812 th = TraceHandle.__new__(TraceHandle)
816 def get_context(self):
818 Get the context associated with an event.
819 Return None on error.
822 ctx._c = _bt_ctf_event_get_context(self._e);
829 class Definition(object):
830 """Definition class. Do not instantiate."""
833 raise NotImplementedError("ctf.Definition cannot be instantiated")
836 return "Babeltrace Definition: name('{}'), type({})".format(
837 self.field_name(), self.field_type())
839 def field_name(self):
840 """Return the name of a field or None on error."""
841 return _bt_ctf_field_name(self._d)
843 def field_type(self):
844 """Return the type of a field or -1 if unknown."""
845 return _bt_ctf_field_type(self._d)
847 def get_int_signedness(self):
849 Return the signedness of an integer:
850 0 if unsigned; 1 if signed; -1 on error.
852 return _bt_ctf_get_int_signedness(self._d)
854 def get_int_base(self):
855 """Return the base of an int or a negative value on error."""
856 return _bt_ctf_get_int_base(self._d)
858 def get_int_byte_order(self):
860 Return the byte order of an int or a negative
863 return _bt_ctf_get_int_byte_order(self._d)
865 def get_int_len(self):
867 Return the size, in bits, of an int or a negative
870 return _bt_ctf_get_int_len(self._d)
872 def get_encoding(self):
874 Return the encoding of an int or a string.
875 Return a negative value on error.
877 return _bt_ctf_get_encoding(self._d)
879 def get_array_len(self):
881 Return the len of an array or a negative
884 return _bt_ctf_get_array_len(self._d)
886 def get_uint64(self):
888 Return the value associated with the field.
889 If the field does not exist or is not of the type requested,
890 the value returned is undefined. To check if an error occured,
891 use the ctf.field_error() function after accessing a field.
893 return _bt_ctf_get_uint64(self._d)
897 Return the value associated with the field.
898 If the field does not exist or is not of the type requested,
899 the value returned is undefined. To check if an error occured,
900 use the ctf.field_error() function after accessing a field.
902 return _bt_ctf_get_int64(self._d)
904 def get_char_array(self):
906 Return the value associated with the field.
907 If the field does not exist or is not of the type requested,
908 the value returned is undefined. To check if an error occured,
909 use the ctf.field_error() function after accessing a field.
911 return _bt_ctf_get_char_array(self._d)
915 Return the value associated with the field.
916 If the field does not exist or is not of the type requested,
917 the value returned is undefined. To check if an error occured,
918 use the ctf.field_error() function after accessing a field.
920 return _bt_ctf_get_string(self._d)
923 class EventDecl(object):
924 """Event declaration class. Do not instantiate."""
927 raise NotImplementedError("ctf.EventDecl cannot be instantiated")
930 return "Babeltrace EventDecl: name {}".format(self.get_name())
933 """Return the name of the event or None on error"""
934 return _bt_ctf_get_decl_event_name(self._d)
936 def get_decl_fields(self, scope):
938 Return a list of ctf.FieldDecl
939 Return None on error.
941 ptr_list = _by_python_field_decl_listcaller(self._d, scope)
949 tmp = ctf.FieldDecl.__new__(ctf.FieldDecl)
950 tmp._d = _bt_python_field_decl_one_from_list(
954 #Last item of list is None
957 decl_list.append(tmp)
962 class FieldDecl(object):
963 """Field declaration class. Do not instantiate."""
966 raise NotImplementedError("ctf.FieldDecl cannot be instantiated")
969 return "Babeltrace FieldDecl: name {}".format(self.get_name())
972 """Return the name of a FieldDecl or None on error"""
973 return _bt_ctf_get_decl_field_name(self._d)
979 Return the last error code encountered while
980 accessing a field and reset the error flag.
981 Return 0 if no error, a negative value otherwise.
983 return _bt_ctf_field_get_error()
986 def get_event_decl_list(trace_handle, context):
988 Return a list of ctf.EventDecl
989 Return None on error.
992 handle_id = trace_handle._id
993 except AttributeError:
994 raise TypeError("in get_event_decl_list, "
995 "argument 1 must be a TraceHandle instance")
997 ptr_list = _bt_python_event_decl_listcaller(handle_id, context._c)
998 except AttributeError:
999 raise TypeError("in get_event_decl_list, "
1000 "argument 2 must be a Context instance")
1002 if ptr_list is None:
1008 tmp = ctf.EventDecl.__new__(ctf.EventDecl)
1009 tmp._d = _bt_python_decl_one_from_list(ptr_list, i)
1012 #Last item of list is None
1015 decl_list.append(tmp)
1023 // =================================================================
1025 // File and list-related
1026 // python-complements.h
1027 // =================================================================
1029 %include python-complements.c
1035 Open a file for babeltrace.
1037 file_path is a string containing the path or None to use the
1038 standard output in writing mode.
1040 The mode can be 'r', 'w' or 'a' for reading (default), writing or
1041 appending. The file will be created if it doesn't exist when
1042 opened for writing or appending; it will be truncated when opened
1043 for writing. Add a 'b' to the mode for binary files. Add a '+'
1044 to the mode to allow simultaneous reading and writing.
1047 def __new__(cls, file_path, mode='r'):
1048 # __new__ is used to control the return value
1049 # as the File class should return None
1050 # if _bt_file_open returns NULL
1053 if file_path is not None and type(file_path) is not str:
1054 raise TypeError("in method __init__, argument 2 of type 'str'")
1055 if type(mode) is not str:
1056 raise TypeError("in method __init__, argument 3 of type 'str'")
1059 file_ptr = _bt_file_open(file_path, mode)
1060 if file_ptr is None:
1063 # Class instantiation
1064 file_inst = super(File, cls).__new__(cls)
1065 file_inst._file = file_ptr
1068 def __init__(self, file_path, mode='r'):
1070 self._use_stdout = False
1072 if file_path is None:
1074 file_path = "stdout"
1076 self._use_stdout = True
1078 self._file_path = file_path
1089 return "{} babeltrace File; file_path('{}'), mode('{}')".format(
1090 stat, self._file_path, self._mode)
1093 """Close the file. Is also called using del."""
1094 if self._opened and not self._use_stdout:
1095 _bt_file_close(self._file)
1096 self._opened = False