Closure#
- class Closure(*args, **kwargs)#
A GClosure
represents a callback supplied by the programmer.
It will generally comprise a function of some kind and a marshaller
used to call it. It is the responsibility of the marshaller to
convert the arguments for the invocation from Value
into
a suitable form, perform the callback on the converted arguments,
and transform the return value back into a Value
.
In the case of C programs, a closure usually just holds a pointer
to a function and maybe a data argument, and the marshaller
converts between Value
and native C types. The GObject
library provides the GCClosure
type for this purpose. Bindings for
other languages need marshallers which convert between Value
and suitable representations in the runtime of the language in
order to use functions written in that language as callbacks. Use
set_marshal()
to set the marshaller on such a custom
closure implementation.
Within GObject, closures play an important role in the
implementation of signals. When a signal is registered, the
c_marshaller
argument to signal_new()
specifies the default C
marshaller for any closure which is connected to this
signal. GObject provides a number of C marshallers for this
purpose, see the ``g_cclosure_marshal_``*() functions. Additional C
marshallers can be generated with the [glib-genmarshal][glib-genmarshal]
utility. Closures can be explicitly connected to signals with
signal_connect_closure()
, but it usually more convenient to let
GObject create a closure automatically by using one of the
``g_signal_connect_``*() functions which take a callback function/user
data pair.
Using closures has a number of important advantages over a simple callback function/data pointer combination:
Closures allow the callee to get the types of the callback parameters, which means that language bindings don’t have to write individual glue for each callback type.
The reference counting of
Closure
makes it easy to handle reentrancy right; if a callback is removed while it is being invoked, the closure and its parameters won’t be freed until the invocation finishes.invalidate()
and invalidation notifiers allow callbacks to be automatically removed when the objects they point to go away.
Constructors#
- class Closure
- classmethod new_object(sizeof_closure: int, object: Object) Callable[[...], Any] #
A variant of
new_simple()
which storesobject
in thedata
field of the closure and callswatch_closure()
onobject
and the created closure. This function is mainly useful when implementing new types of closures.
- classmethod new_simple(sizeof_closure: int, data: None) Callable[[...], Any] #
Allocates a struct of the given size and initializes the initial part as a
Closure
.This function is mainly useful when implementing new types of closures:
typedef struct _MyClosure MyClosure; struct _MyClosure { GClosure closure; // extra data goes here }; static void my_closure_finalize (gpointer notify_data, GClosure *closure) { MyClosure *my_closure = (MyClosure *)closure; // free extra data here } MyClosure *my_closure_new (gpointer data) { GClosure *closure; MyClosure *my_closure; closure = g_closure_new_simple (sizeof (MyClosure), data); my_closure = (MyClosure *) closure; // initialize extra data here g_closure_add_finalize_notifier (closure, notify_data, my_closure_finalize); return my_closure; }
- Parameters:
sizeof_closure – the size of the structure to allocate, must be at least
sizeof (GClosure)
data – data to store in the
data
field of the newly allocatedClosure
Methods#
- class Closure
- invalidate() None #
Sets a flag on the closure to indicate that its calling environment has become invalid, and thus causes any future invocations of
invoke()
on thisclosure
to be ignored.Also, invalidation notifiers installed on the closure will be called at this point. Note that unless you are holding a reference to the closure yourself, the invalidation notifiers may unref the closure and cause it to be destroyed, so if you need to access the closure after calling
invalidate()
, make sure that you’ve previously calledref()
.Note that
invalidate()
will also be called when the reference count of a closure drops to zero (unless it has already been invalidated before).
- invoke(param_values: Sequence[Any], invocation_hint: None) Any #
Invokes the closure, i.e. executes the callback represented by the
closure
.- Parameters:
param_values – an array of
Value
holding the arguments on which to invoke the callback ofclosure
invocation_hint – a context-dependent invocation hint
- sink() None #
Takes over the initial ownership of a closure.
Each closure is initially created in a “floating” state, which means that the initial reference count is not owned by any caller.
This function checks to see if the object is still floating, and if so, unsets the floating state and decreases the reference count. If the closure is not floating,
sink()
does nothing.The reason for the existence of the floating state is to prevent cumbersome code sequences like:
closure = g_cclosure_new (cb_func, cb_data); g_source_set_closure (source, closure); g_closure_unref (closure); // GObject doesn't really need this
Because
source_set_closure()
(and similar functions) take ownership of the initial reference count, if it is unowned, we instead can write:g_source_set_closure (source, g_cclosure_new (cb_func, cb_data));
Generally, this function is used together with
ref()
. An example of storing a closure for later notification looks like:static GClosure *notify_closure = NULL; void foo_notify_set_closure (GClosure *closure) { if (notify_closure) g_closure_unref (notify_closure); notify_closure = closure; if (notify_closure) { g_closure_ref (notify_closure); g_closure_sink (notify_closure); } }
Because
sink()
may decrement the reference count of a closure (if it hasn’t been called onclosure
yet) just likeunref()
,ref()
should be called prior to this function.