summaryrefslogtreecommitdiff
path: root/examples
diff options
context:
space:
mode:
Diffstat (limited to 'examples')
-rw-r--r--examples/example-ae.c26
-rw-r--r--examples/example-glib.c28
-rw-r--r--examples/example-ivykis.c26
-rw-r--r--examples/example-libev.c26
-rw-r--r--examples/example-libevent-ssl.c40
-rw-r--r--examples/example-libevent.c30
-rw-r--r--examples/example-libhv.c36
-rw-r--r--examples/example-libsdevent.c36
-rw-r--r--examples/example-libuv.c34
-rw-r--r--examples/example-macosx.c26
-rw-r--r--examples/example-poll.c28
-rw-r--r--examples/example-push.c56
-rw-r--r--examples/example-qt.cpp12
-rw-r--r--examples/example-qt.h12
-rw-r--r--examples/example-redictmoduleapi.c58
-rw-r--r--examples/example-ssl.c52
-rw-r--r--examples/example.c44
17 files changed, 284 insertions, 286 deletions
diff --git a/examples/example-ae.c b/examples/example-ae.c
index 983ca9c..170d7b2 100644
--- a/examples/example-ae.c
+++ b/examples/example-ae.c
@@ -16,17 +16,17 @@
/* Put event loop in the global scope, so it can be explicitly stopped */
static aeEventLoop *loop;
-void getCallback(redisAsyncContext *c, void *r, void *privdata) {
- redisReply *reply = r;
+void getCallback(redictAsyncContext *c, void *r, void *privdata) {
+ redictReply *reply = r;
if (reply == NULL) return;
printf("argv[%s]: %s\n", (char*)privdata, reply->str);
/* Disconnect after receiving the reply to GET */
- redisAsyncDisconnect(c);
+ redictAsyncDisconnect(c);
}
-void connectCallback(const redisAsyncContext *c, int status) {
- if (status != REDIS_OK) {
+void connectCallback(const redictAsyncContext *c, int status) {
+ if (status != REDICT_OK) {
printf("Error: %s\n", c->errstr);
aeStop(loop);
return;
@@ -35,8 +35,8 @@ void connectCallback(const redisAsyncContext *c, int status) {
printf("Connected...\n");
}
-void disconnectCallback(const redisAsyncContext *c, int status) {
- if (status != REDIS_OK) {
+void disconnectCallback(const redictAsyncContext *c, int status) {
+ if (status != REDICT_OK) {
printf("Error: %s\n", c->errstr);
aeStop(loop);
return;
@@ -49,7 +49,7 @@ void disconnectCallback(const redisAsyncContext *c, int status) {
int main (int argc, char **argv) {
signal(SIGPIPE, SIG_IGN);
- redisAsyncContext *c = redisAsyncConnect("127.0.0.1", 6379);
+ redictAsyncContext *c = redictAsyncConnect("127.0.0.1", 6379);
if (c->err) {
/* Let *c leak for now... */
printf("Error: %s\n", c->errstr);
@@ -57,11 +57,11 @@ int main (int argc, char **argv) {
}
loop = aeCreateEventLoop(64);
- redisAeAttach(loop, c);
- redisAsyncSetConnectCallback(c,connectCallback);
- redisAsyncSetDisconnectCallback(c,disconnectCallback);
- redisAsyncCommand(c, NULL, NULL, "SET key %b", argv[argc-1], strlen(argv[argc-1]));
- redisAsyncCommand(c, getCallback, (char*)"end-1", "GET key");
+ redictAeAttach(loop, c);
+ redictAsyncSetConnectCallback(c,connectCallback);
+ redictAsyncSetDisconnectCallback(c,disconnectCallback);
+ redictAsyncCommand(c, NULL, NULL, "SET key %b", argv[argc-1], strlen(argv[argc-1]));
+ redictAsyncCommand(c, getCallback, (char*)"end-1", "GET key");
aeMain(loop);
return 0;
}
diff --git a/examples/example-glib.c b/examples/example-glib.c
index 46aa550..97cf279 100644
--- a/examples/example-glib.c
+++ b/examples/example-glib.c
@@ -13,10 +13,10 @@
static GMainLoop *mainloop;
static void
-connect_cb (const redisAsyncContext *ac G_GNUC_UNUSED,
+connect_cb (const redictAsyncContext *ac G_GNUC_UNUSED,
int status)
{
- if (status != REDIS_OK) {
+ if (status != REDICT_OK) {
g_printerr("Failed to connect: %s\n", ac->errstr);
g_main_loop_quit(mainloop);
} else {
@@ -25,10 +25,10 @@ connect_cb (const redisAsyncContext *ac G_GNUC_UNUSED,
}
static void
-disconnect_cb (const redisAsyncContext *ac G_GNUC_UNUSED,
+disconnect_cb (const redictAsyncContext *ac G_GNUC_UNUSED,
int status)
{
- if (status != REDIS_OK) {
+ if (status != REDICT_OK) {
g_error("Failed to disconnect: %s", ac->errstr);
} else {
g_printerr("Disconnected...\n");
@@ -37,41 +37,41 @@ disconnect_cb (const redisAsyncContext *ac G_GNUC_UNUSED,
}
static void
-command_cb(redisAsyncContext *ac,
+command_cb(redictAsyncContext *ac,
gpointer r,
gpointer user_data G_GNUC_UNUSED)
{
- redisReply *reply = r;
+ redictReply *reply = r;
if (reply) {
g_print("REPLY: %s\n", reply->str);
}
- redisAsyncDisconnect(ac);
+ redictAsyncDisconnect(ac);
}
gint
main (gint argc G_GNUC_UNUSED,
gchar *argv[] G_GNUC_UNUSED)
{
- redisAsyncContext *ac;
+ redictAsyncContext *ac;
GMainContext *context = NULL;
GSource *source;
- ac = redisAsyncConnect("127.0.0.1", 6379);
+ ac = redictAsyncConnect("127.0.0.1", 6379);
if (ac->err) {
g_printerr("%s\n", ac->errstr);
exit(EXIT_FAILURE);
}
- source = redis_source_new(ac);
+ source = redict_source_new(ac);
mainloop = g_main_loop_new(context, FALSE);
g_source_attach(source, context);
- redisAsyncSetConnectCallback(ac, connect_cb);
- redisAsyncSetDisconnectCallback(ac, disconnect_cb);
- redisAsyncCommand(ac, command_cb, NULL, "SET key 1234");
- redisAsyncCommand(ac, command_cb, NULL, "GET key");
+ redictAsyncSetConnectCallback(ac, connect_cb);
+ redictAsyncSetDisconnectCallback(ac, disconnect_cb);
+ redictAsyncCommand(ac, command_cb, NULL, "SET key 1234");
+ redictAsyncCommand(ac, command_cb, NULL, "GET key");
g_main_loop_run(mainloop);
diff --git a/examples/example-ivykis.c b/examples/example-ivykis.c
index 989fa12..8aa2570 100644
--- a/examples/example-ivykis.c
+++ b/examples/example-ivykis.c
@@ -13,25 +13,25 @@
#include <async.h>
#include <adapters/ivykis.h>
-void getCallback(redisAsyncContext *c, void *r, void *privdata) {
- redisReply *reply = r;
+void getCallback(redictAsyncContext *c, void *r, void *privdata) {
+ redictReply *reply = r;
if (reply == NULL) return;
printf("argv[%s]: %s\n", (char*)privdata, reply->str);
/* Disconnect after receiving the reply to GET */
- redisAsyncDisconnect(c);
+ redictAsyncDisconnect(c);
}
-void connectCallback(const redisAsyncContext *c, int status) {
- if (status != REDIS_OK) {
+void connectCallback(const redictAsyncContext *c, int status) {
+ if (status != REDICT_OK) {
printf("Error: %s\n", c->errstr);
return;
}
printf("Connected...\n");
}
-void disconnectCallback(const redisAsyncContext *c, int status) {
- if (status != REDIS_OK) {
+void disconnectCallback(const redictAsyncContext *c, int status) {
+ if (status != REDICT_OK) {
printf("Error: %s\n", c->errstr);
return;
}
@@ -45,18 +45,18 @@ int main (int argc, char **argv) {
iv_init();
- redisAsyncContext *c = redisAsyncConnect("127.0.0.1", 6379);
+ redictAsyncContext *c = redictAsyncConnect("127.0.0.1", 6379);
if (c->err) {
/* Let *c leak for now... */
printf("Error: %s\n", c->errstr);
return 1;
}
- redisIvykisAttach(c);
- redisAsyncSetConnectCallback(c,connectCallback);
- redisAsyncSetDisconnectCallback(c,disconnectCallback);
- redisAsyncCommand(c, NULL, NULL, "SET key %b", argv[argc-1], strlen(argv[argc-1]));
- redisAsyncCommand(c, getCallback, (char*)"end-1", "GET key");
+ redictIvykisAttach(c);
+ redictAsyncSetConnectCallback(c,connectCallback);
+ redictAsyncSetDisconnectCallback(c,disconnectCallback);
+ redictAsyncCommand(c, NULL, NULL, "SET key %b", argv[argc-1], strlen(argv[argc-1]));
+ redictAsyncCommand(c, getCallback, (char*)"end-1", "GET key");
iv_main();
diff --git a/examples/example-libev.c b/examples/example-libev.c
index ade7ed1..b180674 100644
--- a/examples/example-libev.c
+++ b/examples/example-libev.c
@@ -13,25 +13,25 @@
#include <async.h>
#include <adapters/libev.h>
-void getCallback(redisAsyncContext *c, void *r, void *privdata) {
- redisReply *reply = r;
+void getCallback(redictAsyncContext *c, void *r, void *privdata) {
+ redictReply *reply = r;
if (reply == NULL) return;
printf("argv[%s]: %s\n", (char*)privdata, reply->str);
/* Disconnect after receiving the reply to GET */
- redisAsyncDisconnect(c);
+ redictAsyncDisconnect(c);
}
-void connectCallback(const redisAsyncContext *c, int status) {
- if (status != REDIS_OK) {
+void connectCallback(const redictAsyncContext *c, int status) {
+ if (status != REDICT_OK) {
printf("Error: %s\n", c->errstr);
return;
}
printf("Connected...\n");
}
-void disconnectCallback(const redisAsyncContext *c, int status) {
- if (status != REDIS_OK) {
+void disconnectCallback(const redictAsyncContext *c, int status) {
+ if (status != REDICT_OK) {
printf("Error: %s\n", c->errstr);
return;
}
@@ -43,18 +43,18 @@ int main (int argc, char **argv) {
signal(SIGPIPE, SIG_IGN);
#endif
- redisAsyncContext *c = redisAsyncConnect("127.0.0.1", 6379);
+ redictAsyncContext *c = redictAsyncConnect("127.0.0.1", 6379);
if (c->err) {
/* Let *c leak for now... */
printf("Error: %s\n", c->errstr);
return 1;
}
- redisLibevAttach(EV_DEFAULT_ c);
- redisAsyncSetConnectCallback(c,connectCallback);
- redisAsyncSetDisconnectCallback(c,disconnectCallback);
- redisAsyncCommand(c, NULL, NULL, "SET key %b", argv[argc-1], strlen(argv[argc-1]));
- redisAsyncCommand(c, getCallback, (char*)"end-1", "GET key");
+ redictLibevAttach(EV_DEFAULT_ c);
+ redictAsyncSetConnectCallback(c,connectCallback);
+ redictAsyncSetDisconnectCallback(c,disconnectCallback);
+ redictAsyncCommand(c, NULL, NULL, "SET key %b", argv[argc-1], strlen(argv[argc-1]));
+ redictAsyncCommand(c, getCallback, (char*)"end-1", "GET key");
ev_loop(EV_DEFAULT_ 0);
return 0;
}
diff --git a/examples/example-libevent-ssl.c b/examples/example-libevent-ssl.c
index a142b22..b15e7e2 100644
--- a/examples/example-libevent-ssl.c
+++ b/examples/example-libevent-ssl.c
@@ -10,29 +10,29 @@
#include <signal.h>
#include <hiredict.h>
-#include <hiredis_ssl.h>
+#include <hiredict_ssl.h>
#include <async.h>
#include <adapters/libevent.h>
-void getCallback(redisAsyncContext *c, void *r, void *privdata) {
- redisReply *reply = r;
+void getCallback(redictAsyncContext *c, void *r, void *privdata) {
+ redictReply *reply = r;
if (reply == NULL) return;
printf("argv[%s]: %s\n", (char*)privdata, reply->str);
/* Disconnect after receiving the reply to GET */
- redisAsyncDisconnect(c);
+ redictAsyncDisconnect(c);
}
-void connectCallback(const redisAsyncContext *c, int status) {
- if (status != REDIS_OK) {
+void connectCallback(const redictAsyncContext *c, int status) {
+ if (status != REDICT_OK) {
printf("Error: %s\n", c->errstr);
return;
}
printf("Connected...\n");
}
-void disconnectCallback(const redisAsyncContext *c, int status) {
- if (status != REDIS_OK) {
+void disconnectCallback(const redictAsyncContext *c, int status) {
+ if (status != REDICT_OK) {
printf("Error: %s\n", c->errstr);
return;
}
@@ -61,36 +61,36 @@ int main (int argc, char **argv) {
const char *certKey = argv[5];
const char *caCert = argc > 5 ? argv[6] : NULL;
- redisSSLContext *ssl;
- redisSSLContextError ssl_error = REDIS_SSL_CTX_NONE;
+ redictSSLContext *ssl;
+ redictSSLContextError ssl_error = REDICT_SSL_CTX_NONE;
- redisInitOpenSSL();
+ redictInitOpenSSL();
- ssl = redisCreateSSLContext(caCert, NULL,
+ ssl = redictCreateSSLContext(caCert, NULL,
cert, certKey, NULL, &ssl_error);
if (!ssl) {
printf("Error: %s\n", redictSSLContextGetError(ssl_error));
return 1;
}
- redisAsyncContext *c = redisAsyncConnect(hostname, port);
+ redictAsyncContext *c = redictAsyncConnect(hostname, port);
if (c->err) {
/* Let *c leak for now... */
printf("Error: %s\n", c->errstr);
return 1;
}
- if (redisInitiateSSLWithContext(&c->c, ssl) != REDIS_OK) {
+ if (redictInitiateSSLWithContext(&c->c, ssl) != REDICT_OK) {
printf("SSL Error!\n");
exit(1);
}
- redisLibeventAttach(c,base);
- redisAsyncSetConnectCallback(c,connectCallback);
- redisAsyncSetDisconnectCallback(c,disconnectCallback);
- redisAsyncCommand(c, NULL, NULL, "SET key %b", value, nvalue);
- redisAsyncCommand(c, getCallback, (char*)"end-1", "GET key");
+ redictLibeventAttach(c,base);
+ redictAsyncSetConnectCallback(c,connectCallback);
+ redictAsyncSetDisconnectCallback(c,disconnectCallback);
+ redictAsyncCommand(c, NULL, NULL, "SET key %b", value, nvalue);
+ redictAsyncCommand(c, getCallback, (char*)"end-1", "GET key");
event_base_dispatch(base);
- redisFreeSSLContext(ssl);
+ redictFreeSSLContext(ssl);
return 0;
}
diff --git a/examples/example-libevent.c b/examples/example-libevent.c
index 747f343..efc21d6 100644
--- a/examples/example-libevent.c
+++ b/examples/example-libevent.c
@@ -13,8 +13,8 @@
#include <async.h>
#include <adapters/libevent.h>
-void getCallback(redisAsyncContext *c, void *r, void *privdata) {
- redisReply *reply = r;
+void getCallback(redictAsyncContext *c, void *r, void *privdata) {
+ redictReply *reply = r;
if (reply == NULL) {
if (c->errstr) {
printf("errstr: %s\n", c->errstr);
@@ -24,19 +24,19 @@ void getCallback(redisAsyncContext *c, void *r, void *privdata) {
printf("argv[%s]: %s\n", (char*)privdata, reply->str);
/* Disconnect after receiving the reply to GET */
- redisAsyncDisconnect(c);
+ redictAsyncDisconnect(c);
}
-void connectCallback(const redisAsyncContext *c, int status) {
- if (status != REDIS_OK) {
+void connectCallback(const redictAsyncContext *c, int status) {
+ if (status != REDICT_OK) {
printf("Error: %s\n", c->errstr);
return;
}
printf("Connected...\n");
}
-void disconnectCallback(const redisAsyncContext *c, int status) {
- if (status != REDIS_OK) {
+void disconnectCallback(const redictAsyncContext *c, int status) {
+ if (status != REDICT_OK) {
printf("Error: %s\n", c->errstr);
return;
}
@@ -49,25 +49,25 @@ int main (int argc, char **argv) {
#endif
struct event_base *base = event_base_new();
- redisOptions options = {0};
- REDIS_OPTIONS_SET_TCP(&options, "127.0.0.1", 6379);
+ redictOptions options = {0};
+ REDICT_OPTIONS_SET_TCP(&options, "127.0.0.1", 6379);
struct timeval tv = {0};
tv.tv_sec = 1;
options.connect_timeout = &tv;
- redisAsyncContext *c = redisAsyncConnectWithOptions(&options);
+ redictAsyncContext *c = redictAsyncConnectWithOptions(&options);
if (c->err) {
/* Let *c leak for now... */
printf("Error: %s\n", c->errstr);
return 1;
}
- redisLibeventAttach(c,base);
- redisAsyncSetConnectCallback(c,connectCallback);
- redisAsyncSetDisconnectCallback(c,disconnectCallback);
- redisAsyncCommand(c, NULL, NULL, "SET key %b", argv[argc-1], strlen(argv[argc-1]));
- redisAsyncCommand(c, getCallback, (char*)"end-1", "GET key");
+ redictLibeventAttach(c,base);
+ redictAsyncSetConnectCallback(c,connectCallback);
+ redictAsyncSetDisconnectCallback(c,disconnectCallback);
+ redictAsyncCommand(c, NULL, NULL, "SET key %b", argv[argc-1], strlen(argv[argc-1]));
+ redictAsyncCommand(c, getCallback, (char*)"end-1", "GET key");
event_base_dispatch(base);
return 0;
}
diff --git a/examples/example-libhv.c b/examples/example-libhv.c
index 4878039..ca053c0 100644
--- a/examples/example-libhv.c
+++ b/examples/example-libhv.c
@@ -13,37 +13,37 @@
#include <async.h>
#include <adapters/libhv.h>
-void getCallback(redisAsyncContext *c, void *r, void *privdata) {
- redisReply *reply = r;
+void getCallback(redictAsyncContext *c, void *r, void *privdata) {
+ redictReply *reply = r;
if (reply == NULL) return;
printf("argv[%s]: %s\n", (char*)privdata, reply->str);
/* Disconnect after receiving the reply to GET */
- redisAsyncDisconnect(c);
+ redictAsyncDisconnect(c);
}
-void debugCallback(redisAsyncContext *c, void *r, void *privdata) {
+void debugCallback(redictAsyncContext *c, void *r, void *privdata) {
(void)privdata;
- redisReply *reply = r;
+ redictReply *reply = r;
if (reply == NULL) {
printf("`DEBUG SLEEP` error: %s\n", c->errstr ? c->errstr : "unknown error");
return;
}
- redisAsyncDisconnect(c);
+ redictAsyncDisconnect(c);
}
-void connectCallback(const redisAsyncContext *c, int status) {
- if (status != REDIS_OK) {
+void connectCallback(const redictAsyncContext *c, int status) {
+ if (status != REDICT_OK) {
printf("Error: %s\n", c->errstr);
return;
}
printf("Connected...\n");
}
-void disconnectCallback(const redisAsyncContext *c, int status) {
- if (status != REDIS_OK) {
+void disconnectCallback(const redictAsyncContext *c, int status) {
+ if (status != REDICT_OK) {
printf("Error: %s\n", c->errstr);
return;
}
@@ -55,7 +55,7 @@ int main (int argc, char **argv) {
signal(SIGPIPE, SIG_IGN);
#endif
- redisAsyncContext *c = redisAsyncConnect("127.0.0.1", 6379);
+ redictAsyncContext *c = redictAsyncConnect("127.0.0.1", 6379);
if (c->err) {
/* Let *c leak for now... */
printf("Error: %s\n", c->errstr);
@@ -63,13 +63,13 @@ int main (int argc, char **argv) {
}
hloop_t* loop = hloop_new(HLOOP_FLAG_QUIT_WHEN_NO_ACTIVE_EVENTS);
- redisLibhvAttach(c, loop);
- redisAsyncSetTimeout(c, (struct timeval){.tv_sec = 0, .tv_usec = 500000});
- redisAsyncSetConnectCallback(c,connectCallback);
- redisAsyncSetDisconnectCallback(c,disconnectCallback);
- redisAsyncCommand(c, NULL, NULL, "SET key %b", argv[argc-1], strlen(argv[argc-1]));
- redisAsyncCommand(c, getCallback, (char*)"end-1", "GET key");
- redisAsyncCommand(c, debugCallback, NULL, "DEBUG SLEEP %d", 1);
+ redictLibhvAttach(c, loop);
+ redictAsyncSetTimeout(c, (struct timeval){.tv_sec = 0, .tv_usec = 500000});
+ redictAsyncSetConnectCallback(c,connectCallback);
+ redictAsyncSetDisconnectCallback(c,disconnectCallback);
+ redictAsyncCommand(c, NULL, NULL, "SET key %b", argv[argc-1], strlen(argv[argc-1]));
+ redictAsyncCommand(c, getCallback, (char*)"end-1", "GET key");
+ redictAsyncCommand(c, debugCallback, NULL, "DEBUG SLEEP %d", 1);
hloop_run(loop);
hloop_free(&loop);
return 0;
diff --git a/examples/example-libsdevent.c b/examples/example-libsdevent.c
index 8599b76..6e544fc 100644
--- a/examples/example-libsdevent.c
+++ b/examples/example-libsdevent.c
@@ -13,20 +13,20 @@
#include <async.h>
#include <adapters/libsdevent.h>
-void debugCallback(redisAsyncContext *c, void *r, void *privdata) {
+void debugCallback(redictAsyncContext *c, void *r, void *privdata) {
(void)privdata;
- redisReply *reply = r;
+ redictReply *reply = r;
if (reply == NULL) {
/* The DEBUG SLEEP command will almost always fail, because we have set a 1 second timeout */
printf("`DEBUG SLEEP` error: %s\n", c->errstr ? c->errstr : "unknown error");
return;
}
/* Disconnect after receiving the reply of DEBUG SLEEP (which will not)*/
- redisAsyncDisconnect(c);
+ redictAsyncDisconnect(c);
}
-void getCallback(redisAsyncContext *c, void *r, void *privdata) {
- redisReply *reply = r;
+void getCallback(redictAsyncContext *c, void *r, void *privdata) {
+ redictReply *reply = r;
if (reply == NULL) {
printf("`GET key` error: %s\n", c->errstr ? c->errstr : "unknown error");
return;
@@ -34,19 +34,19 @@ void getCallback(redisAsyncContext *c, void *r, void *privdata) {
printf("`GET key` result: argv[%s]: %s\n", (char*)privdata, reply->str);
/* start another request that demonstrate timeout */
- redisAsyncCommand(c, debugCallback, NULL, "DEBUG SLEEP %f", 1.5);
+ redictAsyncCommand(c, debugCallback, NULL, "DEBUG SLEEP %f", 1.5);
}
-void connectCallback(const redisAsyncContext *c, int status) {
- if (status != REDIS_OK) {
+void connectCallback(const redictAsyncContext *c, int status) {
+ if (status != REDICT_OK) {
printf("connect error: %s\n", c->errstr);
return;
}
printf("Connected...\n");
}
-void disconnectCallback(const redisAsyncContext *c, int status) {
- if (status != REDIS_OK) {
+void disconnectCallback(const redictAsyncContext *c, int status) {
+ if (status != REDICT_OK) {
printf("disconnect because of error: %s\n", c->errstr);
return;
}
@@ -59,17 +59,17 @@ int main (int argc, char **argv) {
struct sd_event *event;
sd_event_default(&event);
- redisAsyncContext *c = redisAsyncConnect("127.0.0.1", 6379);
+ redictAsyncContext *c = redictAsyncConnect("127.0.0.1", 6379);
if (c->err) {
printf("Error: %s\n", c->errstr);
- redisAsyncFree(c);
+ redictAsyncFree(c);
return 1;
}
- redisLibsdeventAttach(c,event);
- redisAsyncSetConnectCallback(c,connectCallback);
- redisAsyncSetDisconnectCallback(c,disconnectCallback);
- redisAsyncSetTimeout(c, (struct timeval){ .tv_sec = 1, .tv_usec = 0});
+ redictLibsdeventAttach(c,event);
+ redictAsyncSetConnectCallback(c,connectCallback);
+ redictAsyncSetDisconnectCallback(c,disconnectCallback);
+ redictAsyncSetTimeout(c, (struct timeval){ .tv_sec = 1, .tv_usec = 0});
/*
In this demo, we first `set key`, then `get key` to demonstrate the basic usage of libsdevent adapter.
@@ -78,8 +78,8 @@ int main (int argc, char **argv) {
timeout error, which is shown in the `debugCallback`.
*/
- redisAsyncCommand(c, NULL, NULL, "SET key %b", argv[argc-1], strlen(argv[argc-1]));
- redisAsyncCommand(c, getCallback, (char*)"end-1", "GET key");
+ redictAsyncCommand(c, NULL, NULL, "SET key %b", argv[argc-1], strlen(argv[argc-1]));
+ redictAsyncCommand(c, getCallback, (char*)"end-1", "GET key");
/* sd-event does not quit when there are no handlers registered. Manually exit after 1.5 seconds */
sd_event_source *s;
diff --git a/examples/example-libuv.c b/examples/example-libuv.c
index 7d0e624..c8992bc 100644
--- a/examples/example-libuv.c
+++ b/examples/example-libuv.c
@@ -13,20 +13,20 @@
#include <async.h>
#include <adapters/libuv.h>
-void debugCallback(redisAsyncContext *c, void *r, void *privdata) {
+void debugCallback(redictAsyncContext *c, void *r, void *privdata) {
(void)privdata; //unused
- redisReply *reply = r;
+ redictReply *reply = r;
if (reply == NULL) {
/* The DEBUG SLEEP command will almost always fail, because we have set a 1 second timeout */
printf("`DEBUG SLEEP` error: %s\n", c->errstr ? c->errstr : "unknown error");
return;
}
/* Disconnect after receiving the reply of DEBUG SLEEP (which will not)*/
- redisAsyncDisconnect(c);
+ redictAsyncDisconnect(c);
}
-void getCallback(redisAsyncContext *c, void *r, void *privdata) {
- redisReply *reply = r;
+void getCallback(redictAsyncContext *c, void *r, void *privdata) {
+ redictReply *reply = r;
if (reply == NULL) {
printf("`GET key` error: %s\n", c->errstr ? c->errstr : "unknown error");
return;
@@ -34,19 +34,19 @@ void getCallback(redisAsyncContext *c, void *r, void *privdata) {
printf("`GET key` result: argv[%s]: %s\n", (char*)privdata, reply->str);
/* start another request that demonstrate timeout */
- redisAsyncCommand(c, debugCallback, NULL, "DEBUG SLEEP %f", 1.5);
+ redictAsyncCommand(c, debugCallback, NULL, "DEBUG SLEEP %f", 1.5);
}
-void connectCallback(const redisAsyncContext *c, int status) {
- if (status != REDIS_OK) {
+void connectCallback(const redictAsyncContext *c, int status) {
+ if (status != REDICT_OK) {
printf("connect error: %s\n", c->errstr);
return;
}
printf("Connected...\n");
}
-void disconnectCallback(const redisAsyncContext *c, int status) {
- if (status != REDIS_OK) {
+void disconnectCallback(const redictAsyncContext *c, int status) {
+ if (status != REDICT_OK) {
printf("disconnect because of error: %s\n", c->errstr);
return;
}
@@ -60,17 +60,17 @@ int main (int argc, char **argv) {
uv_loop_t* loop = uv_default_loop();
- redisAsyncContext *c = redisAsyncConnect("127.0.0.1", 6379);
+ redictAsyncContext *c = redictAsyncConnect("127.0.0.1", 6379);
if (c->err) {
/* Let *c leak for now... */
printf("Error: %s\n", c->errstr);
return 1;
}
- redisLibuvAttach(c,loop);
- redisAsyncSetConnectCallback(c,connectCallback);
- redisAsyncSetDisconnectCallback(c,disconnectCallback);
- redisAsyncSetTimeout(c, (struct timeval){ .tv_sec = 1, .tv_usec = 0});
+ redictLibuvAttach(c,loop);
+ redictAsyncSetConnectCallback(c,connectCallback);
+ redictAsyncSetDisconnectCallback(c,disconnectCallback);
+ redictAsyncSetTimeout(c, (struct timeval){ .tv_sec = 1, .tv_usec = 0});
/*
In this demo, we first `set key`, then `get key` to demonstrate the basic usage of libuv adapter.
@@ -79,8 +79,8 @@ int main (int argc, char **argv) {
timeout error, which is shown in the `debugCallback`.
*/
- redisAsyncCommand(c, NULL, NULL, "SET key %b", argv[argc-1], strlen(argv[argc-1]));
- redisAsyncCommand(c, getCallback, (char*)"end-1", "GET key");
+ redictAsyncCommand(c, NULL, NULL, "SET key %b", argv[argc-1], strlen(argv[argc-1]));
+ redictAsyncCommand(c, getCallback, (char*)"end-1", "GET key");
uv_run(loop, UV_RUN_DEFAULT);
return 0;
diff --git a/examples/example-macosx.c b/examples/example-macosx.c
index 659d3b5..265afe4 100644
--- a/examples/example-macosx.c
+++ b/examples/example-macosx.c
@@ -12,25 +12,25 @@
#include <async.h>
#include <adapters/macosx.h>
-void getCallback(redisAsyncContext *c, void *r, void *privdata) {
- redisReply *reply = r;
+void getCallback(redictAsyncContext *c, void *r, void *privdata) {
+ redictReply *reply = r;
if (reply == NULL) return;
printf("argv[%s]: %s\n", (char*)privdata, reply->str);
/* Disconnect after receiving the reply to GET */
- redisAsyncDisconnect(c);
+ redictAsyncDisconnect(c);
}
-void connectCallback(const redisAsyncContext *c, int status) {
- if (status != REDIS_OK) {
+void connectCallback(const redictAsyncContext *c, int status) {
+ if (status != REDICT_OK) {
printf("Error: %s\n", c->errstr);
return;
}
printf("Connected...\n");
}
-void disconnectCallback(const redisAsyncContext *c, int status) {
- if (status != REDIS_OK) {
+void disconnectCallback(const redictAsyncContext *c, int status) {
+ if (status != REDICT_OK) {
printf("Error: %s\n", c->errstr);
return;
}
@@ -47,20 +47,20 @@ int main (int argc, char **argv) {
return 1;
}
- redisAsyncContext *c = redisAsyncConnect("127.0.0.1", 6379);
+ redictAsyncContext *c = redictAsyncConnect("127.0.0.1", 6379);
if (c->err) {
/* Let *c leak for now... */
printf("Error: %s\n", c->errstr);
return 1;
}
- redisMacOSAttach(c, loop);
+ redictMacOSAttach(c, loop);
- redisAsyncSetConnectCallback(c,connectCallback);
- redisAsyncSetDisconnectCallback(c,disconnectCallback);
+ redictAsyncSetConnectCallback(c,connectCallback);
+ redictAsyncSetDisconnectCallback(c,disconnectCallback);
- redisAsyncCommand(c, NULL, NULL, "SET key %b", argv[argc-1], strlen(argv[argc-1]));
- redisAsyncCommand(c, getCallback, (char*)"end-1", "GET key");
+ redictAsyncCommand(c, NULL, NULL, "SET key %b", argv[argc-1], strlen(argv[argc-1]));
+ redictAsyncCommand(c, getCallback, (char*)"end-1", "GET key");
CFRunLoopRun();
diff --git a/examples/example-poll.c b/examples/example-poll.c
index eb53659..75d4fd5 100644
--- a/examples/example-poll.c
+++ b/examples/example-poll.c
@@ -16,17 +16,17 @@
/* Put in the global scope, so that loop can be explicitly stopped */
static int exit_loop = 0;
-void getCallback(redisAsyncContext *c, void *r, void *privdata) {
- redisReply *reply = r;
+void getCallback(redictAsyncContext *c, void *r, void *privdata) {
+ redictReply *reply = r;
if (reply == NULL) return;
printf("argv[%s]: %s\n", (char*)privdata, reply->str);
/* Disconnect after receiving the reply to GET */
- redisAsyncDisconnect(c);
+ redictAsyncDisconnect(c);
}
-void connectCallback(const redisAsyncContext *c, int status) {
- if (status != REDIS_OK) {
+void connectCallback(const redictAsyncContext *c, int status) {
+ if (status != REDICT_OK) {
printf("Error: %s\n", c->errstr);
exit_loop = 1;
return;
@@ -35,9 +35,9 @@ void connectCallback(const redisAsyncContext *c, int status) {
printf("Connected...\n");
}
-void disconnectCallback(const redisAsyncContext *c, int status) {
+void disconnectCallback(const redictAsyncContext *c, int status) {
exit_loop = 1;
- if (status != REDIS_OK) {
+ if (status != REDICT_OK) {
printf("Error: %s\n", c->errstr);
return;
}
@@ -48,21 +48,21 @@ void disconnectCallback(const redisAsyncContext *c, int status) {
int main (int argc, char **argv) {
signal(SIGPIPE, SIG_IGN);
- redisAsyncContext *c = redisAsyncConnect("127.0.0.1", 6379);
+ redictAsyncContext *c = redictAsyncConnect("127.0.0.1", 6379);
if (c->err) {
/* Let *c leak for now... */
printf("Error: %s\n", c->errstr);
return 1;
}
- redisPollAttach(c);
- redisAsyncSetConnectCallback(c,connectCallback);
- redisAsyncSetDisconnectCallback(c,disconnectCallback);
- redisAsyncCommand(c, NULL, NULL, "SET key %b", argv[argc-1], strlen(argv[argc-1]));
- redisAsyncCommand(c, getCallback, (char*)"end-1", "GET key");
+ redictPollAttach(c);
+ redictAsyncSetConnectCallback(c,connectCallback);
+ redictAsyncSetDisconnectCallback(c,disconnectCallback);
+ redictAsyncCommand(c, NULL, NULL, "SET key %b", argv[argc-1], strlen(argv[argc-1]));
+ redictAsyncCommand(c, getCallback, (char*)"end-1", "GET key");
while (!exit_loop)
{
- redisPollTick(c, 0.1);
+ redictPollTick(c, 0.1);
}
return 0;
}
diff --git a/examples/example-push.c b/examples/example-push.c
index ce28c38..1d6d0b5 100644
--- a/examples/example-push.c
+++ b/examples/example-push.c
@@ -19,12 +19,12 @@
exit(-1); \
} while (0)
-static void assertReplyAndFree(redisContext *context, redisReply *reply, int type) {
+static void assertReplyAndFree(redictContext *context, redictReply *reply, int type) {
if (reply == NULL)
panicAbort("NULL reply from server (error: %s)", context->errstr);
if (reply->type != type) {
- if (reply->type == REDIS_REPLY_ERROR)
+ if (reply->type == REDICT_REPLY_ERROR)
fprintf(stderr, "Redict Error: %s\n", reply->str);
panicAbort("Expected reply type %d but got type %d", type, reply->type);
@@ -34,34 +34,34 @@ static void assertReplyAndFree(redisContext *context, redisReply *reply, int typ
}
/* Switch to the RESP3 protocol and enable client tracking */
-static void enableClientTracking(redisContext *c) {
- redisReply *reply = redisCommand(c, "HELLO 3");
+static void enableClientTracking(redictContext *c) {
+ redictReply *reply = redictCommand(c, "HELLO 3");
if (reply == NULL || c->err) {
panicAbort("NULL reply or server error (error: %s)", c->errstr);
}
- if (reply->type != REDIS_REPLY_MAP) {
+ if (reply->type != REDICT_REPLY_MAP) {
fprintf(stderr, "Error: Can't send HELLO 3 command. Are you sure you're ");
fprintf(stderr, "connected to redict-server >= 6.0.0?\nRedict error: %s\n",
- reply->type == REDIS_REPLY_ERROR ? reply->str : "(unknown)");
+ reply->type == REDICT_REPLY_ERROR ? reply->str : "(unknown)");
exit(-1);
}
freeReplyObject(reply);
/* Enable client tracking */
- reply = redisCommand(c, "CLIENT TRACKING ON");
- assertReplyAndFree(c, reply, REDIS_REPLY_STATUS);
+ reply = redictCommand(c, "CLIENT TRACKING ON");
+ assertReplyAndFree(c, reply, REDICT_REPLY_STATUS);
}
void pushReplyHandler(void *privdata, void *r) {
- redisReply *reply = r;
+ redictReply *reply = r;
int *invalidations = privdata;
/* Sanity check on the invalidation reply */
- if (reply->type != REDIS_REPLY_PUSH || reply->elements != 2 ||
- reply->element[1]->type != REDIS_REPLY_ARRAY ||
- reply->element[1]->element[0]->type != REDIS_REPLY_STRING)
+ if (reply->type != REDICT_REPLY_PUSH || reply->elements != 2 ||
+ reply->element[1]->type != REDICT_REPLY_ARRAY ||
+ reply->element[1]->element[0]->type != REDICT_REPLY_STRING)
{
panicAbort("%s", "Can't parse PUSH message!");
}
@@ -76,7 +76,7 @@ void pushReplyHandler(void *privdata, void *r) {
}
/* We aren't actually freeing anything here, but it is included to show that we can
- * have hiredis call our data destructor when freeing the context */
+ * have hiredict call our data destructor when freeing the context */
void privdata_dtor(void *privdata) {
unsigned int *icount = privdata;
printf("privdata_dtor(): In context privdata dtor (invalidations: %u)\n", *icount);
@@ -84,55 +84,55 @@ void privdata_dtor(void *privdata) {
int main(int argc, char **argv) {
unsigned int j, invalidations = 0;
- redisContext *c;
- redisReply *reply;
+ redictContext *c;
+ redictReply *reply;
const char *hostname = (argc > 1) ? argv[1] : "127.0.0.1";
int port = (argc > 2) ? atoi(argv[2]) : 6379;
- redisOptions o = {0};
- REDIS_OPTIONS_SET_TCP(&o, hostname, port);
+ redictOptions o = {0};
+ REDICT_OPTIONS_SET_TCP(&o, hostname, port);
/* Set our context privdata to the address of our invalidation counter. Each
- * time our PUSH handler is called, hiredis will pass the privdata for context.
+ * time our PUSH handler is called, hiredict will pass the privdata for context.
*
* This could also be done after we create the context like so:
*
* c->privdata = &invalidations;
* c->free_privdata = privdata_dtor;
*/
- REDIS_OPTIONS_SET_PRIVDATA(&o, &invalidations, privdata_dtor);
+ REDICT_OPTIONS_SET_PRIVDATA(&o, &invalidations, privdata_dtor);
/* Set our custom PUSH message handler */
o.push_cb = pushReplyHandler;
- c = redisConnectWithOptions(&o);
+ c = redictConnectWithOptions(&o);
if (c == NULL || c->err)
panicAbort("Connection error: %s", c ? c->errstr : "OOM");
/* Enable RESP3 and turn on client tracking */
enableClientTracking(c);
- /* Set some keys and then read them back. Once we do that, Redis will deliver
+ /* Set some keys and then read them back. Once we do that, Redict will deliver
* invalidation push messages whenever the key is modified */
for (j = 0; j < KEY_COUNT; j++) {
- reply = redisCommand(c, "SET key:%d initial:%d", j, j);
- assertReplyAndFree(c, reply, REDIS_REPLY_STATUS);
+ reply = redictCommand(c, "SET key:%d initial:%d", j, j);
+ assertReplyAndFree(c, reply, REDICT_REPLY_STATUS);
- reply = redisCommand(c, "GET key:%d", j);
- assertReplyAndFree(c, reply, REDIS_REPLY_STRING);
+ reply = redictCommand(c, "GET key:%d", j);
+ assertReplyAndFree(c, reply, REDICT_REPLY_STRING);
}
/* Trigger invalidation messages by updating keys we just read */
for (j = 0; j < KEY_COUNT; j++) {
printf(" main(): SET key:%d update:%d\n", j, j);
- reply = redisCommand(c, "SET key:%d update:%d", j, j);
- assertReplyAndFree(c, reply, REDIS_REPLY_STATUS);
+ reply = redictCommand(c, "SET key:%d update:%d", j, j);
+ assertReplyAndFree(c, reply, REDICT_REPLY_STATUS);
printf(" main(): SET REPLY OK\n");
}
printf("\nTotal detected invalidations: %d, expected: %d\n", invalidations, KEY_COUNT);
/* PING server */
- redisFree(c);
+ redictFree(c);
}
diff --git a/examples/example-qt.cpp b/examples/example-qt.cpp
index 9ed61e8..8f6926c 100644
--- a/examples/example-qt.cpp
+++ b/examples/example-qt.cpp
@@ -12,9 +12,9 @@ using namespace std;
#include "example-qt.h"
-void getCallback(redisAsyncContext *, void * r, void * privdata) {
+void getCallback(redictAsyncContext *, void * r, void * privdata) {
- redisReply * reply = static_cast<redisReply *>(r);
+ redictReply * reply = static_cast<redictReply *>(r);
ExampleQt * ex = static_cast<ExampleQt *>(privdata);
if (reply == nullptr || ex == nullptr) return;
@@ -25,18 +25,18 @@ void getCallback(redisAsyncContext *, void * r, void * privdata) {
void ExampleQt::run() {
- m_ctx = redisAsyncConnect("localhost", 6379);
+ m_ctx = redictAsyncConnect("localhost", 6379);
if (m_ctx->err) {
cerr << "Error: " << m_ctx->errstr << endl;
- redisAsyncFree(m_ctx);
+ redictAsyncFree(m_ctx);
emit finished();
}
m_adapter.setContext(m_ctx);
- redisAsyncCommand(m_ctx, NULL, NULL, "SET key %s", m_value);
- redisAsyncCommand(m_ctx, getCallback, this, "GET key");
+ redictAsyncCommand(m_ctx, NULL, NULL, "SET key %s", m_value);
+ redictAsyncCommand(m_ctx, getCallback, this, "GET key");
}
int main (int argc, char **argv) {
diff --git a/examples/example-qt.h b/examples/example-qt.h
index 31195ae..f48df17 100644
--- a/examples/example-qt.h
+++ b/examples/example-qt.h
@@ -4,8 +4,8 @@
// SPDX-License-Identifier: BSD-3-Clause
// SPDX-License-Identifier: LGPL-3.0-or-later
-#ifndef __HIREDIS_EXAMPLE_QT_H
-#define __HIREDIS_EXAMPLE_QT_H
+#ifndef __HIREDICT_EXAMPLE_QT_H
+#define __HIREDICT_EXAMPLE_QT_H
#include <adapters/qt.h>
@@ -28,11 +28,11 @@ class ExampleQt : public QObject {
private:
const char * m_value;
- redisAsyncContext * m_ctx;
- RedisQtAdapter m_adapter;
+ redictAsyncContext * m_ctx;
+ RedictQtAdapter m_adapter;
friend
- void getCallback(redisAsyncContext *, void *, void *);
+ void getCallback(redictAsyncContext *, void *, void *);
};
-#endif /* !__HIREDIS_EXAMPLE_QT_H */
+#endif /* !__HIREDICT_EXAMPLE_QT_H */
diff --git a/examples/example-redictmoduleapi.c b/examples/example-redictmoduleapi.c
index f929ffc..84dea0d 100644
--- a/examples/example-redictmoduleapi.c
+++ b/examples/example-redictmoduleapi.c
@@ -13,20 +13,20 @@
#include <async.h>
#include <adapters/redictmoduleapi.h>
-void debugCallback(redisAsyncContext *c, void *r, void *privdata) {
+void debugCallback(redictAsyncContext *c, void *r, void *privdata) {
(void)privdata; //unused
- redisReply *reply = r;
+ redictReply *reply = r;
if (reply == NULL) {
/* The DEBUG SLEEP command will almost always fail, because we have set a 1 second timeout */
printf("`DEBUG SLEEP` error: %s\n", c->errstr ? c->errstr : "unknown error");
return;
}
/* Disconnect after receiving the reply of DEBUG SLEEP (which will not)*/
- redisAsyncDisconnect(c);
+ redictAsyncDisconnect(c);
}
-void getCallback(redisAsyncContext *c, void *r, void *privdata) {
- redisReply *reply = r;
+void getCallback(redictAsyncContext *c, void *r, void *privdata) {
+ redictReply *reply = r;
if (reply == NULL) {
if (c->errstr) {
printf("errstr: %s\n", c->errstr);
@@ -36,19 +36,19 @@ void getCallback(redisAsyncContext *c, void *r, void *privdata) {
printf("argv[%s]: %s\n", (char*)privdata, reply->str);
/* start another request that demonstrate timeout */
- redisAsyncCommand(c, debugCallback, NULL, "DEBUG SLEEP %f", 1.5);
+ redictAsyncCommand(c, debugCallback, NULL, "DEBUG SLEEP %f", 1.5);
}
-void connectCallback(const redisAsyncContext *c, int status) {
- if (status != REDIS_OK) {
+void connectCallback(const redictAsyncContext *c, int status) {
+ if (status != REDICT_OK) {
printf("Error: %s\n", c->errstr);
return;
}
printf("Connected...\n");
}
-void disconnectCallback(const redisAsyncContext *c, int status) {
- if (status != REDIS_OK) {
+void disconnectCallback(const redictAsyncContext *c, int status) {
+ if (status != REDICT_OK) {
printf("Error: %s\n", c->errstr);
return;
}
@@ -56,28 +56,26 @@ void disconnectCallback(const redisAsyncContext *c, int status) {
}
/*
- * This example requires Redis 7.0 or above.
- *
- * 1- Compile this file as a shared library. Directory of "redismodule.h" must
+ * 1- Compile this file as a shared library. Directory of "redictmodule.h" must
* be in the include path.
- * gcc -fPIC -shared -I../../redis/src/ -I.. example-redismoduleapi.c -o example-redismoduleapi.so
+ * gcc -fPIC -shared -I../../redict/src/ -I.. example-redictmoduleapi.c -o example-redictmoduleapi.so
*
* 2- Load module:
- * redis-server --loadmodule ./example-redismoduleapi.so value
+ * redict-server --loadmodule ./example-redictmoduleapi.so value
*/
-int RedisModule_OnLoad(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
+int RedictModule_OnLoad(RedictModuleCtx *ctx, RedictModuleString **argv, int argc) {
- int ret = RedisModule_Init(ctx, "example-redictmoduleapi", 1, REDISMODULE_APIVER_1);
- if (ret != REDISMODULE_OK) {
+ int ret = RedictModule_Init(ctx, "example-redictmoduleapi", 1, REDICTMODULE_APIVER_1);
+ if (ret != REDICTMODULE_OK) {
printf("error module init \n");
- return REDISMODULE_ERR;
+ return REDICTMODULE_ERR;
}
- if (redisModuleCompatibilityCheck() != REDIS_OK) {
- return REDISMODULE_ERR;
+ if (redictModuleCompatibilityCheck() != REDICT_OK) {
+ return REDICTMODULE_ERR;
}
- redisAsyncContext *c = redisAsyncConnect("127.0.0.1", 6379);
+ redictAsyncContext *c = redictAsyncConnect("127.0.0.1", 6379);
if (c->err) {
/* Let *c leak for now... */
printf("Error: %s\n", c->errstr);
@@ -85,13 +83,13 @@ int RedisModule_OnLoad(RedisModuleCtx *ctx, RedisModuleString **argv, int argc)
}
size_t len;
- const char *val = RedisModule_StringPtrLen(argv[argc-1], &len);
+ const char *val = RedictModule_StringPtrLen(argv[argc-1], &len);
- RedisModuleCtx *module_ctx = RedisModule_GetDetachedThreadSafeContext(ctx);
- redisModuleAttach(c, module_ctx);
- redisAsyncSetConnectCallback(c,connectCallback);
- redisAsyncSetDisconnectCallback(c,disconnectCallback);
- redisAsyncSetTimeout(c, (struct timeval){ .tv_sec = 1, .tv_usec = 0});
+ RedictModuleCtx *module_ctx = RedictModule_GetDetachedThreadSafeContext(ctx);
+ redictModuleAttach(c, module_ctx);
+ redictAsyncSetConnectCallback(c,connectCallback);
+ redictAsyncSetDisconnectCallback(c,disconnectCallback);
+ redictAsyncSetTimeout(c, (struct timeval){ .tv_sec = 1, .tv_usec = 0});
/*
In this demo, we first `set key`, then `get key` to demonstrate the basic usage of the adapter.
@@ -100,7 +98,7 @@ int RedisModule_OnLoad(RedisModuleCtx *ctx, RedisModuleString **argv, int argc)
timeout error, which is shown in the `debugCallback`.
*/
- redisAsyncCommand(c, NULL, NULL, "SET key %b", val, len);
- redisAsyncCommand(c, getCallback, (char*)"end-1", "GET key");
+ redictAsyncCommand(c, NULL, NULL, "SET key %b", val, len);
+ redictAsyncCommand(c, getCallback, (char*)"end-1", "GET key");
return 0;
}
diff --git a/examples/example-ssl.c b/examples/example-ssl.c
index ac3dfb8..c9b8818 100644
--- a/examples/example-ssl.c
+++ b/examples/example-ssl.c
@@ -9,7 +9,7 @@
#include <string.h>
#include <hiredict.h>
-#include <hiredis_ssl.h>
+#include <hiredict_ssl.h>
#ifdef _MSC_VER
#include <winsock2.h> /* For struct timeval */
@@ -17,10 +17,10 @@
int main(int argc, char **argv) {
unsigned int j;
- redisSSLContext *ssl;
- redisSSLContextError ssl_error = REDIS_SSL_CTX_NONE;
- redisContext *c;
- redisReply *reply;
+ redictSSLContext *ssl;
+ redictSSLContextError ssl_error = REDICT_SSL_CTX_NONE;
+ redictContext *c;
+ redictReply *reply;
if (argc < 4) {
printf("Usage: %s <host> <port> <cert> <key> [ca]\n", argv[0]);
exit(1);
@@ -31,78 +31,78 @@ int main(int argc, char **argv) {
const char *key = argv[4];
const char *ca = argc > 4 ? argv[5] : NULL;
- redisInitOpenSSL();
- ssl = redisCreateSSLContext(ca, NULL, cert, key, NULL, &ssl_error);
- if (!ssl || ssl_error != REDIS_SSL_CTX_NONE) {
+ redictInitOpenSSL();
+ ssl = redictCreateSSLContext(ca, NULL, cert, key, NULL, &ssl_error);
+ if (!ssl || ssl_error != REDICT_SSL_CTX_NONE) {
printf("SSL Context error: %s\n", redictSSLContextGetError(ssl_error));
exit(1);
}
struct timeval tv = { 1, 500000 }; // 1.5 seconds
- redisOptions options = {0};
- REDIS_OPTIONS_SET_TCP(&options, hostname, port);
+ redictOptions options = {0};
+ REDICT_OPTIONS_SET_TCP(&options, hostname, port);
options.connect_timeout = &tv;
- c = redisConnectWithOptions(&options);
+ c = redictConnectWithOptions(&options);
if (c == NULL || c->err) {
if (c) {
printf("Connection error: %s\n", c->errstr);
- redisFree(c);
+ redictFree(c);
} else {
printf("Connection error: can't allocate redict context\n");
}
exit(1);
}
- if (redisInitiateSSLWithContext(c, ssl) != REDIS_OK) {
+ if (redictInitiateSSLWithContext(c, ssl) != REDICT_OK) {
printf("Couldn't initialize SSL!\n");
printf("Error: %s\n", c->errstr);
- redisFree(c);
+ redictFree(c);
exit(1);
}
/* PING server */
- reply = redisCommand(c,"PING");
+ reply = redictCommand(c,"PING");
printf("PING: %s\n", reply->str);
freeReplyObject(reply);
/* Set a key */
- reply = redisCommand(c,"SET %s %s", "foo", "hello world");
+ reply = redictCommand(c,"SET %s %s", "foo", "hello world");
printf("SET: %s\n", reply->str);
freeReplyObject(reply);
/* Set a key using binary safe API */
- reply = redisCommand(c,"SET %b %b", "bar", (size_t) 3, "hello", (size_t) 5);
+ reply = redictCommand(c,"SET %b %b", "bar", (size_t) 3, "hello", (size_t) 5);
printf("SET (binary API): %s\n", reply->str);
freeReplyObject(reply);
/* Try a GET and two INCR */
- reply = redisCommand(c,"GET foo");
+ reply = redictCommand(c,"GET foo");
printf("GET foo: %s\n", reply->str);
freeReplyObject(reply);
- reply = redisCommand(c,"INCR counter");
+ reply = redictCommand(c,"INCR counter");
printf("INCR counter: %lld\n", reply->integer);
freeReplyObject(reply);
/* again ... */
- reply = redisCommand(c,"INCR counter");
+ reply = redictCommand(c,"INCR counter");
printf("INCR counter: %lld\n", reply->integer);
freeReplyObject(reply);
/* Create a list of numbers, from 0 to 9 */
- reply = redisCommand(c,"DEL mylist");
+ reply = redictCommand(c,"DEL mylist");
freeReplyObject(reply);
for (j = 0; j < 10; j++) {
char buf[64];
snprintf(buf,64,"%u",j);
- reply = redisCommand(c,"LPUSH mylist element-%s", buf);
+ reply = redictCommand(c,"LPUSH mylist element-%s", buf);
freeReplyObject(reply);
}
/* Let's check what we have inside the list */
- reply = redisCommand(c,"LRANGE mylist 0 -1");
- if (reply->type == REDIS_REPLY_ARRAY) {
+ reply = redictCommand(c,"LRANGE mylist 0 -1");
+ if (reply->type == REDICT_REPLY_ARRAY) {
for (j = 0; j < reply->elements; j++) {
printf("%u) %s\n", j, reply->element[j]->str);
}
@@ -110,9 +110,9 @@ int main(int argc, char **argv) {
freeReplyObject(reply);
/* Disconnects and frees the context */
- redisFree(c);
+ redictFree(c);
- redisFreeSSLContext(ssl);
+ redictFreeSSLContext(ssl);
return 0;
}
diff --git a/examples/example.c b/examples/example.c
index 41c8189..28e77e4 100644
--- a/examples/example.c
+++ b/examples/example.c
@@ -13,10 +13,10 @@
#include <winsock2.h> /* For struct timeval */
#endif
-static void example_argv_command(redisContext *c, size_t n) {
+static void example_argv_command(redictContext *c, size_t n) {
char **argv, tmp[42];
size_t *argvlen;
- redisReply *reply;
+ redictReply *reply;
/* We're allocating two additional elements for command and key */
argv = malloc(sizeof(*argv) * (2 + n));
@@ -36,17 +36,17 @@ static void example_argv_command(redisContext *c, size_t n) {
argv[i] = strdup(tmp);
}
- /* Execute the command using redisCommandArgv. We're sending the arguments with
+ /* Execute the command using redictCommandArgv. We're sending the arguments with
* two explicit arrays. One for each argument's string, and the other for its
* length. */
- reply = redisCommandArgv(c, n + 2, (const char **)argv, (const size_t*)argvlen);
+ reply = redictCommandArgv(c, n + 2, (const char **)argv, (const size_t*)argvlen);
if (reply == NULL || c->err) {
fprintf(stderr, "Error: Couldn't execute redictCommandArgv\n");
exit(1);
}
- if (reply->type == REDIS_REPLY_INTEGER) {
+ if (reply->type == REDICT_REPLY_INTEGER) {
printf("%s reply: %lld\n", argv[0], reply->integer);
}
@@ -63,8 +63,8 @@ static void example_argv_command(redisContext *c, size_t n) {
int main(int argc, char **argv) {
unsigned int j, isunix = 0;
- redisContext *c;
- redisReply *reply;
+ redictContext *c;
+ redictReply *reply;
const char *hostname = (argc > 1) ? argv[1] : "127.0.0.1";
if (argc > 2) {
@@ -79,14 +79,14 @@ int main(int argc, char **argv) {
struct timeval timeout = { 1, 500000 }; // 1.5 seconds
if (isunix) {
- c = redisConnectUnixWithTimeout(hostname, timeout);
+ c = redictConnectUnixWithTimeout(hostname, timeout);
} else {
- c = redisConnectWithTimeout(hostname, port, timeout);
+ c = redictConnectWithTimeout(hostname, port, timeout);
}
if (c == NULL || c->err) {
if (c) {
printf("Connection error: %s\n", c->errstr);
- redisFree(c);
+ redictFree(c);
} else {
printf("Connection error: can't allocate redict context\n");
}
@@ -94,58 +94,58 @@ int main(int argc, char **argv) {
}
/* PING server */
- reply = redisCommand(c,"PING");
+ reply = redictCommand(c,"PING");
printf("PING: %s\n", reply->str);
freeReplyObject(reply);
/* Set a key */
- reply = redisCommand(c,"SET %s %s", "foo", "hello world");
+ reply = redictCommand(c,"SET %s %s", "foo", "hello world");
printf("SET: %s\n", reply->str);
freeReplyObject(reply);
/* Set a key using binary safe API */
- reply = redisCommand(c,"SET %b %b", "bar", (size_t) 3, "hello", (size_t) 5);
+ reply = redictCommand(c,"SET %b %b", "bar", (size_t) 3, "hello", (size_t) 5);
printf("SET (binary API): %s\n", reply->str);
freeReplyObject(reply);
/* Try a GET and two INCR */
- reply = redisCommand(c,"GET foo");
+ reply = redictCommand(c,"GET foo");
printf("GET foo: %s\n", reply->str);
freeReplyObject(reply);
- reply = redisCommand(c,"INCR counter");
+ reply = redictCommand(c,"INCR counter");
printf("INCR counter: %lld\n", reply->integer);
freeReplyObject(reply);
/* again ... */
- reply = redisCommand(c,"INCR counter");
+ reply = redictCommand(c,"INCR counter");
printf("INCR counter: %lld\n", reply->integer);
freeReplyObject(reply);
/* Create a list of numbers, from 0 to 9 */
- reply = redisCommand(c,"DEL mylist");
+ reply = redictCommand(c,"DEL mylist");
freeReplyObject(reply);
for (j = 0; j < 10; j++) {
char buf[64];
snprintf(buf,64,"%u",j);
- reply = redisCommand(c,"LPUSH mylist element-%s", buf);
+ reply = redictCommand(c,"LPUSH mylist element-%s", buf);
freeReplyObject(reply);
}
/* Let's check what we have inside the list */
- reply = redisCommand(c,"LRANGE mylist 0 -1");
- if (reply->type == REDIS_REPLY_ARRAY) {
+ reply = redictCommand(c,"LRANGE mylist 0 -1");
+ if (reply->type == REDICT_REPLY_ARRAY) {
for (j = 0; j < reply->elements; j++) {
printf("%u) %s\n", j, reply->element[j]->str);
}
}
freeReplyObject(reply);
- /* See function for an example of redisCommandArgv */
+ /* See function for an example of redictCommandArgv */
example_argv_command(c, 10);
/* Disconnects and frees the context */
- redisFree(c);
+ redictFree(c);
return 0;
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-09-20 04:17:25 +0000