From 356797cee679a3f7a2963554d7edf67c4c51498d Mon Sep 17 00:00:00 2001 From: zhangw Date: Tue, 23 Jan 2007 17:05:57 +0000 Subject: Tue Jan 23 17:04:06 UTC 2007 Wallace Zhang * 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. --- TAO/ChangeLog.oci_rt9734 | 9 + .../DynamicInterface/AMH_DSI_Response_Handler.cpp | 487 +++++++++++++++++++++ .../DynamicInterface/AMH_DSI_Response_Handler.h | 265 +++++++++++ .../DynamicInterface/AMH_DSI_Response_Handler.inl | 110 +++++ TAO/tao/DynamicInterface/DII_Reply_Handler.cpp | 1 - 5 files changed, 871 insertions(+), 1 deletion(-) create mode 100644 TAO/tao/DynamicInterface/AMH_DSI_Response_Handler.cpp create mode 100644 TAO/tao/DynamicInterface/AMH_DSI_Response_Handler.h create mode 100644 TAO/tao/DynamicInterface/AMH_DSI_Response_Handler.inl 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 + + * 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 * 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(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 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(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 +// +// ============================================================================ + +#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$ -- cgit v1.2.1