dict.c API names modified to be more coincise and consistent.

diff --git a/src/aof.c b/src/aof.c
index 66516f7879b267a86ea8bd575563b10137cacd5a..e43e5cfd8c80be2d41b6e099e53e4b619fe8f212 100644 (file)
--- a/src/aof.c
+++ b/src/aof.c
@@ -443,8 +443,8 @@ int rewriteAppendOnlyFile(char *filename) {
             robj key, *o;
             time_t expiretime;
 
             robj key, *o;
             time_t expiretime;
 

-            keystr = dictGetEntryKey(de);
-            o = dictGetEntryVal(de);
+            keystr = dictGetKey(de);
+            o = dictGetVal(de);

             initStaticStringObject(key,keystr);
 
             expiretime = getExpire(db,&key);
             initStaticStringObject(key,keystr);
 
             expiretime = getExpire(db,&key);


@@ -511,7 +511,7 @@ int rewriteAppendOnlyFile(char *filename) {
                     dictIterator *di = dictGetIterator(o->ptr);
                     dictEntry *de;
                     while((de = dictNext(di)) != NULL) {
                     dictIterator *di = dictGetIterator(o->ptr);
                     dictEntry *de;
                     while((de = dictNext(di)) != NULL) {

-                        robj *eleobj = dictGetEntryKey(de);
+                        robj *eleobj = dictGetKey(de);

                         if (rioWrite(&aof,cmd,sizeof(cmd)-1) == 0) goto werr;
                         if (rioWriteBulkObject(&aof,&key) == 0) goto werr;
                         if (rioWriteBulkObject(&aof,eleobj) == 0) goto werr;
                         if (rioWrite(&aof,cmd,sizeof(cmd)-1) == 0) goto werr;
                         if (rioWriteBulkObject(&aof,&key) == 0) goto werr;
                         if (rioWriteBulkObject(&aof,eleobj) == 0) goto werr;


@@ -559,8 +559,8 @@ int rewriteAppendOnlyFile(char *filename) {
                     dictEntry *de;
 
                     while((de = dictNext(di)) != NULL) {
                     dictEntry *de;
 
                     while((de = dictNext(di)) != NULL) {

-                        robj *eleobj = dictGetEntryKey(de);
-                        double *score = dictGetEntryVal(de);
+                        robj *eleobj = dictGetKey(de);
+                        double *score = dictGetVal(de);

 
                         if (rioWrite(&aof,cmd,sizeof(cmd)-1) == 0) goto werr;
                         if (rioWriteBulkObject(&aof,&key) == 0) goto werr;
 
                         if (rioWrite(&aof,cmd,sizeof(cmd)-1) == 0) goto werr;
                         if (rioWriteBulkObject(&aof,&key) == 0) goto werr;


@@ -593,8 +593,8 @@ int rewriteAppendOnlyFile(char *filename) {
                     dictEntry *de;
 
                     while((de = dictNext(di)) != NULL) {
                     dictEntry *de;
 
                     while((de = dictNext(di)) != NULL) {

-                        robj *field = dictGetEntryKey(de);
-                        robj *val = dictGetEntryVal(de);
+                        robj *field = dictGetKey(de);
+                        robj *val = dictGetVal(de);

 
                         if (rioWrite(&aof,cmd,sizeof(cmd)-1) == 0) goto werr;
                         if (rioWriteBulkObject(&aof,&key) == 0) goto werr;
 
                         if (rioWrite(&aof,cmd,sizeof(cmd)-1) == 0) goto werr;
                         if (rioWriteBulkObject(&aof,&key) == 0) goto werr;

diff --git a/src/cluster.c b/src/cluster.c
index fadce42eacdb9a8adf082b2ecf8029801e63e762..4ccff657363659b4d8c8920e5c07f88aaf791b08 100644 (file)
--- a/src/cluster.c
+++ b/src/cluster.c
@@ -377,7 +377,7 @@ clusterNode *clusterLookupNode(char *name) {
     de = dictFind(server.cluster.nodes,s);
     sdsfree(s);
     if (de == NULL) return NULL;
     de = dictFind(server.cluster.nodes,s);
     sdsfree(s);
     if (de == NULL) return NULL;

-    return dictGetEntryVal(de);
+    return dictGetVal(de);

 }
 
 /* This is only used after the handshake. When we connect a given IP/PORT
 }
 
 /* This is only used after the handshake. When we connect a given IP/PORT


@@ -793,7 +793,7 @@ void clusterBroadcastMessage(void *buf, size_t len) {
 
     di = dictGetIterator(server.cluster.nodes);
     while((de = dictNext(di)) != NULL) {
 
     di = dictGetIterator(server.cluster.nodes);
     while((de = dictNext(di)) != NULL) {

-        clusterNode *node = dictGetEntryVal(de);
+        clusterNode *node = dictGetVal(de);

 
         if (!node->link) continue;
         if (node->flags & (REDIS_NODE_MYSELF|REDIS_NODE_NOADDR)) continue;
 
         if (!node->link) continue;
         if (node->flags & (REDIS_NODE_MYSELF|REDIS_NODE_NOADDR)) continue;


@@ -849,7 +849,7 @@ void clusterSendPing(clusterLink *link, int type) {
     /* Populate the gossip fields */
     while(freshnodes > 0 && gossipcount < 3) {
         struct dictEntry *de = dictGetRandomKey(server.cluster.nodes);
     /* Populate the gossip fields */
     while(freshnodes > 0 && gossipcount < 3) {
         struct dictEntry *de = dictGetRandomKey(server.cluster.nodes);

-        clusterNode *this = dictGetEntryVal(de);
+        clusterNode *this = dictGetVal(de);

         clusterMsgDataGossip *gossip;
         int j;
 
         clusterMsgDataGossip *gossip;
         int j;
 


@@ -970,7 +970,7 @@ void clusterCron(void) {
     /* Check if we have disconnected nodes and reestablish the connection. */
     di = dictGetIterator(server.cluster.nodes);
     while((de = dictNext(di)) != NULL) {
     /* Check if we have disconnected nodes and reestablish the connection. */
     di = dictGetIterator(server.cluster.nodes);
     while((de = dictNext(di)) != NULL) {

-        clusterNode *node = dictGetEntryVal(de);
+        clusterNode *node = dictGetVal(de);

 
         if (node->flags & (REDIS_NODE_MYSELF|REDIS_NODE_NOADDR)) continue;
         if (node->link == NULL) {
 
         if (node->flags & (REDIS_NODE_MYSELF|REDIS_NODE_NOADDR)) continue;
         if (node->link == NULL) {


@@ -1005,7 +1005,7 @@ void clusterCron(void) {
      * the oldest ping_sent time */
     for (j = 0; j < 5; j++) {
         de = dictGetRandomKey(server.cluster.nodes);
      * the oldest ping_sent time */
     for (j = 0; j < 5; j++) {
         de = dictGetRandomKey(server.cluster.nodes);

-        clusterNode *this = dictGetEntryVal(de);
+        clusterNode *this = dictGetVal(de);

 
         if (this->link == NULL) continue;
         if (this->flags & (REDIS_NODE_MYSELF|REDIS_NODE_HANDSHAKE)) continue;
 
         if (this->link == NULL) continue;
         if (this->flags & (REDIS_NODE_MYSELF|REDIS_NODE_HANDSHAKE)) continue;


@@ -1022,7 +1022,7 @@ void clusterCron(void) {
     /* Iterate nodes to check if we need to flag something as failing */
     di = dictGetIterator(server.cluster.nodes);
     while((de = dictNext(di)) != NULL) {
     /* Iterate nodes to check if we need to flag something as failing */
     di = dictGetIterator(server.cluster.nodes);
     while((de = dictNext(di)) != NULL) {

-        clusterNode *node = dictGetEntryVal(de);
+        clusterNode *node = dictGetVal(de);

         int delay;
 
         if (node->flags &
         int delay;
 
         if (node->flags &


@@ -1153,7 +1153,7 @@ sds clusterGenNodesDescription(void) {
 
     di = dictGetIterator(server.cluster.nodes);
     while((de = dictNext(di)) != NULL) {
 
     di = dictGetIterator(server.cluster.nodes);
     while((de = dictNext(di)) != NULL) {

-        clusterNode *node = dictGetEntryVal(de);
+        clusterNode *node = dictGetVal(de);

 
         /* Node coordinates */
         ci = sdscatprintf(ci,"%.40s %s:%d ",
 
         /* Node coordinates */
         ci = sdscatprintf(ci,"%.40s %s:%d ",

diff --git a/src/db.c b/src/db.c
index cc9810b6bdebe5b2254e5ef46c517608491cde95..2bc8d7c4e4d49e686513769df0ce34091857282d 100644 (file)
--- a/src/db.c
+++ b/src/db.c
@@ -34,7 +34,7 @@ void SlotToKeyDel(robj *key);
 robj *lookupKey(redisDb *db, robj *key) {
     dictEntry *de = dictFind(db->dict,key->ptr);
     if (de) {
 robj *lookupKey(redisDb *db, robj *key) {
     dictEntry *de = dictFind(db->dict,key->ptr);
     if (de) {

-        robj *val = dictGetEntryVal(de);
+        robj *val = dictGetVal(de);

 
         /* Update the access time for the aging algorithm.
          * Don't do it if we have a saving child, as this will trigger
 
         /* Update the access time for the aging algorithm.
          * Don't do it if we have a saving child, as this will trigger


@@ -130,7 +130,7 @@ robj *dbRandomKey(redisDb *db) {
         de = dictGetRandomKey(db->dict);
         if (de == NULL) return NULL;
 
         de = dictGetRandomKey(db->dict);
         if (de == NULL) return NULL;
 

-        key = dictGetEntryKey(de);
+        key = dictGetKey(de);

         keyobj = createStringObject(key,sdslen(key));
         if (dictFind(db->expires,key)) {
             if (expireIfNeeded(db,keyobj)) {
         keyobj = createStringObject(key,sdslen(key));
         if (dictFind(db->expires,key)) {
             if (expireIfNeeded(db,keyobj)) {


@@ -282,7 +282,7 @@ void keysCommand(redisClient *c) {
     di = dictGetIterator(c->db->dict);
     allkeys = (pattern[0] == '*' && pattern[1] == '\0');
     while((de = dictNext(di)) != NULL) {
     di = dictGetIterator(c->db->dict);
     allkeys = (pattern[0] == '*' && pattern[1] == '\0');
     while((de = dictNext(di)) != NULL) {

-        sds key = dictGetEntryKey(de);
+        sds key = dictGetKey(de);

         robj *keyobj;
 
         if (allkeys || stringmatchlen(pattern,plen,key,sdslen(key),0)) {
         robj *keyobj;
 
         if (allkeys || stringmatchlen(pattern,plen,key,sdslen(key),0)) {


@@ -438,7 +438,7 @@ void setExpire(redisDb *db, robj *key, time_t when) {
     /* Reuse the sds from the main dict in the expire dict */
     de = dictFind(db->dict,key->ptr);
     redisAssertWithInfo(NULL,key,de != NULL);
     /* Reuse the sds from the main dict in the expire dict */
     de = dictFind(db->dict,key->ptr);
     redisAssertWithInfo(NULL,key,de != NULL);

-    dictReplace(db->expires,dictGetEntryKey(de),(void*)when);
+    dictReplace(db->expires,dictGetKey(de),(void*)when);

 }
 
 /* Return the expire time of the specified key, or -1 if no expire
 }
 
 /* Return the expire time of the specified key, or -1 if no expire


@@ -453,7 +453,7 @@ time_t getExpire(redisDb *db, robj *key) {
     /* The entry was found in the expire dict, this means it should also
      * be present in the main dict (safety check). */
     redisAssertWithInfo(NULL,key,dictFind(db->dict,key->ptr) != NULL);
     /* The entry was found in the expire dict, this means it should also
      * be present in the main dict (safety check). */
     redisAssertWithInfo(NULL,key,dictFind(db->dict,key->ptr) != NULL);

-    return (time_t) dictGetEntryVal(de);
+    return (time_t) dictGetVal(de);

 }
 
 /* Propagate expires into slaves and the AOF file.
 }
 
 /* Propagate expires into slaves and the AOF file.

diff --git a/src/debug.c b/src/debug.c
index 7751adf932b280d552d410c7de2537c0bd85a430..2dfe22806acf48095b3f29a3e66b2886a7b7fd92 100644 (file)
--- a/src/debug.c
+++ b/src/debug.c
@@ -94,13 +94,13 @@ void computeDatasetDigest(unsigned char *final) {
             time_t expiretime;
 
             memset(digest,0,20); /* This key-val digest */
             time_t expiretime;
 
             memset(digest,0,20); /* This key-val digest */

-            key = dictGetEntryKey(de);
+            key = dictGetKey(de);

             keyobj = createStringObject(key,sdslen(key));
 
             mixDigest(digest,key,sdslen(key));
 
             /* Make sure the key is loaded if VM is active */
             keyobj = createStringObject(key,sdslen(key));
 
             mixDigest(digest,key,sdslen(key));
 
             /* Make sure the key is loaded if VM is active */

-            o = dictGetEntryVal(de);
+            o = dictGetVal(de);

 
             aux = htonl(o->type);
             mixDigest(digest,&aux,sizeof(aux));
 
             aux = htonl(o->type);
             mixDigest(digest,&aux,sizeof(aux));


@@ -165,8 +165,8 @@ void computeDatasetDigest(unsigned char *final) {
                     dictEntry *de;
 
                     while((de = dictNext(di)) != NULL) {
                     dictEntry *de;
 
                     while((de = dictNext(di)) != NULL) {

-                        robj *eleobj = dictGetEntryKey(de);
-                        double *score = dictGetEntryVal(de);
+                        robj *eleobj = dictGetKey(de);
+                        double *score = dictGetVal(de);

 
                         snprintf(buf,sizeof(buf),"%.17g",*score);
                         memset(eledigest,0,20);
 
                         snprintf(buf,sizeof(buf),"%.17g",*score);
                         memset(eledigest,0,20);


@@ -244,7 +244,7 @@ void debugCommand(redisClient *c) {
             addReply(c,shared.nokeyerr);
             return;
         }
             addReply(c,shared.nokeyerr);
             return;
         }

-        val = dictGetEntryVal(de);
+        val = dictGetVal(de);

         strenc = strEncoding(val->encoding);
 
         addReplyStatusFormat(c,
         strenc = strEncoding(val->encoding);
 
         addReplyStatusFormat(c,

diff --git a/src/dict.c b/src/dict.c
index 9d3368412d0443a8c22db585101bd95290915625..11962f7c4579622f62b3e3d2eaca8c1f951b31fb 100644 (file)
--- a/src/dict.c
+++ b/src/dict.c
@@ -262,7 +262,7 @@ int dictAdd(dict *d, void *key, void *val)
     dictEntry *entry = dictAddRaw(d,key);
 
     if (!entry) return DICT_ERR;
     dictEntry *entry = dictAddRaw(d,key);
 
     if (!entry) return DICT_ERR;

-    dictSetHashVal(d, entry, val);
+    dictSetVal(d, entry, val);

     return DICT_OK;
 }
 
     return DICT_OK;
 }
 


@@ -302,7 +302,7 @@ dictEntry *dictAddRaw(dict *d, void *key)
     ht->used++;
 
     /* Set the hash entry fields. */
     ht->used++;
 
     /* Set the hash entry fields. */

-    dictSetHashKey(d, entry, key);
+    dictSetKey(d, entry, key);

     return entry;
 }
 
     return entry;
 }
 


@@ -326,8 +326,8 @@ int dictReplace(dict *d, void *key, void *val)
      * you want to increment (set), and then decrement (free), and not the
      * reverse. */
     auxentry = *entry;
      * you want to increment (set), and then decrement (free), and not the
      * reverse. */
     auxentry = *entry;

-    dictSetHashVal(d, entry, val);
-    dictFreeEntryVal(d, &auxentry);
+    dictSetVal(d, entry, val);
+    dictFreeVal(d, &auxentry);

     return 0;
 }
 
     return 0;
 }
 


@@ -359,15 +359,15 @@ static int dictGenericDelete(dict *d, const void *key, int nofree)
         he = d->ht[table].table[idx];
         prevHe = NULL;
         while(he) {
         he = d->ht[table].table[idx];
         prevHe = NULL;
         while(he) {

-            if (dictCompareHashKeys(d, key, he->key)) {
+            if (dictCompareKeys(d, key, he->key)) {

                 /* Unlink the element from the list */
                 if (prevHe)
                     prevHe->next = he->next;
                 else
                     d->ht[table].table[idx] = he->next;
                 if (!nofree) {
                 /* Unlink the element from the list */
                 if (prevHe)
                     prevHe->next = he->next;
                 else
                     d->ht[table].table[idx] = he->next;
                 if (!nofree) {

-                    dictFreeEntryKey(d, he);
-                    dictFreeEntryVal(d, he);
+                    dictFreeKey(d, he);
+                    dictFreeVal(d, he);

                 }
                 zfree(he);
                 d->ht[table].used--;
                 }
                 zfree(he);
                 d->ht[table].used--;


@@ -401,8 +401,8 @@ int _dictClear(dict *d, dictht *ht)
         if ((he = ht->table[i]) == NULL) continue;
         while(he) {
             nextHe = he->next;
         if ((he = ht->table[i]) == NULL) continue;
         while(he) {
             nextHe = he->next;

-            dictFreeEntryKey(d, he);
-            dictFreeEntryVal(d, he);
+            dictFreeKey(d, he);
+            dictFreeVal(d, he);

             zfree(he);
             ht->used--;
             he = nextHe;
             zfree(he);
             ht->used--;
             he = nextHe;


@@ -435,7 +435,7 @@ dictEntry *dictFind(dict *d, const void *key)
         idx = h & d->ht[table].sizemask;
         he = d->ht[table].table[idx];
         while(he) {
         idx = h & d->ht[table].sizemask;
         he = d->ht[table].table[idx];
         while(he) {

-            if (dictCompareHashKeys(d, key, he->key))
+            if (dictCompareKeys(d, key, he->key))

                 return he;
             he = he->next;
         }
                 return he;
             he = he->next;
         }


@@ -448,7 +448,7 @@ void *dictFetchValue(dict *d, const void *key) {
     dictEntry *he;
 
     he = dictFind(d,key);
     dictEntry *he;
 
     he = dictFind(d,key);

-    return he ? dictGetEntryVal(he) : NULL;
+    return he ? dictGetVal(he) : NULL;

 }
 
 dictIterator *dictGetIterator(dict *d)
 }
 
 dictIterator *dictGetIterator(dict *d)


@@ -607,7 +607,7 @@ static int _dictKeyIndex(dict *d, const void *key)
         /* Search if this slot does not already contain the given key */
         he = d->ht[table].table[idx];
         while(he) {
         /* Search if this slot does not already contain the given key */
         he = d->ht[table].table[idx];
         while(he) {

-            if (dictCompareHashKeys(d, key, he->key))
+            if (dictCompareKeys(d, key, he->key))

                 return -1;
             he = he->next;
         }
                 return -1;
             he = he->next;
         }

diff --git a/src/dict.h b/src/dict.h
index 23b1fc52eeb21c79dc013630d26d48eb814e2567..af485e2cdabc9dd2f96f6677e4721be764d6cae3 100644 (file)
--- a/src/dict.h
+++ b/src/dict.h
@@ -94,37 +94,36 @@ typedef struct dictIterator {
 #define DICT_HT_INITIAL_SIZE     4
 
 /* ------------------------------- Macros ------------------------------------*/
 #define DICT_HT_INITIAL_SIZE     4
 
 /* ------------------------------- Macros ------------------------------------*/

-#define dictFreeEntryVal(d, entry) \
+#define dictFreeVal(d, entry) \

     if ((d)->type->valDestructor) \
         (d)->type->valDestructor((d)->privdata, (entry)->v.val)
 
     if ((d)->type->valDestructor) \
         (d)->type->valDestructor((d)->privdata, (entry)->v.val)
 

-#define dictSetHashVal(d, entry, _val_) do { \
+#define dictSetVal(d, entry, _val_) do { \

     if ((d)->type->valDup) \
         entry->v.val = (d)->type->valDup((d)->privdata, _val_); \
     else \
         entry->v.val = (_val_); \
 } while(0)
 
     if ((d)->type->valDup) \
         entry->v.val = (d)->type->valDup((d)->privdata, _val_); \
     else \
         entry->v.val = (_val_); \
 } while(0)
 

-#define dictFreeEntryKey(d, entry) \
+#define dictFreeKey(d, entry) \

     if ((d)->type->keyDestructor) \
         (d)->type->keyDestructor((d)->privdata, (entry)->key)
 
     if ((d)->type->keyDestructor) \
         (d)->type->keyDestructor((d)->privdata, (entry)->key)
 

-#define dictSetHashKey(d, entry, _key_) do { \
+#define dictSetKey(d, entry, _key_) do { \

     if ((d)->type->keyDup) \
         entry->key = (d)->type->keyDup((d)->privdata, _key_); \
     else \
         entry->key = (_key_); \
 } while(0)
 
     if ((d)->type->keyDup) \
         entry->key = (d)->type->keyDup((d)->privdata, _key_); \
     else \
         entry->key = (_key_); \
 } while(0)
 

-#define dictCompareHashKeys(d, key1, key2) \
+#define dictCompareKeys(d, key1, key2) \

     (((d)->type->keyCompare) ? \
         (d)->type->keyCompare((d)->privdata, key1, key2) : \
         (key1) == (key2))
 
 #define dictHashKey(d, key) (d)->type->hashFunction(key)
     (((d)->type->keyCompare) ? \
         (d)->type->keyCompare((d)->privdata, key1, key2) : \
         (key1) == (key2))
 
 #define dictHashKey(d, key) (d)->type->hashFunction(key)

-
-#define dictGetEntryKey(he) ((he)->key)
-#define dictGetEntryVal(he) ((he)->v.val)
+#define dictGetKey(he) ((he)->key)
+#define dictGetVal(he) ((he)->v.val)

 #define dictSlots(d) ((d)->ht[0].size+(d)->ht[1].size)
 #define dictSize(d) ((d)->ht[0].used+(d)->ht[1].used)
 #define dictIsRehashing(ht) ((ht)->rehashidx != -1)
 #define dictSlots(d) ((d)->ht[0].size+(d)->ht[1].size)
 #define dictSize(d) ((d)->ht[0].used+(d)->ht[1].used)
 #define dictIsRehashing(ht) ((ht)->rehashidx != -1)

diff --git a/src/object.c b/src/object.c
index 23462a5b595835b0f0fe45bcee14251aa7a3aacf..fd7786ed6e463a8ec6b1e225857b166a4f307244 100644 (file)
--- a/src/object.c
+++ b/src/object.c
@@ -465,7 +465,7 @@ robj *objectCommandLookup(redisClient *c, robj *key) {
     dictEntry *de;
 
     if ((de = dictFind(c->db->dict,key->ptr)) == NULL) return NULL;
     dictEntry *de;
 
     if ((de = dictFind(c->db->dict,key->ptr)) == NULL) return NULL;

-    return (robj*) dictGetEntryVal(de);
+    return (robj*) dictGetVal(de);

 }
 
 robj *objectCommandLookupOrReply(redisClient *c, robj *key, robj *reply) {
 }
 
 robj *objectCommandLookupOrReply(redisClient *c, robj *key, robj *reply) {

diff --git a/src/pubsub.c b/src/pubsub.c
index af37df5c431f17ad5dcd79daec76f415cd72378d..27e6f9a5819b49cddb4bd4766c9af2fb2e076d6a 100644 (file)
--- a/src/pubsub.c
+++ b/src/pubsub.c
@@ -36,7 +36,7 @@ int pubsubSubscribeChannel(redisClient *c, robj *channel) {
             dictAdd(server.pubsub_channels,channel,clients);
             incrRefCount(channel);
         } else {
             dictAdd(server.pubsub_channels,channel,clients);
             incrRefCount(channel);
         } else {

-            clients = dictGetEntryVal(de);
+            clients = dictGetVal(de);

         }
         listAddNodeTail(clients,c);
     }
         }
         listAddNodeTail(clients,c);
     }


@@ -64,7 +64,7 @@ int pubsubUnsubscribeChannel(redisClient *c, robj *channel, int notify) {
         /* Remove the client from the channel -> clients list hash table */
         de = dictFind(server.pubsub_channels,channel);
         redisAssertWithInfo(c,NULL,de != NULL);
         /* Remove the client from the channel -> clients list hash table */
         de = dictFind(server.pubsub_channels,channel);
         redisAssertWithInfo(c,NULL,de != NULL);

-        clients = dictGetEntryVal(de);
+        clients = dictGetVal(de);

         ln = listSearchKey(clients,c);
         redisAssertWithInfo(c,NULL,ln != NULL);
         listDelNode(clients,ln);
         ln = listSearchKey(clients,c);
         redisAssertWithInfo(c,NULL,ln != NULL);
         listDelNode(clients,ln);


@@ -146,7 +146,7 @@ int pubsubUnsubscribeAllChannels(redisClient *c, int notify) {
     int count = 0;
 
     while((de = dictNext(di)) != NULL) {
     int count = 0;
 
     while((de = dictNext(di)) != NULL) {

-        robj *channel = dictGetEntryKey(de);
+        robj *channel = dictGetKey(de);

 
         count += pubsubUnsubscribeChannel(c,channel,notify);
     }
 
         count += pubsubUnsubscribeChannel(c,channel,notify);
     }


@@ -180,7 +180,7 @@ int pubsubPublishMessage(robj *channel, robj *message) {
     /* Send to clients listening for that channel */
     de = dictFind(server.pubsub_channels,channel);
     if (de) {
     /* Send to clients listening for that channel */
     de = dictFind(server.pubsub_channels,channel);
     if (de) {

-        list *list = dictGetEntryVal(de);
+        list *list = dictGetVal(de);

         listNode *ln;
         listIter li;
 
         listNode *ln;
         listIter li;
 

diff --git a/src/rdb.c b/src/rdb.c
index d2d54807e350792b149cafc97b8f26858224e636..ebd4f88cb45200b7b35b1392b41487d6acba69b6 100644 (file)
--- a/src/rdb.c
+++ b/src/rdb.c
@@ -476,7 +476,7 @@ int rdbSaveObject(rio *rdb, robj *o) {
             nwritten += n;
 
             while((de = dictNext(di)) != NULL) {
             nwritten += n;
 
             while((de = dictNext(di)) != NULL) {

-                robj *eleobj = dictGetEntryKey(de);
+                robj *eleobj = dictGetKey(de);

                 if ((n = rdbSaveStringObject(rdb,eleobj)) == -1) return -1;
                 nwritten += n;
             }
                 if ((n = rdbSaveStringObject(rdb,eleobj)) == -1) return -1;
                 nwritten += n;
             }


@@ -505,8 +505,8 @@ int rdbSaveObject(rio *rdb, robj *o) {
             nwritten += n;
 
             while((de = dictNext(di)) != NULL) {
             nwritten += n;
 
             while((de = dictNext(di)) != NULL) {

-                robj *eleobj = dictGetEntryKey(de);
-                double *score = dictGetEntryVal(de);
+                robj *eleobj = dictGetKey(de);
+                double *score = dictGetVal(de);

 
                 if ((n = rdbSaveStringObject(rdb,eleobj)) == -1) return -1;
                 nwritten += n;
 
                 if ((n = rdbSaveStringObject(rdb,eleobj)) == -1) return -1;
                 nwritten += n;


@@ -532,8 +532,8 @@ int rdbSaveObject(rio *rdb, robj *o) {
             nwritten += n;
 
             while((de = dictNext(di)) != NULL) {
             nwritten += n;
 
             while((de = dictNext(di)) != NULL) {

-                robj *key = dictGetEntryKey(de);
-                robj *val = dictGetEntryVal(de);
+                robj *key = dictGetKey(de);
+                robj *val = dictGetVal(de);

 
                 if ((n = rdbSaveStringObject(rdb,key)) == -1) return -1;
                 nwritten += n;
 
                 if ((n = rdbSaveStringObject(rdb,key)) == -1) return -1;
                 nwritten += n;


@@ -617,8 +617,8 @@ int rdbSave(char *filename) {
 
         /* Iterate this DB writing every entry */
         while((de = dictNext(di)) != NULL) {
 
         /* Iterate this DB writing every entry */
         while((de = dictNext(di)) != NULL) {

-            sds keystr = dictGetEntryKey(de);
-            robj key, *o = dictGetEntryVal(de);
+            sds keystr = dictGetKey(de);
+            robj key, *o = dictGetVal(de);

             time_t expire;
             
             initStaticStringObject(key,keystr);
             time_t expire;
             
             initStaticStringObject(key,keystr);

diff --git a/src/redis.c b/src/redis.c
index 832a9f5926e79d7588be3ff9f9e6220242de87aa..fcc3be182021f8deab66f05b41a767d1702f6485 100644 (file)
--- a/src/redis.c
+++ b/src/redis.c
@@ -563,9 +563,9 @@ void activeExpireCycle(void) {
                 time_t t;
 
                 if ((de = dictGetRandomKey(db->expires)) == NULL) break;
                 time_t t;
 
                 if ((de = dictGetRandomKey(db->expires)) == NULL) break;

-                t = (time_t) dictGetEntryVal(de);
+                t = (time_t) dictGetVal(de);

                 if (now > t) {
                 if (now > t) {

-                    sds key = dictGetEntryKey(de);
+                    sds key = dictGetKey(de);

                     robj *keyobj = createStringObject(key,sdslen(key));
 
                     propagateExpire(db,keyobj);
                     robj *keyobj = createStringObject(key,sdslen(key));
 
                     propagateExpire(db,keyobj);


@@ -1679,7 +1679,7 @@ void freeMemoryIfNeeded(void) {
                 server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_RANDOM)
             {
                 de = dictGetRandomKey(dict);
                 server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_RANDOM)
             {
                 de = dictGetRandomKey(dict);

-                bestkey = dictGetEntryKey(de);
+                bestkey = dictGetKey(de);

             }
 
             /* volatile-lru and allkeys-lru policy */
             }
 
             /* volatile-lru and allkeys-lru policy */


@@ -1692,12 +1692,12 @@ void freeMemoryIfNeeded(void) {
                     robj *o;
 
                     de = dictGetRandomKey(dict);
                     robj *o;
 
                     de = dictGetRandomKey(dict);

-                    thiskey = dictGetEntryKey(de);
+                    thiskey = dictGetKey(de);

                     /* When policy is volatile-lru we need an additonal lookup
                      * to locate the real key, as dict is set to db->expires. */
                     if (server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_LRU)
                         de = dictFind(db->dict, thiskey);
                     /* When policy is volatile-lru we need an additonal lookup
                      * to locate the real key, as dict is set to db->expires. */
                     if (server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_LRU)
                         de = dictFind(db->dict, thiskey);

-                    o = dictGetEntryVal(de);
+                    o = dictGetVal(de);

                     thisval = estimateObjectIdleTime(o);
 
                     /* Higher idle time is better candidate for deletion */
                     thisval = estimateObjectIdleTime(o);
 
                     /* Higher idle time is better candidate for deletion */


@@ -1715,8 +1715,8 @@ void freeMemoryIfNeeded(void) {
                     long thisval;
 
                     de = dictGetRandomKey(dict);
                     long thisval;
 
                     de = dictGetRandomKey(dict);

-                    thiskey = dictGetEntryKey(de);
-                    thisval = (long) dictGetEntryVal(de);
+                    thiskey = dictGetKey(de);
+                    thisval = (long) dictGetVal(de);

 
                     /* Expire sooner (minor expire unix timestamp) is better
                      * candidate for deletion */
 
                     /* Expire sooner (minor expire unix timestamp) is better
                      * candidate for deletion */

diff --git a/src/sort.c b/src/sort.c
index da31b1b538c3d94eef4166571da01afdf4cd3a87..f70810b9baeeef1a66eb4b6500c0f5d25c8e2e17 100644 (file)
--- a/src/sort.c
+++ b/src/sort.c
@@ -238,7 +238,7 @@ void sortCommand(redisClient *c) {
         dictEntry *setele;
         di = dictGetIterator(set);
         while((setele = dictNext(di)) != NULL) {
         dictEntry *setele;
         di = dictGetIterator(set);
         while((setele = dictNext(di)) != NULL) {

-            vector[j].obj = dictGetEntryKey(setele);
+            vector[j].obj = dictGetKey(setele);

             vector[j].u.score = 0;
             vector[j].u.cmpobj = NULL;
             j++;
             vector[j].u.score = 0;
             vector[j].u.cmpobj = NULL;
             j++;

diff --git a/src/t_hash.c b/src/t_hash.c
index 3ccdfd142c81ac9a4328fe1f8fcbfaaf042458ee..eebb66f3638bc395aa42e2352b5fcd01319baf5d 100644 (file)
--- a/src/t_hash.c
+++ b/src/t_hash.c
@@ -55,7 +55,7 @@ int hashTypeGet(robj *o, robj *key, robj **objval, unsigned char **v,
     } else {
         dictEntry *de = dictFind(o->ptr,key);
         if (de == NULL) return -1;
     } else {
         dictEntry *de = dictFind(o->ptr,key);
         if (de == NULL) return -1;

-        *objval = dictGetEntryVal(de);
+        *objval = dictGetVal(de);

     }
     return o->encoding;
 }
     }
     return o->encoding;
 }


@@ -206,9 +206,9 @@ int hashTypeCurrent(hashTypeIterator *hi, int what, robj **objval, unsigned char
         }
     } else {
         if (what & REDIS_HASH_KEY)
         }
     } else {
         if (what & REDIS_HASH_KEY)

-            *objval = dictGetEntryKey(hi->de);
+            *objval = dictGetKey(hi->de);

         else
         else

-            *objval = dictGetEntryVal(hi->de);
+            *objval = dictGetVal(hi->de);

     }
     return hi->encoding;
 }
     }
     return hi->encoding;
 }

diff --git a/src/t_list.c b/src/t_list.c
index c5e3df61490651f0fce92477e93b05e7674c6f1f..21fd1c2f5f333bc0fc9f0f6aa6efb57aa45001c0 100644 (file)
--- a/src/t_list.c
+++ b/src/t_list.c
@@ -776,7 +776,7 @@ void blockForKeys(redisClient *c, robj **keys, int numkeys, time_t timeout, robj
             incrRefCount(keys[j]);
             redisAssertWithInfo(c,keys[j],retval == DICT_OK);
         } else {
             incrRefCount(keys[j]);
             redisAssertWithInfo(c,keys[j],retval == DICT_OK);
         } else {

-            l = dictGetEntryVal(de);
+            l = dictGetVal(de);

         }
         listAddNodeTail(l,c);
     }
         }
         listAddNodeTail(l,c);
     }


@@ -797,7 +797,7 @@ void unblockClientWaitingData(redisClient *c) {
         /* Remove this client from the list of clients waiting for this key. */
         de = dictFind(c->db->blocking_keys,c->bpop.keys[j]);
         redisAssertWithInfo(c,c->bpop.keys[j],de != NULL);
         /* Remove this client from the list of clients waiting for this key. */
         de = dictFind(c->db->blocking_keys,c->bpop.keys[j]);
         redisAssertWithInfo(c,c->bpop.keys[j],de != NULL);

-        l = dictGetEntryVal(de);
+        l = dictGetVal(de);

         listDelNode(l,listSearchKey(l,c));
         /* If the list is empty we need to remove it to avoid wasting memory */
         if (listLength(l) == 0)
         listDelNode(l,listSearchKey(l,c));
         /* If the list is empty we need to remove it to avoid wasting memory */
         if (listLength(l) == 0)


@@ -836,7 +836,7 @@ int handleClientsWaitingListPush(redisClient *c, robj *key, robj *ele) {
 
     de = dictFind(c->db->blocking_keys,key);
     if (de == NULL) return 0;
 
     de = dictFind(c->db->blocking_keys,key);
     if (de == NULL) return 0;

-    clients = dictGetEntryVal(de);
+    clients = dictGetVal(de);

     numclients = listLength(clients);
 
     /* Try to handle the push as long as there are clients waiting for a push.
     numclients = listLength(clients);
 
     /* Try to handle the push as long as there are clients waiting for a push.

diff --git a/src/t_set.c b/src/t_set.c
index db54ffe7af972f6379393fa3449b11ae2ed410a5..3cf1cf005ae7f79d2b919e036d3ceeaf17ce1fc4 100644 (file)
--- a/src/t_set.c
+++ b/src/t_set.c
@@ -115,7 +115,7 @@ int setTypeNext(setTypeIterator *si, robj **objele, int64_t *llele) {
     if (si->encoding == REDIS_ENCODING_HT) {
         dictEntry *de = dictNext(si->di);
         if (de == NULL) return -1;
     if (si->encoding == REDIS_ENCODING_HT) {
         dictEntry *de = dictNext(si->di);
         if (de == NULL) return -1;

-        *objele = dictGetEntryKey(de);
+        *objele = dictGetKey(de);

     } else if (si->encoding == REDIS_ENCODING_INTSET) {
         if (!intsetGet(si->subject->ptr,si->ii++,llele))
             return -1;
     } else if (si->encoding == REDIS_ENCODING_INTSET) {
         if (!intsetGet(si->subject->ptr,si->ii++,llele))
             return -1;


@@ -165,7 +165,7 @@ robj *setTypeNextObject(setTypeIterator *si) {
 int setTypeRandomElement(robj *setobj, robj **objele, int64_t *llele) {
     if (setobj->encoding == REDIS_ENCODING_HT) {
         dictEntry *de = dictGetRandomKey(setobj->ptr);
 int setTypeRandomElement(robj *setobj, robj **objele, int64_t *llele) {
     if (setobj->encoding == REDIS_ENCODING_HT) {
         dictEntry *de = dictGetRandomKey(setobj->ptr);

-        *objele = dictGetEntryKey(de);
+        *objele = dictGetKey(de);

     } else if (setobj->encoding == REDIS_ENCODING_INTSET) {
         *llele = intsetRandom(setobj->ptr);
     } else {
     } else if (setobj->encoding == REDIS_ENCODING_INTSET) {
         *llele = intsetRandom(setobj->ptr);
     } else {

diff --git a/src/t_zset.c b/src/t_zset.c
index 5dab64dc01c2990e736b32984ded1b2861a67215..43fdd48db237fbbdf6d4e463ad9a5fc6e2b52b1f 100644 (file)
--- a/src/t_zset.c
+++ b/src/t_zset.c
@@ -900,8 +900,8 @@ void zaddGenericCommand(redisClient *c, int incr) {
             ele = c->argv[3+j*2] = tryObjectEncoding(c->argv[3+j*2]);
             de = dictFind(zs->dict,ele);
             if (de != NULL) {
             ele = c->argv[3+j*2] = tryObjectEncoding(c->argv[3+j*2]);
             de = dictFind(zs->dict,ele);
             if (de != NULL) {

-                curobj = dictGetEntryKey(de);
-                curscore = *(double*)dictGetEntryVal(de);
+                curobj = dictGetKey(de);
+                curscore = *(double*)dictGetVal(de);

 
                 if (incr) {
                     score += curscore;
 
                 if (incr) {
                     score += curscore;


@@ -921,7 +921,7 @@ void zaddGenericCommand(redisClient *c, int incr) {
                     redisAssertWithInfo(c,curobj,zslDelete(zs->zsl,curscore,curobj));
                     znode = zslInsert(zs->zsl,score,curobj);
                     incrRefCount(curobj); /* Re-inserted in skiplist. */
                     redisAssertWithInfo(c,curobj,zslDelete(zs->zsl,curscore,curobj));
                     znode = zslInsert(zs->zsl,score,curobj);
                     incrRefCount(curobj); /* Re-inserted in skiplist. */

-                    dictGetEntryVal(de) = &znode->score; /* Update score ptr. */
+                    dictGetVal(de) = &znode->score; /* Update score ptr. */

 
                     signalModifiedKey(c->db,key);
                     server.dirty++;
 
                     signalModifiedKey(c->db,key);
                     server.dirty++;


@@ -987,7 +987,7 @@ void zremCommand(redisClient *c) {
                 deleted++;
 
                 /* Delete from the skiplist */
                 deleted++;
 
                 /* Delete from the skiplist */

-                score = *(double*)dictGetEntryVal(de);
+                score = *(double*)dictGetVal(de);

                 redisAssertWithInfo(c,c->argv[j],zslDelete(zs->zsl,score,c->argv[j]));
 
                 /* Delete from the hash table */
                 redisAssertWithInfo(c,c->argv[j],zslDelete(zs->zsl,score,c->argv[j]));
 
                 /* Delete from the hash table */


@@ -1263,7 +1263,7 @@ int zuiNext(zsetopsrc *op, zsetopval *val) {
         } else if (op->encoding == REDIS_ENCODING_HT) {
             if (it->ht.de == NULL)
                 return 0;
         } else if (op->encoding == REDIS_ENCODING_HT) {
             if (it->ht.de == NULL)
                 return 0;

-            val->ele = dictGetEntryKey(it->ht.de);
+            val->ele = dictGetKey(it->ht.de);

             val->score = 1.0;
 
             /* Move to next element. */
             val->score = 1.0;
 
             /* Move to next element. */


@@ -1397,7 +1397,7 @@ int zuiFind(zsetopsrc *op, zsetopval *val, double *score) {
         } else if (op->encoding == REDIS_ENCODING_SKIPLIST) {
             dictEntry *de;
             if ((de = dictFind(it->sl.zs->dict,val->ele)) != NULL) {
         } else if (op->encoding == REDIS_ENCODING_SKIPLIST) {
             dictEntry *de;
             if ((de = dictFind(it->sl.zs->dict,val->ele)) != NULL) {

-                *score = *(double*)dictGetEntryVal(de);
+                *score = *(double*)dictGetVal(de);

                 return 1;
             } else {
                 return 0;
                 return 1;
             } else {
                 return 0;


@@ -1417,7 +1417,7 @@ int zuiCompareByCardinality(const void *s1, const void *s2) {
 #define REDIS_AGGR_SUM 1
 #define REDIS_AGGR_MIN 2
 #define REDIS_AGGR_MAX 3
 #define REDIS_AGGR_SUM 1
 #define REDIS_AGGR_MIN 2
 #define REDIS_AGGR_MAX 3

-#define zunionInterDictValue(_e) (dictGetEntryVal(_e) == NULL ? 1.0 : *(double*)dictGetEntryVal(_e))
+#define zunionInterDictValue(_e) (dictGetVal(_e) == NULL ? 1.0 : *(double*)dictGetVal(_e))

 
 inline static void zunionInterAggregate(double *target, double val, int aggregate) {
     if (aggregate == REDIS_AGGR_SUM) {
 
 inline static void zunionInterAggregate(double *target, double val, int aggregate) {
     if (aggregate == REDIS_AGGR_SUM) {


@@ -2058,7 +2058,7 @@ void zscoreCommand(redisClient *c) {
         c->argv[2] = tryObjectEncoding(c->argv[2]);
         de = dictFind(zs->dict,c->argv[2]);
         if (de != NULL) {
         c->argv[2] = tryObjectEncoding(c->argv[2]);
         de = dictFind(zs->dict,c->argv[2]);
         if (de != NULL) {

-            score = *(double*)dictGetEntryVal(de);
+            score = *(double*)dictGetVal(de);

             addReplyDouble(c,score);
         } else {
             addReply(c,shared.nullbulk);
             addReplyDouble(c,score);
         } else {
             addReply(c,shared.nullbulk);


@@ -2114,7 +2114,7 @@ void zrankGenericCommand(redisClient *c, int reverse) {
         ele = c->argv[2] = tryObjectEncoding(c->argv[2]);
         de = dictFind(zs->dict,ele);
         if (de != NULL) {
         ele = c->argv[2] = tryObjectEncoding(c->argv[2]);
         de = dictFind(zs->dict,ele);
         if (de != NULL) {

-            score = *(double*)dictGetEntryVal(de);
+            score = *(double*)dictGetVal(de);

             rank = zslGetRank(zsl,score,ele);
             redisAssertWithInfo(c,ele,rank); /* Existing elements always have a rank. */
             if (reverse)
             rank = zslGetRank(zsl,score,ele);
             redisAssertWithInfo(c,ele,rank); /* Existing elements always have a rank. */
             if (reverse)