Fix (Python bindings): Return a string if a sequence's element are chars

[babeltrace.git] / bindings / python / babeltrace.i.in

diff --git a/bindings/python/babeltrace.i.in b/bindings/python/babeltrace.i.in
index 318b9b8c5ebcf688ad63e84fa194cb606a22f550..5a06f0ba4639db4ca12a76723b5c5198e5779be9 100644 (file)
--- a/bindings/python/babeltrace.i.in
+++ b/bindings/python/babeltrace.i.in
@@ -60,6 +60,7 @@ trace to it."
 typedef unsigned long long uint64_t;
 typedef long long int64_t;
 typedef int bt_intern_str;
 typedef unsigned long long uint64_t;
 typedef long long int64_t;
 typedef int bt_intern_str;

+typedef int64_t ssize_t;

 
 /* =================================================================
                PYTHON-COMPLEMENTS.H
 
 /* =================================================================
                PYTHON-COMPLEMENTS.H


@@ -90,6 +91,12 @@ struct definition_array *_bt_python_get_array_from_def(
                struct bt_definition *field);
 struct definition_sequence *_bt_python_get_sequence_from_def(
                struct bt_definition *field);
                struct bt_definition *field);
 struct definition_sequence *_bt_python_get_sequence_from_def(
                struct bt_definition *field);

+struct bt_declaration *_bt_python_get_array_element_declaration(
+               struct bt_declaration *field);
+struct bt_declaration *_bt_python_get_sequence_element_declaration(
+               struct bt_declaration *field);
+const char *_bt_python_get_array_string(struct bt_definition *field);
+const char *_bt_python_get_sequence_string(struct bt_definition *field);

 int _bt_python_field_integer_get_signedness(const struct bt_ctf_field *field);
 enum ctf_type_id _bt_python_get_field_type(const struct bt_ctf_field *field);
 
 int _bt_python_field_integer_get_signedness(const struct bt_ctf_field *field);
 enum ctf_type_id _bt_python_get_field_type(const struct bt_ctf_field *field);
 


@@ -386,7 +393,7 @@ int bt_ctf_event_get_handle_id(const struct bt_ctf_event *event);
 
 %pythoncode%{
 
 
 %pythoncode%{
 

-# Based on enum bt_clock_type in clock-type.h­
+# Based on enum bt_clock_type in clock-type.h

 class ClockType:
        CLOCK_CYCLES = 0
        CLOCK_REAL = 1
 class ClockType:
        CLOCK_CYCLES = 0
        CLOCK_REAL = 1


@@ -426,6 +433,22 @@ class TraceHandle(object):
                return _bt_trace_handle_get_timestamp_end(
                        self._trace_collection._tc, self._id, ClockType.CLOCK_REAL)
 
                return _bt_trace_handle_get_timestamp_end(
                        self._trace_collection._tc, self._id, ClockType.CLOCK_REAL)
 

+       @property
+       def events(self):
+               """
+               Generator returning all events (EventDeclaration) in a trace.
+               """
+               ret = _bt_python_event_decl_listcaller(self.id, self._trace_collection._tc)
+
+               if not isinstance(ret, list):
+                       return
+
+               ptr_list, count = ret
+               for i in range(count):
+                       tmp = EventDeclaration.__new__(EventDeclaration)
+                       tmp._ed =  _bt_python_decl_one_from_list(ptr_list, i)
+                       yield tmp
+

 %}
 
 
 %}
 
 


@@ -493,6 +516,8 @@ struct bt_ctf_event *bt_ctf_iter_read_event(struct bt_ctf_iter *iter);
                const struct bt_ctf_field_decl *field);
 %rename("_bt_ctf_get_decl_from_def") bt_ctf_get_decl_from_def(
                const struct bt_definition *field);
                const struct bt_ctf_field_decl *field);
 %rename("_bt_ctf_get_decl_from_def") bt_ctf_get_decl_from_def(
                const struct bt_definition *field);

+%rename("_bt_ctf_get_decl_from_field_decl") bt_ctf_get_decl_from_field_decl(
+               const struct bt_ctf_field_decl *field);

 %rename("_bt_array_index") bt_array_index(struct definition_array *array, uint64_t i);
 %rename("_bt_sequence_len")  bt_sequence_len(struct definition_sequence *sequence);
 %rename("_bt_sequence_index") bt_sequence_index(struct definition_sequence *sequence, uint64_t i);
 %rename("_bt_array_index") bt_array_index(struct definition_array *array, uint64_t i);
 %rename("_bt_sequence_len")  bt_sequence_len(struct definition_sequence *sequence);
 %rename("_bt_sequence_index") bt_sequence_index(struct definition_sequence *sequence, uint64_t i);


@@ -531,6 +556,7 @@ int bt_ctf_field_get_error(void);
 const char *bt_ctf_get_decl_event_name(const struct bt_ctf_event_decl *event);
 const char *bt_ctf_get_decl_field_name(const struct bt_ctf_field_decl *field);
 const struct bt_declaration *bt_ctf_get_decl_from_def(const struct bt_definition *field);
 const char *bt_ctf_get_decl_event_name(const struct bt_ctf_event_decl *event);
 const char *bt_ctf_get_decl_field_name(const struct bt_ctf_field_decl *field);
 const struct bt_declaration *bt_ctf_get_decl_from_def(const struct bt_definition *field);

+const struct bt_declaration *bt_ctf_get_decl_from_field_decl(const struct bt_ctf_field_decl *field);

 uint64_t bt_sequence_len(struct definition_sequence *sequence);
 struct bt_definition *bt_sequence_index(struct definition_sequence *sequence, uint64_t i);
 uint64_t bt_ctf_get_struct_field_count(const struct bt_definition *structure);
 uint64_t bt_sequence_len(struct definition_sequence *sequence);
 struct bt_definition *bt_sequence_index(struct definition_sequence *sequence, uint64_t i);
 uint64_t bt_ctf_get_struct_field_count(const struct bt_definition *structure);


@@ -544,6 +570,14 @@ class CTFStringEncoding:
        ASCII = 2
        UNKNOWN = 3
 
        ASCII = 2
        UNKNOWN = 3
 

+# Based on the enum in ctf-writer/writer.h
+class ByteOrder:
+       BYTE_ORDER_NATIVE = 0
+       BYTE_ORDER_LITTLE_ENDIAN = 1
+       BYTE_ORDER_BIG_ENDIAN = 2
+       BYTE_ORDER_NETWORK = 3
+       BYTE_ORDER_UNKNOWN = 4 # Python-specific entry
+

 #enum equivalent, accessible constants
 #These are taken directly from ctf/events.h
 #All changes to enums must also be made here
 #enum equivalent, accessible constants
 #These are taken directly from ctf/events.h
 #All changes to enums must also be made here


@@ -560,8 +594,8 @@ class CTFTypeId:
        SEQUENCE = 9
        NR_CTF_TYPES = 10
 
        SEQUENCE = 9
        NR_CTF_TYPES = 10
 

-       def get_type_name(id):
-               name = "UNKNOWN"
+       def type_name(id):
+               name = "UNKNOWN_TYPE"

                constants = [attr for attr in dir(CTFTypeId) if not callable(getattr(CTFTypeId, attr)) and not attr.startswith("__")]
                for attr in constants:
                        if getattr(CTFTypeId, attr) == id:
                constants = [attr for attr in dir(CTFTypeId) if not callable(getattr(CTFTypeId, attr)) and not attr.startswith("__")]
                for attr in constants:
                        if getattr(CTFTypeId, attr) == id:


@@ -569,7 +603,7 @@ class CTFTypeId:
                                break
                return name
 
                                break
                return name
 

-class scope:
+class CTFScope:

        TRACE_PACKET_HEADER = 0
        STREAM_PACKET_CONTEXT = 1
        STREAM_EVENT_HEADER = 2
        TRACE_PACKET_HEADER = 0
        STREAM_PACKET_CONTEXT = 1
        STREAM_EVENT_HEADER = 2


@@ -577,9 +611,18 @@ class scope:
        EVENT_CONTEXT = 4
        EVENT_FIELDS = 5
 
        EVENT_CONTEXT = 4
        EVENT_FIELDS = 5
 

+       def scope_name(scope):
+               name = "UNKNOWN_SCOPE"
+               constants = [attr for attr in dir(CTFScope) if not callable(getattr(CTFScope, attr)) and not attr.startswith("__")]
+               for attr in constants:
+                       if getattr(CTFScope, attr) == scope:
+                               name = attr
+                               break
+               return name
+

 # Priority of the scopes when searching for event fields
 # Priority of the scopes when searching for event fields

-_scopes = [scope.EVENT_FIELDS, scope.EVENT_CONTEXT, scope.STREAM_EVENT_CONTEXT,
-       scope.STREAM_EVENT_HEADER, scope.STREAM_PACKET_CONTEXT, scope.TRACE_PACKET_HEADER]
+_scopes = [CTFScope.EVENT_FIELDS, CTFScope.EVENT_CONTEXT, CTFScope.STREAM_EVENT_CONTEXT,
+       CTFScope.STREAM_EVENT_HEADER, CTFScope.STREAM_PACKET_CONTEXT, CTFScope.TRACE_PACKET_HEADER]

 
 import collections
 class Event(collections.Mapping):
 
 import collections
 class Event(collections.Mapping):


@@ -762,55 +805,183 @@ class FieldError(Exception):
        def __str__(self):
                return repr(self.value)
 
        def __str__(self):
                return repr(self.value)
 

-class EventDecl(object):
+class EventDeclaration(object):

        """Event declaration class.  Do not instantiate."""
 
        def __init__(self):
        """Event declaration class.  Do not instantiate."""
 
        def __init__(self):

-               raise NotImplementedError("EventDecl cannot be instantiated")
+               raise NotImplementedError("EventDeclaration cannot be instantiated")

 
 

-       def get_name(self):
+       @property
+       def name(self):

                """Return the name of the event or None on error"""
                """Return the name of the event or None on error"""

-               return _bt_ctf_get_decl_event_name(self._d)
+               return _bt_ctf_get_decl_event_name(self._ed)

 
 

-       def fields(self, scope):
+       @property
+       def fields(self):

                """
                """

-               Return a list of FieldDecl
-               Return None on error.
+               Generator returning all FieldDeclarations of an event, going through
+               each scope in the following order:
+               1) EVENT_FIELDS
+               2) EVENT_CONTEXT
+               3) STREAM_EVENT_CONTEXT
+               4) STREAM_EVENT_HEADER
+               5) STREAM_PACKET_CONTEXT
+               6) TRACE_PACKET_HEADER

                """
                """

-               ptr_list = _by_python_field_decl_listcaller(self._d, scope)
+               for scope in _scopes:
+                       for declaration in self.fields_scope(scope):
+                               yield declaration

 
 

-               if ptr_list is None:
-                       return None
+       def fields_scope(self, scope):
+               """
+               Generator returning FieldDeclarations of the current event in scope.
+               """
+               ret = _by_python_field_decl_listcaller(self._ed, scope)

 
 

-               decl_list = []
-               i = 0
-               while True:
-                       tmp = FieldDecl.__new__(FieldDecl)
-                       tmp._d =  _bt_python_field_decl_one_from_list(
-                               ptr_list, i)
+               if not isinstance(ret, list):
+                       return

 
 

-                       if tmp._d is None:
-                               #Last item of list is None
-                               break
+               list_ptr, count = ret
+               for i in range(count):
+                       field_declaration_ptr = _bt_python_field_decl_one_from_list(list_ptr, i)
+                       if field_declaration_ptr is not None:
+                               declaration_ptr = _bt_ctf_get_decl_from_field_decl(field_declaration_ptr)
+                               field_declaration = _create_field_declaration(declaration_ptr, _bt_ctf_get_decl_field_name(field_declaration_ptr), scope)
+                               yield field_declaration
+
+class FieldDeclaration(object):
+       """Field declaration class. Do not instantiate."""
+       def __init__(self):
+               raise NotImplementedError("FieldDeclaration cannot be instantiated")

 
 

-                       decl_list.append(tmp)
-                       i += 1
-               return decl_list
+       def __repr__(self):
+               return "({0}) {1} {2}".format(CTFScope.scope_name(self.scope), CTFTypeId.type_name(self.type), self.name)

 
 

+       @property
+       def name(self):
+               """Return the name of a FieldDeclaration or None on error."""
+               return self._name

 
 

-class FieldDecl(object):
-       """Field declaration class.  Do not instantiate."""
+       @property
+       def type(self):
+               """
+               Return the FieldDeclaration's type. One of the entries in class
+               CTFTypeId.
+               """
+               return _bt_ctf_field_type(self._fd)
+
+       @property
+       def scope(self):
+               """
+               Return the FieldDeclaration's scope.
+               """
+               return self._s

 
 

+class IntegerFieldDeclaration(FieldDeclaration):
+       """Do not instantiate."""

        def __init__(self):
        def __init__(self):

-               raise NotImplementedError("FieldDecl cannot be instantiated")
+               raise NotImplementedError("IntegerFieldDeclaration cannot be instantiated")

 
 

-       def __repr__(self):
-               return "Babeltrace FieldDecl: name {0}".format(self.get_name())
+       @property
+       def signedness(self):
+               """
+               Return the signedness of an integer:
+               0 if unsigned; 1 if signed; -1 on error.
+               """
+               return _bt_ctf_get_int_signedness(self._fd)
+
+       @property
+       def base(self):
+               """Return the base of an int or a negative value on error."""
+               return _bt_ctf_get_int_base(self._fd)
+
+       @property
+       def byte_order(self):
+               """
+               Return the byte order. One of class ByteOrder's entries.
+               """
+               ret = _bt_ctf_get_int_byte_order(self._fd)
+               if ret == 1234:
+                       return ByteOrder.BYTE_ORDER_LITTLE_ENDIAN
+               elif ret == 4321:
+                       return ByteOrder.BYTE_ORDER_BIG_ENDIAN
+               else:
+                       return ByteOrder.BYTE_ORDER_UNKNOWN
+
+       @property
+       def length(self):
+               """
+               Return the size, in bits, of an int or a negative
+               value on error.
+               """
+               return _bt_ctf_get_int_len(self._fd)
+
+       @property
+       def encoding(self):
+               """
+               Return the encoding. One of class CTFStringEncoding's entries.
+               Return a negative value on error.
+               """
+               return _bt_ctf_get_encoding(self._fd)
+
+class EnumerationFieldDeclaration(FieldDeclaration):
+       """Do not instantiate."""
+       def __init__(self):
+               raise NotImplementedError("EnumerationFieldDeclaration cannot be instantiated")
+
+class ArrayFieldDeclaration(FieldDeclaration):
+       """Do not instantiate."""
+       def __init__(self):
+               raise NotImplementedError("ArrayFieldDeclaration cannot be instantiated")
+
+       @property
+       def length(self):
+               """
+               Return the length of an array or a negative
+               value on error.
+               """
+               return _bt_ctf_get_array_len(self._fd)

 
 

-       def get_name(self):
-               """Return the name of a FieldDecl or None on error"""
-               return _bt_ctf_get_decl_field_name(self._d)
+       @property
+       def element_declaration(self):
+               """
+               Return element declaration.
+               """
+               field_decl_ptr = _bt_python_get_array_element_declaration(self._fd)
+               return _create_field_declaration(field_decl_ptr, "", self.scope)

 
 

+class SequenceFieldDeclaration(FieldDeclaration):
+       """Do not instantiate."""
+       def __init__(self):
+               raise NotImplementedError("SequenceFieldDeclaration cannot be instantiated")
+
+       @property
+       def element_declaration(self):
+               """
+               Return element declaration.
+               """
+               field_decl_ptr = _bt_python_get_sequence_element_declaration(self._fd)
+               return _create_field_declaration(field_decl_ptr, "", self.scope)
+
+class FloatFieldDeclaration(FieldDeclaration):
+       """Do not instantiate."""
+       def __init__(self):
+               raise NotImplementedError("FloatFieldDeclaration cannot be instantiated")
+
+class StructureFieldDeclaration(FieldDeclaration):
+       """Do not instantiate."""
+       def __init__(self):
+               raise NotImplementedError("StructureFieldDeclaration cannot be instantiated")
+
+class StringFieldDeclaration(FieldDeclaration):
+       """Do not instantiate."""
+       def __init__(self):
+               raise NotImplementedError("StringFieldDeclaration cannot be instantiated")
+
+class VariantFieldDeclaration(FieldDeclaration):
+       """Do not instantiate."""
+       def __init__(self):
+               raise NotImplementedError("VariantFieldDeclaration cannot be instantiated")

 
 def field_error():
        """
 
 def field_error():
        """


@@ -820,32 +991,40 @@ def field_error():
        """
        return _bt_ctf_field_get_error()
 
        """
        return _bt_ctf_field_get_error()
 

-def get_event_decl_list(trace_handle, trace_collection):
+def _create_field_declaration(declaration_ptr, name, scope):

        """
        """

-       Return a list of EventDecl
-       Return None on error.
+       Private field declaration factory.

        """
        """

-       try:
-               handle_id = trace_handle._id
-       except AttributeError:
-                       raise TypeError("in get_event_decl_list, "
-                               "argument 1 must be a TraceHandle instance")
-       try:
-               ptr_list, count = _bt_python_event_decl_listcaller(handle_id, trace_collection._tc)
-       except AttributeError:
-                       raise TypeError("in get_event_decl_list, "
-                               "argument 2 must be a TraceCollection instance")
-
-       if ptr_list is None:
-               return None
-
-       decl_list = []
-       for i in range(count):
-               tmp = EventDecl.__new__(EventDecl)
-               tmp._d =  _bt_python_decl_one_from_list(ptr_list, i)
-               decl_list.append(tmp)
-
-       return decl_list
+       if declaration_ptr is None:
+               raise ValueError("declaration_ptr must be valid")
+       if not scope in _scopes:
+               raise ValueError("Invalid scope provided")
+
+       type = _bt_ctf_field_type(declaration_ptr)
+       declaration = None
+       if type == CTFTypeId.INTEGER:
+               declaration = IntegerFieldDeclaration.__new__(IntegerFieldDeclaration)
+       elif type == CTFTypeId.ENUM:
+               declaration = EnumerationFieldDeclaration.__new__(EnumerationFieldDeclaration)
+       elif type == CTFTypeId.ARRAY:
+               declaration = ArrayFieldDeclaration.__new__(ArrayFieldDeclaration)
+       elif type == CTFTypeId.SEQUENCE:
+               declaration = SequenceFieldDeclaration.__new__(SequenceFieldDeclaration)
+       elif type == CTFTypeId.FLOAT:
+               declaration = FloatFieldDeclaration.__new__(FloatFieldDeclaration)
+       elif type == CTFTypeId.STRUCT:
+               declaration = StructureFieldDeclaration.__new__(StructureFieldDeclaration)
+       elif type == CTFTypeId.STRING:
+               declaration = StringFieldDeclaration.__new__(StringFieldDeclaration)
+       elif type == CTFTypeId.VARIANT:
+               declaration = VariantFieldDeclaration.__new__(VariantFieldDeclaration)
+       else:
+               return declaration
+
+       declaration._fd = declaration_ptr
+       declaration._s = scope
+       declaration._name = name
+       return declaration

 
 class _Definition(object):
        def __init__(self, definition_ptr, scope):
 
 class _Definition(object):
        def __init__(self, definition_ptr, scope):


@@ -854,66 +1033,29 @@ class _Definition(object):
                if not scope in _scopes:
                        ValueError("Invalid scope provided")
 
                if not scope in _scopes:
                        ValueError("Invalid scope provided")
 

-       def __repr__(self):
-               return "Babeltrace Definition: name('{0}'), type({1})".format(self.name, self.type)
-

        @property
        def name(self):
                """Return the name of a field or None on error."""
                return _bt_ctf_field_name(self._d)
 
        @property
        def name(self):
                """Return the name of a field or None on error."""
                return _bt_ctf_field_name(self._d)
 

-       @property       
+       @property

        def type(self):
                """Return the type of a field or -1 if unknown."""
                return _bt_ctf_field_type(_bt_ctf_get_decl_from_def(self._d))
 
        def type(self):
                """Return the type of a field or -1 if unknown."""
                return _bt_ctf_field_type(_bt_ctf_get_decl_from_def(self._d))
 

-       def get_int_signedness(self):
-               """
-               Return the signedness of an integer:
-               0 if unsigned; 1 if signed; -1 on error.
-               """
-               return _bt_ctf_get_int_signedness(_bt_ctf_get_decl_from_def(self._d))
-
-       def get_int_base(self):
-               """Return the base of an int or a negative value on error."""
-               return _bt_ctf_get_int_base(_bt_ctf_get_decl_from_def(self._d))
-
-       def get_int_byte_order(self):
-               """
-               Return the byte order of an int or a negative
-               value on error.
-               """
-               return _bt_ctf_get_int_byte_order(_bt_ctf_get_decl_from_def(self._d))
-
-       def get_int_len(self):
-               """
-               Return the size, in bits, of an int or a negative
-               value on error.
-               """
-               return _bt_ctf_get_int_len(_bt_ctf_get_decl_from_def(self._d))
+       @property
+       def declaration(self):
+               """Return the associated Definition object."""
+               return _create_field_declaration(_bt_ctf_get_decl_from_def(self._d), self.name, self.scope)

 
 

-       def get_enum_str(self):
+       def _get_enum_str(self):

                """
                Return the string matching the current enumeration.
                Return None on error.
                """
                return _bt_ctf_get_enum_str(self._d)
 
                """
                Return the string matching the current enumeration.
                Return None on error.
                """
                return _bt_ctf_get_enum_str(self._d)
 

-       def get_encoding(self):
-               """
-               Return the encoding of an int or a string.
-               Return a negative value on error.
-               """
-               return _bt_ctf_get_encoding(_bt_ctf_get_decl_from_def(self._d))
-
-       def get_array_len(self):
-               """
-               Return the len of an array or a negative
-               value on error.
-               """
-               return _bt_ctf_get_array_len(_bt_ctf_get_decl_from_def(self._d))
-
-       def get_array_element_at(self, index):
+       def _get_array_element_at(self, index):

                """
                Return the array's element at position index.
                Return None on error
                """
                Return the array's element at position index.
                Return None on error


@@ -927,7 +1069,7 @@ class _Definition(object):
                        return None
                return _Definition(definition_ptr, self.scope)
 
                        return None
                return _Definition(definition_ptr, self.scope)
 

-       def get_sequence_len(self):
+       def _get_sequence_len(self):

                """
                Return the len of a sequence or a negative
                value on error.
                """
                Return the len of a sequence or a negative
                value on error.


@@ -935,7 +1077,7 @@ class _Definition(object):
                seq = _bt_python_get_sequence_from_def(self._d)
                return _bt_sequence_len(seq)
 
                seq = _bt_python_get_sequence_from_def(self._d)
                return _bt_sequence_len(seq)
 

-       def get_sequence_element_at(self, index):
+       def _get_sequence_element_at(self, index):

                """
                Return the sequence's element at position index,
                otherwise return None
                """
                Return the sequence's element at position index,
                otherwise return None


@@ -947,7 +1089,7 @@ class _Definition(object):
                                return _Definition(definition_ptr, self.scope)
                return None
 
                                return _Definition(definition_ptr, self.scope)
                return None
 

-       def get_uint64(self):
+       def _get_uint64(self):

                """
                Return the value associated with the field.
                If the field does not exist or is not of the type requested,
                """
                Return the value associated with the field.
                If the field does not exist or is not of the type requested,


@@ -956,7 +1098,7 @@ class _Definition(object):
                """
                return _bt_ctf_get_uint64(self._d)
 
                """
                return _bt_ctf_get_uint64(self._d)
 

-       def get_int64(self):
+       def _get_int64(self):

                """
                Return the value associated with the field.
                If the field does not exist or is not of the type requested,
                """
                Return the value associated with the field.
                If the field does not exist or is not of the type requested,


@@ -965,7 +1107,7 @@ class _Definition(object):
                """
                return _bt_ctf_get_int64(self._d)
 
                """
                return _bt_ctf_get_int64(self._d)
 

-       def get_char_array(self):
+       def _get_char_array(self):

                """
                Return the value associated with the field.
                If the field does not exist or is not of the type requested,
                """
                Return the value associated with the field.
                If the field does not exist or is not of the type requested,


@@ -974,7 +1116,7 @@ class _Definition(object):
                """
                return _bt_ctf_get_char_array(self._d)
 
                """
                return _bt_ctf_get_char_array(self._d)
 

-       def get_str(self):
+       def _get_str(self):

                """
                Return the value associated with the field.
                If the field does not exist or is not of the type requested,
                """
                Return the value associated with the field.
                If the field does not exist or is not of the type requested,


@@ -983,7 +1125,7 @@ class _Definition(object):
                """
                return _bt_ctf_get_string(self._d)
 
                """
                return _bt_ctf_get_string(self._d)
 

-       def get_float(self):
+       def _get_float(self):

                """
                Return the value associated with the field.
                If the field does not exist or is not of the type requested,
                """
                Return the value associated with the field.
                If the field does not exist or is not of the type requested,


@@ -992,7 +1134,7 @@ class _Definition(object):
                """
                return _bt_ctf_get_float(self._d)
 
                """
                return _bt_ctf_get_float(self._d)
 

-       def get_variant(self):
+       def _get_variant(self):

                """
                Return the variant's selected field.
                If the field does not exist or is not of the type requested,
                """
                Return the variant's selected field.
                If the field does not exist or is not of the type requested,


@@ -1001,7 +1143,7 @@ class _Definition(object):
                """
                return _bt_ctf_get_variant(self._d)
 
                """
                return _bt_ctf_get_variant(self._d)
 

-       def get_struct_field_count(self):
+       def _get_struct_field_count(self):

                """
                Return the number of fields contained in the structure.
                If the field does not exist or is not of the type requested,
                """
                Return the number of fields contained in the structure.
                If the field does not exist or is not of the type requested,


@@ -1009,7 +1151,7 @@ class _Definition(object):
                """
                return _bt_ctf_get_struct_field_count(self._d)
 
                """
                return _bt_ctf_get_struct_field_count(self._d)
 

-       def get_struct_field_at(self, i):
+       def _get_struct_field_at(self, i):

                """
                Return the structure's field at position i.
                If the field does not exist or is not of the type requested,
                """
                Return the structure's field at position i.
                If the field does not exist or is not of the type requested,


@@ -1026,40 +1168,53 @@ class _Definition(object):
                """
                id = self.type
                value = None
                """
                id = self.type
                value = None

+

                if id == CTFTypeId.STRING:
                if id == CTFTypeId.STRING:

-                       value = self.get_str()
+                       value = self._get_str()

                elif id == CTFTypeId.ARRAY:
                elif id == CTFTypeId.ARRAY:

-                       value = []
-                       for i in range(self.get_array_len()):
-                               element = self.get_array_element_at(i)
-                               value.append(element.value)
+                       element_decl = self.declaration.element_declaration
+                       if ((element_decl.type == CTFTypeId.INTEGER
+                               and element_decl.length == 8)
+                               and (element_decl.encoding == CTFStringEncoding.ASCII or element_decl.encoding == CTFStringEncoding.UTF8)):
+                               value = _bt_python_get_array_string(self._d)
+                       else:
+                               value = []
+                               for i in range(self.declaration.length):
+                                       element = self._get_array_element_at(i)
+                                       value.append(element.value)

                elif id == CTFTypeId.INTEGER:
                elif id == CTFTypeId.INTEGER:

-                       if self.get_int_signedness() == 0:
-                               value = self.get_uint64()
+                       if self.declaration.signedness == 0:
+                               value = self._get_uint64()

                        else:
                        else:

-                               value = self.get_int64()
+                               value = self._get_int64()

                elif id == CTFTypeId.ENUM:
                elif id == CTFTypeId.ENUM:

-                       value = self.get_enum_str()
+                       value = self._get_enum_str()

                elif id == CTFTypeId.SEQUENCE:
                elif id == CTFTypeId.SEQUENCE:

-                       seq_len = self.get_sequence_len()
-                       value = []
-                       for i in range(seq_len):
-                               evDef = self.get_sequence_element_at(i)
-                               value.append(evDef.value)
+                       element_decl = self.declaration.element_declaration
+                       if ((element_decl.type == CTFTypeId.INTEGER
+                               and element_decl.length == 8)
+                               and (element_decl.encoding == CTFStringEncoding.ASCII or element_decl.encoding == CTFStringEncoding.UTF8)):
+                               value = _bt_python_get_sequence_string(self._d)
+                       else:
+                               seq_len = self._get_sequence_len()
+                               value = []
+                               for i in range(seq_len):
+                                       evDef = self._get_sequence_element_at(i)
+                                       value.append(evDef.value)

                elif id == CTFTypeId.FLOAT:
                elif id == CTFTypeId.FLOAT:

-                       value = self.get_float()
+                       value = self._get_float()

                elif id == CTFTypeId.VARIANT:
                elif id == CTFTypeId.VARIANT:

-                       variant = Definition.__new__(Definition)
-                       variant._d = self.get_variant();
+                       variant = _Definition.__new__(_Definition)
+                       variant._d = self._get_variant();

                        value = variant.value
                elif id == CTFTypeId.STRUCT:
                        value = {}
                        value = variant.value
                elif id == CTFTypeId.STRUCT:
                        value = {}

-                       for i in range(self.get_struct_field_count()):
-                               member = _Definition(self.get_struct_field_at(i), self.scope)
+                       for i in range(self._get_struct_field_count()):
+                               member = _Definition(self._get_struct_field_at(i), self.scope)

                                value[member.name] = member.value
 
                if field_error():
                                value[member.name] = member.value
 
                if field_error():

-                       raise FieldError("Error occurred while accessing field {} of type {}".format(self.field_name(), CTFTypeId.get_type_name(self.field_type())))
+                       raise FieldError("Error occurred while accessing field {} of type {}".format(self.name, CTFTypeId.type_name(id)))

                return value
 
        @property
                return value
 
        @property


@@ -1258,11 +1413,6 @@ void bt_ctf_writer_put(struct bt_ctf_writer *writer);
 %pythoncode %{
 
 class CTFWriter:
 %pythoncode %{
 
 class CTFWriter:

-       class ByteOrder:
-               BYTE_ORDER_NATIVE = 0
-               BYTE_ORDER_LITTLE_ENDIAN = 1
-               BYTE_ORDER_BIG_ENDIAN = 2
-               BYTE_ORDER_NETWORK = 3

 
        class Clock:
                def __init__(self, name):
 
        class Clock:
                def __init__(self, name):


@@ -1273,68 +1423,126 @@ class CTFWriter:
                def __del__(self):
                        _bt_ctf_clock_put(self._c)
 
                def __del__(self):
                        _bt_ctf_clock_put(self._c)
 

+               """
+               Get the clock's description.
+               """
+               @property
+               def description(self):
+                       raise NotImplementedError("Getter not implemented.")
+

                """
                Set the clock's description. The description appears in the clock's TSDL
                meta-data.
                """
                """
                Set the clock's description. The description appears in the clock's TSDL
                meta-data.
                """

-               def set_description(self, desc):
-                       ret = _bt_ctf_clock_set_description(self._c, desc)
+               @description.setter
+               def description(self, desc):
+                       ret = _bt_ctf_clock_set_description(self._c, str(desc))

                        if ret < 0:
                                raise ValueError("Invalid clock description.")
 
                        if ret < 0:
                                raise ValueError("Invalid clock description.")
 

+               """
+               Get the clock's frequency (Hz).
+               """
+               @property
+               def frequency(self):
+                       raise NotImplementedError("Getter not implemented.")
+

                """
                Set the clock's frequency (Hz).
                """
                """
                Set the clock's frequency (Hz).
                """

-               def set_frequency(self, freq):
+               @frequency.setter
+               def frequency(self, freq):

                        ret = _bt_ctf_clock_set_frequency(self._c, freq)
                        if ret < 0:
                                raise ValueError("Invalid frequency value.")
 
                        ret = _bt_ctf_clock_set_frequency(self._c, freq)
                        if ret < 0:
                                raise ValueError("Invalid frequency value.")
 

+               """
+               Get the clock's precision (in clock ticks).
+               """
+               @property
+               def precision(self):
+                       raise NotImplementedError("Getter not implemented.")
+

                """
                Set the clock's precision (in clock ticks).
                """
                """
                Set the clock's precision (in clock ticks).
                """

-               def set_precision(self, precision):
+               @precision.setter
+               def precision(self, precision):

                        ret = _bt_ctf_clock_set_precision(self._c, precision)
 
                        ret = _bt_ctf_clock_set_precision(self._c, precision)
 

+               """
+               Get the clock's offset in seconds from POSIX.1 Epoch.
+               """
+               @property
+               def offset_seconds(self):
+                       raise NotImplementedError("Getter not implemented.")
+

                """
                Set the clock's offset in seconds from POSIX.1 Epoch.
                """
                """
                Set the clock's offset in seconds from POSIX.1 Epoch.
                """

-               def set_offset_seconds(self, offset_s):
+               @offset_seconds.setter
+               def offset_seconds(self, offset_s):

                        ret = _bt_ctf_clock_set_offset_s(self._c, offset_s)
                        if ret < 0:
                                raise ValueError("Invalid offset value.")
 
                        ret = _bt_ctf_clock_set_offset_s(self._c, offset_s)
                        if ret < 0:
                                raise ValueError("Invalid offset value.")
 

+               """
+               Get the clock's offset in ticks from POSIX.1 Epoch + offset in seconds.
+               """
+               @property
+               def offset(self):
+                       raise NotImplementedError("Getter not implemented.")
+

                """
                Set the clock's offset in ticks from POSIX.1 Epoch + offset in seconds.
                """
                """
                Set the clock's offset in ticks from POSIX.1 Epoch + offset in seconds.
                """

-               def set_offset_seconds(self, offset):
+               @offset.setter
+               def offset(self, offset):

                        ret = _bt_ctf_clock_set_offset(self._c, offset)
                        if ret < 0:
                                raise ValueError("Invalid offset value.")
 
                        ret = _bt_ctf_clock_set_offset(self._c, offset)
                        if ret < 0:
                                raise ValueError("Invalid offset value.")
 

+               """
+               Get a clock's absolute attribute. A clock is absolute if the clock
+               is a global reference across the trace's other clocks.
+               """
+               @property
+               def absolute(self):
+                       raise NotImplementedError("Getter not implemented.")
+

                """
                Set a clock's absolute attribute. A clock is absolute if the clock
                is a global reference across the trace's other clocks.
                """
                """
                Set a clock's absolute attribute. A clock is absolute if the clock
                is a global reference across the trace's other clocks.
                """

-               def set_is_absolute(self, is_absolute):
-                       ret = _bt_ctf_clock_set_is_absolute(self._c, is_absolute)
+               @absolute.setter
+               def absolute(self, is_absolute):
+                       ret = _bt_ctf_clock_set_is_absolute(self._c, int(is_absolute))

                        if ret < 0:
                                raise ValueError("Could not set the clock's absolute attribute.")
 
                        if ret < 0:
                                raise ValueError("Could not set the clock's absolute attribute.")
 

+               """
+               Get the current time in nanoseconds since the clock's origin (offset and
+               offset_s attributes).
+               """
+               @property
+               def time(self):
+                       raise NotImplementedError("Getter not implemented.")
+

                """
                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.
                """
                """
                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.
                """

-               def set_time(self, time):
+               @time.setter
+               def time(self, time):

                        ret = _bt_ctf_clock_set_time(self._c, time)
                        if ret < 0:
                                raise ValueError("Invalid time value.")
 
                        ret = _bt_ctf_clock_set_time(self._c, time)
                        if ret < 0:
                                raise ValueError("Invalid time value.")
 

-       class FieldType:
+       class FieldDeclaration:

                """
                """

-               FieldType should not be instantiated directly. Please instantiate
-               one of the concrete FieldType classes.
+               FieldDeclaration should not be instantiated directly. Please instantiate
+               one of the concrete FieldDeclaration classes.

                """
                class IntegerBase:
                        # These values are based on the bt_ctf_integer_base enum
                """
                class IntegerBase:
                        # These values are based on the bt_ctf_integer_base enum


@@ -1347,31 +1555,47 @@ class CTFWriter:
 
                def __init__(self):
                        if self._ft is None:
 
                def __init__(self):
                        if self._ft is None:

-                               raise ValueError("FieldType creation failed.")
+                               raise ValueError("FieldDeclaration creation failed.")

 
                def __del__(self):
                        _bt_ctf_field_type_put(self._ft)
 
 
                def __del__(self):
                        _bt_ctf_field_type_put(self._ft)
 

+               """
+               Get the field type's alignment.
+               """
+               @property
+               def alignment(self):
+                       raise NotImplementedError("Getter not implemented.")
+

                """
                Set the field type's alignment. Defaults to 1 (bit-aligned). However,
                some types, such as structures and string, may impose other alignment
                constraints.
                """
                """
                Set the field type's alignment. Defaults to 1 (bit-aligned). However,
                some types, such as structures and string, may impose other alignment
                constraints.
                """

-               def set_alignment(self, alignment):
+               @alignment.setter
+               def alignment(self, alignment):

                        ret = _bt_ctf_field_type_set_alignment(self._ft, alignment)
                        if ret < 0:
                                raise ValueError("Invalid alignment value.")
 
                        ret = _bt_ctf_field_type_set_alignment(self._ft, alignment)
                        if ret < 0:
                                raise ValueError("Invalid alignment value.")
 

+               """
+               Get the field type's byte order. One of the ByteOrder's constant.
+               """
+               @property
+               def byte_order(self):
+                       raise NotImplementedError("Getter not implemented.")
+

                """
                Set the field type's byte order. Use constants defined in the ByteOrder
                class.
                """
                """
                Set the field type's byte order. Use constants defined in the ByteOrder
                class.
                """

-               def set_byte_order(self, byte_order):
+               @byte_order.setter
+               def byte_order(self, byte_order):

                        ret = _bt_ctf_field_type_set_byte_order(self._ft, byte_order)
                        if ret < 0:
                                raise ValueError("Could not set byte order value.")
 
                        ret = _bt_ctf_field_type_set_byte_order(self._ft, byte_order)
                        if ret < 0:
                                raise ValueError("Could not set byte order value.")
 

-       class FieldTypeInteger(FieldType):
+       class IntegerFieldDeclaration(FieldDeclaration):

                """
                Create a new integer field type of the given size.
                """
                """
                Create a new integer field type of the given size.
                """


@@ -1380,37 +1604,62 @@ class CTFWriter:
                        super().__init__()
 
                """
                        super().__init__()
 
                """

-               Set an integer type's signedness attribute.
+               Get an integer's signedness attribute.
+               """
+               @property
+               def signed(self):
+                       raise NotImplementedError("Getter not implemented.")
+

                """
                """

-               def set_signed(self, signed):
+               Set an integer's signedness attribute.
+               """
+               @signed.setter
+               def signed(self, signed):

                        ret = _bt_ctf_field_type_integer_set_signed(self._ft, signed)
                        if ret < 0:
                                raise ValueError("Could not set signed attribute.")
 
                """
                        ret = _bt_ctf_field_type_integer_set_signed(self._ft, signed)
                        if ret < 0:
                                raise ValueError("Could not set signed attribute.")
 
                """

-               Set the integer type's base used to pretty-print the resulting trace.
+               Get the integer's base used to pretty-print the resulting trace.
+               """
+               @property
+               def base(self):
+                       raise NotImplementedError("Getter not implemented.")
+
+               """
+               Set the integer's base used to pretty-print the resulting trace.

                The base must be a constant of the IntegerBase class.
                """
                The base must be a constant of the IntegerBase class.
                """

-               def set_base(self, base):
+               @base.setter
+               def base(self, base):

                        ret = _bt_ctf_field_type_integer_set_base(self._ft, base)
                        if ret < 0:
                                raise ValueError("Could not set base value.")
 
                        ret = _bt_ctf_field_type_integer_set_base(self._ft, base)
                        if ret < 0:
                                raise ValueError("Could not set base value.")
 

+               """
+               Get the integer's encoding (one of the constants of the
+               CTFStringEncoding class).
+               """
+               @property
+               def encoding(self):
+                       raise NotImplementedError("Getter not implemented.")
+

                """
                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.
                """
                """
                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.
                """

-               def set_encoding(self, encoding):
+               @encoding.setter
+               def encoding(self, encoding):

                        ret = _bt_ctf_field_type_integer_set_encoding(self._ft, encoding)
                        if ret < 0:
                                raise ValueError("Could not set integer encoding.")
 
                        ret = _bt_ctf_field_type_integer_set_encoding(self._ft, encoding)
                        if ret < 0:
                                raise ValueError("Could not set integer encoding.")
 

-       class FieldTypeEnumeration(FieldType):
+       class EnumerationFieldDeclaration(FieldDeclaration):

                """
                Create a new enumeration field type with the given underlying type.
                """
                def __init__(self, integer_type):
                """
                Create a new enumeration field type with the given underlying type.
                """
                def __init__(self, integer_type):

-                       if integer_type is None or not isinstance(integer_type, CTFWriter.FieldTypeInteger):
+                       if integer_type is None or not isinstance(integer_type, CTFWriter.IntegerFieldDeclaration):

                                raise TypeError("Invalid integer container.")
 
                        self._ft = _bt_ctf_field_type_enumeration_create(integer_type._ft)
                                raise TypeError("Invalid integer container.")
 
                        self._ft = _bt_ctf_field_type_enumeration_create(integer_type._ft)


@@ -1420,11 +1669,11 @@ class CTFWriter:
                Add a mapping to the enumeration. The range's values are inclusive.
                """
                def add_mapping(self, name, range_start, range_end):
                Add a mapping to the enumeration. The range's values are inclusive.
                """
                def add_mapping(self, name, range_start, range_end):

-                       ret = _bt_ctf_field_type_enumeration_add_mapping(self._ft, name, range_start, range_end)
+                       ret = _bt_ctf_field_type_enumeration_add_mapping(self._ft, str(name), range_start, range_end)

                        if ret < 0:
                                raise ValueError("Could not add mapping to enumeration type.")
 
                        if ret < 0:
                                raise ValueError("Could not add mapping to enumeration type.")
 

-       class FieldTypeFloatingPoint(FieldType):
+       class FloatFieldDeclaration(FieldDeclaration):

                FLT_EXP_DIG = 8
                DBL_EXP_DIG = 11
                FLT_MANT_DIG = 24
                FLT_EXP_DIG = 8
                DBL_EXP_DIG = 11
                FLT_MANT_DIG = 24


@@ -1438,26 +1687,42 @@ class CTFWriter:
                        super().__init__()
 
                """
                        super().__init__()
 
                """

-               Set the number of exponent digits to use to store the floatingpoint field.
+               Get the number of exponent digits to use to store the floating point field.
+               """
+               @property
+               def exponent_digits(self):
+                       raise NotImplementedError("Getter not implemented.")
+
+               """
+               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.
                """
                The only values currently supported are FLT_EXP_DIG and DBL_EXP_DIG which
                are defined as constants of this class.
                """

-               def set_exponent_digits(self, exponent_digits):
+               @exponent_digits.setter
+               def exponent_digits(self, exponent_digits):

                        ret = _bt_ctf_field_type_floating_point_set_exponent_digits(self._ft, exponent_digits)
                        if ret < 0:
                                raise ValueError("Could not set exponent digit count.")
 
                """
                        ret = _bt_ctf_field_type_floating_point_set_exponent_digits(self._ft, exponent_digits)
                        if ret < 0:
                                raise ValueError("Could not set exponent digit count.")
 
                """

-               Set the numberof mantissa digits to use to store the floatingpoint field.
+               Get the number of mantissa digits to use to store the floating point field.
+               """
+               @property
+               def mantissa_digits(self):
+                       raise NotImplementedError("Getter not implemented.")
+
+               """
+               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.
                """
                The only values currently supported are FLT_MANT_DIG and DBL_MANT_DIG which
                are defined as constants of this class.
                """

-               def set_mantissa_digits(self, mantissa_digits):
+               @mantissa_digits.setter
+               def mantissa_digits(self, mantissa_digits):

                        ret = _bt_ctf_field_type_floating_point_set_mantissa_digits(self._ft, mantissa_digits)
                        if ret < 0:
                                raise ValueError("Could not set mantissa digit count.")
 
                        ret = _bt_ctf_field_type_floating_point_set_mantissa_digits(self._ft, mantissa_digits)
                        if ret < 0:
                                raise ValueError("Could not set mantissa digit count.")
 

-       class FieldTypeStructure(FieldType):
+       class StructureFieldDeclaration(FieldDeclaration):

                """
                Create a new structure field type.
                """
                """
                Create a new structure field type.
                """


@@ -1469,30 +1734,30 @@ class CTFWriter:
                Add a field of type "field_type" to the structure.
                """
                def add_field(self, field_type, field_name):
                Add a field of type "field_type" to the structure.
                """
                def add_field(self, field_type, field_name):

-                       ret = _bt_ctf_field_type_structure_add_field(self._ft, field_type._ft, field_name)
+                       ret = _bt_ctf_field_type_structure_add_field(self._ft, field_type._ft, str(field_name))

                        if ret < 0:
                                raise ValueError("Could not add field to structure.")
 
                        if ret < 0:
                                raise ValueError("Could not add field to structure.")
 

-       class FieldTypeVariant(FieldType):
+       class VariantFieldDeclaration(FieldDeclaration):

                """
                Create a new variant field type.
                """
                def __init__(self, enum_tag, tag_name):
                """
                Create a new variant field type.
                """
                def __init__(self, enum_tag, tag_name):

-                       if enum_tag is None or not isinstance(enum_tag, CTFWriter.FieldTypeEnumeration):
-                               raise TypeError("Invalid tag type; must be of type FieldTypeEnumeration.")
+                       if enum_tag is None or not isinstance(enum_tag, CTFWriter.EnumerationFieldDeclaration):
+                               raise TypeError("Invalid tag type; must be of type EnumerationFieldDeclaration.")

 
 

-                       self._ft = _bt_ctf_field_type_variant_create(enum_tag._ft, tag_name)
+                       self._ft = _bt_ctf_field_type_variant_create(enum_tag._ft, str(tag_name))

                        super().__init__()
 
                """
                Add a field of type "field_type" to the variant.
                """
                def add_field(self, field_type, field_name):
                        super().__init__()
 
                """
                Add a field of type "field_type" to the variant.
                """
                def add_field(self, field_type, field_name):

-                       ret = _bt_ctf_field_type_variant_add_field(self._ft, field_type._ft, field_name)
+                       ret = _bt_ctf_field_type_variant_add_field(self._ft, field_type._ft, str(field_name))

                        if ret < 0:
                                raise ValueError("Could not add field to variant.")
 
                        if ret < 0:
                                raise ValueError("Could not add field to variant.")
 

-       class FieldTypeArray(FieldType):
+       class ArrayFieldDeclaration(FieldDeclaration):

                """
                Create a new array field type.
                """
                """
                Create a new array field type.
                """


@@ -1500,15 +1765,15 @@ class CTFWriter:
                        self._ft = _bt_ctf_field_type_array_create(element_type._ft, length)
                        super().__init__()
 
                        self._ft = _bt_ctf_field_type_array_create(element_type._ft, length)
                        super().__init__()
 

-       class FieldTypeSequence(FieldType):
+       class SequenceFieldDeclaration(FieldDeclaration):

                """
                Create a new sequence field type.
                """
                def __init__(self, element_type, length_field_name):
                """
                Create a new sequence field type.
                """
                def __init__(self, element_type, length_field_name):

-                       self._ft = _bt_ctf_field_type_sequence_create(element_type._ft, length_field_name)
+                       self._ft = _bt_ctf_field_type_sequence_create(element_type._ft, str(length_field_name))

                        super().__init__()
 
                        super().__init__()
 

-       class FieldTypeString(FieldType):
+       class StringFieldDeclaration(FieldDeclaration):

                """
                Create a new string field type.
                """
                """
                Create a new string field type.
                """


@@ -1516,10 +1781,18 @@ class CTFWriter:
                        self._ft = _bt_ctf_field_type_string_create()
                        super().__init__()
 
                        self._ft = _bt_ctf_field_type_string_create()
                        super().__init__()
 

+               """
+               Get a string type's encoding (a constant from the CTFStringEncoding class).
+               """
+               @property
+               def encoding(self):
+                       raise NotImplementedError("Getter not implemented.")
+

                """
                Set a string type's encoding. Must be a constant from the CTFStringEncoding class.
                """
                """
                Set a string type's encoding. Must be a constant from the CTFStringEncoding class.
                """

-               def set_encoding(self, encoding):
+               @encoding.setter
+               def encoding(self, encoding):

                        ret = _bt_ctf_field_type_string_set_encoding(self._ft, encoding)
                        if ret < 0:
                                raise ValueError("Could not set string encoding.")
                        ret = _bt_ctf_field_type_string_set_encoding(self._ft, encoding)
                        if ret < 0:
                                raise ValueError("Could not set string encoding.")


@@ -1529,32 +1802,32 @@ class CTFWriter:
        """
        @staticmethod
        def create_field(self, field_type):
        """
        @staticmethod
        def create_field(self, field_type):

-               if field_type is None or not isinstance(field_type, CTFWriter.FieldType):
-                       raise TypeError("Invalid field_type. Type must be a FieldType-derived class.")
-
-               if isinstance(field_type, CTFWriter.FieldTypeInteger):
-                       return CTFWriter.FieldInteger(field_type)
-               elif isinstance(field_type, CTFWriter.FieldTypeEnumeration):
-                       return CTFWriter.FieldEnumeration(field_type)
-               elif isinstance(field_type, CTFWriter.FieldTypeFloatingPoint):
-                       return CTFWriter.FieldFloatingPoint(field_type)
-               elif isinstance(field_type, CTFWriter.FieldTypeStructure):
-                       return CTFWriter.FieldStructure(field_type)
-               elif isinstance(field_type, CTFWriter.FieldTypeVariant):
-                       return CTFWriter.FieldVariant(field_type)
-               elif isinstance(field_type, CTFWriter.FieldTypeArray):
-                       return CTFWriter.FieldArray(field_type)
-               elif isinstance(field_type, CTFWriter.FieldTypeSequence):
-                       return CTFWriter.FieldSequence(field_type)
-               elif isinstance(field_type, CTFWriter.FieldTypeString):
-                       return CTFWriter.FieldString(field_type)
+               if field_type is None or not isinstance(field_type, CTFWriter.FieldDeclaration):
+                       raise TypeError("Invalid field_type. Type must be a FieldDeclaration-derived class.")
+
+               if isinstance(field_type, CTFWriter.IntegerFieldDeclaration):
+                       return CTFWriter.IntegerField(field_type)
+               elif isinstance(field_type, CTFWriter.EnumerationFieldDeclaration):
+                       return CTFWriter.EnumerationField(field_type)
+               elif isinstance(field_type, CTFWriter.FloatFieldDeclaration):
+                       return CTFWriter.FloatFieldingPoint(field_type)
+               elif isinstance(field_type, CTFWriter.StructureFieldDeclaration):
+                       return CTFWriter.StructureField(field_type)
+               elif isinstance(field_type, CTFWriter.VariantFieldDeclaration):
+                       return CTFWriter.VariantField(field_type)
+               elif isinstance(field_type, CTFWriter.ArrayFieldDeclaration):
+                       return CTFWriter.ArrayField(field_type)
+               elif isinstance(field_type, CTFWriter.SequenceFieldDeclaration):
+                       return CTFWriter.SequenceField(field_type)
+               elif isinstance(field_type, CTFWriter.StringFieldDeclaration):
+                       return CTFWriter.StringField(field_type)

 
        class Field:
                """
                Base class, do not instantiate.
                """
                def __init__(self, field_type):
 
        class Field:
                """
                Base class, do not instantiate.
                """
                def __init__(self, field_type):

-                       if not isinstance(field_type, CTFWriter.FieldType):
+                       if not isinstance(field_type, CTFWriter.FieldDeclaration):

                                raise TypeError("Invalid field_type argument.")
 
                        self._f = _bt_ctf_field_create(field_type._ft)
                                raise TypeError("Invalid field_type argument.")
 
                        self._f = _bt_ctf_field_create(field_type._ft)


@@ -1567,14 +1840,14 @@ class CTFWriter:
                @staticmethod
                def _create_field_from_native_instance(native_field_instance):
                        type_dict = {
                @staticmethod
                def _create_field_from_native_instance(native_field_instance):
                        type_dict = {

-                               CTFTypeId.INTEGER : CTFWriter.FieldInteger,
-                               CTFTypeId.FLOAT : CTFWriter.FieldFloatingPoint,
-                               CTFTypeId.ENUM : CTFWriter.FieldEnumeration,
-                               CTFTypeId.STRING : CTFWriter.FieldString,
-                               CTFTypeId.STRUCT : CTFWriter.FieldStructure,
-                               CTFTypeId.VARIANT : CTFWriter.FieldVariant,
-                               CTFTypeId.ARRAY : CTFWriter.FieldArray,
-                               CTFTypeId.SEQUENCE : CTFWriter.FieldSequence
+                               CTFTypeId.INTEGER : CTFWriter.IntegerField,
+                               CTFTypeId.FLOAT : CTFWriter.FloatFieldingPoint,
+                               CTFTypeId.ENUM : CTFWriter.EnumerationField,
+                               CTFTypeId.STRING : CTFWriter.StringField,
+                               CTFTypeId.STRUCT : CTFWriter.StructureField,
+                               CTFTypeId.VARIANT : CTFWriter.VariantField,
+                               CTFTypeId.ARRAY : CTFWriter.ArrayField,
+                               CTFTypeId.SEQUENCE : CTFWriter.SequenceField

                        }
 
                        field_type = _bt_python_get_field_type(native_field_instance)
                        }
 
                        field_type = _bt_python_get_field_type(native_field_instance)


@@ -1586,11 +1859,19 @@ class CTFWriter:
                        field.__class__ = type_dict[field_type]
                        return field
 
                        field.__class__ = type_dict[field_type]
                        return field
 

-       class FieldInteger(Field):
+       class IntegerField(Field):
+               """
+               Get an integer field's value.
+               """
+               @property
+               def value(self):
+                       raise NotImplementedError("Getter not implemented.")
+

                """
                Set an integer field's value.
                """
                """
                Set an integer field's value.
                """

-               def set_value(self, value):
+               @value.setter
+               def value(self, value):

                        signedness = _bt_python_field_integer_get_signedness(self._f)
                        if signedness < 0:
                                raise TypeError("Invalid integer instance.")
                        signedness = _bt_python_field_integer_get_signedness(self._f)
                        if signedness < 0:
                                raise TypeError("Invalid integer instance.")


@@ -1603,82 +1884,107 @@ class CTFWriter:
                        if ret < 0:
                                raise ValueError("Could not set integer field value.")
 
                        if ret < 0:
                                raise ValueError("Could not set integer field value.")
 

-       class FieldEnumeration(Field):
+       class EnumerationField(Field):

                """
                Return the enumeration's underlying container field (an integer field).
                """
                """
                Return the enumeration's underlying container field (an integer field).
                """

-               def get_container(self):
-                       container = CTFWriter.FieldInteger.__new__(CTFWriter.FieldInteger)
+               @property
+               def container(self):
+                       container = CTFWriter.IntegerField.__new__(CTFWriter.IntegerField)

                        container._f = _bt_ctf_field_enumeration_get_container(self._f)
                        if container._f is None:
                                raise TypeError("Invalid enumeration field type.")
                        return container
 
                        container._f = _bt_ctf_field_enumeration_get_container(self._f)
                        if container._f is None:
                                raise TypeError("Invalid enumeration field type.")
                        return container
 

-       class FieldFloatingPoint(Field):
+       class FloatFieldingPoint(Field):
+               """
+               Get a floating point field's value.
+               """
+               @property
+               def value(self):
+                       raise NotImplementedError("Getter not implemented.")
+

                """
                Set a floating point field's value.
                """
                """
                Set a floating point field's value.
                """

-               def set_value(self, value):
-                       ret = _bt_ctf_field_floating_point_set_value(self._f, value)
+               @value.setter
+               def value(self, value):
+                       ret = _bt_ctf_field_floating_point_set_value(self._f, float(value))

                        if ret < 0:
                                raise ValueError("Could not set floating point field value.")
 
                        if ret < 0:
                                raise ValueError("Could not set floating point field value.")
 

-       class FieldStructure(Field):
+       class StructureField(Field):

                """
                Get the structure's field corresponding to the provided field name.
                """
                """
                Get the structure's field corresponding to the provided field name.
                """

-               def get_field(self, field_name):
-                       native_instance = _bt_ctf_field_structure_get_field(self._f, field_name)
+               def field(self, field_name):
+                       native_instance = _bt_ctf_field_structure_get_field(self._f, str(field_name))

                        if native_instance is None:
                                raise ValueError("Invalid field_name provided.")
                        return CTFWriter.Field._create_field_from_native_instance(native_instance)
 
                        if native_instance is None:
                                raise ValueError("Invalid field_name provided.")
                        return CTFWriter.Field._create_field_from_native_instance(native_instance)
 

-       class FieldVariant(Field):
+       class VariantField(Field):

                """
                Return the variant's selected field. The "tag" field is the selector enum field.
                """
                """
                Return the variant's selected field. The "tag" field is the selector enum field.
                """

-               def get_field(self, tag):
+               def field(self, tag):

                        native_instance = _bt_ctf_field_variant_get_field(self._f, tag._f)
                        if native_instance is None:
                                raise ValueError("Invalid tag provided.")
                        return CTFWriter.Field._create_field_from_native_instance(native_instance)
 
                        native_instance = _bt_ctf_field_variant_get_field(self._f, tag._f)
                        if native_instance is None:
                                raise ValueError("Invalid tag provided.")
                        return CTFWriter.Field._create_field_from_native_instance(native_instance)
 

-       class FieldArray(Field):
+       class ArrayField(Field):

                """
                Return the array's field at position "index".
                """
                """
                Return the array's field at position "index".
                """

-               def get_field(self, index):
+               def field(self, index):

                        native_instance = _bt_ctf_field_array_get_field(self._f, index)
                        if native_instance is None:
                                raise IndexError("Invalid index provided.")
                        return CTFWriter.Field._create_field_from_native_instance(native_instance)
 
                        native_instance = _bt_ctf_field_array_get_field(self._f, index)
                        if native_instance is None:
                                raise IndexError("Invalid index provided.")
                        return CTFWriter.Field._create_field_from_native_instance(native_instance)
 

-       class FieldSequence(Field):
+       class SequenceField(Field):
+               """
+               Get the sequence's length field (IntegerField).
+               """
+               @property
+               def length(self):
+                       raise NotImplementedError("Getter not implemented.")
+

                """
                Set the sequence's length field (IntegerField).
                """
                """
                Set the sequence's length field (IntegerField).
                """

-               def set_length(self, length):
-                       if not isinstance(length, CTFWriter.FieldInteger):
+               @length.setter
+               def length(self, length_field):
+                       if not isinstance(length_field, CTFWriter.IntegerField):

                                raise TypeError("Invalid length field.")
                                raise TypeError("Invalid length field.")

-                       ret = _bt_ctf_field_sequence_set_length(self._f, length._f)
+                       ret = _bt_ctf_field_sequence_set_length(self._f, length_field._f)

                        if ret < 0:
                                raise ValueError("Could not set sequence length.")
 
                """
                Return the sequence's field at position "index".
                """
                        if ret < 0:
                                raise ValueError("Could not set sequence length.")
 
                """
                Return the sequence's field at position "index".
                """

-               def get_field(self, index):
+               def field(self, index):

                        native_instance = _bt_ctf_field_sequence_get_field(self._f, index)
                        if native_instance is None:
                                raise ValueError("Could not get sequence element at index.")
                        return CTFWriter.Field._create_field_from_native_instance(native_instance)
 
                        native_instance = _bt_ctf_field_sequence_get_field(self._f, index)
                        if native_instance is None:
                                raise ValueError("Could not get sequence element at index.")
                        return CTFWriter.Field._create_field_from_native_instance(native_instance)
 

-       class FieldString(Field):
+       class StringField(Field):
+               """
+               Get a string field's value.
+               """
+               @property
+               def value(self):
+                       raise NotImplementedError("Getter not implemented.")
+

                """
                Set a string field's value.
                """
                """
                Set a string field's value.
                """

-               def set_value(self, value):
-                       ret = _bt_ctf_field_string_set_value(self._f, value)
+               @value.setter
+               def value(self, value):
+                       ret = _bt_ctf_field_string_set_value(self._f, str(value))

                        if ret < 0:
                                raise ValueError("Could not set string field value.")
 
                        if ret < 0:
                                raise ValueError("Could not set string field value.")
 


@@ -1698,7 +2004,7 @@ class CTFWriter:
                Add a field of type "field_type" to the event class.
                """
                def add_field(self, field_type, field_name):
                Add a field of type "field_type" to the event class.
                """
                def add_field(self, field_type, field_name):

-                       ret = _bt_ctf_event_class_add_field(self._ec, field_type._ft, field_name)
+                       ret = _bt_ctf_event_class_add_field(self._ec, field_type._ft, str(field_name))

                        if ret < 0:
                                raise ValueError("Could not add field to event class.")
 
                        if ret < 0:
                                raise ValueError("Could not add field to event class.")
 


@@ -1720,18 +2026,18 @@ class CTFWriter:
                """
                Set a manually created field as an event's payload.
                """
                """
                Set a manually created field as an event's payload.
                """

-               def set_payload(self, field_name, value):
+               def set_payload(self, field_name, value_field):

                        if not isinstance(value, CTFWriter.Field):
                                raise TypeError("Invalid value type.")
                        if not isinstance(value, CTFWriter.Field):
                                raise TypeError("Invalid value type.")

-                       ret = _bt_ctf_event_set_payload(self._e, field_name, value._f)
+                       ret = _bt_ctf_event_set_payload(self._e, str(field_name), value_field._f)

                        if ret < 0:
                                raise ValueError("Could not set event field payload.")
 
                """
                        if ret < 0:
                                raise ValueError("Could not set event field payload.")
 
                """

-               Set a manually created field as an event's payload.
+               Get a field from event.

                """
                """

-               def get_payload(self, field_name):
-                       native_instance = _bt_ctf_event_get_payload(self._e, field_name)
+               def payload(self, field_name):
+                       native_instance = _bt_ctf_event_get_payload(self._e, str(field_name))

                        if native_instance is None:
                                raise ValueError("Could not get event payload.")
                        return CTFWriter.Field._create_field_from_native_instance(native_instance)
                        if native_instance is None:
                                raise ValueError("Could not get event payload.")
                        return CTFWriter.Field._create_field_from_native_instance(native_instance)


@@ -1748,10 +2054,18 @@ class CTFWriter:
                def __del__(self):
                        _bt_ctf_stream_class_put(self._sc)
 
                def __del__(self):
                        _bt_ctf_stream_class_put(self._sc)
 

+               """
+               Get a stream class' clock.
+               """
+               @property
+               def clock(self):
+                       raise NotImplementedError("Getter not implemented.")
+

                """
                Assign a clock to a stream class.
                """
                """
                Assign a clock to a stream class.
                """

-               def set_clock(self, clock):
+               @clock.setter
+               def clock(self, clock):

                        if not isinstance(clock, CTFWriter.Clock):
                                raise TypeError("Invalid clock type.")
 
                        if not isinstance(clock, CTFWriter.Clock):
                                raise TypeError("Invalid clock type.")
 


@@ -1761,7 +2075,7 @@ class CTFWriter:
 
                """
                Add an event class to a stream class. New events can be added even after a
 
                """
                Add an event class to a stream class. New events can be added even after a

-               stream has beem instanciated and events have been appended. However, a stream
+               stream has been instantiated and events have been appended. However, a stream

                will not accept events of a class that has not been registered beforehand.
                """
                def add_event_class(self, event_class):
                will not accept events of a class that has not been registered beforehand.
                """
                def add_event_class(self, event_class):


@@ -1791,9 +2105,7 @@ class CTFWriter:
                Increase the current packet's discarded event count.
                """
                def append_discarded_events(self, event_count):
                Increase the current packet's discarded event count.
                """
                def append_discarded_events(self, event_count):

-                       ret = _bt_ctf_stream_append_discarded_events(self._s, event_count)
-                       if ret < 0:
-                               raise ValueError("Could not append discarded events.")
+                       _bt_ctf_stream_append_discarded_events(self._s, event_count)

 
                """
                Append "event" to the stream's current packet. The stream's associated clock
 
                """
                Append "event" to the stream's current packet. The stream's associated clock


@@ -1841,7 +2153,7 @@ class CTFWriter:
                Add an environment field to the trace.
                """
                def add_environment_field(self, name, value):
                Add an environment field to the trace.
                """
                def add_environment_field(self, name, value):

-                       ret = _bt_ctf_writer_add_environment_field(self._w, name, value)
+                       ret = _bt_ctf_writer_add_environment_field(self._w, str(name), str(value))

                        if ret < 0:
                                raise ValueError("Could not add environment field to trace.")
 
                        if ret < 0:
                                raise ValueError("Could not add environment field to trace.")
 


@@ -1857,7 +2169,8 @@ class CTFWriter:
                """
                Get the trace's TSDL meta-data.
                """
                """
                Get the trace's TSDL meta-data.
                """

-               def get_metadata(self):
+               @property
+               def metadata(self):

                        return _bt_ctf_writer_get_metadata_string(self._w)
 
                """
                        return _bt_ctf_writer_get_metadata_string(self._w)
 
                """


@@ -1866,11 +2179,20 @@ class CTFWriter:
                def flush_metadata(self):
                        _bt_ctf_writer_flush_metadata(self._w)
 
                def flush_metadata(self):
                        _bt_ctf_writer_flush_metadata(self._w)
 

+               """
+               Get the trace's byte order. Must be a constant from the ByteOrder
+               class.
+               """
+               @property
+               def byte_order(self):
+                       raise NotImplementedError("Getter not implemented.")
+

                """
                Set the trace's byte order. Must be a constant from the ByteOrder
                class. Defaults to BYTE_ORDER_NATIVE, the host machine's endianness.
                """
                """
                Set the trace's byte order. Must be a constant from the ByteOrder
                class. Defaults to BYTE_ORDER_NATIVE, the host machine's endianness.
                """

-               def set_byte_order(self, byte_order):
+               @byte_order.setter
+               def byte_order(self, byte_order):

                        ret = _bt_ctf_writer_set_byte_order(self._w, byte_order)
                        if ret < 0:
                                raise ValueError("Could not set trace's byte order.")
                        ret = _bt_ctf_writer_set_byte_order(self._w, byte_order)
                        if ret < 0:
                                raise ValueError("Could not set trace's byte order.")