I don’t know whether it counts as “excessive copying“, but you can use a stringstream: std::ostringstream ss; ss << someStreamBuf; std::string s = ss.str(); Like, to read everything from stdin into a string, do std::ostringstream ss; ss << std::cin.rdbuf(); std::string s = ss.str(); Alternatively, you may also use a istreambuf_iterator. You will have to measure … Read more
Got reply from boost community Yes. These platforms are not officially supported because no one has volunteered to run regression tests regularly for them. It is not possible for a Boost developer to test on all platforms. So developers depend on the test results of regression tests run by volunteers. For example, see http://beta.boost.org/development/tests/trunk/developer/summary.html If … Read more
The nomenclature for boost::asio::streambuf is similar to that of which is defined in the C++ standard, and used across various classes in the standard template library, wherein data is written to an output stream and data is read from an input stream. For example, one could use std::cout.put() to write to the output stream, and … Read more
Boost.Asio can be used to encompass the intention of Active Object: decouple method execution from method invocation. Additional requirements will need to be handled at a higher-level, but it is not overly complex when using Boost.Asio in conjunction with other Boost libraries. Scheduler could use: boost::thread for thread abstraction. boost::thread_group to manage lifetime of threads. … Read more
In short, you need to wrap the user’s provided task with another function that will: Invoke the user function or callable object. Lock the mutex and decrement the counter. I may not be understanding all the requirements for this thread pool. Thus, for clarity, here is an explicit list as to what I believe are … Read more
boost::asio is not as thread-friendly as you would hope – there is a big lock around the epoll code in boost/asio/detail/epoll_reactor.hpp which means that only one thread can call into the kernel’s epoll syscall at a time. And for very small requests this makes all the difference (meaning you will only see roughly single-threaded performance). … Read more
The other day somebody recommended this on another thread: http://cpp-netlib.github.com/ I think this is as high-level as you will find, but I’m not sure if it’s mature enough yet (I would say it probably is since they’ve proposed it for Boost inclusion).
In short, boost::bind creates a copy of the boost::shared_ptr<Connection> that is returned from shared_from_this(), and boost::asio may create a copy of the handler. The copy of the handler will remain alive until one of the following occurs: The handler has been called by a thread from which the service’s run(), run_one(), poll() or poll_one() member … Read more
For a cryptographically secure shutdown, both parties musts execute shutdown operations on the boost::asio::ssl::stream by either invoking shutdown() or async_shutdown() and running the io_service. If the operation completes with an error_code that does not have an SSL category and was not cancelled before part of the shutdown could occur, then the connection was securely shutdown … Read more
The cancellation is safe. It’s just not robust. You didn’t account for the case when the timer wasn’t pending. You cancel it once, then, but it will just start a new async wait once the completion handler is invoked. What follows is my detailed steps on how I traced the issue. SUMMARY TL;DR Cancelling a … Read more