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
39 #define SWIG_FILE_WITH_INIT
40 #include <babeltrace/babeltrace.h>
41 #include <babeltrace/babeltrace-internal.h>
42 #include <babeltrace/trace-handle.h>
43 #include <babeltrace/trace-handle-internal.h>
44 #include <babeltrace/context.h>
45 #include <babeltrace/context-internal.h>
46 #include <babeltrace/iterator.h>
47 #include <babeltrace/iterator-internal.h>
48 #include <babeltrace/format.h>
49 #include <babeltrace/list.h>
50 #include <babeltrace/types.h>
51 #include <babeltrace/ctf/iterator.h>
52 #include "python-complements.h"
53 #include <babeltrace/ctf-writer/clock.h>
54 #include <babeltrace/ctf-writer/event-fields.h>
55 #include <babeltrace/ctf-writer/event-types.h>
56 #include <babeltrace/ctf-writer/event.h>
57 #include <babeltrace/ctf-writer/stream.h>
58 #include <babeltrace/ctf-writer/writer.h>
61 typedef int bt_intern_str;
62 typedef int64_t ssize_t;
64 /* =================================================================
66 ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
69 struct bt_definition **_bt_python_field_listcaller(
70 const struct bt_ctf_event *ctf_event,
71 const struct bt_definition *scope,
72 unsigned int *OUTPUT);
73 struct bt_definition *_bt_python_field_one_from_list(
74 struct bt_definition **list, int index);
75 struct bt_ctf_event_decl **_bt_python_event_decl_listcaller(
77 struct bt_context *ctx,
78 unsigned int *OUTPUT);
79 struct bt_ctf_event_decl *_bt_python_decl_one_from_list(
80 struct bt_ctf_event_decl **list, int index);
81 struct bt_ctf_field_decl **_by_python_field_decl_listcaller(
82 struct bt_ctf_event_decl *event_decl,
83 enum bt_ctf_scope scope,
84 unsigned int *OUTPUT);
85 struct bt_ctf_field_decl *_bt_python_field_decl_one_from_list(
86 struct bt_ctf_field_decl **list, int index);
87 struct definition_array *_bt_python_get_array_from_def(
88 struct bt_definition *field);
89 struct definition_sequence *_bt_python_get_sequence_from_def(
90 struct bt_definition *field);
91 struct bt_declaration *_bt_python_get_array_element_declaration(
92 struct bt_declaration *field);
93 struct bt_declaration *_bt_python_get_sequence_element_declaration(
94 struct bt_declaration *field);
95 const char *_bt_python_get_array_string(struct bt_definition *field);
96 const char *_bt_python_get_sequence_string(struct bt_definition *field);
97 int _bt_python_field_integer_get_signedness(const struct bt_ctf_field *field);
98 enum ctf_type_id _bt_python_get_field_type(const struct bt_ctf_field *field);
99 const char *_bt_python_ctf_field_type_enumeration_get_mapping(
100 struct bt_ctf_field_type *enumeration, size_t index,
101 int64_t *OUTPUT, int64_t *OUTPUT);
102 const char *_bt_python_ctf_field_type_enumeration_get_mapping_unsigned(
103 struct bt_ctf_field_type *enumeration, size_t index,
104 uint64_t *OUTPUT, uint64_t *OUTPUT);
105 const char *_bt_python_ctf_field_type_structure_get_field_name(
106 struct bt_ctf_field_type *structure, size_t index);
107 struct bt_ctf_field_type *_bt_python_ctf_field_type_structure_get_field_type(
108 struct bt_ctf_field_type *structure, size_t index);
109 const char *_bt_python_ctf_field_type_variant_get_field_name(
110 struct bt_ctf_field_type *variant, size_t index);
111 struct bt_ctf_field_type *_bt_python_ctf_field_type_variant_get_field_type(
112 struct bt_ctf_field_type *variant, size_t index);
113 const char *_bt_python_ctf_event_class_get_field_name(
114 struct bt_ctf_event_class *event_class, size_t index);
115 struct bt_ctf_field_type *_bt_python_ctf_event_class_get_field_type(
116 struct bt_ctf_event_class *event_class, size_t index);
118 /* =================================================================
119 CONTEXT.H, CONTEXT-INTERNAL.H
120 ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
123 %rename("_bt_context_create") bt_context_create(void);
124 %rename("_bt_context_add_trace") bt_context_add_trace(
125 struct bt_context *ctx, const char *path, const char *format,
126 void (*packet_seek)(struct bt_stream_pos *pos, size_t index, int whence),
127 struct bt_mmap_stream_list *stream_list, FILE *metadata);
128 %rename("_bt_context_remove_trace") bt_context_remove_trace(
129 struct bt_context *ctx, int trace_id);
130 %rename("_bt_context_get") bt_context_get(struct bt_context *ctx);
131 %rename("_bt_context_put") bt_context_put(struct bt_context *ctx);
132 %rename("_bt_ctf_event_get_context") bt_ctf_event_get_context(
133 const struct bt_ctf_event *event);
135 struct bt_context *bt_context_create(void);
136 int bt_context_add_trace(struct bt_context *ctx, const char *path, const char *format,
137 void (*packet_seek)(struct bt_stream_pos *pos, size_t index, int whence),
138 struct bt_mmap_stream_list *stream_list, FILE *metadata);
139 void bt_context_remove_trace(struct bt_context *ctx, int trace_id);
140 void bt_context_get(struct bt_context *ctx);
141 void bt_context_put(struct bt_context *ctx);
142 struct bt_context *bt_ctf_event_get_context(const struct bt_ctf_event *event);
144 // class TraceCollection to prevent direct access to struct bt_context
146 class TraceCollection:
148 The TraceCollection is the object that contains all currently opened traces.
152 self._tc = _bt_context_create()
155 _bt_context_put(self._tc)
157 def add_trace(self, path, format_str):
159 Add a trace by path to the TraceCollection.
163 path is the path to the trace, it is not recursive.
164 If "path" is None, stream_list is used instead as a list
165 of mmap streams to open for the trace.
167 format is a string containing the format name in which the trace was
170 Return: the corresponding TraceHandle on success or None on error.
172 ret = _bt_context_add_trace(self._tc, path, format_str, None, None, None)
176 th = TraceHandle.__new__(TraceHandle)
178 th._trace_collection = self
181 def add_traces_recursive(self, path, format_str):
183 Open a trace recursively.
185 Find each trace present in the subdirectory starting from the given
186 path, and add them to the TraceCollection.
188 Return a dict of TraceHandle instances (the full path is the key).
189 Return None on error.
199 for fullpath, dirs, files in os.walk(path):
200 if "metadata" in files:
201 trace_handle = self.add_trace(fullpath, format_str)
202 if trace_handle is None:
206 trace_handles[fullpath] = trace_handle
209 if noTrace and error:
213 def remove_trace(self, trace_handle):
215 Remove a trace from the TraceCollection.
216 Effectively closing the trace.
219 _bt_context_remove_trace(self._tc, trace_handle._id)
220 except AttributeError:
221 raise TypeError("in remove_trace, "
222 "argument 2 must be a TraceHandle instance")
227 Generator function to iterate over the events of open in the current
230 begin_pos_ptr = _bt_iter_pos()
231 end_pos_ptr = _bt_iter_pos()
232 begin_pos_ptr.type = SEEK_BEGIN
233 end_pos_ptr.type = SEEK_LAST
235 for event in self._events(begin_pos_ptr, end_pos_ptr):
238 def events_timestamps(self, timestamp_begin, timestamp_end):
240 Generator function to iterate over the events of open in the current
241 TraceCollection from timestamp_begin to timestamp_end.
243 begin_pos_ptr = _bt_iter_pos()
244 end_pos_ptr = _bt_iter_pos()
245 begin_pos_ptr.type = end_pos_ptr.type = SEEK_TIME
246 begin_pos_ptr.u.seek_time = timestamp_begin
247 end_pos_ptr.u.seek_time = timestamp_end
249 for event in self._events(begin_pos_ptr, end_pos_ptr):
253 def timestamp_begin(self):
254 pos_ptr = _bt_iter_pos()
255 pos_ptr.type = SEEK_BEGIN
256 return self._timestamp_at_pos(pos_ptr)
259 def timestamp_end(self):
260 pos_ptr = _bt_iter_pos()
261 pos_ptr.type = SEEK_LAST
262 return self._timestamp_at_pos(pos_ptr)
264 def _timestamp_at_pos(self, pos_ptr):
265 ctf_it_ptr = _bt_ctf_iter_create(self._tc, pos_ptr, pos_ptr)
266 if ctf_it_ptr is None:
267 raise NotImplementedError("Creation of multiple iterators is unsupported.")
268 ev_ptr = _bt_ctf_iter_read_event(ctf_it_ptr)
269 _bt_ctf_iter_destroy(ctf_it_ptr)
273 def _events(self, begin_pos_ptr, end_pos_ptr):
274 ctf_it_ptr = _bt_ctf_iter_create(self._tc, begin_pos_ptr, end_pos_ptr)
275 if ctf_it_ptr is None:
276 raise NotImplementedError(
277 "Creation of multiple iterators is unsupported.")
280 ev_ptr = _bt_ctf_iter_read_event(ctf_it_ptr)
284 ev = Event.__new__(Event)
288 except GeneratorExit:
291 ret = _bt_iter_next(_bt_ctf_get_iter(ctf_it_ptr))
295 _bt_ctf_iter_destroy(ctf_it_ptr)
301 /* =================================================================
306 %rename("lookup_format") bt_lookup_format(bt_intern_str qname);
307 %rename("_bt_print_format_list") bt_fprintf_format_list(FILE *fp);
308 %rename("register_format") bt_register_format(struct format *format);
309 %rename("unregister_format") bt_unregister_format(struct bt_format *format);
311 extern struct format *bt_lookup_format(bt_intern_str qname);
312 extern void bt_fprintf_format_list(FILE *fp);
313 extern int bt_register_format(struct bt_format *format);
314 extern void bt_unregister_format(struct bt_format *format);
318 def print_format_list(babeltrace_file):
320 Print a list of available formats to file.
322 babeltrace_file must be a File instance opened in write mode.
325 if babeltrace_file._file is not None:
326 _bt_print_format_list(babeltrace_file._file)
327 except AttributeError:
328 raise TypeError("in print_format_list, "
329 "argument 1 must be a File instance")
334 /* =================================================================
335 ITERATOR.H, ITERATOR-INTERNAL.H
336 ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
339 %rename("_bt_iter_create") bt_iter_create(struct bt_context *ctx,
340 const struct bt_iter_pos *begin_pos, const struct bt_iter_pos *end_pos);
341 %rename("_bt_iter_destroy") bt_iter_destroy(struct bt_iter *iter);
342 %rename("_bt_iter_next") bt_iter_next(struct bt_iter *iter);
343 %rename("_bt_iter_get_pos") bt_iter_get_pos(struct bt_iter *iter);
344 %rename("_bt_iter_free_pos") bt_iter_free_pos(struct bt_iter_pos *pos);
345 %rename("_bt_iter_set_pos") bt_iter_set_pos(struct bt_iter *iter,
346 const struct bt_iter_pos *pos);
347 %rename("_bt_iter_create_time_pos") bt_iter_create_time_pos(struct bt_iter *iter,
350 struct bt_iter *bt_iter_create(struct bt_context *ctx,
351 const struct bt_iter_pos *begin_pos, const struct bt_iter_pos *end_pos);
352 void bt_iter_destroy(struct bt_iter *iter);
353 int bt_iter_next(struct bt_iter *iter);
354 struct bt_iter_pos *bt_iter_get_pos(struct bt_iter *iter);
355 void bt_iter_free_pos(struct bt_iter_pos *pos);
356 int bt_iter_set_pos(struct bt_iter *iter, const struct bt_iter_pos *pos);
357 struct bt_iter_pos *bt_iter_create_time_pos(struct bt_iter *iter, uint64_t timestamp);
359 %rename("_bt_iter_pos") bt_iter_pos;
360 %rename("SEEK_TIME") BT_SEEK_TIME;
361 %rename("SEEK_RESTORE") BT_SEEK_RESTORE;
362 %rename("SEEK_CUR") BT_SEEK_CUR;
363 %rename("SEEK_BEGIN") BT_SEEK_BEGIN;
364 %rename("SEEK_LAST") BT_SEEK_LAST;
366 // This struct is taken from iterator.h
367 // All changes to the struct must also be made here
370 BT_SEEK_TIME, /* uses u.seek_time */
371 BT_SEEK_RESTORE, /* uses u.restore */
378 struct bt_saved_pos *restore;
382 /* =================================================================
383 TRACE-HANDLE.H, TRACE-HANDLE-INTERNAL.H
384 ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
387 %rename("_bt_trace_handle_create") bt_trace_handle_create(struct bt_context *ctx);
388 %rename("_bt_trace_handle_destroy") bt_trace_handle_destroy(struct bt_trace_handle *bt);
389 struct bt_trace_handle *bt_trace_handle_create(struct bt_context *ctx);
390 void bt_trace_handle_destroy(struct bt_trace_handle *bt);
392 %rename("_bt_trace_handle_get_path") bt_trace_handle_get_path(struct bt_context *ctx,
394 %rename("_bt_trace_handle_get_timestamp_begin") bt_trace_handle_get_timestamp_begin(
395 struct bt_context *ctx, int handle_id, enum bt_clock_type type);
396 %rename("_bt_trace_handle_get_timestamp_end") bt_trace_handle_get_timestamp_end(
397 struct bt_context *ctx, int handle_id, enum bt_clock_type type);
398 const char *bt_trace_handle_get_path(struct bt_context *ctx, int handle_id);
399 uint64_t bt_trace_handle_get_timestamp_begin(struct bt_context *ctx, int handle_id,
400 enum bt_clock_type type);
401 uint64_t bt_trace_handle_get_timestamp_end(struct bt_context *ctx, int handle_id,
402 enum bt_clock_type type);
404 %rename("_bt_ctf_event_get_handle_id") bt_ctf_event_get_handle_id(
405 const struct bt_ctf_event *event);
406 int bt_ctf_event_get_handle_id(const struct bt_ctf_event *event);
411 # Based on enum bt_clock_type in clock-type.h
416 class TraceHandle(object):
418 The TraceHandle allows the user to manipulate a trace file directly.
419 It is a unique identifier representing a trace file.
424 raise NotImplementedError("TraceHandle cannot be instantiated")
427 return "Babeltrace TraceHandle: trace_id('{0}')".format(self._id)
431 """Return the TraceHandle id."""
436 """Return the path of a TraceHandle."""
437 return _bt_trace_handle_get_path(self._trace_collection._tc, self._id)
440 def timestamp_begin(self):
441 """Return the creation time of the buffers of a trace."""
442 return _bt_trace_handle_get_timestamp_begin(
443 self._trace_collection._tc, self._id, ClockType.CLOCK_REAL)
446 def timestamp_end(self):
447 """Return the destruction timestamp of the buffers of a trace."""
448 return _bt_trace_handle_get_timestamp_end(
449 self._trace_collection._tc, self._id, ClockType.CLOCK_REAL)
454 Generator returning all events (EventDeclaration) in a trace.
456 ret = _bt_python_event_decl_listcaller(self.id, self._trace_collection._tc)
458 if not isinstance(ret, list):
461 ptr_list, count = ret
462 for i in range(count):
463 tmp = EventDeclaration.__new__(EventDeclaration)
464 tmp._ed = _bt_python_decl_one_from_list(ptr_list, i)
471 // =================================================================
473 // =================================================================
475 /* =================================================================
481 %rename("_bt_ctf_iter_create") bt_ctf_iter_create(struct bt_context *ctx,
482 const struct bt_iter_pos *begin_pos,
483 const struct bt_iter_pos *end_pos);
484 %rename("_bt_ctf_get_iter") bt_ctf_get_iter(struct bt_ctf_iter *iter);
485 %rename("_bt_ctf_iter_destroy") bt_ctf_iter_destroy(struct bt_ctf_iter *iter);
486 %rename("_bt_ctf_iter_read_event") bt_ctf_iter_read_event(struct bt_ctf_iter *iter);
488 struct bt_ctf_iter *bt_ctf_iter_create(struct bt_context *ctx,
489 const struct bt_iter_pos *begin_pos,
490 const struct bt_iter_pos *end_pos);
491 struct bt_iter *bt_ctf_get_iter(struct bt_ctf_iter *iter);
492 void bt_ctf_iter_destroy(struct bt_ctf_iter *iter);
493 struct bt_ctf_event *bt_ctf_iter_read_event(struct bt_ctf_iter *iter);
497 %rename("_bt_ctf_get_top_level_scope") bt_ctf_get_top_level_scope(const struct
498 bt_ctf_event *event, enum bt_ctf_scope scope);
499 %rename("_bt_ctf_event_name") bt_ctf_event_name(const struct bt_ctf_event *ctf_event);
500 %rename("_bt_ctf_get_timestamp") bt_ctf_get_timestamp(
501 const struct bt_ctf_event *ctf_event);
502 %rename("_bt_ctf_get_cycles") bt_ctf_get_cycles(
503 const struct bt_ctf_event *ctf_event);
505 %rename("_bt_ctf_get_field") bt_ctf_get_field(const struct bt_ctf_event *ctf_event,
506 const struct bt_definition *scope, const char *field);
507 %rename("_bt_ctf_get_index") bt_ctf_get_index(const struct bt_ctf_event *ctf_event,
508 const struct bt_definition *field, unsigned int index);
509 %rename("_bt_ctf_field_name") bt_ctf_field_name(const struct bt_definition *field);
510 %rename("_bt_ctf_field_type") bt_ctf_field_type(const struct bt_declaration *field);
511 %rename("_bt_ctf_get_int_signedness") bt_ctf_get_int_signedness(
512 const struct bt_declaration *field);
513 %rename("_bt_ctf_get_int_base") bt_ctf_get_int_base(const struct bt_declaration *field);
514 %rename("_bt_ctf_get_int_byte_order") bt_ctf_get_int_byte_order(
515 const struct bt_declaration *field);
516 %rename("_bt_ctf_get_int_len") bt_ctf_get_int_len(const struct bt_declaration *field);
517 %rename("_bt_ctf_get_enum_int") bt_ctf_get_enum_int(const struct bt_definition *field);
518 %rename("_bt_ctf_get_enum_str") bt_ctf_get_enum_str(const struct bt_definition *field);
519 %rename("_bt_ctf_get_encoding") bt_ctf_get_encoding(const struct bt_declaration *field);
520 %rename("_bt_ctf_get_array_len") bt_ctf_get_array_len(const struct bt_declaration *field);
521 %rename("_bt_ctf_get_uint64") bt_ctf_get_uint64(const struct bt_definition *field);
522 %rename("_bt_ctf_get_int64") bt_ctf_get_int64(const struct bt_definition *field);
523 %rename("_bt_ctf_get_char_array") bt_ctf_get_char_array(const struct bt_definition *field);
524 %rename("_bt_ctf_get_string") bt_ctf_get_string(const struct bt_definition *field);
525 %rename("_bt_ctf_get_float") bt_ctf_get_float(const struct bt_definition *field);
526 %rename("_bt_ctf_get_variant") bt_ctf_get_variant(const struct bt_definition *field);
527 %rename("_bt_ctf_field_get_error") bt_ctf_field_get_error(void);
528 %rename("_bt_ctf_get_decl_event_name") bt_ctf_get_decl_event_name(const struct
529 bt_ctf_event_decl *event);
530 %rename("_bt_ctf_get_decl_event_id") bt_ctf_get_decl_event_id(const struct
531 bt_ctf_event_decl *event);
532 %rename("_bt_ctf_get_decl_field_name") bt_ctf_get_decl_field_name(
533 const struct bt_ctf_field_decl *field);
534 %rename("_bt_ctf_get_decl_from_def") bt_ctf_get_decl_from_def(
535 const struct bt_definition *field);
536 %rename("_bt_ctf_get_decl_from_field_decl") bt_ctf_get_decl_from_field_decl(
537 const struct bt_ctf_field_decl *field);
538 %rename("_bt_array_index") bt_array_index(struct definition_array *array, uint64_t i);
539 %rename("_bt_sequence_len") bt_sequence_len(struct definition_sequence *sequence);
540 %rename("_bt_sequence_index") bt_sequence_index(struct definition_sequence *sequence, uint64_t i);
541 %rename("_bt_ctf_get_struct_field_count") bt_ctf_get_struct_field_count(const struct bt_definition *structure);
542 %rename("_bt_ctf_get_struct_field_index") bt_ctf_get_struct_field_index(const struct bt_definition *structure, uint64_t i);
544 const struct bt_definition *bt_ctf_get_top_level_scope(const struct bt_ctf_event *ctf_event,
545 enum bt_ctf_scope scope);
546 const char *bt_ctf_event_name(const struct bt_ctf_event *ctf_event);
547 uint64_t bt_ctf_get_timestamp(const struct bt_ctf_event *ctf_event);
548 uint64_t bt_ctf_get_cycles(const struct bt_ctf_event *ctf_event);
549 const struct bt_definition *bt_ctf_get_field(const struct bt_ctf_event *ctf_event,
550 const struct bt_definition *scope,
552 const struct bt_definition *bt_ctf_get_index(const struct bt_ctf_event *ctf_event,
553 const struct bt_definition *field,
555 const char *bt_ctf_field_name(const struct bt_definition *field);
556 enum ctf_type_id bt_ctf_field_type(const struct bt_declaration *field);
557 int bt_ctf_get_int_signedness(const struct bt_declaration *field);
558 int bt_ctf_get_int_base(const struct bt_declaration *field);
559 int bt_ctf_get_int_byte_order(const struct bt_declaration *field);
560 ssize_t bt_ctf_get_int_len(const struct bt_declaration *field);
561 const struct bt_definition *bt_ctf_get_enum_int(const struct bt_definition *field);
562 const char *bt_ctf_get_enum_str(const struct bt_definition *field);
563 enum ctf_string_encoding bt_ctf_get_encoding(const struct bt_declaration *field);
564 int bt_ctf_get_array_len(const struct bt_declaration *field);
565 struct bt_definition *bt_array_index(struct definition_array *array, uint64_t i);
566 uint64_t bt_ctf_get_uint64(const struct bt_definition *field);
567 int64_t bt_ctf_get_int64(const struct bt_definition *field);
568 char *bt_ctf_get_char_array(const struct bt_definition *field);
569 char *bt_ctf_get_string(const struct bt_definition *field);
570 double bt_ctf_get_float(const struct bt_definition *field);
571 const struct bt_definition *bt_ctf_get_variant(const struct bt_definition *field);
572 int bt_ctf_field_get_error(void);
573 const char *bt_ctf_get_decl_event_name(const struct bt_ctf_event_decl *event);
574 uint64_t bt_ctf_get_decl_event_id(const struct bt_ctf_event_decl *event);
575 const char *bt_ctf_get_decl_field_name(const struct bt_ctf_field_decl *field);
576 const struct bt_declaration *bt_ctf_get_decl_from_def(const struct bt_definition *field);
577 const struct bt_declaration *bt_ctf_get_decl_from_field_decl(const struct bt_ctf_field_decl *field);
578 uint64_t bt_sequence_len(struct definition_sequence *sequence);
579 struct bt_definition *bt_sequence_index(struct definition_sequence *sequence, uint64_t i);
580 uint64_t bt_ctf_get_struct_field_count(const struct bt_definition *structure);
581 const struct bt_definition *bt_ctf_get_struct_field_index(const struct bt_definition *structure, uint64_t i);
585 class CTFStringEncoding:
591 # Based on the enum in ctf-writer/writer.h
593 BYTE_ORDER_NATIVE = 0
594 BYTE_ORDER_LITTLE_ENDIAN = 1
595 BYTE_ORDER_BIG_ENDIAN = 2
596 BYTE_ORDER_NETWORK = 3
597 BYTE_ORDER_UNKNOWN = 4 # Python-specific entry
599 #enum equivalent, accessible constants
600 #These are taken directly from ctf/events.h
601 #All changes to enums must also be made here
615 name = "UNKNOWN_TYPE"
616 constants = [attr for attr in dir(CTFTypeId) if not callable(getattr(CTFTypeId, attr)) and not attr.startswith("__")]
617 for attr in constants:
618 if getattr(CTFTypeId, attr) == id:
624 TRACE_PACKET_HEADER = 0
625 STREAM_PACKET_CONTEXT = 1
626 STREAM_EVENT_HEADER = 2
627 STREAM_EVENT_CONTEXT = 3
631 def scope_name(scope):
632 name = "UNKNOWN_SCOPE"
633 constants = [attr for attr in dir(CTFScope) if not callable(getattr(CTFScope, attr)) and not attr.startswith("__")]
634 for attr in constants:
635 if getattr(CTFScope, attr) == scope:
640 # Priority of the scopes when searching for event fields
641 _scopes = [CTFScope.EVENT_FIELDS, CTFScope.EVENT_CONTEXT, CTFScope.STREAM_EVENT_CONTEXT,
642 CTFScope.STREAM_EVENT_HEADER, CTFScope.STREAM_PACKET_CONTEXT, CTFScope.TRACE_PACKET_HEADER]
645 class Event(collections.Mapping):
647 This class represents an event from the trace.
648 It is obtained using the TraceCollection generator functions.
652 raise NotImplementedError("Event cannot be instantiated")
656 """Return the name of the event or None on error."""
657 return _bt_ctf_event_name(self._e)
662 Return the timestamp of the event as written in
663 the packet (in cycles) or -1ULL on error.
665 return _bt_ctf_get_cycles(self._e)
670 Return the timestamp of the event offset with the
671 system clock source or -1ULL on error.
673 return _bt_ctf_get_timestamp(self._e)
675 def field_with_scope(self, field_name, scope):
677 Get field_name's value in scope.
678 None is returned if no field matches field_name.
680 if not scope in _scopes:
681 raise ValueError("Invalid scope provided")
682 field = self._field_with_scope(field_name, scope)
683 if field is not None:
687 def field_list_with_scope(self, scope):
688 """Return a list of field names in scope."""
689 if not scope in _scopes:
690 raise ValueError("Invalid scope provided")
692 for field in self._field_list_with_scope(scope):
693 field_names.append(field.name)
699 Get the TraceHandle associated with this event
702 ret = _bt_ctf_event_get_handle_id(self._e)
706 th = TraceHandle.__new__(TraceHandle)
708 th._trace_collection = self.get_trace_collection()
712 def trace_collection(self):
714 Get the TraceCollection associated with this event.
715 Return None on error.
717 trace_collection = TraceCollection()
718 trace_collection._tc = _bt_ctf_event_get_context(self._e);
719 if trace_collection._tc is None:
722 return trace_collection
724 def __getitem__(self, field_name):
726 Get field_name's value. If the field_name exists in multiple
727 scopes, the first field found is returned. The scopes are searched
728 in the following order:
731 3) STREAM_EVENT_CONTEXT
732 4) STREAM_EVENT_HEADER
733 5) STREAM_PACKET_CONTEXT
734 6) TRACE_PACKET_HEADER
735 None is returned if no field matches field_name.
737 Use field_with_scope() to explicitly access fields in a given
740 field = self._field(field_name)
741 if field is not None:
743 raise KeyError(field_name)
746 for key in self.keys():
751 for scope in _scopes:
752 scope_ptr = _bt_ctf_get_top_level_scope(self._e, scope)
753 ret = _bt_python_field_listcaller(self._e, scope_ptr)
754 if isinstance(ret, list):
758 def __contains__(self, field_name):
759 return self._field(field_name) is not None
762 """Return a list of field names."""
764 for scope in _scopes:
765 for name in self.field_list_with_scope(scope):
766 field_names.add(name)
767 return list(field_names)
769 def get(self, field_name, default = None):
770 field = self._field(field_name)
776 for field in self.keys():
777 yield (field, self[field])
779 def _field_with_scope(self, field_name, scope):
780 scope_ptr = _bt_ctf_get_top_level_scope(self._e, scope)
781 if scope_ptr is None:
784 definition_ptr = _bt_ctf_get_field(self._e, scope_ptr, field_name)
785 if definition_ptr is None:
788 field = _Definition(definition_ptr, scope)
791 def _field(self, field_name):
793 for scope in _scopes:
794 field = self._field_with_scope(field_name, scope)
795 if field is not None:
799 def _field_list_with_scope(self, scope):
801 scope_ptr = _bt_ctf_get_top_level_scope(self._e, scope)
803 # Returns a list [list_ptr, count]. If list_ptr is NULL, SWIG will only
804 # provide the "count" return value
807 ret = _bt_python_field_listcaller(self._e, scope_ptr)
808 if isinstance(ret, list):
809 list_ptr, count = ret
811 for i in range(count):
812 definition_ptr = _bt_python_field_one_from_list(list_ptr, i)
813 if definition_ptr is not None:
814 definition = _Definition(definition_ptr, scope)
815 fields.append(definition)
818 class FieldError(Exception):
819 def __init__(self, value):
823 return repr(self.value)
825 class EventDeclaration(object):
826 """Event declaration class. Do not instantiate."""
827 MAX_UINT64 = 0xFFFFFFFFFFFFFFFF
830 raise NotImplementedError("EventDeclaration cannot be instantiated")
834 """Return the name of the event or None on error"""
835 return _bt_ctf_get_decl_event_name(self._ed)
839 """Return the event-ID of the event or -1 on error"""
840 id = _bt_ctf_get_decl_event_id(self._ed)
841 if id == self.MAX_UINT64:
848 Generator returning all FieldDeclarations of an event, going through
849 each scope in the following order:
852 3) STREAM_EVENT_CONTEXT
853 4) STREAM_EVENT_HEADER
854 5) STREAM_PACKET_CONTEXT
855 6) TRACE_PACKET_HEADER
857 for scope in _scopes:
858 for declaration in self.fields_scope(scope):
861 def fields_scope(self, scope):
863 Generator returning FieldDeclarations of the current event in scope.
865 ret = _by_python_field_decl_listcaller(self._ed, scope)
867 if not isinstance(ret, list):
870 list_ptr, count = ret
871 for i in range(count):
872 field_declaration_ptr = _bt_python_field_decl_one_from_list(list_ptr, i)
873 if field_declaration_ptr is not None:
874 declaration_ptr = _bt_ctf_get_decl_from_field_decl(field_declaration_ptr)
875 field_declaration = _create_field_declaration(declaration_ptr, _bt_ctf_get_decl_field_name(field_declaration_ptr), scope)
876 yield field_declaration
878 class FieldDeclaration(object):
879 """Field declaration class. Do not instantiate."""
881 raise NotImplementedError("FieldDeclaration cannot be instantiated")
884 return "({0}) {1} {2}".format(CTFScope.scope_name(self.scope), CTFTypeId.type_name(self.type), self.name)
888 """Return the name of a FieldDeclaration or None on error."""
894 Return the FieldDeclaration's type. One of the entries in class
897 return _bt_ctf_field_type(self._fd)
902 Return the FieldDeclaration's scope.
906 class IntegerFieldDeclaration(FieldDeclaration):
907 """Do not instantiate."""
909 raise NotImplementedError("IntegerFieldDeclaration cannot be instantiated")
912 def signedness(self):
914 Return the signedness of an integer:
915 0 if unsigned; 1 if signed; -1 on error.
917 return _bt_ctf_get_int_signedness(self._fd)
921 """Return the base of an int or a negative value on error."""
922 return _bt_ctf_get_int_base(self._fd)
925 def byte_order(self):
927 Return the byte order. One of class ByteOrder's entries.
929 ret = _bt_ctf_get_int_byte_order(self._fd)
931 return ByteOrder.BYTE_ORDER_LITTLE_ENDIAN
933 return ByteOrder.BYTE_ORDER_BIG_ENDIAN
935 return ByteOrder.BYTE_ORDER_UNKNOWN
940 Return the size, in bits, of an int or a negative
943 return _bt_ctf_get_int_len(self._fd)
948 Return the encoding. One of class CTFStringEncoding's entries.
949 Return a negative value on error.
951 return _bt_ctf_get_encoding(self._fd)
953 class EnumerationFieldDeclaration(FieldDeclaration):
954 """Do not instantiate."""
956 raise NotImplementedError("EnumerationFieldDeclaration cannot be instantiated")
958 class ArrayFieldDeclaration(FieldDeclaration):
959 """Do not instantiate."""
961 raise NotImplementedError("ArrayFieldDeclaration cannot be instantiated")
966 Return the length of an array or a negative
969 return _bt_ctf_get_array_len(self._fd)
972 def element_declaration(self):
974 Return element declaration.
976 field_decl_ptr = _bt_python_get_array_element_declaration(self._fd)
977 return _create_field_declaration(field_decl_ptr, "", self.scope)
979 class SequenceFieldDeclaration(FieldDeclaration):
980 """Do not instantiate."""
982 raise NotImplementedError("SequenceFieldDeclaration cannot be instantiated")
985 def element_declaration(self):
987 Return element declaration.
989 field_decl_ptr = _bt_python_get_sequence_element_declaration(self._fd)
990 return _create_field_declaration(field_decl_ptr, "", self.scope)
992 class FloatFieldDeclaration(FieldDeclaration):
993 """Do not instantiate."""
995 raise NotImplementedError("FloatFieldDeclaration cannot be instantiated")
997 class StructureFieldDeclaration(FieldDeclaration):
998 """Do not instantiate."""
1000 raise NotImplementedError("StructureFieldDeclaration cannot be instantiated")
1002 class StringFieldDeclaration(FieldDeclaration):
1003 """Do not instantiate."""
1005 raise NotImplementedError("StringFieldDeclaration cannot be instantiated")
1007 class VariantFieldDeclaration(FieldDeclaration):
1008 """Do not instantiate."""
1010 raise NotImplementedError("VariantFieldDeclaration cannot be instantiated")
1014 Return the last error code encountered while
1015 accessing a field and reset the error flag.
1016 Return 0 if no error, a negative value otherwise.
1018 return _bt_ctf_field_get_error()
1020 def _create_field_declaration(declaration_ptr, name, scope):
1022 Private field declaration factory.
1024 if declaration_ptr is None:
1025 raise ValueError("declaration_ptr must be valid")
1026 if not scope in _scopes:
1027 raise ValueError("Invalid scope provided")
1029 type = _bt_ctf_field_type(declaration_ptr)
1031 if type == CTFTypeId.INTEGER:
1032 declaration = IntegerFieldDeclaration.__new__(IntegerFieldDeclaration)
1033 elif type == CTFTypeId.ENUM:
1034 declaration = EnumerationFieldDeclaration.__new__(EnumerationFieldDeclaration)
1035 elif type == CTFTypeId.ARRAY:
1036 declaration = ArrayFieldDeclaration.__new__(ArrayFieldDeclaration)
1037 elif type == CTFTypeId.SEQUENCE:
1038 declaration = SequenceFieldDeclaration.__new__(SequenceFieldDeclaration)
1039 elif type == CTFTypeId.FLOAT:
1040 declaration = FloatFieldDeclaration.__new__(FloatFieldDeclaration)
1041 elif type == CTFTypeId.STRUCT:
1042 declaration = StructureFieldDeclaration.__new__(StructureFieldDeclaration)
1043 elif type == CTFTypeId.STRING:
1044 declaration = StringFieldDeclaration.__new__(StringFieldDeclaration)
1045 elif type == CTFTypeId.VARIANT:
1046 declaration = VariantFieldDeclaration.__new__(VariantFieldDeclaration)
1050 declaration._fd = declaration_ptr
1051 declaration._s = scope
1052 declaration._name = name
1055 class _Definition(object):
1056 def __init__(self, definition_ptr, scope):
1057 self._d = definition_ptr
1059 if not scope in _scopes:
1060 ValueError("Invalid scope provided")
1064 """Return the name of a field or None on error."""
1065 return _bt_ctf_field_name(self._d)
1069 """Return the type of a field or -1 if unknown."""
1070 return _bt_ctf_field_type(_bt_ctf_get_decl_from_def(self._d))
1073 def declaration(self):
1074 """Return the associated Definition object."""
1075 return _create_field_declaration(_bt_ctf_get_decl_from_def(self._d), self.name, self.scope)
1077 def _get_enum_str(self):
1079 Return the string matching the current enumeration.
1080 Return None on error.
1082 return _bt_ctf_get_enum_str(self._d)
1084 def _get_array_element_at(self, index):
1086 Return the array's element at position index.
1087 Return None on error
1089 array_ptr = _bt_python_get_array_from_def(self._d)
1090 if array_ptr is None:
1093 definition_ptr = _bt_array_index(array_ptr, index)
1094 if definition_ptr is None:
1096 return _Definition(definition_ptr, self.scope)
1098 def _get_sequence_len(self):
1100 Return the len of a sequence or a negative
1103 seq = _bt_python_get_sequence_from_def(self._d)
1104 return _bt_sequence_len(seq)
1106 def _get_sequence_element_at(self, index):
1108 Return the sequence's element at position index,
1109 otherwise return None
1111 seq = _bt_python_get_sequence_from_def(self._d)
1113 definition_ptr = _bt_sequence_index(seq, index)
1114 if definition_ptr is not None:
1115 return _Definition(definition_ptr, self.scope)
1118 def _get_uint64(self):
1120 Return the value associated with the field.
1121 If the field does not exist or is not of the type requested,
1122 the value returned is undefined. To check if an error occured,
1123 use the field_error() function after accessing a field.
1125 return _bt_ctf_get_uint64(self._d)
1127 def _get_int64(self):
1129 Return the value associated with the field.
1130 If the field does not exist or is not of the type requested,
1131 the value returned is undefined. To check if an error occured,
1132 use the field_error() function after accessing a field.
1134 return _bt_ctf_get_int64(self._d)
1136 def _get_char_array(self):
1138 Return the value associated with the field.
1139 If the field does not exist or is not of the type requested,
1140 the value returned is undefined. To check if an error occurred,
1141 use the field_error() function after accessing a field.
1143 return _bt_ctf_get_char_array(self._d)
1147 Return the value associated with the field.
1148 If the field does not exist or is not of the type requested,
1149 the value returned is undefined. To check if an error occurred,
1150 use the field_error() function after accessing a field.
1152 return _bt_ctf_get_string(self._d)
1154 def _get_float(self):
1156 Return the value associated with the field.
1157 If the field does not exist or is not of the type requested,
1158 the value returned is undefined. To check if an error occurred,
1159 use the field_error() function after accessing a field.
1161 return _bt_ctf_get_float(self._d)
1163 def _get_variant(self):
1165 Return the variant's selected field.
1166 If the field does not exist or is not of the type requested,
1167 the value returned is undefined. To check if an error occurred,
1168 use the field_error() function after accessing a field.
1170 return _bt_ctf_get_variant(self._d)
1172 def _get_struct_field_count(self):
1174 Return the number of fields contained in the structure.
1175 If the field does not exist or is not of the type requested,
1176 the value returned is undefined.
1178 return _bt_ctf_get_struct_field_count(self._d)
1180 def _get_struct_field_at(self, i):
1182 Return the structure's field at position i.
1183 If the field does not exist or is not of the type requested,
1184 the value returned is undefined. To check if an error occurred,
1185 use the field_error() function after accessing a field.
1187 return _bt_ctf_get_struct_field_index(self._d, i)
1192 Return the value associated with the field according to its type.
1193 Return None on error.
1198 if id == CTFTypeId.STRING:
1199 value = self._get_str()
1200 elif id == CTFTypeId.ARRAY:
1201 element_decl = self.declaration.element_declaration
1202 if ((element_decl.type == CTFTypeId.INTEGER
1203 and element_decl.length == 8)
1204 and (element_decl.encoding == CTFStringEncoding.ASCII or element_decl.encoding == CTFStringEncoding.UTF8)):
1205 value = _bt_python_get_array_string(self._d)
1208 for i in range(self.declaration.length):
1209 element = self._get_array_element_at(i)
1210 value.append(element.value)
1211 elif id == CTFTypeId.INTEGER:
1212 if self.declaration.signedness == 0:
1213 value = self._get_uint64()
1215 value = self._get_int64()
1216 elif id == CTFTypeId.ENUM:
1217 value = self._get_enum_str()
1218 elif id == CTFTypeId.SEQUENCE:
1219 element_decl = self.declaration.element_declaration
1220 if ((element_decl.type == CTFTypeId.INTEGER
1221 and element_decl.length == 8)
1222 and (element_decl.encoding == CTFStringEncoding.ASCII or element_decl.encoding == CTFStringEncoding.UTF8)):
1223 value = _bt_python_get_sequence_string(self._d)
1225 seq_len = self._get_sequence_len()
1227 for i in range(seq_len):
1228 evDef = self._get_sequence_element_at(i)
1229 value.append(evDef.value)
1230 elif id == CTFTypeId.FLOAT:
1231 value = self._get_float()
1232 elif id == CTFTypeId.VARIANT:
1233 variant = _Definition.__new__(_Definition)
1234 variant._d = self._get_variant();
1235 value = variant.value
1236 elif id == CTFTypeId.STRUCT:
1238 for i in range(self._get_struct_field_count()):
1239 member = _Definition(self._get_struct_field_at(i), self.scope)
1240 value[member.name] = member.value
1243 raise FieldError("Error occurred while accessing field {} of type {}".format(self.name, CTFTypeId.type_name(id)))
1248 """Return the scope of a field or None on error."""
1254 // =================================================================
1256 // =================================================================
1258 /* =================================================================
1260 ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
1262 %rename("_bt_ctf_clock_create") bt_ctf_clock_create(const char *name);
1263 %rename("_bt_ctf_clock_get_name") bt_ctf_clock_get_name(struct bt_ctf_clock *clock);
1264 %rename("_bt_ctf_clock_get_description") bt_ctf_clock_get_description(struct bt_ctf_clock *clock);
1265 %rename("_bt_ctf_clock_set_description") bt_ctf_clock_set_description(struct bt_ctf_clock *clock, const char *desc);
1266 %rename("_bt_ctf_clock_get_frequency") bt_ctf_clock_get_frequency(struct bt_ctf_clock *clock);
1267 %rename("_bt_ctf_clock_set_frequency") bt_ctf_clock_set_frequency(struct bt_ctf_clock *clock, uint64_t freq);
1268 %rename("_bt_ctf_clock_get_precision") bt_ctf_clock_get_precision(struct bt_ctf_clock *clock);
1269 %rename("_bt_ctf_clock_set_precision") bt_ctf_clock_set_precision(struct bt_ctf_clock *clock, uint64_t precision);
1270 %rename("_bt_ctf_clock_get_offset_s") bt_ctf_clock_get_offset_s(struct bt_ctf_clock *clock);
1271 %rename("_bt_ctf_clock_set_offset_s") bt_ctf_clock_set_offset_s(struct bt_ctf_clock *clock, uint64_t offset_s);
1272 %rename("_bt_ctf_clock_get_offset") bt_ctf_clock_get_offset(struct bt_ctf_clock *clock);
1273 %rename("_bt_ctf_clock_set_offset") bt_ctf_clock_set_offset(struct bt_ctf_clock *clock, uint64_t offset);
1274 %rename("_bt_ctf_clock_get_is_absolute") bt_ctf_clock_get_is_absolute(struct bt_ctf_clock *clock);
1275 %rename("_bt_ctf_clock_set_is_absolute") bt_ctf_clock_set_is_absolute(struct bt_ctf_clock *clock, int is_absolute);
1276 %rename("_bt_ctf_clock_get_time") bt_ctf_clock_get_time(struct bt_ctf_clock *clock);
1277 %rename("_bt_ctf_clock_set_time") bt_ctf_clock_set_time(struct bt_ctf_clock *clock, uint64_t time);
1278 %rename("_bt_ctf_clock_get") bt_ctf_clock_get(struct bt_ctf_clock *clock);
1279 %rename("_bt_ctf_clock_put") bt_ctf_clock_put(struct bt_ctf_clock *clock);
1281 struct bt_ctf_clock *bt_ctf_clock_create(const char *name);
1282 const char *bt_ctf_clock_get_name(struct bt_ctf_clock *clock);
1283 const char *bt_ctf_clock_get_description(struct bt_ctf_clock *clock);
1284 int bt_ctf_clock_set_description(struct bt_ctf_clock *clock, const char *desc);
1285 uint64_t bt_ctf_clock_get_frequency(struct bt_ctf_clock *clock);
1286 int bt_ctf_clock_set_frequency(struct bt_ctf_clock *clock, uint64_t freq);
1287 uint64_t bt_ctf_clock_get_precision(struct bt_ctf_clock *clock);
1288 int bt_ctf_clock_set_precision(struct bt_ctf_clock *clock, uint64_t precision);
1289 uint64_t bt_ctf_clock_get_offset_s(struct bt_ctf_clock *clock);
1290 int bt_ctf_clock_set_offset_s(struct bt_ctf_clock *clock, uint64_t offset_s);
1291 uint64_t bt_ctf_clock_get_offset(struct bt_ctf_clock *clock);
1292 int bt_ctf_clock_set_offset(struct bt_ctf_clock *clock, uint64_t offset);
1293 int bt_ctf_clock_get_is_absolute(struct bt_ctf_clock *clock);
1294 int bt_ctf_clock_set_is_absolute(struct bt_ctf_clock *clock, int is_absolute);
1295 uint64_t bt_ctf_clock_get_time(struct bt_ctf_clock *clock);
1296 int bt_ctf_clock_set_time(struct bt_ctf_clock *clock, uint64_t time);
1297 void bt_ctf_clock_get(struct bt_ctf_clock *clock);
1298 void bt_ctf_clock_put(struct bt_ctf_clock *clock);
1300 /* =================================================================
1302 ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
1304 %rename("_bt_ctf_field_type_integer_create") bt_ctf_field_type_integer_create(unsigned int size);
1305 %rename("_bt_ctf_field_type_integer_get_size") bt_ctf_field_type_integer_get_size(struct bt_ctf_field_type *integer);
1306 %rename("_bt_ctf_field_type_integer_get_signed") bt_ctf_field_type_integer_get_signed(struct bt_ctf_field_type *integer);
1307 %rename("_bt_ctf_field_type_integer_set_signed") bt_ctf_field_type_integer_set_signed(struct bt_ctf_field_type *integer, int is_signed);
1308 %rename("_bt_ctf_field_type_integer_get_base") bt_ctf_field_type_integer_get_base(struct bt_ctf_field_type *integer);
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_get_encoding") bt_ctf_field_type_integer_get_encoding(struct bt_ctf_field_type *integer);
1311 %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);
1312 %rename("_bt_ctf_field_type_enumeration_create") bt_ctf_field_type_enumeration_create(struct bt_ctf_field_type *integer_container_type);
1313 %rename("_bt_ctf_field_type_enumeration_get_container_type") bt_ctf_field_type_enumeration_get_container_type(struct bt_ctf_field_type *enumeration);
1314 %rename("_bt_ctf_field_type_enumeration_add_mapping") bt_ctf_field_type_enumeration_add_mapping(struct bt_ctf_field_type *enumeration, const char *name, int64_t range_start, int64_t range_end);
1315 %rename("_bt_ctf_field_type_enumeration_add_mapping_unsigned") bt_ctf_field_type_enumeration_add_mapping_unsigned(struct bt_ctf_field_type *enumeration, const char *name, uint64_t range_start, uint64_t range_end);
1316 %rename("_bt_ctf_field_type_enumeration_get_mapping_count") bt_ctf_field_type_enumeration_get_mapping_count(struct bt_ctf_field_type *enumeration);
1317 %rename("_bt_ctf_field_type_enumeration_get_mapping") bt_ctf_field_type_enumeration_get_mapping(struct bt_ctf_field_type *enumeration, size_t index, const char **name, int64_t *range_start, int64_t *range_end);
1318 %rename("_bt_ctf_field_type_enumeration_get_mapping_unsigned") bt_ctf_field_type_enumeration_get_mapping_unsigned(struct bt_ctf_field_type *enumeration, size_t index, const char **name, uint64_t *range_start, uint64_t *range_end);
1319 %rename("_bt_ctf_field_type_enumeration_get_mapping_index_by_name") bt_ctf_field_type_enumeration_get_mapping_index_by_name(struct bt_ctf_field_type *enumeration, const char *name, size_t *index);
1320 %rename("_bt_ctf_field_type_enumeration_get_mapping_index_by_value") bt_ctf_field_type_enumeration_get_mapping_index_by_value(struct bt_ctf_field_type *enumeration, int64_t value, size_t *index);
1321 %rename("_bt_ctf_field_type_enumeration_get_mapping_index_by_unsigned_value") bt_ctf_field_type_enumeration_get_mapping_index_by_unsigned_value(struct bt_ctf_field_type *enumeration, uint64_t value, size_t *index);
1322 %rename("_bt_ctf_field_type_floating_point_create") bt_ctf_field_type_floating_point_create(void);
1323 %rename("_bt_ctf_field_type_floating_point_get_exponent_digits") bt_ctf_field_type_floating_point_get_exponent_digits(struct bt_ctf_field_type *floating_point);
1324 %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);
1325 %rename("_bt_ctf_field_type_floating_point_get_mantissa_digits") bt_ctf_field_type_floating_point_get_mantissa_digits(struct bt_ctf_field_type *floating_point);
1326 %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);
1327 %rename("_bt_ctf_field_type_structure_create") bt_ctf_field_type_structure_create(void);
1328 %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);
1329 %rename("_bt_ctf_field_type_structure_get_field_count") bt_ctf_field_type_structure_get_field_count(struct bt_ctf_field_type *structure);
1330 %rename("_bt_ctf_field_type_structure_get_field") bt_ctf_field_type_structure_get_field(struct bt_ctf_field_type *structure, const char **field_name, struct bt_ctf_field_type **field_type, size_t index);
1331 %rename("_bt_ctf_field_type_structure_get_field_type_by_name") bt_ctf_field_type_structure_get_field_type_by_name(struct bt_ctf_field_type *structure, const char *field_name);
1332 %rename("_bt_ctf_field_type_variant_create") bt_ctf_field_type_variant_create(struct bt_ctf_field_type *enum_tag, const char *tag_name);
1333 %rename("_bt_ctf_field_type_variant_get_tag_type") bt_ctf_field_type_variant_get_tag_type(struct bt_ctf_field_type *variant);
1334 %rename("_bt_ctf_field_type_variant_get_tag_name") bt_ctf_field_type_variant_get_tag_name(struct bt_ctf_field_type *variant);
1335 %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);
1336 %rename("_bt_ctf_field_type_variant_get_field_type_by_name") bt_ctf_field_type_variant_get_field_type_by_name(struct bt_ctf_field_type *variant, const char *field_name);
1337 %rename("_bt_ctf_field_type_variant_get_field_type_from_tag") bt_ctf_field_type_variant_get_field_type_from_tag(struct bt_ctf_field_type *variant, struct bt_ctf_field *tag);
1338 %rename("_bt_ctf_field_type_variant_get_field_count") bt_ctf_field_type_variant_get_field_count(struct bt_ctf_field_type *variant);
1339 %rename("_bt_ctf_field_type_variant_get_field") bt_ctf_field_type_variant_get_field(struct bt_ctf_field_type *variant, const char **field_name, struct bt_ctf_field_type **field_type, size_t index);
1340 %rename("_bt_ctf_field_type_array_create") bt_ctf_field_type_array_create(struct bt_ctf_field_type *element_type, unsigned int length);
1341 %rename("_bt_ctf_field_type_array_get_element_type") bt_ctf_field_type_array_get_element_type(struct bt_ctf_field_type *array);
1342 %rename("_bt_ctf_field_type_array_get_length") bt_ctf_field_type_array_get_length(struct bt_ctf_field_type *array);
1343 %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);
1344 %rename("_bt_ctf_field_type_sequence_get_element_type") bt_ctf_field_type_sequence_get_element_type(struct bt_ctf_field_type *sequence);
1345 %rename("_bt_ctf_field_type_sequence_get_length_field_name") bt_ctf_field_type_sequence_get_length_field_name(struct bt_ctf_field_type *sequence);
1346 %rename("_bt_ctf_field_type_string_create") bt_ctf_field_type_string_create(void);
1347 %rename("_bt_ctf_field_type_string_get_encoding") bt_ctf_field_type_string_get_encoding(struct bt_ctf_field_type *string_type);
1348 %rename("_bt_ctf_field_type_string_set_encoding") bt_ctf_field_type_string_set_encoding(struct bt_ctf_field_type *string_type, enum ctf_string_encoding encoding);
1349 %rename("_bt_ctf_field_type_get_alignment") bt_ctf_field_type_get_alignment(struct bt_ctf_field_type *type);
1350 %rename("_bt_ctf_field_type_set_alignment") bt_ctf_field_type_set_alignment(struct bt_ctf_field_type *type, unsigned int alignment);
1351 %rename("_bt_ctf_field_type_get_byte_order") bt_ctf_field_type_get_byte_order(struct bt_ctf_field_type *type);
1352 %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);
1353 %rename("_bt_ctf_field_type_get_type_id") bt_ctf_field_type_get_type_id(struct bt_ctf_field_type *type);
1354 %rename("_bt_ctf_field_type_get") bt_ctf_field_type_get(struct bt_ctf_field_type *type);
1355 %rename("_bt_ctf_field_type_put") bt_ctf_field_type_put(struct bt_ctf_field_type *type);
1357 struct bt_ctf_field_type *bt_ctf_field_type_integer_create(unsigned int size);
1358 int bt_ctf_field_type_integer_get_size(struct bt_ctf_field_type *integer);
1359 int bt_ctf_field_type_integer_get_signed(struct bt_ctf_field_type *integer);
1360 int bt_ctf_field_type_integer_set_signed(struct bt_ctf_field_type *integer, int is_signed);
1361 enum bt_ctf_integer_base bt_ctf_field_type_integer_get_base(struct bt_ctf_field_type *integer);
1362 int bt_ctf_field_type_integer_set_base(struct bt_ctf_field_type *integer, enum bt_ctf_integer_base base);
1363 enum ctf_string_encoding bt_ctf_field_type_integer_get_encoding(struct bt_ctf_field_type *integer);
1364 int bt_ctf_field_type_integer_set_encoding(struct bt_ctf_field_type *integer, enum ctf_string_encoding encoding);
1365 struct bt_ctf_field_type *bt_ctf_field_type_enumeration_create(struct bt_ctf_field_type *integer_container_type);
1366 struct bt_ctf_field_type *bt_ctf_field_type_enumeration_get_container_type(struct bt_ctf_field_type *enumeration);
1367 int bt_ctf_field_type_enumeration_add_mapping(struct bt_ctf_field_type *enumeration, const char *name, int64_t range_start, int64_t range_end);
1368 int bt_ctf_field_type_enumeration_add_mapping_unsigned(struct bt_ctf_field_type *enumeration, const char *name, uint64_t range_start, uint64_t range_end);
1369 int64_t bt_ctf_field_type_enumeration_get_mapping_count(struct bt_ctf_field_type *enumeration);
1370 int bt_ctf_field_type_enumeration_get_mapping(struct bt_ctf_field_type *enumeration, size_t index, const char **OUTPUT, int64_t *OUTPUT, int64_t *OUTPUT);
1371 int bt_ctf_field_type_enumeration_get_mapping_unsigned(struct bt_ctf_field_type *enumeration, size_t index, const char **OUTPUT, uint64_t *OUTPUT, uint64_t *OUTPUT);
1372 int bt_ctf_field_type_enumeration_get_mapping_index_by_name(struct bt_ctf_field_type *enumeration, const char *name, size_t *OUTPUT);
1373 int bt_ctf_field_type_enumeration_get_mapping_index_by_value(struct bt_ctf_field_type *enumeration, int64_t value, size_t *OUTPUT);
1374 int bt_ctf_field_type_enumeration_get_mapping_index_by_unsigned_value(struct bt_ctf_field_type *enumeration, uint64_t value, size_t *OUTPUT);
1375 struct bt_ctf_field_type *bt_ctf_field_type_floating_point_create(void);
1376 int bt_ctf_field_type_floating_point_get_exponent_digits(struct bt_ctf_field_type *floating_point);
1377 int bt_ctf_field_type_floating_point_set_exponent_digits(struct bt_ctf_field_type *floating_point, unsigned int exponent_digits);
1378 int bt_ctf_field_type_floating_point_get_mantissa_digits(struct bt_ctf_field_type *floating_point);
1379 int bt_ctf_field_type_floating_point_set_mantissa_digits(struct bt_ctf_field_type *floating_point, unsigned int mantissa_digits);
1380 struct bt_ctf_field_type *bt_ctf_field_type_structure_create(void);
1381 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);
1382 int64_t bt_ctf_field_type_structure_get_field_count(struct bt_ctf_field_type *structure);
1383 int bt_ctf_field_type_structure_get_field(struct bt_ctf_field_type *structure, const char **OUTPUT, struct bt_ctf_field_type **OUTPUT, size_t index);
1384 struct bt_ctf_field_type *bt_ctf_field_type_structure_get_field_type_by_name(struct bt_ctf_field_type *structure, const char *field_name);
1385 struct bt_ctf_field_type *bt_ctf_field_type_variant_create(struct bt_ctf_field_type *enum_tag, const char *tag_name);
1386 struct bt_ctf_field_type *bt_ctf_field_type_variant_get_tag_type(struct bt_ctf_field_type *variant);
1387 const char *bt_ctf_field_type_variant_get_tag_name(struct bt_ctf_field_type *variant);
1388 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);
1389 struct bt_ctf_field_type *bt_ctf_field_type_variant_get_field_type_by_name(struct bt_ctf_field_type *variant, const char *field_name);
1390 struct bt_ctf_field_type *bt_ctf_field_type_variant_get_field_type_from_tag(struct bt_ctf_field_type *variant, struct bt_ctf_field *tag);
1391 int64_t bt_ctf_field_type_variant_get_field_count(struct bt_ctf_field_type *variant);
1392 int bt_ctf_field_type_variant_get_field(struct bt_ctf_field_type *variant, const char **OUTPUT, struct bt_ctf_field_type **OUTPUT, size_t index);
1393 struct bt_ctf_field_type *bt_ctf_field_type_array_create(struct bt_ctf_field_type *element_type, unsigned int length);
1394 struct bt_ctf_field_type *bt_ctf_field_type_array_get_element_type(struct bt_ctf_field_type *array);
1395 int64_t bt_ctf_field_type_array_get_length(struct bt_ctf_field_type *array);
1396 struct bt_ctf_field_type *bt_ctf_field_type_sequence_create(struct bt_ctf_field_type *element_type, const char *length_field_name);
1397 struct bt_ctf_field_type *bt_ctf_field_type_sequence_get_element_type(struct bt_ctf_field_type *sequence);
1398 const char *bt_ctf_field_type_sequence_get_length_field_name(struct bt_ctf_field_type *sequence);
1399 struct bt_ctf_field_type *bt_ctf_field_type_string_create(void);
1400 enum ctf_string_encoding bt_ctf_field_type_string_get_encoding(struct bt_ctf_field_type *string_type);
1401 int bt_ctf_field_type_string_set_encoding(struct bt_ctf_field_type *string_type, enum ctf_string_encoding encoding);
1402 int bt_ctf_field_type_get_alignment(struct bt_ctf_field_type *type);
1403 int bt_ctf_field_type_set_alignment(struct bt_ctf_field_type *type, unsigned int alignment);
1404 enum bt_ctf_byte_order bt_ctf_field_type_get_byte_order(struct bt_ctf_field_type *type);
1405 int bt_ctf_field_type_set_byte_order(struct bt_ctf_field_type *type, enum bt_ctf_byte_order byte_order);
1406 enum ctf_type_id bt_ctf_field_type_get_type_id(struct bt_ctf_field_type *type);
1407 void bt_ctf_field_type_get(struct bt_ctf_field_type *type);
1408 void bt_ctf_field_type_put(struct bt_ctf_field_type *type);
1410 /* =================================================================
1412 ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
1414 %rename("_bt_ctf_field_create") bt_ctf_field_create(struct bt_ctf_field_type *type);
1415 %rename("_bt_ctf_field_structure_get_field") bt_ctf_field_structure_get_field(struct bt_ctf_field *structure, const char *name);
1416 %rename("_bt_ctf_field_array_get_field") bt_ctf_field_array_get_field(struct bt_ctf_field *array, uint64_t index);
1417 %rename("_bt_ctf_field_sequence_get_length") bt_ctf_field_sequence_get_length(struct bt_ctf_field *sequence);
1418 %rename("_bt_ctf_field_sequence_set_length") bt_ctf_field_sequence_set_length(struct bt_ctf_field *sequence, struct bt_ctf_field *length_field);
1419 %rename("_bt_ctf_field_sequence_get_field") bt_ctf_field_sequence_get_field(struct bt_ctf_field *sequence, uint64_t index);
1420 %rename("_bt_ctf_field_variant_get_field") bt_ctf_field_variant_get_field(struct bt_ctf_field *variant, struct bt_ctf_field *tag);
1421 %rename("_bt_ctf_field_enumeration_get_container") bt_ctf_field_enumeration_get_container(struct bt_ctf_field *enumeration);
1422 %rename("_bt_ctf_field_enumeration_get_mapping_name") bt_ctf_field_enumeration_get_mapping_name(struct bt_ctf_field *enumeration);
1423 %rename("_bt_ctf_field_signed_integer_get_value") bt_ctf_field_signed_integer_get_value(struct bt_ctf_field *integer, int64_t *value);
1424 %rename("_bt_ctf_field_signed_integer_set_value") bt_ctf_field_signed_integer_set_value(struct bt_ctf_field *integer, int64_t value);
1425 %rename("_bt_ctf_field_unsigned_integer_get_value") bt_ctf_field_unsigned_integer_get_value(struct bt_ctf_field *integer, uint64_t *value);
1426 %rename("_bt_ctf_field_unsigned_integer_set_value") bt_ctf_field_unsigned_integer_set_value(struct bt_ctf_field *integer, uint64_t value);
1427 %rename("_bt_ctf_field_floating_point_get_value") bt_ctf_field_floating_point_get_value(struct bt_ctf_field *floating_point, double *value);
1428 %rename("_bt_ctf_field_floating_point_set_value") bt_ctf_field_floating_point_set_value(struct bt_ctf_field *floating_point, double value);
1429 %rename("_bt_ctf_field_string_get_value") bt_ctf_field_string_get_value(struct bt_ctf_field *string_field);
1430 %rename("_bt_ctf_field_string_set_value") bt_ctf_field_string_set_value(struct bt_ctf_field *string_field, const char *value);
1431 %rename("_bt_ctf_field_get_type") bt_ctf_field_get_type(struct bt_ctf_field *field);
1432 %rename("_bt_ctf_field_get") bt_ctf_field_get(struct bt_ctf_field *field);
1433 %rename("_bt_ctf_field_put") bt_ctf_field_put(struct bt_ctf_field *field);
1435 struct bt_ctf_field *bt_ctf_field_create(struct bt_ctf_field_type *type);
1436 struct bt_ctf_field *bt_ctf_field_structure_get_field(struct bt_ctf_field *structure, const char *name);
1437 struct bt_ctf_field *bt_ctf_field_array_get_field(struct bt_ctf_field *array, uint64_t index);
1438 struct bt_ctf_field * bt_ctf_field_sequence_get_length(struct bt_ctf_field *sequence);
1439 int bt_ctf_field_sequence_set_length(struct bt_ctf_field *sequence, struct bt_ctf_field *length_field);
1440 struct bt_ctf_field *bt_ctf_field_sequence_get_field(struct bt_ctf_field *sequence, uint64_t index);
1441 struct bt_ctf_field *bt_ctf_field_variant_get_field(struct bt_ctf_field *variant, struct bt_ctf_field *tag);
1442 struct bt_ctf_field *bt_ctf_field_enumeration_get_container(struct bt_ctf_field *enumeration);
1443 const char *bt_ctf_field_enumeration_get_mapping_name(struct bt_ctf_field *enumeration);
1444 int bt_ctf_field_signed_integer_get_value(struct bt_ctf_field *integer, int64_t *OUTPUT);
1445 int bt_ctf_field_signed_integer_set_value(struct bt_ctf_field *integer, int64_t value);
1446 int bt_ctf_field_unsigned_integer_get_value(struct bt_ctf_field *integer, uint64_t *OUTPUT);
1447 int bt_ctf_field_unsigned_integer_set_value(struct bt_ctf_field *integer, uint64_t value);
1448 int bt_ctf_field_floating_point_get_value(struct bt_ctf_field *floating_point, double *OUTPUT);
1449 int bt_ctf_field_floating_point_set_value(struct bt_ctf_field *floating_point, double value);
1450 const char *bt_ctf_field_string_get_value(struct bt_ctf_field *string_field);
1451 int bt_ctf_field_string_set_value(struct bt_ctf_field *string_field, const char *value);
1452 struct bt_ctf_field_type *bt_ctf_field_get_type(struct bt_ctf_field *field);
1453 void bt_ctf_field_get(struct bt_ctf_field *field);
1454 void bt_ctf_field_put(struct bt_ctf_field *field);
1456 /* =================================================================
1458 ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
1460 %rename("_bt_ctf_event_class_create") bt_ctf_event_class_create(const char *name);
1461 %rename("_bt_ctf_event_class_get_name") bt_ctf_event_class_get_name(struct bt_ctf_event_class *event_class);
1462 %rename("_bt_ctf_event_class_get_id") bt_ctf_event_class_get_id(struct bt_ctf_event_class *event_class);
1463 %rename("_bt_ctf_event_class_set_id") bt_ctf_event_class_set_id(struct bt_ctf_event_class *event_class, uint32_t id);
1464 %rename("_bt_ctf_event_class_get_stream_class") bt_ctf_event_class_get_stream_class(struct bt_ctf_event_class *event_class);
1465 %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);
1466 %rename("_bt_ctf_event_class_get_field_count") bt_ctf_event_class_get_field_count(struct bt_ctf_event_class *event_class);
1467 %rename("_bt_ctf_event_class_get_field") bt_ctf_event_class_get_field(struct bt_ctf_event_class *event_class, const char **field_name, struct bt_ctf_field_type **field_type, size_t index);
1468 %rename("_bt_ctf_event_class_get_field_by_name") bt_ctf_event_class_get_field_by_name(struct bt_ctf_event_class *event_class, const char *name);
1469 %rename("_bt_ctf_event_class_get") bt_ctf_event_class_get(struct bt_ctf_event_class *event_class);
1470 %rename("_bt_ctf_event_class_put") bt_ctf_event_class_put(struct bt_ctf_event_class *event_class);
1471 %rename("_bt_ctf_event_create") bt_ctf_event_create(struct bt_ctf_event_class *event_class);
1472 %rename("_bt_ctf_event_get_class") bt_ctf_event_get_class(struct bt_ctf_event *event);
1473 %rename("_bt_ctf_event_get_clock") bt_ctf_event_get_clock(struct bt_ctf_event *event);
1474 %rename("_bt_ctf_event_get_payload") bt_ctf_event_get_payload(struct bt_ctf_event *event, const char *name);
1475 %rename("_bt_ctf_event_set_payload") bt_ctf_event_set_payload(struct bt_ctf_event *event, const char *name, struct bt_ctf_field *value);
1476 %rename("_bt_ctf_event_get_payload_by_index") bt_ctf_event_get_payload_by_index(struct bt_ctf_event *event, size_t index);
1477 %rename("_bt_ctf_event_get") bt_ctf_event_get(struct bt_ctf_event *event);
1478 %rename("_bt_ctf_event_put") bt_ctf_event_put(struct bt_ctf_event *event);
1480 struct bt_ctf_event_class *bt_ctf_event_class_create(const char *name);
1481 const char *bt_ctf_event_class_get_name(struct bt_ctf_event_class *event_class);
1482 int64_t bt_ctf_event_class_get_id(struct bt_ctf_event_class *event_class);
1483 int bt_ctf_event_class_set_id(struct bt_ctf_event_class *event_class, uint32_t id);
1484 struct bt_ctf_stream_class *bt_ctf_event_class_get_stream_class(struct bt_ctf_event_class *event_class);
1485 int bt_ctf_event_class_add_field(struct bt_ctf_event_class *event_class, struct bt_ctf_field_type *type, const char *name);
1486 int64_t bt_ctf_event_class_get_field_count(struct bt_ctf_event_class *event_class);
1487 int bt_ctf_event_class_get_field(struct bt_ctf_event_class *event_class, const char **field_name, struct bt_ctf_field_type **field_type, size_t index);
1488 struct bt_ctf_field_type *bt_ctf_event_class_get_field_by_name(struct bt_ctf_event_class *event_class, const char *name);
1489 void bt_ctf_event_class_get(struct bt_ctf_event_class *event_class);
1490 void bt_ctf_event_class_put(struct bt_ctf_event_class *event_class);
1491 struct bt_ctf_event *bt_ctf_event_create(struct bt_ctf_event_class *event_class);
1492 struct bt_ctf_event_class *bt_ctf_event_get_class(struct bt_ctf_event *event);
1493 struct bt_ctf_clock *bt_ctf_event_get_clock(struct bt_ctf_event *event);
1494 struct bt_ctf_field *bt_ctf_event_get_payload(struct bt_ctf_event *event, const char *name);
1495 int bt_ctf_event_set_payload(struct bt_ctf_event *event, const char *name, struct bt_ctf_field *value);
1496 struct bt_ctf_field *bt_ctf_event_get_payload_by_index(struct bt_ctf_event *event, size_t index);
1497 void bt_ctf_event_get(struct bt_ctf_event *event);
1498 void bt_ctf_event_put(struct bt_ctf_event *event);
1500 /* =================================================================
1502 ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
1504 %rename("_bt_ctf_stream_class_create") bt_ctf_stream_class_create(const char *name);
1505 %rename("_bt_ctf_stream_class_get_name") bt_ctf_stream_class_get_name(struct bt_ctf_stream_class *stream_class);
1506 %rename("_bt_ctf_stream_class_get_clock") bt_ctf_stream_class_get_clock(struct bt_ctf_stream_class *stream_class);
1507 %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);
1508 %rename("_bt_ctf_stream_class_get_id") bt_ctf_stream_class_get_id(struct bt_ctf_stream_class *stream_class);
1509 %rename("_bt_ctf_stream_class_set_id") bt_ctf_stream_class_set_id(struct bt_ctf_stream_class *stream_class, uint32_t id);
1510 %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);
1511 %rename("_bt_ctf_stream_class_get_event_class_count") bt_ctf_stream_class_get_event_class_count(struct bt_ctf_stream_class *stream_class);
1512 %rename("_bt_ctf_stream_class_get_event_class") bt_ctf_stream_class_get_event_class(struct bt_ctf_stream_class *stream_class, size_t index);
1513 %rename("_bt_ctf_stream_class_get_event_class_by_name") bt_ctf_stream_class_get_event_class_by_name(struct bt_ctf_stream_class *stream_class, const char *name);
1514 %rename("_bt_ctf_stream_class_get") bt_ctf_stream_class_get(struct bt_ctf_stream_class *stream_class);
1515 %rename("_bt_ctf_stream_class_put") bt_ctf_stream_class_put(struct bt_ctf_stream_class *stream_class);
1516 %rename("_bt_ctf_stream_get_discarded_events_count") bt_ctf_stream_get_discarded_events_count(struct bt_ctf_stream *stream, uint64_t *count);
1517 %rename("_bt_ctf_stream_append_discarded_events") bt_ctf_stream_append_discarded_events(struct bt_ctf_stream *stream, uint64_t event_count);
1518 %rename("_bt_ctf_stream_append_event") bt_ctf_stream_append_event(struct bt_ctf_stream *stream, struct bt_ctf_event *event);
1519 %rename("_bt_ctf_stream_flush") bt_ctf_stream_flush(struct bt_ctf_stream *stream);
1520 %rename("_bt_ctf_stream_get") bt_ctf_stream_get(struct bt_ctf_stream *stream);
1521 %rename("_bt_ctf_stream_put") bt_ctf_stream_put(struct bt_ctf_stream *stream);
1523 struct bt_ctf_stream_class *bt_ctf_stream_class_create(const char *name);
1524 const char *bt_ctf_stream_class_get_name(struct bt_ctf_stream_class *stream_class);
1525 struct bt_ctf_clock *bt_ctf_stream_class_get_clock(struct bt_ctf_stream_class *stream_class);
1526 int bt_ctf_stream_class_set_clock(struct bt_ctf_stream_class *stream_class, struct bt_ctf_clock *clock);
1527 int64_t bt_ctf_stream_class_get_id(struct bt_ctf_stream_class *stream_class);
1528 int bt_ctf_stream_class_set_id(struct bt_ctf_stream_class *stream_class, uint32_t id);
1529 int bt_ctf_stream_class_add_event_class(struct bt_ctf_stream_class *stream_class, struct bt_ctf_event_class *event_class);
1530 int64_t bt_ctf_stream_class_get_event_class_count(struct bt_ctf_stream_class *stream_class);
1531 struct bt_ctf_event_class *bt_ctf_stream_class_get_event_class(struct bt_ctf_stream_class *stream_class, size_t index);
1532 struct bt_ctf_event_class *bt_ctf_stream_class_get_event_class_by_name(struct bt_ctf_stream_class *stream_class, const char *name);
1533 void bt_ctf_stream_class_get(struct bt_ctf_stream_class *stream_class);
1534 void bt_ctf_stream_class_put(struct bt_ctf_stream_class *stream_class);
1535 int bt_ctf_stream_get_discarded_events_count(struct bt_ctf_stream *stream, uint64_t *OUTPUT);
1536 void bt_ctf_stream_append_discarded_events(struct bt_ctf_stream *stream, uint64_t event_count);
1537 int bt_ctf_stream_append_event(struct bt_ctf_stream *stream, struct bt_ctf_event *event);
1538 int bt_ctf_stream_flush(struct bt_ctf_stream *stream);
1539 void bt_ctf_stream_get(struct bt_ctf_stream *stream);
1540 void bt_ctf_stream_put(struct bt_ctf_stream *stream);
1542 /* =================================================================
1544 ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
1546 %rename("_bt_ctf_writer_create") bt_ctf_writer_create(const char *path);
1547 %rename("_bt_ctf_writer_create_stream") bt_ctf_writer_create_stream(struct bt_ctf_writer *writer, struct bt_ctf_stream_class *stream_class);
1548 %rename("_bt_ctf_writer_add_environment_field") bt_ctf_writer_add_environment_field(struct bt_ctf_writer *writer, const char *name, const char *value);
1549 %rename("_bt_ctf_writer_add_clock") bt_ctf_writer_add_clock(struct bt_ctf_writer *writer, struct bt_ctf_clock *clock);
1550 %newobject bt_ctf_writer_get_metadata_string;
1551 %rename("_bt_ctf_writer_get_metadata_string") bt_ctf_writer_get_metadata_string(struct bt_ctf_writer *writer);
1552 %rename("_bt_ctf_writer_flush_metadata") bt_ctf_writer_flush_metadata(struct bt_ctf_writer *writer);
1553 %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);
1554 %rename("_bt_ctf_writer_get") bt_ctf_writer_get(struct bt_ctf_writer *writer);
1555 %rename("_bt_ctf_writer_put") bt_ctf_writer_put(struct bt_ctf_writer *writer);
1557 struct bt_ctf_writer *bt_ctf_writer_create(const char *path);
1558 struct bt_ctf_stream *bt_ctf_writer_create_stream(struct bt_ctf_writer *writer, struct bt_ctf_stream_class *stream_class);
1559 int bt_ctf_writer_add_environment_field(struct bt_ctf_writer *writer, const char *name, const char *value);
1560 int bt_ctf_writer_add_clock(struct bt_ctf_writer *writer, struct bt_ctf_clock *clock);
1561 char *bt_ctf_writer_get_metadata_string(struct bt_ctf_writer *writer);
1562 void bt_ctf_writer_flush_metadata(struct bt_ctf_writer *writer);
1563 int bt_ctf_writer_set_byte_order(struct bt_ctf_writer *writer, enum bt_ctf_byte_order byte_order);
1564 void bt_ctf_writer_get(struct bt_ctf_writer *writer);
1565 void bt_ctf_writer_put(struct bt_ctf_writer *writer);
1570 # Used to compare to -1ULL in error checks
1571 _MAX_UINT64 = 0xFFFFFFFFFFFFFFFF
1574 Enumeration mapping class. start and end values are inclusive.
1576 class EnumerationMapping:
1577 def __init__(self, name, start, end):
1583 def __init__(self, name):
1584 self._c = _bt_ctf_clock_create(name)
1586 raise ValueError("Invalid clock name.")
1589 _bt_ctf_clock_put(self._c)
1592 Get the clock's name.
1596 name = _bt_ctf_clock_get_name(self._c)
1598 raise ValueError("Invalid clock instance.")
1602 Get the clock's description. None if unset.
1605 def description(self):
1606 return _bt_ctf_clock_get_description(self._c)
1609 Set the clock's description. The description appears in the clock's TSDL
1613 def description(self, desc):
1614 ret = _bt_ctf_clock_set_description(self._c, str(desc))
1616 raise ValueError("Invalid clock description.")
1619 Get the clock's frequency (Hz).
1622 def frequency(self):
1623 freq = _bt_ctf_clock_get_frequency(self._c)
1624 if freq == CTFWriter._MAX_UINT64:
1625 raise ValueError("Invalid clock instance")
1629 Set the clock's frequency (Hz).
1632 def frequency(self, freq):
1633 ret = _bt_ctf_clock_set_frequency(self._c, freq)
1635 raise ValueError("Invalid frequency value.")
1638 Get the clock's precision (in clock ticks).
1641 def precision(self):
1642 precision = _bt_ctf_clock_get_precision(self._c)
1643 if precision == CTFWriter._MAX_UINT64:
1644 raise ValueError("Invalid clock instance")
1648 Set the clock's precision (in clock ticks).
1651 def precision(self, precision):
1652 ret = _bt_ctf_clock_set_precision(self._c, precision)
1655 Get the clock's offset in seconds from POSIX.1 Epoch.
1658 def offset_seconds(self):
1659 offset_s = _bt_ctf_clock_get_offset_s(self._c)
1660 if offset_s == CTFWriter._MAX_UINT64:
1661 raise ValueError("Invalid clock instance")
1665 Set the clock's offset in seconds from POSIX.1 Epoch.
1667 @offset_seconds.setter
1668 def offset_seconds(self, offset_s):
1669 ret = _bt_ctf_clock_set_offset_s(self._c, offset_s)
1671 raise ValueError("Invalid offset value.")
1674 Get the clock's offset in ticks from POSIX.1 Epoch + offset in seconds.
1678 offset = _bt_ctf_clock_get_offset(self._c)
1679 if offset == CTFWriter._MAX_UINT64:
1680 raise ValueError("Invalid clock instance")
1684 Set the clock's offset in ticks from POSIX.1 Epoch + offset in seconds.
1687 def offset(self, offset):
1688 ret = _bt_ctf_clock_set_offset(self._c, offset)
1690 raise ValueError("Invalid offset value.")
1693 Get a clock's absolute attribute. A clock is absolute if the clock
1694 is a global reference across the trace's other clocks.
1698 is_absolute = _bt_ctf_clock_get_is_absolute(self._c)
1699 if is_absolute == -1:
1700 raise ValueError("Invalid clock instance")
1701 return False if is_absolute == 0 else True
1704 Set a clock's absolute attribute. A clock is absolute if the clock
1705 is a global reference across the trace's other clocks.
1708 def absolute(self, is_absolute):
1709 ret = _bt_ctf_clock_set_is_absolute(self._c, int(is_absolute))
1711 raise ValueError("Could not set the clock's absolute attribute.")
1714 Get the current time in nanoseconds since the clock's origin (offset and
1715 offset_s attributes).
1719 time = _bt_ctf_clock_get_time(self._c)
1720 if time == CTFWriter._MAX_UINT64:
1721 raise ValueError("Invalid clock instance")
1725 Set the current time in nanoseconds since the clock's origin (offset and
1726 offset_s attributes). The clock's value will be sampled as events are
1727 appended to a stream.
1730 def time(self, time):
1731 ret = _bt_ctf_clock_set_time(self._c, time)
1733 raise ValueError("Invalid time value.")
1735 class FieldDeclaration:
1737 FieldDeclaration should not be instantiated directly. Instantiate
1738 one of the concrete FieldDeclaration classes.
1741 # These values are based on the bt_ctf_integer_base enum
1742 # declared in event-types.h.
1743 INTEGER_BASE_UNKNOWN = -1
1744 INTEGER_BASE_BINARY = 2
1745 INTEGER_BASE_OCTAL = 8
1746 INTEGER_BASE_DECIMAL = 10
1747 INTEGER_BASE_HEXADECIMAL = 16
1750 if self._ft is None:
1751 raise ValueError("FieldDeclaration creation failed.")
1754 _bt_ctf_field_type_put(self._ft)
1757 def _create_field_declaration_from_native_instance(native_field_declaration):
1759 CTFTypeId.INTEGER : CTFWriter.IntegerFieldDeclaration,
1760 CTFTypeId.FLOAT : CTFWriter.FloatFieldDeclaration,
1761 CTFTypeId.ENUM : CTFWriter.EnumerationFieldDeclaration,
1762 CTFTypeId.STRING : CTFWriter.StringFieldDeclaration,
1763 CTFTypeId.STRUCT : CTFWriter.StructureFieldDeclaration,
1764 CTFTypeId.VARIANT : CTFWriter.VariantFieldDeclaration,
1765 CTFTypeId.ARRAY : CTFWriter.ArrayFieldDeclaration,
1766 CTFTypeId.SEQUENCE : CTFWriter.SequenceFieldDeclaration
1769 field_type_id = _bt_ctf_field_type_get_type_id(native_field_declaration)
1770 if field_type_id == CTFTypeId.UNKNOWN:
1771 raise TypeError("Invalid field instance")
1773 declaration = CTFWriter.Field.__new__(CTFWriter.Field)
1774 declaration._ft = native_field_declaration
1775 declaration.__class__ = type_dict[field_type_id]
1779 Get the field declaration's alignment. Returns -1 on error.
1782 def alignment(self):
1783 return _bt_ctf_field_type_get_alignment(self._ft)
1786 Set the field declaration's alignment. Defaults to 1 (bit-aligned). However,
1787 some types, such as structures and string, may impose other alignment
1791 def alignment(self, alignment):
1792 ret = _bt_ctf_field_type_set_alignment(self._ft, alignment)
1794 raise ValueError("Invalid alignment value.")
1797 Get the field declaration's byte order. One of the ByteOrder's constant.
1800 def byte_order(self):
1801 return _bt_ctf_field_type_get_byte_order(self._ft)
1804 Set the field declaration's byte order. Use constants defined in the ByteOrder
1808 def byte_order(self, byte_order):
1809 ret = _bt_ctf_field_type_set_byte_order(self._ft, byte_order)
1811 raise ValueError("Could not set byte order value.")
1813 class IntegerFieldDeclaration(FieldDeclaration):
1815 Create a new integer field declaration of the given size.
1817 def __init__(self, size):
1818 self._ft = _bt_ctf_field_type_integer_create(size)
1822 Get an integer's size.
1826 ret = _bt_ctf_field_type_integer_get_size(self._ft)
1828 raise ValueError("Could not get Integer's size attribute.")
1833 Get an integer's signedness attribute.
1837 ret = _bt_ctf_field_type_integer_get_signed(self._ft)
1839 raise ValueError("Could not get Integer's signed attribute.")
1846 Set an integer's signedness attribute.
1849 def signed(self, signed):
1850 ret = _bt_ctf_field_type_integer_set_signed(self._ft, signed)
1852 raise ValueError("Could not set Integer's signed attribute.")
1855 Get the integer's base used to pretty-print the resulting trace.
1856 Returns a constant from the FieldDeclaration.IntegerBase class.
1860 return _bt_ctf_field_type_integer_get_base(self._ft)
1863 Set the integer's base used to pretty-print the resulting trace.
1864 The base must be a constant of the FieldDeclarationIntegerBase class.
1867 def base(self, base):
1868 ret = _bt_ctf_field_type_integer_set_base(self._ft, base)
1870 raise ValueError("Could not set Integer's base.")
1873 Get the integer's encoding (one of the constants of the
1874 CTFStringEncoding class).
1875 Returns a constant from the CTFStringEncoding class.
1879 return _bt_ctf_field_type_integer_get_encoding(self._ft)
1882 An integer encoding may be set to signal that the integer must be printed
1883 as a text character. Must be a constant from the CTFStringEncoding class.
1886 def encoding(self, encoding):
1887 ret = _bt_ctf_field_type_integer_set_encoding(self._ft, encoding)
1889 raise ValueError("Could not set Integer's encoding.")
1891 class EnumerationFieldDeclaration(FieldDeclaration):
1893 Create a new enumeration field declaration with the given underlying container type.
1895 def __init__(self, integer_type):
1896 if integer_type is None or not isinstance(integer_type, CTFWriter.IntegerFieldDeclaration):
1897 raise TypeError("Invalid integer container.")
1899 self._ft = _bt_ctf_field_type_enumeration_create(integer_type._ft)
1903 Get the enumeration's underlying container type.
1906 def container(self):
1907 ret = _bt_ctf_field_type_enumeration_get_container_type(self._ft)
1909 raise TypeError("Invalid enumeration declaration")
1910 return CTFWriter.FieldDeclaration._create_field_declaration_from_native_instance(ret)
1913 Add a mapping to the enumeration. The range's values are inclusive.
1915 def add_mapping(self, name, range_start, range_end):
1916 if range_start < 0 or range_end < 0:
1917 ret = _bt_ctf_field_type_enumeration_add_mapping(self._ft, str(name), range_start, range_end)
1919 ret = _bt_ctf_field_type_enumeration_add_mapping_unsigned(self._ft, str(name), range_start, range_end)
1922 raise ValueError("Could not add mapping to enumeration declaration.")
1925 Generator returning instances of EnumerationMapping.
1929 signed = self.container.signed
1931 count = _bt_ctf_field_type_enumeration_get_mapping_count(self._ft)
1932 for i in range(count):
1934 ret = _bt_python_ctf_field_type_enumeration_get_mapping(self._ft, i)
1936 ret = _bt_python_ctf_field_type_enumeration_get_mapping_unsigned(self._ft, i)
1939 raise TypeError("Could not get Enumeration mapping at index {}".format(i))
1940 name, range_start, range_end = ret
1941 yield CTFWriter.EnumerationMapping(name, range_start, range_end)
1944 Get a mapping by name (EnumerationMapping).
1946 def get_mapping_by_name(self, name):
1947 ret, index = _bt_ctf_field_type_enumeration_get_mapping_index_by_name(self._ft, name);
1951 if self.container.signed:
1952 ret = _bt_python_ctf_field_type_enumeration_get_mapping(self._ft, index)
1954 ret = _bt_python_ctf_field_type_enumeration_get_mapping_unsigned(self._ft, index)
1957 raise TypeError("Could not get Enumeration mapping at index {}".format(i))
1958 name, range_start, range_end = ret
1959 return CTFWriter.EnumerationMapping(name, range_start, range_end)
1962 Get a mapping by value (EnumerationMapping).
1964 def get_mapping_by_value(self, value):
1966 ret, index = _bt_ctf_field_type_enumeration_get_mapping_index_by_value(self._ft, value);
1968 ret, index = _bt_ctf_field_type_enumeration_get_mapping_index_by_unsigned_value(self._ft, value);
1973 if self.container.signed:
1974 ret = _bt_python_ctf_field_type_enumeration_get_mapping(self._ft, index)
1976 ret = _bt_python_ctf_field_type_enumeration_get_mapping_unsigned(self._ft, index)
1979 raise TypeError("Could not get Enumeration mapping at index {}".format(i))
1980 name, range_start, range_end = ret
1981 return CTFWriter.EnumerationMapping(name, range_start, range_end)
1983 class FloatFieldDeclaration(FieldDeclaration):
1990 Create a new floating point field declaration.
1993 self._ft = _bt_ctf_field_type_floating_point_create()
1997 Get the number of exponent digits used to store the floating point field.
2000 def exponent_digits(self):
2001 ret = _bt_ctf_field_type_floating_point_get_exponent_digits(self._ft)
2003 raise TypeError("Could not get Floating point exponent digit count")
2007 Set the number of exponent digits to use to store the floating point field.
2008 The only values currently supported are FLT_EXP_DIG and DBL_EXP_DIG which
2009 are defined as constants of this class.
2011 @exponent_digits.setter
2012 def exponent_digits(self, exponent_digits):
2013 ret = _bt_ctf_field_type_floating_point_set_exponent_digits(self._ft, exponent_digits)
2015 raise ValueError("Could not set exponent digit count.")
2018 Get the number of mantissa digits used to store the floating point field.
2021 def mantissa_digits(self):
2022 ret = _bt_ctf_field_type_floating_point_get_mantissa_digits(self._ft)
2024 raise TypeError("Could not get Floating point mantissa digit count")
2028 Set the number of mantissa digits to use to store the floating point field.
2029 The only values currently supported are FLT_MANT_DIG and DBL_MANT_DIG which
2030 are defined as constants of this class.
2032 @mantissa_digits.setter
2033 def mantissa_digits(self, mantissa_digits):
2034 ret = _bt_ctf_field_type_floating_point_set_mantissa_digits(self._ft, mantissa_digits)
2036 raise ValueError("Could not set mantissa digit count.")
2038 class StructureFieldDeclaration(FieldDeclaration):
2040 Create a new structure field declaration.
2043 self._ft = _bt_ctf_field_type_structure_create()
2047 Add a field of type "field_type" to the structure.
2049 def add_field(self, field_type, field_name):
2050 ret = _bt_ctf_field_type_structure_add_field(self._ft, field_type._ft, str(field_name))
2052 raise ValueError("Could not add field to structure.")
2055 Generator returning the structure's field as tuples of (field name, field declaration).
2059 count = _bt_ctf_field_type_structure_get_field_count(self._ft)
2061 raise TypeError("Could not get Structure field count")
2063 for i in range(count):
2064 field_name = _bt_python_ctf_field_type_structure_get_field_name(self._ft, i)
2065 if field_name is None:
2066 raise TypeError("Could not get Structure field name at index {}".format(i))
2068 field_type_native = _bt_python_ctf_field_type_structure_get_field_type(self._ft, i)
2069 if field_type_native is None:
2070 raise TypeError("Could not get Structure field type at index {}".format(i))
2072 field_type = CTFWriter.FieldDeclaration._create_field_declaration_from_native_instance(field_type_native)
2073 yield (field_name, field_type)
2076 Get a field declaration by name (FieldDeclaration).
2078 def get_field_by_name(self, name):
2079 field_type_native = _bt_ctf_field_type_structure_get_field_type_by_name(self._ft, name)
2080 if field_type_native is None:
2081 raise TypeError("Could not find Structure field with name {}".format(name))
2083 return CTFWriter.FieldDeclaration._create_field_declaration_from_native_instance(field_type_native)
2085 class VariantFieldDeclaration(FieldDeclaration):
2087 Create a new variant field declaration.
2089 def __init__(self, enum_tag, tag_name):
2090 if enum_tag is None or not isinstance(enum_tag, CTFWriter.EnumerationFieldDeclaration):
2091 raise TypeError("Invalid tag type; must be of type EnumerationFieldDeclaration.")
2093 self._ft = _bt_ctf_field_type_variant_create(enum_tag._ft, str(tag_name))
2097 Get the variant's tag name.
2101 ret = _bt_ctf_field_type_variant_get_tag_name(self._ft)
2103 raise TypeError("Could not get Variant tag name")
2107 Get the variant's tag type.
2111 ret = _bt_ctf_field_type_variant_get_tag_type(self._ft)
2113 raise TypeError("Could not get Variant tag type")
2114 return CTFWriter.FieldDeclaration._create_field_declaration_from_native_instance(ret)
2117 Add a field of type "field_type" to the variant.
2119 def add_field(self, field_type, field_name):
2120 ret = _bt_ctf_field_type_variant_add_field(self._ft, field_type._ft, str(field_name))
2122 raise ValueError("Could not add field to variant.")
2125 Generator returning the variant's field as tuples of (field name, field declaration).
2129 count = _bt_ctf_field_type_variant_get_field_count(self._ft)
2131 raise TypeError("Could not get Variant field count")
2133 for i in range(count):
2134 field_name = _bt_python_ctf_field_type_variant_get_field_name(self._ft, i)
2135 if field_name is None:
2136 raise TypeError("Could not get Variant field name at index {}".format(i))
2138 field_type_native = _bt_python_ctf_field_type_variant_get_field_type(self._ft, i)
2139 if field_type_native is None:
2140 raise TypeError("Could not get Variant field type at index {}".format(i))
2142 field_type = CTFWriter.FieldDeclaration._create_field_declaration_from_native_instance(field_type_native)
2143 yield (field_name, field_type)
2146 Get a field declaration by name (FieldDeclaration).
2148 def get_field_by_name(self, name):
2149 field_type_native = _bt_ctf_field_type_variant_get_field_type_by_name(self._ft, name)
2150 if field_type_native is None:
2151 raise TypeError("Could not find Variant field with name {}".format(name))
2153 return CTFWriter.FieldDeclaration._create_field_declaration_from_native_instance(field_type_native)
2156 Get a field declaration from tag (EnumerationField).
2158 def get_field_from_tag(self, tag):
2159 field_type_native = _bt_ctf_field_type_variant_get_field_type_from_tag(self._ft, tag._f)
2160 if field_type_native is None:
2161 raise TypeError("Could not find Variant field with tag value {}".format(tag.value))
2163 return CTFWriter.FieldDeclaration._create_field_declaration_from_native_instance(field_type_native)
2165 class ArrayFieldDeclaration(FieldDeclaration):
2167 Create a new array field declaration.
2169 def __init__(self, element_type, length):
2170 self._ft = _bt_ctf_field_type_array_create(element_type._ft, length)
2174 Get the array's element type.
2177 def element_type(self):
2178 ret = _bt_ctf_field_type_array_get_element_type(self._ft)
2180 raise TypeError("Could not get Array element type")
2181 return CTFWriter.FieldDeclaration._create_field_declaration_from_native_instance(ret)
2184 Get the array's length.
2188 ret = _bt_ctf_field_type_array_get_length(self._ft)
2190 raise TypeError("Could not get Array length")
2193 class SequenceFieldDeclaration(FieldDeclaration):
2195 Create a new sequence field declaration.
2197 def __init__(self, element_type, length_field_name):
2198 self._ft = _bt_ctf_field_type_sequence_create(element_type._ft, str(length_field_name))
2202 Get the sequence's element type.
2205 def element_type(self):
2206 ret = _bt_ctf_field_type_sequence_get_element_type(self._ft)
2208 raise TypeError("Could not get Sequence element type")
2209 return CTFWriter.FieldDeclaration._create_field_declaration_from_native_instance(ret)
2212 Get the sequence's length field name.
2215 def length_field_name(self):
2216 ret = _bt_ctf_field_type_sequence_get_length_field_name(self._ft)
2218 raise TypeError("Could not get Sequence length field name")
2221 class StringFieldDeclaration(FieldDeclaration):
2223 Create a new string field declaration.
2226 self._ft = _bt_ctf_field_type_string_create()
2230 Get a string declaration's encoding (a constant from the CTFStringEncoding class).
2234 return _bt_ctf_field_type_string_get_encoding(self._ft)
2237 Set a string declaration's encoding. Must be a constant from the CTFStringEncoding class.
2240 def encoding(self, encoding):
2241 ret = _bt_ctf_field_type_string_set_encoding(self._ft, encoding)
2243 raise ValueError("Could not set string encoding.")
2246 Create an instance of a field.
2249 def create_field(field_type):
2250 if field_type is None or not isinstance(field_type, CTFWriter.FieldDeclaration):
2251 raise TypeError("Invalid field_type. Type must be a FieldDeclaration-derived class.")
2253 if isinstance(field_type, CTFWriter.IntegerFieldDeclaration):
2254 return CTFWriter.IntegerField(field_type)
2255 elif isinstance(field_type, CTFWriter.EnumerationFieldDeclaration):
2256 return CTFWriter.EnumerationField(field_type)
2257 elif isinstance(field_type, CTFWriter.FloatFieldDeclaration):
2258 return CTFWriter.FloatFieldingPoint(field_type)
2259 elif isinstance(field_type, CTFWriter.StructureFieldDeclaration):
2260 return CTFWriter.StructureField(field_type)
2261 elif isinstance(field_type, CTFWriter.VariantFieldDeclaration):
2262 return CTFWriter.VariantField(field_type)
2263 elif isinstance(field_type, CTFWriter.ArrayFieldDeclaration):
2264 return CTFWriter.ArrayField(field_type)
2265 elif isinstance(field_type, CTFWriter.SequenceFieldDeclaration):
2266 return CTFWriter.SequenceField(field_type)
2267 elif isinstance(field_type, CTFWriter.StringFieldDeclaration):
2268 return CTFWriter.StringField(field_type)
2272 Base class, do not instantiate.
2274 def __init__(self, field_type):
2275 if not isinstance(field_type, CTFWriter.FieldDeclaration):
2276 raise TypeError("Invalid field_type argument.")
2278 self._f = _bt_ctf_field_create(field_type._ft)
2280 raise ValueError("Field creation failed.")
2283 _bt_ctf_field_put(self._f)
2286 def _create_field_from_native_instance(native_field_instance):
2288 CTFTypeId.INTEGER : CTFWriter.IntegerField,
2289 CTFTypeId.FLOAT : CTFWriter.FloatFieldingPoint,
2290 CTFTypeId.ENUM : CTFWriter.EnumerationField,
2291 CTFTypeId.STRING : CTFWriter.StringField,
2292 CTFTypeId.STRUCT : CTFWriter.StructureField,
2293 CTFTypeId.VARIANT : CTFWriter.VariantField,
2294 CTFTypeId.ARRAY : CTFWriter.ArrayField,
2295 CTFTypeId.SEQUENCE : CTFWriter.SequenceField
2298 field_type = _bt_python_get_field_type(native_field_instance)
2299 if field_type == CTFTypeId.UNKNOWN:
2300 raise TypeError("Invalid field instance")
2302 field = CTFWriter.Field.__new__(CTFWriter.Field)
2303 field._f = native_field_instance
2304 field.__class__ = type_dict[field_type]
2308 def declaration(self):
2309 native_field_type = _bt_ctf_field_get_type(self._f)
2310 if native_field_type is None:
2311 raise TypeError("Invalid field instance")
2312 return CTFWriter.FieldDeclaration._create_field_declaration_from_native_instance(native_field_type)
2314 class IntegerField(Field):
2316 Get an integer field's value.
2320 signedness = _bt_python_field_integer_get_signedness(self._f)
2322 raise TypeError("Invalid integer instance.")
2325 ret, value = _bt_ctf_field_unsigned_integer_get_value(self._f)
2327 ret, value = _bt_ctf_field_signed_integer_get_value(self._f)
2330 raise ValueError("Could not get integer field value.")
2334 Set an integer field's value.
2337 def value(self, value):
2338 if not isinstance(value, int):
2339 raise TypeError("IntegerField's value must be an int")
2341 signedness = _bt_python_field_integer_get_signedness(self._f)
2343 raise TypeError("Invalid integer instance.")
2346 ret = _bt_ctf_field_unsigned_integer_set_value(self._f, value)
2348 ret = _bt_ctf_field_signed_integer_set_value(self._f, value)
2351 raise ValueError("Could not set integer field value.")
2353 class EnumerationField(Field):
2355 Return the enumeration's underlying container field (an integer field).
2358 def container(self):
2359 container = CTFWriter.IntegerField.__new__(CTFWriter.IntegerField)
2360 container._f = _bt_ctf_field_enumeration_get_container(self._f)
2361 if container._f is None:
2362 raise TypeError("Invalid enumeration field type.")
2366 Get the enumeration field's mapping name.
2370 value = _bt_ctf_field_enumeration_get_mapping_name(self._f)
2372 raise ValueError("Could not get enumeration's mapping name.")
2376 Set the enumeration field's value. Must be an integer as mapping names
2380 def value(self, value):
2381 if not isinstance(value, int):
2382 raise TypeError("EnumerationField value must be an int")
2383 self.container.value = value
2385 class FloatFieldingPoint(Field):
2387 Get a floating point field's value.
2391 ret, value = _bt_ctf_field_floating_point_get_value(self._f)
2393 raise ValueError("Could not get floating point field value.")
2397 Set a floating point field's value.
2400 def value(self, value):
2401 if not isinstance(value, int) and not isinstance(value, float):
2402 raise TypeError("Value must be either a float or an int")
2404 ret = _bt_ctf_field_floating_point_set_value(self._f, float(value))
2406 raise ValueError("Could not set floating point field value.")
2408 class StructureField(Field):
2410 Get the structure's field corresponding to the provided field name.
2412 def field(self, field_name):
2413 native_instance = _bt_ctf_field_structure_get_field(self._f, str(field_name))
2414 if native_instance is None:
2415 raise ValueError("Invalid field_name provided.")
2416 return CTFWriter.Field._create_field_from_native_instance(native_instance)
2418 class VariantField(Field):
2420 Return the variant's selected field. The "tag" field is the selector enum field.
2422 def field(self, tag):
2423 native_instance = _bt_ctf_field_variant_get_field(self._f, tag._f)
2424 if native_instance is None:
2425 raise ValueError("Invalid tag provided.")
2426 return CTFWriter.Field._create_field_from_native_instance(native_instance)
2428 class ArrayField(Field):
2430 Return the array's field at position "index".
2432 def field(self, index):
2433 native_instance = _bt_ctf_field_array_get_field(self._f, index)
2434 if native_instance is None:
2435 raise IndexError("Invalid index provided.")
2436 return CTFWriter.Field._create_field_from_native_instance(native_instance)
2438 class SequenceField(Field):
2440 Get the sequence's length field (IntegerField).
2444 native_instance = _bt_ctf_field_sequence_get_length(self._f)
2445 if native_instance is None:
2447 return CTFWriter.Field._create_field_from_native_instance(native_instance)
2450 Set the sequence's length field (IntegerField).
2453 def length(self, length_field):
2454 if not isinstance(length_field, CTFWriter.IntegerField):
2455 raise TypeError("Invalid length field.")
2456 if length_field.declaration.signed:
2457 raise TypeError("Sequence field length must be unsigned")
2458 ret = _bt_ctf_field_sequence_set_length(self._f, length_field._f)
2460 raise ValueError("Could not set sequence length.")
2463 Return the sequence's field at position "index".
2465 def field(self, index):
2466 native_instance = _bt_ctf_field_sequence_get_field(self._f, index)
2467 if native_instance is None:
2468 raise ValueError("Could not get sequence element at index.")
2469 return CTFWriter.Field._create_field_from_native_instance(native_instance)
2471 class StringField(Field):
2473 Get a string field's value.
2477 return _bt_ctf_field_string_get_value(self._f)
2480 Set a string field's value.
2483 def value(self, value):
2484 ret = _bt_ctf_field_string_set_value(self._f, str(value))
2486 raise ValueError("Could not set string field value.")
2490 Create a new event class of the given name.
2492 def __init__(self, name):
2493 self._ec = _bt_ctf_event_class_create(name)
2494 if self._ec is None:
2495 raise ValueError("Event class creation failed.")
2498 _bt_ctf_event_class_put(self._ec)
2501 Add a field of type "field_type" to the event class.
2503 def add_field(self, field_type, field_name):
2504 ret = _bt_ctf_event_class_add_field(self._ec, field_type._ft, str(field_name))
2506 raise ValueError("Could not add field to event class.")
2509 Get the event class' name.
2513 name = _bt_ctf_event_class_get_name(self._ec)
2515 raise TypeError("Could not get EventClass name")
2519 Get the event class' id. Returns a negative value if unset.
2523 id = _bt_ctf_event_class_get_id(self._ec)
2525 raise TypeError("Could not get EventClass id")
2529 Set the event class' id. Throws a TypeError if the event class
2530 is already registered to a stream class.
2534 ret = _bt_ctf_event_class_set_id(self._ec, id)
2536 raise TypeError("Can't change an Event Class's id after it has been assigned to a stream class")
2539 Get the event class' stream class. Returns None if unset.
2542 def stream_class(self):
2543 stream_class_native = _bt_ctf_event_class_get_stream_class(self._ec)
2544 if stream_class_native is None:
2546 stream_class = CTFWriter.StreamClass.__new__(CTFWriter.StreamClass)
2547 stream_class._sc = stream_class_native
2551 Generator returning the event class' fields as tuples of (field name, field declaration).
2555 count = _bt_ctf_event_class_get_field_count(self._ec)
2557 raise TypeError("Could not get EventClass' field count")
2559 for i in range(count):
2560 field_name = _bt_python_ctf_event_class_get_field_name(self._ec, i)
2561 if field_name is None:
2562 raise TypeError("Could not get EventClass' field name at index {}".format(i))
2564 field_type_native = _bt_python_ctf_event_class_get_field_type(self._ec, i)
2565 if field_type_native is None:
2566 raise TypeError("Could not get EventClass' field type at index {}".format(i))
2568 field_type = CTFWriter.FieldDeclaration._create_field_declaration_from_native_instance(field_type_native)
2569 yield (field_name, field_type)
2572 Get a field declaration by name (FieldDeclaration).
2574 def get_field_by_name(self, name):
2575 field_type_native = _bt_ctf_event_class_get_field_by_name(self._ec, name)
2576 if field_type_native is None:
2577 raise TypeError("Could not find EventClass field with name {}".format(name))
2578 return CTFWriter.FieldDeclaration._create_field_declaration_from_native_instance(field_type_native)
2582 Create a new event of the given event class.
2584 def __init__(self, event_class):
2585 if not isinstance(event_class, CTFWriter.EventClass):
2586 raise TypeError("Invalid event_class argument.")
2588 self._e = _bt_ctf_event_create(event_class._ec)
2590 raise ValueError("Event creation failed.")
2593 _bt_ctf_event_put(self._e)
2596 Get the event's class.
2599 def event_class(self):
2600 event_class_native = _bt_ctf_event_get_class(self._e)
2601 if event_class_native is None:
2603 event_class = CTFWriter.EventClass.__new__(CTFWriter.EventClass)
2604 event_class._ec = event_class_native
2608 Get a clock from event. Returns None if the event's class
2609 is not registered to a stream class.
2612 clock_instance = _bt_ctf_event_get_clock(self._e)
2613 if clock_instance is None:
2615 clock = CTFWriter.Clock.__new__(CTFWriter.Clock)
2616 clock._c = clock_instance
2620 Get a field from event.
2622 def payload(self, field_name):
2623 native_instance = _bt_ctf_event_get_payload(self._e, str(field_name))
2624 if native_instance is None:
2625 raise ValueError("Could not get event payload.")
2626 return CTFWriter.Field._create_field_from_native_instance(native_instance)
2629 Set a manually created field as an event's payload.
2631 def set_payload(self, field_name, value_field):
2632 if not isinstance(value, CTFWriter.Field):
2633 raise TypeError("Invalid value type.")
2634 ret = _bt_ctf_event_set_payload(self._e, str(field_name), value_field._f)
2636 raise ValueError("Could not set event field payload.")
2640 Create a new stream class of the given name.
2642 def __init__(self, name):
2643 self._sc = _bt_ctf_stream_class_create(name)
2644 if self._sc is None:
2645 raise ValueError("Stream class creation failed.")
2648 _bt_ctf_stream_class_put(self._sc)
2651 Get a stream class' name.
2655 name = _bt_ctf_stream_class_get_name(self._sc)
2657 raise TypeError("Could not get StreamClass name")
2661 Get a stream class' clock.
2665 clock_instance = _bt_ctf_stream_class_get_clock(self._sc)
2666 if clock_instance is None:
2668 clock = CTFWriter.Clock.__new__(CTFWriter.Clock)
2669 clock._c = clock_instance
2673 Assign a clock to a stream class.
2676 def clock(self, clock):
2677 if not isinstance(clock, CTFWriter.Clock):
2678 raise TypeError("Invalid clock type.")
2680 ret = _bt_ctf_stream_class_set_clock(self._sc, clock._c)
2682 raise ValueError("Could not set stream class clock.")
2685 Get a stream class' id.
2689 ret = _bt_ctf_stream_class_get_id(self._sc)
2691 raise TypeError("Could not get StreamClass id")
2695 Assign an id to a stream class.
2699 ret = _bt_ctf_stream_class_set_id(self._sc, id)
2701 raise TypeError("Could not set stream class id.")
2704 Generator returning the stream class' event classes.
2707 def event_classes(self):
2708 count = _bt_ctf_stream_class_get_event_class_count(self._sc)
2710 raise TypeError("Could not get StreamClass' event class count")
2712 for i in range(count):
2713 event_class_native = _bt_ctf_stream_class_get_event_class(self._sc, i)
2714 if event_class_native is None:
2715 raise TypeError("Could not get StreamClass' event class at index {}".format(i))
2717 event_class = CTFWriter.EventClass.__new__(CTFWriter.EventClass)
2718 event_class._ec = event_class_native
2722 Add an event class to a stream class. New events can be added even after a
2723 stream has been instantiated and events have been appended. However, a stream
2724 will not accept events of a class that has not been registered beforehand.
2726 def add_event_class(self, event_class):
2727 if not isinstance(event_class, CTFWriter.EventClass):
2728 raise TypeError("Invalid event_class type.")
2730 ret = _bt_ctf_stream_class_add_event_class(self._sc, event_class._ec)
2732 raise ValueError("Could not add event class.")
2736 Create a stream of the given class.
2738 def __init__(self, stream_class):
2739 if not isinstance(stream_class, CTFWriter.StreamClass):
2740 raise TypeError("Invalid stream_class type.")
2742 self._s = _bt_ctf_stream_create(stream_class._sc)
2744 raise ValueError("Stream creation failed.")
2747 _bt_ctf_stream_put(self._s)
2750 Get a stream's discarded event count.
2753 def discarded_events(self):
2754 ret, count = _bt_ctf_stream_get_discarded_events_count(self._s)
2756 raise ValueError("Could not get the stream's discarded events count")
2760 Increase the current packet's discarded event count.
2762 def append_discarded_events(self, event_count):
2763 _bt_ctf_stream_append_discarded_events(self._s, event_count)
2766 Append "event" to the stream's current packet. The stream's associated clock
2767 will be sampled during this call. The event shall not be modified after
2768 being appended to a stream.
2770 def append_event(self, event):
2771 ret = _bt_ctf_stream_append_event(self._s, event._e)
2773 raise ValueError("Could not append event to stream.")
2776 The stream's current packet's events will be flushed to disk. Events
2777 subsequently appended to the stream will be added to a new packet.
2780 ret = _bt_ctf_stream_flush(self._s)
2782 raise ValueError("Could not flush stream.")
2786 Create a new writer that will produce a trace in the given path.
2788 def __init__(self, path):
2789 self._w = _bt_ctf_writer_create(path)
2791 raise ValueError("Writer creation failed.")
2794 _bt_ctf_writer_put(self._w)
2797 Create a new stream instance and register it to the writer.
2799 def create_stream(self, stream_class):
2800 if not isinstance(stream_class, CTFWriter.StreamClass):
2801 raise TypeError("Invalid stream_class type.")
2803 stream = CTFWriter.Stream.__new__(CTFWriter.Stream)
2804 stream._s = _bt_ctf_writer_create_stream(self._w, stream_class._sc)
2808 Add an environment field to the trace.
2810 def add_environment_field(self, name, value):
2811 ret = _bt_ctf_writer_add_environment_field(self._w, str(name), str(value))
2813 raise ValueError("Could not add environment field to trace.")
2816 Add a clock to the trace. Clocks assigned to stream classes must be
2817 registered to the writer.
2819 def add_clock(self, clock):
2820 ret = _bt_ctf_writer_add_clock(self._w, clock._c)
2822 raise ValueError("Could not add clock to Writer.")
2825 Get the trace's TSDL meta-data.
2829 return _bt_ctf_writer_get_metadata_string(self._w)
2832 Flush the trace's metadata to the metadata file.
2834 def flush_metadata(self):
2835 _bt_ctf_writer_flush_metadata(self._w)
2838 Get the trace's byte order. Must be a constant from the ByteOrder
2842 def byte_order(self):
2843 raise NotImplementedError("Getter not implemented.")
2846 Set the trace's byte order. Must be a constant from the ByteOrder
2847 class. Defaults to BYTE_ORDER_NATIVE, the host machine's endianness.
2850 def byte_order(self, byte_order):
2851 ret = _bt_ctf_writer_set_byte_order(self._w, byte_order)
2853 raise ValueError("Could not set trace's byte order.")