1
typedef struct sdstr{
2
  int   len     // 字符串分配的字节
3
  int   free    // 未使用的字节数
4
  char  buff[]  // 存储字符串的数组
5
}

1
{
2
  len:5,
3
  free:0,
4
  buff:['h','e','l','l','o','\0']
5
}

1
{
2
  len:11,
3
  free:11,
4
  buff:['h','e','l','l','o',',','r','e','d','i','s','\0']
5
}

1
{
2
  len:5,      // 字符串长度
3
  free:17,    // 原本11,加上释放到的6个字节
4
  buff:['r','e','d','i','s','\0']
5
}

1
//链表
2
typedef struct list{
3
  listNode * head;    //头节点
4
  listNode * tail;  //尾节点
5
  unsigned long len;   //节点数量
6
  void *(*dup)(void *ptr);  //节点值复制函数
7
  void (*free)(void *ptr);   //节点值释放函数
8
  void (*match)(void *ptr,void *key);  //节点值对比函数
9
}
10

11
//链表节点
12
typedef struct listNode{
13
  struct listNode *pre;
14
  struct listNode *next;
15
  void *value;
16
}listNode;

1
{
2
    list: {
3
        head: {
4
            pre: null,
5
            next: 2,
6
            value: 1
7
        },
8
        tail: {
9
            pre: 99,
10
            next: null,
11
            value: 100
12
        },
13
        len: 100,
14
        dup:function () {},
15
        free:function () {},
16
        match:function () {}
17
    }
18
}

1
typedef struct quicklistEntry {
2
    const quicklist *quicklist;
3
    quicklistNode *node;
4
    unsigned char *zi;
5
    unsigned char *value;
6
    long long longval;
7
    unsigned int sz;
8
    int offset;
9
} quicklistEntry;
10

11
/* quicklist is a 32 byte struct (on 64-bit systems) describing a quicklist.
12
 * 'count' is the number of total entries.
13
 * 'len' is the number of quicklist nodes.
14
 * 'compress' is: -1 if compression disabled, otherwise it's the number
15
 *                of quicklistNodes to leave uncompressed at ends of quicklist.
16
 * 'fill' is the user-requested (or default) fill factor. */
17
typedef struct quicklist {
18
    quicklistNode *head;
19
    quicklistNode *tail;
20
    unsigned long count;        /* total count of all entries in all ziplists */
21
    unsigned int len;           /* number of quicklistNodes */
22
    int fill : 16;              /* fill factor for individual nodes */
23
    unsigned int compress : 16; /* depth of end nodes not to compress;0=off */
24
} quicklist;
25

26
/* quicklistNode is a 32 byte struct describing a ziplist for a quicklist.
27
 * We use bit fields keep the quicklistNode at 32 bytes.
28
 * count: 16 bits, max 65536 (max zl bytes is 65k, so max count actually < 32k).
29
 * encoding: 2 bits, RAW=1, LZF=2.
30
 * container: 2 bits, NONE=1, ZIPLIST=2.
31
 * recompress: 1 bit, bool, true if node is temporarry decompressed for usage.
32
 * attempted_compress: 1 bit, boolean, used for verifying during testing.
33
 * extra: 12 bits, free for future use; pads out the remainder of 32 bits */
34
typedef struct quicklistNode {
35
    struct quicklistNode *prev;
36
    struct quicklistNode *next;
37
    unsigned char *zl;
38
    unsigned int sz;             /* ziplist size in bytes */
39
    unsigned int count : 16;     /* count of items in ziplist */
40
    unsigned int encoding : 2;   /* RAW==1 or LZF==2 */
41
    unsigned int container : 2;  /* NONE==1 or ZIPLIST==2 */
42
    unsigned int recompress : 1; /* was this node previous compressed? */
43
    unsigned int attempted_compress : 1; /* node can't compress; too small */
44
    unsigned int extra : 10; /* more bits to steal for future usage */
45
} quicklistNode;

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

9
/* This is our hash table structure. Every dictionary has two of this as we
10
 * implement incremental rehashing, for the old to the new table. */
11
typedef struct dictht {
12
    dictEntry **table;
13
    unsigned long size;
14
    unsigned long sizemask;
15
    unsigned long used;
16
} dictht;
17

18
typedef struct dictEntry {
19
    void *key;
20
    union {
21
        void *val;
22
        uint64_t u64;
23
        int64_t s64;
24
        double d;
25
    } v;
26
    struct dictEntry *next;
27
} dictEntry;

1
{
2
    dict: {
3
        type: hash,
4
        privadata: null,
5
        ht: [{
6
                size: 100,
7
                used: 80,
8
                sizemask: "0xff778",
9
                hash: {
10
                    key: "test1",
11
                    value: 22,
12
                    next: 34
13
                }
14
            },
15
            {}  // rehash时候使用
16
        ],
17
        rehashidx: -1
18
    }
19
}

1
//跳跃表
2
typedef struct zskiplist{
3
    struct zskiplistNode *header,*tail;//头结点和尾节点
4
    unsigned long length;//表中节点数量
5
    int level;//表中除头节点外层数最大的节点
6
} zskiplist;
7

8
//跳跃表节点
9
typedef struct zskiplistNode {
10
    //层
11
    struct zskiplevel{
12
        struct zskiplistNode *forward;//前进指针
13
        unsigned int span;//跨度
14
    } level[];
15
    struct zskiplistNode *backword;//后退指针
16
    double score;//分值
17
    robj *obj;
18
} zskiplistNode;

1
{
2
    zskiplist: {
3
        header: {
4
            obj: "aa",
5
            score: 45,
6
            backforward: null,
7
            zskiplevel: [{
8
                forward: null,
9
                span: 9
10
            },{
11
                forward: *p,
12
                span: 8
13
            }]
14
        },
15
        tail: {
16
            obj: "aa",
17
            score: 45,
18
            backforward: null,
19
            zskiplevel: [{
20
                forward: null,
21
                span: 9
22
            }]
23
        },
24
        length: 100,
25
        level: 32
26
    }
27
}

1
typedef struct intset {
2
    uint32_t encoding;
3
    uint32_t length;
4
    int8_t contents[];
5
} intset;