Re: Sockets in C++?

Hi John,

John Nagle wrote:
 > The basic concept of Boost's "asio" is that
 > "boost::asio::demuxer::run()" owns the main event loop and calls
 > everything else. That's a framework, not a library.

You are looking at an ancient version of Boost.Asio, and certainly one
that was before the Boost review process. The submitted proposal is
closest to 0.3.8rc2.

 > Frameworks tend to take over the program design. Try using
 > "asio". and some GUI framework which also wants to own the event
 > loop, in the same program. Sometimes multiple frameworks can be made
 > to play together using multiple threads, but it's usually not easy.

People do successfully use Boost.Asio in GUI applications. The most
common designs are to either:

- call io_service::run() in a background thread; or

- periodically call one of io_service::poll(), io_service::poll_one() or
   io_service::run_one() from a GUI-driven event (such as a timer).

In the case of using a background thread, you can customise the
invocation of the application's completion handlers so that they are
executed from the GUI's event loop.

Yes, it is possible to write programs where you turn over control to
Boost.Asio by calling io_service::run(). For certain problems this is
the right design choice, but I strongly disagree with the assertion that
it is imposed. In particular, the use of generic function objects as
callbacks (as opposed to deriving from an abstract base class as in a
traditional framework) is intended to give a lot of flexibility in the
use of the library.

For example, Boost.Asio is designed to play nicely with forthcoming
standard support for threads and futures:

    future<size_t> bytes_read;
    async_read(sock, buffer, set_this_future(bytes_read));
    ... do other stuff ...
    size_t b = bytes_read();

Alternatively, you might prefer a predominantly synchronous design and
only switch to asynchronous operations when you need to do multiple
operations at once:

    read(sock, request);
    ...
    write(sock, reply);
    ...
    error_code read_result = not_done_yet;
    async_read(sock, request, var(read_result) = _1); // Boost.Lambda
    error_code write_result = not_done_yet;
    async_write(sock, request, var(write_result) = _1);
    while (io_service.run_one())
    {
      if (read_result != not_done_yet) ...
      if (write_result != not_done_yet) ...
    }
    ...

Anyway, there are more design options than I can do justice to in one
posting. I hope the different ways in which Boost.Asio can be used
demonstrate that I have designed it to be as un-framework-like as
possible.

Cheers,
Chris

---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:std-c++@ncar.ucar.edu ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.comeaucomputing.com/csc/faq.html ]