重写muduo之Buffer

1、 Buffer.h

Buffer封装

是一个缓冲区

prependable bytes+readable bytes+writable bytes=8字节长度（解决粘包问题）+读数据+写数据
根据下标进行读或者写

3个成员变量：数组，数据可读的下标，数据可写的下标

#pragma once

#include <vector>
#include <string>
#include <algorithm>

//网络库底层的缓冲区类型定义
class Buffer
{
public:
    static const size_t kCheapPrepend=8;//记录数据包的长度
    static const size_t kInitialSize=1024;//缓冲区的大小

    explicit Buffer(size_t initialSize=kInitialSize)
        :buffer_(kCheapPrepend+initialSize)
        ,readerIndex_(kCheapPrepend)
        ,writerIndex_(kCheapPrepend)
    {}

    size_t readableBytes() const//可读的缓冲区大小
    {
        return writerIndex_-readerIndex_;
    }

    size_t writableBytes() const//可写的缓冲区大小
    {
        return buffer_.size()-writerIndex_;
    }

    size_t prependableBytes() const//prependable Bytes区域大小
    {
        return readerIndex_;
    }

    //返回缓冲区中可读数据的起始地址
    const char* peek() const
    {
        return begin()+readerIndex_;
    }

    //注册回调  onMessage 有读写事件发生时，将buffer->string
    void retrieve(size_t len)
    {
        if(len<readableBytes())
        {
            readerIndex_+=len;//应用只读取了可读缓冲区数据的一部分，就是len，还剩下readerIndex_+=len~writerIndex_没读
        }
        else//len==readableBytes()
        {
            retrieveAll();
        }
    }

    void retrieveAll()
    {
        readerIndex_=writerIndex_=kCheapPrepend;
    }

    //把onMessage函数上报的Buffer数据，转成string类型的数据返回
    std::string retrieveAllAsString()
    {
        return retrieveAllAsString(readableBytes());//应用可读取数据的长度
    }

    std::string retrieveAllAsString(size_t len)
    {
        std::string result(peek(),len);//peek() 可读数据的起始地址
        retrieve(len);//上面一句把缓冲区中可读的数据，已经读取出来，这里肯定要对缓冲区进行复位操作
        return result;
    }

    //剩余的可写缓冲区buffer_.size()~writerIndex_    要写的数据的长度  len
    void ensureWriteableBytes(size_t len)
    {
        if(writableBytes()<len)
        {
            makeSpace(len);//扩容函数
        }
    }

    //把[data,data+len]内存上的数据，添加到writable缓冲区当中
    void append(const char* data,size_t len)
    {
        ensureWriteableBytes(len);//确保空间可用
        std::copy(data,data+len,beginWrite());
        writerIndex_+=len;
    }

    char* beginWrite()//可以写的地方的地址
    {
        return begin()+writerIndex_;
    }

    const char* beginWrite()const//常对象可调用
    {
        return begin()+writerIndex_;
    }

    //从fd上读取数据
    ssize_t readFd(int fd,int* saveErrno);

    //通过fd发送数据
    ssize_t writeFd(int fd,int* saveErrno);

private:
    char* begin()
    {
        //it.operator*()  取迭代器访问的第一个元素，再对这个元素取地址
        return &*buffer_.begin();//vector底层数组首元素的地址，也就是数组的起始地址
    }
    const char* begin() const
    {
        return &*buffer_.begin();
    }

    void makeSpace(size_t len)
    {
        /*
        kCheapPrepend  |  reader    |     writer     |
        kCheapPrepend  |           len               |
        */
        if(writableBytes()+prependableBytes()<len+kCheapPrepend)//writableBytes()+prependableBytes()=>可写缓存区长度+已读完数据已经空闲下来的缓冲区
        {
            buffer_.resize(writerIndex_+len);//扩容
        }
        else//将未读数据和可写缓冲区往前挪
        {
            size_t readalbe=readableBytes();//未读数据长度
            std::copy(begin()+readerIndex_,//将未读数据挪到前面
                    begin()+writerIndex_,
                    begin()+kCheapPrepend);
            readerIndex_=kCheapPrepend;//readerIndex_前移
            writerIndex_=readerIndex_+readalbe;//writerIndex_前移
        }
    }
    std::vector<char> buffer_;
    size_t readerIndex_;
    size_t writerIndex_;
};

2、Buffer.cc 

readv()可以根据读出的数据，自动填充多个缓冲区，这些缓冲区不需要连续
iovec：缓冲区的起始地址，缓冲区的长度

#include "Buffer.h"

#include <errno.h>
#include <sys/uio.h>
#include <unistd.h>

/**
 * 从fd上读取数据  Poller工作在LT模式
 * Buffer缓冲区是有大小的！  但是从fd上读数据的时候  却不知道tcp数据最终的大小
*/
ssize_t Buffer::readFd(int fd,int* saveErrno)
{
    char extrabuf[65536]={0};//栈上的内存空间  64k

    struct iovec vec[2];

    const size_t writable=writableBytes();//这是Buffer底层缓冲区剩余的可写空间大小
    vec[0].iov_base=begin()+writerIndex_;//缓冲区的起始地址
    vec[0].iov_len=writable;//缓冲区的长度

    //如果vec[0]缓冲区够填的话，就填充到vec[0]，不够填，就填到vec[1],最后，如果我们看到vec[1]中有内容的话，就把其中的内容直接添加到缓冲区中
    //缓冲区刚刚好存入所有我们需要写入的内容，不浪费空间，空间利用率高
    vec[1].iov_base=extrabuf;
    vec[1].iov_len=sizeof extrabuf;

    const int iovcnt=(writable<sizeof extrabuf)?2:1;
    const ssize_t n=::readv(fd,vec,iovcnt);
    if(n<0)
    {
        *saveErrno=errno;
    }
    else if(n<=writable)//Buffer的可写缓冲区已经够存储读出来的数据了
    {
        writerIndex_+=n;
    }
    else//extrabuf里面也写入了数据
    {
        writerIndex_=buffer_.size();
        append(extrabuf,n-writable);//writerIndex_开始写n-writable大小的数据
    }
    
    return n;//读取的字节数
}

// 通过fd发送数据
ssize_t Buffer::writeFd(int fd, int *saveErrno)
{
    ssize_t n=::write(fd,peek(),readableBytes());
    if(n<0)//错误
    {
        *saveErrno=errno;
    }
    return n;
}