From 281125c72767713d6294ac7094f3bf7bde47a1e3 Mon Sep 17 00:00:00 2001 From: Lennart Poettering Date: Sun, 13 Aug 2006 01:43:34 +0000 Subject: rework hook list stuff again, and replace macros with real functins. We loose type safety but things are much cleaner now git-svn-id: file:///home/lennart/svn/public/pulseaudio/trunk@1234 fefdeb5f-60dc-0310-8127-8f9354f1896f --- src/pulsecore/hook-list.c | 111 ++++++++++++++++++++++++++++++++++++++++++++++ src/pulsecore/hook-list.h | 99 +++++++++-------------------------------- 2 files changed, 133 insertions(+), 77 deletions(-) create mode 100644 src/pulsecore/hook-list.c (limited to 'src/pulsecore') diff --git a/src/pulsecore/hook-list.c b/src/pulsecore/hook-list.c new file mode 100644 index 00000000..14ab8e89 --- /dev/null +++ b/src/pulsecore/hook-list.c @@ -0,0 +1,111 @@ +/* $Id$ */ + +/*** + This file is part of PulseAudio. + + PulseAudio 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 of the + License, or (at your option) any later version. + + PulseAudio 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 + General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with PulseAudio; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + USA. +***/ + +#include + +void pa_hook_init(pa_hook *hook) { + assert(hook); + + PA_LLIST_HEAD_INIT(pa_hook_slots, hook->slots); + hook->last = NULL; + hook->n_dead = hook->firing = 0; +} + +static void slot_free(pa_hook *hook, pa_hook_slot *slot) { + assert(hook); + assert(slot); + + if (hook->last == slot) + hook->last = slot->prev; + + PA_LLIST_REMOVE(pa_hook_slot, hook->slots, slot); + + pa_xfree(slot); +} + +void pa_hook_free(pa_hook *hook) { + assert(hook); + assert(!hook->firing); + + while (hook->slots) + slot_free(hook, hook->slots); + + pa_hook_init(hook); +} + +pa_hook_slot* pa_hook_connect(pa_hook *hook, pa_hook_cb_t cb, void *userdata) { + pa_hook_slot *slot; + + assert(cb); + + slot = pa_xnew(pa_hook_slot, 1); + slot->hook = hook; + slot->dead = 0; + slot->callback = cb; + slot->userdata = userdata; + + PA_LLIST_INSERT_AFTER(pa_hook_slot, hook->slots, hook->last, slot); + hook->last = slot; + + return slot; +} + +void pa_hook_slot_free(pa_hook_slot *slot) { + assert(slot); + assert(!slot->dead); + + if (slot->hook->firing > 0) { + slot->dead = 1; + slot->hook->n_dead++; + } else + slot_free(slot->hook, slot); +} + +pa_hook_result_t pa_hook_fire(pa_hook *hook, void *data) { + pa_hook_slot *slot, *next; + pa_hook_result_t result = PA_HOOK_OK; + + assert(hook); + + hook->firing ++; + + for (slot = hook->slots; slot; slot = slot->next) { + if (slot->dead) + continue; + + if ((result = slot->callback(data, slot->userdata)) != PA_HOOK_OK) + break; + } + + hook->firing --; + + for (slot = hook->slots; hook->n_dead > 0 && slot; slot = next) { + next = slot->next; + + if (slot->dead) { + slot_free(hook, slot); + hook->n_dead--; + } + } + + return result; +} + diff --git a/src/pulsecore/hook-list.h b/src/pulsecore/hook-list.h index 6bfe9cb5..e016ff0c 100644 --- a/src/pulsecore/hook-list.h +++ b/src/pulsecore/hook-list.h @@ -22,11 +22,12 @@ USA. ***/ -/* Some macro voodoo to implement a type safe hook list */ - #include #include -#include +#include + +typedef struct pa_hook_slot pa_hook_slot; +typedef struct pa_hook pa_hook; typedef enum pa_hook_result { PA_HOOK_OK = 0, @@ -34,84 +35,28 @@ typedef enum pa_hook_result { PA_HOOK_CANCEL = -1 } pa_hook_result_t; -#define PA_HOOK_DECLARE(name, arg1, arg2) \ -typedef pa_hook_result_t (*pa_hook__##name##__func_t)(arg1 a, arg2 b, void *userdata); \ -\ -typedef struct pa_hook__##name##__func_info pa_hook__##name##__func_info; \ -struct pa_hook__##name##__func_info { \ - int dead; \ - pa_hook__##name##__func_t func; \ - void *userdata; \ - PA_LLIST_FIELDS(pa_hook__##name##__func_info); \ -}; \ -PA_GCC_UNUSED static void pa_hook__##name##__free_one( \ - pa_hook__##name##__func_info **head, \ - pa_hook__##name##__func_info *i) { \ - PA_LLIST_REMOVE(pa_hook__##name##__func_info, *head, i); \ - pa_xfree(i); \ -} \ -PA_GCC_UNUSED static void pa_hook__##name##__free_all( \ - pa_hook__##name##__func_info **head) { \ - while (*head) \ - pa_hook__##name##__free_one(head, *head); \ -} \ -PA_GCC_UNUSED static void pa_hook__##name##__mark_dead( \ - pa_hook__##name##__func_info *i, \ - pa_hook__##name##__func_t func, \ - void *userdata) { \ - for (; i; i = i->next) { \ - if (i->func != func || i->userdata != userdata) \ - continue; \ - i->dead = 1; \ - break; \ - } \ -} \ -PA_GCC_UNUSED static void pa_hook__##name##__append( \ - pa_hook__##name##__func_info **head, \ - pa_hook__##name##__func_t func, \ - void *userdata) { \ - pa_hook__##name##__func_info *i = pa_xnew(pa_hook__##name##__func_info, 1); \ - i->dead = 0; \ - i->func = func; \ - i->userdata = userdata; \ - PA_LLIST_PREPEND(pa_hook__##name##__func_info, *head, i); \ -} \ -PA_GCC_UNUSED static pa_hook_result_t pa_hook__##name##__execute ( \ - pa_hook__##name##__func_info **head, \ - arg1 a, \ - arg2 b) { \ - pa_hook__##name##__func_info *i, *n; \ - pa_hook_result_t ret = PA_HOOK_OK; \ - for (i = *head; i; i = i->next) { \ - if ((ret = i->func(a, b, i->userdata)) != PA_HOOK_OK) \ - break; \ - } \ - for (i = *head; i; i = n) { \ - n = i->next; \ - if (i->dead) \ - pa_hook__##name##__free_one(head, i); \ - } \ - return ret; \ -}\ -void pa_hook__##name##__nowarn(void) - - -#define PA_HOOK_HEAD(name, head) \ -pa_hook__##name##__func_info *head; +typedef pa_hook_result_t (*pa_hook_cb_t)(void *data, void *userdata); -#define PA_HOOK_HEAD_INIT(name, head) \ -(head) = NULL +struct pa_hook_slot { + int dead; + pa_hook *hook; + pa_hook_cb_t callback; + void *userdata; + PA_LLIST_FIELDS(pa_hook_slot); +}; -#define PA_HOOK_EXECUTE(name, head, arg1, arg2) \ -pa_hook__##name##__execute(&(head), arg1, arg2) +struct pa_hook { + PA_LLIST_HEAD(pa_hook_slot, slots); + pa_hook_slot *last; + int firing, n_dead; +}; -#define PA_HOOK_APPEND(name, head, func, userdata) \ -pa_hook__##name##__append(&(head), func, userdata) +void pa_hook_init(pa_hook *hook); +void pa_hook_free(pa_hook *hook); -#define PA_HOOK_REMOVE(name, head, func, userdata) \ -pa_hook__##name##__mark_dead(head, func, userdata) +pa_hook_slot* pa_hook_connect(pa_hook *hook, pa_hook_cb_t, void *userdata); +void pa_hook_slot_free(pa_hook_slot *slot); -#define PA_HOOK_FREE(name, head) \ -pa_hook__##name##__free_all(&(head)) +pa_hook_result_t pa_hook_fire(pa_hook *hook, void *data); #endif -- cgit