boost-asio

Yes. I know there have been a few questions around this time_out in boost::asio . My problem might to too simple for the asio guys to solve here. I am using boost::asio on TCP protocol to read data over a network continuously in a loop as fast as I can. Following function ReadData() gets called continuously from a worker std::thread in a while loop. std::size_t ReadData(std::vector<unsigned char> & buffer, unsigned int size_to_read) { boost::system::error_code error_code; buffer.resize(size_to_read); // Receive body std::size_t bytes_read = boost::asio::read(*m_socket, boost::asio::buffer

In my program, using boost asio io_service, I want to have two parallel call chains. Two endless loops writing and reading to two usb ports. But does boost asio io_service guarantee execution of two parallel call chains? Look at this minimal example: #include <boost/asio/io_service.hpp> #include <functional> class Chain { public: Chain(boost::asio::io_service &io_service, const std::string &message) : io_service(io_service) , message(message) {} void call() { std::cout << message << std::endl; io_service.post(std::bind(&Chain::call, this)); } private: boost::asio::io_service &io_service; std:

int main() { boost::asio::io_service io_service; Worker ob1(&io_service); ob1.AsyncRead(); io_service.run(); } void Worker::AsyncRead() { socket.async_receive_from(buffer,endpoint, handler); } void handler (const boost::system::error_code& error, size_t bytes_received) { if(!error) handleData(); AsyncRead(); } Now this works perfectly fine. But if I use boost::Spawn() to do asyncRead() it crashes. void work(boost::asio::io_service* io_service) { auto ob1 = std::make_shared<Worker>(io_service); boost::asio::spawn(*io_service, [ob1]( boost::asio::yield_context yield) { ob1->AsyncRead(); }); }

Here is my code: void client_connection::serve() { asio::async_read(this->socket_, asio::buffer(&buffer_, buffer_.size()), // predicate/condition (do I wrap this?) std::bind(&client_connection::handle_read_predicate, this->shared_from_this(), std::placeholders::_1, std::placeholders::_2), // handler this->strand_.wrap(std::bind(&client_connection::handle_read, this->shared_from_this(), std::placeholders::_1, std::placeholders::_2))); } std::size_t client_connection::handle_read_predicate(const asio::error_code& error, std::size_t bytes_) { // useless flawed function, for now // std::cout <<

While using boost::asio 1.66 I read in the documentation that boost::asio::io_context::post is deprecated for boost::asio::post , same for boost::asio::io_context::dispatch . Because before they where member functions of the io_context before, and of course the handler needs to be executed in the context of some io_context i.e. executor my question is: How does boost::asio::io_context::post simplest overload know which io_context i.e. executor to use? The documentation of template< typename CompletionToken> DEDUCED post(CompletionToken && token); states that Obtains the handler's associated