ChangeLogTag:Tue Jul 6 09:55:42 1999 Alexander Babu Arulanthu <alex@cs.wustl.edu>

11 files changed, 273 insertions, 75 deletions

diff --git a/TAO/tao/GIOP.cpp b/TAO/tao/GIOP.cpp
index 5e21c373502..fe1b4191706 100644
--- a/TAO/tao/GIOP.cpp
+++ b/TAO/tao/GIOP.cpp
@@ -230,7 +230,7 @@ TAO_GIOP::dump_msg (const char *label,
         message_name = names [slot];
       int byte_order = ptr[TAO_GIOP_MESSAGE_FLAGS_OFFSET] & 0x01;
       ACE_DEBUG ((LM_DEBUG,
-                  "%s GIOP v%c.%c msg, %d data bytes, %s endian, %s",
+                  "(%P | %t):%s GIOP v%c.%c msg, %d data bytes, %s endian, %s",
                   label,
                   digits[ptr[TAO_GIOP_VERSION_MAJOR_OFFSET]],
                   digits[ptr[TAO_GIOP_VERSION_MINOR_OFFSET]],
diff --git a/TAO/tao/IIOP_Transport.cpp b/TAO/tao/IIOP_Transport.cpp
index 8fee0534c04..5a0f052f57c 100644
--- a/TAO/tao/IIOP_Transport.cpp
+++ b/TAO/tao/IIOP_Transport.cpp
@@ -208,9 +208,12 @@ TAO_IIOP_Client_Transport::send_request (TAO_ORB_Core *orb_core,
                                   two_way) == -1)
     return -1;
 
-  return TAO_GIOP::send_message (this,
-                                 stream,
-                                 orb_core);
+  if (TAO_GIOP::send_message (this,
+                              stream,
+                              orb_core) == -1)
+    return -1;
+
+  return this->idle_after_send ();
 }
 
 // Return 0, when the reply is not read fully, 1 if it is read fully.
diff --git a/TAO/tao/Invocation.cpp b/TAO/tao/Invocation.cpp
index fe90d77a19a..89ccc86da42 100644
--- a/TAO/tao/Invocation.cpp
+++ b/TAO/tao/Invocation.cpp
@@ -10,6 +10,11 @@
 #include "tao/Pluggable.h"
 #include "tao/Connector_Registry.h"
 
+#include "tao/Wait_Strategy.h"
+// @@ This file is here so that we can call sending request method on
+//    the wait strategy. It is a hack and this should go
+//    away. (Alex). 
+
 #if !defined (__ACE_INLINE__)
 # include "tao/Invocation.i"
 #endif /* ! __ACE_INLINE__ */
@@ -66,8 +71,8 @@ ACE_TIMEPROBE_EVENT_DESCRIPTIONS (TAO_Invocation_Timeprobe_Description,
 // restructuring an ORB core in terms of asynchrony.
 
 TAO_GIOP_Invocation::TAO_GIOP_Invocation (TAO_Stub *stub,
-                                                      const char *operation,
-                                                      TAO_ORB_Core* orb_core)
+                                          const char *operation,
+                                          TAO_ORB_Core* orb_core)
   : stub_ (stub),
     opname_ (operation),
     request_id_ (0),
@@ -363,8 +368,8 @@ TAO_GIOP_Invocation::location_forward (TAO_InputCDR &inp_stream,
 
 TAO_GIOP_Twoway_Invocation::~TAO_GIOP_Twoway_Invocation (void)
 {
-  if (this->transport_ != 0)
-    this->transport_->idle ();
+
+  this->transport_->idle_after_reply ();
 }
 
 void
@@ -613,6 +618,20 @@ TAO_GIOP_Twoway_Invocation::invoke_i (CORBA::Environment &ACE_TRY_ENV)
 
   int reply_error = this->transport_->wait_for_reply ();
 
+  // Do the wait loop till we receive the reply for this invocation.
+  while (reply_error != -1 && 
+         this->transport_->reply_received (this->request_id_) != 1)
+    {
+      // @@ Hack to init the Leader-Follower state, so that we can
+      //    wait again. (Alex).
+      this->transport_->wait_strategy ()->sending_request (this->orb_core_,
+                                                           1);
+      
+      // Wait for reply.
+      reply_error = this->transport_->wait_for_reply ();
+    }
+
+  // Check the reply error.
   if (reply_error == -1)
     {
       this->close_connection ();
@@ -706,8 +725,7 @@ TAO_GIOP_Twoway_Invocation::invoke_i (CORBA::Environment &ACE_TRY_ENV)
 
 TAO_GIOP_Oneway_Invocation::~TAO_GIOP_Oneway_Invocation (void)
 {
-  if (this->transport_ != 0)
-    this->transport_->idle ();
+  this->transport_->idle_after_reply ();
 }
 
 void
@@ -730,8 +748,7 @@ TAO_GIOP_Oneway_Invocation::start (CORBA::Environment &ACE_TRY_ENV)
 
 TAO_GIOP_Locate_Request_Invocation::~TAO_GIOP_Locate_Request_Invocation (void)
 {
-  if (this->transport_ != 0)
-    this->transport_->idle ();
+  this->transport_->idle_after_reply ();
 }
 
 // Send request, block until any reply comes back. 
@@ -807,6 +824,14 @@ TAO_GIOP_Locate_Request_Invocation::invoke (CORBA::Environment &ACE_TRY_ENV)
 
   int reply_error = this->transport_->wait_for_reply ();
 
+  // Do the wait loop, till we receive the reply for this invocation. 
+  while (reply_error != -1 && 
+         this->transport_->reply_received (this->request_id_) != 1)
+    {
+      reply_error = this->transport_->wait_for_reply ();
+    }
+  
+  // Check the reply error.
   if (reply_error == -1)
     {
       this->close_connection ();
diff --git a/TAO/tao/Invocation.i b/TAO/tao/Invocation.i
index 96375b29bec..229ad64d456 100644
--- a/TAO/tao/Invocation.i
+++ b/TAO/tao/Invocation.i
@@ -31,7 +31,7 @@ TAO_GIOP_Twoway_Invocation (TAO_Stub *stub,
 ACE_INLINE TAO_InputCDR &
 TAO_GIOP_Twoway_Invocation::inp_stream (void)
 {
-  return this->rd_.message_state ()->cdr;
+  return this->rd_.reply_cdr ();
 }
 
 ACE_INLINE void
@@ -73,5 +73,5 @@ TAO_GIOP_Locate_Request_Invocation (TAO_Stub *stub,
 ACE_INLINE TAO_InputCDR &
 TAO_GIOP_Locate_Request_Invocation::inp_stream (void)
 {
-  return this->rd_.message_state ()->cdr;
+  return this->rd_. reply_cdr ();
 }
diff --git a/TAO/tao/Pluggable.cpp b/TAO/tao/Pluggable.cpp
index 47c879073a1..1758173826c 100644
--- a/TAO/tao/Pluggable.cpp
+++ b/TAO/tao/Pluggable.cpp
@@ -215,6 +215,12 @@ TAO_Transport::bind_reply_dispatcher (CORBA::ULong request_id,
                                       rd);
 }
 
+int
+TAO_Transport::wait_for_reply (void)
+{
+  return this->ws_->wait ();
+}
+
 // Read and handle the reply. Returns 0 when there is Short Read on
 // the connection. Returns 1 when the full reply is read and
 // handled. Returns -1 on errors.
@@ -233,9 +239,20 @@ TAO_Transport::register_handler (void)
 }
 
 int
-TAO_Transport::wait_for_reply (void)
+TAO_Transport::idle_after_send (void)
 {
-  return this->ws_->wait ();
+  return this->tms ()->idle_after_send (this);
+}  
+int
+TAO_Transport::idle_after_reply (void)
+{
+  return this->tms ()->idle_after_reply (this);
+}
+
+int
+TAO_Transport::reply_received (const CORBA::ULong request_id)
+{
+  return this->tms ()->reply_received (request_id);
 }
 
 void
diff --git a/TAO/tao/Pluggable.h b/TAO/tao/Pluggable.h
index 08a38a9d1f8..09a60070359 100644
--- a/TAO/tao/Pluggable.h
+++ b/TAO/tao/Pluggable.h
@@ -180,6 +180,22 @@ public:
   // Strategy if Reactor is used  for that strategy. Default
   // implementation out here returns -1 setting <errno> to ENOTSUP.
 
+  // = Setting the Transport object in Idle state. Theese methods are
+  //   routed the TMS object. The TMS starategies implement the
+  //   methods accordingly. 
+  
+  virtual int idle_after_send (void);
+  // Request has been just sent, but the reply is not received. Idle
+  // the transport now.
+  
+  virtual int idle_after_reply (void);
+  // Request is sent and the reply is received. Idle the transport
+  // now. 
+
+  virtual int reply_received (const CORBA::ULong request_id);
+  // Check with the TMS whether the reply has been receieved for the
+  // request with <request_id>.
+
 protected:
   CORBA::ULong tag_;
   // IOP protocol tag.
diff --git a/TAO/tao/Reply_Dispatcher.cpp b/TAO/tao/Reply_Dispatcher.cpp
index caa019766bc..a630ba42e7b 100644
--- a/TAO/tao/Reply_Dispatcher.cpp
+++ b/TAO/tao/Reply_Dispatcher.cpp
@@ -9,6 +9,7 @@
 
 // Constructor.
 TAO_Reply_Dispatcher::TAO_Reply_Dispatcher (void)
+  //  : reply_received_ (0)
 {
 }
 
@@ -23,11 +24,18 @@ TAO_Reply_Dispatcher::message_state (void) const
   return 0;
 }
 
+// int
+// TAO_Reply_Dispatcher::reply_received (void) const
+// {
+//   return reply_received_;
+// }
+ 
 // *********************************************************************
 
 // Constructor.
 TAO_Synch_Reply_Dispatcher::TAO_Synch_Reply_Dispatcher (void)
-  : message_state_ (0)
+  : message_state_ (0),
+    reply_cdr_ (0)
 {
 }
 
@@ -43,6 +51,8 @@ TAO_Synch_Reply_Dispatcher::dispatch_reply (CORBA::ULong reply_status,
                                             TAO_GIOP_ServiceContextList &reply_ctx,
                                             TAO_GIOP_Message_State *message_state)
 {
+  // this->reply_received_ = 1;
+
   this->reply_status_ = reply_status;
   this->version_ = version;
   this->message_state_ = message_state;
@@ -54,6 +64,16 @@ TAO_Synch_Reply_Dispatcher::dispatch_reply (CORBA::ULong reply_status,
   TAO_GIOP_ServiceContext* context_list = reply_ctx.get_buffer (1);
   this->reply_ctx_.replace (max, len, context_list, 1);
 
+  // @@ Unnecessary copying should be avoided here (Alex).
+  // @@ Carlos: I am confused about implementing this one. In the
+  //    MUXED TMS, this mess state is going to get deleted, as soon as
+  //    we return from here. So we need to save the CDR. But in the
+  //    Exclusive case, the message state will be there. So, how do we
+  //    correctly own the CDR here? (Alex).
+  ACE_NEW_RETURN (this->reply_cdr_,
+                  TAO_InputCDR (message_state->cdr.steal_contents ()),
+                  0);
+  
   return 0;
 }
 
@@ -63,6 +83,13 @@ TAO_Synch_Reply_Dispatcher::message_state (void) const
   return this->message_state_;
 }
 
+TAO_InputCDR &
+TAO_Synch_Reply_Dispatcher::reply_cdr (void) const
+{
+  return *this->reply_cdr_;
+}
+
+
 // *********************************************************************
 
 // Constructor.
@@ -85,6 +112,8 @@ TAO_Asynch_Reply_Dispatcher::dispatch_reply (CORBA::ULong reply_status,
                                              TAO_GIOP_ServiceContextList &reply_ctx,
                                              TAO_GIOP_Message_State *message_state)
 {
+  // this->reply_received_ = 1;
+  
   this->reply_status_ = reply_status;
   this->version_ = version;
   this->message_state_ = message_state;
@@ -96,10 +125,10 @@ TAO_Asynch_Reply_Dispatcher::dispatch_reply (CORBA::ULong reply_status,
   TAO_GIOP_ServiceContext* context_list = reply_ctx.get_buffer (1);
   this->reply_ctx_.replace (max, len, context_list, 1);
 
-  if (TAO_debug_level > 0)
+  if (TAO_debug_level >= 4)
     {
       ACE_DEBUG ((LM_DEBUG,
-                  "%N:%l:TAO_Asynch_Reply_Dispatcher::dispatch_reply:\n"));
+                  "(%P | %t):TAO_Asynch_Reply_Dispatcher::dispatch_reply:\n"));
     }
   
   ACE_DECLARE_NEW_CORBA_ENV;
@@ -108,6 +137,10 @@ TAO_Asynch_Reply_Dispatcher::dispatch_reply (CORBA::ULong reply_status,
   reply_handler_skel_ (message_state_->cdr,
                        reply_handler_,
                        ACE_TRY_ENV);
+  
+  // This was dynamically allocated. Now the job is done. Commit 
+  // suicide here.  
+  delete this;
                                   
   return 0;
 }
diff --git a/TAO/tao/Reply_Dispatcher.h b/TAO/tao/Reply_Dispatcher.h
index d1d00d35ab5..1c728600aa5 100644
--- a/TAO/tao/Reply_Dispatcher.h
+++ b/TAO/tao/Reply_Dispatcher.h
@@ -49,6 +49,13 @@ public:
 
   virtual TAO_GIOP_Message_State *message_state (void) const;
   // Get the Message State into which the reply has been read. 
+
+  // virtual int reply_received (void) const;
+  // Return the reply received flag.
+
+  // protected:
+  // int reply_received_;
+  // Reply received flag.
 };
 
 // *********************************************************************
@@ -89,6 +96,9 @@ public:
   virtual TAO_GIOP_Message_State *message_state (void) const;
   // Return the message state of this invocation.
 
+  virtual TAO_InputCDR &reply_cdr (void) const;
+  // Return the reply CDR.
+
 private:
   CORBA::ULong reply_status_;
   // Reply or LocateReply status.
@@ -101,6 +111,14 @@ private:
 
   TAO_GIOP_Message_State *message_state_;
   // CDR stream for reading the input.
+  // @@ Carlos : message_state should go away. All we need is the reply
+  //    cdr. Is that rite? (Alex).
+
+  TAO_InputCDR *reply_cdr_;
+  // CDR where the reply message is placed. 
+  // @@ Carlos : You mentioned that wherever this is used, we should
+  //    make sure we dont do any copying. I havent taken care of this
+  //    yet. (Alex).
 };
 
 // *********************************************************************
@@ -154,6 +172,8 @@ private:
 
   TAO_GIOP_Message_State *message_state_;
   // CDR stream for reading the input.
+  // @@ Carlos : message_state should go away. All we need is the reply
+  //    cdr. Is that rite? (Alex).
 
   const TAO_Reply_Handler_Skeleton reply_handler_skel_;
   // Skeleton for the call back method in the Reply Handler.
diff --git a/TAO/tao/Transport_Mux_Strategy.cpp b/TAO/tao/Transport_Mux_Strategy.cpp
index 3c704f45715..57e61f04aff 100644
--- a/TAO/tao/Transport_Mux_Strategy.cpp
+++ b/TAO/tao/Transport_Mux_Strategy.cpp
@@ -3,14 +3,7 @@
 #include "tao/Transport_Mux_Strategy.h"
 #include "tao/Reply_Dispatcher.h"
 #include "tao/debug.h"
-
-// @@ Alex: there is another aspect that is controlled by this
-//    strategy: the demuxed version must idle() the transport
-//    right after the request is sent, otherwise nobody else will be
-//    able to use it.
-//    The exclusive version must idle it after the reply is received,
-//    to guarantee that nobody else is using it.
-//    We may need to add a couple of methods to implement that.
+#include "tao/Pluggable.h"
 
 TAO_Transport_Mux_Strategy::TAO_Transport_Mux_Strategy (void)
 {
@@ -105,14 +98,52 @@ TAO_Exclusive_TMS::get_message_state (void)
 void
 TAO_Exclusive_TMS::destroy_message_state (TAO_GIOP_Message_State *)
 {
-  // We dont have to delete the message state. But we can reset it to
-  // receive the next incoming message.
-  // If there was a previous reply, cleanup its state first.
-  // if (this->message_state_.message_size != 0)
-  //   this->message_state_.reset ();
-  // @@ We do this already in the <bind_dispatcher>.
+  // No Op.
+}
+
+int
+TAO_Exclusive_TMS::idle_after_send (TAO_Transport *)
+{
+  // No op.
+  return 0;
+}
+  
+int
+TAO_Exclusive_TMS::idle_after_reply (TAO_Transport *transport)
+{
+  if (transport != 0)
+    return transport->idle ();
+
+  return 0;
 }
 
+int
+TAO_Exclusive_TMS::reply_received (const CORBA::ULong request_id)
+{
+  if (this->rd_ == 0)
+    {
+      // Reply should have been dispatched already.
+      return 1;
+    }
+  else if (this->request_id_ == request_id)
+    {
+      // Reply dispatcher is still here.
+      return 0;
+    }
+  else
+    {
+      // Error. Request id is not matching.
+      
+      if (TAO_debug_level > 0)
+        {
+          ACE_DEBUG ((LM_DEBUG,
+                      "(%P | %t):TAO_Exclusive_TMS::reply_received:"
+                      "Invalid request_id \n"));
+        }
+      return -1;
+    }
+}
+ 
 // *********************************************************************
 
 TAO_Muxed_TMS::TAO_Muxed_TMS (TAO_ORB_Core *orb_core)
@@ -146,7 +177,7 @@ TAO_Muxed_TMS::bind_dispatcher (CORBA::ULong request_id,
     {
       if (TAO_debug_level > 0)
         ACE_DEBUG ((LM_DEBUG,
-                    "%N:%L:TAO_Muxed_TMS::bind_dispatcher: "
+                    "(%P | %t):TAO_Muxed_TMS::bind_dispatcher: "
                     "bind dispatcher failed: result = %d\n",
                     result));
 
@@ -170,31 +201,29 @@ TAO_Muxed_TMS::dispatch_reply (CORBA::ULong request_id,
   int result = 0;
   TAO_Reply_Dispatcher *rd = 0;
 
-  // Find the reply dispatcher for this id.
+  // Grab the reply dispatcher for this id.
   result = this->dispatcher_table_.unbind (request_id, rd);
   
   if (result != 0)
     {
       if (TAO_debug_level > 0)
         ACE_DEBUG ((LM_DEBUG,
-                    "%N:%L:TAO_Muxed_TMS::dispatch_reply: "
+                    "(%P | %t):TAO_Muxed_TMS::dispatch_reply: "
                     "unbind dispatcher failed: result = %d\n",
                     result));
       
       return -1;
     }
-     
+
+  // @@ Carlos : We could save the <messagee_state> somehow and then
+  //    signal some other thread to go ahead read the incoming message
+  //    if any. Is this what you were telling me before? (Alex).
+
   // Dispatch the reply.
-  result =  rd->dispatch_reply (reply_status,
-                                version,
-                                reply_ctx,
-                                message_state);
-
-  // Delete the reply dispatcher.
-  delete rd;
-  rd = 0;
-  
-  return result;
+  return rd->dispatch_reply (reply_status,
+                             version,
+                             reply_ctx,
+                             message_state);
 }
 
 TAO_GIOP_Message_State *
@@ -218,6 +247,36 @@ TAO_Muxed_TMS::destroy_message_state (TAO_GIOP_Message_State *)
   this->message_state_ = 0;
 }
 
+int
+TAO_Muxed_TMS::idle_after_send (TAO_Transport *transport)
+{
+  if (transport != 0)
+    return transport->idle ();
+  
+  return 0;
+}
+  
+int
+TAO_Muxed_TMS::idle_after_reply (TAO_Transport *)
+{
+  return 0;
+}
+
+int
+TAO_Muxed_TMS::reply_received (const CORBA::ULong request_id)
+{
+  if (this->dispatcher_table_.find (request_id) == -1)
+    {
+      // Reply should have been dispatched already.
+      return 1;
+    }
+  else
+    {
+      // Reply dispatcher is still here.
+      return 0;
+    }
+}
+
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
 template class ACE_Hash_Map_Manager_Ex <CORBA::ULong,
                                         TAO_Reply_Dispatcher *,
diff --git a/TAO/tao/Transport_Mux_Strategy.h b/TAO/tao/Transport_Mux_Strategy.h
index 92216c6a775..73e60d2081b 100644
--- a/TAO/tao/Transport_Mux_Strategy.h
+++ b/TAO/tao/Transport_Mux_Strategy.h
@@ -76,6 +76,19 @@ public:
 
   virtual void destroy_message_state (TAO_GIOP_Message_State *) = 0;
   // Destroy a CDR stream.
+
+  virtual int idle_after_send (TAO_Transport *) = 0;
+  // Request has been just sent, but the reply is not received. Idle
+  // the transport now.
+  
+  virtual int idle_after_reply (TAO_Transport *) = 0;
+  // Request is sent and the reply is received. Idle the transport
+  // now. 
+
+  virtual int reply_received (const CORBA::ULong request_id) = 0;
+  // Check whether the reply has been receieved for the request with
+  // <request_id>. Return 0 if no, 1 on yes and -1 if the request_id
+  // is invalid or there are some errors.
 };
 
 // *********************************************************************
@@ -118,6 +131,19 @@ public:
   virtual void destroy_message_state (TAO_GIOP_Message_State *);
   // No op in this strategy.
 
+  virtual int idle_after_send (TAO_Transport *transport);
+  // Request has been just sent, but the reply is not received. Idle
+  // the transport now.
+  
+  virtual int idle_after_reply (TAO_Transport *transport);
+  // Request is sent and the reply is received. Idle the transport
+  // now. 
+  
+  virtual int reply_received (const CORBA::ULong request_id);
+  // Check whether the reply has been receieved for the request with
+  // <request_id>. Return 0 if no, 1 on yes and -1 if the request_id
+  // is invalid or there are errors.
+
 protected:
   CORBA::ULong request_id_generator_;
   // Used to generate a different request_id on each call to
@@ -173,6 +199,19 @@ public:
   virtual void destroy_message_state (TAO_GIOP_Message_State *);
   // No op in this strategy.
 
+  virtual int idle_after_send (TAO_Transport *transport);
+  // Request has been just sent, but the reply is not received. Idle
+  // the transport now.
+  
+  virtual int idle_after_reply (TAO_Transport *transport);
+  // Request is sent and the reply is received. Idle the transport
+  // now. 
+
+  virtual int reply_received (const CORBA::ULong request_id);
+  // Check whether the reply has been receieved for the request with
+  // <request_id>. Return 0 if no, 1 on yes and -1 if the request_id
+  // is invalid or there are errors.
+
 protected:
   CORBA::ULong request_id_generator_;
   // Used to generate a different request_id on each call to
diff --git a/TAO/tao/Wait_Strategy.cpp b/TAO/tao/Wait_Strategy.cpp
index 5d07a29c36f..5b9629f26f9 100644
--- a/TAO/tao/Wait_Strategy.cpp
+++ b/TAO/tao/Wait_Strategy.cpp
@@ -46,16 +46,8 @@ TAO_Wait_On_Reactor::wait (void)
   ACE_Reactor* reactor =
     this->transport_->orb_core ()->reactor ();
 
-  // @@ Carlos: Can we rely on <reply_received> flag in the AMI case?
-  //    It depends on whether we are expecting replies or not, right?
-  //    So, I think we can simply return from this loop, when some
-  //    event occurs, and the invocation guy can call us again, if it
-  //    wants to. (AMI will call, if it is expecting replies, SMI will
-  //    call if the reply is not arrived) (Alex).
-  // @@ Alex: I think you are right, let's fix it later....
-
-  // Do the event loop, till we received the reply.
-
+  // Do the event loop, till we fully receive a reply.
+  
   int result = 0;
   this->reply_received_ = 0;
   while (this->reply_received_ == 0 && result >= 0)
@@ -136,23 +128,12 @@ TAO_Wait_On_Leader_Follower::sending_request (TAO_ORB_Core *orb_core,
     //if (TAO_debug_level > 0)
     //ACE_DEBUG ((LM_DEBUG, "TAO (%P|%t) - sending request for <%x>\n",
     //this->transport_));
-
   }
 
-  // @@ Should we do here that checking for the difference in the
-  //    Reactor used??? (Alex).
-
   // Register the handler.
   this->transport_->register_handler ();
-  // @@ Carlos: We do this only if the reactor is different right?
-  //    (Alex)
-  // @@ Alex: that is taken care of in
-  //    IIOP_Transport::register_handler, but maybe we shouldn't do
-  //    this checking everytime, I recall that there was a problem
-  //    (sometime ago) about using the wrong ORB core, but that may
-  //    have been fixed...
-
-  // Send the request
+  
+  // Send the request.
   int result =
     this->TAO_Wait_Strategy::sending_request (orb_core,
                                               two_way);
@@ -213,9 +194,11 @@ TAO_Wait_On_Leader_Follower::wait (void)
       if (leader_follower.add_follower (cond) == -1)
         ACE_ERROR ((LM_ERROR,
                     "TAO (%P|%t) TAO_Wait_On_Leader_Follower::wait - "
-                    "add_follower failed for <%x>\n", cond));
+                    "add_follower failed for <%x>\n",
+                    cond));
 
-      while (!this->reply_received_ && leader_follower.leader_available ())
+      while (!this->reply_received_ &&
+             leader_follower.leader_available ())
         {
           if (cond == 0 || cond->wait () == -1)
             return -1;
@@ -233,7 +216,8 @@ TAO_Wait_On_Leader_Follower::wait (void)
       // our input. We are already removed from the follower queue.
       if (this->reply_received_ == 1)
         {
-          // But first reset our state in case we are invoked again...
+          // But first reset our state in case we are invoked
+          // again... 
           this->reply_received_ = 0;
           this->expecting_response_ = 0;
           this->calling_thread_ = ACE_OS::NULL_thread;
@@ -242,7 +226,8 @@ TAO_Wait_On_Leader_Follower::wait (void)
         }
       else if (this->reply_received_ == -1)
         {
-          // But first reset our state in case we are invoked again...
+          // But first reset our state in case we are invoked
+          // again... 
           this->reply_received_ = 0;
           this->expecting_response_ = 0;
           this->calling_thread_ = ACE_OS::NULL_thread;
@@ -334,7 +319,8 @@ TAO_Wait_On_Leader_Follower::handle_input (void)
 
   // Obtain the lock.
   ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon,
-                    orb_core->leader_follower ().lock (), -1);
+                    orb_core->leader_follower ().lock (), 
+                    -1);
 
   //  ACE_DEBUG ((LM_DEBUG, "TAO (%P|%t) - reading reply <%x>\n",
   //              this->transport_));