// Consume the specified number of bytes from the buffers.
  void consume(std::size_t size)
  {
    // Remove buffers from the start until the specified size is reached.
    while (size > 0 && !at_end_)
    {
      if (buffer_size(first_) <= size)
      {
        size -= buffer_size(first_);
        if (begin_remainder_ == buffers_.end())
          at_end_ = true;
        else
          first_ = *begin_remainder_++;
      }
      else
      {
        first_ = first_ + size;
        size = 0;
      }
    }

    // Remove any more empty buffers at the start.
    while (!at_end_ && buffer_size(first_) == 0)
    {
      if (begin_remainder_ == buffers_.end())
        at_end_ = true;
      else
        first_ = *begin_remainder_++;
    }
  }

/// Create a new non-modifiable buffer from an existing buffer.
inline const_buffer_container_1 buffer(const const_buffer& b,
    std::size_t max_size_in_bytes)
{
  return const_buffer_container_1(
      const_buffer(buffer_cast<const void*>(b),
        buffer_size(b) < max_size_in_bytes
        ? buffer_size(b) : max_size_in_bytes));
}

/**
 * @relates const_buffer
 */
inline const_buffer operator+(std::size_t start, const const_buffer& b)
{
  if (start > buffer_size(b))
    return const_buffer();
  const char* new_data = buffer_cast<const char*>(b) + start;
  std::size_t new_size = buffer_size(b) - start;
  return const_buffer(new_data, new_size);
}

/**
 * @relates mutable_buffer
 */
inline mutable_buffer operator+(const mutable_buffer& b, std::size_t start)
{
  if (start > buffer_size(b))
    return mutable_buffer();
  char* new_data = buffer_cast<char*>(b) + start;
  std::size_t new_size = buffer_size(b) - start;
  return mutable_buffer(new_data, new_size);
}

static bool need_wrap(struct buffer * buffer)
{
    if (buffer == &primary_buf)
	return buffer_size(buffer) + indent_size() == max_columns;
    else
	return (buffer_size(&primary_buf) + buffer_size(&tag_buf)
		+ buffer_size(buffer) + indent_size()) >= max_columns;
}

void Attribute::resize(Mesh *mesh, AttributePrimitive prim, bool reserve_only)
{
	if(reserve_only) {
		buffer.reserve(buffer_size(mesh, prim));
	}
	else {
		buffer.resize(buffer_size(mesh, prim), 0);
	}
}

mutable_buffer save(mutable_buffer& buffer, const mutable_buffer& v)
{
	if(buffer_size(buffer) < buffer_size(v)) {
		throw serialization_error("not enough buffer");
	}

	memcpy(buffer_cast<uint8*>(buffer), buffer_cast<uint8*>(v), buffer_size(v));
	return buffer + buffer_size(v);
}

/*
 * pconn is proxy --> server, and has no buffer.
 */
int write_server_handle( conn_t *pconn )
{
	log_message( LOG_DEBUG, "in write_server_handle" );

	//如果client_conn已经关闭，还是需要把剩余数据发送给server端
	if ( NULL == pconn->write_buffer ) {
		log_message( LOG_ERROR, "write_server_handle: write_buffer is NULL." );
		return -1;
	}
	if ( 1 == pconn->write_closed ) {
		log_message( LOG_WARNING, "try writing to server[%s] fd[%d], but it closed write", 
				inet_ntoa(pconn->addr.sin_addr), pconn->fd );
		return -1;
	}

	int bytes;
	bytes = write_buffer( pconn->fd, pconn->write_buffer );
	log_message( LOG_DEBUG, "send to server[%s:%d] %d bytes.\n",  inet_ntoa(pconn->addr.sin_addr), ntohs(pconn->addr.sin_port), bytes );

	if ( g_errno < 0 ) {					//写出错
		CONN_CLOSE_WRITE( pconn );
		if ( 1 == pconn->read_closed )
			return -1;
	}
	else {
		if ( 0==buffer_size(pconn->write_buffer) &&			//发送完缓冲区中的数据
			( NULL==pconn->server_conn ||					//并且客户端不会再有数据过来
				1 == pconn->server_conn->read_closed ) )  {
			CONN_CLOSE_WRITE( pconn );
			if ( 1 == pconn->read_closed )
				return -1;
		}
	}

	/*
	 * it's very important
	 */
	uint32_t clientf = 0, serverf = 0;
	//写缓存中还有数据
	if ( 0 == pconn->write_closed && buffer_size( pconn->write_buffer ) > 0 )
		serverf |= EPOLLOUT;
	//读缓存未满并且未关闭读
	if ( 0 == pconn->read_closed && buffer_size( pconn->read_buffer ) < MAXBUFFSIZE )	
		serverf |= EPOLLIN;			//继续侦听读事件
	epoll_mod_connection( pconn, serverf );

	conn_t	*pclie_conn;
	if ( NULL != ( pclie_conn = pconn->server_conn ) ) {
		if ( 0 == pclie_conn->write_closed && buffer_size( pclie_conn->write_buffer ) > 0 )
			clientf |= EPOLLOUT;
		if ( 0 == pclie_conn->read_closed && buffer_size( pclie_conn->read_buffer ) < MAXBUFFSIZE )
			clientf |= EPOLLIN;
		epoll_mod_connection( pclie_conn, clientf );
	}

	return TRUE;
}

bool Lexer::skipComments()
{
	// We need to ensure that we have enough characters in the buffer.
	switch (buffer_size()) {
	case 0:
		buffer_put(m_input->get());
	case 1:
		buffer_put(m_input->get());
	case 2:
		buffer_put(m_input->get());
	case 3:
		buffer_put(m_input->get());
	}

	// We have a comment iff it begins with '<!--' sequence.
	if (!(buffer_at(0) == '<' &&
	      buffer_at(1) == '!' &&
	      buffer_at(2) == '-' &&
	      buffer_at(3) == '-'))
	{
		return false;
	}

	buffer_pop();
	buffer_pop();
	buffer_pop();
	buffer_pop();

	for (;;) {
		// TODO: Handle unclosed comments.

		// As above, we enusre that we have enough characters available.
		switch (buffer_size()) {
		case 0:
			buffer_put(m_input->get());
		case 1:
			buffer_put(m_input->get());
		case 2:
			buffer_put(m_input->get());
		}

		// The comment ends only with the '-->' sequence.
		if (buffer_at(0) == '-' &&
		    buffer_at(1) == '-' &&
		    buffer_at(2) == '>')
		{
			buffer_pop();
			buffer_pop();
			buffer_pop();
			break;
		}

		buffer_pop();
	}

	return true;
}

static void content(void)
{
    char current;

    /*
     * We should get one character at a time.
     */
    assert(strlen(yytext) == 1);

    current = yytext[0];
    if (current == EOF)
	return;
    
    if (is_newline(current)) {
	 newline();
	 return;
    }
    buffer_push_char(current_buf, current);

    /*
     * Forcing newline changes 'text' so lets do it after we've pushed
     * it to the buffer.
     */
    if (wrap_long_lines && need_wrap(current_buf)) {
	struct buffer tmp;
	buffer_init(&tmp, buffer_size(current_buf));
	/*
	 * Find last character that was not whitespace
	 */
	for (;;) {
	    int c;
	    if (buffer_size(current_buf) == 0)
		break;

	    c = buffer_pop_char(current_buf);
	    if (is_whitespace(c)) {
		/*
		 * Do not push whitespace because it would appear
		 * after the newline.
		 */
		break;
	    }
	    /*
	     * Characters are put in tmp buffer in reverse order.
	     */
	    buffer_push_char(&tmp, c);
	}
	force_newline_for_wrap(current_buf);
	/*
	 * Restore non-wrapped text into buffer.
	 */
	while (buffer_size(&tmp) > 0) {
	    buffer_push_char(current_buf, buffer_pop_char(&tmp));
	}
	buffer_release(&tmp);
    }
}

void Attribute::reserve(int numverts, int numtris, int numsteps, int numcurves, int numkeys, bool resize)
{
	if (resize) {
		buffer.resize(buffer_size(numverts, numtris, numsteps, numcurves, numkeys), 0);
	}
	else {
		buffer.reserve(buffer_size(numverts, numtris, numsteps, numcurves, numkeys));
	}
}

const_buffer load(const_buffer& buffer, const_buffer& v)
{
	if(buffer_size(buffer) < buffer_size(v)) {
		throw serialization_error("not enough buffer");
	}

	memcpy(const_cast<uint8*>(buffer_cast<const uint8*>(v))
		, buffer_cast<const uint8*>(buffer), buffer_size(v));
	return buffer + buffer_size(v);
}

 bool equal(const consuming_buffers_iterator& other) const
 {
   if (at_end_ && other.at_end_)
     return true;
   return !at_end_ && !other.at_end_
     && buffer_cast<const void*>(first_)
       == buffer_cast<const void*>(other.first_)
     && buffer_size(first_) == buffer_size(other.first_)
     && begin_remainder_ == other.begin_remainder_
     && end_remainder_ == other.end_remainder_;
 }

/**
 * VMNative: string_prealloc( workshop , newsize )
 * Accepts a workshop argument and a number. The newsize is the size to
 * reallocate the workshop buffer to. Preallocate buffer for best performance.
 */
static bool vmn_str_prealloc(VM * vm, VMArg * arg, int argc) {
  VMLibData * data;
  Buffer * buffer;
  int newSize;

  /* check for proper number of arguments */
  if(argc != 2) {
    vm_set_err(vm, VMERR_INCORRECT_NUMARGS);
    return false;
  }

  /* check argument 1 major type */
  if(vmarg_type(arg[0]) != TYPE_LIBDATA) {
    vm_set_err(vm, VMERR_INVALID_TYPE_ARGUMENT);
    return false;
  }

  /* extract the libdata from the argument */
  data = vmarg_libdata(arg[0]);

  /* check libdata type */
  if(!vmlibdata_is_type(data, LIBSTR_STRING_TYPE, LIBSTR_STRING_TYPE_LEN)) {
    vm_set_err(vm, VMERR_INVALID_TYPE_ARGUMENT);
    return false;
  }

  /* check argument 2 type */
  if(vmarg_type(arg[1]) != TYPE_NUMBER) {
    vm_set_err(vm, VMERR_INVALID_TYPE_ARGUMENT);
    return false;
  }

  newSize = (int)vmarg_number(arg[1], NULL);

  /* check buffer size range */
  if(newSize < 1) {
    vm_set_err(vm, VMERR_ARGUMENT_OUT_OF_RANGE);
    return false;
  }

  /* extract the workshop */
  buffer = vmlibdata_data(data);

  /* can't make it smaller, only bigger */
  buffer_resize(buffer, newSize >= buffer_size(buffer)
		? newSize : buffer_size(buffer));

  /* push null result */
  vmarg_push_null(vm);

  /* this function does return a value */
  return true;
}

void stream_check_test(Buffer_Set *buffers, void *scratch, int scratch_size){
    int i, page_size, size;
    
    size = buffer_size(&buffers->buffer);
    {
        int size2;
        size2 = buffer_size(&buffers->gap_buffer);
        hard_assert_4tech(size == size2);
        size2 = buffer_size(&buffers->multi_gap_buffer);
        hard_assert_4tech(size == size2);
        size2 = buffer_size(&buffers->rope_buffer);
        hard_assert_4tech(size == size2);
    }

    page_size = 1 << 10;

    char *page_1 = (char*)scratch;
    char *page_2 = page_1 + page_size;
    scratch_size -= page_size*2;
    hard_assert_4tech(scratch_size > 0);
    
    for (i = 0; i < size; i += page_size){
        int end = i + page_size;
        if (end > size) end = size;
        
        buffer_stringify(&buffers->buffer, i, end, page_1);
        
        buffer_stringify(&buffers->gap_buffer, i, end, page_2);
        page_compare(page_1, page_2, page_size);
        
        buffer_stringify(&buffers->multi_gap_buffer, i, end, page_2);
        page_compare(page_1, page_2, page_size);
        
        buffer_stringify(&buffers->rope_buffer, i, end, page_2);
        page_compare(page_1, page_2, page_size);
    }

    for (i = size-1; i > 0; i -= page_size){
        int end = i - page_size;
        if (end < 0) end = 0;
        
        buffer_backify(&buffers->buffer, i, end, page_1);
        
        buffer_backify(&buffers->gap_buffer, i, end, page_2);
        page_compare(page_1, page_2, page_size);
        
        buffer_backify(&buffers->multi_gap_buffer, i, end, page_2);
        page_compare(page_1, page_2, page_size);
        
        buffer_backify(&buffers->rope_buffer, i, end, page_2);
        page_compare(page_1, page_2, page_size);
    }
}

static int
check_size(const struct buffer *b, size_t offset, size_t size, const char *desc)
{
	if (size == 0)
		return 0;

	if (offset >= buffer_size(b) || (offset + size) > buffer_size(b)) {
		ERROR("The file is not large enough for the '%s'. "
		      "%zu bytes @ offset %zu, input %zu bytes.\n",
		      desc, size, offset, buffer_size(b));
		return -1;
	}
	return 0;
}

void data_received(endpoint_t ep, int err, size_t bytes, size_t more_bytes, buffer_t *buffer, void *ctx) {
    context_t *context = ctx;

    fprintf(stdout, "Receival error: %d: %s\n", err, strerror(err));
    if(err) {
        io_service_stop(context->service, true);
        return;
    }

    fprintf(stdout, "Data received (size: %llu): %.*s\n",
            buffer_size(buffer), buffer_size(buffer), buffer_data(buffer));

    io_service_stop(context->service, true);
}

/*
 * pconn: client --> proxy, its buffer isn't NULL
 */
int write_client_handle( conn_t *pconn )
{
	log_message( LOG_DEBUG, "in write_client_handle" );

	if ( 1 == pconn->write_closed ) {
		log_message( LOG_WARNING, "try writing to client[%s:%d], but it closed write", inet_ntoa(pconn->addr.sin_addr), ntohs(pconn->addr.sin_port) );
		return -1;
	}

	int bytes;
	bytes = write_buffer( pconn->fd, pconn->write_buffer );
	log_message( LOG_DEBUG, "write %d bytes to client[%s:%d].", bytes, inet_ntoa(pconn->addr.sin_addr), ntohs(pconn->addr.sin_port) );

	if ( g_errno < 0 ) {		//写出错
		CONN_CLOSE_WRITE( pconn );
		if ( 1 == pconn->read_closed )
			return -1;
	}
	else {
		if ( 0==buffer_size(pconn->write_buffer) &&			//发送完缓冲区中的数据
			( NULL==pconn->server_conn ||					//并且server已经不再写
				( NULL!=pconn->server_conn && 1 == pconn->server_conn->read_closed )) )  {
			CONN_CLOSE_WRITE( pconn );
			if ( 1 == pconn->read_closed )
				return -1;
		}
	}

	/*
	 * it's very important
	 */
	uint32_t clientf = 0, serverf = 0;
	if ( NULL != pconn->server_conn ) {
		conn_t	*pserv_conn = pconn->server_conn;
		if ( 0 == pserv_conn->write_closed && buffer_size( pserv_conn->write_buffer ) > 0 )
			serverf |= EPOLLOUT;
		if ( 0 == pserv_conn->read_closed && buffer_size( pserv_conn->read_buffer ) < MAXBUFFSIZE )
			serverf |= EPOLLIN;
		epoll_mod_connection( pserv_conn, serverf );
	}

	if ( 0 == pconn->write_closed && buffer_size( pconn->write_buffer ) > 0 )
		clientf |= EPOLLOUT;
	if ( 0 == pconn->read_closed && buffer_size( pconn->read_buffer ) < MAXBUFFSIZE )
		clientf |= EPOLLIN;
	epoll_mod_connection( pconn, clientf );

	return 0;
}

//实现随机存取，迭代器可以直接跳跃n个距离
  self& operator+=(difference_type n)
  {
    difference_type offset = n + (cur - first);
    if (offset >= 0 && offset < difference_type(buffer_size()))
      cur += n; //目标位置在同一缓冲区内
    else {  //目标位置不在同一缓冲区内
      difference_type node_offset =
        offset > 0 ? offset / difference_type(buffer_size())
                   : -difference_type((-offset - 1) / buffer_size()) - 1;
      set_node(node + node_offset);  //切换到正确的节点（缓冲区）
	  //切换到正确的元素
      cur = first + (offset - node_offset * difference_type(buffer_size()));
    }
    return *this;
  }

void
ramp_request_proxy (void* state, void* param, bid_t bid)
{
  ramp_t* ramp = state;
  assert (ramp != NULL);

  assert (buffer_size (bid) == sizeof (proxy_request_t));

  const proxy_request_t* request = buffer_read_ptr (bid);
  ramp_proxy_t* ramp_proxy = malloc (sizeof (ramp_proxy_t));
  ramp_proxy->request = *request;
  assert (automan_declare (ramp->automan,
			   &ramp_proxy->composed,
			   ramp_proxy,
			   ramp_declared,
			   ramp_proxy) == 0);
  assert (automan_create (ramp->automan,
			  &ramp_proxy->aid,
			  &ramp_proxy_descriptor,
			  NULL,
			  ramp_proxy_created,
			  ramp_proxy) == 0);
  assert (automan_compose (ramp->automan,
			   &ramp_proxy->composed,
			   &ramp->self,
			   ramp_integer_out,
			   ramp_proxy,
			   &ramp_proxy->aid,
			   ramp_proxy_integer_in,
			   NULL,
			   NULL,
			   NULL) == 0);
  assert (schedule_system_output () == 0);
}