AMH_DSI_Response_Handler.h
Go to the documentation of this file.
00001 // -*- C++ -*- 00002 00003 //===================================================================== 00004 /** 00005 * @file AMH_DSI_Response_Handler.h 00006 * 00007 * $Id: AMH_DSI_Response_Handler.h 81429 2008-04-24 18:49:54Z johnnyw $ 00008 * 00009 * @brief Handle the Repsonse appropriately. 00010 */ 00011 //===================================================================== 00012 00013 #ifndef TAO_AMH_DSI_RESPONSE_HANDLER_H 00014 #define TAO_AMH_DSI_RESPONSE_HANDLER_H 00015 #include /**/ "ace/pre.h" 00016 00017 #include "tao/orbconf.h" 00018 00019 #if !defined (ACE_LACKS_PRAGMA_ONCE) 00020 # pragma once 00021 #endif /* ACE_LACKS_PRAGMA_ONCE */ 00022 00023 #include "tao/LocalObject.h" 00024 #include "tao/PortableServer/PortableServer.h" 00025 #include "tao/Messaging/AMH_Response_Handler.h" 00026 #include "tao/Valuetype/ValueBase.h" 00027 #include "dynamicinterface_export.h" 00028 00029 TAO_BEGIN_VERSIONED_NAMESPACE_DECL 00030 00031 class TAO_AMH_DSI_Response_Handler; 00032 typedef TAO_AMH_DSI_Response_Handler *TAO_AMH_DSI_Response_Handler_ptr; 00033 00034 /** 00035 * @class TAO_AMH_DSI_Response_Handler_var 00036 * 00037 * @brief The T_var class for response handler 00038 * 00039 * As any other pseudo object, this class has a T_var class too. 00040 * 00041 */ 00042 class TAO_DynamicInterface_Export TAO_AMH_DSI_Response_Handler_var 00043 { 00044 public: 00045 TAO_AMH_DSI_Response_Handler_var (void); 00046 TAO_AMH_DSI_Response_Handler_var (TAO_AMH_DSI_Response_Handler_ptr); 00047 TAO_AMH_DSI_Response_Handler_var ( 00048 const TAO_AMH_DSI_Response_Handler_var &); 00049 ~TAO_AMH_DSI_Response_Handler_var (void); 00050 00051 TAO_AMH_DSI_Response_Handler_var &operator= ( 00052 TAO_AMH_DSI_Response_Handler_ptr); 00053 TAO_AMH_DSI_Response_Handler_var &operator= ( 00054 const TAO_AMH_DSI_Response_Handler_var &); 00055 TAO_AMH_DSI_Response_Handler_ptr operator-> (void) const; 00056 00057 operator const TAO_AMH_DSI_Response_Handler_ptr &() const; 00058 operator TAO_AMH_DSI_Response_Handler_ptr &(); 00059 00060 TAO_AMH_DSI_Response_Handler_ptr in (void) const; 00061 TAO_AMH_DSI_Response_Handler_ptr &inout (void); 00062 TAO_AMH_DSI_Response_Handler_ptr &out (void); 00063 TAO_AMH_DSI_Response_Handler_ptr _retn (void); 00064 TAO_AMH_DSI_Response_Handler_ptr ptr (void) const; 00065 00066 private: 00067 TAO_AMH_DSI_Response_Handler_ptr ptr_; 00068 }; 00069 00070 class TAO_AMH_DSI_Exception_Holder; 00071 typedef TAO_AMH_DSI_Exception_Holder *TAO_AMH_DSI_Exception_Holder_ptr; 00072 00073 /** 00074 * @class TAO_AMH_DSI_Exception_Holder_var 00075 * 00076 * @brief The T_var class for exception holder 00077 * 00078 * As any other pseudo object, this class has a T_var class too. 00079 * 00080 */ 00081 class TAO_DynamicInterface_Export TAO_AMH_DSI_Exception_Holder_var 00082 { 00083 public: 00084 TAO_AMH_DSI_Exception_Holder_var (void); 00085 TAO_AMH_DSI_Exception_Holder_var (TAO_AMH_DSI_Exception_Holder*); 00086 TAO_AMH_DSI_Exception_Holder_var (const TAO_AMH_DSI_Exception_Holder*); 00087 TAO_AMH_DSI_Exception_Holder_var (const TAO_AMH_DSI_Exception_Holder_var &); 00088 ~TAO_AMH_DSI_Exception_Holder_var (void); 00089 00090 TAO_AMH_DSI_Exception_Holder_var &operator= (TAO_AMH_DSI_Exception_Holder*); 00091 TAO_AMH_DSI_Exception_Holder_var &operator= ( 00092 const TAO_AMH_DSI_Exception_Holder_var &); 00093 TAO_AMH_DSI_Exception_Holder* operator-> (void) const; 00094 00095 operator const TAO_AMH_DSI_Exception_Holder* () const; 00096 operator TAO_AMH_DSI_Exception_Holder*& (); 00097 00098 TAO_AMH_DSI_Exception_Holder* in (void) const; 00099 TAO_AMH_DSI_Exception_Holder*& inout (void); 00100 TAO_AMH_DSI_Exception_Holder*& out (void); 00101 TAO_AMH_DSI_Exception_Holder* _retn (void); 00102 TAO_AMH_DSI_Exception_Holder* ptr (void) const; 00103 00104 // Hooks used by template sequence and valuetype manager classes 00105 // for non-defined forward declared valuetypes. 00106 static void tao_add_ref (TAO_AMH_DSI_Exception_Holder *); 00107 static void tao_remove_ref (TAO_AMH_DSI_Exception_Holder *); 00108 00109 private: 00110 TAO_AMH_DSI_Exception_Holder* ptr_; 00111 }; 00112 00113 /** 00114 * @class TAO_AMH_DSI_Exception_Holder_out 00115 * 00116 * @brief The T_out class for exception holder 00117 * 00118 */ 00119 class TAO_DynamicInterface_Export TAO_AMH_DSI_Exception_Holder_out 00120 { 00121 public: 00122 TAO_AMH_DSI_Exception_Holder_out (TAO_AMH_DSI_Exception_Holder* &); 00123 TAO_AMH_DSI_Exception_Holder_out (TAO_AMH_DSI_Exception_Holder_var &); 00124 TAO_AMH_DSI_Exception_Holder_out (const TAO_AMH_DSI_Exception_Holder_out &); 00125 TAO_AMH_DSI_Exception_Holder_out &operator= ( 00126 const TAO_AMH_DSI_Exception_Holder_out &); 00127 TAO_AMH_DSI_Exception_Holder_out &operator= ( 00128 const TAO_AMH_DSI_Exception_Holder_var &); 00129 TAO_AMH_DSI_Exception_Holder_out &operator= ( 00130 TAO_AMH_DSI_Exception_Holder*); 00131 operator TAO_AMH_DSI_Exception_Holder*& (); 00132 TAO_AMH_DSI_Exception_Holder*& ptr (void); 00133 TAO_AMH_DSI_Exception_Holder* operator-> (void); 00134 00135 private: 00136 TAO_AMH_DSI_Exception_Holder* &ptr_; 00137 }; 00138 00139 /** 00140 * @class TAO_AMH_DSI_Exception_Holder 00141 * 00142 * @brief This is the class for holding exception. 00143 * 00144 */ 00145 class TAO_DynamicInterface_Export TAO_AMH_DSI_Exception_Holder 00146 : public virtual CORBA::DefaultValueRefCountBase, 00147 public virtual CORBA::ValueBase 00148 { 00149 public: 00150 typedef TAO_AMH_DSI_Exception_Holder_var _var_type; 00151 TAO_AMH_DSI_Exception_Holder (CORBA::Exception *ex); 00152 00153 virtual ~TAO_AMH_DSI_Exception_Holder (void); 00154 00155 static TAO_AMH_DSI_Exception_Holder* _downcast ( CORBA::ValueBase* ); 00156 00157 static CORBA::Boolean _tao_unmarshal ( TAO_InputCDR &, 00158 TAO_AMH_DSI_Exception_Holder *& ); 00159 virtual const char* _tao_obv_repository_id (void) const; 00160 static const char* _tao_obv_static_repository_id (void); 00161 00162 static void _tao_any_destructor (void *); 00163 00164 virtual void raise_invoke ( ); 00165 00166 CORBA::TypeCode_ptr _tao_type (void) const; 00167 void _tao_obv_truncatable_repo_ids (Repository_Id_List &) const; 00168 CORBA::Boolean _tao_match_formal_type (ptrdiff_t ) const; 00169 00170 protected: 00171 TAO_AMH_DSI_Exception_Holder (void); 00172 /// *** Terrible Hack ? *** 00173 virtual CORBA::Boolean _tao_marshal_v (TAO_OutputCDR &) const; 00174 virtual CORBA::Boolean _tao_unmarshal_v (TAO_InputCDR &); 00175 00176 private: 00177 TAO_AMH_DSI_Exception_Holder (const TAO_AMH_DSI_Exception_Holder &); 00178 void operator= (const TAO_AMH_DSI_Exception_Holder &); 00179 CORBA::Exception *exception_; 00180 00181 protected: 00182 virtual CORBA::Boolean _tao_marshal__Test_TAO_AMH_DSI_Exception_Holder ( 00183 TAO_OutputCDR &); 00184 virtual CORBA::Boolean _tao_unmarshal__Test_TAO_AMH_DSI_Exception_Holder ( 00185 TAO_InputCDR &); 00186 }; 00187 00188 /** 00189 * @class TAO_AMH_DSI_Response_Handler 00190 * 00191 * @brief This is the main class for DSI using AMH. 00192 * 00193 * With ordinary DSI, the POA calls _dispatch, which in turn calls invoke 00194 * on the DSI handler. Invoke completely handles the request, and packages 00195 * the result in the request object so that it can be marshalled and sent 00196 * back to the caller. 00197 * 00198 * With the AMH variation, the DSI handler's invoke method starts the 00199 * processing, but delegates the result packaging to a response handler. 00200 * This way, if the invocation takes a long time, or involves blocking 00201 * calls, then the result handling can be managed by another thread. 00202 * This is particularly useful for gateway implementations, where the 00203 * middle tier should not have to block waiting for replies. 00204 * 00205 * As this is built on the CORBA object model, there are separate classes 00206 * representing the interface and the implementation. 00207 * 00208 */ 00209 class TAO_DynamicInterface_Export TAO_AMH_DSI_Response_Handler 00210 : public virtual TAO_AMH_Response_Handler 00211 { 00212 public: 00213 typedef TAO_AMH_DSI_Response_Handler_ptr _ptr_type; 00214 typedef TAO_AMH_DSI_Response_Handler_var _var_type; 00215 00216 TAO_AMH_DSI_Response_Handler (TAO_ServerRequest &sr); 00217 ~TAO_AMH_DSI_Response_Handler (void); 00218 00219 virtual void invoke_reply (CORBA::NVList_ptr args, 00220 CORBA::NamedValue_ptr result); 00221 00222 virtual void invoke_excep ( TAO_AMH_DSI_Exception_Holder * h); 00223 00224 virtual void invoke_location_forward (CORBA::Object_ptr fwd, 00225 CORBA::Boolean is_perm); 00226 00227 virtual void gateway_exception_reply (CORBA::ULong reply_status, 00228 TAO_OutputCDR &encap); 00229 00230 virtual void gateway_exception_reply (CORBA::ULong reply_status, 00231 TAO_InputCDR &encap); 00232 00233 /// Returns a CORBA::Object_ptr for the target object. 00234 CORBA::Object_ptr _this (); 00235 00236 /// CORBA Object related methods 00237 static TAO_AMH_DSI_Response_Handler* _duplicate ( 00238 TAO_AMH_DSI_Response_Handler_ptr); 00239 static TAO_AMH_DSI_Response_Handler* _nil (void); 00240 static TAO_AMH_DSI_Response_Handler* _narrow (CORBA::Object_ptr); 00241 static TAO_AMH_DSI_Response_Handler* _unchecked_narrow (CORBA::Object_ptr); 00242 00243 protected: 00244 00245 /// Return 0. Should never be used. 00246 virtual const char *_interface_repository_id (void) const; 00247 00248 /// Simply returns "this" 00249 virtual void *_downcast (const char *repository_id); 00250 00251 private: 00252 TAO_ORB_Core *orb_core_; 00253 }; 00254 00255 TAO_END_VERSIONED_NAMESPACE_DECL 00256 00257 #if defined (__ACE_INLINE__) 00258 # include "AMH_DSI_Response_Handler.inl" 00259 #endif /* __ACE_INLINE__ */ 00260 00261 #include /**/ "ace/post.h" 00262 #endif /* TAO_AMH_DSI_RESPONSE_HANDLER_H */
