此结构在Stream中扮演着存储消息的角色。

//listpack 头部大小为 6 其中total bytes 为4个字节 numelement 为2个字节
#define LP_HDR_SIZE 6
//结束符
#define LP_EOF 0xFF
//设置total值
//p自然是 listpack的指针 而他的前四个字节存储的便是其字节的总数
//所以此处需要将一个四个字节的 int 赋值给四个byte 此处需要注意 存储方式为小端
//因为将低位存储到了 0字节 依次类推
#define lpSetTotalBytes(p,v) do { \
    (p)[0] = (v)&0xff; \
    (p)[1] = ((v)>>8)&0xff; \
    (p)[2] = ((v)>>16)&0xff; \
    (p)[3] = ((v)>>24)&0xff; \
} while(0)
//设置listpack的元素数
//与上方相同 存储为小端
#define lpSetNumElements(p,v) do { \
    (p)[4] = (v)&0xff; \
    (p)[5] = ((v)>>8)&0xff; \
} while(0)
//创建一个listpack
unsigned char *lpNew(void) {
    //声明一个7字节的空间 其中+1 是因为 listpack有个结束符 0xFF占用一个字节
    unsigned char *lp = lp_malloc(LP_HDR_SIZE+1);
    //如果声明失败返回null
    if (lp == NULL) return NULL;
    //设置lp的total bytes初始化数据为 7
    lpSetTotalBytes(lp,LP_HDR_SIZE+1);
    //设置默认element数为 0
    lpSetNumElements(lp,0);
    //设置结束符为 0xFF
    lp[LP_HDR_SIZE] = LP_EOF;
    return lp;
}
//listpack中 entry的最大编码长度为 9
#define LP_MAX_INT_ENCODING_LEN 9
//listpack中 entry长度描述最大为5个字节
#define LP_MAX_BACKLEN_SIZE 5
//前插
#define LP_BEFORE 0
//后插
#define LP_AFTER 1
//替换
#define LP_REPLACE 2
//listpack 插入数据、删除数据、替换数据 根据参数调用来确定
// lp listpack的指针 ele 新数据 size 数据长度 p 如果是插入则此数据为需要插如到的那个数据，如果是删除则为需要删除的数据
// where 需要操作的位置LP_BEFORE（前插） 、 LP_AFTER（后插） 、LP_REPLACE（替换） newp 操作完数据的下一个数据指针
//如果是删除 则ele为NULL
unsigned char *lpInsert(unsigned char *lp, unsigned char *ele, uint32_t size, unsigned char *p, int where, unsigned char **newp) {
    //首先声明当前entry的 需要编码大小 和 长度描述大小 此处backlen用于后往前遍历 所以此处长度只包含 编码长度+数据长度
    unsigned char intenc[LP_MAX_INT_ENCODING_LEN];
    unsigned char backlen[LP_MAX_BACKLEN_SIZE];
    //计算当前编码的长度
    uint64_t enclen;

    //如果ele为null说明需要删除 而此处的删除是将当前p占用的字节替换为空字节
    if (ele == NULL) where = LP_REPLACE;
    //如果是在之后插入 则将其转换为向前插入   这样做少些逻辑代码 值得学习
    if (where == LP_AFTER) {
        //首先跳转到下一个节点
        p = lpSkip(p);
        //设置where为before
        where = LP_BEFORE;
    }

    //计算当前p 在lp的偏移值
    unsigned long poff = p-lp;

    //根据ele 计算需要的编码类型 共 9中类型
    //1、 7 位的无符号整型 加上内容共占 1个字节 结构为 0xxx xxxx x是存储数据的地方 0标示位
    //2、 63长度以下的字符串  结构为 10LL LLLL L是存储字符串长度的地方 10 标识位 后续便是内容
    //3、 13位的有符号整型 加上内容共占 2个字节 结构为 110x xxxx xxxx xxxx x是存储数据的地方 110 标示位
    //4、 4095长度以下 63 长度以上的字符串 结构为 1110  LLLL LLLL LLLL L存储字符串长度的地方 1110 标识位 后续便是L计算出长度大小的内容
    //5、 4294967295 长度以下 4095 长度以上的字符串 结构为 1111 0000 后续四个字节存储 字符串长度 1111 0000 标示位
    //6、 16位整型 结构为 1111 0001 也是为标示位 后续两个字节为 数据值 共 3个字节大小
    //7、 24位整型 结构为 1111 0010 也是为标示位 后续三个字节为 数据值 共 4个字节大小
    //8、 32位整型 结构为 1111 0100 也是为标示位 后续四个字节为 数据值 共 5个字节大小
    //9、 64位整型 结构为 1111 1000 也是为标示位 后续八个字节为 数据值 共 9个字节大小 然而也是已知占用最多的类型所以intenc为9
    int enctype;
    if (ele) {
        //便是使用上方的规则计算当前ele的类型编码 存储到 intenc中 在根据编码的类型和数据获取对应的长度 enclen
        enctype = lpEncodeGetType(ele,size,intenc,&enclen);
    } else {
        //如果为NULL 则设置type为-1 长度为 0
        enctype = -1;
        enclen = 0;
    }

   //计算当前backlen需要占用的大小 根据enclen计算 规则如下
   //1、enclen <= 127  占用 1 个字节
   //2、enclen < 16383 占用 2 个字节
   //3、enclen < 2097151 占用 3 个字节
   //4、enclen < 268435455 占用4个字节
   //5、如果不满足上方的条件则占用五个字节 并且将enclen 写入到backlen中
    unsigned long backlen_size = ele ? lpEncodeBacklen(backlen,enclen) : 0;

    //获取当前的字节数
    uint64_t old_listpack_bytes = lpGetTotalBytes(lp);
    //如果是替换则计算需要需要替换的字节数 即 encoding size + content size + backlen size 便是一个entry的总共大小
    uint32_t replaced_len  = 0;
    if (where == LP_REPLACE) {
        //解析当前p的 encoding size + content size
        replaced_len = lpCurrentEncodedSize(p);
        //根据获取到len 计算下backlen占用的size
        replaced_len += lpEncodeBacklen(NULL,replaced_len);
    }
    //计算一下最新listpack需要的字节数 当前字节数 + 新ele的字节数 - 需要替换元素的字节数
    uint64_t new_listpack_bytes = old_listpack_bytes + enclen + backlen_size
                                  - replaced_len;
    //获取到最新的字节数后 判断当前字节数是否超过了限制 即 4294967295 因为listpack的长度描述 total bytes 是四个字节 无符号的最大数便是4294967295
    //如果超过那么不在执行 返回NULL 因为程序出错
    if (new_listpack_bytes > UINT32_MAX) return NULL;

    //获取需要被替换的目标地址
    unsigned char *dst = lp + poff;

    //如果上方计算的最新大小超过了原有的大小
    if (new_listpack_bytes > old_listpack_bytes) {
        //那么遍进行realloc 重新分配内存空间
        if ((lp = lp_realloc(lp,new_listpack_bytes)) == NULL) return NULL;
        //分配完成后再次计算需要操作的目标位置
        dst = lp + poff;
    }

   //判断当前位置 因为之前将after修改为了before所以此处只有 before和replace
    if (where == LP_BEFORE) {
        //如果是before操作 那么此处将 dst 位置的数据 移动到 dst+enclen+backlen_size的位置
        //这样做变空出了当前ele大小的位置方便后续操作
        memmove(dst+enclen+backlen_size,dst,old_listpack_bytes-poff);
    } else {
        //如果是替换 那么计算当前元素大小和 原先元素大小的差 如果是正数 则往后移 如果是负数则向前移
        long lendiff = (enclen+backlen_size)-replaced_len;
        //dst + replacelen 便是 当前元素的下一个元素地址 然后在加上上方计算的差 这样便计算出 下一个元素需要位移的具体位置
        //然后设置需要位移的元素首地址 再次计算此元素的长度 总长度-当前替换元素的偏移-当前替换元素的大小 便是后面所有元素的占用大小
        memmove(dst+replaced_len+lendiff,
                dst+replaced_len,
                old_listpack_bytes-poff-replaced_len);
    }

    //如果当前listpack的大小小于了原先的大小 则需要丢弃后面空出来的字节
    //因为上方已经进行了插入/替换的操作所以此处尾部的字节数 必然是多余的
    if (new_listpack_bytes < old_listpack_bytes) {
        if ((lp = lp_realloc(lp,new_listpack_bytes)) == NULL) return NULL;
        //根据偏移 再次计算当前元素的首地址  因为上方经过了插入 和 替换所以此处指针一定是新元素的地址
        dst = lp + poff;
    }

    //如果需要回传新元素的地址 则设置为dst
    if (newp) {
        *newp = dst;
        //如果是删除操作并且当前删除的元素是最后一个 那么 不存在新元素所以为NULL
        if (!ele && dst[0] == LP_EOF) *newp = NULL;
    }
    //如果ele不为空 要么是替换 要么是 添加 但是之前都是对原先内存的移动并没有赋值
    //所以此处是将新元素的具体数据赋值到内存中
    if (ele) {
        //如果是整型 那么直接copy即可
        if (enctype == LP_ENCODING_INT) {
            memcpy(dst,intenc,enclen);
        } else {
            //否则需要将字符串编码为指定的encoding 然后在复制
            //此方法的操作是根据size编码为上方的对应类型然后memcpy拷贝到dst中
            lpEncodeString(dst,ele,size);
        }
        //将dst偏移指定的长度
        dst += enclen;
        //将backlen也拷贝进dst中
        memcpy(dst,backlen,backlen_size);
        //dst back的长度
        dst += backlen_size;
    }

    //如果当前操作类型不是replace 或者 ele == null
    //都是需要对元素个数进行操作的 因为不是replace说明是插入 需要 ++ 如果ele为null 说明是删除需要 --
    if (where != LP_REPLACE || ele == NULL) {
        //获取当前元素个数
        uint32_t num_elements = lpGetNumElements(lp);
        //如果当前长度不是65535 即 short的最大值 无符号 那么就对num进行设置
        if (num_elements != LP_HDR_NUMELE_UNKNOWN) {
            if (ele)
                //如果存在ele说明是添加则 +1
                lpSetNumElements(lp,num_elements+1);
            else
                //如果不存在说明是删除则 --
                lpSetNumElements(lp,num_elements-1);
        }
    }

    //将当前最新的bytes大小设置到lp中
    lpSetTotalBytes(lp,new_listpack_bytes);
    //到此处可以总结 下newp 如果是插入或者替换 那么此值为当前p的偏移首地址 如果是删除则为当前p的下一个元素的地址
    return lp;
}
//获取当前listpack的第一个元素
unsigned char *lpFirst(unsigned char *lp) {
    //在listpack的首地址基础上跳过头部 便是第一个元素的首地址
    lp += LP_HDR_SIZE;
    //如果首地址的值是0xff 那么说明list为空 直接返回null
    if (lp[0] == LP_EOF) return NULL;
    //否则返回首地址
    return lp;
}

//获取当前listpack的最后一个元素
unsigned char *lpLast(unsigned char *lp) {
    //根据当前listpack的首地址 加上 当前listpack的总字节数 便超过了当前listpack的内存空间 进行-1 回到EOF 0xff的地址
    unsigned char *p = lp+lpGetTotalBytes(lp)-1;
    //根据最后一个字节向前根据backlen算出前一个字节的长度 根据长度进行 p - backlen 便是最后一个元素的首地址
    return lpPrev(lp,p);
}
//根据当前元素的首地址 计算前一个元素的首地址
unsigned char *lpPrev(unsigned char *lp, unsigned char *p) {
    //如果当前元素的地址 减去 listpack的地址 等于6 说明当前lp为空 则不进行计算
    if (p-lp == LP_HDR_SIZE) return NULL;
    //不为空则跳过当前元素的首地址 到达上一个元素的backlen的位置
    p--;
    //根据backlen向前计算 获取到元素的长度
    uint64_t prevlen = lpDecodeBacklen(p);
    //当前获取到的元素长度是编码的长度+数据长度 还缺少了backlen的长度所以此处根据上方解析出的backlen在计算下backlen的长度
    //从而获取到当前p 到上一个元素长度
    prevlen += lpEncodeBacklen(NULL,prevlen);
    //但是之前为了计算backlen所以p进行了--已经不是原来的那个位置 但是我们计算出的长度是根据原先的位置计算的
    //所以此处需要+1 才是上一个元素的真正位置
    return p-prevlen+1;
}
//如果需要获取下一个元素那么必须需要当前的元素
//lp listpack的指针地址 p 需要查询下个元素的指针地址
unsigned char *lpNext(unsigned char *lp, unsigned char *p) {
    //此处暂时没有使用到了lp 但是在编译是会提示未使用 所以此处使用此方法欺骗编译器
    ((void) lp);
    //next使用的是skip跳过当前p
    p = lpSkip(p);
    //如果跳过的结果是EOF 结束符 那么返回null 否则返回跳过结果
    if (p[0] == LP_EOF) return NULL;
    return p;
}
//跳过当前p 获取到下一个元素的地址
unsigned char *lpSkip(unsigned char *p) {
    //首先计算当前元素占用的长度
    unsigned long entrylen = lpCurrentEncodedSize(p);
    //根据长度计算出back的长度
    entrylen += lpEncodeBacklen(NULL,entrylen);
    //根据计算出的 backlen的长度 + entrylen的长度便是下一个元素的长度
    //所以此处p加上上方的计算结果便可
    p += entrylen;
    return p;
}
//获取当前元素的数据
// p 为元素的首地址 count 如果元素存储的是整型并且复合之前编码的 那么count为返回值 但是此处返回值优势char* 所以需要一个参数做为结果
//inbuff如果想获取到当前整型的buff数据 那么此值为返回值 如果需要inbuff 则count语义改成为写入到inbuff的字节个数
unsigned char *lpGet(unsigned char *p, int64_t *count, unsigned char *intbuf) {
    //如果为整型 此处便是计算 count的临时变量
    int64_t val;
    //uval 根据char计算出的值  negstart存储的值是否为负数根据此值进行判别
    //negmax 如果是负数 需要此值将当前正数计算为负数
    uint64_t uval, negstart, negmax;
    //如果当前是无符号整型 那么直接计算uval即可
    if (LP_ENCODING_IS_7BIT_UINT(p[0])) {
        negstart = UINT64_MAX;
        negmax = 0;
        //当前char & 一个0x7f 便是具体值
        uval = p[0] & 0x7f;
        //如果当前是六位的字符串 那么此处 p +1 就是数据体 因为encoding站1个字节 之前编码有详细说明过
    } else if (LP_ENCODING_IS_6BIT_STR(p[0])) {
        *count = LP_ENCODING_6BIT_STR_LEN(p);
        return p+1;
        //如果当前是13位的有符号整型
    } else if (LP_ENCODING_IS_13BIT_INT(p[0])) {
        //根据&0x1f 获取到高位值 在位移 8位 设置为高位数据 然后 或 | p1 低位值
        uval = ((p[0]&0x1f)<<8) | p[1];
        //他的最大值不能超过的 4096 如果超过那么便是负数
        negstart = (uint64_t)1<<12;
        //计算负数的基数 基数减去 uval -1 便是最终的结果
        negmax = 8191;
        //与13同理
    } else if (LP_ENCODING_IS_16BIT_INT(p[0])) {
        uval = (uint64_t)p[1] |
               (uint64_t)p[2]<<8;
        negstart = (uint64_t)1<<15;
        negmax = UINT16_MAX;
        //如果13同理
    } else if (LP_ENCODING_IS_24BIT_INT(p[0])) {
        uval = (uint64_t)p[1] |
               (uint64_t)p[2]<<8 |
               (uint64_t)p[3]<<16;
        negstart = (uint64_t)1<<23;
        negmax = UINT32_MAX>>8;
        //与13同理
    } else if (LP_ENCODING_IS_32BIT_INT(p[0])) {
        uval = (uint64_t)p[1] |
               (uint64_t)p[2]<<8 |
               (uint64_t)p[3]<<16 |
               (uint64_t)p[4]<<24;
        negstart = (uint64_t)1<<31;
        negmax = UINT32_MAX;
        //与13同理
    } else if (LP_ENCODING_IS_64BIT_INT(p[0])) {
        uval = (uint64_t)p[1] |
               (uint64_t)p[2]<<8 |
               (uint64_t)p[3]<<16 |
               (uint64_t)p[4]<<24 |
               (uint64_t)p[5]<<32 |
               (uint64_t)p[6]<<40 |
               (uint64_t)p[7]<<48 |
               (uint64_t)p[8]<<56;
        negstart = (uint64_t)1<<63;
        negmax = UINT64_MAX;
        //如果是12位的字符串 那么需要p+2 encoding长度为 2
    } else if (LP_ENCODING_IS_12BIT_STR(p[0])) {
        *count = LP_ENCODING_12BIT_STR_LEN(p);
        return p+2;
        //如果是32位的字符串 那么需要p+5 encoding长度为 5
    } else if (LP_ENCODING_IS_32BIT_STR(p[0])) {
        *count = LP_ENCODING_32BIT_STR_LEN(p);
        return p+5;
    } else {
        //如果都不是那么设置默认值 方便调试
        uval = 12345678900000000ULL + p[0];
        negstart = UINT64_MAX;
        negmax = 0;
    }

    //如果当前值超过了限定的值 则说明 到达了负数
    if (uval >= negstart) {
        //之前设置的基数 减去当前值
        uval = negmax-uval;
        val = uval;
        //取反-1 就是当时存储的具体值
        val = -val-1;
    } else {
        //否则将读出的数据存储到val中
        val = uval;
    }

    //如果需要字符串的buff那么snpringf存储进去
    if (intbuf) {
        //此时count为写入到inbuff中的字节长度
        *count = snprintf((char*)intbuf,LP_INTBUF_SIZE,"%lld",(long long)val);
        //然后返回intbuff
        return intbuf;
    } else {
        //否则设置count 此为具体value的值
        *count = val;
        return NULL;
    }
}
//追加元素 其实就是添加最后一个元素
//lp listpack 指针 ele 当前元素的指针 size 当前元素的大小
unsigned char *lpAppend(unsigned char *lp, unsigned char *ele, uint32_t size) {
    //首先获取当前元素的占用字节数
    uint64_t listpack_bytes = lpGetTotalBytes(lp);
    //当前lp首地址加上字节数 减去 1 就是 eof的地址
    unsigned char *eofptr = lp + listpack_bytes - 1;
    //只要在调用insert的时候 指定位before 设置需要插入的元素为eof便为append
    return lpInsert(lp,ele,size,eofptr,LP_BEFORE,NULL);
}
//元素的删除 之前在insert中讲解过 lp listpack 指针 p 元素指针 newp如果需要删除元素的下一个指针则不为空
unsigned char *lpDelete(unsigned char *lp, unsigned char *p, unsigned char **newp) {
    //设置插入值为NULL 类型为REPLACE 便是删除
    return lpInsert(lp,NULL,0,p,LP_REPLACE,newp);
}