From bb3475e8eb379ee18f3d8f37caa8040b852a6213 Mon Sep 17 00:00:00 2001 From: "Anna (navi) Figueiredo Gomes" Date: Sat, 23 Mar 2024 01:21:46 +0100 Subject: all: rename redis -> redict symbols and comments Signed-off-by: Anna (navi) Figueiredo Gomes --- adapters/ae.h | 74 +++++++++++++-------------- adapters/glib.h | 98 ++++++++++++++++++------------------ adapters/ivykis.h | 74 +++++++++++++-------------- adapters/libev.h | 94 +++++++++++++++++----------------- adapters/libevent.h | 106 +++++++++++++++++++-------------------- adapters/libhv.h | 80 ++++++++++++++--------------- adapters/libsdevent.h | 104 +++++++++++++++++++------------------- adapters/libuv.h | 90 ++++++++++++++++----------------- adapters/macosx.h | 110 ++++++++++++++++++++-------------------- adapters/poll.h | 102 ++++++++++++++++++------------------- adapters/qt.h | 64 ++++++++++++------------ adapters/redictmoduleapi.h | 122 ++++++++++++++++++++++----------------------- 12 files changed, 559 insertions(+), 559 deletions(-) (limited to 'adapters') diff --git a/adapters/ae.h b/adapters/ae.h index 44db8ee..1edcd0e 100644 --- a/adapters/ae.h +++ b/adapters/ae.h @@ -9,45 +9,45 @@ * */ -#ifndef __HIREDIS_AE_H__ -#define __HIREDIS_AE_H__ +#ifndef __HIREDICT_AE_H__ +#define __HIREDICT_AE_H__ #include #include #include "../hiredict.h" #include "../async.h" -typedef struct redisAeEvents { - redisAsyncContext *context; +typedef struct redictAeEvents { + redictAsyncContext *context; aeEventLoop *loop; int fd; int reading, writing; -} redisAeEvents; +} redictAeEvents; -static void redisAeReadEvent(aeEventLoop *el, int fd, void *privdata, int mask) { +static void redictAeReadEvent(aeEventLoop *el, int fd, void *privdata, int mask) { ((void)el); ((void)fd); ((void)mask); - redisAeEvents *e = (redisAeEvents*)privdata; - redisAsyncHandleRead(e->context); + redictAeEvents *e = (redictAeEvents*)privdata; + redictAsyncHandleRead(e->context); } -static void redisAeWriteEvent(aeEventLoop *el, int fd, void *privdata, int mask) { +static void redictAeWriteEvent(aeEventLoop *el, int fd, void *privdata, int mask) { ((void)el); ((void)fd); ((void)mask); - redisAeEvents *e = (redisAeEvents*)privdata; - redisAsyncHandleWrite(e->context); + redictAeEvents *e = (redictAeEvents*)privdata; + redictAsyncHandleWrite(e->context); } -static void redisAeAddRead(void *privdata) { - redisAeEvents *e = (redisAeEvents*)privdata; +static void redictAeAddRead(void *privdata) { + redictAeEvents *e = (redictAeEvents*)privdata; aeEventLoop *loop = e->loop; if (!e->reading) { e->reading = 1; - aeCreateFileEvent(loop,e->fd,AE_READABLE,redisAeReadEvent,e); + aeCreateFileEvent(loop,e->fd,AE_READABLE,redictAeReadEvent,e); } } -static void redisAeDelRead(void *privdata) { - redisAeEvents *e = (redisAeEvents*)privdata; +static void redictAeDelRead(void *privdata) { + redictAeEvents *e = (redictAeEvents*)privdata; aeEventLoop *loop = e->loop; if (e->reading) { e->reading = 0; @@ -55,17 +55,17 @@ static void redisAeDelRead(void *privdata) { } } -static void redisAeAddWrite(void *privdata) { - redisAeEvents *e = (redisAeEvents*)privdata; +static void redictAeAddWrite(void *privdata) { + redictAeEvents *e = (redictAeEvents*)privdata; aeEventLoop *loop = e->loop; if (!e->writing) { e->writing = 1; - aeCreateFileEvent(loop,e->fd,AE_WRITABLE,redisAeWriteEvent,e); + aeCreateFileEvent(loop,e->fd,AE_WRITABLE,redictAeWriteEvent,e); } } -static void redisAeDelWrite(void *privdata) { - redisAeEvents *e = (redisAeEvents*)privdata; +static void redictAeDelWrite(void *privdata) { + redictAeEvents *e = (redictAeEvents*)privdata; aeEventLoop *loop = e->loop; if (e->writing) { e->writing = 0; @@ -73,25 +73,25 @@ static void redisAeDelWrite(void *privdata) { } } -static void redisAeCleanup(void *privdata) { - redisAeEvents *e = (redisAeEvents*)privdata; - redisAeDelRead(privdata); - redisAeDelWrite(privdata); +static void redictAeCleanup(void *privdata) { + redictAeEvents *e = (redictAeEvents*)privdata; + redictAeDelRead(privdata); + redictAeDelWrite(privdata); hi_free(e); } -static int redisAeAttach(aeEventLoop *loop, redisAsyncContext *ac) { - redisContext *c = &(ac->c); - redisAeEvents *e; +static int redictAeAttach(aeEventLoop *loop, redictAsyncContext *ac) { + redictContext *c = &(ac->c); + redictAeEvents *e; /* Nothing should be attached when something is already attached */ if (ac->ev.data != NULL) - return REDIS_ERR; + return REDICT_ERR; /* Create container for context and r/w events */ - e = (redisAeEvents*)hi_malloc(sizeof(*e)); + e = (redictAeEvents*)hi_malloc(sizeof(*e)); if (e == NULL) - return REDIS_ERR; + return REDICT_ERR; e->context = ac; e->loop = loop; @@ -99,13 +99,13 @@ static int redisAeAttach(aeEventLoop *loop, redisAsyncContext *ac) { e->reading = e->writing = 0; /* Register functions to start/stop listening for events */ - ac->ev.addRead = redisAeAddRead; - ac->ev.delRead = redisAeDelRead; - ac->ev.addWrite = redisAeAddWrite; - ac->ev.delWrite = redisAeDelWrite; - ac->ev.cleanup = redisAeCleanup; + ac->ev.addRead = redictAeAddRead; + ac->ev.delRead = redictAeDelRead; + ac->ev.addWrite = redictAeAddWrite; + ac->ev.delWrite = redictAeDelWrite; + ac->ev.cleanup = redictAeCleanup; ac->ev.data = e; - return REDIS_OK; + return REDICT_OK; } #endif diff --git a/adapters/glib.h b/adapters/glib.h index f3143ed..84490c8 100644 --- a/adapters/glib.h +++ b/adapters/glib.h @@ -9,8 +9,8 @@ * */ -#ifndef __HIREDIS_GLIB_H__ -#define __HIREDIS_GLIB_H__ +#ifndef __HIREDICT_GLIB_H__ +#define __HIREDICT_GLIB_H__ #include @@ -20,55 +20,55 @@ typedef struct { GSource source; - redisAsyncContext *ac; + redictAsyncContext *ac; GPollFD poll_fd; -} RedisSource; +} RedictSource; static void -redis_source_add_read (gpointer data) +redict_source_add_read (gpointer data) { - RedisSource *source = (RedisSource *)data; + RedictSource *source = (RedictSource *)data; g_return_if_fail(source); source->poll_fd.events |= G_IO_IN; g_main_context_wakeup(g_source_get_context((GSource *)data)); } static void -redis_source_del_read (gpointer data) +redict_source_del_read (gpointer data) { - RedisSource *source = (RedisSource *)data; + RedictSource *source = (RedictSource *)data; g_return_if_fail(source); source->poll_fd.events &= ~G_IO_IN; g_main_context_wakeup(g_source_get_context((GSource *)data)); } static void -redis_source_add_write (gpointer data) +redict_source_add_write (gpointer data) { - RedisSource *source = (RedisSource *)data; + RedictSource *source = (RedictSource *)data; g_return_if_fail(source); source->poll_fd.events |= G_IO_OUT; g_main_context_wakeup(g_source_get_context((GSource *)data)); } static void -redis_source_del_write (gpointer data) +redict_source_del_write (gpointer data) { - RedisSource *source = (RedisSource *)data; + RedictSource *source = (RedictSource *)data; g_return_if_fail(source); source->poll_fd.events &= ~G_IO_OUT; g_main_context_wakeup(g_source_get_context((GSource *)data)); } static void -redis_source_cleanup (gpointer data) +redict_source_cleanup (gpointer data) { - RedisSource *source = (RedisSource *)data; + RedictSource *source = (RedictSource *)data; g_return_if_fail(source); - redis_source_del_read(source); - redis_source_del_write(source); + redict_source_del_read(source); + redict_source_del_write(source); /* * It is not our responsibility to remove ourself from the * current main loop. However, we will remove the GPollFD. @@ -80,36 +80,36 @@ redis_source_cleanup (gpointer data) } static gboolean -redis_source_prepare (GSource *source, +redict_source_prepare (GSource *source, gint *timeout_) { - RedisSource *redis = (RedisSource *)source; + RedictSource *redict = (RedictSource *)source; *timeout_ = -1; - return !!(redis->poll_fd.events & redis->poll_fd.revents); + return !!(redict->poll_fd.events & redict->poll_fd.revents); } static gboolean -redis_source_check (GSource *source) +redict_source_check (GSource *source) { - RedisSource *redis = (RedisSource *)source; - return !!(redis->poll_fd.events & redis->poll_fd.revents); + RedictSource *redict = (RedictSource *)source; + return !!(redict->poll_fd.events & redict->poll_fd.revents); } static gboolean -redis_source_dispatch (GSource *source, +redict_source_dispatch (GSource *source, GSourceFunc callback, gpointer user_data) { - RedisSource *redis = (RedisSource *)source; + RedictSource *redict = (RedictSource *)source; - if ((redis->poll_fd.revents & G_IO_OUT)) { - redisAsyncHandleWrite(redis->ac); - redis->poll_fd.revents &= ~G_IO_OUT; + if ((redict->poll_fd.revents & G_IO_OUT)) { + redictAsyncHandleWrite(redict->ac); + redict->poll_fd.revents &= ~G_IO_OUT; } - if ((redis->poll_fd.revents & G_IO_IN)) { - redisAsyncHandleRead(redis->ac); - redis->poll_fd.revents &= ~G_IO_IN; + if ((redict->poll_fd.revents & G_IO_IN)) { + redictAsyncHandleRead(redict->ac); + redict->poll_fd.revents &= ~G_IO_IN; } if (callback) { @@ -120,31 +120,31 @@ redis_source_dispatch (GSource *source, } static void -redis_source_finalize (GSource *source) +redict_source_finalize (GSource *source) { - RedisSource *redis = (RedisSource *)source; + RedictSource *redict = (RedictSource *)source; - if (redis->poll_fd.fd >= 0) { - g_source_remove_poll(source, &redis->poll_fd); - redis->poll_fd.fd = -1; + if (redict->poll_fd.fd >= 0) { + g_source_remove_poll(source, &redict->poll_fd); + redict->poll_fd.fd = -1; } } static GSource * -redis_source_new (redisAsyncContext *ac) +redict_source_new (redictAsyncContext *ac) { static GSourceFuncs source_funcs = { - .prepare = redis_source_prepare, - .check = redis_source_check, - .dispatch = redis_source_dispatch, - .finalize = redis_source_finalize, + .prepare = redict_source_prepare, + .check = redict_source_check, + .dispatch = redict_source_dispatch, + .finalize = redict_source_finalize, }; - redisContext *c = &ac->c; - RedisSource *source; + redictContext *c = &ac->c; + RedictSource *source; g_return_val_if_fail(ac != NULL, NULL); - source = (RedisSource *)g_source_new(&source_funcs, sizeof *source); + source = (RedictSource *)g_source_new(&source_funcs, sizeof *source); if (source == NULL) return NULL; @@ -154,14 +154,14 @@ redis_source_new (redisAsyncContext *ac) source->poll_fd.revents = 0; g_source_add_poll((GSource *)source, &source->poll_fd); - ac->ev.addRead = redis_source_add_read; - ac->ev.delRead = redis_source_del_read; - ac->ev.addWrite = redis_source_add_write; - ac->ev.delWrite = redis_source_del_write; - ac->ev.cleanup = redis_source_cleanup; + ac->ev.addRead = redict_source_add_read; + ac->ev.delRead = redict_source_del_read; + ac->ev.addWrite = redict_source_add_write; + ac->ev.delWrite = redict_source_del_write; + ac->ev.cleanup = redict_source_cleanup; ac->ev.data = source; return (GSource *)source; } -#endif /* __HIREDIS_GLIB_H__ */ +#endif /* __HIREDICT_GLIB_H__ */ diff --git a/adapters/ivykis.h b/adapters/ivykis.h index 544723d..a8468d8 100644 --- a/adapters/ivykis.h +++ b/adapters/ivykis.h @@ -9,87 +9,87 @@ * */ -#ifndef __HIREDIS_IVYKIS_H__ -#define __HIREDIS_IVYKIS_H__ +#ifndef __HIREDICT_IVYKIS_H__ +#define __HIREDICT_IVYKIS_H__ #include #include "../hiredict.h" #include "../async.h" -typedef struct redisIvykisEvents { - redisAsyncContext *context; +typedef struct redictIvykisEvents { + redictAsyncContext *context; struct iv_fd fd; -} redisIvykisEvents; +} redictIvykisEvents; -static void redisIvykisReadEvent(void *arg) { - redisAsyncContext *context = (redisAsyncContext *)arg; - redisAsyncHandleRead(context); +static void redictIvykisReadEvent(void *arg) { + redictAsyncContext *context = (redictAsyncContext *)arg; + redictAsyncHandleRead(context); } -static void redisIvykisWriteEvent(void *arg) { - redisAsyncContext *context = (redisAsyncContext *)arg; - redisAsyncHandleWrite(context); +static void redictIvykisWriteEvent(void *arg) { + redictAsyncContext *context = (redictAsyncContext *)arg; + redictAsyncHandleWrite(context); } -static void redisIvykisAddRead(void *privdata) { - redisIvykisEvents *e = (redisIvykisEvents*)privdata; - iv_fd_set_handler_in(&e->fd, redisIvykisReadEvent); +static void redictIvykisAddRead(void *privdata) { + redictIvykisEvents *e = (redictIvykisEvents*)privdata; + iv_fd_set_handler_in(&e->fd, redictIvykisReadEvent); } -static void redisIvykisDelRead(void *privdata) { - redisIvykisEvents *e = (redisIvykisEvents*)privdata; +static void redictIvykisDelRead(void *privdata) { + redictIvykisEvents *e = (redictIvykisEvents*)privdata; iv_fd_set_handler_in(&e->fd, NULL); } -static void redisIvykisAddWrite(void *privdata) { - redisIvykisEvents *e = (redisIvykisEvents*)privdata; - iv_fd_set_handler_out(&e->fd, redisIvykisWriteEvent); +static void redictIvykisAddWrite(void *privdata) { + redictIvykisEvents *e = (redictIvykisEvents*)privdata; + iv_fd_set_handler_out(&e->fd, redictIvykisWriteEvent); } -static void redisIvykisDelWrite(void *privdata) { - redisIvykisEvents *e = (redisIvykisEvents*)privdata; +static void redictIvykisDelWrite(void *privdata) { + redictIvykisEvents *e = (redictIvykisEvents*)privdata; iv_fd_set_handler_out(&e->fd, NULL); } -static void redisIvykisCleanup(void *privdata) { - redisIvykisEvents *e = (redisIvykisEvents*)privdata; +static void redictIvykisCleanup(void *privdata) { + redictIvykisEvents *e = (redictIvykisEvents*)privdata; iv_fd_unregister(&e->fd); hi_free(e); } -static int redisIvykisAttach(redisAsyncContext *ac) { - redisContext *c = &(ac->c); - redisIvykisEvents *e; +static int redictIvykisAttach(redictAsyncContext *ac) { + redictContext *c = &(ac->c); + redictIvykisEvents *e; /* Nothing should be attached when something is already attached */ if (ac->ev.data != NULL) - return REDIS_ERR; + return REDICT_ERR; /* Create container for context and r/w events */ - e = (redisIvykisEvents*)hi_malloc(sizeof(*e)); + e = (redictIvykisEvents*)hi_malloc(sizeof(*e)); if (e == NULL) - return REDIS_ERR; + return REDICT_ERR; e->context = ac; /* Register functions to start/stop listening for events */ - ac->ev.addRead = redisIvykisAddRead; - ac->ev.delRead = redisIvykisDelRead; - ac->ev.addWrite = redisIvykisAddWrite; - ac->ev.delWrite = redisIvykisDelWrite; - ac->ev.cleanup = redisIvykisCleanup; + ac->ev.addRead = redictIvykisAddRead; + ac->ev.delRead = redictIvykisDelRead; + ac->ev.addWrite = redictIvykisAddWrite; + ac->ev.delWrite = redictIvykisDelWrite; + ac->ev.cleanup = redictIvykisCleanup; ac->ev.data = e; /* Initialize and install read/write events */ IV_FD_INIT(&e->fd); e->fd.fd = c->fd; - e->fd.handler_in = redisIvykisReadEvent; - e->fd.handler_out = redisIvykisWriteEvent; + e->fd.handler_in = redictIvykisReadEvent; + e->fd.handler_out = redictIvykisWriteEvent; e->fd.handler_err = NULL; e->fd.cookie = e->context; iv_fd_register(&e->fd); - return REDIS_OK; + return REDICT_OK; } #endif diff --git a/adapters/libev.h b/adapters/libev.h index 265e642..9aa841e 100644 --- a/adapters/libev.h +++ b/adapters/libev.h @@ -11,44 +11,44 @@ * */ -#ifndef __HIREDIS_LIBEV_H__ -#define __HIREDIS_LIBEV_H__ +#ifndef __HIREDICT_LIBEV_H__ +#define __HIREDICT_LIBEV_H__ #include #include #include #include "../hiredict.h" #include "../async.h" -typedef struct redisLibevEvents { - redisAsyncContext *context; +typedef struct redictLibevEvents { + redictAsyncContext *context; struct ev_loop *loop; int reading, writing; ev_io rev, wev; ev_timer timer; -} redisLibevEvents; +} redictLibevEvents; -static void redisLibevReadEvent(EV_P_ ev_io *watcher, int revents) { +static void redictLibevReadEvent(EV_P_ ev_io *watcher, int revents) { #if EV_MULTIPLICITY ((void)EV_A); #endif ((void)revents); - redisLibevEvents *e = (redisLibevEvents*)watcher->data; - redisAsyncHandleRead(e->context); + redictLibevEvents *e = (redictLibevEvents*)watcher->data; + redictAsyncHandleRead(e->context); } -static void redisLibevWriteEvent(EV_P_ ev_io *watcher, int revents) { +static void redictLibevWriteEvent(EV_P_ ev_io *watcher, int revents) { #if EV_MULTIPLICITY ((void)EV_A); #endif ((void)revents); - redisLibevEvents *e = (redisLibevEvents*)watcher->data; - redisAsyncHandleWrite(e->context); + redictLibevEvents *e = (redictLibevEvents*)watcher->data; + redictAsyncHandleWrite(e->context); } -static void redisLibevAddRead(void *privdata) { - redisLibevEvents *e = (redisLibevEvents*)privdata; +static void redictLibevAddRead(void *privdata) { + redictLibevEvents *e = (redictLibevEvents*)privdata; #if EV_MULTIPLICITY struct ev_loop *loop = e->loop; #endif @@ -58,8 +58,8 @@ static void redisLibevAddRead(void *privdata) { } } -static void redisLibevDelRead(void *privdata) { - redisLibevEvents *e = (redisLibevEvents*)privdata; +static void redictLibevDelRead(void *privdata) { + redictLibevEvents *e = (redictLibevEvents*)privdata; #if EV_MULTIPLICITY struct ev_loop *loop = e->loop; #endif @@ -69,8 +69,8 @@ static void redisLibevDelRead(void *privdata) { } } -static void redisLibevAddWrite(void *privdata) { - redisLibevEvents *e = (redisLibevEvents*)privdata; +static void redictLibevAddWrite(void *privdata) { + redictLibevEvents *e = (redictLibevEvents*)privdata; #if EV_MULTIPLICITY struct ev_loop *loop = e->loop; #endif @@ -80,8 +80,8 @@ static void redisLibevAddWrite(void *privdata) { } } -static void redisLibevDelWrite(void *privdata) { - redisLibevEvents *e = (redisLibevEvents*)privdata; +static void redictLibevDelWrite(void *privdata) { + redictLibevEvents *e = (redictLibevEvents*)privdata; #if EV_MULTIPLICITY struct ev_loop *loop = e->loop; #endif @@ -91,39 +91,39 @@ static void redisLibevDelWrite(void *privdata) { } } -static void redisLibevStopTimer(void *privdata) { - redisLibevEvents *e = (redisLibevEvents*)privdata; +static void redictLibevStopTimer(void *privdata) { + redictLibevEvents *e = (redictLibevEvents*)privdata; #if EV_MULTIPLICITY struct ev_loop *loop = e->loop; #endif ev_timer_stop(EV_A_ &e->timer); } -static void redisLibevCleanup(void *privdata) { - redisLibevEvents *e = (redisLibevEvents*)privdata; - redisLibevDelRead(privdata); - redisLibevDelWrite(privdata); - redisLibevStopTimer(privdata); +static void redictLibevCleanup(void *privdata) { + redictLibevEvents *e = (redictLibevEvents*)privdata; + redictLibevDelRead(privdata); + redictLibevDelWrite(privdata); + redictLibevStopTimer(privdata); hi_free(e); } -static void redisLibevTimeout(EV_P_ ev_timer *timer, int revents) { +static void redictLibevTimeout(EV_P_ ev_timer *timer, int revents) { #if EV_MULTIPLICITY ((void)EV_A); #endif ((void)revents); - redisLibevEvents *e = (redisLibevEvents*)timer->data; - redisAsyncHandleTimeout(e->context); + redictLibevEvents *e = (redictLibevEvents*)timer->data; + redictAsyncHandleTimeout(e->context); } -static void redisLibevSetTimeout(void *privdata, struct timeval tv) { - redisLibevEvents *e = (redisLibevEvents*)privdata; +static void redictLibevSetTimeout(void *privdata, struct timeval tv) { + redictLibevEvents *e = (redictLibevEvents*)privdata; #if EV_MULTIPLICITY struct ev_loop *loop = e->loop; #endif if (!ev_is_active(&e->timer)) { - ev_init(&e->timer, redisLibevTimeout); + ev_init(&e->timer, redictLibevTimeout); e->timer.data = e; } @@ -131,18 +131,18 @@ static void redisLibevSetTimeout(void *privdata, struct timeval tv) { ev_timer_again(EV_A_ &e->timer); } -static int redisLibevAttach(EV_P_ redisAsyncContext *ac) { - redisContext *c = &(ac->c); - redisLibevEvents *e; +static int redictLibevAttach(EV_P_ redictAsyncContext *ac) { + redictContext *c = &(ac->c); + redictLibevEvents *e; /* Nothing should be attached when something is already attached */ if (ac->ev.data != NULL) - return REDIS_ERR; + return REDICT_ERR; /* Create container for context and r/w events */ - e = (redisLibevEvents*)hi_calloc(1, sizeof(*e)); + e = (redictLibevEvents*)hi_calloc(1, sizeof(*e)); if (e == NULL) - return REDIS_ERR; + return REDICT_ERR; e->context = ac; #if EV_MULTIPLICITY @@ -154,18 +154,18 @@ static int redisLibevAttach(EV_P_ redisAsyncContext *ac) { e->wev.data = e; /* Register functions to start/stop listening for events */ - ac->ev.addRead = redisLibevAddRead; - ac->ev.delRead = redisLibevDelRead; - ac->ev.addWrite = redisLibevAddWrite; - ac->ev.delWrite = redisLibevDelWrite; - ac->ev.cleanup = redisLibevCleanup; - ac->ev.scheduleTimer = redisLibevSetTimeout; + ac->ev.addRead = redictLibevAddRead; + ac->ev.delRead = redictLibevDelRead; + ac->ev.addWrite = redictLibevAddWrite; + ac->ev.delWrite = redictLibevDelWrite; + ac->ev.cleanup = redictLibevCleanup; + ac->ev.scheduleTimer = redictLibevSetTimeout; ac->ev.data = e; /* Initialize read/write events */ - ev_io_init(&e->rev,redisLibevReadEvent,c->fd,EV_READ); - ev_io_init(&e->wev,redisLibevWriteEvent,c->fd,EV_WRITE); - return REDIS_OK; + ev_io_init(&e->rev,redictLibevReadEvent,c->fd,EV_READ); + ev_io_init(&e->wev,redictLibevWriteEvent,c->fd,EV_WRITE); + return REDICT_OK; } #endif diff --git a/adapters/libevent.h b/adapters/libevent.h index 936c37e..66ce6b6 100644 --- a/adapters/libevent.h +++ b/adapters/libevent.h @@ -9,59 +9,59 @@ * */ -#ifndef __HIREDIS_LIBEVENT_H__ -#define __HIREDIS_LIBEVENT_H__ +#ifndef __HIREDICT_LIBEVENT_H__ +#define __HIREDICT_LIBEVENT_H__ #include #include "../hiredict.h" #include "../async.h" -#define REDIS_LIBEVENT_DELETED 0x01 -#define REDIS_LIBEVENT_ENTERED 0x02 +#define REDICT_LIBEVENT_DELETED 0x01 +#define REDICT_LIBEVENT_ENTERED 0x02 -typedef struct redisLibeventEvents { - redisAsyncContext *context; +typedef struct redictLibeventEvents { + redictAsyncContext *context; struct event *ev; struct event_base *base; struct timeval tv; short flags; short state; -} redisLibeventEvents; +} redictLibeventEvents; -static void redisLibeventDestroy(redisLibeventEvents *e) { +static void redictLibeventDestroy(redictLibeventEvents *e) { hi_free(e); } -static void redisLibeventHandler(evutil_socket_t fd, short event, void *arg) { +static void redictLibeventHandler(evutil_socket_t fd, short event, void *arg) { ((void)fd); - redisLibeventEvents *e = (redisLibeventEvents*)arg; - e->state |= REDIS_LIBEVENT_ENTERED; + redictLibeventEvents *e = (redictLibeventEvents*)arg; + e->state |= REDICT_LIBEVENT_ENTERED; - #define CHECK_DELETED() if (e->state & REDIS_LIBEVENT_DELETED) {\ - redisLibeventDestroy(e);\ + #define CHECK_DELETED() if (e->state & REDICT_LIBEVENT_DELETED) {\ + redictLibeventDestroy(e);\ return; \ } - if ((event & EV_TIMEOUT) && (e->state & REDIS_LIBEVENT_DELETED) == 0) { - redisAsyncHandleTimeout(e->context); + if ((event & EV_TIMEOUT) && (e->state & REDICT_LIBEVENT_DELETED) == 0) { + redictAsyncHandleTimeout(e->context); CHECK_DELETED(); } - if ((event & EV_READ) && e->context && (e->state & REDIS_LIBEVENT_DELETED) == 0) { - redisAsyncHandleRead(e->context); + if ((event & EV_READ) && e->context && (e->state & REDICT_LIBEVENT_DELETED) == 0) { + redictAsyncHandleRead(e->context); CHECK_DELETED(); } - if ((event & EV_WRITE) && e->context && (e->state & REDIS_LIBEVENT_DELETED) == 0) { - redisAsyncHandleWrite(e->context); + if ((event & EV_WRITE) && e->context && (e->state & REDICT_LIBEVENT_DELETED) == 0) { + redictAsyncHandleWrite(e->context); CHECK_DELETED(); } - e->state &= ~REDIS_LIBEVENT_ENTERED; + e->state &= ~REDICT_LIBEVENT_ENTERED; #undef CHECK_DELETED } -static void redisLibeventUpdate(void *privdata, short flag, int isRemove) { - redisLibeventEvents *e = (redisLibeventEvents *)privdata; +static void redictLibeventUpdate(void *privdata, short flag, int isRemove) { + redictLibeventEvents *e = (redictLibeventEvents *)privdata; const struct timeval *tv = e->tv.tv_sec || e->tv.tv_usec ? &e->tv : NULL; if (isRemove) { @@ -80,28 +80,28 @@ static void redisLibeventUpdate(void *privdata, short flag, int isRemove) { event_del(e->ev); event_assign(e->ev, e->base, e->context->c.fd, e->flags | EV_PERSIST, - redisLibeventHandler, privdata); + redictLibeventHandler, privdata); event_add(e->ev, tv); } -static void redisLibeventAddRead(void *privdata) { - redisLibeventUpdate(privdata, EV_READ, 0); +static void redictLibeventAddRead(void *privdata) { + redictLibeventUpdate(privdata, EV_READ, 0); } -static void redisLibeventDelRead(void *privdata) { - redisLibeventUpdate(privdata, EV_READ, 1); +static void redictLibeventDelRead(void *privdata) { + redictLibeventUpdate(privdata, EV_READ, 1); } -static void redisLibeventAddWrite(void *privdata) { - redisLibeventUpdate(privdata, EV_WRITE, 0); +static void redictLibeventAddWrite(void *privdata) { + redictLibeventUpdate(privdata, EV_WRITE, 0); } -static void redisLibeventDelWrite(void *privdata) { - redisLibeventUpdate(privdata, EV_WRITE, 1); +static void redictLibeventDelWrite(void *privdata) { + redictLibeventUpdate(privdata, EV_WRITE, 1); } -static void redisLibeventCleanup(void *privdata) { - redisLibeventEvents *e = (redisLibeventEvents*)privdata; +static void redictLibeventCleanup(void *privdata) { + redictLibeventEvents *e = (redictLibeventEvents*)privdata; if (!e) { return; } @@ -109,48 +109,48 @@ static void redisLibeventCleanup(void *privdata) { event_free(e->ev); e->ev = NULL; - if (e->state & REDIS_LIBEVENT_ENTERED) { - e->state |= REDIS_LIBEVENT_DELETED; + if (e->state & REDICT_LIBEVENT_ENTERED) { + e->state |= REDICT_LIBEVENT_DELETED; } else { - redisLibeventDestroy(e); + redictLibeventDestroy(e); } } -static void redisLibeventSetTimeout(void *privdata, struct timeval tv) { - redisLibeventEvents *e = (redisLibeventEvents *)privdata; +static void redictLibeventSetTimeout(void *privdata, struct timeval tv) { + redictLibeventEvents *e = (redictLibeventEvents *)privdata; short flags = e->flags; e->flags = 0; e->tv = tv; - redisLibeventUpdate(e, flags, 0); + redictLibeventUpdate(e, flags, 0); } -static int redisLibeventAttach(redisAsyncContext *ac, struct event_base *base) { - redisContext *c = &(ac->c); - redisLibeventEvents *e; +static int redictLibeventAttach(redictAsyncContext *ac, struct event_base *base) { + redictContext *c = &(ac->c); + redictLibeventEvents *e; /* Nothing should be attached when something is already attached */ if (ac->ev.data != NULL) - return REDIS_ERR; + return REDICT_ERR; /* Create container for context and r/w events */ - e = (redisLibeventEvents*)hi_calloc(1, sizeof(*e)); + e = (redictLibeventEvents*)hi_calloc(1, sizeof(*e)); if (e == NULL) - return REDIS_ERR; + return REDICT_ERR; e->context = ac; /* Register functions to start/stop listening for events */ - ac->ev.addRead = redisLibeventAddRead; - ac->ev.delRead = redisLibeventDelRead; - ac->ev.addWrite = redisLibeventAddWrite; - ac->ev.delWrite = redisLibeventDelWrite; - ac->ev.cleanup = redisLibeventCleanup; - ac->ev.scheduleTimer = redisLibeventSetTimeout; + ac->ev.addRead = redictLibeventAddRead; + ac->ev.delRead = redictLibeventDelRead; + ac->ev.addWrite = redictLibeventAddWrite; + ac->ev.delWrite = redictLibeventDelWrite; + ac->ev.cleanup = redictLibeventCleanup; + ac->ev.scheduleTimer = redictLibeventSetTimeout; ac->ev.data = e; /* Initialize and install read/write events */ - e->ev = event_new(base, c->fd, EV_READ | EV_WRITE, redisLibeventHandler, e); + e->ev = event_new(base, c->fd, EV_READ | EV_WRITE, redictLibeventHandler, e); e->base = base; - return REDIS_OK; + return REDICT_OK; } #endif diff --git a/adapters/libhv.h b/adapters/libhv.h index 4955bb4..2d6fd77 100644 --- a/adapters/libhv.h +++ b/adapters/libhv.h @@ -9,52 +9,52 @@ * */ -#ifndef __HIREDIS_LIBHV_H__ -#define __HIREDIS_LIBHV_H__ +#ifndef __HIREDICT_LIBHV_H__ +#define __HIREDICT_LIBHV_H__ #include #include "../hiredict.h" #include "../async.h" -typedef struct redisLibhvEvents { +typedef struct redictLibhvEvents { hio_t *io; htimer_t *timer; -} redisLibhvEvents; +} redictLibhvEvents; -static void redisLibhvHandleEvents(hio_t* io) { - redisAsyncContext* context = (redisAsyncContext*)hevent_userdata(io); +static void redictLibhvHandleEvents(hio_t* io) { + redictAsyncContext* context = (redictAsyncContext*)hevent_userdata(io); int events = hio_events(io); int revents = hio_revents(io); if (context && (events & HV_READ) && (revents & HV_READ)) { - redisAsyncHandleRead(context); + redictAsyncHandleRead(context); } if (context && (events & HV_WRITE) && (revents & HV_WRITE)) { - redisAsyncHandleWrite(context); + redictAsyncHandleWrite(context); } } -static void redisLibhvAddRead(void *privdata) { - redisLibhvEvents* events = (redisLibhvEvents*)privdata; - hio_add(events->io, redisLibhvHandleEvents, HV_READ); +static void redictLibhvAddRead(void *privdata) { + redictLibhvEvents* events = (redictLibhvEvents*)privdata; + hio_add(events->io, redictLibhvHandleEvents, HV_READ); } -static void redisLibhvDelRead(void *privdata) { - redisLibhvEvents* events = (redisLibhvEvents*)privdata; +static void redictLibhvDelRead(void *privdata) { + redictLibhvEvents* events = (redictLibhvEvents*)privdata; hio_del(events->io, HV_READ); } -static void redisLibhvAddWrite(void *privdata) { - redisLibhvEvents* events = (redisLibhvEvents*)privdata; - hio_add(events->io, redisLibhvHandleEvents, HV_WRITE); +static void redictLibhvAddWrite(void *privdata) { + redictLibhvEvents* events = (redictLibhvEvents*)privdata; + hio_add(events->io, redictLibhvHandleEvents, HV_WRITE); } -static void redisLibhvDelWrite(void *privdata) { - redisLibhvEvents* events = (redisLibhvEvents*)privdata; +static void redictLibhvDelWrite(void *privdata) { + redictLibhvEvents* events = (redictLibhvEvents*)privdata; hio_del(events->io, HV_WRITE); } -static void redisLibhvCleanup(void *privdata) { - redisLibhvEvents* events = (redisLibhvEvents*)privdata; +static void redictLibhvCleanup(void *privdata) { + redictLibhvEvents* events = (redictLibhvEvents*)privdata; if (events->timer) htimer_del(events->timer); @@ -65,17 +65,17 @@ static void redisLibhvCleanup(void *privdata) { hi_free(events); } -static void redisLibhvTimeout(htimer_t* timer) { +static void redictLibhvTimeout(htimer_t* timer) { hio_t* io = (hio_t*)hevent_userdata(timer); - redisAsyncHandleTimeout((redisAsyncContext*)hevent_userdata(io)); + redictAsyncHandleTimeout((redictAsyncContext*)hevent_userdata(io)); } -static void redisLibhvSetTimeout(void *privdata, struct timeval tv) { - redisLibhvEvents* events; +static void redictLibhvSetTimeout(void *privdata, struct timeval tv) { + redictLibhvEvents* events; uint32_t millis; hloop_t* loop; - events = (redisLibhvEvents*)privdata; + events = (redictLibhvEvents*)privdata; millis = tv.tv_sec * 1000 + tv.tv_usec / 1000; if (millis == 0) { @@ -87,7 +87,7 @@ static void redisLibhvSetTimeout(void *privdata, struct timeval tv) { } else if (events->timer == NULL) { /* Add new timer */ loop = hevent_loop(events->io); - events->timer = htimer_add(loop, redisLibhvTimeout, millis, 1); + events->timer = htimer_add(loop, redictLibhvTimeout, millis, 1); hevent_set_userdata(events->timer, events->io); } else { /* Update existing timer */ @@ -95,25 +95,25 @@ static void redisLibhvSetTimeout(void *privdata, struct timeval tv) { } } -static int redisLibhvAttach(redisAsyncContext* ac, hloop_t* loop) { - redisContext *c = &(ac->c); - redisLibhvEvents *events; +static int redictLibhvAttach(redictAsyncContext* ac, hloop_t* loop) { + redictContext *c = &(ac->c); + redictLibhvEvents *events; hio_t* io = NULL; if (ac->ev.data != NULL) { - return REDIS_ERR; + return REDICT_ERR; } /* Create container struct to keep track of our io and any timer */ - events = (redisLibhvEvents*)hi_malloc(sizeof(*events)); + events = (redictLibhvEvents*)hi_malloc(sizeof(*events)); if (events == NULL) { - return REDIS_ERR; + return REDICT_ERR; } io = hio_get(loop, c->fd); if (io == NULL) { hi_free(events); - return REDIS_ERR; + return REDICT_ERR; } hevent_set_userdata(io, ac); @@ -121,14 +121,14 @@ static int redisLibhvAttach(redisAsyncContext* ac, hloop_t* loop) { events->io = io; events->timer = NULL; - ac->ev.addRead = redisLibhvAddRead; - ac->ev.delRead = redisLibhvDelRead; - ac->ev.addWrite = redisLibhvAddWrite; - ac->ev.delWrite = redisLibhvDelWrite; - ac->ev.cleanup = redisLibhvCleanup; - ac->ev.scheduleTimer = redisLibhvSetTimeout; + ac->ev.addRead = redictLibhvAddRead; + ac->ev.delRead = redictLibhvDelRead; + ac->ev.addWrite = redictLibhvAddWrite; + ac->ev.delWrite = redictLibhvDelWrite; + ac->ev.cleanup = redictLibhvCleanup; + ac->ev.scheduleTimer = redictLibhvSetTimeout; ac->ev.data = events; - return REDIS_OK; + return REDICT_OK; } #endif diff --git a/adapters/libsdevent.h b/adapters/libsdevent.h index dc4249a..103d69e 100644 --- a/adapters/libsdevent.h +++ b/adapters/libsdevent.h @@ -9,26 +9,26 @@ * */ -#ifndef HIREDIS_LIBSDEVENT_H -#define HIREDIS_LIBSDEVENT_H +#ifndef HIREDICT_LIBSDEVENT_H +#define HIREDICT_LIBSDEVENT_H #include #include "../hiredict.h" #include "../async.h" -#define REDIS_LIBSDEVENT_DELETED 0x01 -#define REDIS_LIBSDEVENT_ENTERED 0x02 +#define REDICT_LIBSDEVENT_DELETED 0x01 +#define REDICT_LIBSDEVENT_ENTERED 0x02 -typedef struct redisLibsdeventEvents { - redisAsyncContext *context; +typedef struct redictLibsdeventEvents { + redictAsyncContext *context; struct sd_event *event; struct sd_event_source *fdSource; struct sd_event_source *timerSource; int fd; short flags; short state; -} redisLibsdeventEvents; +} redictLibsdeventEvents; -static void redisLibsdeventDestroy(redisLibsdeventEvents *e) { +static void redictLibsdeventDestroy(redictLibsdeventEvents *e) { if (e->fdSource) { e->fdSource = sd_event_source_disable_unref(e->fdSource); } @@ -39,43 +39,43 @@ static void redisLibsdeventDestroy(redisLibsdeventEvents *e) { hi_free(e); } -static int redisLibsdeventTimeoutHandler(sd_event_source *s, uint64_t usec, void *userdata) { +static int redictLibsdeventTimeoutHandler(sd_event_source *s, uint64_t usec, void *userdata) { ((void)s); ((void)usec); - redisLibsdeventEvents *e = (redisLibsdeventEvents*)userdata; - redisAsyncHandleTimeout(e->context); + redictLibsdeventEvents *e = (redictLibsdeventEvents*)userdata; + redictAsyncHandleTimeout(e->context); return 0; } -static int redisLibsdeventHandler(sd_event_source *s, int fd, uint32_t event, void *userdata) { +static int redictLibsdeventHandler(sd_event_source *s, int fd, uint32_t event, void *userdata) { ((void)s); ((void)fd); - redisLibsdeventEvents *e = (redisLibsdeventEvents*)userdata; - e->state |= REDIS_LIBSDEVENT_ENTERED; + redictLibsdeventEvents *e = (redictLibsdeventEvents*)userdata; + e->state |= REDICT_LIBSDEVENT_ENTERED; -#define CHECK_DELETED() if (e->state & REDIS_LIBSDEVENT_DELETED) {\ - redisLibsdeventDestroy(e);\ +#define CHECK_DELETED() if (e->state & REDICT_LIBSDEVENT_DELETED) {\ + redictLibsdeventDestroy(e);\ return 0; \ } - if ((event & EPOLLIN) && e->context && (e->state & REDIS_LIBSDEVENT_DELETED) == 0) { - redisAsyncHandleRead(e->context); + if ((event & EPOLLIN) && e->context && (e->state & REDICT_LIBSDEVENT_DELETED) == 0) { + redictAsyncHandleRead(e->context); CHECK_DELETED(); } - if ((event & EPOLLOUT) && e->context && (e->state & REDIS_LIBSDEVENT_DELETED) == 0) { - redisAsyncHandleWrite(e->context); + if ((event & EPOLLOUT) && e->context && (e->state & REDICT_LIBSDEVENT_DELETED) == 0) { + redictAsyncHandleWrite(e->context); CHECK_DELETED(); } - e->state &= ~REDIS_LIBSDEVENT_ENTERED; + e->state &= ~REDICT_LIBSDEVENT_ENTERED; #undef CHECK_DELETED return 0; } -static void redisLibsdeventAddRead(void *userdata) { - redisLibsdeventEvents *e = (redisLibsdeventEvents*)userdata; +static void redictLibsdeventAddRead(void *userdata) { + redictLibsdeventEvents *e = (redictLibsdeventEvents*)userdata; if (e->flags & EPOLLIN) { return; @@ -86,12 +86,12 @@ static void redisLibsdeventAddRead(void *userdata) { if (e->flags & EPOLLOUT) { sd_event_source_set_io_events(e->fdSource, e->flags); } else { - sd_event_add_io(e->event, &e->fdSource, e->fd, e->flags, redisLibsdeventHandler, e); + sd_event_add_io(e->event, &e->fdSource, e->fd, e->flags, redictLibsdeventHandler, e); } } -static void redisLibsdeventDelRead(void *userdata) { - redisLibsdeventEvents *e = (redisLibsdeventEvents*)userdata; +static void redictLibsdeventDelRead(void *userdata) { + redictLibsdeventEvents *e = (redictLibsdeventEvents*)userdata; e->flags &= ~EPOLLIN; @@ -102,8 +102,8 @@ static void redisLibsdeventDelRead(void *userdata) { } } -static void redisLibsdeventAddWrite(void *userdata) { - redisLibsdeventEvents *e = (redisLibsdeventEvents*)userdata; +static void redictLibsdeventAddWrite(void *userdata) { + redictLibsdeventEvents *e = (redictLibsdeventEvents*)userdata; if (e->flags & EPOLLOUT) { return; @@ -114,12 +114,12 @@ static void redisLibsdeventAddWrite(void *userdata) { if (e->flags & EPOLLIN) { sd_event_source_set_io_events(e->fdSource, e->flags); } else { - sd_event_add_io(e->event, &e->fdSource, e->fd, e->flags, redisLibsdeventHandler, e); + sd_event_add_io(e->event, &e->fdSource, e->fd, e->flags, redictLibsdeventHandler, e); } } -static void redisLibsdeventDelWrite(void *userdata) { - redisLibsdeventEvents *e = (redisLibsdeventEvents*)userdata; +static void redictLibsdeventDelWrite(void *userdata) { + redictLibsdeventEvents *e = (redictLibsdeventEvents*)userdata; e->flags &= ~EPOLLOUT; @@ -130,43 +130,43 @@ static void redisLibsdeventDelWrite(void *userdata) { } } -static void redisLibsdeventCleanup(void *userdata) { - redisLibsdeventEvents *e = (redisLibsdeventEvents*)userdata; +static void redictLibsdeventCleanup(void *userdata) { + redictLibsdeventEvents *e = (redictLibsdeventEvents*)userdata; if (!e) { return; } - if (e->state & REDIS_LIBSDEVENT_ENTERED) { - e->state |= REDIS_LIBSDEVENT_DELETED; + if (e->state & REDICT_LIBSDEVENT_ENTERED) { + e->state |= REDICT_LIBSDEVENT_DELETED; } else { - redisLibsdeventDestroy(e); + redictLibsdeventDestroy(e); } } -static void redisLibsdeventSetTimeout(void *userdata, struct timeval tv) { - redisLibsdeventEvents *e = (redisLibsdeventEvents *)userdata; +static void redictLibsdeventSetTimeout(void *userdata, struct timeval tv) { + redictLibsdeventEvents *e = (redictLibsdeventEvents *)userdata; uint64_t usec = tv.tv_sec * 1000000 + tv.tv_usec; if (!e->timerSource) { - sd_event_add_time_relative(e->event, &e->timerSource, CLOCK_MONOTONIC, usec, 1, redisLibsdeventTimeoutHandler, e); + sd_event_add_time_relative(e->event, &e->timerSource, CLOCK_MONOTONIC, usec, 1, redictLibsdeventTimeoutHandler, e); } else { sd_event_source_set_time_relative(e->timerSource, usec); } } -static int redisLibsdeventAttach(redisAsyncContext *ac, struct sd_event *event) { - redisContext *c = &(ac->c); - redisLibsdeventEvents *e; +static int redictLibsdeventAttach(redictAsyncContext *ac, struct sd_event *event) { + redictContext *c = &(ac->c); + redictLibsdeventEvents *e; /* Nothing should be attached when something is already attached */ if (ac->ev.data != NULL) - return REDIS_ERR; + return REDICT_ERR; /* Create container for context and r/w events */ - e = (redisLibsdeventEvents*)hi_calloc(1, sizeof(*e)); + e = (redictLibsdeventEvents*)hi_calloc(1, sizeof(*e)); if (e == NULL) - return REDIS_ERR; + return REDICT_ERR; /* Initialize and increase event refcount */ e->context = ac; @@ -175,14 +175,14 @@ static int redisLibsdeventAttach(redisAsyncContext *ac, struct sd_event *event) sd_event_ref(event); /* Register functions to start/stop listening for events */ - ac->ev.addRead = redisLibsdeventAddRead; - ac->ev.delRead = redisLibsdeventDelRead; - ac->ev.addWrite = redisLibsdeventAddWrite; - ac->ev.delWrite = redisLibsdeventDelWrite; - ac->ev.cleanup = redisLibsdeventCleanup; - ac->ev.scheduleTimer = redisLibsdeventSetTimeout; + ac->ev.addRead = redictLibsdeventAddRead; + ac->ev.delRead = redictLibsdeventDelRead; + ac->ev.addWrite = redictLibsdeventAddWrite; + ac->ev.delWrite = redictLibsdeventDelWrite; + ac->ev.cleanup = redictLibsdeventCleanup; + ac->ev.scheduleTimer = redictLibsdeventSetTimeout; ac->ev.data = e; - return REDIS_OK; + return REDICT_OK; } #endif diff --git a/adapters/libuv.h b/adapters/libuv.h index 317d5e1..e91b872 100644 --- a/adapters/libuv.h +++ b/adapters/libuv.h @@ -9,37 +9,37 @@ * */ -#ifndef __HIREDIS_LIBUV_H__ -#define __HIREDIS_LIBUV_H__ +#ifndef __HIREDICT_LIBUV_H__ +#define __HIREDICT_LIBUV_H__ #include #include #include "../hiredict.h" #include "../async.h" #include -typedef struct redisLibuvEvents { - redisAsyncContext* context; +typedef struct redictLibuvEvents { + redictAsyncContext* context; uv_poll_t handle; uv_timer_t timer; int events; -} redisLibuvEvents; +} redictLibuvEvents; -static void redisLibuvPoll(uv_poll_t* handle, int status, int events) { - redisLibuvEvents* p = (redisLibuvEvents*)handle->data; +static void redictLibuvPoll(uv_poll_t* handle, int status, int events) { + redictLibuvEvents* p = (redictLibuvEvents*)handle->data; int ev = (status ? p->events : events); if (p->context != NULL && (ev & UV_READABLE)) { - redisAsyncHandleRead(p->context); + redictAsyncHandleRead(p->context); } if (p->context != NULL && (ev & UV_WRITABLE)) { - redisAsyncHandleWrite(p->context); + redictAsyncHandleWrite(p->context); } } -static void redisLibuvAddRead(void *privdata) { - redisLibuvEvents* p = (redisLibuvEvents*)privdata; +static void redictLibuvAddRead(void *privdata) { + redictLibuvEvents* p = (redictLibuvEvents*)privdata; if (p->events & UV_READABLE) { return; @@ -47,25 +47,25 @@ static void redisLibuvAddRead(void *privdata) { p->events |= UV_READABLE; - uv_poll_start(&p->handle, p->events, redisLibuvPoll); + uv_poll_start(&p->handle, p->events, redictLibuvPoll); } -static void redisLibuvDelRead(void *privdata) { - redisLibuvEvents* p = (redisLibuvEvents*)privdata; +static void redictLibuvDelRead(void *privdata) { + redictLibuvEvents* p = (redictLibuvEvents*)privdata; p->events &= ~UV_READABLE; if (p->events) { - uv_poll_start(&p->handle, p->events, redisLibuvPoll); + uv_poll_start(&p->handle, p->events, redictLibuvPoll); } else { uv_poll_stop(&p->handle); } } -static void redisLibuvAddWrite(void *privdata) { - redisLibuvEvents* p = (redisLibuvEvents*)privdata; +static void redictLibuvAddWrite(void *privdata) { + redictLibuvEvents* p = (redictLibuvEvents*)privdata; if (p->events & UV_WRITABLE) { return; @@ -73,24 +73,24 @@ static void redisLibuvAddWrite(void *privdata) { p->events |= UV_WRITABLE; - uv_poll_start(&p->handle, p->events, redisLibuvPoll); + uv_poll_start(&p->handle, p->events, redictLibuvPoll); } -static void redisLibuvDelWrite(void *privdata) { - redisLibuvEvents* p = (redisLibuvEvents*)privdata; +static void redictLibuvDelWrite(void *privdata) { + redictLibuvEvents* p = (redictLibuvEvents*)privdata; p->events &= ~UV_WRITABLE; if (p->events) { - uv_poll_start(&p->handle, p->events, redisLibuvPoll); + uv_poll_start(&p->handle, p->events, redictLibuvPoll); } else { uv_poll_stop(&p->handle); } } static void on_timer_close(uv_handle_t *handle) { - redisLibuvEvents* p = (redisLibuvEvents*)handle->data; + redictLibuvEvents* p = (redictLibuvEvents*)handle->data; p->timer.data = NULL; if (!p->handle.data) { // both timer and handle are closed @@ -100,7 +100,7 @@ static void on_timer_close(uv_handle_t *handle) { } static void on_handle_close(uv_handle_t *handle) { - redisLibuvEvents* p = (redisLibuvEvents*)handle->data; + redictLibuvEvents* p = (redictLibuvEvents*)handle->data; p->handle.data = NULL; if (!p->timer.data) { // timer never started, or timer already destroyed @@ -113,17 +113,17 @@ static void on_handle_close(uv_handle_t *handle) { // see: https://github.com/libuv/libuv/blob/v0.11.23/include/uv.h #if (UV_VERSION_MAJOR == 0 && UV_VERSION_MINOR < 11) || \ (UV_VERSION_MAJOR == 0 && UV_VERSION_MINOR == 11 && UV_VERSION_PATCH < 23) -static void redisLibuvTimeout(uv_timer_t *timer, int status) { +static void redictLibuvTimeout(uv_timer_t *timer, int status) { (void)status; // unused #else -static void redisLibuvTimeout(uv_timer_t *timer) { +static void redictLibuvTimeout(uv_timer_t *timer) { #endif - redisLibuvEvents *e = (redisLibuvEvents*)timer->data; - redisAsyncHandleTimeout(e->context); + redictLibuvEvents *e = (redictLibuvEvents*)timer->data; + redictAsyncHandleTimeout(e->context); } -static void redisLibuvSetTimeout(void *privdata, struct timeval tv) { - redisLibuvEvents* p = (redisLibuvEvents*)privdata; +static void redictLibuvSetTimeout(void *privdata, struct timeval tv) { + redictLibuvEvents* p = (redictLibuvEvents*)privdata; uint64_t millsec = tv.tv_sec * 1000 + tv.tv_usec / 1000.0; if (!p->timer.data) { @@ -135,11 +135,11 @@ static void redisLibuvSetTimeout(void *privdata, struct timeval tv) { } // updates the timeout if the timer has already started // or start the timer - uv_timer_start(&p->timer, redisLibuvTimeout, millsec, 0); + uv_timer_start(&p->timer, redictLibuvTimeout, millsec, 0); } -static void redisLibuvCleanup(void *privdata) { - redisLibuvEvents* p = (redisLibuvEvents*)privdata; +static void redictLibuvCleanup(void *privdata) { + redictLibuvEvents* p = (redictLibuvEvents*)privdata; p->context = NULL; // indicate that context might no longer exist if (p->timer.data) { @@ -149,35 +149,35 @@ static void redisLibuvCleanup(void *privdata) { } -static int redisLibuvAttach(redisAsyncContext* ac, uv_loop_t* loop) { - redisContext *c = &(ac->c); +static int redictLibuvAttach(redictAsyncContext* ac, uv_loop_t* loop) { + redictContext *c = &(ac->c); if (ac->ev.data != NULL) { - return REDIS_ERR; + return REDICT_ERR; } - ac->ev.addRead = redisLibuvAddRead; - ac->ev.delRead = redisLibuvDelRead; - ac->ev.addWrite = redisLibuvAddWrite; - ac->ev.delWrite = redisLibuvDelWrite; - ac->ev.cleanup = redisLibuvCleanup; - ac->ev.scheduleTimer = redisLibuvSetTimeout; + ac->ev.addRead = redictLibuvAddRead; + ac->ev.delRead = redictLibuvDelRead; + ac->ev.addWrite = redictLibuvAddWrite; + ac->ev.delWrite = redictLibuvDelWrite; + ac->ev.cleanup = redictLibuvCleanup; + ac->ev.scheduleTimer = redictLibuvSetTimeout; - redisLibuvEvents* p = (redisLibuvEvents*)hi_malloc(sizeof(*p)); + redictLibuvEvents* p = (redictLibuvEvents*)hi_malloc(sizeof(*p)); if (p == NULL) - return REDIS_ERR; + return REDICT_ERR; memset(p, 0, sizeof(*p)); if (uv_poll_init_socket(loop, &p->handle, c->fd) != 0) { hi_free(p); - return REDIS_ERR; + return REDICT_ERR; } ac->ev.data = p; p->handle.data = p; p->context = ac; - return REDIS_OK; + return REDICT_OK; } #endif diff --git a/adapters/macosx.h b/adapters/macosx.h index 7ae5e5a..670ca62 100644 --- a/adapters/macosx.h +++ b/adapters/macosx.h @@ -9,8 +9,8 @@ * */ -#ifndef __HIREDIS_MACOSX_H__ -#define __HIREDIS_MACOSX_H__ +#ifndef __HIREDICT_MACOSX_H__ +#define __HIREDICT_MACOSX_H__ #include @@ -18,61 +18,61 @@ #include "../async.h" typedef struct { - redisAsyncContext *context; + redictAsyncContext *context; CFSocketRef socketRef; CFRunLoopSourceRef sourceRef; -} RedisRunLoop; +} RedictRunLoop; -static int freeRedisRunLoop(RedisRunLoop* redisRunLoop) { - if( redisRunLoop != NULL ) { - if( redisRunLoop->sourceRef != NULL ) { - CFRunLoopSourceInvalidate(redisRunLoop->sourceRef); - CFRelease(redisRunLoop->sourceRef); +static int freeRedictRunLoop(RedictRunLoop* redictRunLoop) { + if( redictRunLoop != NULL ) { + if( redictRunLoop->sourceRef != NULL ) { + CFRunLoopSourceInvalidate(redictRunLoop->sourceRef); + CFRelease(redictRunLoop->sourceRef); } - if( redisRunLoop->socketRef != NULL ) { - CFSocketInvalidate(redisRunLoop->socketRef); - CFRelease(redisRunLoop->socketRef); + if( redictRunLoop->socketRef != NULL ) { + CFSocketInvalidate(redictRunLoop->socketRef); + CFRelease(redictRunLoop->socketRef); } - hi_free(redisRunLoop); + hi_free(redictRunLoop); } - return REDIS_ERR; + return REDICT_ERR; } -static void redisMacOSAddRead(void *privdata) { - RedisRunLoop *redisRunLoop = (RedisRunLoop*)privdata; - CFSocketEnableCallBacks(redisRunLoop->socketRef, kCFSocketReadCallBack); +static void redictMacOSAddRead(void *privdata) { + RedictRunLoop *redictRunLoop = (RedictRunLoop*)privdata; + CFSocketEnableCallBacks(redictRunLoop->socketRef, kCFSocketReadCallBack); } -static void redisMacOSDelRead(void *privdata) { - RedisRunLoop *redisRunLoop = (RedisRunLoop*)privdata; - CFSocketDisableCallBacks(redisRunLoop->socketRef, kCFSocketReadCallBack); +static void redictMacOSDelRead(void *privdata) { + RedictRunLoop *redictRunLoop = (RedictRunLoop*)privdata; + CFSocketDisableCallBacks(redictRunLoop->socketRef, kCFSocketReadCallBack); } -static void redisMacOSAddWrite(void *privdata) { - RedisRunLoop *redisRunLoop = (RedisRunLoop*)privdata; - CFSocketEnableCallBacks(redisRunLoop->socketRef, kCFSocketWriteCallBack); +static void redictMacOSAddWrite(void *privdata) { + RedictRunLoop *redictRunLoop = (RedictRunLoop*)privdata; + CFSocketEnableCallBacks(redictRunLoop->socketRef, kCFSocketWriteCallBack); } -static void redisMacOSDelWrite(void *privdata) { - RedisRunLoop *redisRunLoop = (RedisRunLoop*)privdata; - CFSocketDisableCallBacks(redisRunLoop->socketRef, kCFSocketWriteCallBack); +static void redictMacOSDelWrite(void *privdata) { + RedictRunLoop *redictRunLoop = (RedictRunLoop*)privdata; + CFSocketDisableCallBacks(redictRunLoop->socketRef, kCFSocketWriteCallBack); } -static void redisMacOSCleanup(void *privdata) { - RedisRunLoop *redisRunLoop = (RedisRunLoop*)privdata; - freeRedisRunLoop(redisRunLoop); +static void redictMacOSCleanup(void *privdata) { + RedictRunLoop *redictRunLoop = (RedictRunLoop*)privdata; + freeRedictRunLoop(redictRunLoop); } -static void redisMacOSAsyncCallback(CFSocketRef __unused s, CFSocketCallBackType callbackType, CFDataRef __unused address, const void __unused *data, void *info) { - redisAsyncContext* context = (redisAsyncContext*) info; +static void redictMacOSAsyncCallback(CFSocketRef __unused s, CFSocketCallBackType callbackType, CFDataRef __unused address, const void __unused *data, void *info) { + redictAsyncContext* context = (redictAsyncContext*) info; switch (callbackType) { case kCFSocketReadCallBack: - redisAsyncHandleRead(context); + redictAsyncHandleRead(context); break; case kCFSocketWriteCallBack: - redisAsyncHandleWrite(context); + redictAsyncHandleWrite(context); break; default: @@ -80,41 +80,41 @@ static void redisMacOSAsyncCallback(CFSocketRef __unused s, CFSocketCallBackType } } -static int redisMacOSAttach(redisAsyncContext *redisAsyncCtx, CFRunLoopRef runLoop) { - redisContext *redisCtx = &(redisAsyncCtx->c); +static int redictMacOSAttach(redictAsyncContext *redictAsyncCtx, CFRunLoopRef runLoop) { + redictContext *redictCtx = &(redictAsyncCtx->c); /* Nothing should be attached when something is already attached */ - if( redisAsyncCtx->ev.data != NULL ) return REDIS_ERR; + if( redictAsyncCtx->ev.data != NULL ) return REDICT_ERR; - RedisRunLoop* redisRunLoop = (RedisRunLoop*) hi_calloc(1, sizeof(RedisRunLoop)); - if (redisRunLoop == NULL) - return REDIS_ERR; + RedictRunLoop* redictRunLoop = (RedictRunLoop*) hi_calloc(1, sizeof(RedictRunLoop)); + if (redictRunLoop == NULL) + return REDICT_ERR; - /* Setup redis stuff */ - redisRunLoop->context = redisAsyncCtx; + /* Setup redict stuff */ + redictRunLoop->context = redictAsyncCtx; - redisAsyncCtx->ev.addRead = redisMacOSAddRead; - redisAsyncCtx->ev.delRead = redisMacOSDelRead; - redisAsyncCtx->ev.addWrite = redisMacOSAddWrite; - redisAsyncCtx->ev.delWrite = redisMacOSDelWrite; - redisAsyncCtx->ev.cleanup = redisMacOSCleanup; - redisAsyncCtx->ev.data = redisRunLoop; + redictAsyncCtx->ev.addRead = redictMacOSAddRead; + redictAsyncCtx->ev.delRead = redictMacOSDelRead; + redictAsyncCtx->ev.addWrite = redictMacOSAddWrite; + redictAsyncCtx->ev.delWrite = redictMacOSDelWrite; + redictAsyncCtx->ev.cleanup = redictMacOSCleanup; + redictAsyncCtx->ev.data = redictRunLoop; /* Initialize and install read/write events */ - CFSocketContext socketCtx = { 0, redisAsyncCtx, NULL, NULL, NULL }; + CFSocketContext socketCtx = { 0, redictAsyncCtx, NULL, NULL, NULL }; - redisRunLoop->socketRef = CFSocketCreateWithNative(NULL, redisCtx->fd, + redictRunLoop->socketRef = CFSocketCreateWithNative(NULL, redictCtx->fd, kCFSocketReadCallBack | kCFSocketWriteCallBack, - redisMacOSAsyncCallback, + redictMacOSAsyncCallback, &socketCtx); - if( !redisRunLoop->socketRef ) return freeRedisRunLoop(redisRunLoop); + if( !redictRunLoop->socketRef ) return freeRedictRunLoop(redictRunLoop); - redisRunLoop->sourceRef = CFSocketCreateRunLoopSource(NULL, redisRunLoop->socketRef, 0); - if( !redisRunLoop->sourceRef ) return freeRedisRunLoop(redisRunLoop); + redictRunLoop->sourceRef = CFSocketCreateRunLoopSource(NULL, redictRunLoop->socketRef, 0); + if( !redictRunLoop->sourceRef ) return freeRedictRunLoop(redictRunLoop); - CFRunLoopAddSource(runLoop, redisRunLoop->sourceRef, kCFRunLoopDefaultMode); + CFRunLoopAddSource(runLoop, redictRunLoop->sourceRef, kCFRunLoopDefaultMode); - return REDIS_OK; + return REDICT_OK; } #endif diff --git a/adapters/poll.h b/adapters/poll.h index 23b3eba..adc0aab 100644 --- a/adapters/poll.h +++ b/adapters/poll.h @@ -9,43 +9,43 @@ * */ -#ifndef HIREDIS_POLL_H -#define HIREDIS_POLL_H +#ifndef HIREDICT_POLL_H +#define HIREDICT_POLL_H #include "../async.h" #include "../sockcompat.h" #include // for memset #include -/* Values to return from redisPollTick */ -#define REDIS_POLL_HANDLED_READ 1 -#define REDIS_POLL_HANDLED_WRITE 2 -#define REDIS_POLL_HANDLED_TIMEOUT 4 +/* Values to return from redictPollTick */ +#define REDICT_POLL_HANDLED_READ 1 +#define REDICT_POLL_HANDLED_WRITE 2 +#define REDICT_POLL_HANDLED_TIMEOUT 4 /* An adapter to allow manual polling of the async context by checking the state * of the underlying file descriptor. Useful in cases where there is no formal * IO event loop but regular ticking can be used, such as in game engines. */ -typedef struct redisPollEvents { - redisAsyncContext *context; - redisFD fd; +typedef struct redictPollEvents { + redictAsyncContext *context; + redictFD fd; char reading, writing; char in_tick; char deleted; double deadline; -} redisPollEvents; +} redictPollEvents; -static double redisPollTimevalToDouble(struct timeval *tv) { +static double redictPollTimevalToDouble(struct timeval *tv) { if (tv == NULL) return 0.0; return tv->tv_sec + tv->tv_usec / 1000000.00; } -static double redisPollGetNow(void) { +static double redictPollGetNow(void) { #ifndef _MSC_VER struct timeval tv; gettimeofday(&tv,NULL); - return redisPollTimevalToDouble(&tv); + return redictPollTimevalToDouble(&tv); #else FILETIME ft; ULARGE_INTEGER li; @@ -59,14 +59,14 @@ static double redisPollGetNow(void) { /* Poll for io, handling any pending callbacks. The timeout argument can be * positive to wait for a maximum given time for IO, zero to poll, or negative * to wait forever */ -static int redisPollTick(redisAsyncContext *ac, double timeout) { +static int redictPollTick(redictAsyncContext *ac, double timeout) { int reading, writing; struct pollfd pfd; int handled; int ns; int itimeout; - redisPollEvents *e = (redisPollEvents*)ac->ev.data; + redictPollEvents *e = (redictPollEvents*)ac->ev.data; if (!e) return 0; @@ -101,29 +101,29 @@ static int redisPollTick(redisAsyncContext *ac, double timeout) { e->in_tick = 1; if (ns) { if (reading && (pfd.revents & POLLIN)) { - redisAsyncHandleRead(ac); - handled |= REDIS_POLL_HANDLED_READ; + redictAsyncHandleRead(ac); + handled |= REDICT_POLL_HANDLED_READ; } /* on Windows, connection failure is indicated with the Exception fdset. * handle it the same as writable. */ if (writing && (pfd.revents & (POLLOUT | POLLERR))) { /* context Read callback may have caused context to be deleted, e.g. - by doing an redisAsyncDisconnect() */ + by doing an redictAsyncDisconnect() */ if (!e->deleted) { - redisAsyncHandleWrite(ac); - handled |= REDIS_POLL_HANDLED_WRITE; + redictAsyncHandleWrite(ac); + handled |= REDICT_POLL_HANDLED_WRITE; } } } /* perform timeouts */ if (!e->deleted && e->deadline != 0.0) { - double now = redisPollGetNow(); + double now = redictPollGetNow(); if (now >= e->deadline) { /* deadline has passed. disable timeout and perform callback */ e->deadline = 0.0; - redisAsyncHandleTimeout(ac); - handled |= REDIS_POLL_HANDLED_TIMEOUT; + redictAsyncHandleTimeout(ac); + handled |= REDICT_POLL_HANDLED_TIMEOUT; } } @@ -136,28 +136,28 @@ static int redisPollTick(redisAsyncContext *ac, double timeout) { return handled; } -static void redisPollAddRead(void *data) { - redisPollEvents *e = (redisPollEvents*)data; +static void redictPollAddRead(void *data) { + redictPollEvents *e = (redictPollEvents*)data; e->reading = 1; } -static void redisPollDelRead(void *data) { - redisPollEvents *e = (redisPollEvents*)data; +static void redictPollDelRead(void *data) { + redictPollEvents *e = (redictPollEvents*)data; e->reading = 0; } -static void redisPollAddWrite(void *data) { - redisPollEvents *e = (redisPollEvents*)data; +static void redictPollAddWrite(void *data) { + redictPollEvents *e = (redictPollEvents*)data; e->writing = 1; } -static void redisPollDelWrite(void *data) { - redisPollEvents *e = (redisPollEvents*)data; +static void redictPollDelWrite(void *data) { + redictPollEvents *e = (redictPollEvents*)data; e->writing = 0; } -static void redisPollCleanup(void *data) { - redisPollEvents *e = (redisPollEvents*)data; +static void redictPollCleanup(void *data) { + redictPollEvents *e = (redictPollEvents*)data; /* if we are currently processing a tick, postpone deletion */ if (e->in_tick) @@ -166,25 +166,25 @@ static void redisPollCleanup(void *data) { hi_free(e); } -static void redisPollScheduleTimer(void *data, struct timeval tv) +static void redictPollScheduleTimer(void *data, struct timeval tv) { - redisPollEvents *e = (redisPollEvents*)data; - double now = redisPollGetNow(); - e->deadline = now + redisPollTimevalToDouble(&tv); + redictPollEvents *e = (redictPollEvents*)data; + double now = redictPollGetNow(); + e->deadline = now + redictPollTimevalToDouble(&tv); } -static int redisPollAttach(redisAsyncContext *ac) { - redisContext *c = &(ac->c); - redisPollEvents *e; +static int redictPollAttach(redictAsyncContext *ac) { + redictContext *c = &(ac->c); + redictPollEvents *e; /* Nothing should be attached when something is already attached */ if (ac->ev.data != NULL) - return REDIS_ERR; + return REDICT_ERR; /* Create container for context and r/w events */ - e = (redisPollEvents*)hi_malloc(sizeof(*e)); + e = (redictPollEvents*)hi_malloc(sizeof(*e)); if (e == NULL) - return REDIS_ERR; + return REDICT_ERR; memset(e, 0, sizeof(*e)); e->context = ac; @@ -194,14 +194,14 @@ static int redisPollAttach(redisAsyncContext *ac) { e->deadline = 0.0; /* Register functions to start/stop listening for events */ - ac->ev.addRead = redisPollAddRead; - ac->ev.delRead = redisPollDelRead; - ac->ev.addWrite = redisPollAddWrite; - ac->ev.delWrite = redisPollDelWrite; - ac->ev.scheduleTimer = redisPollScheduleTimer; - ac->ev.cleanup = redisPollCleanup; + ac->ev.addRead = redictPollAddRead; + ac->ev.delRead = redictPollDelRead; + ac->ev.addWrite = redictPollAddWrite; + ac->ev.delWrite = redictPollDelWrite; + ac->ev.scheduleTimer = redictPollScheduleTimer; + ac->ev.cleanup = redictPollCleanup; ac->ev.data = e; - return REDIS_OK; + return REDICT_OK; } -#endif /* HIREDIS_POLL_H */ +#endif /* HIREDICT_POLL_H */ diff --git a/adapters/qt.h b/adapters/qt.h index a75cf31..de8d191 100644 --- a/adapters/qt.h +++ b/adapters/qt.h @@ -9,73 +9,73 @@ * */ -#ifndef __HIREDIS_QT_H__ -#define __HIREDIS_QT_H__ +#ifndef __HIREDICT_QT_H__ +#define __HIREDICT_QT_H__ #include #include "../async.h" -static void RedisQtAddRead(void *); -static void RedisQtDelRead(void *); -static void RedisQtAddWrite(void *); -static void RedisQtDelWrite(void *); -static void RedisQtCleanup(void *); +static void RedictQtAddRead(void *); +static void RedictQtDelRead(void *); +static void RedictQtAddWrite(void *); +static void RedictQtDelWrite(void *); +static void RedictQtCleanup(void *); -class RedisQtAdapter : public QObject { +class RedictQtAdapter : public QObject { Q_OBJECT friend - void RedisQtAddRead(void * adapter) { - RedisQtAdapter * a = static_cast(adapter); + void RedictQtAddRead(void * adapter) { + RedictQtAdapter * a = static_cast(adapter); a->addRead(); } friend - void RedisQtDelRead(void * adapter) { - RedisQtAdapter * a = static_cast(adapter); + void RedictQtDelRead(void * adapter) { + RedictQtAdapter * a = static_cast(adapter); a->delRead(); } friend - void RedisQtAddWrite(void * adapter) { - RedisQtAdapter * a = static_cast(adapter); + void RedictQtAddWrite(void * adapter) { + RedictQtAdapter * a = static_cast(adapter); a->addWrite(); } friend - void RedisQtDelWrite(void * adapter) { - RedisQtAdapter * a = static_cast(adapter); + void RedictQtDelWrite(void * adapter) { + RedictQtAdapter * a = static_cast(adapter); a->delWrite(); } friend - void RedisQtCleanup(void * adapter) { - RedisQtAdapter * a = static_cast(adapter); + void RedictQtCleanup(void * adapter) { + RedictQtAdapter * a = static_cast(adapter); a->cleanup(); } public: - RedisQtAdapter(QObject * parent = 0) + RedictQtAdapter(QObject * parent = 0) : QObject(parent), m_ctx(0), m_read(0), m_write(0) { } - ~RedisQtAdapter() { + ~RedictQtAdapter() { if (m_ctx != 0) { m_ctx->ev.data = NULL; } } - int setContext(redisAsyncContext * ac) { + int setContext(redictAsyncContext * ac) { if (ac->ev.data != NULL) { - return REDIS_ERR; + return REDICT_ERR; } m_ctx = ac; m_ctx->ev.data = this; - m_ctx->ev.addRead = RedisQtAddRead; - m_ctx->ev.delRead = RedisQtDelRead; - m_ctx->ev.addWrite = RedisQtAddWrite; - m_ctx->ev.delWrite = RedisQtDelWrite; - m_ctx->ev.cleanup = RedisQtCleanup; - return REDIS_OK; + m_ctx->ev.addRead = RedictQtAddRead; + m_ctx->ev.delRead = RedictQtDelRead; + m_ctx->ev.addWrite = RedictQtAddWrite; + m_ctx->ev.delWrite = RedictQtDelWrite; + m_ctx->ev.cleanup = RedictQtCleanup; + return REDICT_OK; } private: @@ -109,13 +109,13 @@ class RedisQtAdapter : public QObject { } private slots: - void read() { redisAsyncHandleRead(m_ctx); } - void write() { redisAsyncHandleWrite(m_ctx); } + void read() { redictAsyncHandleRead(m_ctx); } + void write() { redictAsyncHandleWrite(m_ctx); } private: - redisAsyncContext * m_ctx; + redictAsyncContext * m_ctx; QSocketNotifier * m_read; QSocketNotifier * m_write; }; -#endif /* !__HIREDIS_QT_H__ */ +#endif /* !__HIREDICT_QT_H__ */ diff --git a/adapters/redictmoduleapi.h b/adapters/redictmoduleapi.h index 1a134f5..0238ba1 100644 --- a/adapters/redictmoduleapi.h +++ b/adapters/redictmoduleapi.h @@ -9,8 +9,8 @@ * */ -#ifndef __HIREDIS_REDISMODULEAPI_H__ -#define __HIREDIS_REDISMODULEAPI_H__ +#ifndef __HIREDICT_REDICTMODULEAPI_H__ +#define __HIREDICT_REDICTMODULEAPI_H__ #include "redictmodule.h" @@ -19,120 +19,120 @@ #include -typedef struct redisModuleEvents { - redisAsyncContext *context; - RedisModuleCtx *module_ctx; +typedef struct redictModuleEvents { + redictAsyncContext *context; + RedictModuleCtx *module_ctx; int fd; int reading, writing; int timer_active; - RedisModuleTimerID timer_id; -} redisModuleEvents; + RedictModuleTimerID timer_id; +} redictModuleEvents; -static inline void redisModuleReadEvent(int fd, void *privdata, int mask) { +static inline void redictModuleReadEvent(int fd, void *privdata, int mask) { (void) fd; (void) mask; - redisModuleEvents *e = (redisModuleEvents*)privdata; - redisAsyncHandleRead(e->context); + redictModuleEvents *e = (redictModuleEvents*)privdata; + redictAsyncHandleRead(e->context); } -static inline void redisModuleWriteEvent(int fd, void *privdata, int mask) { +static inline void redictModuleWriteEvent(int fd, void *privdata, int mask) { (void) fd; (void) mask; - redisModuleEvents *e = (redisModuleEvents*)privdata; - redisAsyncHandleWrite(e->context); + redictModuleEvents *e = (redictModuleEvents*)privdata; + redictAsyncHandleWrite(e->context); } -static inline void redisModuleAddRead(void *privdata) { - redisModuleEvents *e = (redisModuleEvents*)privdata; +static inline void redictModuleAddRead(void *privdata) { + redictModuleEvents *e = (redictModuleEvents*)privdata; if (!e->reading) { e->reading = 1; - RedisModule_EventLoopAdd(e->fd, REDISMODULE_EVENTLOOP_READABLE, redisModuleReadEvent, e); + RedictModule_EventLoopAdd(e->fd, REDICTMODULE_EVENTLOOP_READABLE, redictModuleReadEvent, e); } } -static inline void redisModuleDelRead(void *privdata) { - redisModuleEvents *e = (redisModuleEvents*)privdata; +static inline void redictModuleDelRead(void *privdata) { + redictModuleEvents *e = (redictModuleEvents*)privdata; if (e->reading) { e->reading = 0; - RedisModule_EventLoopDel(e->fd, REDISMODULE_EVENTLOOP_READABLE); + RedictModule_EventLoopDel(e->fd, REDICTMODULE_EVENTLOOP_READABLE); } } -static inline void redisModuleAddWrite(void *privdata) { - redisModuleEvents *e = (redisModuleEvents*)privdata; +static inline void redictModuleAddWrite(void *privdata) { + redictModuleEvents *e = (redictModuleEvents*)privdata; if (!e->writing) { e->writing = 1; - RedisModule_EventLoopAdd(e->fd, REDISMODULE_EVENTLOOP_WRITABLE, redisModuleWriteEvent, e); + RedictModule_EventLoopAdd(e->fd, REDICTMODULE_EVENTLOOP_WRITABLE, redictModuleWriteEvent, e); } } -static inline void redisModuleDelWrite(void *privdata) { - redisModuleEvents *e = (redisModuleEvents*)privdata; +static inline void redictModuleDelWrite(void *privdata) { + redictModuleEvents *e = (redictModuleEvents*)privdata; if (e->writing) { e->writing = 0; - RedisModule_EventLoopDel(e->fd, REDISMODULE_EVENTLOOP_WRITABLE); + RedictModule_EventLoopDel(e->fd, REDICTMODULE_EVENTLOOP_WRITABLE); } } -static inline void redisModuleStopTimer(void *privdata) { - redisModuleEvents *e = (redisModuleEvents*)privdata; +static inline void redictModuleStopTimer(void *privdata) { + redictModuleEvents *e = (redictModuleEvents*)privdata; if (e->timer_active) { - RedisModule_StopTimer(e->module_ctx, e->timer_id, NULL); + RedictModule_StopTimer(e->module_ctx, e->timer_id, NULL); } e->timer_active = 0; } -static inline void redisModuleCleanup(void *privdata) { - redisModuleEvents *e = (redisModuleEvents*)privdata; - redisModuleDelRead(privdata); - redisModuleDelWrite(privdata); - redisModuleStopTimer(privdata); +static inline void redictModuleCleanup(void *privdata) { + redictModuleEvents *e = (redictModuleEvents*)privdata; + redictModuleDelRead(privdata); + redictModuleDelWrite(privdata); + redictModuleStopTimer(privdata); hi_free(e); } -static inline void redisModuleTimeout(RedisModuleCtx *ctx, void *privdata) { +static inline void redictModuleTimeout(RedictModuleCtx *ctx, void *privdata) { (void) ctx; - redisModuleEvents *e = (redisModuleEvents*)privdata; + redictModuleEvents *e = (redictModuleEvents*)privdata; e->timer_active = 0; - redisAsyncHandleTimeout(e->context); + redictAsyncHandleTimeout(e->context); } -static inline void redisModuleSetTimeout(void *privdata, struct timeval tv) { - redisModuleEvents* e = (redisModuleEvents*)privdata; +static inline void redictModuleSetTimeout(void *privdata, struct timeval tv) { + redictModuleEvents* e = (redictModuleEvents*)privdata; - redisModuleStopTimer(privdata); + redictModuleStopTimer(privdata); mstime_t millis = tv.tv_sec * 1000 + tv.tv_usec / 1000.0; - e->timer_id = RedisModule_CreateTimer(e->module_ctx, millis, redisModuleTimeout, e); + e->timer_id = RedictModule_CreateTimer(e->module_ctx, millis, redictModuleTimeout, e); e->timer_active = 1; } -/* Check if Redis version is compatible with the adapter. */ -static inline int redisModuleCompatibilityCheck(void) { - if (!RedisModule_EventLoopAdd || - !RedisModule_EventLoopDel || - !RedisModule_CreateTimer || - !RedisModule_StopTimer) { - return REDIS_ERR; +/* Check if Redict is compatible with the adapter. */ +static inline int redictModuleCompatibilityCheck(void) { + if (!RedictModule_EventLoopAdd || + !RedictModule_EventLoopDel || + !RedictModule_CreateTimer || + !RedictModule_StopTimer) { + return REDICT_ERR; } - return REDIS_OK; + return REDICT_OK; } -static inline int redisModuleAttach(redisAsyncContext *ac, RedisModuleCtx *module_ctx) { - redisContext *c = &(ac->c); - redisModuleEvents *e; +static inline int redictModuleAttach(redictAsyncContext *ac, RedictModuleCtx *module_ctx) { + redictContext *c = &(ac->c); + redictModuleEvents *e; /* Nothing should be attached when something is already attached */ if (ac->ev.data != NULL) - return REDIS_ERR; + return REDICT_ERR; /* Create container for context and r/w events */ - e = (redisModuleEvents*)hi_malloc(sizeof(*e)); + e = (redictModuleEvents*)hi_malloc(sizeof(*e)); if (e == NULL) - return REDIS_ERR; + return REDICT_ERR; e->context = ac; e->module_ctx = module_ctx; @@ -141,15 +141,15 @@ static inline int redisModuleAttach(redisAsyncContext *ac, RedisModuleCtx *modul e->timer_active = 0; /* Register functions to start/stop listening for events */ - ac->ev.addRead = redisModuleAddRead; - ac->ev.delRead = redisModuleDelRead; - ac->ev.addWrite = redisModuleAddWrite; - ac->ev.delWrite = redisModuleDelWrite; - ac->ev.cleanup = redisModuleCleanup; - ac->ev.scheduleTimer = redisModuleSetTimeout; + ac->ev.addRead = redictModuleAddRead; + ac->ev.delRead = redictModuleDelRead; + ac->ev.addWrite = redictModuleAddWrite; + ac->ev.delWrite = redictModuleDelWrite; + ac->ev.cleanup = redictModuleCleanup; + ac->ev.scheduleTimer = redictModuleSetTimeout; ac->ev.data = e; - return REDIS_OK; + return REDICT_OK; } #endif -- cgit v1.2.3