4 * Babeltrace Python Module interface file
6 * Copyright 2012 EfficiOS Inc.
8 * Author: Danny Serres <danny.serres@efficios.com>
9 * Author: Jérémie Galarneau <jeremie.galarneau@efficios.com>
11 * Permission is hereby granted, free of charge, to any person obtaining a copy
12 * of this software and associated documentation files (the "Software"), to deal
13 * in the Software without restriction, including without limitation the rights
14 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
15 * copies of the Software, and to permit persons to whom the Software is
16 * furnished to do so, subject to the following conditions:
18 * The above copyright notice and this permission notice shall be included in
19 * all copies or substantial portions of the Software.
24 "BABELTRACE_VERSION_STR
26 Babeltrace is a trace viewer and converter reading and writing the
27 Common Trace Format (CTF). Its main use is to pretty-print CTF
28 traces into a human-readable text output.
30 To use this module, the first step is to create a TraceCollection and add a
34 %module(docstring=DOCSTRING) babeltrace
38 #define SWIG_FILE_WITH_INIT
39 #include <babeltrace/babeltrace.h>
40 #include <babeltrace/babeltrace-internal.h>
41 #include <babeltrace/trace-handle.h>
42 #include <babeltrace/trace-handle-internal.h>
43 #include <babeltrace/context.h>
44 #include <babeltrace/context-internal.h>
45 #include <babeltrace/iterator.h>
46 #include <babeltrace/iterator-internal.h>
47 #include <babeltrace/format.h>
48 #include <babeltrace/list.h>
49 #include <babeltrace/types.h>
50 #include <babeltrace/ctf/iterator.h>
51 #include "python-complements.h"
52 #include <babeltrace/ctf-writer/clock.h>
53 #include <babeltrace/ctf-writer/event-fields.h>
54 #include <babeltrace/ctf-writer/event-types.h>
55 #include <babeltrace/ctf-writer/event.h>
56 #include <babeltrace/ctf-writer/stream.h>
57 #include <babeltrace/ctf-writer/writer.h>
60 typedef unsigned long long uint64_t;
61 typedef long long int64_t;
62 typedef int bt_intern_str;
63 typedef int64_t ssize_t;
65 /* =================================================================
67 ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
70 FILE *_bt_file_open(char *file_path, char *mode);
71 void _bt_file_close(FILE *fp);
72 struct bt_definition **_bt_python_field_listcaller(
73 const struct bt_ctf_event *ctf_event,
74 const struct bt_definition *scope,
75 unsigned int *OUTPUT);
76 struct bt_definition *_bt_python_field_one_from_list(
77 struct bt_definition **list, int index);
78 struct bt_ctf_event_decl **_bt_python_event_decl_listcaller(
80 struct bt_context *ctx,
81 unsigned int *OUTPUT);
82 struct bt_ctf_event_decl *_bt_python_decl_one_from_list(
83 struct bt_ctf_event_decl **list, int index);
84 struct bt_ctf_field_decl **_by_python_field_decl_listcaller(
85 struct bt_ctf_event_decl *event_decl,
86 enum bt_ctf_scope scope,
87 unsigned int *OUTPUT);
88 struct bt_ctf_field_decl *_bt_python_field_decl_one_from_list(
89 struct bt_ctf_field_decl **list, int index);
90 struct definition_array *_bt_python_get_array_from_def(
91 struct bt_definition *field);
92 struct definition_sequence *_bt_python_get_sequence_from_def(
93 struct bt_definition *field);
94 struct bt_declaration *_bt_python_get_array_element_declaration(
95 struct bt_declaration *field);
96 struct bt_declaration *_bt_python_get_sequence_element_declaration(
97 struct bt_declaration *field);
98 const char *_bt_python_get_array_string(struct bt_definition *field);
99 const char *_bt_python_get_sequence_string(struct bt_definition *field);
100 int _bt_python_field_integer_get_signedness(const struct bt_ctf_field *field);
101 enum ctf_type_id _bt_python_get_field_type(const struct bt_ctf_field *field);
102 struct bt_iter_pos *_bt_python_create_iter_pos(void);
103 struct bt_ctf_iter *_bt_python_ctf_iter_create_intersect(
104 struct bt_context *ctx,
105 struct bt_iter_pos *inter_begin_pos,
106 struct bt_iter_pos *inter_end_pos);
107 int _bt_python_has_intersection(struct bt_context *ctx);
109 /* =================================================================
110 CONTEXT.H, CONTEXT-INTERNAL.H
111 ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
114 %rename("_bt_context_create") bt_context_create(void);
115 %rename("_bt_context_add_trace") bt_context_add_trace(
116 struct bt_context *ctx, const char *path, const char *format,
117 void (*packet_seek)(struct bt_stream_pos *pos, size_t index, int whence),
118 struct bt_mmap_stream_list *stream_list, FILE *metadata);
119 %rename("_bt_context_remove_trace") bt_context_remove_trace(
120 struct bt_context *ctx, int trace_id);
121 %rename("_bt_context_get") bt_context_get(struct bt_context *ctx);
122 %rename("_bt_context_put") bt_context_put(struct bt_context *ctx);
123 %rename("_bt_ctf_event_get_context") bt_ctf_event_get_context(
124 const struct bt_ctf_event *event);
126 struct bt_context *bt_context_create(void);
127 int bt_context_add_trace(struct bt_context *ctx, const char *path, const char *format,
128 void (*packet_seek)(struct bt_stream_pos *pos, size_t index, int whence),
129 struct bt_mmap_stream_list *stream_list, FILE *metadata);
130 void bt_context_remove_trace(struct bt_context *ctx, int trace_id);
131 void bt_context_get(struct bt_context *ctx);
132 void bt_context_put(struct bt_context *ctx);
133 struct bt_context *bt_ctf_event_get_context(const struct bt_ctf_event *event);
135 // class TraceCollection to prevent direct access to struct bt_context
137 class TraceCollection:
139 The TraceCollection is the object that contains all currently opened traces.
142 def __init__(self, intersect_mode=False):
143 self._tc = _bt_context_create()
144 self._intersect_mode = intersect_mode
147 _bt_context_put(self._tc)
149 def add_trace(self, path, format_str):
151 Add a trace by path to the TraceCollection.
155 path is the path to the trace, it is not recursive.
156 If "path" is None, stream_list is used instead as a list
157 of mmap streams to open for the trace.
159 format is a string containing the format name in which the trace was
162 Return: the corresponding TraceHandle on success or None on error.
164 ret = _bt_context_add_trace(self._tc, path, format_str, None, None, None)
168 th = TraceHandle.__new__(TraceHandle)
170 th._trace_collection = self
173 def add_traces_recursive(self, path, format_str):
175 Open a trace recursively.
177 Find each trace present in the subdirectory starting from the given
178 path, and add them to the TraceCollection.
180 Return a dict of TraceHandle instances (the full path is the key).
181 Return None on error.
191 for fullpath, dirs, files in os.walk(path):
192 if "metadata" in files:
193 trace_handle = self.add_trace(fullpath, format_str)
194 if trace_handle is None:
198 trace_handles[fullpath] = trace_handle
201 if noTrace and error:
205 def remove_trace(self, trace_handle):
207 Remove a trace from the TraceCollection.
208 Effectively closing the trace.
211 _bt_context_remove_trace(self._tc, trace_handle._id)
212 except AttributeError:
213 raise TypeError("in remove_trace, "
214 "argument 2 must be a TraceHandle instance")
217 def intersect_mode(self):
218 return self._intersect_mode
223 Generator function to iterate over the events of open in the current
226 Due to limitations of the native Babeltrace API, only one event
227 may be "alive" at a time (i.e. a user should never store a copy
228 of the events returned by this function for ulterior use). Users
229 shall make sure to copy the information they need from an event
230 before accessing the next one.
232 Furthermore, event objects become invalid when the generator goes
233 out of scope as the underlying iterator will be reclaimed. Using an
234 event after the the generator has gone out of scope may result in a
235 crash or data corruption.
237 begin_pos_ptr = _bt_python_create_iter_pos()
238 end_pos_ptr = _bt_python_create_iter_pos()
239 if not self.intersect_mode:
240 begin_pos_ptr.type = SEEK_BEGIN
241 end_pos_ptr.type = SEEK_LAST
243 for event in self._events(begin_pos_ptr, end_pos_ptr):
246 _bt_iter_free_pos(begin_pos_ptr)
247 _bt_iter_free_pos(end_pos_ptr)
249 def events_timestamps(self, timestamp_begin, timestamp_end):
251 Generator function to iterate over the events of open in the current
252 TraceCollection from timestamp_begin to timestamp_end.
254 begin_pos_ptr = _bt_python_create_iter_pos()
255 end_pos_ptr = _bt_python_create_iter_pos()
256 begin_pos_ptr.type = end_pos_ptr.type = SEEK_TIME
257 begin_pos_ptr.u.seek_time = timestamp_begin
258 end_pos_ptr.u.seek_time = timestamp_end
260 for event in self._events(begin_pos_ptr, end_pos_ptr):
263 _bt_iter_free_pos(begin_pos_ptr)
264 _bt_iter_free_pos(end_pos_ptr)
267 def timestamp_begin(self):
268 pos_ptr = _bt_iter_pos()
269 pos_ptr.type = SEEK_BEGIN
270 return self._timestamp_at_pos(pos_ptr)
273 def timestamp_end(self):
274 pos_ptr = _bt_iter_pos()
275 pos_ptr.type = SEEK_LAST
276 return self._timestamp_at_pos(pos_ptr)
278 def _timestamp_at_pos(self, pos_ptr):
279 ctf_it_ptr = _bt_ctf_iter_create(self._tc, pos_ptr, pos_ptr)
280 if ctf_it_ptr is None:
281 raise NotImplementedError("Creation of multiple iterators is unsupported.")
282 ev_ptr = _bt_ctf_iter_read_event(ctf_it_ptr)
283 _bt_ctf_iter_destroy(ctf_it_ptr)
286 ev = Event.__new__(Event)
290 def _events(self, begin_pos_ptr, end_pos_ptr):
291 if self.intersect_mode:
292 has_intersection = _bt_python_has_intersection(self._tc)
293 if not has_intersection:
294 # There are no events to provide.
297 ctf_it_ptr = _bt_python_ctf_iter_create_intersect(
298 self._tc, begin_pos_ptr, end_pos_ptr
301 ctf_it_ptr = _bt_ctf_iter_create(
302 self._tc, begin_pos_ptr, end_pos_ptr
305 if ctf_it_ptr is None:
306 raise NotImplementedError(
307 "Creation of multiple iterators is unsupported.")
310 ev_ptr = _bt_ctf_iter_read_event(ctf_it_ptr)
314 ev = Event.__new__(Event)
318 except GeneratorExit:
321 ret = _bt_iter_next(_bt_ctf_get_iter(ctf_it_ptr))
325 _bt_ctf_iter_destroy(ctf_it_ptr)
331 /* =================================================================
336 %rename("lookup_format") bt_lookup_format(bt_intern_str qname);
337 %rename("_bt_print_format_list") bt_fprintf_format_list(FILE *fp);
338 %rename("register_format") bt_register_format(struct format *format);
339 %rename("unregister_format") bt_unregister_format(struct bt_format *format);
341 extern struct format *bt_lookup_format(bt_intern_str qname);
342 extern void bt_fprintf_format_list(FILE *fp);
343 extern int bt_register_format(struct bt_format *format);
344 extern void bt_unregister_format(struct bt_format *format);
348 def print_format_list(babeltrace_file):
350 Print a list of available formats to file.
352 babeltrace_file must be a File instance opened in write mode.
355 if babeltrace_file._file is not None:
356 _bt_print_format_list(babeltrace_file._file)
357 except AttributeError:
358 raise TypeError("in print_format_list, "
359 "argument 1 must be a File instance")
364 /* =================================================================
365 ITERATOR.H, ITERATOR-INTERNAL.H
366 ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
369 %rename("_bt_iter_create") bt_iter_create(struct bt_context *ctx,
370 const struct bt_iter_pos *begin_pos, const struct bt_iter_pos *end_pos);
371 %rename("_bt_iter_destroy") bt_iter_destroy(struct bt_iter *iter);
372 %rename("_bt_iter_next") bt_iter_next(struct bt_iter *iter);
373 %rename("_bt_iter_get_pos") bt_iter_get_pos(struct bt_iter *iter);
374 %rename("_bt_iter_free_pos") bt_iter_free_pos(struct bt_iter_pos *pos);
375 %rename("_bt_iter_set_pos") bt_iter_set_pos(struct bt_iter *iter,
376 const struct bt_iter_pos *pos);
377 %rename("_bt_iter_create_time_pos") bt_iter_create_time_pos(struct bt_iter *iter,
380 struct bt_iter *bt_iter_create(struct bt_context *ctx,
381 const struct bt_iter_pos *begin_pos, const struct bt_iter_pos *end_pos);
382 void bt_iter_destroy(struct bt_iter *iter);
383 int bt_iter_next(struct bt_iter *iter);
384 struct bt_iter_pos *bt_iter_get_pos(struct bt_iter *iter);
385 void bt_iter_free_pos(struct bt_iter_pos *pos);
386 int bt_iter_set_pos(struct bt_iter *iter, const struct bt_iter_pos *pos);
387 struct bt_iter_pos *bt_iter_create_time_pos(struct bt_iter *iter, uint64_t timestamp);
389 %rename("_bt_iter_pos") bt_iter_pos;
390 %rename("SEEK_TIME") BT_SEEK_TIME;
391 %rename("SEEK_RESTORE") BT_SEEK_RESTORE;
392 %rename("SEEK_CUR") BT_SEEK_CUR;
393 %rename("SEEK_BEGIN") BT_SEEK_BEGIN;
394 %rename("SEEK_LAST") BT_SEEK_LAST;
396 // This struct is taken from iterator.h
397 // All changes to the struct must also be made here
400 BT_SEEK_TIME, /* uses u.seek_time */
401 BT_SEEK_RESTORE, /* uses u.restore */
408 struct bt_saved_pos *restore;
412 /* =================================================================
413 TRACE-HANDLE.H, TRACE-HANDLE-INTERNAL.H
414 ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
417 %rename("_bt_trace_handle_create") bt_trace_handle_create(struct bt_context *ctx);
418 %rename("_bt_trace_handle_destroy") bt_trace_handle_destroy(struct bt_trace_handle *bt);
419 struct bt_trace_handle *bt_trace_handle_create(struct bt_context *ctx);
420 void bt_trace_handle_destroy(struct bt_trace_handle *bt);
422 %rename("_bt_trace_handle_get_path") bt_trace_handle_get_path(struct bt_context *ctx,
424 %rename("_bt_trace_handle_get_timestamp_begin") bt_trace_handle_get_timestamp_begin(
425 struct bt_context *ctx, int handle_id, enum bt_clock_type type);
426 %rename("_bt_trace_handle_get_timestamp_end") bt_trace_handle_get_timestamp_end(
427 struct bt_context *ctx, int handle_id, enum bt_clock_type type);
428 const char *bt_trace_handle_get_path(struct bt_context *ctx, int handle_id);
429 uint64_t bt_trace_handle_get_timestamp_begin(struct bt_context *ctx, int handle_id,
430 enum bt_clock_type type);
431 uint64_t bt_trace_handle_get_timestamp_end(struct bt_context *ctx, int handle_id,
432 enum bt_clock_type type);
434 %rename("_bt_ctf_event_get_handle_id") bt_ctf_event_get_handle_id(
435 const struct bt_ctf_event *event);
436 int bt_ctf_event_get_handle_id(const struct bt_ctf_event *event);
441 # Based on enum bt_clock_type in clock-type.h
446 class TraceHandle(object):
448 The TraceHandle allows the user to manipulate a trace file directly.
449 It is a unique identifier representing a trace file.
454 raise NotImplementedError("TraceHandle cannot be instantiated")
457 return "Babeltrace TraceHandle: trace_id('{0}')".format(self._id)
461 """Return the TraceHandle id."""
466 """Return the path of a TraceHandle."""
467 return _bt_trace_handle_get_path(self._trace_collection._tc, self._id)
470 def timestamp_begin(self):
471 """Return the creation time of the buffers of a trace."""
472 return _bt_trace_handle_get_timestamp_begin(
473 self._trace_collection._tc, self._id, ClockType.CLOCK_REAL)
476 def timestamp_end(self):
477 """Return the destruction timestamp of the buffers of a trace."""
478 return _bt_trace_handle_get_timestamp_end(
479 self._trace_collection._tc, self._id, ClockType.CLOCK_REAL)
484 Generator returning all events (EventDeclaration) in a trace.
486 ret = _bt_python_event_decl_listcaller(self.id, self._trace_collection._tc)
488 if not isinstance(ret, list):
491 ptr_list, count = ret
492 for i in range(count):
493 tmp = EventDeclaration.__new__(EventDeclaration)
494 tmp._ed = _bt_python_decl_one_from_list(ptr_list, i)
501 // =================================================================
503 // =================================================================
505 /* =================================================================
511 %rename("_bt_ctf_iter_create") bt_ctf_iter_create(struct bt_context *ctx,
512 const struct bt_iter_pos *begin_pos,
513 const struct bt_iter_pos *end_pos);
514 %rename("_bt_ctf_get_iter") bt_ctf_get_iter(struct bt_ctf_iter *iter);
515 %rename("_bt_ctf_iter_destroy") bt_ctf_iter_destroy(struct bt_ctf_iter *iter);
516 %rename("_bt_ctf_iter_read_event") bt_ctf_iter_read_event(struct bt_ctf_iter *iter);
518 struct bt_ctf_iter *bt_ctf_iter_create(struct bt_context *ctx,
519 const struct bt_iter_pos *begin_pos,
520 const struct bt_iter_pos *end_pos);
521 struct bt_iter *bt_ctf_get_iter(struct bt_ctf_iter *iter);
522 void bt_ctf_iter_destroy(struct bt_ctf_iter *iter);
523 struct bt_ctf_event *bt_ctf_iter_read_event(struct bt_ctf_iter *iter);
527 %rename("_bt_ctf_get_top_level_scope") bt_ctf_get_top_level_scope(const struct
528 bt_ctf_event *event, enum bt_ctf_scope scope);
529 %rename("_bt_ctf_event_name") bt_ctf_event_name(const struct bt_ctf_event *ctf_event);
530 %rename("_bt_ctf_get_timestamp") bt_ctf_get_timestamp(
531 const struct bt_ctf_event *ctf_event);
532 %rename("_bt_ctf_get_cycles") bt_ctf_get_cycles(
533 const struct bt_ctf_event *ctf_event);
535 %rename("_bt_ctf_get_field") bt_ctf_get_field(const struct bt_ctf_event *ctf_event,
536 const struct bt_definition *scope, const char *field);
537 %rename("_bt_ctf_get_index") bt_ctf_get_index(const struct bt_ctf_event *ctf_event,
538 const struct bt_definition *field, unsigned int index);
539 %rename("_bt_ctf_field_name") bt_ctf_field_name(const struct bt_definition *field);
540 %rename("_bt_ctf_field_type") bt_ctf_field_type(const struct bt_declaration *field);
541 %rename("_bt_ctf_get_int_signedness") bt_ctf_get_int_signedness(
542 const struct bt_declaration *field);
543 %rename("_bt_ctf_get_int_base") bt_ctf_get_int_base(const struct bt_declaration *field);
544 %rename("_bt_ctf_get_int_byte_order") bt_ctf_get_int_byte_order(
545 const struct bt_declaration *field);
546 %rename("_bt_ctf_get_int_len") bt_ctf_get_int_len(const struct bt_declaration *field);
547 %rename("_bt_ctf_get_enum_int") bt_ctf_get_enum_int(const struct bt_definition *field);
548 %rename("_bt_ctf_get_enum_str") bt_ctf_get_enum_str(const struct bt_definition *field);
549 %rename("_bt_ctf_get_encoding") bt_ctf_get_encoding(const struct bt_declaration *field);
550 %rename("_bt_ctf_get_array_len") bt_ctf_get_array_len(const struct bt_declaration *field);
551 %rename("_bt_ctf_get_uint64") bt_ctf_get_uint64(const struct bt_definition *field);
552 %rename("_bt_ctf_get_int64") bt_ctf_get_int64(const struct bt_definition *field);
553 %rename("_bt_ctf_get_char_array") bt_ctf_get_char_array(const struct bt_definition *field);
554 %rename("_bt_ctf_get_string") bt_ctf_get_string(const struct bt_definition *field);
555 %rename("_bt_ctf_get_float") bt_ctf_get_float(const struct bt_definition *field);
556 %rename("_bt_ctf_get_variant") bt_ctf_get_variant(const struct bt_definition *field);
557 %rename("_bt_ctf_field_get_error") bt_ctf_field_get_error(void);
558 %rename("_bt_ctf_get_decl_event_name") bt_ctf_get_decl_event_name(const struct
559 bt_ctf_event_decl *event);
560 %rename("_bt_ctf_get_decl_field_name") bt_ctf_get_decl_field_name(
561 const struct bt_ctf_field_decl *field);
562 %rename("_bt_ctf_get_decl_from_def") bt_ctf_get_decl_from_def(
563 const struct bt_definition *field);
564 %rename("_bt_ctf_get_decl_from_field_decl") bt_ctf_get_decl_from_field_decl(
565 const struct bt_ctf_field_decl *field);
566 %rename("_bt_array_index") bt_array_index(struct definition_array *array, uint64_t i);
567 %rename("_bt_sequence_len") bt_sequence_len(struct definition_sequence *sequence);
568 %rename("_bt_sequence_index") bt_sequence_index(struct definition_sequence *sequence, uint64_t i);
569 %rename("_bt_ctf_get_struct_field_count") bt_ctf_get_struct_field_count(const struct bt_definition *structure);
570 %rename("_bt_ctf_get_struct_field_index") bt_ctf_get_struct_field_index(const struct bt_definition *structure, uint64_t i);
572 const struct bt_definition *bt_ctf_get_top_level_scope(const struct bt_ctf_event *ctf_event,
573 enum bt_ctf_scope scope);
574 const char *bt_ctf_event_name(const struct bt_ctf_event *ctf_event);
575 uint64_t bt_ctf_get_timestamp(const struct bt_ctf_event *ctf_event);
576 uint64_t bt_ctf_get_cycles(const struct bt_ctf_event *ctf_event);
577 const struct bt_definition *bt_ctf_get_field(const struct bt_ctf_event *ctf_event,
578 const struct bt_definition *scope,
580 const struct bt_definition *bt_ctf_get_index(const struct bt_ctf_event *ctf_event,
581 const struct bt_definition *field,
583 const char *bt_ctf_field_name(const struct bt_definition *field);
584 enum ctf_type_id bt_ctf_field_type(const struct bt_declaration *field);
585 int bt_ctf_get_int_signedness(const struct bt_declaration *field);
586 int bt_ctf_get_int_base(const struct bt_declaration *field);
587 int bt_ctf_get_int_byte_order(const struct bt_declaration *field);
588 ssize_t bt_ctf_get_int_len(const struct bt_declaration *field);
589 const struct bt_definition *bt_ctf_get_enum_int(const struct bt_definition *field);
590 const char *bt_ctf_get_enum_str(const struct bt_definition *field);
591 enum ctf_string_encoding bt_ctf_get_encoding(const struct bt_declaration *field);
592 int bt_ctf_get_array_len(const struct bt_declaration *field);
593 struct bt_definition *bt_array_index(struct definition_array *array, uint64_t i);
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 double bt_ctf_get_float(const struct bt_definition *field);
599 const struct bt_definition *bt_ctf_get_variant(const struct bt_definition *field);
600 int bt_ctf_field_get_error(void);
601 const char *bt_ctf_get_decl_event_name(const struct bt_ctf_event_decl *event);
602 const char *bt_ctf_get_decl_field_name(const struct bt_ctf_field_decl *field);
603 const struct bt_declaration *bt_ctf_get_decl_from_def(const struct bt_definition *field);
604 const struct bt_declaration *bt_ctf_get_decl_from_field_decl(const struct bt_ctf_field_decl *field);
605 uint64_t bt_sequence_len(struct definition_sequence *sequence);
606 struct bt_definition *bt_sequence_index(struct definition_sequence *sequence, uint64_t i);
607 uint64_t bt_ctf_get_struct_field_count(const struct bt_definition *structure);
608 const struct bt_definition *bt_ctf_get_struct_field_index(const struct bt_definition *structure, uint64_t i);
612 class CTFStringEncoding:
618 # Based on the enum in ctf-writer/writer.h
620 BYTE_ORDER_NATIVE = 0
621 BYTE_ORDER_LITTLE_ENDIAN = 1
622 BYTE_ORDER_BIG_ENDIAN = 2
623 BYTE_ORDER_NETWORK = 3
624 BYTE_ORDER_UNKNOWN = 4 # Python-specific entry
626 #enum equivalent, accessible constants
627 #These are taken directly from ctf/events.h
628 #All changes to enums must also be made here
643 name = "UNKNOWN_TYPE"
644 constants = [attr for attr in dir(CTFTypeId) if not callable(getattr(CTFTypeId, attr)) and not attr.startswith("__")]
645 for attr in constants:
646 if getattr(CTFTypeId, attr) == id:
652 TRACE_PACKET_HEADER = 0
653 STREAM_PACKET_CONTEXT = 1
654 STREAM_EVENT_HEADER = 2
655 STREAM_EVENT_CONTEXT = 3
659 def scope_name(scope):
660 name = "UNKNOWN_SCOPE"
661 constants = [attr for attr in dir(CTFScope) if not callable(getattr(CTFScope, attr)) and not attr.startswith("__")]
662 for attr in constants:
663 if getattr(CTFScope, attr) == scope:
668 # Priority of the scopes when searching for event fields
669 _scopes = [CTFScope.EVENT_FIELDS, CTFScope.EVENT_CONTEXT, CTFScope.STREAM_EVENT_CONTEXT,
670 CTFScope.STREAM_EVENT_HEADER, CTFScope.STREAM_PACKET_CONTEXT, CTFScope.TRACE_PACKET_HEADER]
673 class Event(collections.Mapping):
675 This class represents an event from the trace.
676 It is obtained using the TraceCollection generator functions.
680 raise NotImplementedError("Event cannot be instantiated")
684 """Return the name of the event or None on error."""
685 return _bt_ctf_event_name(self._e)
690 Return the timestamp of the event as written in
691 the packet (in cycles) or -1ULL on error.
693 return _bt_ctf_get_cycles(self._e)
698 Return the timestamp of the event offset with the
699 system clock source or -1ULL on error.
701 return _bt_ctf_get_timestamp(self._e)
703 def field_with_scope(self, field_name, scope):
705 Get field_name's value in scope.
706 None is returned if no field matches field_name.
708 if not scope in _scopes:
709 raise ValueError("Invalid scope provided")
710 field = self._field_with_scope(field_name, scope)
711 if field is not None:
715 def field_list_with_scope(self, scope):
716 """Return a list of field names in scope."""
717 if not scope in _scopes:
718 raise ValueError("Invalid scope provided")
720 for field in self._field_list_with_scope(scope):
721 field_names.append(field.name)
727 Get the TraceHandle associated with this event
730 ret = _bt_ctf_event_get_handle_id(self._e)
734 th = TraceHandle.__new__(TraceHandle)
736 th._trace_collection = self.get_trace_collection()
740 def trace_collection(self):
742 Get the TraceCollection associated with this event.
743 Return None on error.
745 trace_collection = TraceCollection()
746 trace_collection._tc = _bt_ctf_event_get_context(self._e);
747 if trace_collection._tc is None:
750 return trace_collection
752 def __getitem__(self, field_name):
754 Get field_name's value. If the field_name exists in multiple
755 scopes, the first field found is returned. The scopes are searched
756 in the following order:
759 3) STREAM_EVENT_CONTEXT
760 4) STREAM_EVENT_HEADER
761 5) STREAM_PACKET_CONTEXT
762 6) TRACE_PACKET_HEADER
763 None is returned if no field matches field_name.
765 Use field_with_scope() to explicitly access fields in a given
768 field = self._field(field_name)
769 if field is not None:
771 raise KeyError(field_name)
774 for key in self.keys():
779 for scope in _scopes:
780 scope_ptr = _bt_ctf_get_top_level_scope(self._e, scope)
781 ret = _bt_python_field_listcaller(self._e, scope_ptr)
782 if isinstance(ret, list):
786 def __contains__(self, field_name):
787 return self._field(field_name) is not None
790 """Return a list of field names."""
792 for scope in _scopes:
793 for name in self.field_list_with_scope(scope):
794 field_names.add(name)
795 return list(field_names)
797 def get(self, field_name, default = None):
798 field = self._field(field_name)
804 for field in self.keys():
805 yield (field, self[field])
807 def _field_with_scope(self, field_name, scope):
808 scope_ptr = _bt_ctf_get_top_level_scope(self._e, scope)
809 if scope_ptr is None:
812 definition_ptr = _bt_ctf_get_field(self._e, scope_ptr, field_name)
813 if definition_ptr is None:
816 field = _Definition(definition_ptr, scope)
819 def _field(self, field_name):
821 for scope in _scopes:
822 field = self._field_with_scope(field_name, scope)
823 if field is not None:
827 def _field_list_with_scope(self, scope):
829 scope_ptr = _bt_ctf_get_top_level_scope(self._e, scope)
831 # Returns a list [list_ptr, count]. If list_ptr is NULL, SWIG will only
832 # provide the "count" return value
835 ret = _bt_python_field_listcaller(self._e, scope_ptr)
836 if isinstance(ret, list):
837 list_ptr, count = ret
839 for i in range(count):
840 definition_ptr = _bt_python_field_one_from_list(list_ptr, i)
841 if definition_ptr is not None:
842 definition = _Definition(definition_ptr, scope)
843 fields.append(definition)
846 class FieldError(Exception):
847 def __init__(self, value):
851 return repr(self.value)
853 class EventDeclaration(object):
854 """Event declaration class. Do not instantiate."""
857 raise NotImplementedError("EventDeclaration cannot be instantiated")
861 """Return the name of the event or None on error"""
862 return _bt_ctf_get_decl_event_name(self._ed)
867 Generator returning all FieldDeclarations of an event, going through
868 each scope in the following order:
871 3) STREAM_EVENT_CONTEXT
872 4) STREAM_EVENT_HEADER
873 5) STREAM_PACKET_CONTEXT
874 6) TRACE_PACKET_HEADER
876 for scope in _scopes:
877 for declaration in self.fields_scope(scope):
880 def fields_scope(self, scope):
882 Generator returning FieldDeclarations of the current event in scope.
884 ret = _by_python_field_decl_listcaller(self._ed, scope)
886 if not isinstance(ret, list):
889 list_ptr, count = ret
890 for i in range(count):
891 field_declaration_ptr = _bt_python_field_decl_one_from_list(list_ptr, i)
892 if field_declaration_ptr is not None:
893 declaration_ptr = _bt_ctf_get_decl_from_field_decl(field_declaration_ptr)
894 field_declaration = _create_field_declaration(declaration_ptr, _bt_ctf_get_decl_field_name(field_declaration_ptr), scope)
895 yield field_declaration
897 class FieldDeclaration(object):
898 """Field declaration class. Do not instantiate."""
900 raise NotImplementedError("FieldDeclaration cannot be instantiated")
903 return "({0}) {1} {2}".format(CTFScope.scope_name(self.scope), CTFTypeId.type_name(self.type), self.name)
907 """Return the name of a FieldDeclaration or None on error."""
913 Return the FieldDeclaration's type. One of the entries in class
916 return _bt_ctf_field_type(self._fd)
921 Return the FieldDeclaration's scope.
925 class IntegerFieldDeclaration(FieldDeclaration):
926 """Do not instantiate."""
928 raise NotImplementedError("IntegerFieldDeclaration cannot be instantiated")
931 def signedness(self):
933 Return the signedness of an integer:
934 0 if unsigned; 1 if signed; -1 on error.
936 return _bt_ctf_get_int_signedness(self._fd)
940 """Return the base of an int or a negative value on error."""
941 return _bt_ctf_get_int_base(self._fd)
944 def byte_order(self):
946 Return the byte order. One of class ByteOrder's entries.
948 ret = _bt_ctf_get_int_byte_order(self._fd)
950 return ByteOrder.BYTE_ORDER_LITTLE_ENDIAN
952 return ByteOrder.BYTE_ORDER_BIG_ENDIAN
954 return ByteOrder.BYTE_ORDER_UNKNOWN
959 Return the size, in bits, of an int or a negative
962 return _bt_ctf_get_int_len(self._fd)
967 Return the encoding. One of class CTFStringEncoding's entries.
968 Return a negative value on error.
970 return _bt_ctf_get_encoding(self._fd)
972 class EnumerationFieldDeclaration(FieldDeclaration):
973 """Do not instantiate."""
975 raise NotImplementedError("EnumerationFieldDeclaration cannot be instantiated")
977 class ArrayFieldDeclaration(FieldDeclaration):
978 """Do not instantiate."""
980 raise NotImplementedError("ArrayFieldDeclaration cannot be instantiated")
985 Return the length of an array or a negative
988 return _bt_ctf_get_array_len(self._fd)
991 def element_declaration(self):
993 Return element declaration.
995 field_decl_ptr = _bt_python_get_array_element_declaration(self._fd)
996 return _create_field_declaration(field_decl_ptr, "", self.scope)
998 class SequenceFieldDeclaration(FieldDeclaration):
999 """Do not instantiate."""
1001 raise NotImplementedError("SequenceFieldDeclaration cannot be instantiated")
1004 def element_declaration(self):
1006 Return element declaration.
1008 field_decl_ptr = _bt_python_get_sequence_element_declaration(self._fd)
1009 return _create_field_declaration(field_decl_ptr, "", self.scope)
1011 class FloatFieldDeclaration(FieldDeclaration):
1012 """Do not instantiate."""
1014 raise NotImplementedError("FloatFieldDeclaration cannot be instantiated")
1016 class StructureFieldDeclaration(FieldDeclaration):
1017 """Do not instantiate."""
1019 raise NotImplementedError("StructureFieldDeclaration cannot be instantiated")
1021 class StringFieldDeclaration(FieldDeclaration):
1022 """Do not instantiate."""
1024 raise NotImplementedError("StringFieldDeclaration cannot be instantiated")
1026 class VariantFieldDeclaration(FieldDeclaration):
1027 """Do not instantiate."""
1029 raise NotImplementedError("VariantFieldDeclaration cannot be instantiated")
1033 Return the last error code encountered while
1034 accessing a field and reset the error flag.
1035 Return 0 if no error, a negative value otherwise.
1037 return _bt_ctf_field_get_error()
1039 def _create_field_declaration(declaration_ptr, name, scope):
1041 Private field declaration factory.
1043 if declaration_ptr is None:
1044 raise ValueError("declaration_ptr must be valid")
1045 if not scope in _scopes:
1046 raise ValueError("Invalid scope provided")
1048 type = _bt_ctf_field_type(declaration_ptr)
1050 if type == CTFTypeId.INTEGER:
1051 declaration = IntegerFieldDeclaration.__new__(IntegerFieldDeclaration)
1052 elif type == CTFTypeId.ENUM:
1053 declaration = EnumerationFieldDeclaration.__new__(EnumerationFieldDeclaration)
1054 elif type == CTFTypeId.ARRAY:
1055 declaration = ArrayFieldDeclaration.__new__(ArrayFieldDeclaration)
1056 elif type == CTFTypeId.SEQUENCE:
1057 declaration = SequenceFieldDeclaration.__new__(SequenceFieldDeclaration)
1058 elif type == CTFTypeId.FLOAT:
1059 declaration = FloatFieldDeclaration.__new__(FloatFieldDeclaration)
1060 elif type == CTFTypeId.STRUCT:
1061 declaration = StructureFieldDeclaration.__new__(StructureFieldDeclaration)
1062 elif type == CTFTypeId.STRING:
1063 declaration = StringFieldDeclaration.__new__(StringFieldDeclaration)
1064 elif type == CTFTypeId.VARIANT:
1065 declaration = VariantFieldDeclaration.__new__(VariantFieldDeclaration)
1069 declaration._fd = declaration_ptr
1070 declaration._s = scope
1071 declaration._name = name
1074 class _Definition(object):
1075 def __init__(self, definition_ptr, scope):
1076 self._d = definition_ptr
1078 if not scope in _scopes:
1079 ValueError("Invalid scope provided")
1083 """Return the name of a field or None on error."""
1084 return _bt_ctf_field_name(self._d)
1088 """Return the type of a field or -1 if unknown."""
1089 return _bt_ctf_field_type(_bt_ctf_get_decl_from_def(self._d))
1092 def declaration(self):
1093 """Return the associated Definition object."""
1094 return _create_field_declaration(_bt_ctf_get_decl_from_def(self._d), self.name, self.scope)
1096 def _get_enum_str(self):
1098 Return the string matching the current enumeration.
1099 Return None on error.
1101 return _bt_ctf_get_enum_str(self._d)
1103 def _get_array_element_at(self, index):
1105 Return the array's element at position index.
1106 Return None on error
1108 array_ptr = _bt_python_get_array_from_def(self._d)
1109 if array_ptr is None:
1112 definition_ptr = _bt_array_index(array_ptr, index)
1113 if definition_ptr is None:
1115 return _Definition(definition_ptr, self.scope)
1117 def _get_sequence_len(self):
1119 Return the len of a sequence or a negative
1122 seq = _bt_python_get_sequence_from_def(self._d)
1123 return _bt_sequence_len(seq)
1125 def _get_sequence_element_at(self, index):
1127 Return the sequence's element at position index,
1128 otherwise return None
1130 seq = _bt_python_get_sequence_from_def(self._d)
1132 definition_ptr = _bt_sequence_index(seq, index)
1133 if definition_ptr is not None:
1134 return _Definition(definition_ptr, self.scope)
1137 def _get_uint64(self):
1139 Return the value associated with the field.
1140 If the field does not exist or is not of the type requested,
1141 the value returned is undefined. To check if an error occured,
1142 use the field_error() function after accessing a field.
1144 return _bt_ctf_get_uint64(self._d)
1146 def _get_int64(self):
1148 Return the value associated with the field.
1149 If the field does not exist or is not of the type requested,
1150 the value returned is undefined. To check if an error occured,
1151 use the field_error() function after accessing a field.
1153 return _bt_ctf_get_int64(self._d)
1155 def _get_char_array(self):
1157 Return the value associated with the field.
1158 If the field does not exist or is not of the type requested,
1159 the value returned is undefined. To check if an error occurred,
1160 use the field_error() function after accessing a field.
1162 return _bt_ctf_get_char_array(self._d)
1166 Return the value associated with the field.
1167 If the field does not exist or is not of the type requested,
1168 the value returned is undefined. To check if an error occurred,
1169 use the field_error() function after accessing a field.
1171 return _bt_ctf_get_string(self._d)
1173 def _get_float(self):
1175 Return the value associated with the field.
1176 If the field does not exist or is not of the type requested,
1177 the value returned is undefined. To check if an error occurred,
1178 use the field_error() function after accessing a field.
1180 return _bt_ctf_get_float(self._d)
1182 def _get_variant(self):
1184 Return the variant's selected field.
1185 If the field does not exist or is not of the type requested,
1186 the value returned is undefined. To check if an error occurred,
1187 use the field_error() function after accessing a field.
1189 return _bt_ctf_get_variant(self._d)
1191 def _get_struct_field_count(self):
1193 Return the number of fields contained in the structure.
1194 If the field does not exist or is not of the type requested,
1195 the value returned is undefined.
1197 return _bt_ctf_get_struct_field_count(self._d)
1199 def _get_struct_field_at(self, i):
1201 Return the structure's field at position i.
1202 If the field does not exist or is not of the type requested,
1203 the value returned is undefined. To check if an error occurred,
1204 use the field_error() function after accessing a field.
1206 return _bt_ctf_get_struct_field_index(self._d, i)
1211 Return the value associated with the field according to its type.
1212 Return None on error.
1217 if id == CTFTypeId.STRING:
1218 value = self._get_str()
1219 elif id == CTFTypeId.ARRAY:
1220 element_decl = self.declaration.element_declaration
1221 if ((element_decl.type == CTFTypeId.INTEGER
1222 and element_decl.length == 8)
1223 and (element_decl.encoding == CTFStringEncoding.ASCII or element_decl.encoding == CTFStringEncoding.UTF8)):
1224 value = _bt_python_get_array_string(self._d)
1227 for i in range(self.declaration.length):
1228 element = self._get_array_element_at(i)
1229 value.append(element.value)
1230 elif id == CTFTypeId.INTEGER:
1231 if self.declaration.signedness == 0:
1232 value = self._get_uint64()
1234 value = self._get_int64()
1235 elif id == CTFTypeId.ENUM:
1236 value = self._get_enum_str()
1237 elif id == CTFTypeId.SEQUENCE:
1238 element_decl = self.declaration.element_declaration
1239 if ((element_decl.type == CTFTypeId.INTEGER
1240 and element_decl.length == 8)
1241 and (element_decl.encoding == CTFStringEncoding.ASCII or element_decl.encoding == CTFStringEncoding.UTF8)):
1242 value = _bt_python_get_sequence_string(self._d)
1244 seq_len = self._get_sequence_len()
1246 for i in range(seq_len):
1247 evDef = self._get_sequence_element_at(i)
1248 value.append(evDef.value)
1249 elif id == CTFTypeId.FLOAT:
1250 value = self._get_float()
1251 elif id == CTFTypeId.VARIANT:
1252 variant = _Definition.__new__(_Definition)
1253 variant._d = self._get_variant();
1254 value = variant.value
1255 elif id == CTFTypeId.STRUCT:
1257 for i in range(self._get_struct_field_count()):
1258 member = _Definition(self._get_struct_field_at(i), self.scope)
1259 value[member.name] = member.value
1262 raise FieldError("Error occurred while accessing field {} of type {}".format(self.name, CTFTypeId.type_name(id)))
1267 """Return the scope of a field or None on error."""
1273 // =================================================================
1275 // =================================================================
1277 /* =================================================================
1279 ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
1281 %rename("_bt_ctf_clock_create") bt_ctf_clock_create(const char *name);
1282 %rename("_bt_ctf_clock_set_description") bt_ctf_clock_set_description(struct bt_ctf_clock *clock, const char *desc);
1283 %rename("_bt_ctf_clock_set_frequency") bt_ctf_clock_set_frequency(struct bt_ctf_clock *clock, uint64_t freq);
1284 %rename("_bt_ctf_clock_set_precision") bt_ctf_clock_set_precision(struct bt_ctf_clock *clock, uint64_t precision);
1285 %rename("_bt_ctf_clock_set_offset_s") bt_ctf_clock_set_offset_s(struct bt_ctf_clock *clock, uint64_t offset_s);
1286 %rename("_bt_ctf_clock_set_offset") bt_ctf_clock_set_offset(struct bt_ctf_clock *clock, uint64_t offset);
1287 %rename("_bt_ctf_clock_set_is_absolute") bt_ctf_clock_set_is_absolute(struct bt_ctf_clock *clock, int is_absolute);
1288 %rename("_bt_ctf_clock_set_time") bt_ctf_clock_set_time(struct bt_ctf_clock *clock, uint64_t time);
1289 %rename("_bt_ctf_clock_get") bt_ctf_clock_get(struct bt_ctf_clock *clock);
1290 %rename("_bt_ctf_clock_put") bt_ctf_clock_put(struct bt_ctf_clock *clock);
1292 struct bt_ctf_clock *bt_ctf_clock_create(const char *name);
1293 int bt_ctf_clock_set_description(struct bt_ctf_clock *clock, const char *desc);
1294 int bt_ctf_clock_set_frequency(struct bt_ctf_clock *clock, uint64_t freq);
1295 int bt_ctf_clock_set_precision(struct bt_ctf_clock *clock, uint64_t precision);
1296 int bt_ctf_clock_set_offset_s(struct bt_ctf_clock *clock, uint64_t offset_s);
1297 int bt_ctf_clock_set_offset(struct bt_ctf_clock *clock, uint64_t offset);
1298 int bt_ctf_clock_set_is_absolute(struct bt_ctf_clock *clock, int is_absolute);
1299 int bt_ctf_clock_set_time(struct bt_ctf_clock *clock, uint64_t time);
1300 void bt_ctf_clock_get(struct bt_ctf_clock *clock);
1301 void bt_ctf_clock_put(struct bt_ctf_clock *clock);
1303 /* =================================================================
1305 ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
1307 %rename("_bt_ctf_field_type_integer_create") bt_ctf_field_type_integer_create(unsigned int size);
1308 %rename("_bt_ctf_field_type_integer_set_signed") bt_ctf_field_type_integer_set_signed(struct bt_ctf_field_type *integer, int is_signed);
1309 %rename("_bt_ctf_field_type_integer_set_base") bt_ctf_field_type_integer_set_base(struct bt_ctf_field_type *integer, enum bt_ctf_integer_base base);
1310 %rename("_bt_ctf_field_type_integer_set_encoding") bt_ctf_field_type_integer_set_encoding(struct bt_ctf_field_type *integer, enum ctf_string_encoding encoding);
1311 %rename("_bt_ctf_field_type_enumeration_create") bt_ctf_field_type_enumeration_create(struct bt_ctf_field_type *integer_container_type);
1312 %rename("_bt_ctf_field_type_enumeration_add_mapping") bt_ctf_field_type_enumeration_add_mapping(struct bt_ctf_field_type *enumeration, const char *string, int64_t range_start, int64_t range_end);
1313 %rename("_bt_ctf_field_type_floating_point_create") bt_ctf_field_type_floating_point_create(void);
1314 %rename("_bt_ctf_field_type_floating_point_set_exponent_digits") bt_ctf_field_type_floating_point_set_exponent_digits(struct bt_ctf_field_type *floating_point, unsigned int exponent_digits);
1315 %rename("_bt_ctf_field_type_floating_point_set_mantissa_digits") bt_ctf_field_type_floating_point_set_mantissa_digits(struct bt_ctf_field_type *floating_point, unsigned int mantissa_digits);
1316 %rename("_bt_ctf_field_type_structure_create") bt_ctf_field_type_structure_create(void);
1317 %rename("_bt_ctf_field_type_structure_add_field") bt_ctf_field_type_structure_add_field(struct bt_ctf_field_type *structure, struct bt_ctf_field_type *field_type, const char *field_name);
1318 %rename("_bt_ctf_field_type_variant_create") bt_ctf_field_type_variant_create(struct bt_ctf_field_type *enum_tag, const char *tag_name);
1319 %rename("_bt_ctf_field_type_variant_add_field") bt_ctf_field_type_variant_add_field(struct bt_ctf_field_type *variant, struct bt_ctf_field_type *field_type, const char *field_name);
1320 %rename("_bt_ctf_field_type_array_create") bt_ctf_field_type_array_create(struct bt_ctf_field_type *element_type, unsigned int length);
1321 %rename("_bt_ctf_field_type_sequence_create") bt_ctf_field_type_sequence_create(struct bt_ctf_field_type *element_type, const char *length_field_name);
1322 %rename("_bt_ctf_field_type_string_create") bt_ctf_field_type_string_create(void);
1323 %rename("_bt_ctf_field_type_string_set_encoding") bt_ctf_field_type_string_set_encoding(struct bt_ctf_field_type *string, enum ctf_string_encoding encoding);
1324 %rename("_bt_ctf_field_type_set_alignment") bt_ctf_field_type_set_alignment(struct bt_ctf_field_type *type, unsigned int alignment);
1325 %rename("_bt_ctf_field_type_set_byte_order") bt_ctf_field_type_set_byte_order(struct bt_ctf_field_type *type, enum bt_ctf_byte_order byte_order);
1326 %rename("_bt_ctf_field_type_get") bt_ctf_field_type_get(struct bt_ctf_field_type *type);
1327 %rename("_bt_ctf_field_type_put") bt_ctf_field_type_put(struct bt_ctf_field_type *type);
1329 struct bt_ctf_field_type *bt_ctf_field_type_integer_create(unsigned int size);
1330 int bt_ctf_field_type_integer_set_signed(struct bt_ctf_field_type *integer, int is_signed);
1331 int bt_ctf_field_type_integer_set_base(struct bt_ctf_field_type *integer, enum bt_ctf_integer_base base);
1332 int bt_ctf_field_type_integer_set_encoding(struct bt_ctf_field_type *integer, enum ctf_string_encoding encoding);
1333 struct bt_ctf_field_type *bt_ctf_field_type_enumeration_create(struct bt_ctf_field_type *integer_container_type);
1334 int bt_ctf_field_type_enumeration_add_mapping(struct bt_ctf_field_type *enumeration, const char *string, int64_t range_start, int64_t range_end);
1335 struct bt_ctf_field_type *bt_ctf_field_type_floating_point_create(void);
1336 int bt_ctf_field_type_floating_point_set_exponent_digits(struct bt_ctf_field_type *floating_point, unsigned int exponent_digits);
1337 int bt_ctf_field_type_floating_point_set_mantissa_digits(struct bt_ctf_field_type *floating_point, unsigned int mantissa_digits);
1338 struct bt_ctf_field_type *bt_ctf_field_type_structure_create(void);
1339 int bt_ctf_field_type_structure_add_field(struct bt_ctf_field_type *structure, struct bt_ctf_field_type *field_type, const char *field_name);
1340 struct bt_ctf_field_type *bt_ctf_field_type_variant_create(struct bt_ctf_field_type *enum_tag, const char *tag_name);
1341 int bt_ctf_field_type_variant_add_field(struct bt_ctf_field_type *variant, struct bt_ctf_field_type *field_type, const char *field_name);
1342 struct bt_ctf_field_type *bt_ctf_field_type_array_create(struct bt_ctf_field_type *element_type, unsigned int length);
1343 struct bt_ctf_field_type *bt_ctf_field_type_sequence_create(struct bt_ctf_field_type *element_type, const char *length_field_name);
1344 struct bt_ctf_field_type *bt_ctf_field_type_string_create(void);
1345 int bt_ctf_field_type_string_set_encoding(struct bt_ctf_field_type *string, enum ctf_string_encoding encoding);
1346 int bt_ctf_field_type_set_alignment(struct bt_ctf_field_type *type, unsigned int alignment);
1347 int bt_ctf_field_type_set_byte_order(struct bt_ctf_field_type *type, enum bt_ctf_byte_order byte_order);
1348 void bt_ctf_field_type_get(struct bt_ctf_field_type *type);
1349 void bt_ctf_field_type_put(struct bt_ctf_field_type *type);
1351 /* =================================================================
1353 ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
1355 %rename("_bt_ctf_field_create") bt_ctf_field_create(struct bt_ctf_field_type *type);
1356 %rename("_bt_ctf_field_structure_get_field") bt_ctf_field_structure_get_field(struct bt_ctf_field *structure, const char *name);
1357 %rename("_bt_ctf_field_array_get_field") bt_ctf_field_array_get_field(struct bt_ctf_field *array, uint64_t index);
1358 %rename("_bt_ctf_field_sequence_set_length") bt_ctf_field_sequence_set_length(struct bt_ctf_field *sequence, struct bt_ctf_field *length_field);
1359 %rename("_bt_ctf_field_sequence_get_field") bt_ctf_field_sequence_get_field(struct bt_ctf_field *sequence, uint64_t index);
1360 %rename("_bt_ctf_field_variant_get_field") bt_ctf_field_variant_get_field(struct bt_ctf_field *variant, struct bt_ctf_field *tag);
1361 %rename("_bt_ctf_field_enumeration_get_container") bt_ctf_field_enumeration_get_container(struct bt_ctf_field *enumeration);
1362 %rename("_bt_ctf_field_signed_integer_set_value") bt_ctf_field_signed_integer_set_value(struct bt_ctf_field *integer, int64_t value);
1363 %rename("_bt_ctf_field_unsigned_integer_set_value") bt_ctf_field_unsigned_integer_set_value(struct bt_ctf_field *integer, uint64_t value);
1364 %rename("_bt_ctf_field_floating_point_set_value") bt_ctf_field_floating_point_set_value(struct bt_ctf_field *floating_point, double value);
1365 %rename("_bt_ctf_field_string_set_value") bt_ctf_field_string_set_value(struct bt_ctf_field *string, const char *value);
1366 %rename("_bt_ctf_field_get") bt_ctf_field_get(struct bt_ctf_field *field);
1367 %rename("_bt_ctf_field_put") bt_ctf_field_put(struct bt_ctf_field *field);
1369 struct bt_ctf_field *bt_ctf_field_create(struct bt_ctf_field_type *type);
1370 struct bt_ctf_field *bt_ctf_field_structure_get_field(struct bt_ctf_field *structure, const char *name);
1371 struct bt_ctf_field *bt_ctf_field_array_get_field(struct bt_ctf_field *array, uint64_t index);
1372 int bt_ctf_field_sequence_set_length(struct bt_ctf_field *sequence, struct bt_ctf_field *length_field);
1373 struct bt_ctf_field *bt_ctf_field_sequence_get_field(struct bt_ctf_field *sequence, uint64_t index);
1374 struct bt_ctf_field *bt_ctf_field_variant_get_field(struct bt_ctf_field *variant, struct bt_ctf_field *tag);
1375 struct bt_ctf_field *bt_ctf_field_enumeration_get_container(struct bt_ctf_field *enumeration);
1376 int bt_ctf_field_signed_integer_set_value(struct bt_ctf_field *integer, int64_t value);
1377 int bt_ctf_field_unsigned_integer_set_value(struct bt_ctf_field *integer, uint64_t value);
1378 int bt_ctf_field_floating_point_set_value(struct bt_ctf_field *floating_point, double value);
1379 int bt_ctf_field_string_set_value(struct bt_ctf_field *string, const char *value);
1380 void bt_ctf_field_get(struct bt_ctf_field *field);
1381 void bt_ctf_field_put(struct bt_ctf_field *field);
1383 /* =================================================================
1385 ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
1387 %rename("_bt_ctf_event_class_create") bt_ctf_event_class_create(const char *name);
1388 %rename("_bt_ctf_event_class_add_field") bt_ctf_event_class_add_field(struct bt_ctf_event_class *event_class, struct bt_ctf_field_type *type, const char *name);
1389 %rename("_bt_ctf_event_class_get") bt_ctf_event_class_get(struct bt_ctf_event_class *event_class);
1390 %rename("_bt_ctf_event_class_put") bt_ctf_event_class_put(struct bt_ctf_event_class *event_class);
1391 %rename("_bt_ctf_event_create") bt_ctf_event_create(struct bt_ctf_event_class *event_class);
1392 %rename("_bt_ctf_event_set_payload") bt_ctf_event_set_payload(struct bt_ctf_event *event, const char *name, struct bt_ctf_field *value);
1393 %rename("_bt_ctf_event_get_payload") bt_ctf_event_get_payload(struct bt_ctf_event *event, const char *name);
1394 %rename("_bt_ctf_event_get") bt_ctf_event_get(struct bt_ctf_event *event);
1395 %rename("_bt_ctf_event_put") bt_ctf_event_put(struct bt_ctf_event *event);
1397 struct bt_ctf_event_class *bt_ctf_event_class_create(const char *name);
1398 int bt_ctf_event_class_add_field(struct bt_ctf_event_class *event_class, struct bt_ctf_field_type *type, const char *name);
1399 void bt_ctf_event_class_get(struct bt_ctf_event_class *event_class);
1400 void bt_ctf_event_class_put(struct bt_ctf_event_class *event_class);
1401 struct bt_ctf_event *bt_ctf_event_create(struct bt_ctf_event_class *event_class);
1402 int bt_ctf_event_set_payload(struct bt_ctf_event *event, const char *name, struct bt_ctf_field *value);
1403 struct bt_ctf_field *bt_ctf_event_get_payload(struct bt_ctf_event *event, const char *name);
1404 void bt_ctf_event_get(struct bt_ctf_event *event);
1405 void bt_ctf_event_put(struct bt_ctf_event *event);
1407 /* =================================================================
1409 ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
1411 %rename("_bt_ctf_stream_class_create") bt_ctf_stream_class_create(const char *name);
1412 %rename("_bt_ctf_stream_class_set_clock") bt_ctf_stream_class_set_clock(struct bt_ctf_stream_class *stream_class, struct bt_ctf_clock *clock);
1413 %rename("_bt_ctf_stream_class_add_event_class") bt_ctf_stream_class_add_event_class(struct bt_ctf_stream_class *stream_class, struct bt_ctf_event_class *event_class);
1414 %rename("_bt_ctf_stream_class_get") bt_ctf_stream_class_get(struct bt_ctf_stream_class *stream_class);
1415 %rename("_bt_ctf_stream_class_put") bt_ctf_stream_class_put(struct bt_ctf_stream_class *stream_class);
1416 %rename("_bt_ctf_stream_append_discarded_events") bt_ctf_stream_append_discarded_events(struct bt_ctf_stream *stream, uint64_t event_count);
1417 %rename("_bt_ctf_stream_append_event") bt_ctf_stream_append_event(struct bt_ctf_stream *stream, struct bt_ctf_event *event);
1418 %rename("_bt_ctf_stream_flush") bt_ctf_stream_flush(struct bt_ctf_stream *stream);
1419 %rename("_bt_ctf_stream_get") bt_ctf_stream_get(struct bt_ctf_stream *stream);
1420 %rename("_bt_ctf_stream_put") bt_ctf_stream_put(struct bt_ctf_stream *stream);
1422 struct bt_ctf_stream_class *bt_ctf_stream_class_create(const char *name);
1423 int bt_ctf_stream_class_set_clock(struct bt_ctf_stream_class *stream_class, struct bt_ctf_clock *clock);
1424 int bt_ctf_stream_class_add_event_class(struct bt_ctf_stream_class *stream_class, struct bt_ctf_event_class *event_class);
1425 void bt_ctf_stream_class_get(struct bt_ctf_stream_class *stream_class);
1426 void bt_ctf_stream_class_put(struct bt_ctf_stream_class *stream_class);
1427 void bt_ctf_stream_append_discarded_events(struct bt_ctf_stream *stream, uint64_t event_count);
1428 int bt_ctf_stream_append_event(struct bt_ctf_stream *stream, struct bt_ctf_event *event);
1429 int bt_ctf_stream_flush(struct bt_ctf_stream *stream);
1430 void bt_ctf_stream_get(struct bt_ctf_stream *stream);
1431 void bt_ctf_stream_put(struct bt_ctf_stream *stream);
1433 /* =================================================================
1435 ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
1437 %rename("_bt_ctf_writer_create") bt_ctf_writer_create(const char *path);
1438 %rename("_bt_ctf_writer_create_stream") bt_ctf_writer_create_stream(struct bt_ctf_writer *writer, struct bt_ctf_stream_class *stream_class);
1439 %rename("_bt_ctf_writer_add_environment_field") bt_ctf_writer_add_environment_field(struct bt_ctf_writer *writer, const char *name, const char *value);
1440 %rename("_bt_ctf_writer_add_clock") bt_ctf_writer_add_clock(struct bt_ctf_writer *writer, struct bt_ctf_clock *clock);
1441 %newobject bt_ctf_writer_get_metadata_string;
1442 %rename("_bt_ctf_writer_get_metadata_string") bt_ctf_writer_get_metadata_string(struct bt_ctf_writer *writer);
1443 %rename("_bt_ctf_writer_flush_metadata") bt_ctf_writer_flush_metadata(struct bt_ctf_writer *writer);
1444 %rename("_bt_ctf_writer_set_byte_order") bt_ctf_writer_set_byte_order(struct bt_ctf_writer *writer, enum bt_ctf_byte_order byte_order);
1445 %rename("_bt_ctf_writer_get") bt_ctf_writer_get(struct bt_ctf_writer *writer);
1446 %rename("_bt_ctf_writer_put") bt_ctf_writer_put(struct bt_ctf_writer *writer);
1448 struct bt_ctf_writer *bt_ctf_writer_create(const char *path);
1449 struct bt_ctf_stream *bt_ctf_writer_create_stream(struct bt_ctf_writer *writer, struct bt_ctf_stream_class *stream_class);
1450 int bt_ctf_writer_add_environment_field(struct bt_ctf_writer *writer, const char *name, const char *value);
1451 int bt_ctf_writer_add_clock(struct bt_ctf_writer *writer, struct bt_ctf_clock *clock);
1452 char *bt_ctf_writer_get_metadata_string(struct bt_ctf_writer *writer);
1453 void bt_ctf_writer_flush_metadata(struct bt_ctf_writer *writer);
1454 int bt_ctf_writer_set_byte_order(struct bt_ctf_writer *writer, enum bt_ctf_byte_order byte_order);
1455 void bt_ctf_writer_get(struct bt_ctf_writer *writer);
1456 void bt_ctf_writer_put(struct bt_ctf_writer *writer);
1463 def __init__(self, name):
1464 self._c = _bt_ctf_clock_create(name)
1466 raise ValueError("Invalid clock name.")
1469 _bt_ctf_clock_put(self._c)
1472 Get the clock's description.
1475 def description(self):
1476 raise NotImplementedError("Getter not implemented.")
1479 Set the clock's description. The description appears in the clock's TSDL
1483 def description(self, desc):
1484 ret = _bt_ctf_clock_set_description(self._c, str(desc))
1486 raise ValueError("Invalid clock description.")
1489 Get the clock's frequency (Hz).
1492 def frequency(self):
1493 raise NotImplementedError("Getter not implemented.")
1496 Set the clock's frequency (Hz).
1499 def frequency(self, freq):
1500 ret = _bt_ctf_clock_set_frequency(self._c, freq)
1502 raise ValueError("Invalid frequency value.")
1505 Get the clock's precision (in clock ticks).
1508 def precision(self):
1509 raise NotImplementedError("Getter not implemented.")
1512 Set the clock's precision (in clock ticks).
1515 def precision(self, precision):
1516 ret = _bt_ctf_clock_set_precision(self._c, precision)
1519 Get the clock's offset in seconds from POSIX.1 Epoch.
1522 def offset_seconds(self):
1523 raise NotImplementedError("Getter not implemented.")
1526 Set the clock's offset in seconds from POSIX.1 Epoch.
1528 @offset_seconds.setter
1529 def offset_seconds(self, offset_s):
1530 ret = _bt_ctf_clock_set_offset_s(self._c, offset_s)
1532 raise ValueError("Invalid offset value.")
1535 Get the clock's offset in ticks from POSIX.1 Epoch + offset in seconds.
1539 raise NotImplementedError("Getter not implemented.")
1542 Set the clock's offset in ticks from POSIX.1 Epoch + offset in seconds.
1545 def offset(self, offset):
1546 ret = _bt_ctf_clock_set_offset(self._c, offset)
1548 raise ValueError("Invalid offset value.")
1551 Get a clock's absolute attribute. A clock is absolute if the clock
1552 is a global reference across the trace's other clocks.
1556 raise NotImplementedError("Getter not implemented.")
1559 Set a clock's absolute attribute. A clock is absolute if the clock
1560 is a global reference across the trace's other clocks.
1563 def absolute(self, is_absolute):
1564 ret = _bt_ctf_clock_set_is_absolute(self._c, int(is_absolute))
1566 raise ValueError("Could not set the clock's absolute attribute.")
1569 Get the current time in nanoseconds since the clock's origin (offset and
1570 offset_s attributes).
1574 raise NotImplementedError("Getter not implemented.")
1577 Set the current time in nanoseconds since the clock's origin (offset and
1578 offset_s attributes). The clock's value will be sampled as events are
1579 appended to a stream.
1582 def time(self, time):
1583 ret = _bt_ctf_clock_set_time(self._c, time)
1585 raise ValueError("Invalid time value.")
1587 class FieldDeclaration:
1589 FieldDeclaration should not be instantiated directly. Please instantiate
1590 one of the concrete FieldDeclaration classes.
1593 # These values are based on the bt_ctf_integer_base enum
1594 # declared in event-types.h.
1595 INTEGER_BASE_UNKNOWN = -1
1596 INTEGER_BASE_BINARY = 2
1597 INTEGER_BASE_OCTAL = 8
1598 INTEGER_BASE_DECIMAL = 10
1599 INTEGER_BASE_HEXADECIMAL = 16
1602 if self._ft is None:
1603 raise ValueError("FieldDeclaration creation failed.")
1606 _bt_ctf_field_type_put(self._ft)
1609 Get the field type's alignment.
1612 def alignment(self):
1613 raise NotImplementedError("Getter not implemented.")
1616 Set the field type's alignment. Defaults to 1 (bit-aligned). However,
1617 some types, such as structures and string, may impose other alignment
1621 def alignment(self, alignment):
1622 ret = _bt_ctf_field_type_set_alignment(self._ft, alignment)
1624 raise ValueError("Invalid alignment value.")
1627 Get the field type's byte order. One of the ByteOrder's constant.
1630 def byte_order(self):
1631 raise NotImplementedError("Getter not implemented.")
1634 Set the field type's byte order. Use constants defined in the ByteOrder
1638 def byte_order(self, byte_order):
1639 ret = _bt_ctf_field_type_set_byte_order(self._ft, byte_order)
1641 raise ValueError("Could not set byte order value.")
1643 class IntegerFieldDeclaration(FieldDeclaration):
1645 Create a new integer field type of the given size.
1647 def __init__(self, size):
1648 self._ft = _bt_ctf_field_type_integer_create(size)
1652 Get an integer's signedness attribute.
1656 raise NotImplementedError("Getter not implemented.")
1659 Set an integer's signedness attribute.
1662 def signed(self, signed):
1663 ret = _bt_ctf_field_type_integer_set_signed(self._ft, signed)
1665 raise ValueError("Could not set signed attribute.")
1668 Get the integer's base used to pretty-print the resulting trace.
1672 raise NotImplementedError("Getter not implemented.")
1675 Set the integer's base used to pretty-print the resulting trace.
1676 The base must be a constant of the IntegerBase class.
1679 def base(self, base):
1680 ret = _bt_ctf_field_type_integer_set_base(self._ft, base)
1682 raise ValueError("Could not set base value.")
1685 Get the integer's encoding (one of the constants of the
1686 CTFStringEncoding class).
1690 raise NotImplementedError("Getter not implemented.")
1693 An integer encoding may be set to signal that the integer must be printed
1694 as a text character. Must be a constant from the CTFStringEncoding class.
1697 def encoding(self, encoding):
1698 ret = _bt_ctf_field_type_integer_set_encoding(self._ft, encoding)
1700 raise ValueError("Could not set integer encoding.")
1702 class EnumerationFieldDeclaration(FieldDeclaration):
1704 Create a new enumeration field type with the given underlying type.
1706 def __init__(self, integer_type):
1707 if integer_type is None or not isinstance(integer_type, CTFWriter.IntegerFieldDeclaration):
1708 raise TypeError("Invalid integer container.")
1710 self._ft = _bt_ctf_field_type_enumeration_create(integer_type._ft)
1714 Add a mapping to the enumeration. The range's values are inclusive.
1716 def add_mapping(self, name, range_start, range_end):
1717 ret = _bt_ctf_field_type_enumeration_add_mapping(self._ft, str(name), range_start, range_end)
1719 raise ValueError("Could not add mapping to enumeration type.")
1721 class FloatFieldDeclaration(FieldDeclaration):
1728 Create a new floating point field type.
1731 self._ft = _bt_ctf_field_type_floating_point_create()
1735 Get the number of exponent digits to use to store the floating point field.
1738 def exponent_digits(self):
1739 raise NotImplementedError("Getter not implemented.")
1742 Set the number of exponent digits to use to store the floating point field.
1743 The only values currently supported are FLT_EXP_DIG and DBL_EXP_DIG which
1744 are defined as constants of this class.
1746 @exponent_digits.setter
1747 def exponent_digits(self, exponent_digits):
1748 ret = _bt_ctf_field_type_floating_point_set_exponent_digits(self._ft, exponent_digits)
1750 raise ValueError("Could not set exponent digit count.")
1753 Get the number of mantissa digits to use to store the floating point field.
1756 def mantissa_digits(self):
1757 raise NotImplementedError("Getter not implemented.")
1760 Set the number of mantissa digits to use to store the floating point field.
1761 The only values currently supported are FLT_MANT_DIG and DBL_MANT_DIG which
1762 are defined as constants of this class.
1764 @mantissa_digits.setter
1765 def mantissa_digits(self, mantissa_digits):
1766 ret = _bt_ctf_field_type_floating_point_set_mantissa_digits(self._ft, mantissa_digits)
1768 raise ValueError("Could not set mantissa digit count.")
1770 class StructureFieldDeclaration(FieldDeclaration):
1772 Create a new structure field type.
1775 self._ft = _bt_ctf_field_type_structure_create()
1779 Add a field of type "field_type" to the structure.
1781 def add_field(self, field_type, field_name):
1782 ret = _bt_ctf_field_type_structure_add_field(self._ft, field_type._ft, str(field_name))
1784 raise ValueError("Could not add field to structure.")
1786 class VariantFieldDeclaration(FieldDeclaration):
1788 Create a new variant field type.
1790 def __init__(self, enum_tag, tag_name):
1791 if enum_tag is None or not isinstance(enum_tag, CTFWriter.EnumerationFieldDeclaration):
1792 raise TypeError("Invalid tag type; must be of type EnumerationFieldDeclaration.")
1794 self._ft = _bt_ctf_field_type_variant_create(enum_tag._ft, str(tag_name))
1798 Add a field of type "field_type" to the variant.
1800 def add_field(self, field_type, field_name):
1801 ret = _bt_ctf_field_type_variant_add_field(self._ft, field_type._ft, str(field_name))
1803 raise ValueError("Could not add field to variant.")
1805 class ArrayFieldDeclaration(FieldDeclaration):
1807 Create a new array field type.
1809 def __init__(self, element_type, length):
1810 self._ft = _bt_ctf_field_type_array_create(element_type._ft, length)
1813 class SequenceFieldDeclaration(FieldDeclaration):
1815 Create a new sequence field type.
1817 def __init__(self, element_type, length_field_name):
1818 self._ft = _bt_ctf_field_type_sequence_create(element_type._ft, str(length_field_name))
1821 class StringFieldDeclaration(FieldDeclaration):
1823 Create a new string field type.
1826 self._ft = _bt_ctf_field_type_string_create()
1830 Get a string type's encoding (a constant from the CTFStringEncoding class).
1834 raise NotImplementedError("Getter not implemented.")
1837 Set a string type's encoding. Must be a constant from the CTFStringEncoding class.
1840 def encoding(self, encoding):
1841 ret = _bt_ctf_field_type_string_set_encoding(self._ft, encoding)
1843 raise ValueError("Could not set string encoding.")
1846 Create an instance of a field.
1849 def create_field(self, field_type):
1850 if field_type is None or not isinstance(field_type, CTFWriter.FieldDeclaration):
1851 raise TypeError("Invalid field_type. Type must be a FieldDeclaration-derived class.")
1853 if isinstance(field_type, CTFWriter.IntegerFieldDeclaration):
1854 return CTFWriter.IntegerField(field_type)
1855 elif isinstance(field_type, CTFWriter.EnumerationFieldDeclaration):
1856 return CTFWriter.EnumerationField(field_type)
1857 elif isinstance(field_type, CTFWriter.FloatFieldDeclaration):
1858 return CTFWriter.FloatFieldingPoint(field_type)
1859 elif isinstance(field_type, CTFWriter.StructureFieldDeclaration):
1860 return CTFWriter.StructureField(field_type)
1861 elif isinstance(field_type, CTFWriter.VariantFieldDeclaration):
1862 return CTFWriter.VariantField(field_type)
1863 elif isinstance(field_type, CTFWriter.ArrayFieldDeclaration):
1864 return CTFWriter.ArrayField(field_type)
1865 elif isinstance(field_type, CTFWriter.SequenceFieldDeclaration):
1866 return CTFWriter.SequenceField(field_type)
1867 elif isinstance(field_type, CTFWriter.StringFieldDeclaration):
1868 return CTFWriter.StringField(field_type)
1872 Base class, do not instantiate.
1874 def __init__(self, field_type):
1875 if not isinstance(field_type, CTFWriter.FieldDeclaration):
1876 raise TypeError("Invalid field_type argument.")
1878 self._f = _bt_ctf_field_create(field_type._ft)
1880 raise ValueError("Field creation failed.")
1883 _bt_ctf_field_put(self._f)
1886 def _create_field_from_native_instance(native_field_instance):
1888 CTFTypeId.INTEGER : CTFWriter.IntegerField,
1889 CTFTypeId.FLOAT : CTFWriter.FloatFieldingPoint,
1890 CTFTypeId.ENUM : CTFWriter.EnumerationField,
1891 CTFTypeId.STRING : CTFWriter.StringField,
1892 CTFTypeId.STRUCT : CTFWriter.StructureField,
1893 CTFTypeId.VARIANT : CTFWriter.VariantField,
1894 CTFTypeId.ARRAY : CTFWriter.ArrayField,
1895 CTFTypeId.SEQUENCE : CTFWriter.SequenceField
1898 field_type = _bt_python_get_field_type(native_field_instance)
1899 if field_type == CTFTypeId.UNKNOWN:
1900 raise TypeError("Invalid field instance")
1902 field = CTFWriter.Field.__new__(CTFWriter.Field)
1903 field._f = native_field_instance
1904 field.__class__ = type_dict[field_type]
1907 class IntegerField(Field):
1909 Get an integer field's value.
1913 raise NotImplementedError("Getter not implemented.")
1916 Set an integer field's value.
1919 def value(self, value):
1920 signedness = _bt_python_field_integer_get_signedness(self._f)
1922 raise TypeError("Invalid integer instance.")
1925 ret = _bt_ctf_field_unsigned_integer_set_value(self._f, value)
1927 ret = _bt_ctf_field_signed_integer_set_value(self._f, value)
1930 raise ValueError("Could not set integer field value.")
1932 class EnumerationField(Field):
1934 Return the enumeration's underlying container field (an integer field).
1937 def container(self):
1938 container = CTFWriter.IntegerField.__new__(CTFWriter.IntegerField)
1939 container._f = _bt_ctf_field_enumeration_get_container(self._f)
1940 if container._f is None:
1941 raise TypeError("Invalid enumeration field type.")
1944 class FloatFieldingPoint(Field):
1946 Get a floating point field's value.
1950 raise NotImplementedError("Getter not implemented.")
1953 Set a floating point field's value.
1956 def value(self, value):
1957 ret = _bt_ctf_field_floating_point_set_value(self._f, float(value))
1959 raise ValueError("Could not set floating point field value.")
1961 class StructureField(Field):
1963 Get the structure's field corresponding to the provided field name.
1965 def field(self, field_name):
1966 native_instance = _bt_ctf_field_structure_get_field(self._f, str(field_name))
1967 if native_instance is None:
1968 raise ValueError("Invalid field_name provided.")
1969 return CTFWriter.Field._create_field_from_native_instance(native_instance)
1971 class VariantField(Field):
1973 Return the variant's selected field. The "tag" field is the selector enum field.
1975 def field(self, tag):
1976 native_instance = _bt_ctf_field_variant_get_field(self._f, tag._f)
1977 if native_instance is None:
1978 raise ValueError("Invalid tag provided.")
1979 return CTFWriter.Field._create_field_from_native_instance(native_instance)
1981 class ArrayField(Field):
1983 Return the array's field at position "index".
1985 def field(self, index):
1986 native_instance = _bt_ctf_field_array_get_field(self._f, index)
1987 if native_instance is None:
1988 raise IndexError("Invalid index provided.")
1989 return CTFWriter.Field._create_field_from_native_instance(native_instance)
1991 class SequenceField(Field):
1993 Get the sequence's length field (IntegerField).
1997 raise NotImplementedError("Getter not implemented.")
2000 Set the sequence's length field (IntegerField).
2003 def length(self, length_field):
2004 if not isinstance(length_field, CTFWriter.IntegerField):
2005 raise TypeError("Invalid length field.")
2006 ret = _bt_ctf_field_sequence_set_length(self._f, length_field._f)
2008 raise ValueError("Could not set sequence length.")
2011 Return the sequence's field at position "index".
2013 def field(self, index):
2014 native_instance = _bt_ctf_field_sequence_get_field(self._f, index)
2015 if native_instance is None:
2016 raise ValueError("Could not get sequence element at index.")
2017 return CTFWriter.Field._create_field_from_native_instance(native_instance)
2019 class StringField(Field):
2021 Get a string field's value.
2025 raise NotImplementedError("Getter not implemented.")
2028 Set a string field's value.
2031 def value(self, value):
2032 ret = _bt_ctf_field_string_set_value(self._f, str(value))
2034 raise ValueError("Could not set string field value.")
2038 Create a new event class of the given name.
2040 def __init__(self, name):
2041 self._ec = _bt_ctf_event_class_create(name)
2042 if self._ec is None:
2043 raise ValueError("Event class creation failed.")
2046 _bt_ctf_event_class_put(self._ec)
2049 Add a field of type "field_type" to the event class.
2051 def add_field(self, field_type, field_name):
2052 ret = _bt_ctf_event_class_add_field(self._ec, field_type._ft, str(field_name))
2054 raise ValueError("Could not add field to event class.")
2058 Create a new event of the given event class.
2060 def __init__(self, event_class):
2061 if not isinstance(event_class, CTFWriter.EventClass):
2062 raise TypeError("Invalid event_class argument.")
2064 self._e = _bt_ctf_event_create(event_class._ec)
2066 raise ValueError("Event creation failed.")
2069 _bt_ctf_event_put(self._e)
2072 Set a manually created field as an event's payload.
2074 def set_payload(self, field_name, value_field):
2075 if not isinstance(value, CTFWriter.Field):
2076 raise TypeError("Invalid value type.")
2077 ret = _bt_ctf_event_set_payload(self._e, str(field_name), value_field._f)
2079 raise ValueError("Could not set event field payload.")
2082 Get a field from event.
2084 def payload(self, field_name):
2085 native_instance = _bt_ctf_event_get_payload(self._e, str(field_name))
2086 if native_instance is None:
2087 raise ValueError("Could not get event payload.")
2088 return CTFWriter.Field._create_field_from_native_instance(native_instance)
2092 Create a new stream class of the given name.
2094 def __init__(self, name):
2095 self._sc = _bt_ctf_stream_class_create(name)
2096 if self._sc is None:
2097 raise ValueError("Stream class creation failed.")
2100 _bt_ctf_stream_class_put(self._sc)
2103 Get a stream class' clock.
2107 raise NotImplementedError("Getter not implemented.")
2110 Assign a clock to a stream class.
2113 def clock(self, clock):
2114 if not isinstance(clock, CTFWriter.Clock):
2115 raise TypeError("Invalid clock type.")
2117 ret = _bt_ctf_stream_class_set_clock(self._sc, clock._c)
2119 raise ValueError("Could not set stream class clock.")
2122 Add an event class to a stream class. New events can be added even after a
2123 stream has been instantiated and events have been appended. However, a stream
2124 will not accept events of a class that has not been registered beforehand.
2126 def add_event_class(self, event_class):
2127 if not isinstance(event_class, CTFWriter.EventClass):
2128 raise TypeError("Invalid event_class type.")
2130 ret = _bt_ctf_stream_class_add_event_class(self._sc, event_class._ec)
2132 raise ValueError("Could not add event class.")
2136 Create a stream of the given class.
2138 def __init__(self, stream_class):
2139 if not isinstance(stream_class, CTFWriter.StreamClass):
2140 raise TypeError("Invalid stream_class type.")
2142 self._s = _bt_ctf_stream_create(stream_class._sc)
2144 raise ValueError("Stream creation failed.")
2147 _bt_ctf_stream_put(self._s)
2150 Increase the current packet's discarded event count.
2152 def append_discarded_events(self, event_count):
2153 _bt_ctf_stream_append_discarded_events(self._s, event_count)
2156 Append "event" to the stream's current packet. The stream's associated clock
2157 will be sampled during this call. The event shall not be modified after
2158 being appended to a stream.
2160 def append_event(self, event):
2161 ret = _bt_ctf_stream_append_event(self._s, event._e)
2163 raise ValueError("Could not append event to stream.")
2166 The stream's current packet's events will be flushed to disk. Events
2167 subsequently appended to the stream will be added to a new packet.
2170 ret = _bt_ctf_stream_flush(self._s)
2172 raise ValueError("Could not flush stream.")
2176 Create a new writer that will produce a trace in the given path.
2178 def __init__(self, path):
2179 self._w = _bt_ctf_writer_create(path)
2181 raise ValueError("Writer creation failed.")
2184 _bt_ctf_writer_put(self._w)
2187 Create a new stream instance and register it to the writer.
2189 def create_stream(self, stream_class):
2190 if not isinstance(stream_class, CTFWriter.StreamClass):
2191 raise TypeError("Invalid stream_class type.")
2193 stream = CTFWriter.Stream.__new__(CTFWriter.Stream)
2194 stream._s = _bt_ctf_writer_create_stream(self._w, stream_class._sc)
2198 Add an environment field to the trace.
2200 def add_environment_field(self, name, value):
2201 ret = _bt_ctf_writer_add_environment_field(self._w, str(name), str(value))
2203 raise ValueError("Could not add environment field to trace.")
2206 Add a clock to the trace. Clocks assigned to stream classes must be
2207 registered to the writer.
2209 def add_clock(self, clock):
2210 ret = _bt_ctf_writer_add_clock(self._w, clock._c)
2212 raise ValueError("Could not add clock to Writer.")
2215 Get the trace's TSDL meta-data.
2219 return _bt_ctf_writer_get_metadata_string(self._w)
2222 Flush the trace's metadata to the metadata file.
2224 def flush_metadata(self):
2225 _bt_ctf_writer_flush_metadata(self._w)
2228 Get the trace's byte order. Must be a constant from the ByteOrder
2232 def byte_order(self):
2233 raise NotImplementedError("Getter not implemented.")
2236 Set the trace's byte order. Must be a constant from the ByteOrder
2237 class. Defaults to BYTE_ORDER_NATIVE, the host machine's endianness.
2240 def byte_order(self, byte_order):
2241 ret = _bt_ctf_writer_set_byte_order(self._w, byte_order)
2243 raise ValueError("Could not set trace's byte order.")