boost-asio

I read the boost asio http server example code (see http://www.boost.org/doc/libs/1_54_0/doc/html/boost_asio/example/cpp11/http/server/connection.cpp ) and find the auto self(shared_from_this()); variable is been used in the capture scope ( [this, self] ). But the self variable is not been used in the lambda function. Then what's the benefit of doing so? This is done in order to make sure that connection object outlives the asynchronous operation: as long as the lambda is alive (i.e. the async. operation is in progress), the connection instance is alive as well. 来源： https://stackoverflow.com

Below is my code boost::asio::io_service io; boost::asio::ip::tcp::acceptor::reuse_address option(true); boost::asio::ip::tcp::acceptor accept(io); boost::asio::ip::tcp::resolver resolver(io); boost::asio::ip::tcp::resolver::query query("0.0.0.0", "8080"); boost::asio::ip::tcp::endpoint endpoint = *resolver.resolve(query); accept.open(endpoint.protocol()); accept.set_option(option); accept.bind(endpoint); accept.listen(30); boost::asio::ip::tcp::socket ps(io); accept.accept(ps); struct timeval tv; tv.tv_sec = 1; tv.tv_usec = 0; //setsockopt(ps.native(), SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv)

I'm trying to cancel a boost::asio::basic_waitable_timer<std::chrono::steady_clock> safely. According to this answer , this code should do that work: timer.get_io_service().post([&]{timer.cancel();}) I'm afraid it doesn't work for me. Am I doing something wrong? This is my code: #include <iostream> #include "boost/asio.hpp" #include <chrono> #include <thread> #include <random> boost::asio::io_service io_service; boost::asio::basic_waitable_timer<std::chrono::steady_clock> timer(io_service); std::atomic<bool> started; void handle_timeout(const boost::system::error_code& ec) { if (!ec) { started

Question When is it necessary to use asio_handler_invoke to achieve something that cannot be done by simply wrapping the handler? A canonical example that demonstrates a case where asio_handler_invoke is required would be ideal. Background The boost asio docs contain an example of how to use asio_handler_invoke here , but I don't think it is a compelling example of why you would use the invocation handler. In that example it appears you could make changes like the following (and remove the asio_handler_invoke ) and achieve an identical result: template <typename Arg1> void operator()(Arg1 arg1

I'm trying to integrate D-Bus with my boost::asio application. D-Bus has an API that enumerates a set of Unix file descriptors (mainly sockets but could also be FIFOs) to be watched. When those descriptors have something to be read I should inform the D-Bus API so it can read them and do it's thing. Currently I'm doing this: using boost::asio::posix::stream_descriptor; void read_handle(stream_descriptor* desc, const boost::system::error_code& ec, std::size_t bytes_read) { if (!ec) { stream_descriptor::bytes_readable command(true); descriptor->io_control(command); std::size_t bytes_readable =

I have a data structure that looks like this: typedef struct { unsigned short m_short1; unsigned short m_short2; unsigned char m_character; } MyDataType; I want to use boost::serialization to serialize this data structure, then use boost::asio to transmit it via TCP/IP, then have another application receive the data and de-serialize it using the same boost libraries. I'm trying to following boost::serialization tutorial , ( as some other SO questions have suggested ) but the example is specifically for writing/reading to a file, not to a socket using boost::asio. I'm pretty sure I've got the