class Clock:
+ """
+ A CTF clock allows the description of the system's clock topology, as
+ well as the definition of each clock's parameters.
+
+ :class:`Clock` objects must be registered to a :class:`Writer`
+ object (see :meth:`Writer.add_clock`), as well as be registered to
+ a :class:`StreamClass` object (see :attr:`StreamClass.clock`).
+ """
+
def __init__(self, name):
+ """
+ Creates a default CTF clock named *name*.
+
+ :exc:`ValueError` is raised on error.
+ """
+
self._c = nbt._bt_ctf_clock_create(name)
if self._c is None:
@property
def name(self):
"""
- Get the clock's name.
+ Clock name.
+
+ Set this attribute to change the clock's name.
+
+ :exc:`ValueError` is raised on error.
"""
name = nbt._bt_ctf_clock_get_name(self._c)
@property
def description(self):
"""
- Get the clock's description. None if unset.
+ Clock description (string).
+
+ Set this attribute to change the clock's description.
+
+ :exc:`ValueError` is raised on error.
"""
return nbt._bt_ctf_clock_get_description(self._c)
@description.setter
def description(self, desc):
- """
- Set the clock's description. The description appears in the clock's TSDL
- meta-data.
- """
-
ret = nbt._bt_ctf_clock_set_description(self._c, str(desc))
if ret < 0:
@property
def frequency(self):
"""
- Get the clock's frequency (Hz).
+ Clock frequency in Hz (integer).
+
+ Set this attribute to change the clock's frequency.
+
+ :exc:`ValueError` is raised on error.
"""
freq = nbt._bt_ctf_clock_get_frequency(self._c)
@frequency.setter
def frequency(self, freq):
- """
- Set the clock's frequency (Hz).
- """
-
ret = nbt._bt_ctf_clock_set_frequency(self._c, freq)
if ret < 0:
@property
def precision(self):
"""
- Get the clock's precision (in clock ticks).
+ Clock precision in clock ticks (integer).
+
+ Set this attribute to change the clock's precision.
+
+ :exc:`ValueError` is raised on error.
"""
precision = nbt._bt_ctf_clock_get_precision(self._c)
@precision.setter
def precision(self, precision):
- """
- Set the clock's precision (in clock ticks).
- """
-
ret = nbt._bt_ctf_clock_set_precision(self._c, precision)
@property
def offset_seconds(self):
"""
- Get the clock's offset in seconds from POSIX.1 Epoch.
+ Clock offset in seconds since POSIX.1 Epoch (integer).
+
+ Set this attribute to change the clock's offset in seconds.
+
+ :exc:`ValueError` is raised on error.
"""
offset_s = nbt._bt_ctf_clock_get_offset_s(self._c)
@offset_seconds.setter
def offset_seconds(self, offset_s):
- """
- Set the clock's offset in seconds from POSIX.1 Epoch.
- """
-
ret = nbt._bt_ctf_clock_set_offset_s(self._c, offset_s)
if ret < 0:
@property
def offset(self):
"""
- Get the clock's offset in ticks from POSIX.1 Epoch + offset in seconds.
+ Clock offset in ticks since (POSIX.1 Epoch +
+ :attr:`offset_seconds`).
+
+ Set this attribute to change the clock's offset.
+
+ :exc:`ValueError` is raised on error.
"""
offset = nbt._bt_ctf_clock_get_offset(self._c)
@offset.setter
def offset(self, offset):
- """
- Set the clock's offset in ticks from POSIX.1 Epoch + offset in seconds.
- """
-
ret = nbt._bt_ctf_clock_set_offset(self._c, offset)
if ret < 0:
@property
def absolute(self):
"""
- Get a clock's absolute attribute. A clock is absolute if the clock
- is a global reference across the trace's other clocks.
+ ``True`` if this clock is absolute, i.e. if the clock is a
+ global reference across the other clocks of the trace.
+
+ Set this attribute to change the clock's absolute state
+ (boolean).
+
+ :exc:`ValueError` is raised on error.
"""
is_absolute = nbt._bt_ctf_clock_get_is_absolute(self._c)
@absolute.setter
def absolute(self, is_absolute):
- """
- Set a clock's absolute attribute. A clock is absolute if the clock
- is a global reference across the trace's other clocks.
- """
-
ret = nbt._bt_ctf_clock_set_is_absolute(self._c, int(is_absolute))
if ret < 0:
- raise ValueError("Could not set the clock's absolute attribute.")
+ raise ValueError("Could not set the clock absolute attribute.")
@property
def uuid(self):
"""
- Get a clock's UUID (an object of type UUID).
+ Clock UUID (an :class:`uuid.UUID` object).
+
+ Set this attribute to change the clock's UUID.
+
+ :exc:`ValueError` is raised on error.
"""
uuid_list = []
@uuid.setter
def uuid(self, uuid):
- """
- Set a clock's UUID (an object of type UUID).
- """
-
uuid_bytes = uuid.bytes
if len(uuid_bytes) != 16:
@property
def time(self):
"""
- Get the current time in nanoseconds since the clock's origin (offset and
- offset_s attributes).
+ Clock current time; nanoseconds (integer) since clock origin
+ (POSIX.1 Epoch + :attr:`offset_seconds` + :attr:`offset`).
+
+ Set this attribute to change the clock's current time.
+
+ :exc:`ValueError` is raised on error.
"""
time = nbt._bt_ctf_clock_get_time(self._c)
@time.setter
def time(self, time):
- """
- Set the current time in nanoseconds since the clock's origin (offset and
- offset_s attributes). The clock's value will be sampled as events are
- appended to a stream.
- """
-
ret = nbt._bt_ctf_clock_set_time(self._c, time)
if ret < 0:
raise ValueError("Invalid time value.")
+class IntegerBase:
+ """
+ Display base of an integer.
+ """
+
+ #: Unknown
+ INTEGER_BASE_UNKNOWN = -1
+
+ #: Binary
+ INTEGER_BASE_BINARY = 2
+
+ #: Octal
+ INTEGER_BASE_OCTAL = 8
+
+ #: Decimal
+ INTEGER_BASE_DECIMAL = 10
+
+ #: Hexadecimal
+ INTEGER_BASE_HEXADECIMAL = 16
+
+
class FieldDeclaration:
"""
- FieldDeclaration should not be instantiated directly. Instantiate
- one of the concrete FieldDeclaration classes.
+ Base class of all field declarations. This class is not meant to
+ be instantiated by the user; use one of the concrete field
+ declaration subclasses instead.
"""
- class IntegerBase:
- # These values are based on the bt_ctf_integer_base enum
- # declared in event-types.h.
- INTEGER_BASE_UNKNOWN = -1
- INTEGER_BASE_BINARY = 2
- INTEGER_BASE_OCTAL = 8
- INTEGER_BASE_DECIMAL = 10
- INTEGER_BASE_HEXADECIMAL = 16
+ class IntegerBase(IntegerBase):
+ pass
def __init__(self):
if self._ft is None:
@property
def alignment(self):
"""
- Get the field declaration's alignment. Returns -1 on error.
+ Field alignment in bits (integer).
+
+ Set this attribute to change this field's alignment.
+
+ :exc:`ValueError` is raised on error.
"""
return nbt._bt_ctf_field_type_get_alignment(self._ft)
@alignment.setter
def alignment(self, alignment):
- """
- Set the field declaration's alignment. Defaults to 1 (bit-aligned). However,
- some types, such as structures and string, may impose other alignment
- constraints.
- """
-
ret = nbt._bt_ctf_field_type_set_alignment(self._ft, alignment)
if ret < 0:
@property
def byte_order(self):
"""
- Get the field declaration's byte order. One of the ByteOrder's constant.
+ Field byte order (one of :class:`babeltrace.common.ByteOrder`
+ constants).
+
+ Set this attribute to change this field's byte order.
+
+ :exc:`ValueError` is raised on error.
"""
return nbt._bt_ctf_field_type_get_byte_order(self._ft)
@byte_order.setter
def byte_order(self, byte_order):
- """
- Set the field declaration's byte order. Use constants defined in the ByteOrder
- class.
- """
-
ret = nbt._bt_ctf_field_type_set_byte_order(self._ft, byte_order)
if ret < 0:
class IntegerFieldDeclaration(FieldDeclaration):
+ """
+ Integer field declaration.
+ """
+
def __init__(self, size):
"""
- Create a new integer field declaration of the given size.
+ Creates an integer field declaration of size *size* bits.
+
+ :exc:`ValueError` is raised on error.
"""
+
self._ft = nbt._bt_ctf_field_type_integer_create(size)
super().__init__()
@property
def size(self):
"""
- Get an integer's size.
+ Integer size in bits (integer).
+
+ Set this attribute to change this integer's size.
+
+ :exc:`ValueError` is raised on error.
"""
ret = nbt._bt_ctf_field_type_integer_get_size(self._ft)
if ret < 0:
- raise ValueError("Could not get Integer's size attribute.")
+ raise ValueError("Could not get Integer size attribute.")
else:
return ret
@property
def signed(self):
"""
- Get an integer's signedness attribute.
+ ``True`` if this integer is signed.
+
+ Set this attribute to change this integer's signedness
+ (boolean).
+
+ :exc:`ValueError` is raised on error.
"""
ret = nbt._bt_ctf_field_type_integer_get_signed(self._ft)
if ret < 0:
- raise ValueError("Could not get Integer's signed attribute.")
+ raise ValueError("Could not get Integer signed attribute.")
elif ret > 0:
return True
else:
@signed.setter
def signed(self, signed):
- """
- Set an integer's signedness attribute.
- """
-
ret = nbt._bt_ctf_field_type_integer_set_signed(self._ft, signed)
if ret < 0:
- raise ValueError("Could not set Integer's signed attribute.")
+ raise ValueError("Could not set Integer signed attribute.")
@property
def base(self):
"""
- Get the integer's base used to pretty-print the resulting trace.
- Returns a constant from the FieldDeclaration.IntegerBase class.
+ Integer display base (one of :class:`IntegerBase` constants).
+
+ Set this attribute to change this integer's display base.
+
+ :exc:`ValueError` is raised on error.
"""
return nbt._bt_ctf_field_type_integer_get_base(self._ft)
@base.setter
def base(self, base):
- """
- Set the integer's base used to pretty-print the resulting trace.
- The base must be a constant of the FieldDeclarationIntegerBase class.
- """
-
ret = nbt._bt_ctf_field_type_integer_set_base(self._ft, base)
if ret < 0:
- raise ValueError("Could not set Integer's base.")
+ raise ValueError("Could not set Integer base.")
@property
def encoding(self):
"""
- Get the integer's encoding (one of the constants of the
- CTFStringEncoding class).
- Returns a constant from the CTFStringEncoding class.
+ Integer encoding (one of
+ :class:`babeltrace.common.CTFStringEncoding` constants).
+
+ Set this attribute to change this integer's encoding.
+
+ :exc:`ValueError` is raised on error.
"""
return nbt._bt_ctf_field_type_integer_get_encoding(self._ft)
@encoding.setter
def encoding(self, encoding):
- """
- An integer encoding may be set to signal that the integer must be printed
- as a text character. Must be a constant from the CTFStringEncoding class.
- """
-
ret = nbt._bt_ctf_field_type_integer_set_encoding(self._ft, encoding)
if ret < 0:
- raise ValueError("Could not set Integer's encoding.")
+ raise ValueError("Could not set Integer encoding.")
class EnumerationFieldDeclaration(FieldDeclaration):
+ """
+ Enumeration field declaration. A CTF enumeration maps labels to
+ ranges of integers.
+ """
+
def __init__(self, integer_type):
"""
- Create a new enumeration field declaration with the given underlying container type.
+ Creates an enumeration field declaration, with *integer_type*
+ being the underlying :class:`IntegerFieldDeclaration` for storing
+ the integer.
+
+ :exc:`ValueError` is raised on error.
"""
+
isinst = isinstance(integer_type, IntegerFieldDeclaration)
if integer_type is None or not isinst:
@property
def container(self):
"""
- Get the enumeration's underlying container type.
+ Underlying container (:class:`IntegerFieldDeclaration`).
+
+ :exc:`TypeError` is raised on error.
"""
ret = nbt._bt_ctf_field_type_enumeration_get_container_type(self._ft)
def add_mapping(self, name, range_start, range_end):
"""
- Add a mapping to the enumeration. The range's values are inclusive.
+ Adds a mapping to the enumeration field declaration, from the
+ label named *name* to range [*range_start*, *range_end*], where
+ *range_start* and *range_end* are integers included in the
+ range.
+
+ :exc:`ValueError` is raised on error.
"""
if range_start < 0 or range_end < 0:
@property
def mappings(self):
"""
- Generator returning instances of EnumerationMapping.
+ Generates the mappings of this enumeration field declaration
+ (:class:`EnumerationMapping` objects).
+
+ :exc:`TypeError` is raised on error.
"""
signed = self.container.signed
def get_mapping_by_name(self, name):
"""
- Get a mapping by name (EnumerationMapping).
+ Returns the :class:`EnumerationMapping` object for the label
+ named *name*.
+
+ :exc:`TypeError` is raised on error.
"""
index = nbt._bt_ctf_field_type_enumeration_get_mapping_index_by_name(self._ft, name)
def get_mapping_by_value(self, value):
"""
- Get a mapping by value (EnumerationMapping).
+ Returns the :class:`EnumerationMapping` object for the value
+ *value* (integer).
+
+ :exc:`TypeError` is raised on error.
"""
if value < 0:
return EnumerationMapping(name, range_start, range_end)
-class FloatFieldDeclaration(FieldDeclaration):
+class FloatingPointFieldDeclaration(FieldDeclaration):
+ """
+ Floating point number field declaration.
+
+ A CTF floating point number is a made of three sections: the sign
+ bit, the exponent bits, and the mantissa bits. The most significant
+ bit of the resulting binary word is the sign bit, and is included
+ in the number of mantissa bits.
+
+ For example, the
+ `IEEE 754 <http://en.wikipedia.org/wiki/IEEE_floating_point>`_
+ single precision floating point number is represented on a 32-bit
+ word using an 8-bit exponent (``e``) and a 24-bit mantissa (``m``),
+ the latter count including the sign bit (``s``)::
+
+ s eeeeeeee mmmmmmmmmmmmmmmmmmmmmmm
+
+ The IEEE 754 double precision floating point number uses an
+ 11-bit exponent and a 53-bit mantissa.
+ """
+
+ #: IEEE 754 single precision floating point number exponent size
FLT_EXP_DIG = 8
+
+ #: IEEE 754 double precision floating point number exponent size
DBL_EXP_DIG = 11
+
+ #: IEEE 754 single precision floating point number mantissa size
FLT_MANT_DIG = 24
+
+ #: IEEE 754 double precision floating point number mantissa size
DBL_MANT_DIG = 53
def __init__(self):
"""
- Create a new floating point field declaration.
+ Creates a floating point number field declaration.
+
+ :exc:`ValueError` is raised on error.
"""
self._ft = nbt._bt_ctf_field_type_floating_point_create()
@property
def exponent_digits(self):
"""
- Get the number of exponent digits used to store the floating point field.
+ Floating point number exponent section size in bits (integer).
+
+ Set this attribute to change the floating point number's
+ exponent section's size. You may use :attr:`FLT_EXP_DIG` or
+ :attr:`DBL_EXP_DIG` for IEEE 754 floating point numbers.
+
+ :exc:`ValueError` is raised on error.
"""
ret = nbt._bt_ctf_field_type_floating_point_get_exponent_digits(self._ft)
@exponent_digits.setter
def exponent_digits(self, exponent_digits):
- """
- Set the number of exponent digits to use to store the floating point field.
- The only values currently supported are FLT_EXP_DIG and DBL_EXP_DIG which
- are defined as constants of this class.
- """
-
ret = nbt._bt_ctf_field_type_floating_point_set_exponent_digits(self._ft,
exponent_digits)
@property
def mantissa_digits(self):
"""
- Get the number of mantissa digits used to store the floating point field.
+ Floating point number mantissa section size in bits (integer).
+
+ Set this attribute to change the floating point number's
+ mantissa section's size. You may use :attr:`FLT_MANT_DIG` or
+ :attr:`DBL_MANT_DIG` for IEEE 754 floating point numbers.
+
+ :exc:`ValueError` is raised on error.
"""
ret = nbt._bt_ctf_field_type_floating_point_get_mantissa_digits(self._ft)
@mantissa_digits.setter
def mantissa_digits(self, mantissa_digits):
- """
- Set the number of mantissa digits to use to store the floating point field.
- The only values currently supported are FLT_MANT_DIG and DBL_MANT_DIG which
- are defined as constants of this class.
- """
-
ret = nbt._bt_ctf_field_type_floating_point_set_mantissa_digits(self._ft,
mantissa_digits)
raise ValueError("Could not set mantissa digit count.")
-class FloatingPointFieldDeclaration(FloatFieldDeclaration):
+class FloatFieldDeclaration(FloatingPointFieldDeclaration):
pass
class StructureFieldDeclaration(FieldDeclaration):
+ """
+ Structure field declaration, i.e. an ordered mapping from field
+ names to field declarations.
+ """
+
def __init__(self):
"""
- Create a new structure field declaration.
+ Creates an empty structure field declaration.
+
+ :exc:`ValueError` is raised on error.
"""
self._ft = nbt._bt_ctf_field_type_structure_create()
def add_field(self, field_type, field_name):
"""
- Add a field of type "field_type" to the structure.
+ Appends one :class:`FieldDeclaration` *field_type* named
+ *field_name* to the structure's ordered map.
+
+ :exc:`ValueError` is raised on error.
"""
ret = nbt._bt_ctf_field_type_structure_add_field(self._ft,
@property
def fields(self):
"""
- Generator returning the structure's field as tuples of (field name, field declaration).
+ Generates the (field name, :class:`FieldDeclaration`) pairs
+ of this structure.
+
+ :exc:`TypeError` is raised on error.
"""
count = nbt._bt_ctf_field_type_structure_get_field_count(self._ft)
def get_field_by_name(self, name):
"""
- Get a field declaration by name (FieldDeclaration).
+ Returns the :class:`FieldDeclaration` mapped to the field name
+ *name* in this structure.
+
+ :exc:`TypeError` is raised on error.
"""
field_type_native = nbt._bt_ctf_field_type_structure_get_field_type_by_name(self._ft, name)
class VariantFieldDeclaration(FieldDeclaration):
+ """
+ Variant field declaration.
+
+ A CTF variant is a dynamic selection between different fields.
+ The value of a *tag* (a CTF enumeration) determines what is the
+ current selected field. All the possible fields must be added to
+ its field declaration before using an actual variant field.
+ """
+
def __init__(self, enum_tag, tag_name):
"""
- Create a new variant field declaration.
+ Creates an empty variant field declaration with tag field
+ declaration *enum_tag* (instance of
+ :class:`EnumerationFieldDeclaration`) named *tag_name*
+ (string).
+
+ :exc:`ValueError` is raised on error.
"""
isinst = isinstance(enum_tag, EnumerationFieldDeclaration)
@property
def tag_name(self):
"""
- Get the variant's tag name.
+ Variant field declaration tag name.
+
+ :exc:`TypeError` is raised on error.
"""
ret = nbt._bt_ctf_field_type_variant_get_tag_name(self._ft)
@property
def tag_type(self):
"""
- Get the variant's tag type.
+ Variant field declaration tag field declaration
+ (:class:`EnumerationFieldDeclaration` object).
+
+ :exc:`TypeError` is raised on error.
"""
ret = nbt._bt_ctf_field_type_variant_get_tag_type(self._ft)
def add_field(self, field_type, field_name):
"""
- Add a field of type "field_type" to the variant.
+ Registers the :class:`FieldDeclaration` object *field_type*
+ as the variant's selected type when the variant's tag's current
+ label is *field_name*.
+
+ :exc:`ValueError` is raised on error.
"""
ret = nbt._bt_ctf_field_type_variant_add_field(self._ft,
@property
def fields(self):
"""
- Generator returning the variant's field as tuples of (field name, field declaration).
+ Generates the (field name, :class:`FieldDeclaration`) pairs
+ of this variant field declaration.
+
+ :exc:`TypeError` is raised on error.
"""
count = nbt._bt_ctf_field_type_variant_get_field_count(self._ft)
def get_field_by_name(self, name):
"""
- Get a field declaration by name (FieldDeclaration).
+ Returns the :class:`FieldDeclaration` selected when the
+ variant's tag's current label is *name*.
+
+ :exc:`TypeError` is raised on error.
"""
field_type_native = nbt._bt_ctf_field_type_variant_get_field_type_by_name(self._ft,
def get_field_from_tag(self, tag):
"""
- Get a field declaration from tag (EnumerationField).
+ Returns the :class:`FieldDeclaration` selected by the current
+ label of the :class:`EnumerationField` *tag*.
+
+ :exc:`TypeError` is raised on error.
"""
field_type_native = nbt._bt_ctf_field_type_variant_get_field_type_from_tag(self._ft, tag._f)
class ArrayFieldDeclaration(FieldDeclaration):
+ """
+ Static array field declaration.
+ """
+
def __init__(self, element_type, length):
"""
- Create a new array field declaration.
+ Creates a static array field declaration of *length*
+ elements of type *element_type* (:class:`FieldDeclaration`).
+
+ :exc:`ValueError` is raised on error.
"""
self._ft = nbt._bt_ctf_field_type_array_create(element_type._ft,
@property
def element_type(self):
"""
- Get the array's element type.
+ Type of the elements of this this static array (subclass of
+ :class:`FieldDeclaration`).
+
+ :exc:`TypeError` is raised on error.
"""
ret = nbt._bt_ctf_field_type_array_get_element_type(self._ft)
@property
def length(self):
"""
- Get the array's length.
+ Length of this static array (integer).
+
+ :exc:`TypeError` is raised on error.
"""
ret = nbt._bt_ctf_field_type_array_get_length(self._ft)
class SequenceFieldDeclaration(FieldDeclaration):
+ """
+ Sequence (dynamic array) field declaration.
+ """
+
def __init__(self, element_type, length_field_name):
"""
- Create a new sequence field declaration.
+ Creates a sequence field declaration of
+ elements of type *element_type* (:class:`FieldDeclaration`).
+ The length of a sequence field based on this sequence field
+ declaration is obtained by retrieving the dynamic integer
+ value of the field named *length_field_name*.
+
+ :exc:`ValueError` is raised on error.
"""
self._ft = nbt._bt_ctf_field_type_sequence_create(element_type._ft,
@property
def element_type(self):
"""
- Get the sequence's element type.
+ Type of the elements of this sequence (subclass of
+ :class:`FieldDeclaration`).
+
+ :exc:`TypeError` is raised on error.
"""
ret = nbt._bt_ctf_field_type_sequence_get_element_type(self._ft)
@property
def length_field_name(self):
"""
- Get the sequence's length field name.
+ Name of the integer field defining the dynamic length of
+ sequence fields based on this sequence field declaration.
+
+ :exc:`TypeError` is raised on error.
"""
ret = nbt._bt_ctf_field_type_sequence_get_length_field_name(self._ft)
class StringFieldDeclaration(FieldDeclaration):
+ """
+ String (NULL-terminated array of bytes) field declaration.
+ """
+
def __init__(self):
"""
- Create a new string field declaration.
+ Creates a string field declaration.
+
+ :exc:`ValueError` is raised on error.
"""
self._ft = nbt._bt_ctf_field_type_string_create()
@property
def encoding(self):
"""
- Get a string declaration's encoding (a constant from the CTFStringEncoding class).
+ String encoding (one of
+ :class:`babeltrace.common.CTFStringEncoding` constants).
+
+ Set this attribute to change this string's encoding.
+
+ :exc:`ValueError` is raised on error.
"""
return nbt._bt_ctf_field_type_string_get_encoding(self._ft)
@encoding.setter
def encoding(self, encoding):
- """
- Set a string declaration's encoding. Must be a constant from the CTFStringEncoding class.
- """
-
ret = nbt._bt_ctf_field_type_string_set_encoding(self._ft, encoding)
if ret < 0:
raise ValueError("Could not set string encoding.")
class Field:
"""
- Base class, do not instantiate.
+ Base class of all fields. This class is not meant to be
+ instantiated by the user, and neither are its subclasses. Use
+ :meth:`Event.payload` to access specific, concrete fields of
+ an event.
"""
def __init__(self, field_type):
@property
def declaration(self):
+ """
+ Field declaration (subclass of :class:`FieldDeclaration`).
+
+ :exc:`TypeError` is raised on error.
+ """
+
native_field_type = nbt._bt_ctf_field_get_type(self._f)
if native_field_type is None:
class IntegerField(Field):
+ """
+ Integer field, based on an :class:`IntegerFieldDeclaration` object.
+ """
+
@property
def value(self):
"""
- Get an integer field's value.
+ Integer value (:class:`int`).
+
+ Set this attribute to change the integer field's value.
+
+ :exc:`ValueError` or :exc:`TypeError` are raised on error.
"""
signedness = nbt._bt_python_field_integer_get_signedness(self._f)
@value.setter
def value(self, value):
- """
- Set an integer field's value.
- """
-
if not isinstance(value, int):
raise TypeError("IntegerField's value must be an int")
class EnumerationField(Field):
+ """
+ Enumeration field, based on an
+ :class:`EnumerationFieldDeclaration` object.
+ """
+
@property
def container(self):
"""
- Return the enumeration's underlying container field (an integer field).
+ Underlying container (:class:`IntegerField`).
+
+ :exc:`TypeError` is raised on error.
"""
container = IntegerField.__new__(IntegerField)
@property
def value(self):
"""
- Get the enumeration field's mapping name.
+ Current label of this enumeration field (:class:`str`).
+
+ Set this attribute to an integer (:class:`int`) to change the
+ enumeration field's value.
+
+ :exc:`ValueError` is raised on error.
"""
value = nbt._bt_ctf_field_enumeration_get_mapping_name(self._f)
if value is None:
- raise ValueError("Could not get enumeration's mapping name.")
+ raise ValueError("Could not get enumeration mapping name.")
return value
@value.setter
def value(self, value):
- """
- Set the enumeration field's value. Must be an integer as mapping names
- may be ambiguous.
- """
-
if not isinstance(value, int):
raise TypeError("EnumerationField value must be an int")
class FloatingPointField(Field):
+ """
+ Floating point number field, based on a
+ :class:`FloatingPointFieldDeclaration` object.
+ """
+
@property
def value(self):
"""
- Get a floating point field's value.
+ Floating point number value (:class:`float`).
+
+ Set this attribute to change the floating point number field's
+ value.
+
+ :exc:`ValueError` or :exc:`TypeError` are raised on error.
"""
ret, value = nbt._bt_ctf_field_floating_point_get_value(self._f)
@value.setter
def value(self, value):
- """
- Set a floating point field's value.
- """
-
if not isinstance(value, int) and not isinstance(value, float):
raise TypeError("Value must be either a float or an int")
class StructureField(Field):
+ """
+ Structure field, based on a
+ :class:`StructureFieldDeclaration` object.
+ """
+
def field(self, field_name):
"""
- Get the structure's field corresponding to the provided field name.
+ Returns the structure :class:`Field` named *field_name*.
+
+ :exc:`ValueError` is raised on error.
"""
native_instance = nbt._bt_ctf_field_structure_get_field(self._f,
class VariantField(Field):
+ """
+ Variant field, based on a
+ :class:`VariantFieldDeclaration` object.
+ """
+
def field(self, tag):
"""
- Return the variant's selected field. The "tag" field is the selector enum field.
+ Returns the :class:`Field` selected by the current label of
+ *tag* (:class:`EnumerationField`).
+
+ :exc:`ValueError` is raised on error.
"""
native_instance = nbt._bt_ctf_field_variant_get_field(self._f, tag._f)
class ArrayField(Field):
+ """
+ Static array field, based on an
+ :class:`ArrayFieldDeclaration` object.
+ """
+
def field(self, index):
"""
- Return the array's field at position "index".
+ Returns the :class:`Field` at index *index* in this static
+ array.
+
+ :exc:`IndexError` is raised on error.
"""
native_instance = nbt._bt_ctf_field_array_get_field(self._f, index)
projects / babeltrace.git / blobdiff