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