[boost] [asio] Error handling. Revisited

2 Dec 2006

      Hello,

I've read asio docs and was really impressed by this library's design.
Thank you Christopher for this contribution.
However, error handling was very annoying through all examples.

Consider handle_read_body function from chat_client.cpp:

   void handle_read_body(const boost::asio::error& error)
   {
     if (!error)
     {
       std::cout.write(read_msg_.body(), read_msg_.body_length());
       std::cout << "\n";
       boost::asio::async_read(socket_,
           boost::asio::buffer(read_msg_.data(), 
chat_message::header_length),
           boost::bind(&chat_client::handle_read_header, this,
             boost::asio::placeholders::error));
     }
     else
     {
       do_close();
     }
   }

It is a common idiom in current asio lib:

void some_handler(const boost::asio::error& error)
{
     if (!error)
     {
        // asynchronous operation succeed
     }
     else
     {
        // asynchronous operation failed
     }
}

This reminds me the motivation for the Null Object pattern:
The object has a trivial state that should be checked explicitly in 
every method. It is often better to apply the degenerated case of the 
State pattern (The Null Object pattern) and eliminate all this annoying 
checks in object's methods.

If we apply this to asio's async* methods, we should provide two 
handlers: first for success case and second for fail, for example:

socket_.async_connect(endpoint,
   boost::bind(&chat_client::handle_connect, this), // success
   boost::bind(&chat_client::handle_connect_error, this, // fail
   boost::asio::placeholders::error, ++endpoint_iterator));

I've reworked the chat_client.cpp example with an assumption that such a 
two-handlers methods are provided and the result is below.
I want to ask people in this list if they like this approach better, or not?

class chat_client
{
public:
     chat_client(boost::asio::io_service& io_service,
         tcp::resolver::iterator endpoint_iterator)
         : io_service_(io_service),
         socket_(io_service)
     {
         do_async_connect(endpoint_iterator);
     }

     void write(const chat_message& msg)
     {
         io_service_.post(boost::bind(&chat_client::do_write, this, msg));
     }

     void close()
     {
         io_service_.post(boost::bind(&chat_client::do_close, this));
     }

private:

     void handle_connect()
     {
         do_async_read_header();
     }
     void handle_connect_error(const boost::asio::error& /*error*/,
         tcp::resolver::iterator endpoint_iterator)
     {
         if (endpoint_iterator != tcp::resolver::iterator())
         {
             do_close();
             do_async_connect(endpoint_iterator);
         }
     }
     // helper function to eliminate code duplication
     void do_async_connect(tcp::resolver::iterator endpoint_iterator)
     {
         tcp::endpoint endpoint = *endpoint_iterator;
         socket_.async_connect(endpoint,
             boost::bind(&chat_client::handle_connect, this),
             boost::bind(&chat_client::handle_connect_error, this, // 
Note there
             boost::asio::placeholders::error, ++endpoint_iterator));
     }

     void handle_read_header()
     {
         if (read_msg_.decode_header())
         {
             boost::asio::async_read(socket_,
                 boost::asio::buffer(read_msg_.body(), 
read_msg_.body_length()),
                 boost::bind(&chat_client::handle_read_body, this),
                 boost::bind(&chat_client::do_close, this)); // Note there
         }
         else
         {
             do_close();
         }
     }

     void handle_read_body()
     {
         std::cout.write(read_msg_.body(), read_msg_.body_length());
         std::cout << "\n";
         do_async_read_header();
     }

     // helper function to eliminate code duplication
     void do_async_read_header()
     {
         boost::asio::async_read(socket_,
             boost::asio::buffer(read_msg_.data(), 
chat_message::header_length),
             boost::bind(&chat_client::handle_read_header, this),
             boost::bind(&chat_client::do_close, this)); // Note there
     }

     void do_write(chat_message msg)
     {
         bool write_in_progress = !write_msgs_.empty();
         write_msgs_.push_back(msg);
         if (!write_in_progress)
         {
             do_async_write();
         }
     }

     void handle_write()
     {
         write_msgs_.pop_front();
         if (!write_msgs_.empty())
         {
             do_async_write();
         }
     }

     // helper function to eliminate code duplication
     void do_async_write()
     {
         boost::asio::async_write(socket_,
             boost::asio::buffer(write_msgs_.front().data(),
             write_msgs_.front().length()),
             boost::bind(&chat_client::handle_write, this),
             boost::bind(&chat_client::do_close, this)); // Note here
     }

     void do_close()
     {
         socket_.close();
     }

private:
     boost::asio::io_service& io_service_;
     tcp::socket socket_;
     chat_message read_msg_;
     chat_message_queue write_msgs_;
};

[boost] [asio] Error handling. Revisited

Oleg Abrosimov