Rename flx_* to avahi_*

[catta] / timeeventq.c

diff --git a/timeeventq.c b/timeeventq.c
index 78513aa961a46bb6e3b1be45b3c1ac53a2449165..fc84157fb42bf7761594b1983426adba8cd8cd8a 100644 (file)
--- a/timeeventq.c
+++ b/timeeventq.c
@@ -2,14 +2,14 @@
 #include "util.h"
 
 static gint compare(gconstpointer _a, gconstpointer _b) {
-    const flxTimeEvent *a = _a,  *b = _b;
+    const AvahiTimeEvent *a = _a,  *b = _b;
 
-    return flx_timeval_compare(&a->expiry, &b->expiry);
+    return avahi_timeval_compare(&a->expiry, &b->expiry);
 }
 
 static gboolean prepare_func(GSource *source, gint *timeout) {
-    flxTimeEventQueue *q = (flxTimeEventQueue*) source;
-    flxTimeEvent *e;
+    AvahiTimeEventQueue *q = (AvahiTimeEventQueue*) source;
+    AvahiTimeEvent *e;
     GTimeVal now;
 
     g_assert(source);
@@ -25,19 +25,19 @@ static gboolean prepare_func(GSource *source, gint *timeout) {
 
     g_source_get_current_time(source, &now);
 
-    if (flx_timeval_compare(&now, &e->expiry) >= 0) {
+    if (avahi_timeval_compare(&now, &e->expiry) >= 0) {
         *timeout = -1;
         return TRUE;
     }
 
-    *timeout = (gint) (flx_timeval_diff(&e->expiry, &now)/1000);
+    *timeout = (gint) (avahi_timeval_diff(&e->expiry, &now)/1000);
     
     return FALSE;
 }
 
 static gboolean check_func(GSource *source) {
-    flxTimeEventQueue *q = (flxTimeEventQueue*) source;
-    flxTimeEvent *e;
+    AvahiTimeEventQueue *q = (AvahiTimeEventQueue*) source;
+    AvahiTimeEvent *e;
     GTimeVal now;
 
     g_assert(source);
@@ -50,11 +50,11 @@ static gboolean check_func(GSource *source) {
 
     g_source_get_current_time(source, &now);
     
-    return flx_timeval_compare(&now, &e->expiry) >= 0;
+    return avahi_timeval_compare(&now, &e->expiry) >= 0;
 }
 
 static gboolean dispatch_func(GSource *source, GSourceFunc callback, gpointer user_data) {
-    flxTimeEventQueue *q = (flxTimeEventQueue*) source;
+    AvahiTimeEventQueue *q = (AvahiTimeEventQueue*) source;
     GTimeVal now;
 
     g_assert(source);
@@ -62,9 +62,9 @@ static gboolean dispatch_func(GSource *source, GSourceFunc callback, gpointer us
     g_source_get_current_time(source, &now);
 
     while (q->prioq->root) {
-        flxTimeEvent *e = q->prioq->root->data;
+        AvahiTimeEvent *e = q->prioq->root->data;
 
-        if (flx_timeval_compare(&now, &e->expiry) < 0)
+        if (avahi_timeval_compare(&now, &e->expiry) < 0)
             break;
 
         g_assert(e->callback);
@@ -74,8 +74,8 @@ static gboolean dispatch_func(GSource *source, GSourceFunc callback, gpointer us
     return TRUE;
 }
 
-flxTimeEventQueue* flx_time_event_queue_new(GMainContext *context, gint priority) {
-    flxTimeEventQueue *q;
+AvahiTimeEventQueue* avahi_time_event_queue_new(GMainContext *context, gint priority) {
+    AvahiTimeEventQueue *q;
 
     static GSourceFuncs source_funcs = {
         prepare_func,
@@ -86,8 +86,8 @@ flxTimeEventQueue* flx_time_event_queue_new(GMainContext *context, gint priority
         NULL
     };
 
-    q = (flxTimeEventQueue*) g_source_new(&source_funcs, sizeof(flxTimeEventQueue));
-    q->prioq = flx_prio_queue_new(compare);
+    q = (AvahiTimeEventQueue*) g_source_new(&source_funcs, sizeof(AvahiTimeEventQueue));
+    q->prioq = avahi_prio_queue_new(compare);
 
     g_source_set_priority((GSource*) q, priority);
     
@@ -96,62 +96,62 @@ flxTimeEventQueue* flx_time_event_queue_new(GMainContext *context, gint priority
     return q;
 }
 
-void flx_time_event_queue_free(flxTimeEventQueue *q) {
+void avahi_time_event_queue_free(AvahiTimeEventQueue *q) {
     g_assert(q);
 
     while (q->prioq->root)
-        flx_time_event_queue_remove(q, q->prioq->root->data);
-    flx_prio_queue_free(q->prioq);
+        avahi_time_event_queue_remove(q, q->prioq->root->data);
+    avahi_prio_queue_free(q->prioq);
 
     g_source_destroy(&q->source);
     g_source_unref(&q->source);
 }
 
-flxTimeEvent* flx_time_event_queue_add(flxTimeEventQueue *q, const GTimeVal *timeval, void (*callback)(flxTimeEvent *e, void *userdata), void *userdata) {
-    flxTimeEvent *e;
+AvahiTimeEvent* avahi_time_event_queue_add(AvahiTimeEventQueue *q, const GTimeVal *timeval, void (*callback)(AvahiTimeEvent *e, void *userdata), void *userdata) {
+    AvahiTimeEvent *e;
     
     g_assert(q);
     g_assert(timeval);
     g_assert(callback);
     g_assert(userdata);
 
-    e = g_new(flxTimeEvent, 1);
+    e = g_new(AvahiTimeEvent, 1);
     e->queue = q;
     e->expiry = *timeval;
     e->callback = callback;
     e->userdata = userdata;
 
-    e->node = flx_prio_queue_put(q->prioq, e);
+    e->node = avahi_prio_queue_put(q->prioq, e);
     
     return e;
 }
 
-void flx_time_event_queue_remove(flxTimeEventQueue *q, flxTimeEvent *e) {
+void avahi_time_event_queue_remove(AvahiTimeEventQueue *q, AvahiTimeEvent *e) {
     g_assert(q);
     g_assert(e);
     g_assert(e->queue == q);
 
-    flx_prio_queue_remove(q->prioq, e->node);
+    avahi_prio_queue_remove(q->prioq, e->node);
     g_free(e);
 }
 
-void flx_time_event_queue_update(flxTimeEventQueue *q, flxTimeEvent *e, const GTimeVal *timeval) {
+void avahi_time_event_queue_update(AvahiTimeEventQueue *q, AvahiTimeEvent *e, const GTimeVal *timeval) {
     g_assert(q);
     g_assert(e);
     g_assert(e->queue == q);
 
     e->expiry = *timeval;
 
-    flx_prio_queue_shuffle(q->prioq, e->node);
+    avahi_prio_queue_shuffle(q->prioq, e->node);
 }
 
-flxTimeEvent* flx_time_event_queue_root(flxTimeEventQueue *q) {
+AvahiTimeEvent* avahi_time_event_queue_root(AvahiTimeEventQueue *q) {
     g_assert(q);
 
     return q->prioq->root ? q->prioq->root->data : NULL;
 }
 
-flxTimeEvent* flx_time_event_next(flxTimeEvent *e) {
+AvahiTimeEvent* avahi_time_event_next(AvahiTimeEvent *e) {
     g_assert(e);
 
     return e->node->next->data;