def __init__(self, element_field_class, length): utils._check_type(element_field_class, _FieldClass) utils._check_uint64(length) ptr = native_bt.field_class_array_create(element_field_class._ptr, length) self._check_create_status(ptr) super().__init__(ptr)
def _create_packet_end_message(self, packet, default_clock_snapshot=None): utils._check_type(packet, bt2_packet._Packet) if packet.stream.cls.packets_have_end_default_clock_snapshot: if default_clock_snapshot is None: raise ValueError( "packet end messages in this stream must have a default clock snapshot" ) utils._check_uint64(default_clock_snapshot) ptr = native_bt.message_packet_end_create_with_default_clock_snapshot( self._bt_ptr, packet._ptr, default_clock_snapshot) else: if default_clock_snapshot is not None: raise ValueError( "packet end messages in this stream must not have a default clock snapshot" ) ptr = native_bt.message_packet_end_create(self._bt_ptr, packet._ptr) if ptr is None: raise bt2._MemoryError('cannot create packet end message object') return bt2_message._PacketEndMessage(ptr)
def create_stream(self, stream_class, id=None, name=None): utils._check_type(stream_class, bt2_stream_class._StreamClass) if stream_class.assigns_automatic_stream_id: if id is not None: raise ValueError( "id provided, but stream class assigns automatic stream ids" ) stream_ptr = native_bt.stream_create(stream_class._ptr, self._ptr) else: if id is None: raise ValueError( "id not provided, but stream class does not assign automatic stream ids" ) utils._check_uint64(id) stream_ptr = native_bt.stream_create_with_id( stream_class._ptr, self._ptr, id ) if stream_ptr is None: raise bt2._MemoryError('cannot create stream object') stream = bt2_stream._Stream._create_from_ptr(stream_ptr) if name is not None: stream._name = name return stream
def __init__(self, element_field_class, length_name): utils._check_type(element_field_class, _FieldClass) utils._check_str(length_name) ptr = native_bt.field_class_sequence_create(element_field_class._ptr, length_name) self._check_create_status(ptr) super().__init__(ptr)
def append_option(self, name, field_class, ranges, user_attributes=None): utils._check_str(name) utils._check_type(field_class, _FieldClass) utils._check_type(ranges, self._variant_option_pycls._range_set_pycls) if name in self: raise ValueError("duplicate option name '{}'".format(name)) if len(ranges) == 0: raise ValueError('range set is empty') user_attributes_value = None if user_attributes is not None: # check now that user attributes are valid user_attributes_value = bt2.create_value(user_attributes) # TODO: check overlaps (precondition of self._append_option()) status = self._append_option(self._ptr, name, field_class._ptr, ranges._ptr) utils._handle_func_status( status, 'cannot append option to variant field class object' ) if user_attributes is not None: self[name]._user_attributes = user_attributes_value
def __setitem__(self, key, value): utils._check_type(key, bt2.ClockClass) utils._check_uint64(value) ret = native_bt.clock_class_priority_map_add_clock_class(self._ptr, key._ptr, value) utils._handle_ret(ret, "cannot set clock class's priority in clock class priority map object")
def __init__(self, element_field_type, length_name): utils._check_type(element_field_type, _FieldType) utils._check_str(length_name) ptr = native_bt.ctf_field_type_sequence_create(element_field_type._ptr, length_name) self._check_create_status(ptr) super().__init__(ptr)
def append_field(self, name, field_class): utils._check_str(name) utils._check_type(field_class, _FieldClass) ret = self._add_field(field_class._ptr, name) utils._handle_ret( ret, "cannot add field to {} field class object".format( self._NAME.lower()))
def __init__(self, stream): utils._check_type(stream, bt2.stream._Stream) ptr = native_bt.notification_stream_end_create(stream._ptr) if ptr is None: raise bt2.CreationError('cannot create end of stream notification object') super().__init__(ptr)
def __init__(self, packet): utils._check_type(packet, bt2.packet._Packet) ptr = native_bt.notification_packet_end_create(packet._ptr) if ptr is None: raise bt2.CreationError('cannot create end of packet notification object') super().__init__(ptr)
def __init__(self, event): utils._check_type(event, bt2.event._Event) ptr = native_bt.notification_event_create(event._ptr) if ptr is None: raise bt2.CreationError('cannot create trace event notification object') super().__init__(ptr)
def offset(self, offset): utils._check_type(offset, ClockClassOffset) ret = native_bt.clock_class_set_offset_s(self._ptr, offset.seconds) utils._handle_ret(ret, "cannot set clock class object's offset (seconds)") ret = native_bt.clock_class_set_offset_cycles(self._ptr, offset.cycles) utils._handle_ret(ret, "cannot set clock class object's offset (cycles)")
def __init__(self, trace): utils._check_type(trace, bt2.Trace) ptr = native_bt.notification_new_trace_create(trace._ptr) if ptr is None: raise bt2.CreationError('cannot create new trace notification object') super().__init__(ptr)
def __init__(self, stream): utils._check_type(stream, bt2.stream._Stream) ptr = native_bt.message_stream_end_create(stream._ptr) if ptr is None: raise bt2.CreationError('cannot create stream end message object') super().__init__(ptr)
def _specific_context_field_class(self, context_field_class): if context_field_class is not None: utils._check_type(context_field_class, bt2_field_class._StructureFieldClass) status = native_bt.event_class_set_specific_context_field_class( self._ptr, context_field_class._ptr) utils._handle_func_status( status, "cannot set event class object's context field class")
def __init__(self, packet): utils._check_type(packet, bt2.packet._Packet) ptr = native_bt.message_packet_end_create(packet._ptr) if ptr is None: raise bt2.CreationError('cannot create packet end message object') super().__init__(ptr)
def _payload_field_class(self, payload_field_class): if payload_field_class is not None: utils._check_type(payload_field_class, bt2_field_class._StructureFieldClass) status = native_bt.event_class_set_payload_field_class( self._ptr, payload_field_class._ptr) utils._handle_func_status( status, "cannot set event class object's payload field class")
def offset(self, offset): utils._check_type(offset, bt2.ClockClassOffset) ret = native_bt.ctf_clock_set_offset_s(self._ptr, offset.seconds) utils._handle_ret( ret, "cannot set CTF writer clock object's offset (seconds)") ret = native_bt.ctf_clock_set_offset(self._ptr, offset.cycles) utils._handle_ret( ret, "cannot set CTF writer clock object's offset (cycles)")
def __init__(self, stream_class): utils._check_type(stream_class, bt2.StreamClass) ptr = native_bt.notification_new_stream_class_create(stream_class._ptr) if ptr is None: raise bt2.CreationError('cannot create new stream class notification object') super().__init__(ptr)
def __init__(self, stream): utils._check_type(stream, bt2.stream._Stream) ptr = native_bt.notification_stream_end_create(stream._ptr) if ptr is None: raise bt2.CreationError( 'cannot create end of stream notification object') super().__init__(ptr)
def header_field(self, header_field): header_field_ptr = None if header_field is not None: utils._check_type(header_field, bt2.fields._Field) header_field_ptr = header_field._ptr ret = native_bt.ctf_event_set_header(self._ptr, header_field_ptr) utils._handle_ret(ret, "cannot set event object's header field")
def context_field(self, context): context_ptr = None if context is not None: utils._check_type(context, bt2.fields._Field) context_ptr = context._ptr ret = native_bt.ctf_event_set_event_context(self._ptr, context_ptr) utils._handle_ret(ret, "cannot set event object's context field")
def context_field_type(self, context_field_type): context_field_type_ptr = None if context_field_type is not None: utils._check_type(context_field_type, bt2.field_types._FieldType) context_field_type_ptr = context_field_type._ptr ret = native_bt.event_class_set_context_type(self._ptr, context_field_type_ptr) utils._handle_ret(ret, "cannot set event class object's context field type")
def __setitem__(self, key, value): utils._check_type(key, bt2.ClockClass) utils._check_uint64(value) ret = native_bt.clock_class_priority_map_add_clock_class( self._ptr, key._ptr, value) utils._handle_ret( ret, "cannot set clock class's priority in clock class priority map object" )
def __init__(self, stream_class): utils._check_type(stream_class, bt2.StreamClass) ptr = native_bt.notification_new_stream_class_create(stream_class._ptr) if ptr is None: raise bt2.CreationError( 'cannot create new stream class notification object') super().__init__(ptr)
def __init__(self, event): utils._check_type(event, bt2.event._Event) ptr = native_bt.notification_event_create(event._ptr) if ptr is None: raise bt2.CreationError( 'cannot create trace event notification object') super().__init__(ptr)
def __init__(self, packet): utils._check_type(packet, bt2.packet._Packet) ptr = native_bt.notification_packet_end_create(packet._ptr) if ptr is None: raise bt2.CreationError( 'cannot create end of packet notification object') super().__init__(ptr)
def __getitem__(self, key): utils._check_type(key, bt2.ClockClass) ret, prio = native_bt.clock_class_priority_map_get_clock_class_priority( self._ptr, key._ptr) if ret != 0: raise KeyError(key) return prio
def __init__(self, trace): utils._check_type(trace, bt2.Trace) ptr = native_bt.notification_new_trace_create(trace._ptr) if ptr is None: raise bt2.CreationError( 'cannot create new trace notification object') super().__init__(ptr)
def payload_field_type(self, payload_field_type): payload_field_type_ptr = None if payload_field_type is not None: utils._check_type(payload_field_type, bt2.field_types._FieldType) payload_field_type_ptr = payload_field_type._ptr ret = native_bt.event_class_set_payload_type(self._ptr, payload_field_type_ptr) utils._handle_ret(ret, "cannot set event class object's payload field type")
def context_field(self, context_field): context_field_ptr = None if context_field is not None: utils._check_type(context_field, bt2.field._Field) context_field_ptr = context_field._ptr ret = native_bt.packet_set_context(self._ptr, context_field_ptr) utils._handle_ret(ret, "cannot set packet object's context field")
def payload_field(self, payload): payload_ptr = None if payload is not None: utils._check_type(payload, bt2.fields._Field) payload_ptr = payload._ptr ret = native_bt.ctf_event_set_payload_field(self._ptr, payload_ptr) utils._handle_ret(ret, "cannot set event object's payload field")
def connect_ports(self, upstream_port, downstream_port): utils._check_type(upstream_port, bt2.port._OutputPort) utils._check_type(downstream_port, bt2.port._InputPort) status, conn_ptr = native_bt.graph_connect_ports(self._ptr, upstream_port._ptr, downstream_port._ptr) self._handle_status(status, 'cannot connect component ports within graph') assert(conn_ptr) return bt2.connection._Connection._create_from_ptr(conn_ptr)
def __getitem__(self, key): utils._check_type(key, bt2.ClockClass) ret, prio = native_bt.clock_class_priority_map_get_clock_class_priority(self._ptr, key._ptr) if ret != 0: raise KeyError(key) return prio
def _get_from_bt(self): # this can raise anything: it's catched by the system notif = self._get() utils._check_type(notif, bt2.notification._Notification) # steal the underlying native notification object for the caller notif_ptr = notif._ptr notif._ptr = None return int(notif_ptr)
def create_static_array_field_class(self, elem_fc, length): utils._check_type(elem_fc, bt2_field_class._FieldClass) utils._check_uint64(length) ptr = native_bt.field_class_array_static_create( self._ptr, elem_fc._ptr, length) self._check_create_status(ptr, 'static array') return bt2_field_class._StaticArrayFieldClass._create_from_ptr_and_get_ref( ptr)
def connect_ports(self, upstream_port, downstream_port): utils._check_type(upstream_port, bt2_port._OutputPortConst) utils._check_type(downstream_port, bt2_port._InputPortConst) status, conn_ptr = native_bt.graph_connect_ports( self._ptr, upstream_port._ptr, downstream_port._ptr ) utils._handle_func_status(status, 'cannot connect component ports within graph') assert conn_ptr return bt2_connection._ConnectionConst._create_from_ptr(conn_ptr)
def packet_context_field_type(self, packet_context_field_type): packet_context_field_type_ptr = None if packet_context_field_type is not None: utils._check_type(packet_context_field_type, bt2.field_types._FieldType) packet_context_field_type_ptr = packet_context_field_type._ptr ret = native_bt.ctf_stream_class_set_packet_context_type(self._ptr, packet_context_field_type_ptr) utils._handle_ret(ret, "cannot set stream class object's packet context field type")
def __getitem__(self, clock_class): utils._check_type(clock_class, bt2.ClockClass) clock_snapshot_ptr = native_bt.message_inactivity_get_clock_snapshot(self._msg._ptr, clock_class._ptr) if clock_snapshot_ptr is None: return clock_snapshot = bt2.clock_snapshot._create_clock_snapshot_from_ptr(clock_snapshot_ptr) return clock_snapshot
def _create_message_iterator_inactivity_message(self, clock_class, clock_snapshot): utils._check_type(clock_class, bt2_clock_class._ClockClass) ptr = native_bt.message_message_iterator_inactivity_create( self._bt_ptr, clock_class._ptr, clock_snapshot) if ptr is None: raise bt2._MemoryError('cannot create inactivity message object') return bt2_message._MessageIteratorInactivityMessage(ptr)
def create_variant_field_class(self, selector_fc=None): selector_fc_ptr = None if selector_fc is not None: utils._check_type(selector_fc, bt2_field_class._IntegerFieldClass) selector_fc_ptr = selector_fc._ptr ptr = native_bt.field_class_variant_create(self._ptr, selector_fc_ptr) self._check_create_status(ptr, 'variant') return bt2_field_class._create_field_class_from_ptr_and_get_ref(ptr)
def _create_input_port_message_iterator(self, input_port): utils._check_type(input_port, bt2_port._UserComponentInputPort) msg_iter_ptr = native_bt.self_component_port_input_message_iterator_create_from_message_iterator( self._bt_ptr, input_port._ptr) if msg_iter_ptr is None: raise bt2.CreationError('cannot create message iterator object') return _UserComponentInputPortMessageIterator(msg_iter_ptr)
def stream_event_context_field(self, stream_event_context): stream_event_context_ptr = None if stream_event_context is not None: utils._check_type(stream_event_context, bt2.fields._Field) stream_event_context_ptr = stream_event_context._ptr ret = native_bt.ctf_event_set_stream_event_context(self._ptr, stream_event_context_ptr) utils._handle_ret(ret, "cannot set event object's stream event context field")
def packet_context_field(self, packet_context_field): packet_context_field_ptr = None if packet_context_field is not None: utils._check_type(packet_context_field, bt2.fields._Field) packet_context_field_ptr = packet_context_field._ptr ret = native_bt.stream_set_packet_context(self._ptr, packet_context_field_ptr) utils._handle_ret(ret, "cannot set CTF writer stream object's packet context field")
def event_context_field_class(self, event_context_field_class): event_context_field_class_ptr = None if event_context_field_class is not None: utils._check_type(event_context_field_class, bt2.field_class._FieldClass) event_context_field_class_ptr = event_context_field_class._ptr ret = native_bt.stream_class_set_event_context_type(self._ptr, event_context_field_class_ptr) utils._handle_ret(ret, "cannot set stream class object's event context field class")
def packet_context_field_class(self, packet_context_field_class): packet_context_field_class_ptr = None if packet_context_field_class is not None: utils._check_type(packet_context_field_class, bt2.field_class._FieldClass) packet_context_field_class_ptr = packet_context_field_class._ptr ret = native_bt.stream_class_set_packet_context_type(self._ptr, packet_context_field_class_ptr) utils._handle_ret(ret, "cannot set stream class object's packet context field class")
def get_clock_value(self, clock_class): utils._check_type(clock_class, bt2.ClockClass) clock_value_ptr = native_bt.ctf_event_get_clock_value(self._ptr, clock_class._ptr) if clock_value_ptr is None: return clock_value = bt2.clock_class._create_clock_value_from_ptr(clock_value_ptr) return clock_value
def packet_header_field_class(self, packet_header_field_class): packet_header_field_class_ptr = None if packet_header_field_class is not None: utils._check_type(packet_header_field_class, bt2.field_class._FieldClass) packet_header_field_class_ptr = packet_header_field_class._ptr ret = native_bt.trace_set_packet_header_type(self._ptr, packet_header_field_class_ptr) utils._handle_ret(ret, "cannot set trace class object's packet header field class")
def field(self, tag_field=None): if tag_field is None: field_ptr = native_bt.ctf_field_variant_get_current_field(self._ptr) utils._handle_ptr(field_ptr, "cannot get variant field object's selected field") else: utils._check_type(tag_field, _EnumerationField) field_ptr = native_bt.ctf_field_variant_get_field(self._ptr, tag_field._ptr) utils._handle_ptr(field_ptr, "cannot select variant field object's field") return _create_from_ptr(field_ptr)
def packet_header_field_type(self, packet_header_field_type): packet_header_field_type_ptr = None if packet_header_field_type is not None: utils._check_type(packet_header_field_type, bt2.field_types._FieldType) packet_header_field_type_ptr = packet_header_field_type._ptr ret = native_bt.trace_set_packet_header_type(self._ptr, packet_header_field_type_ptr) utils._handle_ret(ret, "cannot set trace class object's packet header field type")
def event_context_field_type(self, event_context_field_type): event_context_field_type_ptr = None if event_context_field_type is not None: utils._check_type(event_context_field_type, bt2.field_types._FieldType) event_context_field_type_ptr = event_context_field_type._ptr ret = native_bt.ctf_stream_class_set_event_context_type(self._ptr, event_context_field_type_ptr) utils._handle_ret(ret, "cannot set stream class object's event context field type")