From bb3475e8eb379ee18f3d8f37caa8040b852a6213 Mon Sep 17 00:00:00 2001
From: "Anna (navi) Figueiredo Gomes" <navi@vlhl.dev>
Date: Sat, 23 Mar 2024 01:21:46 +0100
Subject: all: rename redis -> redict symbols and comments

Signed-off-by: Anna (navi) Figueiredo Gomes <navi@vlhl.dev>
---
 adapters/libhv.h | 80 ++++++++++++++++++++++++++++----------------------------
 1 file changed, 40 insertions(+), 40 deletions(-)

(limited to 'adapters/libhv.h')

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 <hv/hloop.h>
 #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
-- 
cgit v1.2.3