| /* GLIB - Library of useful routines for C programming |
| * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald |
| * |
| * GHook: Callback maintenance functions |
| * Copyright (C) 1998 Tim Janik |
| * |
| * 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/>. |
| */ |
| |
| /* |
| * Modified by the GLib Team and others 1997-2000. See the AUTHORS |
| * file for a list of people on the GLib Team. See the ChangeLog |
| * files for a list of changes. These files are distributed with |
| * GLib at ftp://ftp.gtk.org/pub/gtk/. |
| */ |
| |
| /* |
| * MT safe |
| */ |
| |
| #include "config.h" |
| |
| #include "ghook.h" |
| |
| #include "gtestutils.h" |
| #include "gslice.h" |
| |
| /** |
| * GHookList: |
| * @seq_id: the next free #GHook id |
| * @hook_size: the size of the #GHookList elements, in bytes |
| * @is_setup: 1 if the #GHookList has been initialized |
| * @hooks: the first #GHook element in the list |
| * @dummy3: unused |
| * @finalize_hook: the function to call to finalize a #GHook element. |
| * The default behaviour is to call the hooks @destroy function |
| * @dummy: unused |
| * |
| * The #GHookList struct represents a list of hook functions. |
| */ |
| |
| /** |
| * GHookFinalizeFunc: |
| * @hook_list: a #GHookList |
| * @hook: the hook in @hook_list that gets finalized |
| * |
| * Defines the type of function to be called when a hook in a |
| * list of hooks gets finalized. |
| */ |
| |
| /** |
| * GHookFlagMask: |
| * @G_HOOK_FLAG_ACTIVE: set if the hook has not been destroyed |
| * @G_HOOK_FLAG_IN_CALL: set if the hook is currently being run |
| * @G_HOOK_FLAG_MASK: A mask covering all bits reserved for |
| * hook flags; see %G_HOOK_FLAG_USER_SHIFT |
| * |
| * Flags used internally in the #GHook implementation. |
| */ |
| |
| /** |
| * G_HOOK_FLAGS: |
| * @hook: a #GHook |
| * |
| * Gets the flags of a hook. |
| */ |
| |
| /** |
| * G_HOOK_FLAG_USER_SHIFT: |
| * |
| * The position of the first bit which is not reserved for internal |
| * use be the #GHook implementation, i.e. |
| * `1 << G_HOOK_FLAG_USER_SHIFT` is the first |
| * bit which can be used for application-defined flags. |
| */ |
| |
| /** |
| * G_HOOK: |
| * @hook: a pointer |
| * |
| * Casts a pointer to a `GHook*`. |
| */ |
| |
| /** |
| * G_HOOK_IS_VALID: |
| * @hook: a #GHook |
| * |
| * Returns %TRUE if the #GHook is valid, i.e. it is in a #GHookList, |
| * it is active and it has not been destroyed. |
| * |
| * Returns: %TRUE if the #GHook is valid |
| */ |
| |
| /** |
| * G_HOOK_ACTIVE: |
| * @hook: a #GHook |
| * |
| * Returns %TRUE if the #GHook is active, which is normally the case |
| * until the #GHook is destroyed. |
| * |
| * Returns: %TRUE if the #GHook is active |
| */ |
| |
| /** |
| * G_HOOK_IN_CALL: |
| * @hook: a #GHook |
| * |
| * Returns %TRUE if the #GHook function is currently executing. |
| * |
| * Returns: %TRUE if the #GHook function is currently executing |
| */ |
| |
| /** |
| * G_HOOK_IS_UNLINKED: |
| * @hook: a #GHook |
| * |
| * Returns %TRUE if the #GHook is not in a #GHookList. |
| * |
| * Returns: %TRUE if the #GHook is not in a #GHookList |
| */ |
| |
| /** |
| * GHook: |
| * @data: data which is passed to func when this hook is invoked |
| * @next: pointer to the next hook in the list |
| * @prev: pointer to the previous hook in the list |
| * @ref_count: the reference count of this hook |
| * @hook_id: the id of this hook, which is unique within its list |
| * @flags: flags which are set for this hook. See #GHookFlagMask for |
| * predefined flags |
| * @func: the function to call when this hook is invoked. The possible |
| * signatures for this function are #GHookFunc and #GHookCheckFunc |
| * @destroy: the default @finalize_hook function of a #GHookList calls |
| * this member of the hook that is being finalized |
| * |
| * The #GHook struct represents a single hook function in a #GHookList. |
| */ |
| |
| /** |
| * GHookFunc: |
| * @data: the data field of the #GHook is passed to the hook function here |
| * |
| * Defines the type of a hook function that can be invoked |
| * by g_hook_list_invoke(). |
| */ |
| |
| /** |
| * GHookCheckFunc: |
| * @data: the data field of the #GHook is passed to the hook function here |
| * |
| * Defines the type of a hook function that can be invoked |
| * by g_hook_list_invoke_check(). |
| * |
| * Returns: %FALSE if the #GHook should be destroyed |
| */ |
| |
| /* --- functions --- */ |
| static void |
| default_finalize_hook (GHookList *hook_list, |
| GHook *hook) |
| { |
| GDestroyNotify destroy = hook->destroy; |
| |
| if (destroy) |
| { |
| hook->destroy = NULL; |
| destroy (hook->data); |
| } |
| } |
| |
| /** |
| * g_hook_list_init: |
| * @hook_list: a #GHookList |
| * @hook_size: the size of each element in the #GHookList, |
| * typically `sizeof (GHook)`. |
| * |
| * Initializes a #GHookList. |
| * This must be called before the #GHookList is used. |
| */ |
| void |
| g_hook_list_init (GHookList *hook_list, |
| guint hook_size) |
| { |
| g_return_if_fail (hook_list != NULL); |
| g_return_if_fail (hook_size >= sizeof (GHook)); |
| |
| hook_list->seq_id = 1; |
| hook_list->hook_size = hook_size; |
| hook_list->is_setup = TRUE; |
| hook_list->hooks = NULL; |
| hook_list->dummy3 = NULL; |
| hook_list->finalize_hook = default_finalize_hook; |
| hook_list->dummy[0] = NULL; |
| hook_list->dummy[1] = NULL; |
| } |
| |
| /** |
| * g_hook_list_clear: |
| * @hook_list: a #GHookList |
| * |
| * Removes all the #GHook elements from a #GHookList. |
| */ |
| void |
| g_hook_list_clear (GHookList *hook_list) |
| { |
| g_return_if_fail (hook_list != NULL); |
| |
| if (hook_list->is_setup) |
| { |
| GHook *hook; |
| |
| hook_list->is_setup = FALSE; |
| |
| hook = hook_list->hooks; |
| if (!hook) |
| { |
| /* destroy hook_list->hook_memchunk */ |
| } |
| else |
| do |
| { |
| GHook *tmp; |
| |
| g_hook_ref (hook_list, hook); |
| g_hook_destroy_link (hook_list, hook); |
| tmp = hook->next; |
| g_hook_unref (hook_list, hook); |
| hook = tmp; |
| } |
| while (hook); |
| } |
| } |
| |
| /** |
| * g_hook_alloc: |
| * @hook_list: a #GHookList |
| * |
| * Allocates space for a #GHook and initializes it. |
| * |
| * Returns: a new #GHook |
| */ |
| GHook* |
| g_hook_alloc (GHookList *hook_list) |
| { |
| GHook *hook; |
| |
| g_return_val_if_fail (hook_list != NULL, NULL); |
| g_return_val_if_fail (hook_list->is_setup, NULL); |
| |
| hook = g_slice_alloc0 (hook_list->hook_size); |
| hook->data = NULL; |
| hook->next = NULL; |
| hook->prev = NULL; |
| hook->flags = G_HOOK_FLAG_ACTIVE; |
| hook->ref_count = 0; |
| hook->hook_id = 0; |
| hook->func = NULL; |
| hook->destroy = NULL; |
| |
| return hook; |
| } |
| /** |
| * g_hook_free: |
| * @hook_list: a #GHookList |
| * @hook: the #GHook to free |
| * |
| * Calls the #GHookList @finalize_hook function if it exists, |
| * and frees the memory allocated for the #GHook. |
| */ |
| void |
| g_hook_free (GHookList *hook_list, |
| GHook *hook) |
| { |
| g_return_if_fail (hook_list != NULL); |
| g_return_if_fail (hook_list->is_setup); |
| g_return_if_fail (hook != NULL); |
| g_return_if_fail (G_HOOK_IS_UNLINKED (hook)); |
| g_return_if_fail (!G_HOOK_IN_CALL (hook)); |
| |
| if(hook_list->finalize_hook != NULL) |
| hook_list->finalize_hook (hook_list, hook); |
| g_slice_free1 (hook_list->hook_size, hook); |
| } |
| |
| /** |
| * g_hook_destroy_link: |
| * @hook_list: a #GHookList |
| * @hook: the #GHook to remove |
| * |
| * Removes one #GHook from a #GHookList, marking it |
| * inactive and calling g_hook_unref() on it. |
| */ |
| void |
| g_hook_destroy_link (GHookList *hook_list, |
| GHook *hook) |
| { |
| g_return_if_fail (hook_list != NULL); |
| g_return_if_fail (hook != NULL); |
| |
| hook->flags &= ~G_HOOK_FLAG_ACTIVE; |
| if (hook->hook_id) |
| { |
| hook->hook_id = 0; |
| g_hook_unref (hook_list, hook); /* counterpart to g_hook_insert_before */ |
| } |
| } |
| |
| /** |
| * g_hook_destroy: |
| * @hook_list: a #GHookList |
| * @hook_id: a hook ID |
| * |
| * Destroys a #GHook, given its ID. |
| * |
| * Returns: %TRUE if the #GHook was found in the #GHookList and destroyed |
| */ |
| gboolean |
| g_hook_destroy (GHookList *hook_list, |
| gulong hook_id) |
| { |
| GHook *hook; |
| |
| g_return_val_if_fail (hook_list != NULL, FALSE); |
| g_return_val_if_fail (hook_id > 0, FALSE); |
| |
| hook = g_hook_get (hook_list, hook_id); |
| if (hook) |
| { |
| g_hook_destroy_link (hook_list, hook); |
| return TRUE; |
| } |
| |
| return FALSE; |
| } |
| |
| /** |
| * g_hook_unref: |
| * @hook_list: a #GHookList |
| * @hook: the #GHook to unref |
| * |
| * Decrements the reference count of a #GHook. |
| * If the reference count falls to 0, the #GHook is removed |
| * from the #GHookList and g_hook_free() is called to free it. |
| */ |
| void |
| g_hook_unref (GHookList *hook_list, |
| GHook *hook) |
| { |
| g_return_if_fail (hook_list != NULL); |
| g_return_if_fail (hook != NULL); |
| g_return_if_fail (hook->ref_count > 0); |
| |
| hook->ref_count--; |
| if (!hook->ref_count) |
| { |
| g_return_if_fail (hook->hook_id == 0); |
| g_return_if_fail (!G_HOOK_IN_CALL (hook)); |
| |
| if (hook->prev) |
| hook->prev->next = hook->next; |
| else |
| hook_list->hooks = hook->next; |
| if (hook->next) |
| { |
| hook->next->prev = hook->prev; |
| hook->next = NULL; |
| } |
| hook->prev = NULL; |
| |
| if (!hook_list->is_setup) |
| { |
| hook_list->is_setup = TRUE; |
| g_hook_free (hook_list, hook); |
| hook_list->is_setup = FALSE; |
| |
| if (!hook_list->hooks) |
| { |
| /* destroy hook_list->hook_memchunk */ |
| } |
| } |
| else |
| g_hook_free (hook_list, hook); |
| } |
| } |
| |
| /** |
| * g_hook_ref: |
| * @hook_list: a #GHookList |
| * @hook: the #GHook to increment the reference count of |
| * |
| * Increments the reference count for a #GHook. |
| * |
| * Returns: the @hook that was passed in (since 2.6) |
| */ |
| GHook * |
| g_hook_ref (GHookList *hook_list, |
| GHook *hook) |
| { |
| g_return_val_if_fail (hook_list != NULL, NULL); |
| g_return_val_if_fail (hook != NULL, NULL); |
| g_return_val_if_fail (hook->ref_count > 0, NULL); |
| |
| hook->ref_count++; |
| |
| return hook; |
| } |
| |
| /** |
| * g_hook_append: |
| * @hook_list: a #GHookList |
| * @hook: the #GHook to add to the end of @hook_list |
| * |
| * Appends a #GHook onto the end of a #GHookList. |
| */ |
| |
| /** |
| * g_hook_prepend: |
| * @hook_list: a #GHookList |
| * @hook: the #GHook to add to the start of @hook_list |
| * |
| * Prepends a #GHook on the start of a #GHookList. |
| */ |
| void |
| g_hook_prepend (GHookList *hook_list, |
| GHook *hook) |
| { |
| g_return_if_fail (hook_list != NULL); |
| |
| g_hook_insert_before (hook_list, hook_list->hooks, hook); |
| } |
| |
| /** |
| * g_hook_insert_before: |
| * @hook_list: a #GHookList |
| * @sibling: (nullable): the #GHook to insert the new #GHook before |
| * @hook: the #GHook to insert |
| * |
| * Inserts a #GHook into a #GHookList, before a given #GHook. |
| */ |
| void |
| g_hook_insert_before (GHookList *hook_list, |
| GHook *sibling, |
| GHook *hook) |
| { |
| g_return_if_fail (hook_list != NULL); |
| g_return_if_fail (hook_list->is_setup); |
| g_return_if_fail (hook != NULL); |
| g_return_if_fail (G_HOOK_IS_UNLINKED (hook)); |
| g_return_if_fail (hook->ref_count == 0); |
| |
| hook->hook_id = hook_list->seq_id++; |
| hook->ref_count = 1; /* counterpart to g_hook_destroy_link */ |
| |
| if (sibling) |
| { |
| if (sibling->prev) |
| { |
| hook->prev = sibling->prev; |
| hook->prev->next = hook; |
| hook->next = sibling; |
| sibling->prev = hook; |
| } |
| else |
| { |
| hook_list->hooks = hook; |
| hook->next = sibling; |
| sibling->prev = hook; |
| } |
| } |
| else |
| { |
| if (hook_list->hooks) |
| { |
| sibling = hook_list->hooks; |
| while (sibling->next) |
| sibling = sibling->next; |
| hook->prev = sibling; |
| sibling->next = hook; |
| } |
| else |
| hook_list->hooks = hook; |
| } |
| } |
| |
| /** |
| * g_hook_list_invoke: |
| * @hook_list: a #GHookList |
| * @may_recurse: %TRUE if functions which are already running |
| * (e.g. in another thread) can be called. If set to %FALSE, |
| * these are skipped |
| * |
| * Calls all of the #GHook functions in a #GHookList. |
| */ |
| void |
| g_hook_list_invoke (GHookList *hook_list, |
| gboolean may_recurse) |
| { |
| GHook *hook; |
| |
| g_return_if_fail (hook_list != NULL); |
| g_return_if_fail (hook_list->is_setup); |
| |
| hook = g_hook_first_valid (hook_list, may_recurse); |
| while (hook) |
| { |
| GHookFunc func; |
| gboolean was_in_call; |
| |
| func = (GHookFunc) hook->func; |
| |
| was_in_call = G_HOOK_IN_CALL (hook); |
| hook->flags |= G_HOOK_FLAG_IN_CALL; |
| func (hook->data); |
| if (!was_in_call) |
| hook->flags &= ~G_HOOK_FLAG_IN_CALL; |
| |
| hook = g_hook_next_valid (hook_list, hook, may_recurse); |
| } |
| } |
| |
| /** |
| * g_hook_list_invoke_check: |
| * @hook_list: a #GHookList |
| * @may_recurse: %TRUE if functions which are already running |
| * (e.g. in another thread) can be called. If set to %FALSE, |
| * these are skipped |
| * |
| * Calls all of the #GHook functions in a #GHookList. |
| * Any function which returns %FALSE is removed from the #GHookList. |
| */ |
| void |
| g_hook_list_invoke_check (GHookList *hook_list, |
| gboolean may_recurse) |
| { |
| GHook *hook; |
| |
| g_return_if_fail (hook_list != NULL); |
| g_return_if_fail (hook_list->is_setup); |
| |
| hook = g_hook_first_valid (hook_list, may_recurse); |
| while (hook) |
| { |
| GHookCheckFunc func; |
| gboolean was_in_call; |
| gboolean need_destroy; |
| |
| func = (GHookCheckFunc) hook->func; |
| |
| was_in_call = G_HOOK_IN_CALL (hook); |
| hook->flags |= G_HOOK_FLAG_IN_CALL; |
| need_destroy = !func (hook->data); |
| if (!was_in_call) |
| hook->flags &= ~G_HOOK_FLAG_IN_CALL; |
| if (need_destroy) |
| g_hook_destroy_link (hook_list, hook); |
| |
| hook = g_hook_next_valid (hook_list, hook, may_recurse); |
| } |
| } |
| |
| /** |
| * GHookCheckMarshaller: |
| * @hook: a #GHook |
| * @marshal_data: user data |
| * |
| * Defines the type of function used by g_hook_list_marshal_check(). |
| * |
| * Returns: %FALSE if @hook should be destroyed |
| */ |
| |
| /** |
| * g_hook_list_marshal_check: |
| * @hook_list: a #GHookList |
| * @may_recurse: %TRUE if hooks which are currently running |
| * (e.g. in another thread) are considered valid. If set to %FALSE, |
| * these are skipped |
| * @marshaller: (scope call): the function to call for each #GHook |
| * @marshal_data: data to pass to @marshaller |
| * |
| * Calls a function on each valid #GHook and destroys it if the |
| * function returns %FALSE. |
| */ |
| void |
| g_hook_list_marshal_check (GHookList *hook_list, |
| gboolean may_recurse, |
| GHookCheckMarshaller marshaller, |
| gpointer data) |
| { |
| GHook *hook; |
| |
| g_return_if_fail (hook_list != NULL); |
| g_return_if_fail (hook_list->is_setup); |
| g_return_if_fail (marshaller != NULL); |
| |
| hook = g_hook_first_valid (hook_list, may_recurse); |
| while (hook) |
| { |
| gboolean was_in_call; |
| gboolean need_destroy; |
| |
| was_in_call = G_HOOK_IN_CALL (hook); |
| hook->flags |= G_HOOK_FLAG_IN_CALL; |
| need_destroy = !marshaller (hook, data); |
| if (!was_in_call) |
| hook->flags &= ~G_HOOK_FLAG_IN_CALL; |
| if (need_destroy) |
| g_hook_destroy_link (hook_list, hook); |
| |
| hook = g_hook_next_valid (hook_list, hook, may_recurse); |
| } |
| } |
| |
| /** |
| * GHookMarshaller: |
| * @hook: a #GHook |
| * @marshal_data: user data |
| * |
| * Defines the type of function used by g_hook_list_marshal(). |
| */ |
| |
| /** |
| * g_hook_list_marshal: |
| * @hook_list: a #GHookList |
| * @may_recurse: %TRUE if hooks which are currently running |
| * (e.g. in another thread) are considered valid. If set to %FALSE, |
| * these are skipped |
| * @marshaller: (scope call): the function to call for each #GHook |
| * @marshal_data: data to pass to @marshaller |
| * |
| * Calls a function on each valid #GHook. |
| */ |
| void |
| g_hook_list_marshal (GHookList *hook_list, |
| gboolean may_recurse, |
| GHookMarshaller marshaller, |
| gpointer data) |
| { |
| GHook *hook; |
| |
| g_return_if_fail (hook_list != NULL); |
| g_return_if_fail (hook_list->is_setup); |
| g_return_if_fail (marshaller != NULL); |
| |
| hook = g_hook_first_valid (hook_list, may_recurse); |
| while (hook) |
| { |
| gboolean was_in_call; |
| |
| was_in_call = G_HOOK_IN_CALL (hook); |
| hook->flags |= G_HOOK_FLAG_IN_CALL; |
| marshaller (hook, data); |
| if (!was_in_call) |
| hook->flags &= ~G_HOOK_FLAG_IN_CALL; |
| |
| hook = g_hook_next_valid (hook_list, hook, may_recurse); |
| } |
| } |
| |
| /** |
| * g_hook_first_valid: |
| * @hook_list: a #GHookList |
| * @may_be_in_call: %TRUE if hooks which are currently running |
| * (e.g. in another thread) are considered valid. If set to %FALSE, |
| * these are skipped |
| * |
| * Returns the first #GHook in a #GHookList which has not been destroyed. |
| * The reference count for the #GHook is incremented, so you must call |
| * g_hook_unref() to restore it when no longer needed. (Or call |
| * g_hook_next_valid() if you are stepping through the #GHookList.) |
| * |
| * Returns: the first valid #GHook, or %NULL if none are valid |
| */ |
| GHook* |
| g_hook_first_valid (GHookList *hook_list, |
| gboolean may_be_in_call) |
| { |
| g_return_val_if_fail (hook_list != NULL, NULL); |
| |
| if (hook_list->is_setup) |
| { |
| GHook *hook; |
| |
| hook = hook_list->hooks; |
| if (hook) |
| { |
| g_hook_ref (hook_list, hook); |
| if (G_HOOK_IS_VALID (hook) && (may_be_in_call || !G_HOOK_IN_CALL (hook))) |
| return hook; |
| else |
| return g_hook_next_valid (hook_list, hook, may_be_in_call); |
| } |
| } |
| |
| return NULL; |
| } |
| |
| /** |
| * g_hook_next_valid: |
| * @hook_list: a #GHookList |
| * @hook: the current #GHook |
| * @may_be_in_call: %TRUE if hooks which are currently running |
| * (e.g. in another thread) are considered valid. If set to %FALSE, |
| * these are skipped |
| * |
| * Returns the next #GHook in a #GHookList which has not been destroyed. |
| * The reference count for the #GHook is incremented, so you must call |
| * g_hook_unref() to restore it when no longer needed. (Or continue to call |
| * g_hook_next_valid() until %NULL is returned.) |
| * |
| * Returns: the next valid #GHook, or %NULL if none are valid |
| */ |
| GHook* |
| g_hook_next_valid (GHookList *hook_list, |
| GHook *hook, |
| gboolean may_be_in_call) |
| { |
| GHook *ohook = hook; |
| |
| g_return_val_if_fail (hook_list != NULL, NULL); |
| |
| if (!hook) |
| return NULL; |
| |
| hook = hook->next; |
| while (hook) |
| { |
| if (G_HOOK_IS_VALID (hook) && (may_be_in_call || !G_HOOK_IN_CALL (hook))) |
| { |
| g_hook_ref (hook_list, hook); |
| g_hook_unref (hook_list, ohook); |
| |
| return hook; |
| } |
| hook = hook->next; |
| } |
| g_hook_unref (hook_list, ohook); |
| |
| return NULL; |
| } |
| |
| /** |
| * g_hook_get: |
| * @hook_list: a #GHookList |
| * @hook_id: a hook id |
| * |
| * Returns the #GHook with the given id, or %NULL if it is not found. |
| * |
| * Returns: the #GHook with the given id, or %NULL if it is not found |
| */ |
| GHook* |
| g_hook_get (GHookList *hook_list, |
| gulong hook_id) |
| { |
| GHook *hook; |
| |
| g_return_val_if_fail (hook_list != NULL, NULL); |
| g_return_val_if_fail (hook_id > 0, NULL); |
| |
| hook = hook_list->hooks; |
| while (hook) |
| { |
| if (hook->hook_id == hook_id) |
| return hook; |
| hook = hook->next; |
| } |
| |
| return NULL; |
| } |
| |
| /** |
| * GHookFindFunc: |
| * @hook: a #GHook |
| * @data: user data passed to g_hook_find_func() |
| * |
| * Defines the type of the function passed to g_hook_find(). |
| * |
| * Returns: %TRUE if the required #GHook has been found |
| */ |
| |
| /** |
| * g_hook_find: |
| * @hook_list: a #GHookList |
| * @need_valids: %TRUE if #GHook elements which have been destroyed |
| * should be skipped |
| * @func: (scope call): the function to call for each #GHook, which should return |
| * %TRUE when the #GHook has been found |
| * @data: the data to pass to @func |
| * |
| * Finds a #GHook in a #GHookList using the given function to |
| * test for a match. |
| * |
| * Returns: the found #GHook or %NULL if no matching #GHook is found |
| */ |
| GHook* |
| g_hook_find (GHookList *hook_list, |
| gboolean need_valids, |
| GHookFindFunc func, |
| gpointer data) |
| { |
| GHook *hook; |
| |
| g_return_val_if_fail (hook_list != NULL, NULL); |
| g_return_val_if_fail (func != NULL, NULL); |
| |
| hook = hook_list->hooks; |
| while (hook) |
| { |
| GHook *tmp; |
| |
| /* test only non-destroyed hooks */ |
| if (!hook->hook_id) |
| { |
| hook = hook->next; |
| continue; |
| } |
| |
| g_hook_ref (hook_list, hook); |
| |
| if (func (hook, data) && hook->hook_id && (!need_valids || G_HOOK_ACTIVE (hook))) |
| { |
| g_hook_unref (hook_list, hook); |
| |
| return hook; |
| } |
| |
| tmp = hook->next; |
| g_hook_unref (hook_list, hook); |
| hook = tmp; |
| } |
| |
| return NULL; |
| } |
| |
| /** |
| * g_hook_find_data: |
| * @hook_list: a #GHookList |
| * @need_valids: %TRUE if #GHook elements which have been destroyed |
| * should be skipped |
| * @data: the data to find |
| * |
| * Finds a #GHook in a #GHookList with the given data. |
| * |
| * Returns: the #GHook with the given @data or %NULL if no matching |
| * #GHook is found |
| */ |
| GHook* |
| g_hook_find_data (GHookList *hook_list, |
| gboolean need_valids, |
| gpointer data) |
| { |
| GHook *hook; |
| |
| g_return_val_if_fail (hook_list != NULL, NULL); |
| |
| hook = hook_list->hooks; |
| while (hook) |
| { |
| /* test only non-destroyed hooks */ |
| if (hook->data == data && |
| hook->hook_id && |
| (!need_valids || G_HOOK_ACTIVE (hook))) |
| return hook; |
| |
| hook = hook->next; |
| } |
| |
| return NULL; |
| } |
| |
| /** |
| * g_hook_find_func: |
| * @hook_list: a #GHookList |
| * @need_valids: %TRUE if #GHook elements which have been destroyed |
| * should be skipped |
| * @func: the function to find |
| * |
| * Finds a #GHook in a #GHookList with the given function. |
| * |
| * Returns: the #GHook with the given @func or %NULL if no matching |
| * #GHook is found |
| */ |
| GHook* |
| g_hook_find_func (GHookList *hook_list, |
| gboolean need_valids, |
| gpointer func) |
| { |
| GHook *hook; |
| |
| g_return_val_if_fail (hook_list != NULL, NULL); |
| g_return_val_if_fail (func != NULL, NULL); |
| |
| hook = hook_list->hooks; |
| while (hook) |
| { |
| /* test only non-destroyed hooks */ |
| if (hook->func == func && |
| hook->hook_id && |
| (!need_valids || G_HOOK_ACTIVE (hook))) |
| return hook; |
| |
| hook = hook->next; |
| } |
| |
| return NULL; |
| } |
| |
| /** |
| * g_hook_find_func_data: |
| * @hook_list: a #GHookList |
| * @need_valids: %TRUE if #GHook elements which have been destroyed |
| * should be skipped |
| * @func: (not nullable): the function to find |
| * @data: the data to find |
| * |
| * Finds a #GHook in a #GHookList with the given function and data. |
| * |
| * Returns: the #GHook with the given @func and @data or %NULL if |
| * no matching #GHook is found |
| */ |
| GHook* |
| g_hook_find_func_data (GHookList *hook_list, |
| gboolean need_valids, |
| gpointer func, |
| gpointer data) |
| { |
| GHook *hook; |
| |
| g_return_val_if_fail (hook_list != NULL, NULL); |
| g_return_val_if_fail (func != NULL, NULL); |
| |
| hook = hook_list->hooks; |
| while (hook) |
| { |
| /* test only non-destroyed hooks */ |
| if (hook->data == data && |
| hook->func == func && |
| hook->hook_id && |
| (!need_valids || G_HOOK_ACTIVE (hook))) |
| return hook; |
| |
| hook = hook->next; |
| } |
| |
| return NULL; |
| } |
| |
| /** |
| * GHookCompareFunc: |
| * @new_hook: the #GHook being inserted |
| * @sibling: the #GHook to compare with @new_hook |
| * |
| * Defines the type of function used to compare #GHook elements in |
| * g_hook_insert_sorted(). |
| * |
| * Returns: a value <= 0 if @new_hook should be before @sibling |
| */ |
| |
| /** |
| * g_hook_insert_sorted: |
| * @hook_list: a #GHookList |
| * @hook: the #GHook to insert |
| * @func: (scope call): the comparison function used to sort the #GHook elements |
| * |
| * Inserts a #GHook into a #GHookList, sorted by the given function. |
| */ |
| void |
| g_hook_insert_sorted (GHookList *hook_list, |
| GHook *hook, |
| GHookCompareFunc func) |
| { |
| GHook *sibling; |
| |
| g_return_if_fail (hook_list != NULL); |
| g_return_if_fail (hook_list->is_setup); |
| g_return_if_fail (hook != NULL); |
| g_return_if_fail (G_HOOK_IS_UNLINKED (hook)); |
| g_return_if_fail (hook->func != NULL); |
| g_return_if_fail (func != NULL); |
| |
| /* first non-destroyed hook */ |
| sibling = hook_list->hooks; |
| while (sibling && !sibling->hook_id) |
| sibling = sibling->next; |
| |
| while (sibling) |
| { |
| GHook *tmp; |
| |
| g_hook_ref (hook_list, sibling); |
| if (func (hook, sibling) <= 0 && sibling->hook_id) |
| { |
| g_hook_unref (hook_list, sibling); |
| break; |
| } |
| |
| /* next non-destroyed hook */ |
| tmp = sibling->next; |
| while (tmp && !tmp->hook_id) |
| tmp = tmp->next; |
| |
| g_hook_unref (hook_list, sibling); |
| sibling = tmp; |
| |
| } |
| |
| g_hook_insert_before (hook_list, sibling, hook); |
| } |
| |
| /** |
| * g_hook_compare_ids: |
| * @new_hook: a #GHook |
| * @sibling: a #GHook to compare with @new_hook |
| * |
| * Compares the ids of two #GHook elements, returning a negative value |
| * if the second id is greater than the first. |
| * |
| * Returns: a value <= 0 if the id of @sibling is >= the id of @new_hook |
| */ |
| gint |
| g_hook_compare_ids (GHook *new_hook, |
| GHook *sibling) |
| { |
| if (new_hook->hook_id < sibling->hook_id) |
| return -1; |
| else if (new_hook->hook_id > sibling->hook_id) |
| return 1; |
| |
| return 0; |
| } |