muduo的日志库分析一之LogStream

muduo日志库是C++ stream风格，这样用起来更自然，不必费心保持格式字符串和参数类型的一致性，可以随用随写，而且是类型安全的。

stream风格的另一个好处是当输出的日志级别高于语句的日志级别是，打印日志是个空操作，运行是开销接近零，而printf风格不易做到。

muduo没有用到标准库的iostream，而是自己写的LogStream类，这主要是出于性能。

设计这个LogStream类，让它如同C++的标准输出流对象cout，能用<<符号接收输入，cout是输出到终端，而LogStream类是把输出保存自己内部的缓冲区，可以让外部程序把缓冲区的内容重定向输出到不同的目标，如文件、终端、socket。

1.FixedBuffer的设计

  FixedBuffer的实现为一个非类型参数的模板类（对于非类型参数而言，目前C++的标准仅支持整型、枚举、指针类型和引用类型），传入一个非类型参数SIZE表示缓冲区的大小。通过成员 data_首地址、cur_指针、end()完成对缓冲区的各项操作。通过append()接口把日志内容添加到缓冲区来。

void append(const char* /*restrict*/ buf, size_t len)
 {
    // FIXME: append partially
    if (implicit_cast<size_t>(avail()) > len)
    {
      memcpy(cur_, buf, len);
      cur_ += len;
    }
 }

   FixedBuffer模版类有两个特例化：

const int kSmallBuffer = 4000;
const int kLargeBuffer = 4000*1000;

template class FixedBuffer<kSmallBuffer>;
template class FixedBuffer<kLargeBuffer>;

二、LogStream类

 LogStream类里面有一个Buffer成员(就是FixedBuffer类的，不是muduo::Buffer类)。该类主要负责将要记录的日志内容放到这个Buffer里面。包括字符串，整型、double类型（整型和double要先将之转换成字符型，再放到buffer里面)。该类对这些类型都重载了<<操作符。这个LogStream类不做具体的IO操作。以后要是需要这个buffer里的数据，可以调用LogStream的buffer()函数，这个函数返回const Buffer& 。

 LogStream这个类的重点难点在于重载运算符<<，以整型的<<运算符重载为例子。

// 通过调用convert函数将整数转换为字符串
const char digits[] = "9876543210123456789"; 
// (疑问：digits数组为什么是"9876543210123456789"，而不直接赋为"0123456789"？)
const char* zero = digits + 9;

template<typename T>
size_t convert(char buf[], T value)
{
  T i = value;
  char* p = buf;

  do
  {
    int lsd = static_cast<int>(i % 10);  // 得到最后一个数字，last digit
    i /= 10;
    *p++ = zero[lsd];
  } while (i != 0);

  // 为负数则添加负号
  if (value < 0)
  {
    *p++ = '-';
  }
  *p = '\0';
  std::reverse(buf, p);  // 将字符串逆转

  return p - buf;
}

......

template<typename T>
void LogStream::formatInteger(T v)
{
  // kMaxNumericSize的值为32，即如果buffer的空间足够大
  if (buffer_.avail() >= kMaxNumericSize)
  {
    size_t len = convert(buffer_.current(), v);
    buffer_.add(len);
  }
}

......

LogStream& LogStream::operator<<(int v)
{
  formatInteger(v);  // 调用formatInteger()函数
  return *this;  // 返回LogStream对象的指针
}

//uintptr_t类型对于32位平台来说就是unsigned int
//对于64位平台来说就是unsigned long int
size_t convertHex(char buf[], uintptr_t value)
{//转换成16进制的字符，和转换成10进制的差不多
  uintptr_t i = value;
  char* p = buf;
  do
  {
    int lsd = i % 16;
    i /= 16;
    *p++ = digitsHex[lsd];
  } while (i != 0);


  *p = '\0';
  std::reverse(buf, p);


  return p - buf;
}


//在数据后面加个\0，相当于字符串
template<int SIZE>
const char* FixedBuffer<SIZE>::debugString()
{
  *cur_ = '\0';//加入结束符
  return data_;
}

 通过模版函数formatInteger()把short、unsigned short、int、unsigned int、long、unsigned long、long long等类型转换为字符串，并保存到buffer中。

// 静态检查，用于检查一些类型的大小 
void LogStream::staticCheck()
{
    //kMaxNumericSize的值为32
  static_assert(kMaxNumericSize - 10 > std::numeric_limits<double>::digits10,
                "kMaxNumericSize is large enough");
  static_assert(kMaxNumericSize - 10 > std::numeric_limits<long double>::digits10,
                "kMaxNumericSize is large enough");
  static_assert(kMaxNumericSize - 10 > std::numeric_limits<long>::digits10,
                "kMaxNumericSize is large enough");
  static_assert(kMaxNumericSize - 10 > std::numeric_limits<long long>::digits10,
                "kMaxNumericSize is large enough");
}

 std::numeric_limits<T>::digits10 ，返回目标类型在十进制下可以表示的最大位数，值是类型 T 能无更改地表示的底 10 位数，即任何拥有这么多十进制有效数字的数能转换成 T 的值并转换回十进制形式，而不因舍入或上溢而更改。对于底 radix 类型，它是 digits （对于浮点类型是 digits-1 ）的值乘 log10(radix) 并向下取整。 

         std::numeric_limits的详细介绍可以看看另外一篇文章，C++ limits头文件的用法（numeric_limits）: http://blog.csdn.net/wordwarwordwar/article/details/39344131

    另外，static_assert这个关键字，用来做编译期间的断言，因此叫做静态断言。

    使用static_assert，我们可以在编译期间发现更多的错误，而不像assert那样要运行起来才诊断，用编译器来强制保证一些契约，并帮助我们改善编译信息的可读性，尤其是用于模板的时候。    

    例如：static_assert（a==b,"a!=b"）;,当产生错误的时候，编译器就会提示:a!=b,这样就明显多了………………，也为我们苦逼的码农解决了生命。
    其语法很简单：static_assert(常量表达式，提示字符串)。
    如果第一个参数常量表达式的值为真(true或者非零值)，那么static_assert不做任何事情，就像它不存在一样，否则会产生一条编译错误，错误位置就是该static_assert语句所在行，错误提示就是第二个参数提示字符串。

    对于字符串的输出，为了提高性能，作者用了google写的一个类StringPiece，只是复制字符串的指针，故不涉及具体字符串内存的拷贝，高效地传递字符串。这个StringPiece类的详细讲解，可以看看我的另外一篇文章:http://blog.csdn.net/q5707802/article/details/78420629.

class Fmt // : noncopyable
{
 public:
  template<typename T>
  Fmt(const char* fmt, T val);//
   
  const char* data() const { return buf_; }
  int length() const { return length_; }

 private:
  char buf_[32];
  int length_;
};

template<typename T>  
Fmt::Fmt(const char* fmt, T val)  
{  
  //断言是算术类型（即整数类型或浮点类型）
  static_assert(std::is_arithmetic<T>::value == true, "Must be arithmetic type"); 
   //按照fmt 格式将val 格式化成字符串放入buf_中
  length_ = snprintf(buf_, sizeof buf_, fmt, val);  
  assert(static_cast<size_t>(length_) < sizeof buf_);  
}  
  
// Explicit instantiations  
//模板的特化，只支持这么多类型  
template Fmt::Fmt(const char* fmt, char);  
  
template Fmt::Fmt(const char* fmt, short);  
template Fmt::Fmt(const char* fmt, unsigned short);  
template Fmt::Fmt(const char* fmt, int);  
template Fmt::Fmt(const char* fmt, unsigned int);  
template Fmt::Fmt(const char* fmt, long);  
template Fmt::Fmt(const char* fmt, unsigned long);  
template Fmt::Fmt(const char* fmt, long long);  
template Fmt::Fmt(const char* fmt, unsigned long long);  
  
template Fmt::Fmt(const char* fmt, float);  
template Fmt::Fmt(const char* fmt, double);