Tue Jan 23 17:04:06 UTC 2007 Wallace Zhang <zhang_w@ociweb.com>

        * tao/DynamicInterface/AMH_DSI_Response_Handler.h:
        * tao/DynamicInterface/AMH_DSI_Response_Handler.inl:
        * tao/DynamicInterface/AMH_DSI_Response_Handler.cpp:
        * tao/DynamicInterface/DII_Reply_Handler.cpp:

          Extended TAO  for support the combination of DSI and AMH.

5 files changed, 871 insertions, 1 deletions

diff --git a/TAO/ChangeLog.oci_rt9734 b/TAO/ChangeLog.oci_rt9734
index e6b8ff7ed67..6d6a913994f 100644
--- a/TAO/ChangeLog.oci_rt9734
+++ b/TAO/ChangeLog.oci_rt9734
@@ -1,3 +1,12 @@
+Tue Jan 23 17:04:06 UTC 2007  Wallace Zhang  <zhang_w@ociweb.com>
+
+        * tao/DynamicInterface/AMH_DSI_Response_Handler.h:
+        * tao/DynamicInterface/AMH_DSI_Response_Handler.inl:
+        * tao/DynamicInterface/AMH_DSI_Response_Handler.cpp:
+        * tao/DynamicInterface/DII_Reply_Handler.cpp:
+
+          Extended TAO  for support the combination of DSI and AMH.
+
 Mon Jan 22 22:26:07 UTC 2007  Wallace Zhang  <zhang_w@ociweb.com>
 
         * tao/DynamicInterface/DII_Invocation.h:
diff --git a/TAO/tao/DynamicInterface/AMH_DSI_Response_Handler.cpp b/TAO/tao/DynamicInterface/AMH_DSI_Response_Handler.cpp
new file mode 100644
index 00000000000..541114a336b
--- /dev/null
+++ b/TAO/tao/DynamicInterface/AMH_DSI_Response_Handler.cpp
@@ -0,0 +1,487 @@
+// $Id$
+#include "Request.h"
+
+ACE_RCSID(DynamicInterface, Request, "$Id$")
+
+
+#include "ExceptionList.h"
+#include "DII_Invocation.h"
+#include "Server_Request.h"
+#include "tao/ORB_Core.h"
+#include "tao/GIOP_Utils.h"
+#include "tao/PortableServer/Root_POA.h"
+#include "AMH_DSI_Response_Handler.h"
+
+#include "tao/Valuetype/ValueFactory.h"
+#include "tao/Object.h"
+#include "tao/Pluggable_Messaging_Utils.h"
+#include "tao/AnyTypeCode/Any_Impl.h"
+
+#if !defined (__ACE_INLINE__)
+# include "AMH_DSI_Response_Handler.inl"
+#endif /* ! __ACE_INLINE__ */
+
+
+const char*
+TAO_AMH_DSI_Exception_Holder::_tao_obv_static_repository_id ()
+{
+  return "IDL:TAO_AMH_DSI_Exception_Holder:1.0";
+}
+
+TAO_AMH_DSI_Exception_Holder::~TAO_AMH_DSI_Exception_Holder()
+{
+}
+
+void
+tao_TAO_AMH_DSI_Exception_Holder_add_ref (
+    TAO_AMH_DSI_Exception_Holder *p
+  )
+{
+  CORBA::add_ref (p);
+}
+
+void
+tao_TAO_AMH_DSI_Exception_Holder_remove_ref (
+    TAO_AMH_DSI_Exception_Holder *p
+  )
+{
+  CORBA::remove_ref (p);
+}
+
+// TAO_IDL - Generated from
+// be/be_valuetype.cpp:300
+
+// *************************************************************
+// Operations for class Test::TAO_AMH_DSI_Exception_Holder_var
+// *************************************************************
+
+TAO_AMH_DSI_Exception_Holder_var::TAO_AMH_DSI_Exception_Holder_var (void)
+  : ptr_ (0)
+{}
+
+TAO_AMH_DSI_Exception_Holder_var::TAO_AMH_DSI_Exception_Holder_var (TAO_AMH_DSI_Exception_Holder* p)
+  : ptr_ (p)
+{}
+
+TAO_AMH_DSI_Exception_Holder_var::TAO_AMH_DSI_Exception_Holder_var (const TAO_AMH_DSI_Exception_Holder* p)
+  : ptr_ (ACE_const_cast (TAO_AMH_DSI_Exception_Holder *, p))
+{}
+
+TAO_AMH_DSI_Exception_Holder *
+TAO_AMH_DSI_Exception_Holder_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+TAO_AMH_DSI_Exception_Holder_var::TAO_AMH_DSI_Exception_Holder_var (const TAO_AMH_DSI_Exception_Holder_var &p)
+{
+  CORBA::add_ref (p.ptr ());
+  this->ptr_ = p.ptr ();
+}
+
+TAO_AMH_DSI_Exception_Holder_var::~TAO_AMH_DSI_Exception_Holder_var (void) // destructor
+{
+  CORBA::remove_ref (this->ptr_);
+}
+
+TAO_AMH_DSI_Exception_Holder_var &
+TAO_AMH_DSI_Exception_Holder_var::operator= (TAO_AMH_DSI_Exception_Holder *p)
+{
+  CORBA::remove_ref (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+TAO_AMH_DSI_Exception_Holder_var &
+TAO_AMH_DSI_Exception_Holder_var::operator= (const TAO_AMH_DSI_Exception_Holder_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::remove_ref (this->ptr_);
+    TAO_AMH_DSI_Exception_Holder *tmp = p.ptr ();
+    CORBA::add_ref (tmp);
+    this->ptr_ = tmp;
+  }
+
+  return *this;
+}
+
+TAO_AMH_DSI_Exception_Holder_var::operator const TAO_AMH_DSI_Exception_Holder* () const // cast
+{
+  return this->ptr_;
+}
+
+TAO_AMH_DSI_Exception_Holder_var::operator TAO_AMH_DSI_Exception_Holder*& () // cast
+{
+  return this->ptr_;
+}
+
+TAO_AMH_DSI_Exception_Holder *
+TAO_AMH_DSI_Exception_Holder_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+TAO_AMH_DSI_Exception_Holder *
+TAO_AMH_DSI_Exception_Holder_var::in (void) const
+{
+  return this->ptr_;
+}
+
+TAO_AMH_DSI_Exception_Holder *&
+TAO_AMH_DSI_Exception_Holder_var::inout (void)
+{
+  return this->ptr_;
+}
+
+TAO_AMH_DSI_Exception_Holder *&
+TAO_AMH_DSI_Exception_Holder_var::out (void)
+{
+  CORBA::remove_ref (this->ptr_);
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+TAO_AMH_DSI_Exception_Holder *
+TAO_AMH_DSI_Exception_Holder_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  TAO_AMH_DSI_Exception_Holder* tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+void
+TAO_AMH_DSI_Exception_Holder_var::tao_add_ref (
+    TAO_AMH_DSI_Exception_Holder *p
+  )
+{
+  CORBA::add_ref (p);
+}
+
+void
+TAO_AMH_DSI_Exception_Holder_var::tao_remove_ref (
+    TAO_AMH_DSI_Exception_Holder *p
+  )
+{
+  CORBA::remove_ref (p);
+}
+
+// TAO_IDL - Generated from
+// be/be_valuetype.cpp:570
+
+// *************************************************************
+// Operations for class TAO_AMH_DSI_Exception_Holder_out
+// *************************************************************
+
+TAO_AMH_DSI_Exception_Holder_out::TAO_AMH_DSI_Exception_Holder_out (TAO_AMH_DSI_Exception_Holder *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+TAO_AMH_DSI_Exception_Holder_out::TAO_AMH_DSI_Exception_Holder_out (TAO_AMH_DSI_Exception_Holder_var &p)
+  : ptr_ (p.out ())
+{
+  CORBA::remove_ref (this->ptr_);
+  this->ptr_ = 0;
+}
+
+TAO_AMH_DSI_Exception_Holder_out::TAO_AMH_DSI_Exception_Holder_out (const TAO_AMH_DSI_Exception_Holder_out &p)
+  : ptr_ (ACE_const_cast (TAO_AMH_DSI_Exception_Holder_out&, p).ptr_)
+{}
+
+TAO_AMH_DSI_Exception_Holder_out &
+TAO_AMH_DSI_Exception_Holder_out::operator= (const TAO_AMH_DSI_Exception_Holder_out &p)
+{
+  this->ptr_ = ACE_const_cast (TAO_AMH_DSI_Exception_Holder_out&, p).ptr_;
+  return *this;
+}
+
+TAO_AMH_DSI_Exception_Holder_out &
+TAO_AMH_DSI_Exception_Holder_out::operator= (const TAO_AMH_DSI_Exception_Holder_var &p)
+{
+  TAO_AMH_DSI_Exception_Holder *tmp = p.ptr ();
+  CORBA::add_ref (tmp);
+  this->ptr_ = tmp;
+  return *this;
+}
+
+TAO_AMH_DSI_Exception_Holder_out &
+TAO_AMH_DSI_Exception_Holder_out::operator= (TAO_AMH_DSI_Exception_Holder *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+TAO_AMH_DSI_Exception_Holder_out::operator TAO_AMH_DSI_Exception_Holder*& () // cast
+{
+  return this->ptr_;
+}
+
+TAO_AMH_DSI_Exception_Holder *&
+TAO_AMH_DSI_Exception_Holder_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+TAO_AMH_DSI_Exception_Holder *
+TAO_AMH_DSI_Exception_Holder_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+
+// TAO_IDL - Generated from
+// be/be_visitor_valuetype/valuetype_cs.cpp:138
+
+TAO_AMH_DSI_Exception_Holder *
+TAO_AMH_DSI_Exception_Holder::_downcast (CORBA::ValueBase *v)
+{
+  if (v == 0)
+    {
+      return 0;
+    }
+
+  return dynamic_cast<TAO_AMH_DSI_Exception_Holder *>(v);
+}
+
+const char *
+TAO_AMH_DSI_Exception_Holder::_tao_obv_repository_id (void) const
+{
+  return this->_tao_obv_static_repository_id ();
+}
+
+void
+TAO_AMH_DSI_Exception_Holder::_tao_any_destructor (void *_tao_void_pointer)
+{
+  TAO_AMH_DSI_Exception_Holder *tmp =
+    ACE_static_cast (
+        TAO_AMH_DSI_Exception_Holder *,
+        _tao_void_pointer
+      );
+  delete tmp;
+}
+
+CORBA::Boolean
+TAO_AMH_DSI_Exception_Holder::_tao_unmarshal (
+    TAO_InputCDR &strm,
+    TAO_AMH_DSI_Exception_Holder *&new_object
+  )
+{
+  CORBA::ValueBase *base = 0;
+  CORBA::ValueFactory_var factory;
+  CORBA::Boolean retval =
+    CORBA::ValueBase::_tao_unmarshal_pre (
+        strm,
+        base,
+        TAO_AMH_DSI_Exception_Holder::_tao_obv_static_repository_id ()
+      );
+
+  if (retval == 0)
+    {
+      return 0;
+    }
+
+  if (factory.in () != 0)
+    {
+      base = factory->create_for_unmarshal ();
+
+      if (base == 0)
+        {
+          return 0;  // %! except.?
+        }
+
+      retval = base->_tao_unmarshal_v (strm);
+
+      if (retval == 0)
+        {
+          return 0;
+        }
+    }
+
+  // Now base must be null or point to the unmarshaled object.
+  // Align the pointer to the right subobject.
+  new_object = TAO_AMH_DSI_Exception_Holder::_downcast (base);
+  return retval;
+}
+
+void
+TAO_AMH_DSI_Exception_Holder::raise_invoke ( ACE_ENV_SINGLE_ARG_DECL )
+    ACE_THROW_SPEC (( CORBA::SystemException ))
+{
+#if defined (TAO_HAS_EXCEPTIONS)
+  auto_ptr<CORBA::Exception> safety (this->exception);
+  // Direct throw because we don't have the ACE_TRY_ENV.
+  this->exception->_raise ();
+#else
+  // We can not use ACE_THROW here.
+  ACE_TRY_ENV.exception (this->exception);
+#endif
+}
+
+// The pseudo-object _nil method.
+TAO_AMH_DSI_Response_Handler_ptr
+TAO_AMH_DSI_Response_Handler::_nil (void)
+{
+  return (TAO_AMH_DSI_Response_Handler_ptr)0;
+}
+
+// DII Request class implementation
+
+TAO_AMH_DSI_Response_Handler::TAO_AMH_DSI_Response_Handler (TAO_ServerRequest &sr)
+  :TAO_AMH_Response_Handler (),
+   exception_type_ (TAO_GIOP_NO_EXCEPTION),
+   orb_core_ (sr.orb_core())
+{
+}
+
+TAO_AMH_DSI_Response_Handler::~TAO_AMH_DSI_Response_Handler (void)
+{
+}
+
+void
+TAO_AMH_DSI_Response_Handler::invoke_reply(CORBA::NVList_ptr args,
+                                           CORBA::NamedValue_ptr result
+                                           ACE_ENV_ARG_DECL)
+{
+  ACE_TRY
+    {
+      this->_tao_rh_init_reply(ACE_ENV_SINGLE_ARG_PARAMETER);
+      ACE_TRY_CHECK;
+
+      // Send the return value, if any.
+      if (result != 0 && result->value() != 0)
+        {
+          result->value()->impl()->marshal_value(this->_tao_out);
+          ACE_TRY_CHECK;
+        }
+
+      // Send the "inout" and "out" parameters.
+      if (args != 0)
+        {
+          args->_tao_encode (this->_tao_out,
+                             CORBA::ARG_INOUT | CORBA::ARG_OUT
+                             ACE_ENV_ARG_PARAMETER
+                             );
+          ACE_TRY_CHECK;
+        }
+      this->_tao_rh_send_reply (ACE_ENV_SINGLE_ARG_PARAMETER);
+    }
+  ACE_CATCH (CORBA::Exception, ex)
+    {
+      //      request->_tao_server_request().tao_send_reply_exception (ex);
+    }
+  ACE_ENDTRY;
+}
+
+void
+TAO_AMH_DSI_Response_Handler::invoke_excep ( TAO_AMH_DSI_Exception_Holder * h
+                                             ACE_ENV_ARG_DECL )
+  ACE_THROW_SPEC (( CORBA::SystemException ))
+{
+  ACE_TRY
+  {
+    h->raise_invoke (ACE_ENV_SINGLE_ARG_PARAMETER);
+    ACE_TRY_CHECK;
+  }
+  ACE_CATCH (CORBA::Exception, ex)
+  {
+    this->_tao_rh_send_exception (ex ACE_ENV_ARG_PARAMETER);
+    ACE_CHECK;
+  }
+  ACE_ENDTRY;
+}
+
+void
+TAO_AMH_DSI_Response_Handler::gateway_exception_reply (CORBA::ULong reply_status,
+                                                       TAO_OutputCDR &encap)
+{
+  // for this to be effective, ACE & TAO must be built with
+  // ACE_ENABLE_SWAP_ON_WRITE defined in ace/config.h
+  this->_tao_out.reset_byte_order(encap.byte_order());
+  // This reply path handles only user exceptions.
+  switch (reply_status)
+    {
+    //case TAO_PLUGGABLE_MESSAGE_USER_EXCEPTION:
+    case TAO_AMI_REPLY_USER_EXCEPTION:
+      this->exception_type_ = TAO_GIOP_USER_EXCEPTION;
+      break;
+    case TAO_AMI_REPLY_SYSTEM_EXCEPTION:
+      this->exception_type_ = TAO_GIOP_SYSTEM_EXCEPTION;
+      break;
+
+    // we don't handle location forward at this moment.
+    // need to be addressed later.
+    //
+    //case TAO_PLUGGABLE_MESSAGE_LOCATION_FORWARD:
+    //  this->exception_type_ = TAO_GIOP_LOCATION_FORWARD;
+    //  break;
+    }
+  ACE_TRY_NEW_ENV
+  {
+    this->_tao_rh_init_reply (ACE_ENV_SINGLE_ARG_PARAMETER);
+    ACE_TRY_CHECK;
+
+  // We know nothing about this exception, so we marshal it as a block
+  // of bytes. The outgoing stream's byte order has already been matched
+  // to the original source of the reply.
+    this->_tao_out.write_char_array (encap.buffer(), encap.length());
+  // This will prevent the marshaling of any parameters into this reply.
+  //  this->sent_gateway_exception_ = 1;
+    this->_tao_rh_send_reply (ACE_ENV_SINGLE_ARG_PARAMETER);
+    ACE_TRY_CHECK;
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+
+}
+
+
+
+#if 0
+void
+TAO_AMH_DSI_Response_Handler::_primary_interface (CORBA::RepositoryId *result
+                                   ACE_ENV_ARG_DECL)
+{
+}
+
+void
+TAO_AMH_DSI_Response_Handler::_is_a (CORBA::Boolean result
+                                     ACE_ENV_ARG_DECL)
+{
+}
+#endif
+
+void *
+TAO_AMH_DSI_Response_Handler::_downcast (const char *)
+{
+  return this;
+}
+
+TAO_AMH_DSI_Response_Handler_ptr
+TAO_AMH_DSI_Response_Handler::_narrow (CORBA::Object_ptr obj
+                                ACE_ENV_ARG_DECL)
+{
+  return TAO_AMH_DSI_Response_Handler::_unchecked_narrow (obj
+                                                   ACE_ENV_ARG_PARAMETER);
+}
+
+TAO_AMH_DSI_Response_Handler_ptr
+TAO_AMH_DSI_Response_Handler::_unchecked_narrow (CORBA::Object_ptr obj
+                                ACE_ENV_ARG_DECL)
+{
+  if (CORBA::is_nil (obj))
+    return TAO_AMH_DSI_Response_Handler::_nil ();
+
+  return dynamic_cast<TAO_AMH_DSI_Response_Handler_ptr>(obj);
+}
+
+const char*
+TAO_AMH_DSI_Response_Handler::_interface_repository_id (void) const
+{
+  return 0;
+}
diff --git a/TAO/tao/DynamicInterface/AMH_DSI_Response_Handler.h b/TAO/tao/DynamicInterface/AMH_DSI_Response_Handler.h
new file mode 100644
index 00000000000..5d874f450f1
--- /dev/null
+++ b/TAO/tao/DynamicInterface/AMH_DSI_Response_Handler.h
@@ -0,0 +1,265 @@
+// This may look like C, but it's really -*- C++ -*-
+// $Id$
+
+// ============================================================================
+//
+// = LIBRARY
+//    DynamicInterface
+//
+// = FILENAME
+//    AMH_DSI_Response_Handler.h
+//
+// = DESCRIPTION
+//    Header file for class TAO_AMH_DSI_Response_Handler
+//
+// = AUTHOR
+//    Irfan Pyarali <irfan@cs.wustl.edu>
+//
+// ============================================================================
+
+#ifndef TAO_AMH_DSI_RESPONSE_HANDLER_H
+#define TAO_AMH_DSI_RESPONSE_HANDLER_H
+#include "ace/pre.h"
+
+#include "tao/orbconf.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "tao/LocalObject.h"
+#include "tao/PortableServer/PortableServer.h"
+#include "tao/Messaging/AMH_Response_Handler.h"
+#include "tao/Valuetype/ValueBase.h"
+#include "dynamicinterface_export.h"
+
+class TAO_AMH_DSI_Response_Handler;
+typedef TAO_AMH_DSI_Response_Handler *TAO_AMH_DSI_Response_Handler_ptr;
+
+class TAO_DynamicInterface_Export TAO_AMH_DSI_Response_Handler_var
+{
+  // = TITLE
+  //    The T_var class for Request.
+  //
+  // = DESCRIPTION
+  //    As any other pseudo object Request must have a T_var class,
+  //    the interface an semantics are specified in the CORBA spec.
+  //
+  // = NOTE
+  //    We use TAO_AMH_DSI_Response_Handler_ptr as the _ptr type instead of
+  //    CORBA::Request_ptr, this is an attempt to reduced the cyclic
+  //    dependencies in TAO.
+  //
+public:
+  TAO_AMH_DSI_Response_Handler_var (void);
+  TAO_AMH_DSI_Response_Handler_var (TAO_AMH_DSI_Response_Handler_ptr);
+  TAO_AMH_DSI_Response_Handler_var (const TAO_AMH_DSI_Response_Handler_var &);
+  ~TAO_AMH_DSI_Response_Handler_var (void);
+
+  TAO_AMH_DSI_Response_Handler_var &operator= (TAO_AMH_DSI_Response_Handler_ptr);
+  TAO_AMH_DSI_Response_Handler_var &operator= (const TAO_AMH_DSI_Response_Handler_var &);
+  TAO_AMH_DSI_Response_Handler_ptr operator-> (void) const;
+
+  operator const TAO_AMH_DSI_Response_Handler_ptr &() const;
+  operator TAO_AMH_DSI_Response_Handler_ptr &();
+
+  // in, inout, out, _retn.
+  TAO_AMH_DSI_Response_Handler_ptr in (void) const;
+  TAO_AMH_DSI_Response_Handler_ptr &inout (void);
+  TAO_AMH_DSI_Response_Handler_ptr &out (void);
+  TAO_AMH_DSI_Response_Handler_ptr _retn (void);
+  TAO_AMH_DSI_Response_Handler_ptr ptr (void) const;
+
+private:
+  TAO_AMH_DSI_Response_Handler_ptr ptr_;
+};
+
+
+
+
+class TAO_AMH_DSI_Exception_Holder;
+typedef TAO_AMH_DSI_Exception_Holder *TAO_AMH_DSI_Exception_Holder_ptr;
+
+  // TAO_IDL - Generated from
+  // be/be_valuetype.cpp:183
+
+class TAO_DynamicInterface_Export TAO_AMH_DSI_Exception_Holder_var
+{
+public:
+  TAO_AMH_DSI_Exception_Holder_var (void);
+  TAO_AMH_DSI_Exception_Holder_var (TAO_AMH_DSI_Exception_Holder*);
+  TAO_AMH_DSI_Exception_Holder_var (const TAO_AMH_DSI_Exception_Holder*); // (TAO extension)
+  TAO_AMH_DSI_Exception_Holder_var (const TAO_AMH_DSI_Exception_Holder_var &);
+  ~TAO_AMH_DSI_Exception_Holder_var (void);
+
+  TAO_AMH_DSI_Exception_Holder_var &operator= (TAO_AMH_DSI_Exception_Holder*);
+  TAO_AMH_DSI_Exception_Holder_var &operator= (const TAO_AMH_DSI_Exception_Holder_var &);
+  TAO_AMH_DSI_Exception_Holder* operator-> (void) const;
+
+  operator const TAO_AMH_DSI_Exception_Holder* () const;
+  operator TAO_AMH_DSI_Exception_Holder*& ();
+  // in, inout, out, _retn
+  TAO_AMH_DSI_Exception_Holder* in (void) const;
+  TAO_AMH_DSI_Exception_Holder*& inout (void);
+  TAO_AMH_DSI_Exception_Holder*& out (void);
+  TAO_AMH_DSI_Exception_Holder* _retn (void);
+  TAO_AMH_DSI_Exception_Holder* ptr (void) const;
+
+  // Hooks used by template sequence and valuetype manager classes
+  // for non-defined forward declared valuetypes.
+  static void tao_add_ref (TAO_AMH_DSI_Exception_Holder *);
+  static void tao_remove_ref (TAO_AMH_DSI_Exception_Holder *);
+
+private:
+  TAO_AMH_DSI_Exception_Holder* ptr_;
+};
+
+class TAO_DynamicInterface_Export TAO_AMH_DSI_Exception_Holder_out
+{
+public:
+  TAO_AMH_DSI_Exception_Holder_out (TAO_AMH_DSI_Exception_Holder* &);
+  TAO_AMH_DSI_Exception_Holder_out (TAO_AMH_DSI_Exception_Holder_var &);
+  TAO_AMH_DSI_Exception_Holder_out (const TAO_AMH_DSI_Exception_Holder_out &);
+  TAO_AMH_DSI_Exception_Holder_out &operator= (const TAO_AMH_DSI_Exception_Holder_out &);
+  TAO_AMH_DSI_Exception_Holder_out &operator= (const TAO_AMH_DSI_Exception_Holder_var &);
+  TAO_AMH_DSI_Exception_Holder_out &operator= (TAO_AMH_DSI_Exception_Holder*);
+  operator TAO_AMH_DSI_Exception_Holder*& ();
+  TAO_AMH_DSI_Exception_Holder*& ptr (void);
+  TAO_AMH_DSI_Exception_Holder* operator-> (void);
+
+private:
+  TAO_AMH_DSI_Exception_Holder* &ptr_;
+};
+
+class TAO_DynamicInterface_Export TAO_AMH_DSI_Exception_Holder
+  : public virtual CORBA::DefaultValueRefCountBase,
+    public virtual CORBA::ValueBase
+{
+public:
+  typedef TAO_AMH_DSI_Exception_Holder_var _var_type;
+  TAO_AMH_DSI_Exception_Holder (CORBA::Exception *ex)
+  { this->exception = ex; }
+
+  virtual ~TAO_AMH_DSI_Exception_Holder (void);
+
+  static TAO_AMH_DSI_Exception_Holder* _downcast ( CORBA::ValueBase* );
+  // The address of static _downcast is implicit used as type id
+
+  // (TAO extensions or internals)
+  static CORBA::Boolean _tao_unmarshal ( TAO_InputCDR &,
+                                         TAO_AMH_DSI_Exception_Holder *& );
+  virtual const char* _tao_obv_repository_id (void) const;
+  static const char* _tao_obv_static_repository_id (void);
+
+  static void _tao_any_destructor (void *);
+
+  virtual void raise_invoke ( ACE_ENV_SINGLE_ARG_DECL )
+    ACE_THROW_SPEC (( CORBA::SystemException ));
+
+protected:
+  TAO_AMH_DSI_Exception_Holder (void);
+  // *** Terrible Hack ? ***
+  virtual CORBA::Boolean _tao_marshal_v (TAO_OutputCDR &) const { return 1; }
+  virtual CORBA::Boolean _tao_unmarshal_v (TAO_InputCDR &) { return 1; }
+
+private:
+  TAO_AMH_DSI_Exception_Holder (const TAO_AMH_DSI_Exception_Holder &);
+  void operator= (const TAO_AMH_DSI_Exception_Holder &);
+  CORBA::Exception *exception;
+
+protected:
+  virtual CORBA::Boolean _tao_marshal__Test_TAO_AMH_DSI_Exception_Holder (TAO_OutputCDR &) {return 1;}
+  virtual CORBA::Boolean _tao_unmarshal__Test_TAO_AMH_DSI_Exception_Holder (TAO_InputCDR &) {return 1;}
+};
+
+class TAO_DynamicInterface_Export TAO_AMH_DSI_Response_Handler
+  : public virtual TAO_AMH_Response_Handler
+{
+  // = TITLE
+  //    "interface" class for DSI using AMH
+  //
+  // = DESCRIPTION
+  //    With ordinary DSI, the POA calls _dispatch, which in turn calls invoke
+  //    on the DSI handler. Invoke completely handles the request, and packages
+  //    the result in the request object so that it can be marshalled and sent
+  //    back to the caller.
+  //
+  //    With the AMH variation, the DSI handler's invoke method starts the
+  //    processing, but delegates the result packaging to a response handler.
+  //    This way, if the invocation takes a long time, or involves blocking
+  //    calls, then the result handling can be managed by another thread.
+  //    This is particularly useful for gateway implementations, where the
+  //    middle tier should not have to block waiting for replies.
+  //
+  //    As this is built on the CORBA object model, there are separate classes
+  //    representing the interface and the implementation.
+public:
+  typedef TAO_AMH_DSI_Response_Handler_ptr _ptr_type;
+  typedef TAO_AMH_DSI_Response_Handler_var _var_type;
+
+  TAO_AMH_DSI_Response_Handler (TAO_ServerRequest &sr);
+  ~TAO_AMH_DSI_Response_Handler (void);
+
+  virtual void invoke_reply (CORBA::NVList_ptr args,
+                             CORBA::NamedValue_ptr result
+                             ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+  // The invoke() method receives requests issued to any CORBA object
+  // incarnated by the DSI servant and performs the processing
+  // necessary to execute the request.
+
+  virtual void invoke_excep ( TAO_AMH_DSI_Exception_Holder * h
+                              ACE_ENV_ARG_DECL )
+    ACE_THROW_SPEC (( CORBA::SystemException ));
+
+  virtual void gateway_exception_reply (CORBA::ULong reply_status,
+                                        TAO_OutputCDR &encap);
+
+#if 0
+  virtual void _primary_interface_reply (CORBA::RepositoryId *result
+                                   ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+  // The _primary_interface() method receives an ObjectId value and a
+  // POA_ptr as input parameters and returns a valid RepositoryId
+  // representing the most-derived interface for that oid.
+#endif
+
+  CORBA::Object_ptr _this (ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS);
+  // Returns a CORBA::Object_ptr for the target object.
+#if 0
+  virtual CORBA_InterfaceDef_ptr _get_interface (
+      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
+    );
+  // Query the Interface Repository for the interface definition.
+#endif
+  // CORBA Object related methods
+  static TAO_AMH_DSI_Response_Handler* _duplicate (TAO_AMH_DSI_Response_Handler_ptr);
+  static TAO_AMH_DSI_Response_Handler* _nil (void);
+  static TAO_AMH_DSI_Response_Handler* _narrow (CORBA::Object_ptr
+                                         ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+  static TAO_AMH_DSI_Response_Handler* _unchecked_narrow (CORBA::Object_ptr
+                                         ACE_ENV_ARG_DECL_WITH_DEFAULTS);
+
+protected:
+
+  virtual const char *_interface_repository_id (void) const;
+  // Return 0.  Should never be used.
+
+  virtual void *_downcast (const char *repository_id);
+  // Simply returns "this"
+
+private:
+  TAO_ORB_Core *orb_core_;
+  // TODO: why not
+  //  TAO_GIOP_ReplyStatusType exception_type_;
+  /// Exception type (will be NO_EXCEPTION in the majority of the
+  /// cases).
+  // @@ Mayur: I do not think we need this one, we can deduce the type
+  //    of reply depending on the _tao_rh_*() method called.
+  CORBA::ULong exception_type_;
+};
+
+#if defined (__ACE_INLINE__)
+# include "AMH_DSI_Response_Handler.inl"
+#endif /* __ACE_INLINE__ */
+
+#include "ace/post.h"
+#endif /* TAO_DII_RESPONSE_HANDLER_H */
diff --git a/TAO/tao/DynamicInterface/AMH_DSI_Response_Handler.inl b/TAO/tao/DynamicInterface/AMH_DSI_Response_Handler.inl
new file mode 100644
index 00000000000..f3b1f7e0c21
--- /dev/null
+++ b/TAO/tao/DynamicInterface/AMH_DSI_Response_Handler.inl
@@ -0,0 +1,110 @@
+// -*- C++ -*-
+// $Id$
+
+ACE_INLINE TAO_AMH_DSI_Response_Handler_ptr
+TAO_AMH_DSI_Response_Handler::_duplicate (TAO_AMH_DSI_Response_Handler_ptr x)
+{
+  if (x != 0)
+    {
+      x->_add_ref ();
+    }
+
+  return x;
+}
+
+// *************************************************************
+// Inline operations for class TAO_AMH_DSI_Response_Handler_var
+// *************************************************************
+
+ACE_INLINE
+TAO_AMH_DSI_Response_Handler_var::TAO_AMH_DSI_Response_Handler_var (void)
+  : ptr_ (TAO_AMH_DSI_Response_Handler::_nil ())
+{
+}
+
+ACE_INLINE
+TAO_AMH_DSI_Response_Handler_var::TAO_AMH_DSI_Response_Handler_var (TAO_AMH_DSI_Response_Handler_ptr p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+TAO_AMH_DSI_Response_Handler_var::~TAO_AMH_DSI_Response_Handler_var (void)
+{
+}
+
+ACE_INLINE TAO_AMH_DSI_Response_Handler_ptr
+TAO_AMH_DSI_Response_Handler_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+TAO_AMH_DSI_Response_Handler_var::TAO_AMH_DSI_Response_Handler_var (const TAO_AMH_DSI_Response_Handler_var &p)
+  : ptr_ (TAO_AMH_DSI_Response_Handler::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE TAO_AMH_DSI_Response_Handler_var &
+TAO_AMH_DSI_Response_Handler_var::operator= (TAO_AMH_DSI_Response_Handler_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE TAO_AMH_DSI_Response_Handler_var &
+TAO_AMH_DSI_Response_Handler_var::operator= (const TAO_AMH_DSI_Response_Handler_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = TAO_AMH_DSI_Response_Handler::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE
+TAO_AMH_DSI_Response_Handler_var::operator const TAO_AMH_DSI_Response_Handler_ptr &() const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+TAO_AMH_DSI_Response_Handler_var::operator TAO_AMH_DSI_Response_Handler_ptr &()
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_AMH_DSI_Response_Handler_ptr
+TAO_AMH_DSI_Response_Handler_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_AMH_DSI_Response_Handler_ptr
+TAO_AMH_DSI_Response_Handler_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_AMH_DSI_Response_Handler_ptr &
+TAO_AMH_DSI_Response_Handler_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_AMH_DSI_Response_Handler_ptr &
+TAO_AMH_DSI_Response_Handler_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = TAO_AMH_DSI_Response_Handler::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_AMH_DSI_Response_Handler_ptr
+TAO_AMH_DSI_Response_Handler_var::_retn (void)
+{
+  // yield ownership
+  TAO_AMH_DSI_Response_Handler_ptr val = this->ptr_;
+  this->ptr_ = TAO_AMH_DSI_Response_Handler::_nil ();
+  return val;
+}
diff --git a/TAO/tao/DynamicInterface/DII_Reply_Handler.cpp b/TAO/tao/DynamicInterface/DII_Reply_Handler.cpp
index 94e9964f1fa..a03fd856ce3 100644
--- a/TAO/tao/DynamicInterface/DII_Reply_Handler.cpp
+++ b/TAO/tao/DynamicInterface/DII_Reply_Handler.cpp
@@ -1,4 +1,3 @@
-#include "DynamicInterface/dynamicinterface_pch.h"
 #include "Request.h"
 // $Id$