/src/glib/gobject/gobject.h

Source (jump to first uncovered line)
/* GObject - GLib Type, Object, Parameter and Signal Library
 * Copyright (C) 1998-1999, 2000-2001 Tim Janik and Red Hat, Inc.
 *
 * SPDX-License-Identifier: LGPL-2.1-or-later
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General
 * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
 */
#ifndef __G_OBJECT_H__
#define __G_OBJECT_H__

#if !defined (__GLIB_GOBJECT_H_INSIDE__) && !defined (GOBJECT_COMPILATION)
#error "Only <glib-object.h> can be included directly."
#endif

#include        <gobject/gtype.h>
#include        <gobject/gvalue.h>
#include        <gobject/gparam.h>
#include        <gobject/gclosure.h>
#include        <gobject/gsignal.h>
#include        <gobject/gboxed.h>

G_BEGIN_DECLS

/* --- type macros --- */
/**
 * G_TYPE_IS_OBJECT:
 * @type: Type id to check
 * 
 * Check if the passed in type id is a %G_TYPE_OBJECT or derived from it.
 * 
 * Returns: %FALSE or %TRUE, indicating whether @type is a %G_TYPE_OBJECT.
 */
#define G_TYPE_IS_OBJECT(type)      (G_TYPE_FUNDAMENTAL (type) == G_TYPE_OBJECT)
/**
 * G_OBJECT:
 * @object: Object which is subject to casting.
 * 
 * Casts a #GObject or derived pointer into a (GObject*) pointer.
 *
 * Depending on the current debugging level, this function may invoke
 * certain runtime checks to identify invalid casts.
 */
#define G_OBJECT(object)            (G_TYPE_CHECK_INSTANCE_CAST ((object), G_TYPE_OBJECT, GObject))
/**
 * G_OBJECT_CLASS:
 * @class: a valid #GObjectClass
 * 
 * Casts a derived #GObjectClass structure into a #GObjectClass structure.
 */
#define G_OBJECT_CLASS(class)       (G_TYPE_CHECK_CLASS_CAST ((class), G_TYPE_OBJECT, GObjectClass))
/**
 * G_IS_OBJECT:
 * @object: Instance to check for being a %G_TYPE_OBJECT.
 * 
 * Checks whether a valid #GTypeInstance pointer is of type %G_TYPE_OBJECT.
 */
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_42
#define G_IS_OBJECT(object)         (G_TYPE_CHECK_INSTANCE_FUNDAMENTAL_TYPE ((object), G_TYPE_OBJECT))
#else
#define G_IS_OBJECT(object)         (G_TYPE_CHECK_INSTANCE_TYPE ((object), G_TYPE_OBJECT))
#endif
/**
 * G_IS_OBJECT_CLASS:
 * @class: a #GObjectClass
 * 
 * Checks whether @class "is a" valid #GObjectClass structure of type
 * %G_TYPE_OBJECT or derived.
 */
#define G_IS_OBJECT_CLASS(class)    (G_TYPE_CHECK_CLASS_TYPE ((class), G_TYPE_OBJECT))
/**
 * G_OBJECT_GET_CLASS:
 * @object: a #GObject instance.
 * 
 * Get the class structure associated to a #GObject instance.
 *
 * Returns: pointer to object class structure.
 */
#define G_OBJECT_GET_CLASS(object)  (G_TYPE_INSTANCE_GET_CLASS ((object), G_TYPE_OBJECT, GObjectClass))
/**
 * G_OBJECT_TYPE:
 * @object: Object to return the type id for.
 * 
 * Get the type id of an object.
 * 
 * Returns: Type id of @object.
 */
#define G_OBJECT_TYPE(object)       (G_TYPE_FROM_INSTANCE (object))
/**
 * G_OBJECT_TYPE_NAME:
 * @object: Object to return the type name for.
 * 
 * Get the name of an object's type.
 * 
 * Returns: Type name of @object. The string is owned by the type system and 
 *  should not be freed.
 */
#define G_OBJECT_TYPE_NAME(object)  (g_type_name (G_OBJECT_TYPE (object)))
/**
 * G_OBJECT_CLASS_TYPE:
 * @class: a valid #GObjectClass
 * 
 * Get the type id of a class structure.
 * 
 * Returns: Type id of @class.
 */
#define G_OBJECT_CLASS_TYPE(class)  (G_TYPE_FROM_CLASS (class))
/**
 * G_OBJECT_CLASS_NAME:
 * @class: a valid #GObjectClass
 * 
 * Return the name of a class structure's type.
 * 
 * Returns: Type name of @class. The string is owned by the type system and 
 *  should not be freed.
 */
#define G_OBJECT_CLASS_NAME(class)  (g_type_name (G_OBJECT_CLASS_TYPE (class)))
/**
 * G_VALUE_HOLDS_OBJECT:
 * @value: a valid #GValue structure
 * 
 * Checks whether the given #GValue can hold values derived from type %G_TYPE_OBJECT.
 * 
 * Returns: %TRUE on success.
 */
#define G_VALUE_HOLDS_OBJECT(value) (G_TYPE_CHECK_VALUE_TYPE ((value), G_TYPE_OBJECT))

/* --- type macros --- */
/**
 * G_TYPE_INITIALLY_UNOWNED:
 * 
 * The type for #GInitiallyUnowned.
 */
#define G_TYPE_INITIALLY_UNOWNED        (g_initially_unowned_get_type())
/**
 * G_INITIALLY_UNOWNED:
 * @object: Object which is subject to casting.
 * 
 * Casts a #GInitiallyUnowned or derived pointer into a (GInitiallyUnowned*) 
 * pointer.
 *
 * Depending on the current debugging level, this function may invoke
 * certain runtime checks to identify invalid casts.
 */
#define G_INITIALLY_UNOWNED(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), G_TYPE_INITIALLY_UNOWNED, GInitiallyUnowned))
/**
 * G_INITIALLY_UNOWNED_CLASS:
 * @class: a valid #GInitiallyUnownedClass
 * 
 * Casts a derived #GInitiallyUnownedClass structure into a
 * #GInitiallyUnownedClass structure.
 */
#define G_INITIALLY_UNOWNED_CLASS(class)      (G_TYPE_CHECK_CLASS_CAST ((class), G_TYPE_INITIALLY_UNOWNED, GInitiallyUnownedClass))
/**
 * G_IS_INITIALLY_UNOWNED:
 * @object: Instance to check for being a %G_TYPE_INITIALLY_UNOWNED.
 * 
 * Checks whether a valid #GTypeInstance pointer is of type %G_TYPE_INITIALLY_UNOWNED.
 */
#define G_IS_INITIALLY_UNOWNED(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), G_TYPE_INITIALLY_UNOWNED))
/**
 * G_IS_INITIALLY_UNOWNED_CLASS:
 * @class: a #GInitiallyUnownedClass
 * 
 * Checks whether @class "is a" valid #GInitiallyUnownedClass structure of type
 * %G_TYPE_INITIALLY_UNOWNED or derived.
 */
#define G_IS_INITIALLY_UNOWNED_CLASS(class)   (G_TYPE_CHECK_CLASS_TYPE ((class), G_TYPE_INITIALLY_UNOWNED))
/**
 * G_INITIALLY_UNOWNED_GET_CLASS:
 * @object: a #GInitiallyUnowned instance.
 * 
 * Get the class structure associated to a #GInitiallyUnowned instance.
 *
 * Returns: pointer to object class structure.
 */
#define G_INITIALLY_UNOWNED_GET_CLASS(object) (G_TYPE_INSTANCE_GET_CLASS ((object), G_TYPE_INITIALLY_UNOWNED, GInitiallyUnownedClass))
/* GInitiallyUnowned ia a GObject with initially floating reference count */


/* --- typedefs & structures --- */
typedef struct _GObject                  GObject;
typedef struct _GObjectClass             GObjectClass;
typedef struct _GObject                  GInitiallyUnowned;
typedef struct _GObjectClass             GInitiallyUnownedClass;
typedef struct _GObjectConstructParam    GObjectConstructParam;
/**
 * GObjectGetPropertyFunc:
 * @object: a #GObject
 * @property_id: the numeric id under which the property was registered with
 *  g_object_class_install_property().
 * @value: a #GValue to return the property value in
 * @pspec: the #GParamSpec describing the property
 * 
 * The type of the @get_property function of #GObjectClass. 
 */
typedef void (*GObjectGetPropertyFunc)  (GObject      *object,
                                         guint         property_id,
                                         GValue       *value,
                                         GParamSpec   *pspec);
/**
 * GObjectSetPropertyFunc:
 * @object: a #GObject
 * @property_id: the numeric id under which the property was registered with
 *  g_object_class_install_property().
 * @value: the new value for the property
 * @pspec: the #GParamSpec describing the property
 * 
 * The type of the @set_property function of #GObjectClass. 
 */
typedef void (*GObjectSetPropertyFunc)  (GObject      *object,
                                         guint         property_id,
                                         const GValue *value,
                                         GParamSpec   *pspec);
/**
 * GObjectFinalizeFunc:
 * @object: the #GObject being finalized
 * 
 * The type of the @finalize function of #GObjectClass.
 */
typedef void (*GObjectFinalizeFunc)     (GObject      *object);
/**
 * GWeakNotify:
 * @data: data that was provided when the weak reference was established
 * @where_the_object_was: the object being disposed
 * 
 * A #GWeakNotify function can be added to an object as a callback that gets
 * triggered when the object is finalized.
 *
 * Since the object is already being disposed when the #GWeakNotify is called,
 * there's not much you could do with the object, apart from e.g. using its
 * address as hash-index or the like.
 *
 * In particular, this means it’s invalid to call g_object_ref(),
 * g_weak_ref_init(), g_weak_ref_set(), g_object_add_toggle_ref(),
 * g_object_weak_ref(), g_object_add_weak_pointer() or any function which calls
 * them on the object from this callback.
 */
typedef void (*GWeakNotify)   (gpointer      data,
           GObject      *where_the_object_was);
/**
 * GObject:
 *
 * The base object type.
 * 
 * All the fields in the `GObject` structure are private to the implementation
 * and should never be accessed directly.
 *
 * Since GLib 2.72, all #GObjects are guaranteed to be aligned to at least the
 * alignment of the largest basic GLib type (typically this is #guint64 or
 * #gdouble). If you need larger alignment for an element in a #GObject, you
 * should allocate it on the heap (aligned), or arrange for your #GObject to be
 * appropriately padded. This guarantee applies to the #GObject (or derived)
 * struct, the #GObjectClass (or derived) struct, and any private data allocated
 * by G_ADD_PRIVATE().
 */
struct  _GObject
{
  GTypeInstance  g_type_instance;
  
  /*< private >*/
  guint          ref_count;  /* (atomic) */
  GData         *qdata;
};
/**
 * GObjectClass:
 * @g_type_class: the parent class
 * @constructor: the @constructor function is called by g_object_new () to 
 *  complete the object initialization after all the construction properties are
 *  set. The first thing a @constructor implementation must do is chain up to the
 *  @constructor of the parent class. Overriding @constructor should be rarely 
 *  needed, e.g. to handle construct properties, or to implement singletons.
 * @set_property: the generic setter for all properties of this type. Should be
 *  overridden for every type with properties. If implementations of
 *  @set_property don't emit property change notification explicitly, this will
 *  be done implicitly by the type system. However, if the notify signal is
 *  emitted explicitly, the type system will not emit it a second time.
 * @get_property: the generic getter for all properties of this type. Should be
 *  overridden for every type with properties.
 * @dispose: the @dispose function is supposed to drop all references to other 
 *  objects, but keep the instance otherwise intact, so that client method 
 *  invocations still work. It may be run multiple times (due to reference 
 *  loops). Before returning, @dispose should chain up to the @dispose method 
 *  of the parent class.
 * @finalize: instance finalization function, should finish the finalization of 
 *  the instance begun in @dispose and chain up to the @finalize method of the 
 *  parent class.
 * @dispatch_properties_changed: emits property change notification for a bunch
 *  of properties. Overriding @dispatch_properties_changed should be rarely 
 *  needed.
 * @notify: the class closure for the notify signal
 * @constructed: the @constructed function is called by g_object_new() as the
 *  final step of the object creation process.  At the point of the call, all
 *  construction properties have been set on the object.  The purpose of this
 *  call is to allow for object initialisation steps that can only be performed
 *  after construction properties have been set.  @constructed implementors
 *  should chain up to the @constructed call of their parent class to allow it
 *  to complete its initialisation.
 * 
 * The class structure for the GObject type.
 * 
 * |[<!-- language="C" -->
 * // Example of implementing a singleton using a constructor.
 * static MySingleton *the_singleton = NULL;
 * 
 * static GObject*
 * my_singleton_constructor (GType                  type,
 *                           guint                  n_construct_params,
 *                           GObjectConstructParam *construct_params)
 * {
 *   GObject *object;
 *   
 *   if (!the_singleton)
 *     {
 *       object = G_OBJECT_CLASS (parent_class)->constructor (type,
 *                                                            n_construct_params,
 *                                                            construct_params);
 *       the_singleton = MY_SINGLETON (object);
 *     }
 *   else
 *     object = g_object_ref (G_OBJECT (the_singleton));
 * 
 *   return object;
 * }
 * ]|
 */
struct  _GObjectClass
{
  GTypeClass   g_type_class;

  /*< private >*/
  GSList      *construct_properties;

  /*< public >*/
  /* seldom overridden */
  GObject*   (*constructor)     (GType                  type,
                                 guint                  n_construct_properties,
                                 GObjectConstructParam *construct_properties);
  /* overridable methods */
  void       (*set_property)    (GObject        *object,
                                         guint           property_id,
                                         const GValue   *value,
                                         GParamSpec     *pspec);
  void       (*get_property)    (GObject        *object,
                                         guint           property_id,
                                         GValue         *value,
                                         GParamSpec     *pspec);
  void       (*dispose)     (GObject        *object);
  void       (*finalize)    (GObject        *object);
  /* seldom overridden */
  void       (*dispatch_properties_changed) (GObject      *object,
               guint     n_pspecs,
               GParamSpec  **pspecs);
  /* signals */
  void       (*notify)      (GObject  *object,
           GParamSpec *pspec);

  /* called when done constructing */
  void       (*constructed)   (GObject  *object);

  /*< private >*/
  gsize   flags;

  gsize         n_construct_properties;

  gpointer pspecs;
  gsize n_pspecs;

  /* padding */
  gpointer  pdummy[3];
};

/**
 * GObjectConstructParam:
 * @pspec: the #GParamSpec of the construct parameter
 * @value: the value to set the parameter to
 * 
 * The GObjectConstructParam struct is an auxiliary structure used to hand
 * #GParamSpec/#GValue pairs to the @constructor of a #GObjectClass.
 */
struct _GObjectConstructParam
{
  GParamSpec *pspec;
  GValue     *value;
};

/**
 * GInitiallyUnowned:
 *
 * A type for objects that have an initially floating reference.
 * 
 * All the fields in the `GInitiallyUnowned` structure are private to the
 * implementation and should never be accessed directly.
 */
/**
 * GInitiallyUnownedClass:
 * 
 * The class structure for the GInitiallyUnowned type.
 */


/* --- prototypes --- */
GOBJECT_AVAILABLE_IN_ALL
GType       g_initially_unowned_get_type      (void);
GOBJECT_AVAILABLE_IN_ALL
void        g_object_class_install_property   (GObjectClass   *oclass,
                 guint           property_id,
                 GParamSpec     *pspec);
GOBJECT_AVAILABLE_IN_ALL
GParamSpec* g_object_class_find_property      (GObjectClass   *oclass,
                 const gchar    *property_name);
GOBJECT_AVAILABLE_IN_ALL
GParamSpec**g_object_class_list_properties    (GObjectClass   *oclass,
                 guint        *n_properties);
GOBJECT_AVAILABLE_IN_ALL
void        g_object_class_override_property  (GObjectClass   *oclass,
                 guint           property_id,
                 const gchar    *name);
GOBJECT_AVAILABLE_IN_ALL
void        g_object_class_install_properties (GObjectClass   *oclass,
                                               guint           n_pspecs,
                                               GParamSpec    **pspecs);

GOBJECT_AVAILABLE_IN_ALL
void        g_object_interface_install_property (gpointer     g_iface,
             GParamSpec  *pspec);
GOBJECT_AVAILABLE_IN_ALL
GParamSpec* g_object_interface_find_property    (gpointer     g_iface,
             const gchar *property_name);
GOBJECT_AVAILABLE_IN_ALL
GParamSpec**g_object_interface_list_properties  (gpointer     g_iface,
             guint       *n_properties_p);

GOBJECT_AVAILABLE_IN_ALL
GType       g_object_get_type                 (void) G_GNUC_CONST;
GOBJECT_AVAILABLE_IN_ALL
gpointer    g_object_new                      (GType           object_type,
                 const gchar    *first_property_name,
                 ...);
GOBJECT_AVAILABLE_IN_2_54
GObject*    g_object_new_with_properties      (GType           object_type,
                                               guint           n_properties,
                                               const char     *names[],
                                               const GValue    values[]);

G_GNUC_BEGIN_IGNORE_DEPRECATIONS

GOBJECT_DEPRECATED_IN_2_54_FOR(g_object_new_with_properties)
gpointer    g_object_newv         (GType           object_type,
                 guint         n_parameters,
                 GParameter     *parameters);

G_GNUC_END_IGNORE_DEPRECATIONS

GOBJECT_AVAILABLE_IN_ALL
GObject*    g_object_new_valist               (GType           object_type,
                 const gchar    *first_property_name,
                 va_list         var_args);
GOBJECT_AVAILABLE_IN_ALL
void      g_object_set                      (gpointer        object,
                 const gchar    *first_property_name,
                 ...) G_GNUC_NULL_TERMINATED;
GOBJECT_AVAILABLE_IN_ALL
void        g_object_get                      (gpointer        object,
                 const gchar    *first_property_name,
                 ...) G_GNUC_NULL_TERMINATED;
GOBJECT_AVAILABLE_IN_ALL
gpointer    g_object_connect                  (gpointer        object,
                 const gchar    *signal_spec,
                 ...) G_GNUC_NULL_TERMINATED;
GOBJECT_AVAILABLE_IN_ALL
void      g_object_disconnect               (gpointer        object,
                 const gchar    *signal_spec,
                 ...) G_GNUC_NULL_TERMINATED;
GOBJECT_AVAILABLE_IN_2_54
void        g_object_setv                     (GObject        *object,
                                               guint           n_properties,
                                               const gchar    *names[],
                                               const GValue    values[]);
GOBJECT_AVAILABLE_IN_ALL
void        g_object_set_valist               (GObject        *object,
                 const gchar    *first_property_name,
                 va_list         var_args);
GOBJECT_AVAILABLE_IN_2_54
void        g_object_getv                     (GObject        *object,
                                               guint           n_properties,
                                               const gchar    *names[],
                                               GValue          values[]);
GOBJECT_AVAILABLE_IN_ALL
void        g_object_get_valist               (GObject        *object,
                 const gchar    *first_property_name,
                 va_list         var_args);
GOBJECT_AVAILABLE_IN_ALL
void        g_object_set_property             (GObject        *object,
                 const gchar    *property_name,
                 const GValue   *value);
GOBJECT_AVAILABLE_IN_ALL
void        g_object_get_property             (GObject        *object,
                 const gchar    *property_name,
                 GValue         *value);
GOBJECT_AVAILABLE_IN_ALL
void        g_object_freeze_notify            (GObject        *object);
GOBJECT_AVAILABLE_IN_ALL
void        g_object_notify                   (GObject        *object,
                 const gchar    *property_name);
GOBJECT_AVAILABLE_IN_ALL
void        g_object_notify_by_pspec          (GObject        *object,
                 GParamSpec     *pspec);
GOBJECT_AVAILABLE_IN_ALL
void        g_object_thaw_notify              (GObject        *object);
GOBJECT_AVAILABLE_IN_ALL
gboolean    g_object_is_floating            (gpointer        object);
GOBJECT_AVAILABLE_IN_ALL
gpointer    g_object_ref_sink               (gpointer        object);
GOBJECT_AVAILABLE_IN_2_70
gpointer    g_object_take_ref                 (gpointer        object);
GOBJECT_AVAILABLE_IN_ALL
gpointer    g_object_ref                      (gpointer        object);
GOBJECT_AVAILABLE_IN_ALL
void        g_object_unref                    (gpointer        object);
GOBJECT_AVAILABLE_IN_ALL
void      g_object_weak_ref         (GObject        *object,
                 GWeakNotify     notify,
                 gpointer        data);
GOBJECT_AVAILABLE_IN_ALL
void      g_object_weak_unref         (GObject        *object,
                 GWeakNotify     notify,
                 gpointer        data);
GOBJECT_AVAILABLE_IN_ALL
void        g_object_add_weak_pointer         (GObject        *object, 
                                               gpointer       *weak_pointer_location);
GOBJECT_AVAILABLE_IN_ALL
void        g_object_remove_weak_pointer      (GObject        *object, 
                                               gpointer       *weak_pointer_location);

#if defined(glib_typeof) && GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_56
/* Make reference APIs type safe with macros */
#define g_object_ref(Obj) ((glib_typeof (Obj)) (g_object_ref) (Obj))
#define g_object_ref_sink(Obj) ((glib_typeof (Obj)) (g_object_ref_sink) (Obj))
#endif

/**
 * GToggleNotify:
 * @data: Callback data passed to g_object_add_toggle_ref()
 * @object: The object on which g_object_add_toggle_ref() was called.
 * @is_last_ref: %TRUE if the toggle reference is now the
 *  last reference to the object. %FALSE if the toggle
 *  reference was the last reference and there are now other
 *  references.
 * 
 * A callback function used for notification when the state
 * of a toggle reference changes.
 *
 * See also: g_object_add_toggle_ref()
 */
typedef void (*GToggleNotify) (gpointer      data,
             GObject      *object,
             gboolean      is_last_ref);

GOBJECT_AVAILABLE_IN_ALL
void g_object_add_toggle_ref    (GObject       *object,
         GToggleNotify  notify,
         gpointer       data);
GOBJECT_AVAILABLE_IN_ALL
void g_object_remove_toggle_ref (GObject       *object,
         GToggleNotify  notify,
         gpointer       data);

GOBJECT_AVAILABLE_IN_ALL
gpointer    g_object_get_qdata                (GObject        *object,
                 GQuark          quark);
GOBJECT_AVAILABLE_IN_ALL
void        g_object_set_qdata                (GObject        *object,
                 GQuark          quark,
                 gpointer        data);
GOBJECT_AVAILABLE_IN_ALL
void        g_object_set_qdata_full           (GObject        *object,
                 GQuark          quark,
                 gpointer        data,
                 GDestroyNotify  destroy);
GOBJECT_AVAILABLE_IN_ALL
gpointer    g_object_steal_qdata              (GObject        *object,
                 GQuark          quark);

GOBJECT_AVAILABLE_IN_2_34
gpointer    g_object_dup_qdata                (GObject        *object,
                                               GQuark          quark,
                                               GDuplicateFunc  dup_func,
                 gpointer         user_data);
GOBJECT_AVAILABLE_IN_2_34
gboolean    g_object_replace_qdata            (GObject        *object,
                                               GQuark          quark,
                                               gpointer        oldval,
                                               gpointer        newval,
                                               GDestroyNotify  destroy,
                 GDestroyNotify *old_destroy);

GOBJECT_AVAILABLE_IN_ALL
gpointer    g_object_get_data                 (GObject        *object,
                 const gchar    *key);
GOBJECT_AVAILABLE_IN_ALL
void        g_object_set_data                 (GObject        *object,
                 const gchar    *key,
                 gpointer        data);
GOBJECT_AVAILABLE_IN_ALL
void        g_object_set_data_full            (GObject        *object,
                 const gchar    *key,
                 gpointer        data,
                 GDestroyNotify  destroy);
GOBJECT_AVAILABLE_IN_ALL
gpointer    g_object_steal_data               (GObject        *object,
                 const gchar    *key);

GOBJECT_AVAILABLE_IN_2_34
gpointer    g_object_dup_data                 (GObject        *object,
                                               const gchar    *key,
                                               GDuplicateFunc  dup_func,
                 gpointer         user_data);
GOBJECT_AVAILABLE_IN_2_34
gboolean    g_object_replace_data             (GObject        *object,
                                               const gchar    *key,
                                               gpointer        oldval,
                                               gpointer        newval,
                                               GDestroyNotify  destroy,
                 GDestroyNotify *old_destroy);


GOBJECT_AVAILABLE_IN_ALL
void        g_object_watch_closure            (GObject        *object,
                 GClosure       *closure);
GOBJECT_AVAILABLE_IN_ALL
GClosure*   g_cclosure_new_object             (GCallback       callback_func,
                 GObject        *object);
GOBJECT_AVAILABLE_IN_ALL
GClosure*   g_cclosure_new_object_swap        (GCallback       callback_func,
                 GObject        *object);
GOBJECT_AVAILABLE_IN_ALL
GClosure*   g_closure_new_object              (guint           sizeof_closure,
                 GObject        *object);
GOBJECT_AVAILABLE_IN_ALL
void        g_value_set_object                (GValue         *value,
                 gpointer        v_object);
GOBJECT_AVAILABLE_IN_ALL
gpointer    g_value_get_object                (const GValue   *value);
GOBJECT_AVAILABLE_IN_ALL
gpointer    g_value_dup_object                (const GValue   *value);
GOBJECT_AVAILABLE_IN_ALL
gulong      g_signal_connect_object           (gpointer        instance,
                 const gchar    *detailed_signal,
                 GCallback       c_handler,
                 gpointer        gobject,
                 GConnectFlags   connect_flags);

/*< protected >*/
GOBJECT_AVAILABLE_IN_ALL
void        g_object_force_floating           (GObject        *object);
GOBJECT_AVAILABLE_IN_ALL
void        g_object_run_dispose        (GObject        *object);


GOBJECT_AVAILABLE_IN_ALL
void        g_value_take_object               (GValue         *value,
                 gpointer        v_object);
GOBJECT_DEPRECATED_FOR(g_value_take_object)
void        g_value_set_object_take_ownership (GValue         *value,
                                               gpointer        v_object);

GOBJECT_DEPRECATED
gsize     g_object_compat_control       (gsize         what,
                 gpointer        data);

/* --- implementation macros --- */
#define G_OBJECT_WARN_INVALID_PSPEC(object, pname, property_id, pspec) \
G_STMT_START { \
  GObject *_glib__object = (GObject*) (object); \
  GParamSpec *_glib__pspec = (GParamSpec*) (pspec); \
  guint _glib__property_id = (property_id); \
  g_warning ("%s:%d: invalid %s id %u for \"%s\" of type '%s' in '%s'", \
             __FILE__, __LINE__, \
             (pname), \
             _glib__property_id, \
             _glib__pspec->name, \
             g_type_name (G_PARAM_SPEC_TYPE (_glib__pspec)), \
             G_OBJECT_TYPE_NAME (_glib__object)); \
} G_STMT_END
/**
 * G_OBJECT_WARN_INVALID_PROPERTY_ID:
 * @object: the #GObject on which set_property() or get_property() was called
 * @property_id: the numeric id of the property
 * @pspec: the #GParamSpec of the property
 * 
 * This macro should be used to emit a standard warning about unexpected 
 * properties in set_property() and get_property() implementations.
 */
#define G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec) \
    G_OBJECT_WARN_INVALID_PSPEC ((object), "property", (property_id), (pspec))

GOBJECT_AVAILABLE_IN_ALL
void    g_clear_object (GObject **object_ptr);
#define g_clear_object(object_ptr) g_clear_pointer ((object_ptr), g_object_unref)

/**
 * g_set_object: (skip)
 * @object_ptr: (inout) (not optional) (nullable): a pointer to a #GObject reference
 * @new_object: (nullable) (transfer none): a pointer to the new #GObject to
 *   assign to @object_ptr, or %NULL to clear the pointer
 *
 * Updates a #GObject pointer to refer to @new_object.
 *
 * It increments the reference count of @new_object (if non-%NULL), decrements
 * the reference count of the current value of @object_ptr (if non-%NULL), and
 * assigns @new_object to @object_ptr. The assignment is not atomic.
 *
 * @object_ptr must not be %NULL, but can point to a %NULL value.
 *
 * A macro is also included that allows this function to be used without
 * pointer casts. The function itself is static inline, so its address may vary
 * between compilation units.
 *
 * One convenient usage of this function is in implementing property setters:
 * |[
 *   void
 *   foo_set_bar (Foo *foo,
 *                Bar *new_bar)
 *   {
 *     g_return_if_fail (IS_FOO (foo));
 *     g_return_if_fail (new_bar == NULL || IS_BAR (new_bar));
 *
 *     if (g_set_object (&foo->bar, new_bar))
 *       g_object_notify (foo, "bar");
 *   }
 * ]|
 *
 * Returns: %TRUE if the value of @object_ptr changed, %FALSE otherwise
 *
 * Since: 2.44
 */
static inline gboolean
(g_set_object) (GObject **object_ptr,
                GObject  *new_object)
{
  GObject *old_object = *object_ptr;

  /* rely on g_object_[un]ref() to check the pointers are actually GObjects;
   * elide a (object_ptr != NULL) check because most of the time we will be
   * operating on struct members with a constant offset, so a NULL check would
   * not catch bugs
   */

  if (old_object == new_object)
    return FALSE;

  if (new_object != NULL)
    g_object_ref (new_object);

  *object_ptr = new_object;

  if (old_object != NULL)
    g_object_unref (old_object);

  return TRUE;
}

/* We need GCC for __extension__, which we need to sort out strict aliasing of @object_ptr */
#if defined(__GNUC__)

#define g_set_object(object_ptr, new_object) \
  (G_GNUC_EXTENSION ({ \
    G_STATIC_ASSERT (sizeof *(object_ptr) == sizeof (new_object)); \
    /* Only one access, please; work around type aliasing */ \
    union { char *in; GObject **out; } _object_ptr; \
    _object_ptr.in = (char *) (object_ptr); \
    /* Check types match */ \
    (void) (0 ? *(object_ptr) = (new_object), FALSE : FALSE); \
    (g_set_object) (_object_ptr.out, (GObject *) new_object); \
  })) \
  GOBJECT_AVAILABLE_MACRO_IN_2_44

#else  /* if !defined(__GNUC__) */

#define g_set_object(object_ptr, new_object) \
 (/* Check types match. */ \
  0 ? *(object_ptr) = (new_object), FALSE : \
  (g_set_object) ((GObject **) (object_ptr), (GObject *) (new_object)) \
 )

#endif  /* !defined(__GNUC__) */

/**
 * g_assert_finalize_object: (skip)
 * @object: (transfer full) (type GObject.Object): an object
 *
 * Assert that @object is non-%NULL, then release one reference to it with
 * g_object_unref() and assert that it has been finalized (i.e. that there
 * are no more references).
 *
 * If assertions are disabled via `G_DISABLE_ASSERT`,
 * this macro just calls g_object_unref() without any further checks.
 *
 * This macro should only be used in regression tests.
 *
 * Since: 2.62
 */
static inline void
(g_assert_finalize_object) (GObject *object)
{
  gpointer weak_pointer = object;

  g_assert_true (G_IS_OBJECT (weak_pointer));
  g_object_add_weak_pointer (object, &weak_pointer);
  g_object_unref (weak_pointer);
  g_assert_null (weak_pointer);
}

#ifdef G_DISABLE_ASSERT
#define g_assert_finalize_object(object) g_object_unref (object)
#else
#define g_assert_finalize_object(object) (g_assert_finalize_object ((GObject *) object))
#endif

/**
 * g_clear_weak_pointer: (skip)
 * @weak_pointer_location: The memory address of a pointer
 *
 * Clears a weak reference to a #GObject.
 *
 * @weak_pointer_location must not be %NULL.
 *
 * If the weak reference is %NULL then this function does nothing.
 * Otherwise, the weak reference to the object is removed for that location
 * and the pointer is set to %NULL.
 *
 * A macro is also included that allows this function to be used without
 * pointer casts. The function itself is static inline, so its address may vary
 * between compilation units.
 *
 * Since: 2.56
 */
static inline void
(g_clear_weak_pointer) (gpointer *weak_pointer_location)
{
  GObject *object = (GObject *) *weak_pointer_location;

  if (object != NULL)
    {
      g_object_remove_weak_pointer (object, weak_pointer_location);
      *weak_pointer_location = NULL;
    }
}

#define g_clear_weak_pointer(weak_pointer_location) \
 (/* Check types match. */ \
  (g_clear_weak_pointer) ((gpointer *) (weak_pointer_location)) \
 )

/**
 * g_set_weak_pointer: (skip)
 * @weak_pointer_location: the memory address of a pointer
 * @new_object: (nullable) (transfer none): a pointer to the new #GObject to
 *   assign to it, or %NULL to clear the pointer
 *
 * Updates a pointer to weakly refer to @new_object.
 *
 * It assigns @new_object to @weak_pointer_location and ensures
 * that @weak_pointer_location will automatically be set to %NULL
 * if @new_object gets destroyed. The assignment is not atomic.
 * The weak reference is not thread-safe, see g_object_add_weak_pointer()
 * for details.
 *
 * The @weak_pointer_location argument must not be %NULL.
 *
 * A macro is also included that allows this function to be used without
 * pointer casts. The function itself is static inline, so its address may vary
 * between compilation units.
 *
 * One convenient usage of this function is in implementing property setters:
 * |[
 *   void
 *   foo_set_bar (Foo *foo,
 *                Bar *new_bar)
 *   {
 *     g_return_if_fail (IS_FOO (foo));
 *     g_return_if_fail (new_bar == NULL || IS_BAR (new_bar));
 *
 *     if (g_set_weak_pointer (&foo->bar, new_bar))
 *       g_object_notify (foo, "bar");
 *   }
 * ]|
 *
 * Returns: %TRUE if the value of @weak_pointer_location changed, %FALSE otherwise
 *
 * Since: 2.56
 */
static inline gboolean
(g_set_weak_pointer) (gpointer *weak_pointer_location,
                      GObject  *new_object)
{
  GObject *old_object = (GObject *) *weak_pointer_location;

  /* elide a (weak_pointer_location != NULL) check because most of the time we
   * will be operating on struct members with a constant offset, so a NULL
   * check would not catch bugs
   */

  if (old_object == new_object)
    return FALSE;

  if (old_object != NULL)
    g_object_remove_weak_pointer (old_object, weak_pointer_location);

  *weak_pointer_location = new_object;

  if (new_object != NULL)
    g_object_add_weak_pointer (new_object, weak_pointer_location);

  return TRUE;
}

#define g_set_weak_pointer(weak_pointer_location, new_object) \
 (/* Check types match. */ \
  0 ? *(weak_pointer_location) = (new_object), FALSE : \
  (g_set_weak_pointer) ((gpointer *) (weak_pointer_location), (GObject *) (new_object)) \
 )

typedef struct {
    /*<private>*/
    union { gpointer p; } priv;
} GWeakRef;

GOBJECT_AVAILABLE_IN_ALL
void     g_weak_ref_init       (GWeakRef *weak_ref,
                                gpointer  object);
GOBJECT_AVAILABLE_IN_ALL
void     g_weak_ref_clear      (GWeakRef *weak_ref);
GOBJECT_AVAILABLE_IN_ALL
gpointer g_weak_ref_get        (GWeakRef *weak_ref);
GOBJECT_AVAILABLE_IN_ALL
void     g_weak_ref_set        (GWeakRef *weak_ref,
                                gpointer  object);

G_END_DECLS

#endif /* __G_OBJECT_H__ */

Coverage Report

Created: 2025-06-13 06:55