pulsecore/strbuf.c pulsecore/strbuf.h \
pulsecore/tokenizer.c pulsecore/tokenizer.h \
pulsecore/winsock.h \
- pulsecore/core-error.c pulsecore/core-error.h
+ pulsecore/core-error.c pulsecore/core-error.h \
+ pulsecore/hook-list.c pulsecore/hook-list.h
if OS_IS_WIN32
libpulsecore_la_SOURCES += \
--- /dev/null
+/* $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 <pulsecore/hook-list.h>
+
+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;
+}
+
USA.
***/
-/* Some macro voodoo to implement a type safe hook list */
-
#include <pulsecore/llist.h>
#include <pulse/xmalloc.h>
-#include <pulse/cdecl.h>
+#include <pulsecore/gccmacro.h>
+
+typedef struct pa_hook_slot pa_hook_slot;
+typedef struct pa_hook pa_hook;
typedef enum pa_hook_result {
PA_HOOK_OK = 0,
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
#include <pulsecore/hook-list.h>
#include <pulsecore/log.h>
-PA_HOOK_DECLARE(test, const char *, const char*);
-
-static pa_hook_result_t func1(const char*a, const char*b, void *userdata) {
- pa_log("#1 a=%s b=%s userdata=%s", a, b, (char*) userdata);
+static pa_hook_result_t func1(const char*a, void *userdata) {
+ pa_log("#1 arg=%s userdata=%s", a, (char*) userdata);
return PA_HOOK_OK;
}
-static pa_hook_result_t func2(const char*a, const char*b, void *userdata) {
- pa_log("#2 a=%s b=%s userdata=%s", a, b, (char*) userdata);
+static pa_hook_result_t func2(const char*a, void *userdata) {
+ pa_log("#2 arg=%s userdata=%s", a, (char*) userdata);
return PA_HOOK_OK;
}
int main(int argc, char *argv[]) {
- void *u;
-
- PA_HOOK_HEAD(test, test);
-
- PA_HOOK_HEAD_INIT(test, test);
+ pa_hook hook;
+ pa_hook_slot *slot;
- PA_HOOK_APPEND(test, test, func1, (void*) "1-1");
- PA_HOOK_APPEND(test, test, func2, u = (void*) "2");
- PA_HOOK_APPEND(test, test, func1, (void*) "1-2");
+ pa_hook_init(&hook);
- PA_HOOK_EXECUTE(test, test, "arg1", "arg2");
-
- PA_HOOK_REMOVE(test, test, func2, u);
+ pa_hook_connect(&hook, (pa_hook_cb_t) func1, (void*) "1-1");
+ slot = pa_hook_connect(&hook, (pa_hook_cb_t) func2, (void*) "2-1");
+ pa_hook_connect(&hook, (pa_hook_cb_t) func1, (void*) "1-2");
+
+ pa_hook_fire(&hook, (void*) "arg2");
- PA_HOOK_FREE(test, test);
+ pa_hook_slot_free(slot);
+ pa_hook_free(&hook);
return 0;
}