boost-asio

can you set SO_RCVTIMEO and SO_SNDTIMEO socket options in boost asio? If so how? Note I know you can use timers instead, but I'd like to know about these socket options in particular. Absolutely! Boost ASIO allows you to access the native/underlying data, which in this case is the SOCKET itself. So, let's say you have: boost::asio::ip::tcp::socket my_socket; And let's say you've already called open or bind or some member function that actually makes my_socket usable. Then, to get the underlying SOCKET value, call: SOCKET native_sock = my_socket.native(); int result = SOCKET_ERROR; if (INVALID

short question: I have a realtime-simulation which is running as a backround process and is connected with pipes to the calling pogramm. I want to send commands to that process using stdin to get certain information from it via stdout. Now because it is a real-time process, it has to be a non blocking input. Is boost::asio::async_read in conjunction with iostream::cin a good idea for this task? how would I use that function if it is feasible? Any more suggestions? Sam Miller Look at boost::asio::posix::stream_descriptor http://www.boost.org/doc/libs/release/doc/html/boost_asio/example/cpp03

io_service::poll_one Run the io_service object's event processing loop to execute one ready handler. vs io_service::run_one Run the io_service object's event processing loop to execute at most one handler. From that explanation it would seem poll_one could execute more than one handler? Does run_one or poll_one use any thread that's called run() or only the thread that calls poll_one/run_one? The documentation for ASIO is very sparse. poll_one will return immediately (non-blocking) in case there is no event to process. run_one will block the calling thread until one event is ready to process.

Reading the document of boost::asio, it is still not clear when I need to use asio::strand. Suppose that I have one thread using io_service is it then safe to write on a socket as follows ? void Connection::write(boost::shared_ptr<string> msg) { _io_service.post(boost::bind(&Connection::_do_write,this,msg)); } void Connection::_do_write(boost::shared_ptr<string> msg) { if(_write_in_progress) { _msg_queue.push_back(msg); } else { _write_in_progress=true; boost::asio::async_write(_socket, boost::asio::buffer(*(msg.get())), boost::bind(&Connection::_handle_write,this, boost::asio::placeholders:

I'm trying to learn a little bit C++ and Boost.Asio. I'm trying to compile the following code example: #include <iostream> #include <boost/array.hpp> #include <boost/asio.hpp> using boost::asio::ip::tcp; int main(int argc, char* argv[]) { try { if (argc != 2) { std::cerr << "Usage: client <host>" << std::endl; return 1; } boost::asio::io_service io_service; tcp::resolver resolver(io_service); tcp::resolver::query query(argv[1], "daytime"); tcp::resolver::iterator endpoint_iterator = resolver.resolve(query); tcp::resolver::iterator end; tcp::socket socket(io_service); boost::system::error_code

using Yield = asio::yield_context; using boost::system::error_code; int Func(Yield yield) { error_code ec; asio::detail::async_result_init<Yield, void(error_code, int)> init(yield[ec]); std::thread th(std::bind(Process, init.handler)); int result = init.result.get(); // <--- yield at here return result; } How to implement Process so that Func will resumed in the context of the strand that Func was originally spawned on? Boost.Asio uses a helper function, asio_handler_invoke , to provide a customization point for invocation strategies. For example, when a Handler has been wrapped by a strand ,

According to http://www.boost.org/doc/libs/1_55_0/doc/html/boost_asio/overview/cpp2011/futures.html , we can use boost::asio with std::future . But I couldn't find any information about working with boost::unique_future , which has more functions, such as then() . How can I use? Boost.Asio only provides first-class support for asynchronous operations to return a C++11 std::future or an actual value in stackful coroutines . Nevertheless, the requirements on asynchronous operations documents how to customize the return type for other types, such as Boost.Thread's boost::unique_future . It