1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

											
											

												
													
														typedef
													 struct
													 dictEntry
													 {
													
    void
													 *
													key
													;
													
    union
													 {
													
        void
													 *
													val
													;
													
        uint64_t
													 u64
													;
													
        int64_t
													 s64
													;
													
        double
													 d
													;
													
    }
													 v
													;
													
    struct
													 dictEntry
													 *
													next
													;
													
}
													 dictEntry
													;
													

typedef
													 struct
													 dictType
													 {
													
    unsigned
													 int
													 (
													*
													hashFunction
													)(
													const
													 void
													 *
													key
													);
													
    void
													 *
													(
													*
													keyDup
													)(
													void
													 *
													privdata
													,
													 const
													 void
													 *
													key
													);
													
    void
													 *
													(
													*
													valDup
													)(
													void
													 *
													privdata
													,
													 const
													 void
													 *
													obj
													);
													
    int
													 (
													*
													keyCompare
													)(
													void
													 *
													privdata
													,
													 const
													 void
													 *
													key1
													,
													 const
													 void
													 *
													key2
													);
													
    void
													 (
													*
													keyDestructor
													)(
													void
													 *
													privdata
													,
													 void
													 *
													key
													);
													
    void
													 (
													*
													valDestructor
													)(
													void
													 *
													privdata
													,
													 void
													 *
													obj
													);
													
}
													 dictType
													;
													

/* This is our hash table structure. Every dictionary has two of this as we
 * implement incremental rehashing99WIN, for the old to the new table. */
typedef
													 struct
													 dictht
													 {
													
    dictEntry
													 **
													table
													;
													
    unsigned
													 long
													 size
													;
													
    unsigned
													 long
													 sizemask
													;
													
    unsigned
													 long
													 used
													;
													
}
													 dictht
													;
													

typedef
													 struct
													 dict
													 {
													
    dictType
													 *
													type
													;
													
    void
													 *
													privdata
													;
													
    dictht
													 ht
													[
													2
													];
													
    long
													 rehashidx
													;
													 /* rehashing not in progress if rehashidx == -1 */
													
    int
													 iterators
													;
													 /* number of iterators currently running */
													
}
													 dict
													;
													

											
										
									
								
							

							
								

									

										

											

												
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

											
											

												
													
														dict
													 *
													dictCreate
													(
													dictType
													 *
													type
													,
													
        void
													 *
													privDataPtr
													)
													
{
													
    dict
													 *
													d
													 =
													 zmalloc
													(
													sizeof
													(
													*
													d
													));
													

    _dictInit
													(
													d
													,
													type
													,
													privDataPtr
													);
													
    return
													 d
													;
													
}
													

int
													 _dictInit
													(
													dict
													 *
													d
													,
													 dictType
													 *
													type
													,
													
        void
													 *
													privDataPtr
													)
													
{
													
    _dictReset
													(
													&
													d
													->
													ht
													[
													0
													]);
													
    _dictReset
													(
													&
													d
													->
													ht
													[
													1
													]);
													
    d
													->
													type
													 =
													 type
													;
													
    d
													->
													privdata
													 =
													 privDataPtr
													;
													
    d
													->
													rehashidx
													 =
													 -
													1
													;
													
    d
													->
													iterators
													 =
													 0
													;
													
    return
													 DICT_OK
													;
													
}
													

static
													 void
													 _dictReset
													(
													dictht
													 *
													ht
													)
													
{
													
    ht
													->
													table
													 =
													 NULL
													;
													
    ht
													->
													size
													 =
													 0
													;
													
    ht
													->
													sizemask
													 =
													 0
													;
													
    ht
													->
													used
													 =
													 0
													;
													
}
													

											
										
									
								
							

							
								

									

										

											

												
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

											
											

												
													
														#define dictIsRehashing(d) ((d)->rehashidx != -1)

													
dictEntry
													 *
													dictFind
													(
													dict
													 *
													d
													,
													 const
													 void
													 *
													key
													)
													
{
													
    dictEntry
													 *
													he
													;
													
    unsigned
													 int
													 h
													,
													 idx
													,
													 table
													;
													

    if
													 (
													d
													->
													ht
													[
													0
													].
													used
													 +
													 d
													->
													ht
													[
													1
													].
													used
													 ==
													 0
													)
													 return
													 NULL
													;
													 /* dict is empty */
													
    if
													 (
													dictIsRehashing
													(
													d
													))
													 _dictRehashStep
													(
													d
													);
													
    h
													 =
													 dictHashKey
													(
													d
													,
													 key
													);
													
    for
													 (
													table
													 =
													 0
													;
													 table
													 <=
													 1
													;
													 table
													++
													)
													 {
													
        idx
													 =
													 h
													 &
													 d
													->
													ht
													[
													table
													].
													sizemask
													;
													
        he
													 =
													 d
													->
													ht
													[
													table
													].
													table
													[
													idx
													];
													
        while
													(
													he
													)
													 {
													
            if
													 (
													key
													==
													he
													->
													key
													 ||
													 dictCompareKeys
													(
													d
													,
													 key
													,
													 he
													->
													key
													))
													
                return
													 he
													;
													
            he
													 =
													 he
													->
													next
													;
													
        }
													
        if
													 (
													!
													dictIsRehashing
													(
													d
													))
													 return
													 NULL
													;
													
    }
													
    return
													 NULL
													;
													
}
													

											
										
									
								
							

							
								

									

										

											

												
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

											
											

												
													
														static
													 void
													 _dictRehashStep
													(
													dict
													 *
													d
													)
													 {
													
    if
													 (
													d
													->
													iterators
													 ==
													 0
													)
													 dictRehash
													(
													d
													,
													1
													);
													
}
													

int
													 dictRehash
													(
													dict
													 *
													d
													,
													 int
													 n
													)
													 {
													
    int
													 empty_visits
													 =
													 n
													*
													10
													;
													 /* Max number of empty buckets to visit. */
													
    if
													 (
													!
													dictIsRehashing
													(
													d
													))
													 return
													 0
													;
													

    while
													(
													n
													--
													 &&
													 d
													->
													ht
													[
													0
													].
													used
													 !=
													 0
													)
													 {
													
        dictEntry
													 *
													de
													,
													 *
													nextde
													;
													

        /* Note that rehashidx can't overflow as we are sure there are more
         * elements because ht[0].used != 0 */
													
        assert
													(
													d
													->
													ht
													[
													0
													].
													size
													 >
													 (
													unsigned
													 long
													)
													d
													->
													rehashidx
													);
													
        while
													(
													d
													->
													ht
													[
													0
													].
													table
													[
													d
													->
													rehashidx
													]
													 ==
													 NULL
													)
													 {
													
            d
													->
													rehashidx
													++
													;
													
            if
													 (
													--
													empty_visits
													 ==
													 0
													)
													 return
													 1
													;
													
        }
													
        de
													 =
													 d
													->
													ht
													[
													0
													].
													table
													[
													d
													->
													rehashidx
													];
													
        /* Move all the keys in this bucket from the old to the new hash HT */
													
        while
													(
													de
													)
													 {
													
            unsigned
													 int
													 h
													;
													

            nextde
													 =
													 de
													->
													next
													;
													
            /* Get the index in the new hash table */
													
            h
													 =
													 dictHashKey
													(
													d
													,
													 de
													->
													key
													)
													 &
													 d
													->
													ht
													[
													1
													].
													sizemask
													;
													
            de
													->
													next
													 =
													 d
													->
													ht
													[
													1
													].
													table
													[
													h
													];
													
            d
													->
													ht
													[
													1
													].
													table
													[
													h
													]
													 =
													 de
													;
													
            d
													->
													ht
													[
													0
													].
													used
													--
													;
													
            d
													->
													ht
													[
													1
													].
													used
													++
													;
													
            de
													 =
													 nextde
													;
													
        }
													
        d
													->
													ht
													[
													0
													].
													table
													[
													d
													->
													rehashidx
													]
													 =
													 NULL
													;
													
        d
													->
													rehashidx
													++
													;
													
    }
													

    /* Check if we already rehashed the whole table... */
													
    if
													 (
													d
													->
													ht
													[
													0
													].
													used
													 ==
													 0
													)
													 {
													
        zfree
													(
													d
													->
													ht
													[
													0
													].
													table
													);
													
        d
													->
													ht
													[
													0
													]
													 =
													 d
													->
													ht
													[
													1
													];
													
        _dictReset
													(
													&
													d
													->
													ht
													[
													1
													]);
													
        d
													->
													rehashidx
													 =
													 -
													1
													;
													
        return
													 0
													;
													
    }
													

    /* More to rehash... */
													
    return
													 1
													;
													
}
													

											
										
									
								
							

							
								

									

										

											

												
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

											
											

												
													
														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
													;
													
}
													

dictEntry
													 *
													dictAddRaw
													(
													dict
													 *
													d
													,
													 void
													 *
													key
													)
													
{
													
    int
													 index
													;
													
    dictEntry
													 *
													entry
													;
													
    dictht
													 *
													ht
													;
													

    if
													 (
													dictIsRehashing
													(
													d
													))
													 _dictRehashStep
													(
													d
													);
													

    /* Get the index of the new elementđá gà trực tiếp app, or -1 if
     * the element already exists. */
    if
													 ((
													index
													 =
													 _dictKeyIndex
													(
													d
													,
													 key
													))
													 ==
													 -
													1
													)
													
        return
													 NULL
													;
													

    /* Allocate the memory and store the new entry.
     * Insert the element in top99WIN, with the assumption that in a database
     * system it is more likely that recently added entries are accessed
     * more frequently. */
    ht
													 =
													 dictIsRehashing
													(
													d
													)
													 ?
													 &
													d
													->
													ht
													[
													1
													]
													 :
													 &
													d
													->
													ht
													[
													0
													];
													
    entry
													 =
													 zmalloc
													(
													sizeof
													(
													*
													entry
													));
													
    entry
													->
													next
													 =
													 ht
													->
													table
													[
													index
													];
													
    ht
													->
													table
													[
													index
													]
													 =
													 entry
													;
													
    ht
													->
													used
													++
													;
													

    /* Set the hash entry fields. */
													
    dictSetKey
													(
													d
													,
													 entry
													,
													 key
													);
													
    return
													 entry
													;
													
}
													

static
													 int
													 _dictKeyIndex
													(
													dict
													 *
													d
													,
													 const
													 void
													 *
													key
													)
													
{
													
    unsigned
													 int
													 h
													,
													 idx
													,
													 table
													;
													
    dictEntry
													 *
													he
													;
													

    /* Expand the hash table if needed */
													
    if
													 (
													_dictExpandIfNeeded
													(
													d
													)
													 ==
													 DICT_ERR
													)
													
        return
													 -
													1
													;
													
    /* Compute the key hash value */
													
    h
													 =
													 dictHashKey
													(
													d
													,
													 key
													);
													
    for
													 (
													table
													 =
													 0
													;
													 table
													 <=
													 1
													;
													 table
													++
													)
													 {
													
        idx
													 =
													 h
													 &
													 d
													->
													ht
													[
													table
													].
													sizemask
													;
													
        /* Search if this slot does not already contain the given key */
													
        he
													 =
													 d
													->
													ht
													[
													table
													].
													table
													[
													idx
													];
													
        while
													(
													he
													)
													 {
													
            if
													 (
													key
													==
													he
													->
													key
													 ||
													 dictCompareKeys
													(
													d
													,
													 key
													,
													 he
													->
													key
													))
													
                return
													 -
													1
													;
													
            he
													 =
													 he
													->
													next
													;
													
        }
													
        if
													 (
													!
													dictIsRehashing
													(
													d
													))
													 break
													;
													
    }
													
    return
													 idx
													;
													
}
													

											
										
									
								
							

							
								

									

										

											

												
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

											
											

												
													
														int
													 dictReplace
													(
													dict
													 *
													d
													,
													 void
													 *
													key
													,
													 void
													 *
													val
													)
													
{
													
    dictEntry
													 *
													entry
													,
													 auxentry
													;
													

    /* Try to add the element. If the key
     * does not exists dictAdd will suceed. */
													
    if
													 (
													dictAdd
													(
													d
													,
													 key
													,
													 val
													)
													 ==
													 DICT_OK
													)
													
        return
													 1
													;
													
    /* It already exists99WIN, get the entry */
    entry
													 =
													 dictFind
													(
													d
													,
													 key
													);
													
    /* Set the new value and free the old one. Note that it is important
     * to do that in this order99WIN, 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
													;
													
    dictSetVal
													(
													d
													,
													 entry
													,
													 val
													);
													
    dictFreeVal
													(
													d
													,
													 &
													auxentry
													);
													
    return
													 0
													;
													
}