View difference between Paste ID: 2RXqfDp0 and p8nQ5NFi

-class Protocol::AsyncHelper {
+template <class AsyncReadStream >
-  typedef boost::shared_ptr<Protocol::AsyncHelper> AsyncHelperP;
+class Protocol::AsyncHelper:
   public boost::enable_shared_from_this< Protocol::
-  AsyncHelper(Protocol &protocol) :
+                                         AsyncHelper< AsyncReadStream > > {
 
-      protocol_(protocol) {}
+
-  template <class AsyncReadStream>
+  AsyncHelper(Protocol &protocol,
-  void AsyncReadMessage(AsyncReadStream &stream,
+              AsyncReadStream &stream,
-                        AsyncReadHandler handler) {
+              AsyncReadHandler handler) :
-    AsyncHelperP ptr(this);
+
       protocol_(protocol),
-    boost::asio::async_read(stream, boost::asio::buffer(&buf[0],
+      stream_(stream),
       handler_(handler) {}
-                            boost::bind(&AsyncHelper
+
-                                        ::AsyncReadHeader<AsyncReadStream>,
+  void AsyncReadMessage() {
-                                        this,
+
-                                        boost::asio::placeholders::error,
+    boost::asio::async_read(stream_, boost::asio::buffer(&buf[0],
-                                        boost::ref(stream),
+
-                                        handler,
+                            boost::bind(&AsyncHelper::AsyncReadHeader,
-                                        ptr));
+                                        shared_from_this(),
                                         boost::asio::placeholders::error));
   }
-  template <class AsyncReadStream>
+
-  void AsyncReadHeader(const boost::system::error_code &ec,
+  void AsyncReadHeader(const boost::system::error_code &ec) {
-                       AsyncReadStream &stream,
+
-                       AsyncReadHandler handler,
+      handler_(MessageP(), ProtocolExceptionP(
-                       AsyncHelperP ptr) {
+
                                 "AsyncHelper::AsyncReadHeader.")));
-      handler(MessageP(), ProtocolExceptionP(
+      return;
     }
     uint32_t id = reinterpret_cast<uint32_t*>(&buf[0])[0];
-    } else {
+    uint32_t size = reinterpret_cast<uint32_t*>(&buf[0])[1];
-      uint32_t id = reinterpret_cast<uint32_t*>(&buf[0])[0];
+    buf.reset(new uint8_t[size]);
-      uint32_t size = reinterpret_cast<uint32_t*>(&buf[0])[1];
+    boost::asio::async_read(stream_, boost::asio::buffer(&buf[0], size),
-      buf.reset(new uint8_t[size]);
+                            boost::bind(&AsyncHelper::AsyncReadBody,
-      boost::asio::async_read(stream, boost::asio::buffer(&buf[0], size),
+                                        shared_from_this(),
-                              boost::bind(&AsyncHelper
+                                        boost::asio::placeholders::error,
-                                          ::AsyncReadBody<AsyncReadStream>,
+                                        id,
-                                          this,
+                                        size);
-                                          boost::asio::placeholders::error,
+
-                                          id,
+
-                                          size,
+
-                                          handler,
+                     uint32_t id, uint32_t size) {
-                                          ptr));
+
       handler_(MessageP(), ProtocolExceptionP(
           new ProtocolException("IO error in Protocol::"
                                 "AsyncHelper::AsyncReadBody.")));
-  template <class AsyncReadStream>
+      return;
     }
-                     uint32_t id, uint32_t size,
+
-                     AsyncReadHandler handler,
+    ProtocolExceptionP exception;
-                     AsyncHelperP ptr) {
+    MessageP message;
     try {
-      handler(MessageP(), ProtocolExceptionP(
+      message = protocol_.helpers_[id]->ReadMessage(&buf[0], size);
     } catch (ProtocolException &e) {
       exception.reset(new ProtocolException(e));
-    } else {
+
-      ProtocolExceptionP exception;
+    handler_(message, exception);
-      MessageP message;
+
-      try {
+
-        message = protocol_.helpers_[id]->ReadMessage(&buf[0], size);
+
-      } catch (ProtocolException &e) {
+
-        exception.reset(new ProtocolException(e));
+  AsyncReadStream &stream_;
-      }
+  AsyncReadHandler handler_;
-      handler(message, exception);
+
 
 template <class AsyncReadStream>
 void Protocol::AsyncReadMessage(AsyncReadStream &stream,
                                 AsyncReadHandler handler) {
   typedef AsyncHelper< AsyncReadStream > Helper;
   boost::shared_ptr< Helper > helper(new Helper(*this, stream, handler));
   helper->AsyncReadMessage();
 }