网络编程入门07

LogStream.h

const int kSmallBuffer = 4000;
const int kLargeBuffer = 4000*1000;
temlpate <int SIZE>
class FixedBuffer{
private:
  void (*cookie_)();
  char data_[SIZE];
  char* cur_;
public:
     FixedBuffer() : cur_(data_){//构造函数
        setCookie(cookieStart);
    } 
    ~dtr() {
       setCookie(cookieEnd);
    }
    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;
    }
  }
  const char* data() const { return data_; }  //返回数据头
  int length() const { return static_cast<int>(cur_ - data_); }  //返回数据长度
  char* current() { return cur_; }  //返回当前数据尾巴 
  int avail() const { return static_cast<int>(end() - cur_); }  //返回缓冲区剩余长度
  void add(size_t len) { cur_ += len; }       //数据区 边长
  const char* debugString();
  void setCookie(void (*cookie)()) { cookie_ = cookie; }  //设置cookie_ 函数指针
  // for used by unit test
  string toString() const { return string(data_, length()); }                  
  StringPiece toStringPiece() const { return StringPiece(data_, length()); }
private:
  const char* end() const { return data_ + sizeof data_; }  //返回缓冲区长度
  // Must be outline function for cookies.
  static void cookieStart(); //静态函数  
  static void cookieEnd();
}

class LogStream : noncopyable  //内部用缓冲区，实现了对移位运算符重载，实现了自己的Log流类
{
public:
 typedef LogStream self;
 typedef detail::FixedBuffer<detail::kSmallBuffer> Buffer;  //FixedBuffer座位内部成员
private:
  void staticCheck();

  template<typename T>
  void formatInteger(T); //模板函数

  Buffer buffer_; //FixedBuffer

  static const int kMaxNumericSize = 32;

 
 public:
  

  self& operator<<(bool v)  //写入bool值
  {
    buffer_.append(v ? "1" : "0", 1);
    return *this;
  }

  self& operator<<(short);
  self& operator<<(unsigned short);
  self& operator<<(int);
  self& operator<<(unsigned int);
  self& operator<<(int);
  self& operator<<(unsigned int);
  self& operator<<(long);
  self& operator<<(unsigned long);
  self& operator<<(long long);
  self& operator<<(unsigned long long);

  self& operator<<(const void*);
 self& operator<<(float v)
  {
    *this << static_cast<double>(v);
    return *this;
  }
  self& operator<<(double);
  // self& operator<<(long double);

  self& operator<<(char v)
  {
    buffer_.append(&v, 1);
    return *this;
  }
 self& operator<<(const char* str)
  {
    if (str)
    {
      buffer_.append(str, strlen(str));
    }
    else
    {
      buffer_.append("(null)", 6);
    }
    return *this;
  }

  self& operator<<(const unsigned char* str)
  {
    return operator<<(reinterpret_cast<const char*>(str));
  }

  self& operator<<(const string& v)
  {
buffer_.append(v.c_str(), v.size());
    return *this;
  }

  self& operator<<(const StringPiece& v)
  {
    buffer_.append(v.data(), v.size());
    return *this;
  }

  self& operator<<(const Buffer& v)
  {
    *this << v.toStringPiece();
    return *this;
  }
void append(const char* data, int len) { buffer_.append(data, len); }
  const Buffer& buffer() const { return buffer_; }
  void resetBuffer() { buffer_.reset(); }
｝

class Fmt{     //类似于redis SDS， 
private:
  char buf_[32];
  int length_;
public:
    template<typename T>
    Fmt(const char* fmt, T val);
    const char* data() { return buf_;}
    int length() const { return length_;}
}

inline LogStream& operator<<(LogStream& s, const Fmt& fmt)  //实现了logStream对 fmt的输入重载
{
  s.append(fmt.data(), fmt.length());
  return s;
}

string formatSI(int64_t n);  //int转成国际单位制

string formatIEC(int64_t n);  //int转为IEC制

template<typename T>
size_t convert(char buf[], T value); //把int转换为字符串，算法是去余，除10，最后翻转  123455   先得到554321 在翻转一下

*#if __WORDSIZE == 64*
*# ifndef __intptr_t_defined*
*typedef long int		intptr_t;*
*#  define __intptr_t_defined*
*# endif*
*typedef unsigned long int	uintptr_t;*
*#else*
*# ifndef __intptr_t_defined*
*typedef int			intptr_t;*
*#  define __intptr_t_defined*
*# endif*
*typedef unsigned int		uintptr_t;*
*#endif*

size_t convertHex(char buf[], uintptr_t value) //uint 转换为 16进制  mod 取余， 除16 ,翻转

Logging.h

class Logger{e
private:
class Impl
{
 public:
  typedef Logger::LogLevel LogLevel;
  Impl(LogLevel level, int old_errno, const SourceFile& file, int line);
  void formatTime();
  void finish();

  Timestamp time_;
  LogStream stream_;
  LogLevel level_;
  int line_;
  SourceFile basename_;
};

  Impl impl_;             //内部有一个Impl对象

};

public:
  enum LogLevel{}

  class SourceFile {  //有感觉是一个类似sds的东西
  const char* data_;
  int size_;
    public:
         template<int N>
         SourceFile(const char (&arr) [N]) : data_(arr), size_(N - 1) {
         const char* slash  =  strrchr(data_, '/') ;  //找到第一个找到'/'字符的那个点
         if (slash)
          {   
            data_ = slash + 1;
            size_ -= static_cast<int>(data_ - arr);
          }   
        }
       
        explicit SourceFile(const char* filename)
          : data_(filename)
        {   
              const char* slash = strrchr(filename, '/');
              if (slash)
              {   
                data_ = slash + 1;
              }
              size_ = static_cast<int>(strlen(data_));
         }
      }

    Logger(SourceFile file, int line);                                         //一些log的构造方法
    Logger(SourceFile file, int line, LogLevel level);
  Logger(SourceFile file, int line, LogLevel level, const char* func);
  Logger(SourceFile file, int line, bool toAbort);
  ~Logger();

LogStream& stream() { return impl_.stream_; }

  static LogLevel logLevel();
  static void setLogLevel(LogLevel level);

  typedef void (*OutputFunc)(const char* msg, int len);
  typedef void (*FlushFunc)();
  static void setOutput(OutputFunc);
  static void setFlush(FlushFunc);
  static void setTimeZone(const TimeZone& tz);
}

extern Logger::LogLevel g_logLevel;

inline Logger::LogLevel Logger::logLevel()
{
  return g_logLevel;
}

const char* strerror_tl(int savedErrno);

template <typename T>
T* CheckNotNull(Logger::SourceFile file, int line, const char *names, T* ptr)
{
  if (ptr == NULL)
  {
   Logger(file, line, Logger::FATAL).stream() << names;
  }
  return ptr;
}

BlockingQueue.h

template<typename T>
class BlockingQueue : noncopyable    //实现了一个线程安全的双端队列，push和take都需要加锁，使用条件变量和锁实现
{
 public:
  BlockingQueue()
    : mutex_(),
      notEmpty_(mutex_),
      queue_()
  {
  }
 }

BoundBlockingQueue.h

template<typename T>
class BoundedBlockingQueue : noncopyable  //一个容量有限制的线程安全对了， 队列可能会满由，由两个条件变量实现 非空和非满
{
 public:
  explicit BoundedBlockingQueue(int maxSize)
    : mutex_(),
      notEmpty_(mutex_),
      notFull_(mutex_),
      queue_(maxSize)
  {
  }

Exception.h

class Exception : public std::exception //对与异常的包装与处理