Updated to more closely mimic greeter_async_client.cc. Fixed typos in comments.

2 files changed, 25 insertions, 20 deletions

diff --git a/examples/cpp/helloworld/greeter_async_client.cc b/examples/cpp/helloworld/greeter_async_client.cc
index 35014267fe..c1f5eb55f0 100644
--- a/examples/cpp/helloworld/greeter_async_client.cc
+++ b/examples/cpp/helloworld/greeter_async_client.cc
@@ -53,7 +53,7 @@ class GreeterClient {
   explicit GreeterClient(std::shared_ptr<Channel> channel)
       : stub_(Greeter::NewStub(channel)) {}
 
-  // Assambles the client's payload, sends it and presents the response back
+  // Assembles the client's payload, sends it and presents the response back
   // from the server.
   std::string SayHello(const std::string& user) {
     // Data we are sending to the server.
@@ -74,9 +74,9 @@ class GreeterClient {
     // Storage for the status of the RPC upon completion.
     Status status;
 
-    // stub_->AsyncSayHello() perform the RPC call, returning an instance we
-    // store in "rpc". Because we are using the asynchronous API, we need the
-    // hold on to the "rpc" instance in order to get updates on the ongoig RPC.
+    // stub_->AsyncSayHello() performs the RPC call, returning an instance we
+    // store in "rpc". Because we are using the asynchronous API, we need to
+    // hold on to the "rpc" instance in order to get updates on the ongoing RPC.
     std::unique_ptr<ClientAsyncResponseReader<HelloReply> > rpc(
         stub_->AsyncSayHello(&context, request, &cq));
 
diff --git a/examples/cpp/helloworld/greeter_async_client2.cc b/examples/cpp/helloworld/greeter_async_client2.cc
index cdbdd1f306..0902376074 100644
--- a/examples/cpp/helloworld/greeter_async_client2.cc
+++ b/examples/cpp/helloworld/greeter_async_client2.cc
@@ -54,42 +54,49 @@ class GreeterClient {
     explicit GreeterClient(std::shared_ptr<Channel> channel)
             : stub_(Greeter::NewStub(channel)) {}
 
-    // Assambles the client's payload, sends it and presents the response back
-    // from the server.
+    // Assembles the client's payload and sends it to the server.
     void SayHello(const std::string& user) {
         // Data we are sending to the server.
         HelloRequest request;
         request.set_name(user);
 
+        // Call object to store rpc data
         AsyncClientCall* call = new AsyncClientCall;
 
-        // stub_->AsyncSayHello() perform the RPC call, returning an instance we
-        // store in "rpc". Because we are using the asynchronous API, we need the
-        // hold on to the "rpc" instance in order to get updates on the ongoing RPC.
+        // stub_->AsyncSayHello() performs the RPC call, returning an instance to
+        // store in "call". Because we are using the asynchronous API, we need to
+        // hold on to the "call" instance in order to get updates on the ongoing RPC.
         call->response_reader = stub_->AsyncSayHello(&call->context, request, &cq_);
 
 
         // Request that, upon completion of the RPC, "reply" be updated with the
         // server's response; "status" with the indication of whether the operation
-        // was successful. Tag the request with the memory address of call object.
+        // was successful. Tag the request with the memory address of the call object.
         call->response_reader->Finish(&call->reply, &call->status, (void*)call);
 
     }
 
-    // Loop while listening for completed responses
-    void AsyncCompleteRpc()
-    {
+    // Loop while listening for completed responses.
+    // Prints out the response from the server.
+    void AsyncCompleteRpc() {
         void* got_tag;
         bool ok = false;
 
         // Block until the next result is available in the completion queue "cq".
-        while (cq_.Next(&got_tag, &ok))
-        {
+        while (cq_.Next(&got_tag, &ok)) {
+            // The tag in this example is the memory location of the call object
             AsyncClientCall* call = static_cast<AsyncClientCall*>(got_tag);
-            if (ok)
+
+            // Verify that the request was completed successfully. Note that "ok"
+            // corresponds solely to the request for updates introduced by Finish().
+            GPR_ASSERT(ok);
+
+            if (call->status.ok())
                 std::cout << "Greeter received: " << call->reply.message() << std::endl;
             else
                 std::cout << "RPC failed" << std::endl;
+
+            // Once we're complete, deallocate the call object.
             delete call;
         }
     }
@@ -97,8 +104,7 @@ class GreeterClient {
   private:
 
     // struct for keeping state and data information
-    struct AsyncClientCall
-    {
+    struct AsyncClientCall {
         // Container for the data we expect from the server.
         HelloReply reply;
 
@@ -135,8 +141,7 @@ int main(int argc, char** argv) {
     // Spawn reader thread that loops indefinitely
     std::thread thread_ = std::thread(&GreeterClient::AsyncCompleteRpc, &greeter);
 
-    for (int i = 0; i < 100; i++)
-    {
+    for (int i = 0; i < 100; i++) {
         std::string user("world " + std::to_string(i));
         greeter.SayHello(user);  // The actual RPC call!
     }