boost之asio相关

1. mutable_buffers_1

class mutable_buffers_1

  : public mutable_buffer

{

      //主要就是提供这2个函数

const_iterator begin();

const_iterator end():

}

mutable_buffer就是封装了void*, size

2.basic_streambuf

--------------------------------------------------

 +                        +

gptr()                 pptr()

gptr() <-->pptr()之间就是已写数据，pptr()是尚未使用的缓冲区

prepare(size_t n);获取n bytes缓冲区，不够就申请

commit(size_t n);pptr()向前移动n bytes

consume(size_ n);gptr()向前移动n bytes

3.

sactter-gaterh理念的实现：

template <typename Stream>
class buffered_write_stream
  : private noncopyable
{
  std::size_t read_some(const MutableBufferSequence& buffers)
  {
    return next_layer_.read_some(buffers);
  }

  template <typename ConstBufferSequence>

  std::size_t write_some(const ConstBufferSequence& buffers,
      boost::system::error_code& ec)
  {
    ec = boost::system::error_code();
    if (boost::asio::buffer_size(buffers) == 0)
      return 0;
    if (storage_.size() == storage_.capacity() && !flush(ec)) //缓冲区写满后才write
      return 0;
    return copy(buffers);
  }

  std::size_t flush(boost::system::error_code& ec)
  {
    std::size_t bytes_written = write(next_layer_,
        buffer(storage_.data(), storage_.size()),
        transfer_all(), ec);
    storage_.consume(bytes_written);
    return bytes_written;
  }
};

template <typename Stream>
class buffered_read_stream
  : private noncopyable
{
  template <typename ConstBufferSequence>
  std::size_t write_some(const ConstBufferSequence& buffers,
      boost::system::error_code& ec)
  {
    return next_layer_.write_some(buffers, ec);
  }
 
  template <typename MutableBufferSequence>
  std::size_t read_some(const MutableBufferSequence& buffers)
  {
    if (boost::asio::buffer_size(buffers) == 0)
      return 0;

    if (storage_.empty())
      fill();

    return copy(buffers); //有一个缓冲区，一次读取指定大小的数据，读完后分次复制给传进来的参数，只有内部缓冲区被读完后，再重新读取数据
  }

   std::size_t fill(boost::system::error_code& ec)
  {
    detail::buffer_resize_guard<detail::buffered_stream_storage>
      resize_guard(storage_);
    std::size_t previous_size = storage_.size();
    storage_.resize(storage_.capacity());
    storage_.resize(previous_size + next_layer_.read_some(buffer(
            storage_.data() + previous_size,
            storage_.size() - previous_size),
          ec));
    resize_guard.commit();
    return storage_.size() - previous_size;
  }
};

asio所有的事情都是在io_service::run里面开始处理的，完成后才返回

boost::asio::ip::tcp::acceptor在构造函数里面会调用bind,listen

io_service内部维护一个service链表,所有这些service的owner必须指向同一个io_service

io_service的所有操作都是交给service（_impl）完成。

win_iocp_io_service : public service_base{};

service_base : public service{};

class service

{

     提供一个get_io_service();

     一个io_service& owner;

    一个service* next指针

};

这种处理方式似乎越来越多

// Base class for all operations. A function pointer is used instead of virtual
// functions to avoid the associated overhead.
class win_iocp_operation
  : public OVERLAPPED
    BOOST_ASIO_ALSO_INHERIT_TRACKED_HANDLER
{};

win_iocp_io_service

{

post_deferred_completion:如果投递失败，将请求放入队列中

}

win_iocp_socket_service_base:

1.有WSAXXX操作的，就用iocp,没有的，如connect就用reactor

2.send / receive有四种：

①：同步操作，用socket_ops:sync_send

②：异步等待可以发送的时机，用socket_ops::poll_write()(内部就是一个write的select)

③：正常异步发送，用iocp

④：异步发送null缓冲区，用reactor

win_iocp_socket_service:public win_iocp_socket_service_base{}

按照上述四种模式增加了send_to / async_send_to, receive_from / async_receive_from 

connect/acceptor结构

socket_acceptor_service : public service_base
{
    win_iocp_socket_service service_impl_type
};

basic_stream_socket : public service_base
{
  win_iocp_socket_service service_impl_type
};