C++ socket::async_read_some方法代码示例

	inline void connection::start() {
	    socket_.async_read_some(boost::asio::buffer(buffer_),
		    strand_.wrap(
			 boost::bind(&connection::handle_read, shared_from_this(),
				     boost::asio::placeholders::error,
				     boost::asio::placeholders::bytes_transferred)));
	}

/**
* Вызывается всякий раз, когда данные получены.
*/
static void handleRead(
    ba::ip::tcp::socket&  readFrom,
    ba::ip::tcp::socket&  writeTo,
    char*   readBuffer,
    size_t  bytes,
    const boost::system::error_code&  e
) {
#ifdef _DEBUG
    const std::string  data( readBuffer, readBuffer + bytes );
    std::cout << data << std::endl;
#endif

    // отправляем полученные данные "другой стороне"
    writeTo.send( ba::buffer( readBuffer, bytes ) );

    // читаем ещё данные с "этой стороны"
    readFrom.async_read_some(
        ba::buffer( readBuffer, 1024 ),
        boost::bind(
            handleRead,
            boost::ref( readFrom ),
            boost::ref( writeTo),
            readBuffer,
            ba::placeholders::bytes_transferred,
            ba::placeholders::error
    ) );
}

void handler::async_read() {
	auto self(shared_from_this());
	m_socket.async_read_some(boost::asio::buffer(m_buffer),
	                         std::bind(&handler::handle_read, self,
	                                   std::placeholders::_1,
	                                   std::placeholders::_2));
}

	void start()
	{
		socket_.async_read_some(boost::asio::buffer(data_),
			boost::bind(&session::handle_read, shared_from_this(),
				boost::asio::placeholders::error,
				boost::asio::placeholders::bytes_transferred));
	}

		void	startRead()
		{
			checkNotReading(true);
			 
			reading = true;
			readBuff.ensure_write_space(MAX_READ_BYTES_ONCE);
			socket.async_read_some(boost::asio::buffer(readBuff.wt_ptr(), readBuff.writeable_bytes()),
				boost::bind(&TcpConnection::handleRead, shared_from_this(),
				boost::asio::placeholders::error,
				boost::asio::placeholders::bytes_transferred));
		}

void run_socket_io(boost::asio::ip::tcp::socket& socket)
{
   std::array<char, 1024> read_buffer;
   std::array<char, 1024> write_buffer;

   socket.async_read_some(boost::asio::buffer(write_buffer, 1024),
       [&write_buffer](const boost::system::error_code& ec, std::size_t length)
       {
          if (!ec)
             std::cout.write(write_buffer.data(), length);
       });

   while (std::cin.getline(read_buffer.data(), 1024))
   {
      socket.send(
          boost::asio::buffer(read_buffer, std::strlen(read_buffer.data())));
   }
}

void AsyncLoopSocket(boost::function<TaskState()> doWork, boost::asio::ip::tcp::socket& sock, bool isRead)
{
    if (sock.get_io_service().stopped())
    {
        return;
    }

    TaskState st = doWork();

    if (st == TASK_WORKING)
    {
        if (isRead)
        {
            sock.async_read_some(boost::asio::null_buffers(), bind(AsyncLoopSocket, doWork, boost::ref(sock),
                isRead));
        }
        else
        {
            sock.async_write_some(boost::asio::null_buffers(), bind(AsyncLoopSocket, doWork, boost::ref(sock),
                isRead));
        }

        return;
    }

    // Work is over. stop any outstanding events.
    // NOTE: this isn't 100% reliable, and there may be events that linger in the queue.
    // The next time we reset() and run() the io_service, these events will be processed,
    // and io_service::stopped() will return false, because we've just done reset() and run().
    // The state management (SSHSession::State) is our first step in controlling this, and we
    // may need to implement our own cancel mechanism
    //
    // this io_service feature poses an additional problem - by spreading the implementation
    // responsibility across multiple classes, we create scenarios where io_service's queue
    // may contain outstanding events referring to objects that were, in the meantime, destroyed.
    // this is why we're favouring, for now, the use of AsyncLoopTimer, where we can use an
    // io_service for each timer, and destroy it right after being used. this makes sure we
    // process no "zombie" outstanding events.
    sock.get_io_service().stop();
}

	inline void connection::handle_read(const boost::system::error_code& e,
					    std::size_t bytes_transferred) {
	    if (!e) {
		boost::tribool result;
		boost::tie(result, boost::tuples::ignore) = request_parser_.parse(
		  *request_, buffer_.data(), buffer_.data() + bytes_transferred);

		if (result) {
		    try {
			request_handler_.handle_request(*request_, reply_);
		    } catch (webserver::reply rep) {
			reply_ = rep;
		    }
		    std::cerr << reply_.content << std::endl;
		    boost::asio::async_write(socket_, reply_.to_buffers(),
		     strand_.wrap(
			  boost::bind(&connection::handle_write, shared_from_this(),
				      boost::asio::placeholders::error)));
		} else if (!result) {
		    reply_ = reply::stock_reply(reply::bad_request);
		    boost::asio::async_write(socket_, reply_.to_buffers(),
		     strand_.wrap(
			  boost::bind(&connection::handle_write, shared_from_this(),
				      boost::asio::placeholders::error)));
		} else {
		    socket_.async_read_some(boost::asio::buffer(buffer_),
			    strand_.wrap(
				 boost::bind(&connection::handle_read, shared_from_this(),
					     boost::asio::placeholders::error,
					     boost::asio::placeholders::bytes_transferred)));
		}
	    }

	    // If an error occurs then no new asynchronous operations are started. This
	    // means that all shared_ptr references to the connection object will
	    // disappear and the object will be destroyed automatically after this
	    // handler returns. The connection class's destructor closes the socket.
	}

	void async_read() {
		socket_.async_read_some(boost::asio::buffer(buffer_read_.bytes, MAX_BUFFER_SIZE),
				boost::bind( &session::handle_read, shared_from_this(),
						boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
	}

	size_t recv(Func handler,
		ARGS&...args)
	{
		return s_opt.async_read_some(boost::asio::buffer(args...), handler);
	}