tl;dr: Use g_set_object() to conveniently update owned object pointers in property setters (and elsewhere); see the bottom of the post for an example.
A little while ago, GLib gained a useful function called g_clear_object(), which clears an owned object pointer (a pointer which owns a reference to a GObject). GLib also just gained a function called g_set_object(), which works similarly but can either clear an object pointer or update it to point to a new object.
Why is this valuable? It saves a few lines of code each time an object pointer is updated, which isn’t much in itself. However, one thing it gets right is the order of reference counting operations, which is a common mistake in property setters. Instead of:
/* This is bad code. */ if (object_ptr != NULL) g_object_unref (object_ptr); if (new_object != NULL) g_object_ref (new_object); object_ptr = new_object;
you should always do:
/* This is better code. */ if (new_object != NULL) g_object_ref (new_object); if (object_ptr != NULL) g_object_unref (object_ptr); object_ptr = new_object;
because otherwise, if (new_object == object_ptr) and the object only has one reference left, object_ptr will end up pointing to a finalised GObject (and g_object_ref() will be called on a finalised GObject too, which it really won’t like).
So how does g_set_object() help? We can now do:
g_set_object (&object_ptr, new_object);
which takes care of all the reference counting, and allows new_object to be NULL. &object_ptr must not be NULL. If you’re worried about performance, never fear. g_set_object() is a static inline function, so shouldn’t adversely affect your code size.
Even better, the return value of g_set_pointer() indicates whether the value changed, so we can conveniently base GObject::notify emissions off it:
/* This is how all GObject property setters should look in future. */ if (g_set_object (&priv->object_ptr, new_object)) g_object_notify (self, "object-ptr");
Hopefully this will make property setters (and other object updates) simpler in new code.