Question

The sample I’m looking at in full is:

#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <boost/shared_ptr.hpp>
#include <iostream>
#include <vector>

using boost::asio::ip::tcp;

// A reference-counted non-modifiable buffer class.
class shared_const_buffer
{
public:
  // Construct from a std::string.
  explicit shared_const_buffer(const std::string& data)
    : data_(new std::vector<char>(data.begin(), data.end())),
      buffer_(boost::asio::buffer(*data_))
  {
  }
  // Implement the ConstBufferSequence requirements.
  typedef boost::asio::const_buffer value_type;
  typedef const boost::asio::const_buffer* const_iterator;
  const boost::asio::const_buffer* begin() const { return &buffer_; }
  const boost::asio::const_buffer* end() const { return &buffer_ + 1; }

private:
  boost::shared_ptr<std::vector<char> > data_;
  boost::asio::const_buffer buffer_;
};

class session
  : public boost::enable_shared_from_this<session>
{
public:
  session(boost::asio::io_service& io_service)
    : socket_(io_service)
  {
  }

  tcp::socket& socket()
  {
    return socket_;
  }

  void start()
  {
    using namespace std; // For time_t, time and ctime.
    time_t now = time(0);
    shared_const_buffer buffer(ctime(&now));
    boost::asio::async_write(socket_, buffer,
        boost::bind(&session::handle_write, shared_from_this()));
  }

  void handle_write()
  {
  }

private:
  // The socket used to communicate with the client.
  tcp::socket socket_;
};

typedef boost::shared_ptr<session> session_ptr;

class server
{
public:
  server(boost::asio::io_service& io_service, short port)
    : io_service_(io_service),
      acceptor_(io_service, tcp::endpoint(tcp::v4(), port))
  {
    session_ptr new_session(new session(io_service_));
    acceptor_.async_accept(new_session->socket(),
        boost::bind(&server::handle_accept, this, new_session,
          boost::asio::placeholders::error));
  }

  void handle_accept(session_ptr new_session,
      const boost::system::error_code& error)
  {
    if (!error)
    {
      new_session->start();
    }

    new_session.reset(new session(io_service_));
    acceptor_.async_accept(new_session->socket(),
        boost::bind(&server::handle_accept, this, new_session,
          boost::asio::placeholders::error));
  }

private:
  boost::asio::io_service& io_service_;
  tcp::acceptor acceptor_;
};

int main(int argc, char* argv[])
{
  try
  {
    if (argc != 2)
    {
      std::cerr << "Usage: reference_counted <port>\n";
      return 1;
    }

    boost::asio::io_service io_service;

    using namespace std; // For atoi.
    server s(io_service, atoi(argv[1]));

    io_service.run();
  }
  catch (std::exception& e)
  {
    std::cerr << "Exception: " << e.what() << "\n";
  }

  return 0;
}

I’m a java programmer trying to understand how boost asio work, there are some points I need help with. My questions are:

1. In these lines:

   const boost::asio::const_buffer* begin() const { return &buffer_; }
   const boost::asio::const_buffer* end() const { return &buffer_ + 1; }
   

   this shared_const_buffer is use to async_write later, so I think it should implement some kind of buffer but I don’t see any inherit signature. So define begin() and end() are enough?

2. And in these lines:

   shared_const_buffer buffer(ctime(&now));
   boost::asio::async_write(socket_, buffer, 
                            boost::bind(&session::handle_write, 
                                        shared_from_this()));    
   

   share_const_buffer has data_ is a shared pointer, but not itself, how is buffer valid until async_write actually writes the data?

Answer 1

this shared_const_buffer is use to async_write() later, so I think it
should implement some kind of buffer but I don’t see any inherit
signature. So define begin() and end() are enough?

The buffer used by the shared_const_buffer class is its _data member, a boost::shared_ptr<std::vector<char> >. Exposing iterators to the buffer is sufficient for using it with async_write().

share_const_buffer has data_ is a shared pointer, but not itself, how
is buffer valid until async_write() actually writes the data?

The shared_const_buffer class implements the asio ConstBufferSequence type requirements

  // Implement the ConstBufferSequence requirements.
  typedef boost::asio::const_buffer value_type;
  typedef const boost::asio::const_buffer* const_iterator;
  const boost::asio::const_buffer* begin() const { return &buffer_; }
  const boost::asio::const_buffer* end() const { return &buffer_ + 1; }

so when invoking async_write it is copied, the documentation explicitly states this:

buffers

One or more buffers containing the data to be written.
Although the buffers object may be copied as necessary, ownership of
the underlying memory blocks is retained by the caller, which must
guarantee that they remain valid until the handler is called.

The underlying data however, is not copied since it is retained in a shared_ptr. You can see this can be seen by sprinkling some debugging statements

--- reference_counted.cpp   2012-02-19 08:30:32.000000000 -0600
+++ reference_counted_good.cpp  2012-02-19 08:26:27.000000000 -0600
@@ -26,9 +26,7 @@
     : data_(new std::vector<char>(data.begin(), data.end())),
       buffer_(boost::asio::buffer(*data_))
   {
-      std::cout << "shared_const_buffer()" << std::endl;
   }
-  ~shared_const_buffer() { std::cout << "~shared_const_buffer() buffer use count: " << data_.use_count() << std::endl; }

   // Implement the ConstBufferSequence requirements.
   typedef boost::asio::const_buffer value_type;
@@ -66,7 +64,6 @@

   void handle_write()
   {
-      std::cout << "handle_write" << std::endl;
   }

 private:

and running it

Sam-Millers-MacBook-Pro:stackoverflow samm$ ./a.out 1234
shared_const_buffer()
~shared_const_buffer() buffer use count: 8
~shared_const_buffer() buffer use count: 7
~shared_const_buffer() buffer use count: 6
~shared_const_buffer() buffer use count: 5
~shared_const_buffer() buffer use count: 4
~shared_const_buffer() buffer use count: 3
~shared_const_buffer() buffer use count: 3
~shared_const_buffer() buffer use count: 2
handle_write
~shared_const_buffer() buffer use count: 2
~shared_const_buffer() buffer use count: 1

in another shell

Sam-Millers-MacBook-Pro:stackoverflow samm$ telnet localhost 1234
Trying ::1...
telnet: connect to address ::1: Connection refused
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
Sun Feb 19 08:22:56 2012
Connection closed by foreign host.
Sam-Millers-MacBook-Pro:stackoverflow samm$ 

So the actual buffer remains valid until the last shared_const_buffer goes out of scope and runs the descriptor