LevelDB源码分析之一：coding

LevelDB默认使用的是小端字节序存储，低位字节排放在内存的低地址端，高位字节排放在内存的高地址端。 
编码分为变长的EncodeVarint和固定大小的EncodeFixed两种，每种又分32位和64位。
一.EncodeFixed

void EncodeFixed32(char* buf, uint32_t value) {#if __BYTE_ORDER == __LITTLE_ENDIAN  memcpy(buf, &value, sizeof(value));#else  buf[0] = value & 0xff;  buf[1] = (value >> 8) & 0xff;  buf[2] = (value >> 16) & 0xff;  buf[3] = (value >> 24) & 0xff;#endif}

void EncodeFixed64(char* buf, uint64_t value) {#if __BYTE_ORDER == __LITTLE_ENDIAN  memcpy(buf, &value, sizeof(value));#else  buf[0] = value & 0xff;  buf[1] = (value >> 8) & 0xff;  buf[2] = (value >> 16) & 0xff;  buf[3] = (value >> 24) & 0xff;  buf[4] = (value >> 32) & 0xff;  buf[5] = (value >> 40) & 0xff;  buf[6] = (value >> 48) & 0xff;  buf[7] = (value >> 56) & 0xff;#endif}

这两个函数非常简单，功能就是判断系统是否为小端存储，如果是，直接将value拷贝到buf，如果不是，则将value转换为小端字节序存储到buf中。
解码函数DecodeFixed32和DecodeFixed64是编码的逆过程，也很简单。
二.EncodeVarint
为什么要把整型（int）编码成变长整型（varint）呢？是为了尽可能的节约存储空间。
varint是一种紧凑的表示数字的方法，它用一个或多个字节来表示一个数字，值越小的数字使用越少的字节数。比如int32类型的数字，一般需要4个字节。但是采用Varint，对于很小的int32类型的数字，则可以用1个字节来表示。当然凡事都有好的也有不好的一面，采用varint表示法，大的数字则可能需要5个字节来表示。从统计的角度来说，一般不会所有消息中的数字都是大数，因此大多数情况下，采用varint后，可以用更小的字节数来表示数字信息。
varint中的每个字节的最高位（bit）有特殊含义，如果该位为1，表示后续的字节也是这个数字的一部分，如果该位为0，则结束。其他的7位（bit）都表示数字。7位能表示的最大数是127，因此小于128的数字都可以用一个字节表示。大于等于128的数字，比如说300，会用两个字节在内存中表示为：
低               高
1010 1100 0000 0010
实现过程如下：
300的二进制为100101100，取低7位也就是010 1100放在内存低字节中，由于第二个字节也是数字的一部分，因此内存低字节的最高位为1，则完整的内存低字节为1010 1100。300的高2位也就是10放到内存的高字节中，因为数字到该字节结束，因此该字节包括最高位的其他6位都用0填充，则完整的内存高字节为0000 0010。
正常情况下，int需要32位，varint用一个字节的最高位作为标识位，所以，一个字节只能存储7位，如果整数特别大，可能需要5个字节才能存放（5*8-5（标志位）>32），下面if语句的第五个分支就是处理这种情况。

char* EncodeVarint32(char* dst, uint32_t v) {  // Operate on characters as unsigneds  unsigned char* ptr = reinterpret_cast<unsigned char*>(dst);  static const int B = 128;  if (v < (1<<7)) {               //如果v小于128    *(ptr++) = v;  } else if (v < (1<<14)) {       //如果v小于16384，假如v=300（0000 0001 0010 1100），先和128（0000 0000 1000 0000）按位或，得到0000 0001 1010 1100，把低8位（1010 1100）给内存低字节。    *(ptr++) = v | B;    *(ptr++) = v>>7;              //把300（0000 0001 0010 1100）右移7位得到000 0000 0000 0001 0，给内存高字节。  } else if (v < (1<<21)) {    *(ptr++) = v | B;    *(ptr++) = (v>>7) | B;    *(ptr++) = v>>14;  } else if (v < (1<<28)) {    *(ptr++) = v | B;    *(ptr++) = (v>>7) | B;    *(ptr++) = (v>>14) | B;    *(ptr++) = v>>21;  } else {    *(ptr++) = v | B;    *(ptr++) = (v>>7) | B;    *(ptr++) = (v>>14) | B;    *(ptr++) = (v>>21) | B;    *(ptr++) = v>>28;  }  return reinterpret_cast<char*>(ptr);}

对于64位整型，我们最多需要10个字节（10*8-10（标志位）>64），如果像EncodeVarint32一样写代码，需要有10个if分支，大牛肯定没这么勤快。其实EncodeVarint32也可以像EncodeVarint64这么写。

char* EncodeVarint64(char* dst, uint64_t v) {  static const int B = 128;  unsigned char* ptr = reinterpret_cast<unsigned char*>(dst);  while (v >= B) {    *(ptr++) = (v & (B-1)) | B;    v >>= 7;  }  *(ptr++) = static_cast<unsigned char>(v);  return reinterpret_cast<char*>(ptr);}

下面的函数是计算整型编码后的长度，也就是varint的长度。

int VarintLength(uint64_t v) {  int len = 1;  while (v >= 128) {    v >>= 7;    len++;  }  return len;}

三.varint解码

解了编码的原理，再来看解码就很轻松了，直接调用GetVarint32Ptr函数，该函数处理value < 128的情况，即varint只占一个字节的情况，对于varint 大于一个字节的情况，GetVarint32Ptr调用GetVarint32PtrFallback来处理。

inline const char* GetVarint32Ptr(const char* p,                                  const char* limit,                                  uint32_t* value) {  if (p < limit) {    uint32_t result = *(reinterpret_cast<const unsigned char*>(p));    if ((result & 128) == 0) {      *value = result;      return p + 1;    }  }  return GetVarint32PtrFallback(p, limit, value);}

在GetVarint32Ptr和GetVarint32PtrFallback函数中，参数p是指向一个包含varint的字符串，limit在调用的时候都是赋值为limit= p + 5, 这是因为varint最多占用5个字节。value用于存储返回的int值。

const char* GetVarint32PtrFallback(const char* p,                                   const char* limit,                                   uint32_t* value) {  uint32_t result = 0;  for (uint32_t shift = 0; shift <= 28 && p < limit; shift += 7) {    uint32_t byte = *(reinterpret_cast<const unsigned char*>(p));    p++;    if (byte & 128) {      // More bytes are present      result |= ((byte & 127) << shift);    } else {      result |= (byte << shift);      *value = result;      return reinterpret_cast<const char*>(p);    }  }  return NULL;}

64位的解码与32位的类似。

参考链接：http://www.360doc.com/content/17/1218/10/51031951_714135151.shtml