# THE SOFTWARE.
from bt2 import native_bt, object, utils
-import bt2.field_types
+import bt2.field_class
import collections.abc
-import bt2.values
+import bt2.value
import bt2.stream
import copy
import bt2
if self._at == len(self._trace):
raise StopIteration
- sc_ptr = native_bt.ctf_trace_get_stream_class_by_index(self._trace._ptr,
- self._at)
+ sc_ptr = native_bt.trace_get_stream_class_by_index(self._trace._ptr,
+ self._at)
assert(sc_ptr)
- id = native_bt.ctf_stream_class_get_id(sc_ptr)
+ id = native_bt.stream_class_get_id(sc_ptr)
native_bt.put(sc_ptr)
assert(id >= 0)
self._at += 1
self._trace = trace
def __len__(self):
- count = native_bt.ctf_trace_get_stream_count(self._trace._ptr)
+ count = native_bt.trace_get_stream_count(self._trace._ptr)
assert(count >= 0)
return count
if index >= len(self):
raise IndexError
- stream_ptr = native_bt.ctf_trace_get_stream_by_index(self._trace._ptr,
- index)
+ stream_ptr = native_bt.trace_get_stream_by_index(self._trace._ptr,
+ index)
assert(stream_ptr)
return bt2.stream._create_from_ptr(stream_ptr)
raise StopIteration
trace_ptr = self._trace_clock_classes._trace._ptr
- cc_ptr = native_bt.ctf_trace_get_clock_class_by_index(trace_ptr, self._at)
+ cc_ptr = native_bt.trace_get_clock_class_by_index(trace_ptr, self._at)
assert(cc_ptr)
- name = native_bt.ctf_clock_class_get_name(cc_ptr)
+ name = native_bt.clock_class_get_name(cc_ptr)
native_bt.put(cc_ptr)
assert(name is not None)
self._at += 1
def __getitem__(self, key):
utils._check_str(key)
- cc_ptr = native_bt.ctf_trace_get_clock_class_by_name(self._trace._ptr,
- key)
+ cc_ptr = native_bt.trace_get_clock_class_by_name(self._trace._ptr, key)
if cc_ptr is None:
raise KeyError(key)
return bt2.ClockClass._create_from_ptr(cc_ptr)
def __len__(self):
- count = native_bt.ctf_trace_get_clock_class_count(self._trace._ptr)
+ count = native_bt.trace_get_clock_class_count(self._trace._ptr)
assert(count >= 0)
return count
raise StopIteration
trace_ptr = self._trace_env._trace._ptr
- entry_name = native_bt.ctf_trace_get_environment_field_name_by_index(trace_ptr,
- self._at)
+ entry_name = native_bt.trace_get_environment_field_name_by_index(trace_ptr,
+ self._at)
assert(entry_name is not None)
self._at += 1
return entry_name
def __getitem__(self, key):
utils._check_str(key)
- value_ptr = native_bt.ctf_trace_get_environment_field_value_by_name(self._trace._ptr,
- key)
+ value_ptr = native_bt.trace_get_environment_field_value_by_name(self._trace._ptr,
+ key)
if value_ptr is None:
raise KeyError(key)
- return bt2.values._create_from_ptr(value_ptr)
+ return bt2.value._create_from_ptr(value_ptr)
def __setitem__(self, key, value):
utils._check_str(key)
value = bt2.create_value(value)
- ret = native_bt.ctf_trace_set_environment_field(self._trace._ptr,
- key, value._ptr)
+ ret = native_bt.trace_set_environment_field(self._trace._ptr,
+ key, value._ptr)
utils._handle_ret(ret, "cannot set trace class object's environment entry")
def __delitem__(self, key):
raise NotImplementedError
def __len__(self):
- count = native_bt.ctf_trace_get_environment_field_count(self._trace._ptr)
+ count = native_bt.trace_get_environment_field_count(self._trace._ptr)
assert(count >= 0)
return count
return _TraceEnvIterator(self)
-class Trace(object._Object, collections.abc.Mapping):
+class Trace(object._SharedObject, collections.abc.Mapping):
def __init__(self, name=None, native_byte_order=None, env=None,
- packet_header_field_type=None, clock_classes=None,
+ packet_header_field_class=None, clock_classes=None,
stream_classes=None):
- ptr = native_bt.ctf_trace_create()
+ ptr = native_bt.trace_create()
if ptr is None:
raise bt2.CreationError('cannot create trace class object')
if native_byte_order is not None:
self.native_byte_order = native_byte_order
- if packet_header_field_type is not None:
- self.packet_header_field_type = packet_header_field_type
+ if packet_header_field_class is not None:
+ self.packet_header_field_class = packet_header_field_class
if env is not None:
for key, value in env.items():
def __getitem__(self, key):
utils._check_int64(key)
- sc_ptr = native_bt.ctf_trace_get_stream_class_by_id(self._ptr, key)
+ sc_ptr = native_bt.trace_get_stream_class_by_id(self._ptr, key)
if sc_ptr is None:
raise KeyError(key)
return bt2.StreamClass._create_from_ptr(sc_ptr)
def __len__(self):
- count = native_bt.ctf_trace_get_stream_class_count(self._ptr)
+ count = native_bt.trace_get_stream_class_count(self._ptr)
assert(count >= 0)
return count
def add_stream_class(self, stream_class):
utils._check_type(stream_class, bt2.StreamClass)
- ret = native_bt.ctf_trace_add_stream_class(self._ptr, stream_class._ptr)
+ ret = native_bt.trace_add_stream_class(self._ptr, stream_class._ptr)
utils._handle_ret(ret, "cannot add stream class object to trace class object")
@property
def name(self):
- return native_bt.ctf_trace_get_name(self._ptr)
+ return native_bt.trace_get_name(self._ptr)
@name.setter
def name(self, name):
utils._check_str(name)
- ret = native_bt.ctf_trace_set_name(self._ptr, name)
+ ret = native_bt.trace_set_name(self._ptr, name)
utils._handle_ret(ret, "cannot set trace class object's name")
@property
def native_byte_order(self):
- bo = native_bt.ctf_trace_get_native_byte_order(self._ptr)
+ bo = native_bt.trace_get_native_byte_order(self._ptr)
assert(bo >= 0)
return bo
@native_byte_order.setter
def native_byte_order(self, native_byte_order):
utils._check_int(native_byte_order)
- ret = native_bt.ctf_trace_set_native_byte_order(self._ptr, native_byte_order)
+ ret = native_bt.trace_set_native_byte_order(self._ptr, native_byte_order)
utils._handle_ret(ret, "cannot set trace class object's native byte order")
@property
def is_static(self):
- is_static = native_bt.ctf_trace_is_static(self._ptr)
+ is_static = native_bt.trace_is_static(self._ptr)
return is_static > 0
def set_is_static(self):
- ret = native_bt.ctf_trace_set_is_static(self._ptr)
+ ret = native_bt.trace_set_is_static(self._ptr)
utils._handle_ret(ret, "cannot set trace object as static")
@property
def add_clock_class(self, clock_class):
utils._check_type(clock_class, bt2.ClockClass)
- ret = native_bt.ctf_trace_add_clock_class(self._ptr, clock_class._ptr)
+ ret = native_bt.trace_add_clock_class(self._ptr, clock_class._ptr)
utils._handle_ret(ret, "cannot add clock class object to trace class object")
@property
return _TraceStreams(self)
@property
- def packet_header_field_type(self):
- ft_ptr = native_bt.ctf_trace_get_packet_header_type(self._ptr)
+ def packet_header_field_class(self):
+ fc_ptr = native_bt.trace_get_packet_header_type(self._ptr)
- if ft_ptr is None:
+ if fc_ptr is None:
return
- return bt2.field_types._create_from_ptr(ft_ptr)
+ return bt2.field_class._create_from_ptr(fc_ptr)
- @packet_header_field_type.setter
- def packet_header_field_type(self, packet_header_field_type):
- packet_header_field_type_ptr = None
+ @packet_header_field_class.setter
+ def packet_header_field_class(self, packet_header_field_class):
+ packet_header_field_class_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
+ 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.ctf_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")
+ 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 __eq__(self, other):
if type(other) is not type(self):
self_env,
self.name,
self.native_byte_order,
- self.packet_header_field_type,
+ self.packet_header_field_class,
)
other_props = (
other_stream_classes,
other_env,
other.name,
other.native_byte_order,
- other.packet_header_field_type,
+ other.packet_header_field_class,
)
return self_props == other_props
if self.name is not None:
cpy.name = self.name
- cpy.packet_header_field_type = gen_copy_func(self.packet_header_field_type)
+ cpy.packet_header_field_class = gen_copy_func(self.packet_header_field_class)
for key, val in self.env.items():
cpy.env[key] = gen_copy_func(val)