N.B. The Windows-specific tick_count_timer example has been removed as
it has been superseded by timers based on the standard steady_clock.
It's also not clear how to map a wrapping time source to the standard
chrono concepts.
Define BOOST_ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM to enable the
old Boost.Date_Time interface in basic_socket_streambuf and
basic_socket_iostream.
* Use asio::steady_timer rather than asio::deadline_timer.
* Use asio::dynamic_buffer rather than asio::streambuf.
* Use timed asio::io_context::run_for() function for blocking clients.
* Add example showing a custom completion token for blocking with timeouts.
for returning a C++11 std::future from an asynchronous operation's
initiating function.
To use asio::use_future, pass it to an asynchronous operation instead of
a normal completion handler. For example:
std::future<std::size_t> length =
my_socket.async_read_some(my_buffer, asio::use_future);
Where a completion handler signature has the form:
void handler(error_code ec, result_type result);
the initiating function returns a std::future templated on result_type.
In the above example, this is std::size_t. If the asynchronous operation
fails, the error_code is converted into a system_error exception and
passed back to the caller through the future.
Where a completion handler signature has the form:
void handler(error_code ec);
the initiating function returns std::future<void>. As above, an error
is passed back in the future as a system_error exception.
[SVN r84313]
stackful coroutines. It is based on the Boost.Coroutine library.
Here is an example of its use:
asio::spawn(my_strand, do_echo);
// ...
void do_echo(asio::yield_context yield)
{
try
{
char data[128];
for (;;)
{
std::size_t length =
my_socket.async_read_some(
asio::buffer(data), yield);
asio::async_write(my_socket,
asio::buffer(data, length), yield);
}
}
catch (std::exception& e)
{
// ...
}
}
The first argument to asio::spawn() may be a strand, io_service or
completion handler. This argument determines the context in which the
coroutine is permitted to execute. For example, a server's per-client
object may consist of multiple coroutines; they should all run on the
same strand so that no explicit synchronisation is required.
The second argument is a function object with signature (**):
void coroutine(asio::yield_context yield);
that specifies the code to be run as part of the coroutine. The
parameter yield may be passed to an asynchronous operation in place of
the completion handler, as in:
std::size_t length =
my_socket.async_read_some(
asio::buffer(data), yield);
This starts the asynchronous operation and suspends the coroutine. The
coroutine will be resumed automatically when the asynchronous operation
completes.
Where a completion handler signature has the form:
void handler(error_code ec, result_type result);
the initiating function returns the result_type. In the async_read_some
example above, this is std::size_t. If the asynchronous operation fails,
the error_code is converted into a system_error exception and thrown.
Where a completion handler signature has the form:
void handler(error_code ec);
the initiating function returns void. As above, an error is passed back
to the coroutine as a system_error exception.
To collect the error_code from an operation, rather than have it throw
an exception, associate the output variable with the yield_context as
follows:
error_code ec;
std::size_t length =
my_socket.async_read_some(
asio::buffer(data), yield[ec]);
**Note: if asio::spawn() is used with a custom completion handler of
type Handler, the function object signature is actually:
void coroutine(asio::basic_yield_context<Handler> yield);
[SVN r84311]
* Duration type should be signed in tick_count_timer example.
* Regenerate documentation.
* Make definition of BOOST_ASIO_MOVE_ARG and BOOST_ASIO_MOVE_CAST separate to
the definition of BOOST_ASIO_HAS_MOVE, to allow the latter to be user-defined.
[SVN r72404]
* Improve backward compatibility of the new SSL implementation.
* Add wrapper for SSL_CTX_set_default_verify_paths().
* Document which OpenSSL functions the ssl::context member functions use.
* Add SSL certificate verification callbacks, and add a new
ssl::rfc2818_verification function object for simple peer certificate
verification based on the host name.
* Use std::atomic<> when available.
* Prefer to use std::array when it is available.
* Use std::shared_ptr and std::weak_ptr when available.
* Use a lightweight scoped smart pointer.
* Fix some shadow variable warnings with g++ 4.6.
[SVN r70384]
io_service.notify_fork() at the appropriate times. Two new examples have been
added showing how to use this feature. Refs #3238, #4162.
* Clean up the handling of errors reported by the close() system call. In
particular, assume that most operating systems won't have close() fail with
EWOULDBLOCK, but if it does then set blocking mode and restart the call. If
any other error occurs we assume the descriptor is closed. Refs #3307.
* EV_ONESHOT seems to cause problems on some versions of Mac OS X, with the
io_service destructor getting stuck inside the close() system call. Use
EV_CLEAR instead. Refs #5021.
* Include function name in exception what() messages.
* Fix insufficient initialisers warning with MinGW.
* Make the shutdown_service() member functions private.
* Add archetypes for testing socket option functions.
* Add missing lock in signal_set_service::cancel().
* Fix copy/paste error in SignalHandler example.
* The signal header needs to be included in signal_set_service.hpp so that we
can use constants like NSIG and SIGRTMAX.
* Don't use Boost.Thread's convenience header. Use the header file that is
specifically for the boost::thread class instead.
[SVN r69467]
* Added support for signal handling, using a new class called
signal_set. Programs may add one or more signals to the set, and then
perform an async_wait() operation. The specified handler will be
called when one of the signals occurs. The same signal number may
registered with multiple signal_set objects, however the signal number
must be used only with Asio.
* Added handler tracking, a new debugging aid. When enabled by defining
BOOST_ASIO_ENABLE_HANDLER_TRACKING, Asio writes debugging output to
the standard error stream. The output records asynchronous operations
and the relationships between their handlers. It may be post-processed
using the included [^handlerviz.pl] tool to create a visual
representation of the handlers (requires GraphViz).
* Fixed a bug in asio::streambuf where the consume() function did not
always update the internal buffer pointers correctly. The problem may
occur when the asio::streambuf is filled with data using the standard
C++ member functions such as sputn(). (Note: the problem does not
manifest when the streambuf is populated by the Asio free functions
read(), async_read(), read_until() or async_read_until().)
* Fixed a bug on kqueue-based platforms, where reactor read operations
that return false from their perform() function are not correctly
re-registered with kqueue.
* Modified the buffers_iterator<> and ip::basic_resolver_iterator
classes so that the value_type typedefs are non-const byte types.
[SVN r69198]
* Added support for timeouts on socket iostreams, such as
ip::tcp::iostream. A timeout is set by calling expires_at() or
expires_from_now() to establish a deadline. Any socket operations
which occur past the deadline will put the iostream into a bad state.
* Added a new error() member function to socket iostreams, for
retrieving the error code from the most recent system call.
* Added a new basic_deadline_timer::cancel_one() function. This function
lets you cancel a single waiting handler on a timer. Handlers are
cancelled in FIFO order.
* Added a new transfer_exactly() completion condition. This can be used
to send or receive a specified number of bytes even if the total size
of the buffer (or buffer sequence) is larger.
* Added new free functions connect() and async_connect(). These
operations try each endpoint in a list until the socket is
successfully connected.
* Extended the buffer_size() function so that it works for buffer
sequences in addition to individual buffers.
* Added a new buffer_copy() function that can be used to copy the raw
bytes between individual buffers and buffer sequences.
* Added new non-throwing overloads of read(), read_at(), write() and
write_at() that do not require a completion condition.
* Added friendlier compiler errors for when a completion handler does
not meet the necessary type requirements. When C++0x is available
(currently supported for g++ 4.5 or later, and MSVC 10), static_assert
is also used to generate an informative error message. Checking may be
disabled by defining BOOST_ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS.
* Made the is_loopback(), is_unspecified() and is_multicast() functions
consistently available across the ip::address, ip::address_v4 and
ip::address_v6 classes. Refs #3939.
* Added new non_blocking() functions for managing the non-blocking
behaviour of a socket or descriptor. The io_control() commands named
non_blocking_io are now deprecated in favour of these new functions.
* Added new native_non_blocking() functions for managing the
non-blocking mode of the underlying socket or descriptor. These
functions are intended to allow the encapsulation of arbitrary
non-blocking system calls as asynchronous operations, in a way that is
transparent to the user of the socket object. The functions have no
effect on the behaviour of the synchronous operations of the socket or
descriptor. Refs #3307.
* Added the io_control() member function for socket acceptors.
Refs #3297.
* For consistency with the C++0x standard library, deprecated the
native_type typedefs in favour of native_handle_type, and the native()
member functions in favour of native_handle().
* Added a release() member function to posix descriptors. This function
releases ownership of the underlying native descriptor to the caller.
Refs #3900.
* Added support for sequenced packet sockets (SOCK_SEQPACKET).
* Added a new io_service::stopped() function that can be used to
determine whether the io_service has stopped (i.e. a reset() call is
needed prior to any further calls to run(), run_one(), poll() or
poll_one()).
* Reduced the copying of handler function objects.
* Added support for C++0x move construction to further reduce copying of
handler objects. Move support is enabled when compiling in -std=c++0x
mode on g++ 4.5 or higher, or when using MSVC10.
* Removed the dependency on OS-provided macros for the well-known IPv4
and IPv6 addresses. This should eliminate the annoying "missing braces
around initializer" warnings. Refs #3741.
* Reduced the size of ip::basic_endpoint<> objects (such as
ip::tcp::endpoint and ip::udp::endpoint).
* Changed the reactor backends to assume that any descriptors or sockets
added using assign() may have been dup()-ed, and so require explicit
deregistration from the reactor. Refs #4971.
* Changed the SSL error category to return error strings from the
OpenSSL library.
* Changed the separate compilation support such that, to use Asio's SSL
capabilities, you should also include 'asio/ssl/impl/src.hpp in one
source file in your program.
* Removed the deprecated member functions named io_service(). The
get_io_service() member functions should be used instead.
* Removed the deprecated typedefs resolver_query and resolver_iterator
from the ip::tcp, ip::udp and ip::icmp classes.
* Fixed a compile error on some versions of g++ due to anonymous enums.
Refs #4883.
* Added an explicit cast to the FIONBIO constant to int to suppress a
compiler warning on some platforms. Refs #5128.
* Fixed warnings reported by g++'s -Wshadow compiler option. Refs #3905.
[SVN r69194]
