ChangelogTag: Tue Jan 4 09:17:53 2005 Arvind S. Krishna <arvindk@dre.vanderbilt.edu>

14 files changed, 230 insertions, 161 deletions

diff --git a/TAO/tao/ChangeLog b/TAO/tao/ChangeLog
index 877033c9f25..cfc52fecc44 100644
--- a/TAO/tao/ChangeLog
+++ b/TAO/tao/ChangeLog
@@ -60,6 +60,14 @@ Tue Jan  4 09:17:53 2005  Arvind S. Krishna  <arvindk@dre.vanderbilt.edu>
          Factored out remoting code from the strategy classes,
          particularly, transport dependecies.
 
+       * tao/Messaging/Asynch_Invocation_Adapter.cpp:
+       * tao/Messaging/Asynch_Invocation_Adapter.h:
+         
+         If using Asynchronous communication, factored remoting code. This 
+         includes code for invoking two way operations. This inturn calls the 
+         Invocation Adapter's invoke which is already specialized for 
+         collocated operation.
+
        * tao/TAO.mpc:
          Modified mpc file to add the macro TAO_HAS_COLLOCATION that
          factores out remoting code. Additionally, several classes that
diff --git a/TAO/tao/Invocation_Endpoint_Selectors.h b/TAO/tao/Invocation_Endpoint_Selectors.h
index 04eb197a961..83deae32a86 100644
--- a/TAO/tao/Invocation_Endpoint_Selectors.h
+++ b/TAO/tao/Invocation_Endpoint_Selectors.h
@@ -61,10 +61,12 @@ public:
   /// Destructor.
   virtual ~TAO_Invocation_Endpoint_Selector (void);
 
+#if !defined (TAO_HAS_COLLOCATION)
   /// Select the endpoint and set @a r's @c profile_
   virtual void select_endpoint (TAO::Profile_Transport_Resolver *r,
                                 ACE_Time_Value *val
                                 ACE_ENV_ARG_DECL) = 0;
+#endif
 
 };
 
@@ -92,9 +94,11 @@ public:
   /// Destructor.
   virtual ~TAO_Default_Endpoint_Selector (void);
 
+#if !defined (TAO_HAS_COLLOCATION)
   virtual void select_endpoint (TAO::Profile_Transport_Resolver *r,
                                 ACE_Time_Value *val
                                 ACE_ENV_ARG_DECL);
+#endif
 };
 
 #if defined (__ACE_INLINE__)
diff --git a/TAO/tao/Messaging/Asynch_Invocation_Adapter.cpp b/TAO/tao/Messaging/Asynch_Invocation_Adapter.cpp
index 5255a103b05..dfa532011d7 100644
--- a/TAO/tao/Messaging/Asynch_Invocation_Adapter.cpp
+++ b/TAO/tao/Messaging/Asynch_Invocation_Adapter.cpp
@@ -22,155 +22,160 @@ ACE_RCSID (Messaging,
            "$Id$")
 
 
-namespace TAO
-{
-  Asynch_Invocation_Adapter::Asynch_Invocation_Adapter (CORBA::Object *target,
-                                                        Argument **args,
-                                                        int arg_number,
-                                                        const char *operation,
-                                                        int op_len,
-                                                        Collocation_Proxy_Broker *p,
-                                                        Invocation_Mode m)
-    : Invocation_Adapter (target,
-                          args,
-                          arg_number,
-                          operation,
-                          op_len,
-                          p,
-                          TAO_TWOWAY_INVOCATION,
-                          m)
-      , safe_rd_ ()
-  {
-  }
-
-  void
-  Asynch_Invocation_Adapter::invoke (
-      Messaging::ReplyHandler_ptr reply_handler_ptr,
-      const TAO_Reply_Handler_Skeleton &reply_handler_skel
-      ACE_ENV_ARG_DECL)
+  namespace TAO
   {
-    TAO_Stub *stub =
-      this->get_stub (ACE_ENV_SINGLE_ARG_PARAMETER);
-    ACE_CHECK;
-
-    if (TAO_debug_level >= 4)
-      {
-        ACE_DEBUG ((LM_DEBUG,
-                    "TAO_Messaging (%P|%t) - Asynch_Invocation_Adapter::"
-                    "invoke\n"));
-      }
-
-    // If the reply handler is nil, we do not create a reply dispatcher.
-    // The ORB will drop replies to which it cannot associate a reply
-    // dispatcher.
-    if (!CORBA::is_nil (reply_handler_ptr))
-      {
-        // New reply dispatcher on the heap or allocator, because
-        // we will go out of scope and hand over the reply dispatcher
-        // to the ORB.
-
-        TAO_Asynch_Reply_Dispatcher *rd = 0;
-
-        // Get the allocator we could use.
-        ACE_Allocator* ami_allocator =
-          stub->orb_core ()->lane_resources().ami_response_handler_allocator();
-
-        // If we have an allocator, use it, else use the heap.
-        if (ami_allocator)
-          {
-            ACE_NEW_MALLOC (rd,
-                            ACE_static_cast (TAO_Asynch_Reply_Dispatcher *,
-                              ami_allocator->malloc (sizeof (TAO_Asynch_Reply_Dispatcher))),
-                            TAO_Asynch_Reply_Dispatcher (reply_handler_skel,
-                                                         reply_handler_ptr,
-                                                         stub->orb_core (),
-                                                         ami_allocator));
-          }
-        else
-          {
-            ACE_NEW (rd,
-                     TAO_Asynch_Reply_Dispatcher (reply_handler_skel,
-                                                  reply_handler_ptr,
-                                                  stub->orb_core (),
-                                                  0));
-          }
-
-        if (rd == 0)
-          {
-            ACE_THROW (CORBA::NO_MEMORY ());
-          }
-
-        this->safe_rd_.reset (rd);
-      }
-
-    Invocation_Adapter::invoke (0, 0 ACE_ENV_ARG_PARAMETER);
-    ACE_CHECK;
-  }
-
-
-  Invocation_Status
-  Asynch_Invocation_Adapter::invoke_twoway (
-      TAO_Operation_Details &op,
-      CORBA::Object_var &effective_target,
-      Profile_Transport_Resolver &r,
-      ACE_Time_Value *&max_wait_time
-      ACE_ENV_ARG_DECL)
-  {
-    // Simple sanity check
-    if (this->mode_ != TAO_ASYNCHRONOUS_CALLBACK_INVOCATION ||
-        this->type_ != TAO_TWOWAY_INVOCATION)
-      {
-        ACE_THROW_RETURN (CORBA::INTERNAL (
-            CORBA::SystemException::_tao_minor_code (
-                TAO_DEFAULT_MINOR_CODE,
-                EINVAL),
-            CORBA::COMPLETED_NO),
-                          TAO_INVOKE_FAILURE);
-      }
-
-    if (this->safe_rd_.get ())
-      {
-        // Cache the  transport in the reply dispatcher
-        this->safe_rd_->transport (r.transport ());
-
-        // AMI Timeout Handling Begin
-        ACE_Time_Value tmp;
-
-        if (this->get_timeout (r.stub (),
-                               tmp))
-          {
-            this->safe_rd_->schedule_timer (
-                op.request_id (),
-                *max_wait_time
-                ACE_ENV_ARG_PARAMETER);
-            ACE_CHECK_RETURN (TAO_INVOKE_FAILURE);
-          }
-      }
-
-    // Loose ownership of the reply dispatcher
-    TAO::Asynch_Remote_Invocation asynch (
-       effective_target.in (),
-       r,
-       op,
-       this->safe_rd_.release ());
-
-    Invocation_Status s =
-      asynch.remote_invocation (max_wait_time
-                                ACE_ENV_ARG_PARAMETER);
-    ACE_CHECK_RETURN (TAO_INVOKE_FAILURE);
-
-    if (s == TAO_INVOKE_RESTART &&
-        asynch.is_forwarded ())
-      {
-        effective_target = asynch.steal_forwarded_reference ();
-
-        this->object_forwarded (effective_target,
-                                r.stub ()
-                                ACE_ENV_ARG_PARAMETER);
-        ACE_CHECK_RETURN (TAO_INVOKE_FAILURE);
-      }
-
-    return s;
-  }
-
-} // End namespace TAO
+    Asynch_Invocation_Adapter::Asynch_Invocation_Adapter (CORBA::Object *target,
+                                                          Argument **args,
+                                                          int arg_number,
+                                                          const char *operation,
+                                                          int op_len,
+                                                          Collocation_Proxy_Broker *p,
+                                                          Invocation_Mode m)
+      : Invocation_Adapter (target,
+                            args,
+                            arg_number,
+                            operation,
+                            op_len,
+                            p,
+                            TAO_TWOWAY_INVOCATION,
+                            m)
+      , safe_rd_ ()
+    {
+    }
+
+    void
+    Asynch_Invocation_Adapter::invoke (Messaging::ReplyHandler_ptr reply_handler_ptr,
+                                       const TAO_Reply_Handler_Skeleton &reply_handler_skel
+                                       ACE_ENV_ARG_DECL)
+    {
+      TAO_Stub *stub =
+        this->get_stub (ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_CHECK;
+
+      if (TAO_debug_level >= 4)
+        {
+          ACE_DEBUG ((LM_DEBUG,
+                      "TAO_Messaging (%P|%t) - Asynch_Invocation_Adapter::"
+                      "invoke\n"));
+        }
+
+      // If the reply handler is nil, we do not create a reply dispatcher.
+      // The ORB will drop replies to which it cannot associate a reply
+      // dispatcher.
+      if (!CORBA::is_nil (reply_handler_ptr))
+        {
+          // New reply dispatcher on the heap or allocator, because
+          // we will go out of scope and hand over the reply dispatcher
+          // to the ORB.
+
+          TAO_Asynch_Reply_Dispatcher *rd = 0;
+
+          // Get the allocator we could use.
+          ACE_Allocator* ami_allocator =
+            stub->orb_core ()->lane_resources().ami_response_handler_allocator();
+
+          // If we have an allocator, use it, else use the heap.
+          if (ami_allocator)
+            {
+              ACE_NEW_MALLOC (rd,
+                              ACE_static_cast (TAO_Asynch_Reply_Dispatcher *,
+                                               ami_allocator->malloc (sizeof (TAO_Asynch_Reply_Dispatcher))),
+                              TAO_Asynch_Reply_Dispatcher (reply_handler_skel,
+                                                           reply_handler_ptr,
+                                                           stub->orb_core (),
+                                                           ami_allocator));
+            }
+          else
+            {
+              ACE_NEW (rd,
+                       TAO_Asynch_Reply_Dispatcher (reply_handler_skel,
+                                                    reply_handler_ptr,
+                                                    stub->orb_core (),
+                                                    0));
+            }
+
+          if (rd == 0)
+            {
+              ACE_THROW (CORBA::NO_MEMORY ());
+            }
+
+          this->safe_rd_.reset (rd);
+        }
+
+      Invocation_Adapter::invoke (0, 0 ACE_ENV_ARG_PARAMETER);
+      ACE_CHECK;
+    }
+
+
+//@@ TAO_HAS_COLLOCATION -- start
+#if !defined (TAO_HAS_COLLOCATION)
+
+    Invocation_Status
+    Asynch_Invocation_Adapter::invoke_twoway (
+                                              TAO_Operation_Details &op,
+                                              CORBA::Object_var &effective_target,
+                                              Profile_Transport_Resolver &r,
+                                              ACE_Time_Value *&max_wait_time
+                                              ACE_ENV_ARG_DECL)
+    {
+      // Simple sanity check
+      if (this->mode_ != TAO_ASYNCHRONOUS_CALLBACK_INVOCATION ||
+          this->type_ != TAO_TWOWAY_INVOCATION)
+        {
+          ACE_THROW_RETURN (CORBA::INTERNAL (
+                                             CORBA::SystemException::_tao_minor_code (
+                                                                                      TAO_DEFAULT_MINOR_CODE,
+                                                                                      EINVAL),
+                                             CORBA::COMPLETED_NO),
+                            TAO_INVOKE_FAILURE);
+        }
+
+      if (this->safe_rd_.get ())
+        {
+          // Cache the  transport in the reply dispatcher
+          this->safe_rd_->transport (r.transport ());
+
+          // AMI Timeout Handling Begin
+          ACE_Time_Value tmp;
+
+          if (this->get_timeout (r.stub (),
+                                 tmp))
+            {
+              this->safe_rd_->schedule_timer (
+                                              op.request_id (),
+                                              *max_wait_time
+                                              ACE_ENV_ARG_PARAMETER);
+              ACE_CHECK_RETURN (TAO_INVOKE_FAILURE);
+            }
+        }
+
+      // Loose ownership of the reply dispatcher
+      TAO::Asynch_Remote_Invocation asynch (
+                                            effective_target.in (),
+                                            r,
+                                            op,
+                                            this->safe_rd_.release ());
+
+      Invocation_Status s =
+        asynch.remote_invocation (max_wait_time
+                                  ACE_ENV_ARG_PARAMETER);
+      ACE_CHECK_RETURN (TAO_INVOKE_FAILURE);
+
+      if (s == TAO_INVOKE_RESTART &&
+          asynch.is_forwarded ())
+        {
+          effective_target = asynch.steal_forwarded_reference ();
+
+          this->object_forwarded (effective_target,
+                                  r.stub ()
+                                  ACE_ENV_ARG_PARAMETER);
+          ACE_CHECK_RETURN (TAO_INVOKE_FAILURE);
+        }
+
+      return s;
+    }
+
+#endif
+//@@ TAO_HAS_COLLOCATION -- start
+
+  } // End namespace TAO
diff --git a/TAO/tao/Messaging/Asynch_Invocation_Adapter.h b/TAO/tao/Messaging/Asynch_Invocation_Adapter.h
index 43c9310ef76..fb08a5318fc 100644
--- a/TAO/tao/Messaging/Asynch_Invocation_Adapter.h
+++ b/TAO/tao/Messaging/Asynch_Invocation_Adapter.h
@@ -7,7 +7,8 @@
  *  $Id$
  *
  *
- *  @author Balachandran Natarajan <bala@dre.vanderbilt.edu>
+ *  @author Originally Balachandran Natarajan <bala@dre.vanderbilt.edu>
+ *  @author Modified   Arvind S. Krishna <arvindk@dre.vanderbilt.edu>
  */
 //=============================================================================
 #ifndef TAO_MESSAGING_ASYNCH_INVOCATION_ADAPTER_H
@@ -80,12 +81,17 @@ namespace TAO
                                     ACE_ENV_ARG_DECL);
     **/
 
+//@@ TAO_HAS_COLLOCATION -- start
+#if !defined (TAO_HAS_COLLOCATION)
+
     virtual Invocation_Status invoke_twoway (
         TAO_Operation_Details &op,
         CORBA::Object_var &effective_target,
         Profile_Transport_Resolver &r,
         ACE_Time_Value *&max_wait_time
         ACE_ENV_ARG_DECL);
+#endif
+//@@ TAO_HAS_COLLOCATION -- end
 
   private:
     /// Autofunctor to manage the reply dispatcher
diff --git a/TAO/tao/Strategies/DIOP_Connection_Handler.cpp b/TAO/tao/Strategies/DIOP_Connection_Handler.cpp
index 8bddb4af377..d3cfef52746 100644
--- a/TAO/tao/Strategies/DIOP_Connection_Handler.cpp
+++ b/TAO/tao/Strategies/DIOP_Connection_Handler.cpp
@@ -10,7 +10,7 @@
 #include "tao/ORB.h"
 #include "tao/CDR.h"
 #include "tao/Server_Strategy_Factory.h"
-#include "tao/Transport_Cache_Manager.h"
+//#include "tao/Transport_Cache_Manager.h"
 #include "tao/Thread_Lane_Resources.h"
 #include "tao/Base_Transport_Property.h"
 #include "tao/Protocols_Hooks.h"
@@ -48,18 +48,20 @@ TAO_DIOP_Connection_Handler::TAO_DIOP_Connection_Handler (TAO_ORB_Core *orb_core
     TAO_Connection_Handler (orb_core),
     dscp_codepoint_ (IPDSFIELD_DSCP_DEFAULT << 2)
 {
+  /*
   TAO_DIOP_Transport* specific_transport = 0;
   ACE_NEW (specific_transport,
            TAO_DIOP_Transport(this, orb_core, flag));
 
   // store this pointer (indirectly increment ref count)
   this->transport (specific_transport);
+  */
 }
 
 
 TAO_DIOP_Connection_Handler::~TAO_DIOP_Connection_Handler (void)
 {
-  delete this->transport ();
+  //delete this->transport ();
   this->udp_socket_.close ();
 }
 
@@ -115,6 +117,7 @@ TAO_DIOP_Connection_Handler::open_handler (void *v)
 int
 TAO_DIOP_Connection_Handler::open (void*)
 {
+  /*
   // Currently, the DIOP properties are not used.  This code is here
   // for consistency with other protocols.
   TAO_DIOP_Protocol_Properties protocol_properties;
@@ -171,11 +174,15 @@ TAO_DIOP_Connection_Handler::open (void*)
   this->state_changed (TAO_LF_Event::LFS_SUCCESS);
 
   return 0;
+  */
+
+  return 0;
 }
 
 int
 TAO_DIOP_Connection_Handler::open_server (void)
 {
+  /*
   this->udp_socket_.open (this->local_addr_);
   if( TAO_debug_level > 5)
   {
@@ -190,6 +197,8 @@ TAO_DIOP_Connection_Handler::open_server (void)
   this->transport ()->id ((size_t) this->get_handle ());
 
   return 0;
+  */
+  return 0;
 }
 
 int
diff --git a/TAO/tao/Strategies/DIOP_Connection_Handler.h b/TAO/tao/Strategies/DIOP_Connection_Handler.h
index ea8de503f81..fe4e98c6b70 100644
--- a/TAO/tao/Strategies/DIOP_Connection_Handler.h
+++ b/TAO/tao/Strategies/DIOP_Connection_Handler.h
@@ -28,6 +28,7 @@
 #include "ace/Acceptor.h"
 
 #include "tao/Wait_Strategy.h"
+
 #include "tao/Connection_Handler.h"
 #include "DIOP_Transport.h"
 #include "ace/SOCK_Dgram.h"
@@ -51,13 +52,14 @@ class TAO_Pluggable_Messaging;
 class TAO_Strategies_Export TAO_DIOP_Connection_Handler :
   public TAO_DIOP_SVC_HANDLER,
   public TAO_Connection_Handler
+
 {
 
 public:
 
   TAO_DIOP_Connection_Handler (ACE_Thread_Manager* t = 0);
 
-  /// Constructor. 
+  /// Constructor.
   TAO_DIOP_Connection_Handler (TAO_ORB_Core *orb_core,
                                CORBA::Boolean flag);
 
@@ -129,7 +131,7 @@ public:
 
   /// Set Diff-Serv codepoint on outgoing packets.
   int set_dscp_codepoint (CORBA::Boolean set_network_priority);
-  
+
 protected:
 
   //@{
diff --git a/TAO/tao/Strategies/DIOP_Connector.cpp b/TAO/tao/Strategies/DIOP_Connector.cpp
index 54cc6fc956e..eaa28fe9c19 100644
--- a/TAO/tao/Strategies/DIOP_Connector.cpp
+++ b/TAO/tao/Strategies/DIOP_Connector.cpp
@@ -153,12 +153,15 @@ TAO_DIOP_Connector::make_connection (TAO::Profile_Transport_Resolver *,
                     svc_handler->get_handle ()));
    }
 
+  /*
   // @@ Michael: We do not use regular connection management.
   svc_handler->add_reference ();
   TAO_Transport *transport =
     svc_handler->transport ();
 
   return transport;
+  */
+  return 0;
 }
 
 TAO_Profile *
diff --git a/TAO/tao/Strategies/DIOP_Factory.cpp b/TAO/tao/Strategies/DIOP_Factory.cpp
index ef5755dde44..991abe71e23 100644
--- a/TAO/tao/Strategies/DIOP_Factory.cpp
+++ b/TAO/tao/Strategies/DIOP_Factory.cpp
@@ -66,6 +66,7 @@ TAO_DIOP_Protocol_Factory::init (int /* argc */,
   return 0;
 }
 
+#if !defined (TAO_HAS_COLLOCATION)
 TAO_Connector *
 TAO_DIOP_Protocol_Factory::make_connector (void)
 {
@@ -76,6 +77,7 @@ TAO_DIOP_Protocol_Factory::make_connector (void)
                   0);
   return connector;
 }
+#endif
 
 int
 TAO_DIOP_Protocol_Factory::requires_explicit_endpoint (void) const
diff --git a/TAO/tao/Strategies/DIOP_Factory.h b/TAO/tao/Strategies/DIOP_Factory.h
index 5b0313bef84..af08f923e67 100644
--- a/TAO/tao/Strategies/DIOP_Factory.h
+++ b/TAO/tao/Strategies/DIOP_Factory.h
@@ -62,7 +62,11 @@ public:
    */
   //@{
   virtual TAO_Acceptor  *make_acceptor (void);
+
+#if !defined (TAO_HAS_COLLOCATION)
   virtual TAO_Connector *make_connector  (void);
+#endif
+
   virtual int requires_explicit_endpoint (void) const;
   //@}
 
diff --git a/TAO/tao/Strategies/DIOP_Transport.h b/TAO/tao/Strategies/DIOP_Transport.h
index 423b23a9317..18b139cad19 100644
--- a/TAO/tao/Strategies/DIOP_Transport.h
+++ b/TAO/tao/Strategies/DIOP_Transport.h
@@ -74,6 +74,7 @@ protected:
   //@{
 
   virtual ACE_Event_Handler * event_handler_i (void);
+
   virtual TAO_Connection_Handler *connection_handler_i (void);
   virtual TAO_Pluggable_Messaging *messaging_object (void);
 
diff --git a/TAO/tao/Strategies/SHMIOP_Connection_Handler.cpp b/TAO/tao/Strategies/SHMIOP_Connection_Handler.cpp
index 7c0cfa328a9..3bb89f11e5f 100644
--- a/TAO/tao/Strategies/SHMIOP_Connection_Handler.cpp
+++ b/TAO/tao/Strategies/SHMIOP_Connection_Handler.cpp
@@ -46,18 +46,20 @@ TAO_SHMIOP_Connection_Handler::TAO_SHMIOP_Connection_Handler (TAO_ORB_Core *orb_
   : TAO_SHMIOP_SVC_HANDLER (orb_core->thr_mgr (), 0, 0),
     TAO_Connection_Handler (orb_core)
 {
+  /*
   TAO_SHMIOP_Transport* specific_transport = 0;
   ACE_NEW (specific_transport,
           TAO_SHMIOP_Transport(this, orb_core, flag));
 
   // store this pointer (indirectly increment ref count)
   this->transport (specific_transport);
+  */
 }
 
 
 TAO_SHMIOP_Connection_Handler::~TAO_SHMIOP_Connection_Handler (void)
 {
-  delete this->transport ();
+  //delete this->transport ();
 }
 
 int
@@ -69,6 +71,7 @@ TAO_SHMIOP_Connection_Handler::open_handler (void *v)
 int
 TAO_SHMIOP_Connection_Handler::open (void*)
 {
+  /*
   TAO_SHMIOP_Protocol_Properties protocol_properties;
 
   // Initialize values from ORB params.
@@ -123,7 +126,7 @@ TAO_SHMIOP_Connection_Handler::open (void*)
                                 sizeof (protocol_properties.no_delay_)) == -1)
     return -1;
 
-#endif /* ! ACE_LACKS_TCP_NODELAY */
+#endif
 
   if (this->transport ()->wait_strategy ()->non_blocking ())
     {
@@ -163,6 +166,8 @@ TAO_SHMIOP_Connection_Handler::open (void*)
   this->state_changed (TAO_LF_Event::LFS_SUCCESS);
 
   return 0;
+  */
+  return 0;
 }
 
 int
@@ -231,6 +236,7 @@ TAO_SHMIOP_Connection_Handler::release_os_resources (void)
 int
 TAO_SHMIOP_Connection_Handler::add_transport_to_cache (void)
 {
+  /*
   ACE_INET_Addr addr;
 
   // Get the peername.
@@ -251,6 +257,8 @@ TAO_SHMIOP_Connection_Handler::add_transport_to_cache (void)
   // Add the handler to Cache
   return cache.cache_idle_transport (&prop,
                                      this->transport ());
+  */
+  return 0;
 }
 
 // ****************************************************************
diff --git a/TAO/tao/Strategies/SHMIOP_Connector.cpp b/TAO/tao/Strategies/SHMIOP_Connector.cpp
index ddce3839d9d..ab842d1dc9c 100644
--- a/TAO/tao/Strategies/SHMIOP_Connector.cpp
+++ b/TAO/tao/Strategies/SHMIOP_Connector.cpp
@@ -14,7 +14,7 @@
 #include "tao/Environment.h"
 #include "tao/Transport_Cache_Manager.h"
 #include "tao/Thread_Lane_Resources.h"
-#include "tao/Blocked_Connect_Strategy.h"
+//#include "tao/Blocked_Connect_Strategy.h"
 #include "ace/OS_NS_strings.h"
 
 ACE_RCSID (Strategies,
@@ -61,6 +61,7 @@ TAO_SHMIOP_Connector::~TAO_SHMIOP_Connector (void)
 int
 TAO_SHMIOP_Connector::open (TAO_ORB_Core *orb_core)
 {
+  /*
   this->orb_core (orb_core);
 
   // The SHMIOP always uses a blocked connect strategy
@@ -101,6 +102,8 @@ TAO_SHMIOP_Connector::open (TAO_ORB_Core *orb_core)
       this->connect_strategy_.connector ().preferred_strategy (ACE_MEM_IO::MT);
     }
   return 0;
+  */
+  return 0;
 }
 
 int
@@ -152,6 +155,7 @@ TAO_SHMIOP_Connector::make_connection (TAO::Profile_Transport_Resolver *,
                                        TAO_Transport_Descriptor_Interface &desc,
                                        ACE_Time_Value *max_wait_time)
 {
+  /*
   if (TAO_debug_level > 0)
       ACE_DEBUG ((LM_DEBUG,
                   ACE_TEXT ("TAO (%P|%t) SHMIOP_Connector::make_connection - ")
@@ -269,6 +273,8 @@ TAO_SHMIOP_Connector::make_connection (TAO::Profile_Transport_Resolver *,
     }
 
   return transport;
+  */
+  return 0;
 }
 
 TAO_Profile *
diff --git a/TAO/tao/Strategies/UIOP_Connection_Handler.cpp b/TAO/tao/Strategies/UIOP_Connection_Handler.cpp
index 57f64dccbd8..a4e24181e7b 100644
--- a/TAO/tao/Strategies/UIOP_Connection_Handler.cpp
+++ b/TAO/tao/Strategies/UIOP_Connection_Handler.cpp
@@ -48,18 +48,20 @@ TAO_UIOP_Connection_Handler::TAO_UIOP_Connection_Handler (
   : TAO_UIOP_SVC_HANDLER (orb_core->thr_mgr (), 0, 0),
     TAO_Connection_Handler (orb_core)
 {
+  /*
   TAO_UIOP_Transport* specific_transport = 0;
   ACE_NEW (specific_transport,
            TAO_UIOP_Transport (this, orb_core, flag));
 
   // store this pointer (indirectly increment ref count)
   this->transport (specific_transport);
+  */
 }
 
 
 TAO_UIOP_Connection_Handler::~TAO_UIOP_Connection_Handler (void)
 {
-  delete this->transport ();
+  //  delete this->transport ();
 }
 
 int
@@ -71,6 +73,7 @@ TAO_UIOP_Connection_Handler::open_handler (void *v)
 int
 TAO_UIOP_Connection_Handler::open (void*)
 {
+  /*
   TAO_UIOP_Protocol_Properties protocol_properties;
 
   // Initialize values from ORB params.
@@ -144,6 +147,8 @@ TAO_UIOP_Connection_Handler::open (void*)
   this->state_changed (TAO_LF_Event::LFS_SUCCESS);
 
   return 0;
+  */
+  return 0;
 }
 
 int
@@ -212,6 +217,7 @@ TAO_UIOP_Connection_Handler::release_os_resources (void)
 int
 TAO_UIOP_Connection_Handler::add_transport_to_cache (void)
 {
+  /*
   ACE_UNIX_Addr addr;
 
   // Get the peername.
@@ -230,6 +236,8 @@ TAO_UIOP_Connection_Handler::add_transport_to_cache (void)
   // Add the handler to Cache
   return cache.cache_idle_transport (&prop,
                                      this->transport ());
+  */
+  return 0;
 }
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
diff --git a/TAO/tao/Strategies/UIOP_Connector.cpp b/TAO/tao/Strategies/UIOP_Connector.cpp
index 9258c6ddf11..ff53d04f05d 100644
--- a/TAO/tao/Strategies/UIOP_Connector.cpp
+++ b/TAO/tao/Strategies/UIOP_Connector.cpp
@@ -131,7 +131,7 @@ TAO_UIOP_Connector::corbaloc_scan (const char *str, size_t &len
   return this->make_profile (ACE_ENV_SINGLE_ARG_PARAMETER);
 }
 
-               
+
 int
 TAO_UIOP_Connector::set_validate_endpoint (TAO_Endpoint *endpoint)
 {
@@ -168,6 +168,7 @@ TAO_UIOP_Connector::make_connection (TAO::Profile_Transport_Resolver *r,
                                      TAO_Transport_Descriptor_Interface &desc,
                                      ACE_Time_Value *max_wait_time)
 {
+  /*
   if (TAO_debug_level > 0)
     ACE_DEBUG ((LM_DEBUG,
                 ACE_TEXT ("TAO (%P|%t) UIUP_Connector::make_connection, ")
@@ -326,6 +327,8 @@ TAO_UIOP_Connector::make_connection (TAO::Profile_Transport_Resolver *r,
     }
 
   return transport;
+  */
+  return 0;
 }