Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   Compound Members   File Members   Related Pages  

CORBA::_TAO_Policy_Remote_Proxy_Impl Class Reference

#include <PolicyC.h>

Inheritance diagram for CORBA::_TAO_Policy_Remote_Proxy_Impl:

Inheritance graph
[legend]
Collaboration diagram for CORBA::_TAO_Policy_Remote_Proxy_Impl:

Collaboration graph
[legend]
List of all members.

Public Methods

 _TAO_Policy_Remote_Proxy_Impl (void)
virtual ~_TAO_Policy_Remote_Proxy_Impl (void)
virtual CORBA::PolicyType policy_type (CORBA_Object *_collocated_tao_target_ ACE_ENV_ARG_DECL) throw ( CORBA::SystemException )
virtual::CORBA::Policy_ptr copy (CORBA_Object *_collocated_tao_target_ ACE_ENV_ARG_DECL) throw ( CORBA::SystemException )
virtual void destroy (CORBA_Object *_collocated_tao_target_ ACE_ENV_ARG_DECL) throw ( CORBA::SystemException )

Constructor & Destructor Documentation

CORBA::_TAO_Policy_Remote_Proxy_Impl::_TAO_Policy_Remote_Proxy_Impl void   
 

Definition at line 1011 of file PolicyC.cpp.

01012 {}

virtual CORBA::_TAO_Policy_Remote_Proxy_Impl::~_TAO_Policy_Remote_Proxy_Impl void    [inline, virtual]
 

Definition at line 516 of file PolicyC.h.

00516 { }


Member Function Documentation

CORBA::Policy_ptr CORBA::_TAO_Policy_Remote_Proxy_Impl::copy CORBA_Object *_collocated_tao_target_    ACE_ENV_ARG_DECL throw ( CORBA::SystemException ) [virtual]
 

Implements CORBA::_TAO_Policy_Proxy_Impl.

Definition at line 1181 of file PolicyC.cpp.

References CORBA::Policy::_nil, CORBA::Policy_var::_retn, ACE_ANY_EXCEPTION, ACE_CATCHANY, ACE_CHECK_RETURN, ACE_ENDTRY, ACE_ENV_ARG_DECL, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_RE_THROW, ACE_THROW_RETURN, ACE_TRY, ACE_TRY_CHECK, TAO_ORB_Core::client_request_interceptors, TAO_ClientRequestInfo_i::exception, CORBA::Policy_var::inout, TAO_GIOP_Synch_Invocation::inp_stream, TAO_GIOP_Twoway_Invocation::invoke, TAO_Stub::orb_core, TAO_GIOP_Invocation::prepare_header, TAO_ClientRequestInterceptor_Adapter::receive_exception, TAO_ClientRequestInterceptor_Adapter::receive_other, TAO_ClientRequestInterceptor_Adapter::receive_reply, TAO_ClientRequestInfo_i::reply_status, TAO_ClientRequestInfo_i::response_expected, TAO_GIOP_Invocation::restart_flag, TAO_ClientRequestInfo_CORBA_Policy_copy::result, TAO_ClientRequestInterceptor_Adapter::send_request, TAO_GIOP_Twoway_Invocation::start, TAO_DEFAULT_MINOR_CODE, TAO_INTERCEPTOR, TAO_INTERCEPTOR_CHECK_RETURN, TAO_INTERCEPTOR_THROW_RETURN, TAO_INVOKE_EXCEPTION, TAO_INVOKE_RESTART, and TAO_TWOWAY_RESPONSE_FLAG.

01188 {
01189   
01190   CORBA::Policy_var _tao_retval (CORBA::Policy::_nil ());
01191 
01192 
01193   
01194   TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
01195   if (istub == 0)
01196     ACE_THROW_RETURN (CORBA::INTERNAL (),_tao_retval._retn ());
01197 
01198   
01199   TAO_GIOP_Twoway_Invocation _tao_call (
01200       istub,
01201       "copy",
01202       4,
01203       0,
01204       istub->orb_core ()
01205     );
01206   
01207   int _invoke_status;
01208   
01209 #if (TAO_HAS_INTERCEPTORS == 1)
01210   TAO_ClientRequestInterceptor_Adapter _tao_vfr (
01211       istub->orb_core ()->client_request_interceptors (),
01212       &_tao_call,
01213       _invoke_status
01214     );
01215   
01216 #endif  /* TAO_HAS_INTERCEPTORS */
01217   
01218   for (;;)
01219     {
01220       _invoke_status = TAO_INVOKE_EXCEPTION;
01221       
01222 #if TAO_HAS_INTERCEPTORS == 1
01223       TAO_ClientRequestInfo_CORBA_Policy_copy _tao_ri (
01224         &_tao_call,
01225         _collocated_tao_target_ ACE_ENV_ARG_PARAMETER
01226       );
01227             ACE_CHECK_RETURN (_tao_retval._retn ());
01228 
01229 #endif /* TAO_HAS_INTERCEPTORS */
01230       
01231       
01232       CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
01233       TAO_INTERCEPTOR (_tao_ri.response_expected (1));
01234       
01235 #if TAO_HAS_INTERCEPTORS == 1
01236       
01237       ACE_TRY
01238         {
01239           _tao_vfr.send_request (
01240             &_tao_ri
01241             ACE_ENV_ARG_PARAMETER
01242           );
01243           ACE_TRY_CHECK;
01244           
01245           if (_invoke_status == TAO_INVOKE_RESTART)
01246             {
01247               _tao_call.restart_flag (1);
01248               continue;
01249             }
01250           
01251 #endif /* TAO_HAS_INTERCEPTORS */
01252           
01253           _tao_call.start (ACE_ENV_SINGLE_ARG_PARAMETER);
01254                     TAO_INTERCEPTOR_CHECK_RETURN (_tao_retval._retn ());
01255 
01256           _tao_call.prepare_header (
01257               ACE_static_cast (CORBA::Octet, _tao_response_flag)
01258               ACE_ENV_ARG_PARAMETER
01259             );
01260                     TAO_INTERCEPTOR_CHECK_RETURN (_tao_retval._retn ());
01261 
01262           _invoke_status =
01263             _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
01264                     TAO_INTERCEPTOR_CHECK_RETURN (_tao_retval._retn ());
01265 
01266           if (_invoke_status == TAO_INVOKE_EXCEPTION)
01267             {
01268               TAO_INTERCEPTOR_THROW_RETURN (
01269                 CORBA::UNKNOWN (CORBA::OMGVMCID | 1, CORBA::COMPLETED_YES),
01270                 0
01271               );
01272               
01273             }
01274           else if (_invoke_status == TAO_INVOKE_RESTART)
01275             {
01276               TAO_INTERCEPTOR (
01277                 _tao_ri.reply_status (_invoke_status);
01278                 _tao_vfr.receive_other (
01279                   &_tao_ri
01280                   ACE_ENV_ARG_PARAMETER
01281                 );
01282                 ACE_TRY_CHECK;
01283               )
01284               
01285               continue;
01286             }
01287           
01288           TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
01289           if (!(
01290                             (_tao_in >> _tao_retval.inout ())
01291               ))
01292             {
01293               TAO_INTERCEPTOR_THROW_RETURN (
01294                 CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
01295                 0
01296               );
01297               
01298             }
01299           
01300 #if TAO_HAS_INTERCEPTORS == 1
01301           ::CORBA::Policy_ptr _tao_retval_info = _tao_retval._retn ();
01302           _tao_ri.result (_tao_retval_info);
01303           _tao_retval = _tao_retval_info;
01304           
01305           _tao_ri.reply_status (_invoke_status);
01306           _tao_vfr.receive_reply (
01307             &_tao_ri
01308             ACE_ENV_ARG_PARAMETER
01309           );
01310           ACE_TRY_CHECK;
01311         
01312       }
01313     ACE_CATCHANY
01314       {
01315         _tao_ri.exception (&ACE_ANY_EXCEPTION);
01316         _tao_vfr.receive_exception (
01317           &_tao_ri
01318           ACE_ENV_ARG_PARAMETER
01319         );
01320         ACE_TRY_CHECK;
01321         
01322         PortableInterceptor::ReplyStatus _tao_status =
01323           _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
01324         ACE_TRY_CHECK;
01325         
01326         if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
01327             || _tao_status == PortableInterceptor::USER_EXCEPTION)
01328           ACE_RE_THROW;
01329       }
01330     ACE_ENDTRY;
01331         ACE_CHECK_RETURN (_tao_retval._retn ());
01332 
01333     PortableInterceptor::ReplyStatus _tao_status =
01334       _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
01335         ACE_CHECK_RETURN (_tao_retval._retn ());
01336 
01337     if (_tao_status == PortableInterceptor::LOCATION_FORWARD
01338         || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
01339       continue;
01340     
01341 #endif  /* TAO_HAS_INTERCEPTORS */
01342     
01343     break;
01344   }
01345 return _tao_retval._retn ();
01346 }

void CORBA::_TAO_Policy_Remote_Proxy_Impl::destroy CORBA_Object *_collocated_tao_target_    ACE_ENV_ARG_DECL throw ( CORBA::SystemException ) [virtual]
 

Implements CORBA::_TAO_Policy_Proxy_Impl.

Definition at line 1348 of file PolicyC.cpp.

References ACE_ANY_EXCEPTION, ACE_CATCHANY, ACE_CHECK, ACE_ENDTRY, ACE_ENV_ARG_DECL, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_RE_THROW, ACE_THROW, ACE_TRY, ACE_TRY_CHECK, TAO_ORB_Core::client_request_interceptors, TAO_ClientRequestInfo_i::exception, TAO_GIOP_Twoway_Invocation::invoke, TAO_Stub::orb_core, TAO_GIOP_Invocation::prepare_header, TAO_ClientRequestInterceptor_Adapter::receive_exception, TAO_ClientRequestInterceptor_Adapter::receive_other, TAO_ClientRequestInterceptor_Adapter::receive_reply, TAO_ClientRequestInfo_i::reply_status, TAO_ClientRequestInfo_i::response_expected, TAO_GIOP_Invocation::restart_flag, TAO_ClientRequestInterceptor_Adapter::send_request, TAO_GIOP_Twoway_Invocation::start, TAO_INTERCEPTOR, TAO_INTERCEPTOR_CHECK, TAO_INTERCEPTOR_THROW, TAO_INVOKE_EXCEPTION, TAO_INVOKE_RESTART, and TAO_TWOWAY_RESPONSE_FLAG.

01355 {
01356   
01357   
01358   
01359   
01360   TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
01361   if (istub == 0)
01362     ACE_THROW (CORBA::INTERNAL ());
01363 
01364   
01365   TAO_GIOP_Twoway_Invocation _tao_call (
01366       istub,
01367       "destroy",
01368       7,
01369       0,
01370       istub->orb_core ()
01371     );
01372   
01373   int _invoke_status;
01374   
01375 #if (TAO_HAS_INTERCEPTORS == 1)
01376   TAO_ClientRequestInterceptor_Adapter _tao_vfr (
01377       istub->orb_core ()->client_request_interceptors (),
01378       &_tao_call,
01379       _invoke_status
01380     );
01381   
01382 #endif  /* TAO_HAS_INTERCEPTORS */
01383   
01384   for (;;)
01385     {
01386       _invoke_status = TAO_INVOKE_EXCEPTION;
01387       
01388 #if TAO_HAS_INTERCEPTORS == 1
01389       TAO_ClientRequestInfo_CORBA_Policy_destroy _tao_ri (
01390         &_tao_call,
01391         _collocated_tao_target_ ACE_ENV_ARG_PARAMETER
01392       );
01393             ACE_CHECK;
01394 
01395 #endif /* TAO_HAS_INTERCEPTORS */
01396       
01397       
01398       CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
01399       TAO_INTERCEPTOR (_tao_ri.response_expected (1));
01400       
01401 #if TAO_HAS_INTERCEPTORS == 1
01402       
01403       ACE_TRY
01404         {
01405           _tao_vfr.send_request (
01406             &_tao_ri
01407             ACE_ENV_ARG_PARAMETER
01408           );
01409           ACE_TRY_CHECK;
01410           
01411           if (_invoke_status == TAO_INVOKE_RESTART)
01412             {
01413               _tao_call.restart_flag (1);
01414               continue;
01415             }
01416           
01417 #endif /* TAO_HAS_INTERCEPTORS */
01418           
01419           _tao_call.start (ACE_ENV_SINGLE_ARG_PARAMETER);
01420                     TAO_INTERCEPTOR_CHECK;
01421 
01422           _tao_call.prepare_header (
01423               ACE_static_cast (CORBA::Octet, _tao_response_flag)
01424               ACE_ENV_ARG_PARAMETER
01425             );
01426                     TAO_INTERCEPTOR_CHECK;
01427 
01428           _invoke_status =
01429             _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
01430                     TAO_INTERCEPTOR_CHECK;
01431 
01432           if (_invoke_status == TAO_INVOKE_EXCEPTION)
01433             {
01434               TAO_INTERCEPTOR_THROW (
01435                 CORBA::UNKNOWN (CORBA::OMGVMCID | 1, CORBA::COMPLETED_YES)
01436               );
01437               
01438             }
01439           else if (_invoke_status == TAO_INVOKE_RESTART)
01440             {
01441               TAO_INTERCEPTOR (
01442                 _tao_ri.reply_status (_invoke_status);
01443                 _tao_vfr.receive_other (
01444                   &_tao_ri
01445                   ACE_ENV_ARG_PARAMETER
01446                 );
01447                 ACE_TRY_CHECK;
01448               )
01449               
01450               continue;
01451             }
01452           
01453           
01454 #if TAO_HAS_INTERCEPTORS == 1
01455           
01456           _tao_ri.reply_status (_invoke_status);
01457           _tao_vfr.receive_reply (
01458             &_tao_ri
01459             ACE_ENV_ARG_PARAMETER
01460           );
01461           ACE_TRY_CHECK;
01462         
01463       }
01464     ACE_CATCHANY
01465       {
01466         _tao_ri.exception (&ACE_ANY_EXCEPTION);
01467         _tao_vfr.receive_exception (
01468           &_tao_ri
01469           ACE_ENV_ARG_PARAMETER
01470         );
01471         ACE_TRY_CHECK;
01472         
01473         PortableInterceptor::ReplyStatus _tao_status =
01474           _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
01475         ACE_TRY_CHECK;
01476         
01477         if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
01478             || _tao_status == PortableInterceptor::USER_EXCEPTION)
01479           ACE_RE_THROW;
01480       }
01481     ACE_ENDTRY;
01482         ACE_CHECK;
01483 
01484     PortableInterceptor::ReplyStatus _tao_status =
01485       _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
01486         ACE_CHECK;
01487 
01488     if (_tao_status == PortableInterceptor::LOCATION_FORWARD
01489         || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
01490       continue;
01491     
01492 #endif  /* TAO_HAS_INTERCEPTORS */
01493     
01494     break;
01495   }
01496 
01497 }

CORBA::PolicyType CORBA::_TAO_Policy_Remote_Proxy_Impl::policy_type CORBA_Object *_collocated_tao_target_    ACE_ENV_ARG_DECL throw ( CORBA::SystemException ) [virtual]
 

Implements CORBA::_TAO_Policy_Proxy_Impl.

Definition at line 1016 of file PolicyC.cpp.

References ACE_ANY_EXCEPTION, ACE_CATCHANY, ACE_CHECK_RETURN, ACE_ENDTRY, ACE_ENV_ARG_DECL, ACE_ENV_ARG_PARAMETER, ACE_ENV_SINGLE_ARG_PARAMETER, ACE_RE_THROW, ACE_THROW_RETURN, ACE_TRY, ACE_TRY_CHECK, TAO_ORB_Core::client_request_interceptors, TAO_GIOP_Synch_Invocation::inp_stream, TAO_GIOP_Twoway_Invocation::invoke, TAO_Stub::orb_core, TAO_GIOP_Invocation::prepare_header, TAO_ClientRequestInterceptor_Adapter::receive_exception, TAO_ClientRequestInterceptor_Adapter::receive_other, TAO_ClientRequestInterceptor_Adapter::receive_reply, TAO_GIOP_Invocation::restart_flag, TAO_ClientRequestInterceptor_Adapter::send_request, TAO_GIOP_Twoway_Invocation::start, TAO_DEFAULT_MINOR_CODE, TAO_INTERCEPTOR, TAO_INTERCEPTOR_CHECK_RETURN, TAO_INTERCEPTOR_THROW_RETURN, TAO_INVOKE_EXCEPTION, TAO_INVOKE_RESTART, and TAO_TWOWAY_RESPONSE_FLAG.

01023 {
01024   
01025   CORBA::PolicyType _tao_retval = 0;
01026   
01027   
01028   TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
01029   if (istub == 0)
01030     ACE_THROW_RETURN (CORBA::INTERNAL (),_tao_retval);
01031 
01032   
01033   TAO_GIOP_Twoway_Invocation _tao_call (
01034       istub,
01035       "_get_policy_type",
01036       16,
01037       0,
01038       istub->orb_core ()
01039     );
01040   
01041   int _invoke_status;
01042   
01043 #if (TAO_HAS_INTERCEPTORS == 1)
01044   TAO_ClientRequestInterceptor_Adapter _tao_vfr (
01045       istub->orb_core ()->client_request_interceptors (),
01046       &_tao_call,
01047       _invoke_status
01048     );
01049   
01050 #endif  /* TAO_HAS_INTERCEPTORS */
01051   
01052   for (;;)
01053     {
01054       _invoke_status = TAO_INVOKE_EXCEPTION;
01055       
01056 #if TAO_HAS_INTERCEPTORS == 1
01057       TAO_ClientRequestInfo_CORBA_Policy_policy_type_get _tao_ri (
01058         &_tao_call,
01059         _collocated_tao_target_ ACE_ENV_ARG_PARAMETER
01060       );
01061             ACE_CHECK_RETURN (_tao_retval);
01062 
01063 #endif /* TAO_HAS_INTERCEPTORS */
01064       
01065       
01066       CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
01067       TAO_INTERCEPTOR (_tao_ri.response_expected (1));
01068       
01069 #if TAO_HAS_INTERCEPTORS == 1
01070       
01071       ACE_TRY
01072         {
01073           _tao_vfr.send_request (
01074             &_tao_ri
01075             ACE_ENV_ARG_PARAMETER
01076           );
01077           ACE_TRY_CHECK;
01078           
01079           if (_invoke_status == TAO_INVOKE_RESTART)
01080             {
01081               _tao_call.restart_flag (1);
01082               continue;
01083             }
01084           
01085 #endif /* TAO_HAS_INTERCEPTORS */
01086           
01087           _tao_call.start (ACE_ENV_SINGLE_ARG_PARAMETER);
01088                     TAO_INTERCEPTOR_CHECK_RETURN (_tao_retval);
01089 
01090           _tao_call.prepare_header (
01091               ACE_static_cast (CORBA::Octet, _tao_response_flag)
01092               ACE_ENV_ARG_PARAMETER
01093             );
01094                     TAO_INTERCEPTOR_CHECK_RETURN (_tao_retval);
01095 
01096           _invoke_status =
01097             _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
01098                     TAO_INTERCEPTOR_CHECK_RETURN (_tao_retval);
01099 
01100           if (_invoke_status == TAO_INVOKE_EXCEPTION)
01101             {
01102               TAO_INTERCEPTOR_THROW_RETURN (
01103                 CORBA::UNKNOWN (CORBA::OMGVMCID | 1, CORBA::COMPLETED_YES),
01104                 _tao_retval
01105               );
01106               
01107             }
01108           else if (_invoke_status == TAO_INVOKE_RESTART)
01109             {
01110               TAO_INTERCEPTOR (
01111                 _tao_ri.reply_status (_invoke_status);
01112                 _tao_vfr.receive_other (
01113                   &_tao_ri
01114                   ACE_ENV_ARG_PARAMETER
01115                 );
01116                 ACE_TRY_CHECK;
01117               )
01118               
01119               continue;
01120             }
01121           
01122           TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
01123           if (!(
01124                             (_tao_in >> _tao_retval)
01125               ))
01126             {
01127               TAO_INTERCEPTOR_THROW_RETURN (
01128                 CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
01129                 _tao_retval
01130               );
01131               
01132             }
01133           
01134 #if TAO_HAS_INTERCEPTORS == 1
01135           CORBA::PolicyType _tao_retval_info = _tao_retval;
01136           _tao_ri.result (_tao_retval_info);
01137           
01138           _tao_ri.reply_status (_invoke_status);
01139           _tao_vfr.receive_reply (
01140             &_tao_ri
01141             ACE_ENV_ARG_PARAMETER
01142           );
01143           ACE_TRY_CHECK;
01144         
01145       }
01146     ACE_CATCHANY
01147       {
01148         _tao_ri.exception (&ACE_ANY_EXCEPTION);
01149         _tao_vfr.receive_exception (
01150           &_tao_ri
01151           ACE_ENV_ARG_PARAMETER
01152         );
01153         ACE_TRY_CHECK;
01154         
01155         PortableInterceptor::ReplyStatus _tao_status =
01156           _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
01157         ACE_TRY_CHECK;
01158         
01159         if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
01160             || _tao_status == PortableInterceptor::USER_EXCEPTION)
01161           ACE_RE_THROW;
01162       }
01163     ACE_ENDTRY;
01164         ACE_CHECK_RETURN (_tao_retval);
01165 
01166     PortableInterceptor::ReplyStatus _tao_status =
01167       _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
01168         ACE_CHECK_RETURN (_tao_retval);
01169 
01170     if (_tao_status == PortableInterceptor::LOCATION_FORWARD
01171         || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
01172       continue;
01173     
01174 #endif  /* TAO_HAS_INTERCEPTORS */
01175     
01176     break;
01177   }
01178 return _tao_retval;
01179 }


The documentation for this class was generated from the following files:
Generated on Mon Jun 16 15:48:12 2003 for TAO by doxygen1.2.14 written by Dimitri van Heesch, © 1997-2002