X-Git-Url: http://git.efficios.com/?p=babeltrace.git;a=blobdiff_plain;f=bindings%2Fpython%2Fbabeltrace.i.in;h=5a06f0ba4639db4ca12a76723b5c5198e5779be9;hp=318b9b8c5ebcf688ad63e84fa194cb606a22f550;hb=e11b8d3a38c016ebbbc849e2b1aabf0a80a28ce4;hpb=e404272a241b2ec786e2c6f036f30c3b467316b6

diff --git a/bindings/python/babeltrace.i.in b/bindings/python/babeltrace.i.in
index 318b9b8c..5a06f0ba 100644
--- 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 int64_t ssize_t;
 
 /* =================================================================
 		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_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);
 
@@ -386,7 +393,7 @@ int bt_ctf_event_get_handle_id(const struct bt_ctf_event *event);
 
 %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
@@ -426,6 +433,22 @@ class TraceHandle(object):
 		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);
+%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);
@@ -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 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);
@@ -544,6 +570,14 @@ class CTFStringEncoding:
 	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
@@ -560,8 +594,8 @@ class CTFTypeId:
 	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:
@@ -569,7 +603,7 @@ class CTFTypeId:
 				break
 		return name
 
-class scope:
+class CTFScope:
 	TRACE_PACKET_HEADER = 0
 	STREAM_PACKET_CONTEXT = 1
 	STREAM_EVENT_HEADER = 2
@@ -577,9 +611,18 @@ class scope:
 	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
-_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):
@@ -762,55 +805,183 @@ class FieldError(Exception):
 	def __str__(self):
 		return repr(self.value)
 
-class EventDecl(object):
+class EventDeclaration(object):
 	"""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 _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):
-		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():
 	"""
@@ -820,32 +991,40 @@ def field_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):
@@ -854,66 +1033,29 @@ class _Definition(object):
 		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	
+	@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 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)
 
-	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
@@ -927,7 +1069,7 @@ class _Definition(object):
 			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.
@@ -935,7 +1077,7 @@ class _Definition(object):
 		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
@@ -947,7 +1089,7 @@ class _Definition(object):
 				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,
@@ -956,7 +1098,7 @@ class _Definition(object):
 		"""
 		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,
@@ -965,7 +1107,7 @@ class _Definition(object):
 		"""
 		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,
@@ -974,7 +1116,7 @@ class _Definition(object):
 		"""
 		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,
@@ -983,7 +1125,7 @@ class _Definition(object):
 		"""
 		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,
@@ -992,7 +1134,7 @@ class _Definition(object):
 		"""
 		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,
@@ -1001,7 +1143,7 @@ class _Definition(object):
 		"""
 		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,
@@ -1009,7 +1151,7 @@ class _Definition(object):
 		"""
 		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,
@@ -1026,40 +1168,53 @@ class _Definition(object):
 		"""
 		id = self.type
 		value = None
+
 		if id == CTFTypeId.STRING:
-			value = self.get_str()
+			value = self._get_str()
 		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:
-			if self.get_int_signedness() == 0:
-				value = self.get_uint64()
+			if self.declaration.signedness == 0:
+				value = self._get_uint64()
 			else:
-				value = self.get_int64()
+				value = self._get_int64()
 		elif id == CTFTypeId.ENUM:
-			value = self.get_enum_str()
+			value = self._get_enum_str()
 		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:
-			value = self.get_float()
+			value = self._get_float()
 		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 = {}
-			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():
-			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
@@ -1258,11 +1413,6 @@ void bt_ctf_writer_put(struct bt_ctf_writer *writer);
 %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):
@@ -1273,68 +1423,126 @@ class CTFWriter:
 		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.
 		"""
-		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.")
 
+		"""
+		Get the clock's frequency (Hz).
+		"""
+		@property
+		def frequency(self):
+			raise NotImplementedError("Getter not implemented.")
+
 		"""
 		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.")
 
+		"""
+		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).
 		"""
-		def set_precision(self, precision):
+		@precision.setter
+		def precision(self, 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.
 		"""
-		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.")
 
+		"""
+		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.
 		"""
-		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.")
 
+		"""
+		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.
 		"""
-		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.")
 
+		"""
+		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.
 		"""
-		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.")
 
-	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
@@ -1347,31 +1555,47 @@ class CTFWriter:
 
 		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)
 
+		"""
+		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.
 		"""
-		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.")
 
+		"""
+		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.
 		"""
-		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.")
 
-	class FieldTypeInteger(FieldType):
+	class IntegerFieldDeclaration(FieldDeclaration):
 		"""
 		Create a new integer field type of the given size.
 		"""
@@ -1380,37 +1604,62 @@ class CTFWriter:
 			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.")
 
 		"""
-		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.
 		"""
-		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.")
 
+		"""
+		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.
 		"""
-		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.")
 
-	class FieldTypeEnumeration(FieldType):
+	class EnumerationFieldDeclaration(FieldDeclaration):
 		"""
 		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)
@@ -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):
-			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.")
 
-	class FieldTypeFloatingPoint(FieldType):
+	class FloatFieldDeclaration(FieldDeclaration):
 		FLT_EXP_DIG = 8
 		DBL_EXP_DIG = 11
 		FLT_MANT_DIG = 24
@@ -1438,26 +1687,42 @@ class CTFWriter:
 			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.
 		"""
-		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.")
 
 		"""
-		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.
 		"""
-		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.")
 
-	class FieldTypeStructure(FieldType):
+	class StructureFieldDeclaration(FieldDeclaration):
 		"""
 		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):
-			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.")
 
-	class FieldTypeVariant(FieldType):
+	class VariantFieldDeclaration(FieldDeclaration):
 		"""
 		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):
-			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.")
 
-	class FieldTypeArray(FieldType):
+	class ArrayFieldDeclaration(FieldDeclaration):
 		"""
 		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__()
 
-	class FieldTypeSequence(FieldType):
+	class SequenceFieldDeclaration(FieldDeclaration):
 		"""
 		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__()
 
-	class FieldTypeString(FieldType):
+	class StringFieldDeclaration(FieldDeclaration):
 		"""
 		Create a new string field type.
 		"""
@@ -1516,10 +1781,18 @@ class CTFWriter:
 			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.
 		"""
-		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.")
@@ -1529,32 +1802,32 @@ class CTFWriter:
 	"""
 	@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):
-			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)
@@ -1567,14 +1840,14 @@ class CTFWriter:
 		@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)
@@ -1586,11 +1859,19 @@ class CTFWriter:
 			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.
 		"""
-		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.")
@@ -1603,82 +1884,107 @@ class CTFWriter:
 			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).
 		"""
-		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
 
-	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.
 		"""
-		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.")
 
-	class FieldStructure(Field):
+	class StructureField(Field):
 		"""
 		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)
 
-	class FieldVariant(Field):
+	class VariantField(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)
 
-	class FieldArray(Field):
+	class ArrayField(Field):
 		"""
 		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)
 
-	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).
 		"""
-		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.")
-			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".
 		"""
-		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)
 
-	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.
 		"""
-		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.")
 
@@ -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):
-			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.")
 
@@ -1720,18 +2026,18 @@ class CTFWriter:
 		"""
 		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.")
-			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.")
 
 		"""
-		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)
@@ -1748,10 +2054,18 @@ class CTFWriter:
 		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.
 		"""
-		def set_clock(self, clock):
+		@clock.setter
+		def clock(self, clock):
 			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
-		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):
@@ -1791,9 +2105,7 @@ class CTFWriter:
 		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
@@ -1841,7 +2153,7 @@ class CTFWriter:
 		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.")
 
@@ -1857,7 +2169,8 @@ class CTFWriter:
 		"""
 		Get the trace's TSDL meta-data.
 		"""
-		def get_metadata(self):
+		@property
+		def metadata(self):
 			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)
 
+		"""
+		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.
 		"""
-		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.")