-h is now alias for --help when running redis-server.

[redis.git] / src / dict.c

diff --git a/src/dict.c b/src/dict.c
index 24001fdd0a520098eaecdc00bc893d2761968a40..a573bcd6e3575477f1e58c67811b46122972de88 100644 (file)
--- a/src/dict.c
+++ b/src/dict.c
@@ -258,6 +258,30 @@ static void _dictRehashStep(dict *d) {
 
 /* Add an element to the target hash table */
 int dictAdd(dict *d, void *key, void *val)
 
 /* Add an element to the target hash table */
 int dictAdd(dict *d, void *key, void *val)

+{
+    dictEntry *entry = dictAddRaw(d,key);
+
+    if (!entry) return DICT_ERR;
+    dictSetVal(d, entry, val);
+    return DICT_OK;
+}
+
+/* Low level add. This function adds the entry but instead of setting
+ * a value returns the dictEntry structure to the user, that will make
+ * sure to fill the value field as he wishes.
+ *
+ * This function is also directly expoed to user API to be called
+ * mainly in order to store non-pointers inside the hash value, example:
+ *
+ * entry = dictAddRaw(dict,mykey);
+ * if (entry != NULL) dictSetSignedIntegerVal(entry,1000);
+ *
+ * Return values:
+ *
+ * If key already exists NULL is returned.
+ * If key was added, the hash entry is returned to be manipulated by the caller.
+ */
+dictEntry *dictAddRaw(dict *d, void *key)

 {
     int index;
     dictEntry *entry;
 {
     int index;
     dictEntry *entry;


@@ -268,9 +292,9 @@ int dictAdd(dict *d, void *key, void *val)
     /* Get the index of the new element, or -1 if
      * the element already exists. */
     if ((index = _dictKeyIndex(d, key)) == -1)
     /* Get the index of the new element, or -1 if
      * the element already exists. */
     if ((index = _dictKeyIndex(d, key)) == -1)

-        return DICT_ERR;
+        return NULL;

 
 

-    /* Allocates the memory and stores key */
+    /* Allocate the memory and store the new entry */

     ht = dictIsRehashing(d) ? &d->ht[1] : &d->ht[0];
     entry = zmalloc(sizeof(*entry));
     entry->next = ht->table[index];
     ht = dictIsRehashing(d) ? &d->ht[1] : &d->ht[0];
     entry = zmalloc(sizeof(*entry));
     entry->next = ht->table[index];


@@ -278,9 +302,8 @@ int dictAdd(dict *d, void *key, void *val)
     ht->used++;
 
     /* Set the hash entry fields. */
     ht->used++;
 
     /* Set the hash entry fields. */

-    dictSetHashKey(d, entry, key);
-    dictSetHashVal(d, entry, val);
-    return DICT_OK;
+    dictSetKey(d, entry, key);
+    return entry;

 }
 
 /* Add an element, discarding the old if the key already exists.
 }
 
 /* Add an element, discarding the old if the key already exists.


@@ -297,18 +320,29 @@ int dictReplace(dict *d, void *key, void *val)
         return 1;
     /* It already exists, get the entry */
     entry = dictFind(d, key);
         return 1;
     /* It already exists, get the entry */
     entry = dictFind(d, key);

-    /* Free the old value and set the new one */

     /* Set the new value and free the old one. Note that it is important
      * to do that in this order, as the value may just be exactly the same
      * as the previous one. In this context, think to reference counting,
      * you want to increment (set), and then decrement (free), and not the
      * reverse. */
     auxentry = *entry;
     /* Set the new value and free the old one. Note that it is important
      * to do that in this order, as the value may just be exactly the same
      * as the previous one. In this context, think to reference counting,
      * 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;
 }
 

+/* dictReplaceRaw() is simply a version of dictAddRaw() that always
+ * returns the hash entry of the specified key, even if the key already
+ * exists and can't be added (in that case the entry of the already
+ * existing key is returned.)
+ *
+ * See dictAddRaw() for more information. */
+dictEntry *dictReplaceRaw(dict *d, void *key) {
+    dictEntry *entry = dictFind(d,key);
+
+    return entry ? entry : dictAddRaw(d,key);
+}
+

 /* Search and remove an element */
 static int dictGenericDelete(dict *d, const void *key, int nofree)
 {
 /* Search and remove an element */
 static int dictGenericDelete(dict *d, const void *key, int nofree)
 {


@@ -325,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--;


@@ -367,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;


@@ -401,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;
         }


@@ -414,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)


@@ -573,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;
         }