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

DomainC.cpp

Go to the documentation of this file.
00001 #include "tao_pch.h"
00002 // -*- C++ -*-
00003 //
00004 // $Id: DomainC.cpp,v 1.1.1.4.2.1 2003/03/14 16:05:12 chad Exp $
00005 
00006 // ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
00007 // TAO and the TAO IDL Compiler have been developed by:
00008 //       Center for Distributed Object Computing
00009 //       Washington University
00010 //       St. Louis, MO
00011 //       USA
00012 //       http://www.cs.wustl.edu/~schmidt/doc-center.html
00013 // and
00014 //       Distributed Object Computing Laboratory
00015 //       University of California at Irvine
00016 //       Irvine, CA
00017 //       USA
00018 //       http://doc.ece.uci.edu/
00019 //
00020 // Information about TAO is available at:
00021 //     http://www.cs.wustl.edu/~schmidt/TAO.html
00022 
00023 #include "DomainC.h"
00024 
00025 #include "tao/Stub.h"
00026 #include "tao/Invocation.h"
00027 #include "tao/PortableInterceptor.h"
00028 
00029 #if TAO_HAS_INTERCEPTORS == 1
00030 #include "tao/RequestInfo_Util.h"
00031 #include "tao/ClientRequestInfo_i.h"
00032 #include "tao/ClientInterceptorAdapter.h"
00033 #endif  /* TAO_HAS_INTERCEPTORS == 1 */
00034 
00035 #include "tao/IFR_Client_Adapter.h"
00036 #include "ace/Dynamic_Service.h"
00037 
00038 #if defined (__BORLANDC__)
00039 #pragma option -w-rvl -w-rch -w-ccc -w-aus -w-sig
00040 #endif /* __BORLANDC__ */
00041 
00042 #if !defined (__ACE_INLINE__)
00043 #include "DomainC.i"
00044 #endif /* !defined INLINE */
00045 
00046 
00047 // TAO_IDL - Generated from 
00048 // be/be_visitor_interface/interface_cs.cpp:67
00049 
00050 int CORBA::DomainManager::_tao_class_id = 0;
00051 
00052 CORBA::DomainManager_ptr
00053 tao_CORBA_DomainManager_duplicate (
00054     CORBA::DomainManager_ptr p
00055   )
00056 {
00057   return CORBA::DomainManager::_duplicate (p);
00058 }
00059 
00060 void
00061 tao_CORBA_DomainManager_release (
00062     CORBA::DomainManager_ptr p
00063   )
00064 {
00065   CORBA::release (p);
00066 }
00067 
00068 CORBA::DomainManager_ptr
00069 tao_CORBA_DomainManager_nil (
00070     void
00071   )
00072 {
00073   return CORBA::DomainManager::_nil ();
00074 }
00075 
00076 CORBA::DomainManager_ptr
00077 tao_CORBA_DomainManager_narrow (
00078     CORBA::Object *p
00079     ACE_ENV_ARG_DECL
00080   )
00081 {
00082   return CORBA::DomainManager::_narrow (p ACE_ENV_ARG_PARAMETER);
00083 }
00084 
00085 CORBA::Object *
00086 tao_CORBA_DomainManager_upcast (
00087     void *src
00088   )
00089 {
00090   CORBA::DomainManager **tmp =
00091     ACE_static_cast (CORBA::DomainManager **, src);
00092   return *tmp;
00093 }
00094 
00095 // *************************************************************
00096 // CORBA::DomainManager_var
00097 // TAO_IDL - Generated from
00098 // be/be_interface.cpp:654
00099 // *************************************************************
00100 
00101 CORBA::DomainManager_var::DomainManager_var (void) // default constructor
00102   : ptr_ (DomainManager::_nil ())
00103 {}
00104 
00105 ::CORBA::DomainManager_ptr
00106 CORBA::DomainManager_var::ptr (void) const
00107 {
00108   return this->ptr_;
00109 }
00110 
00111 CORBA::DomainManager_var::DomainManager_var (const ::CORBA::DomainManager_var &p) // copy constructor
00112   : TAO_Base_var (),
00113     ptr_ (DomainManager::_duplicate (p.ptr ()))
00114 {}
00115 
00116 CORBA::DomainManager_var::~DomainManager_var (void) // destructor
00117 {
00118   CORBA::release (this->ptr_);
00119 }
00120 
00121 CORBA::DomainManager_var &
00122 CORBA::DomainManager_var::operator= (DomainManager_ptr p)
00123 {
00124   CORBA::release (this->ptr_);
00125   this->ptr_ = p;
00126   return *this;
00127 }
00128 
00129 CORBA::DomainManager_var &
00130 CORBA::DomainManager_var::operator= (const ::CORBA::DomainManager_var &p)
00131 {
00132   if (this != &p)
00133   {
00134     CORBA::release (this->ptr_);
00135     this->ptr_ = ::CORBA::DomainManager::_duplicate (p.ptr ());
00136   }
00137   return *this;
00138 }
00139 
00140 CORBA::DomainManager_var::operator const ::CORBA::DomainManager_ptr &() const // cast
00141 {
00142   return this->ptr_;
00143 }
00144 
00145 CORBA::DomainManager_var::operator ::CORBA::DomainManager_ptr &() // cast 
00146 {
00147   return this->ptr_;
00148 }
00149 
00150 ::CORBA::DomainManager_ptr
00151 CORBA::DomainManager_var::operator-> (void) const
00152 {
00153   return this->ptr_;
00154 }
00155 
00156 ::CORBA::DomainManager_ptr
00157 CORBA::DomainManager_var::in (void) const
00158 {
00159   return this->ptr_;
00160 }
00161 
00162 ::CORBA::DomainManager_ptr &
00163 CORBA::DomainManager_var::inout (void)
00164 {
00165   return this->ptr_;
00166 }
00167 
00168 ::CORBA::DomainManager_ptr &
00169 CORBA::DomainManager_var::out (void)
00170 {
00171   CORBA::release (this->ptr_);
00172   this->ptr_ = ::CORBA::DomainManager::_nil ();
00173   return this->ptr_;
00174 }
00175 
00176 ::CORBA::DomainManager_ptr
00177 CORBA::DomainManager_var::_retn (void)
00178 {
00179   // yield ownership of managed obj reference
00180   ::CORBA::DomainManager_ptr val = this->ptr_;
00181   this->ptr_ = ::CORBA::DomainManager::_nil ();
00182   return val;
00183 }
00184 
00185 ::CORBA::DomainManager_ptr
00186 CORBA::DomainManager_var::tao_duplicate (DomainManager_ptr p)
00187 {
00188   return ::CORBA::DomainManager::_duplicate (p);
00189 }
00190 
00191 void
00192 CORBA::DomainManager_var::tao_release (DomainManager_ptr p)
00193 {
00194   CORBA::release (p);
00195 }
00196 
00197 ::CORBA::DomainManager_ptr
00198 CORBA::DomainManager_var::tao_nil (void)
00199 {
00200   return ::CORBA::DomainManager::_nil ();
00201 }
00202 
00203 ::CORBA::DomainManager_ptr
00204 CORBA::DomainManager_var::tao_narrow (
00205     CORBA::Object *p
00206     ACE_ENV_ARG_DECL
00207   )
00208 {
00209   return ::CORBA::DomainManager::_narrow (p ACE_ENV_ARG_PARAMETER);
00210 }
00211 
00212 CORBA::Object *
00213 CORBA::DomainManager_var::tao_upcast (void *src)
00214 {
00215   DomainManager **tmp =
00216     ACE_static_cast (DomainManager **, src);
00217   return *tmp;
00218 }
00219 
00220 // *************************************************************
00221 // CORBA::DomainManager_out
00222 // TAO_IDL - Generated from
00223 // be/be_interface.cpp:932
00224 // *************************************************************
00225 
00226 CORBA::DomainManager_out::DomainManager_out (DomainManager_ptr &p)
00227   : ptr_ (p)
00228 {
00229   this->ptr_ = ::CORBA::DomainManager::_nil ();
00230 }
00231 
00232 CORBA::DomainManager_out::DomainManager_out (DomainManager_var &p) // constructor from _var
00233   : ptr_ (p.out ())
00234 {
00235   CORBA::release (this->ptr_);
00236   this->ptr_ = ::CORBA::DomainManager::_nil ();
00237 }
00238 
00239 CORBA::DomainManager_out::DomainManager_out (const ::CORBA::DomainManager_out &p) // copy constructor
00240   : ptr_ (ACE_const_cast (DomainManager_out &, p).ptr_)
00241 {}
00242 
00243 ::CORBA::DomainManager_out &
00244 CORBA::DomainManager_out::operator= (const ::CORBA::DomainManager_out &p)
00245 {
00246   this->ptr_ = ACE_const_cast (DomainManager_out&, p).ptr_;
00247   return *this;
00248 }
00249 
00250 CORBA::DomainManager_out &
00251 CORBA::DomainManager_out::operator= (const ::CORBA::DomainManager_var &p)
00252 {
00253   this->ptr_ = ::CORBA::DomainManager::_duplicate (p.ptr ());
00254   return *this;
00255 }
00256 
00257 CORBA::DomainManager_out &
00258 CORBA::DomainManager_out::operator= (DomainManager_ptr p)
00259 {
00260   this->ptr_ = p;
00261   return *this;
00262 }
00263 
00264 CORBA::DomainManager_out::operator ::CORBA::DomainManager_ptr &() // cast
00265 {
00266   return this->ptr_;
00267 }
00268 
00269 ::CORBA::DomainManager_ptr &
00270 CORBA::DomainManager_out::ptr (void) // ptr
00271 {
00272   return this->ptr_;
00273 }
00274 
00275 ::CORBA::DomainManager_ptr
00276 CORBA::DomainManager_out::operator-> (void)
00277 {
00278   return this->ptr_;
00279 }
00280 
00281 
00282 #if (TAO_HAS_INTERCEPTORS == 1)
00283 class TAO_ClientRequestInfo_CORBA_DomainManager_get_domain_policy : public TAO_ClientRequestInfo_i
00284 {
00285 public:
00286   TAO_ClientRequestInfo_CORBA_DomainManager_get_domain_policy (
00287       TAO_GIOP_Invocation *_tao_invocation,
00288       CORBA::Object_ptr _tao_target,
00289       const CORBA::PolicyType & policy_type ACE_ENV_ARG_DECL_WITH_DEFAULTS
00290     );
00291 
00292   virtual Dynamic::ParameterList * arguments (ACE_ENV_SINGLE_ARG_DECL)
00293     ACE_THROW_SPEC ((CORBA::SystemException));
00294   
00295   virtual Dynamic::ExceptionList * exceptions (ACE_ENV_SINGLE_ARG_DECL)
00296     ACE_THROW_SPEC ((CORBA::SystemException));
00297   
00298   virtual CORBA::Any * result (ACE_ENV_SINGLE_ARG_DECL)
00299     ACE_THROW_SPEC ((CORBA::SystemException));
00300 
00301   void result (CORBA::Policy_ptr result);
00302 
00303 private:
00304   TAO_ClientRequestInfo_CORBA_DomainManager_get_domain_policy (const TAO_ClientRequestInfo_CORBA_DomainManager_get_domain_policy &);
00305   void operator= (const TAO_ClientRequestInfo_CORBA_DomainManager_get_domain_policy &);
00306 
00307   const CORBA::PolicyType & policy_type_;
00308   CORBA::Policy_ptr _result;
00309 };
00310 
00311 TAO_ClientRequestInfo_CORBA_DomainManager_get_domain_policy::TAO_ClientRequestInfo_CORBA_DomainManager_get_domain_policy (
00312     TAO_GIOP_Invocation *_tao_invocation,
00313     CORBA::Object_ptr _tao_target,
00314     const CORBA::PolicyType & policy_type ACE_ENV_ARG_DECL_NOT_USED    
00315   )
00316   : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target),
00317     policy_type_ (policy_type)
00318 {}
00319 
00320 Dynamic::ParameterList *
00321 TAO_ClientRequestInfo_CORBA_DomainManager_get_domain_policy::arguments (ACE_ENV_SINGLE_ARG_DECL)
00322   ACE_THROW_SPEC ((CORBA::SystemException))
00323 {
00324   // Generate the argument list on demand.
00325   Dynamic::ParameterList *parameter_list =
00326     TAO_RequestInfo_Util::make_parameter_list (ACE_ENV_SINGLE_ARG_PARAMETER);
00327   ACE_CHECK_RETURN (0);
00328   
00329   Dynamic::ParameterList_var safe_parameter_list = parameter_list;
00330   
00331   parameter_list->length (1);
00332   CORBA::ULong len = 0;
00333   
00334     (*parameter_list)[len].argument <<= policy_type_;
00335   (*parameter_list)[len].mode = CORBA::PARAM_IN;
00336   len++;
00337   
00338   return safe_parameter_list._retn ();
00339 }
00340 
00341 Dynamic::ExceptionList *
00342 TAO_ClientRequestInfo_CORBA_DomainManager_get_domain_policy::exceptions (ACE_ENV_SINGLE_ARG_DECL)
00343   ACE_THROW_SPEC ((CORBA::SystemException))
00344 {
00345   // Generate the exception list on demand.
00346   Dynamic::ExceptionList *exception_list =
00347     TAO_RequestInfo_Util::make_exception_list (ACE_ENV_SINGLE_ARG_PARAMETER);
00348   ACE_CHECK_RETURN (0);
00349   
00350   return exception_list;
00351 }
00352 
00353 CORBA::Any * 
00354 TAO_ClientRequestInfo_CORBA_DomainManager_get_domain_policy::result (ACE_ENV_SINGLE_ARG_DECL)
00355   ACE_THROW_SPEC ((CORBA::SystemException))
00356 {
00357   // Generate the result on demand.
00358   CORBA::Boolean tk_void_any = 0;
00359   CORBA::Any *result_any =
00360     TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER);
00361   ACE_CHECK_RETURN (0);
00362   
00363   CORBA::Any_var safe_result_any = result_any;
00364   
00365   (*result_any) <<= this->_result;
00366   return safe_result_any._retn ();
00367 }
00368 
00369 void 
00370 TAO_ClientRequestInfo_CORBA_DomainManager_get_domain_policy::result (::CORBA::Policy_ptr result)
00371 {
00372   // update the result 
00373   this->_result = result;
00374 }
00375 
00376 #endif /* TAO_HAS_INTERCEPTORS */
00377 
00378 ///////////////////////////////////////////////////////////////////////
00379 //                Base & Remote Proxy  Implementation. 
00380 //
00381 
00382 CORBA::_TAO_DomainManager_Proxy_Impl::_TAO_DomainManager_Proxy_Impl (void)
00383 {}
00384 
00385 CORBA::_TAO_DomainManager_Remote_Proxy_Impl::_TAO_DomainManager_Remote_Proxy_Impl (void)
00386 {}
00387 
00388 // Remote Implementation of the IDL interface methods
00389 
00390 ::CORBA::Policy_ptr CORBA::_TAO_DomainManager_Remote_Proxy_Impl::get_domain_policy (
00391     CORBA_Object *_collocated_tao_target_,
00392     CORBA::PolicyType policy_type
00393     ACE_ENV_ARG_DECL
00394   )
00395   ACE_THROW_SPEC ((
00396     CORBA::SystemException
00397   ))
00398 {
00399   
00400   CORBA::Policy_var _tao_retval (CORBA::Policy::_nil ());
00401 
00402 
00403   
00404   TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
00405   if (istub == 0)
00406     ACE_THROW_RETURN (CORBA::INTERNAL (),_tao_retval._retn ());
00407 
00408   
00409   TAO_GIOP_Twoway_Invocation _tao_call (
00410       istub,
00411       "get_domain_policy",
00412       17,
00413       1,
00414       istub->orb_core ()
00415     );
00416   
00417   int _invoke_status;
00418   
00419 #if (TAO_HAS_INTERCEPTORS == 1)
00420   TAO_ClientRequestInterceptor_Adapter _tao_vfr (
00421       istub->orb_core ()->client_request_interceptors (),
00422       &_tao_call,
00423       _invoke_status
00424     );
00425   
00426 #endif  /* TAO_HAS_INTERCEPTORS */
00427   
00428   for (;;)
00429     {
00430       _invoke_status = TAO_INVOKE_EXCEPTION;
00431       
00432 #if TAO_HAS_INTERCEPTORS == 1
00433       TAO_ClientRequestInfo_CORBA_DomainManager_get_domain_policy _tao_ri (
00434         &_tao_call,
00435         _collocated_tao_target_,
00436         policy_type ACE_ENV_ARG_PARAMETER
00437       );
00438             ACE_CHECK_RETURN (_tao_retval._retn ());
00439 
00440 #endif /* TAO_HAS_INTERCEPTORS */
00441       
00442       
00443       CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
00444       TAO_INTERCEPTOR (_tao_ri.response_expected (1));
00445       
00446 #if TAO_HAS_INTERCEPTORS == 1
00447       
00448       ACE_TRY
00449         {
00450           _tao_vfr.send_request (
00451             &_tao_ri
00452             ACE_ENV_ARG_PARAMETER
00453           );
00454           ACE_TRY_CHECK;
00455           
00456           if (_invoke_status == TAO_INVOKE_RESTART)
00457             {
00458               _tao_call.restart_flag (1);
00459               continue;
00460             }
00461           
00462 #endif /* TAO_HAS_INTERCEPTORS */
00463           
00464           _tao_call.start (ACE_ENV_SINGLE_ARG_PARAMETER);
00465                     TAO_INTERCEPTOR_CHECK_RETURN (_tao_retval._retn ());
00466 
00467           _tao_call.prepare_header (
00468               ACE_static_cast (CORBA::Octet, _tao_response_flag)
00469               ACE_ENV_ARG_PARAMETER
00470             );
00471                     TAO_INTERCEPTOR_CHECK_RETURN (_tao_retval._retn ());
00472 
00473           TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
00474           if (!(
00475                             (_tao_out << policy_type)
00476             ))
00477             TAO_INTERCEPTOR_THROW_RETURN (
00478               CORBA::MARSHAL (),
00479               0
00480             );
00481             
00482           _invoke_status =
00483             _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
00484                     TAO_INTERCEPTOR_CHECK_RETURN (_tao_retval._retn ());
00485 
00486           if (_invoke_status == TAO_INVOKE_EXCEPTION)
00487             {
00488               TAO_INTERCEPTOR_THROW_RETURN (
00489                 CORBA::UNKNOWN (CORBA::OMGVMCID | 1, CORBA::COMPLETED_YES),
00490                 0
00491               );
00492               
00493             }
00494           else if (_invoke_status == TAO_INVOKE_RESTART)
00495             {
00496               TAO_INTERCEPTOR (
00497                 _tao_ri.reply_status (_invoke_status);
00498                 _tao_vfr.receive_other (
00499                   &_tao_ri
00500                   ACE_ENV_ARG_PARAMETER
00501                 );
00502                 ACE_TRY_CHECK;
00503               )
00504               
00505               continue;
00506             }
00507           
00508           TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
00509           if (!(
00510                             (_tao_in >> _tao_retval.inout ())
00511               ))
00512             {
00513               TAO_INTERCEPTOR_THROW_RETURN (
00514                 CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES),
00515                 0
00516               );
00517               
00518             }
00519           
00520 #if TAO_HAS_INTERCEPTORS == 1
00521           ::CORBA::Policy_ptr _tao_retval_info = _tao_retval._retn ();
00522           _tao_ri.result (_tao_retval_info);
00523           _tao_retval = _tao_retval_info;
00524           
00525           _tao_ri.reply_status (_invoke_status);
00526           _tao_vfr.receive_reply (
00527             &_tao_ri
00528             ACE_ENV_ARG_PARAMETER
00529           );
00530           ACE_TRY_CHECK;
00531         
00532       }
00533     ACE_CATCHANY
00534       {
00535         _tao_ri.exception (&ACE_ANY_EXCEPTION);
00536         _tao_vfr.receive_exception (
00537           &_tao_ri
00538           ACE_ENV_ARG_PARAMETER
00539         );
00540         ACE_TRY_CHECK;
00541         
00542         PortableInterceptor::ReplyStatus _tao_status =
00543           _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
00544         ACE_TRY_CHECK;
00545         
00546         if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
00547             || _tao_status == PortableInterceptor::USER_EXCEPTION)
00548           ACE_RE_THROW;
00549       }
00550     ACE_ENDTRY;
00551         ACE_CHECK_RETURN (_tao_retval._retn ());
00552 
00553     PortableInterceptor::ReplyStatus _tao_status =
00554       _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
00555         ACE_CHECK_RETURN (_tao_retval._retn ());
00556 
00557     if (_tao_status == PortableInterceptor::LOCATION_FORWARD
00558         || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
00559       continue;
00560     
00561 #endif  /* TAO_HAS_INTERCEPTORS */
00562     
00563     break;
00564   }
00565 return _tao_retval._retn ();
00566 }
00567 
00568 
00569 //
00570 //            End  Base & Remote  Proxy Implemeentation. 
00571 ///////////////////////////////////////////////////////////////////////
00572 
00573 
00574 ///////////////////////////////////////////////////////////////////////
00575 //           Remote & Base  Proxy Broker Implementation
00576 //
00577 
00578 CORBA::_TAO_DomainManager_Proxy_Broker::_TAO_DomainManager_Proxy_Broker (void)
00579 {
00580 }
00581 
00582 CORBA::_TAO_DomainManager_Proxy_Broker::~_TAO_DomainManager_Proxy_Broker (void)
00583 {
00584 }
00585 
00586 CORBA::_TAO_DomainManager_Proxy_Broker * (*CORBA__TAO_DomainManager_Proxy_Broker_Factory_function_pointer) (
00587     CORBA::Object_ptr obj
00588   ) = 0;
00589 
00590 // Factory Member function Implementation.
00591 CORBA::_TAO_DomainManager_Remote_Proxy_Broker *
00592 CORBA::_TAO_DomainManager_Remote_Proxy_Broker::the_TAO_DomainManager_Remote_Proxy_Broker (void)
00593 {
00594   static ::CORBA::_TAO_DomainManager_Remote_Proxy_Broker remote_proxy_broker;
00595   return &remote_proxy_broker;
00596 }
00597 
00598 CORBA::_TAO_DomainManager_Remote_Proxy_Broker::_TAO_DomainManager_Remote_Proxy_Broker (void)
00599 {
00600 }
00601 
00602 CORBA::_TAO_DomainManager_Remote_Proxy_Broker::~_TAO_DomainManager_Remote_Proxy_Broker (void)
00603 {
00604 }
00605 
00606 CORBA::_TAO_DomainManager_Proxy_Impl&
00607 CORBA::_TAO_DomainManager_Remote_Proxy_Broker::select_proxy (
00608   ::CORBA::DomainManager *
00609   ACE_ENV_ARG_DECL_NOT_USED
00610 )
00611 {
00612   return this->remote_proxy_impl_;
00613 }
00614 
00615 
00616 //
00617 //           End Remote & Base Proxy Broker Implementation
00618 ///////////////////////////////////////////////////////////////////////
00619 
00620 
00621 // TAO_IDL - Generated from 
00622 // be/be_visitor_interface/interface_cs.cpp:198
00623 
00624 CORBA::DomainManager::DomainManager (int collocated)
00625 {
00626   this->CORBA_DomainManager_setup_collocation (collocated);
00627 }
00628 
00629 CORBA::DomainManager::~DomainManager (void)
00630 {}
00631 
00632 void
00633 CORBA::DomainManager::CORBA_DomainManager_setup_collocation (int collocated)
00634 {
00635   if (collocated)
00636     this->the_TAO_DomainManager_Proxy_Broker_ =
00637       ::CORBA__TAO_DomainManager_Proxy_Broker_Factory_function_pointer (this);
00638   else
00639     this->the_TAO_DomainManager_Proxy_Broker_ =
00640       ::CORBA::_TAO_DomainManager_Remote_Proxy_Broker::the_TAO_DomainManager_Remote_Proxy_Broker ();
00641 }
00642 
00643 void CORBA::DomainManager::_tao_any_destructor (void *_tao_void_pointer)
00644 {
00645   DomainManager *tmp = ACE_static_cast (DomainManager*, _tao_void_pointer);
00646   CORBA::release (tmp);
00647 }
00648 
00649 CORBA::DomainManager_ptr CORBA::DomainManager::_narrow (
00650     CORBA::Object_ptr obj
00651     ACE_ENV_ARG_DECL
00652   )
00653 {
00654   if (CORBA::is_nil (obj))
00655     return DomainManager::_nil ();
00656   if (! obj->_is_local ())
00657     {
00658       CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/DomainManager:1.0" ACE_ENV_ARG_PARAMETER);
00659       ACE_CHECK_RETURN (DomainManager::_nil ());
00660       if (is_a == 0)
00661         return DomainManager::_nil ();
00662     }
00663   return DomainManager::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
00664 }
00665 
00666 CORBA::DomainManager_ptr 
00667 CORBA::DomainManager::_unchecked_narrow (
00668     CORBA::Object_ptr obj
00669     ACE_ENV_ARG_DECL_NOT_USED
00670   )
00671 {
00672   if (CORBA::is_nil (obj))
00673     return DomainManager::_nil ();
00674   if (! obj->_is_local ())
00675     {
00676       TAO_Stub* stub = obj->_stubobj ();
00677       if (stub)
00678         stub->_incr_refcnt ();
00679       DomainManager_ptr default_proxy = DomainManager::_nil ();
00680 
00681       if (
00682           !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
00683           stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
00684           obj->_is_collocated () &&
00685           CORBA__TAO_DomainManager_Proxy_Broker_Factory_function_pointer != 0
00686         )
00687         {
00688           ACE_NEW_RETURN (
00689               default_proxy,
00690               ::CORBA::DomainManager (
00691                   stub,
00692                   1,
00693                   obj->_servant ()
00694                 ),
00695               DomainManager::_nil ()
00696             );
00697         }
00698       
00699       if (CORBA::is_nil (default_proxy))
00700         {
00701           ACE_NEW_RETURN (
00702               default_proxy,
00703               ::CORBA::DomainManager (
00704                   stub,
00705                   0,
00706                   obj->_servant ()
00707                 ),
00708               DomainManager::_nil ()
00709             );
00710         }
00711       
00712       return default_proxy;
00713     }
00714   else 
00715     return
00716       ACE_reinterpret_cast
00717         (
00718           DomainManager_ptr,
00719             obj->_tao_QueryInterface
00720               (
00721                 ACE_reinterpret_cast
00722                   (
00723                     ptr_arith_t,
00724                     &DomainManager::_tao_class_id
00725                   )
00726               )
00727         );
00728 }
00729 
00730 CORBA::DomainManager_ptr
00731 CORBA::DomainManager::_duplicate (DomainManager_ptr obj)
00732 {
00733   if (!CORBA::is_nil (obj))
00734     obj->_add_ref ();
00735   return obj;
00736 }
00737 
00738 CORBA::Boolean CORBA::DomainManager::_is_a (const CORBA::Char *value ACE_ENV_ARG_DECL)
00739 {
00740   if (
00741     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/DomainManager:1.0")) ||
00742     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
00743   return 1; // success using local knowledge
00744   else
00745     return this->CORBA_Object::_is_a (value ACE_ENV_ARG_PARAMETER);
00746 }
00747 
00748 void *CORBA::DomainManager::_tao_QueryInterface (ptr_arith_t type)
00749 {
00750   void *retv = 0;
00751   if (type == ACE_reinterpret_cast
00752     (ptr_arith_t,
00753       &ACE_NESTED_CLASS (::CORBA, DomainManager)::_tao_class_id))
00754     retv = ACE_reinterpret_cast (void*, this);
00755   else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
00756     retv = ACE_reinterpret_cast (void *,
00757       ACE_static_cast (CORBA::Object_ptr, this));
00758     
00759   if (retv)
00760     this->_add_ref ();
00761   return retv;
00762 }
00763 
00764 const char* CORBA::DomainManager::_interface_repository_id (void) const
00765 {
00766   return "IDL:omg.org/CORBA/DomainManager:1.0";
00767 }
00768 
00769 ::CORBA::Policy_ptr CORBA::DomainManager::get_domain_policy (
00770     CORBA::PolicyType policy_type
00771     ACE_ENV_ARG_DECL
00772   )
00773   ACE_THROW_SPEC ((
00774     CORBA::SystemException
00775   ))
00776 {
00777   _TAO_DomainManager_Proxy_Impl &proxy = 
00778     this->the_TAO_DomainManager_Proxy_Broker_->select_proxy (this ACE_ENV_ARG_PARAMETER);
00779   ACE_CHECK_RETURN (0);
00780   
00781   return proxy.get_domain_policy (
00782       this,
00783       policy_type ACE_ENV_ARG_PARAMETER
00784     );
00785 }
00786 
00787 static const CORBA::Long _oc_CORBA_DomainManager[] =
00788 {
00789   TAO_ENCAP_BYTE_ORDER, // byte order
00790   36,
00791   ACE_NTOHL (0x49444c3a), 
00792   ACE_NTOHL (0x6f6d672e), 
00793   ACE_NTOHL (0x6f72672f), 
00794   ACE_NTOHL (0x434f5242), 
00795   ACE_NTOHL (0x412f446f), 
00796   ACE_NTOHL (0x6d61696e), 
00797   ACE_NTOHL (0x4d616e61), 
00798   ACE_NTOHL (0x6765723a), 
00799   ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/DomainManager:1.0
00800   14,
00801   ACE_NTOHL (0x446f6d61), 
00802   ACE_NTOHL (0x696e4d61), 
00803   ACE_NTOHL (0x6e616765), 
00804   ACE_NTOHL (0x72000000),  // name = DomainManager
00805 };
00806 
00807 static CORBA::TypeCode _tc_TAO_tc_CORBA_DomainManager (
00808     CORBA::tk_objref,
00809     sizeof (_oc_CORBA_DomainManager),
00810     (char *) &_oc_CORBA_DomainManager,
00811     0,
00812     sizeof (CORBA::DomainManager)
00813   );
00814 
00815 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
00816 TAO_NAMESPACE_BEGIN (CORBA)
00817 TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_DomainManager, &_tc_TAO_tc_CORBA_DomainManager)
00818 TAO_NAMESPACE_END
00819 
00820 TAO_NAMESPACE_TYPE (const CORBA::ULong)
00821 TAO_NAMESPACE_BEGIN (CORBA)
00822 TAO_NAMESPACE_DEFINE (const CORBA::ULong, SecConstruction, 11U)
00823 TAO_NAMESPACE_END
00824 
00825 // TAO_IDL - Generated from 
00826 // be/be_visitor_interface/interface_cs.cpp:67
00827 
00828 int CORBA::ConstructionPolicy::_tao_class_id = 0;
00829 
00830 CORBA::ConstructionPolicy_ptr
00831 tao_CORBA_ConstructionPolicy_duplicate (
00832     CORBA::ConstructionPolicy_ptr p
00833   )
00834 {
00835   return CORBA::ConstructionPolicy::_duplicate (p);
00836 }
00837 
00838 void
00839 tao_CORBA_ConstructionPolicy_release (
00840     CORBA::ConstructionPolicy_ptr p
00841   )
00842 {
00843   CORBA::release (p);
00844 }
00845 
00846 CORBA::ConstructionPolicy_ptr
00847 tao_CORBA_ConstructionPolicy_nil (
00848     void
00849   )
00850 {
00851   return CORBA::ConstructionPolicy::_nil ();
00852 }
00853 
00854 CORBA::ConstructionPolicy_ptr
00855 tao_CORBA_ConstructionPolicy_narrow (
00856     CORBA::Object *p
00857     ACE_ENV_ARG_DECL
00858   )
00859 {
00860   return CORBA::ConstructionPolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
00861 }
00862 
00863 CORBA::Object *
00864 tao_CORBA_ConstructionPolicy_upcast (
00865     void *src
00866   )
00867 {
00868   CORBA::ConstructionPolicy **tmp =
00869     ACE_static_cast (CORBA::ConstructionPolicy **, src);
00870   return *tmp;
00871 }
00872 
00873 // *************************************************************
00874 // CORBA::ConstructionPolicy_var
00875 // TAO_IDL - Generated from
00876 // be/be_interface.cpp:654
00877 // *************************************************************
00878 
00879 CORBA::ConstructionPolicy_var::ConstructionPolicy_var (void) // default constructor
00880   : ptr_ (ConstructionPolicy::_nil ())
00881 {}
00882 
00883 ::CORBA::ConstructionPolicy_ptr
00884 CORBA::ConstructionPolicy_var::ptr (void) const
00885 {
00886   return this->ptr_;
00887 }
00888 
00889 CORBA::ConstructionPolicy_var::ConstructionPolicy_var (const ::CORBA::ConstructionPolicy_var &p) // copy constructor
00890   : TAO_Base_var (),
00891     ptr_ (ConstructionPolicy::_duplicate (p.ptr ()))
00892 {}
00893 
00894 CORBA::ConstructionPolicy_var::~ConstructionPolicy_var (void) // destructor
00895 {
00896   CORBA::release (this->ptr_);
00897 }
00898 
00899 CORBA::ConstructionPolicy_var &
00900 CORBA::ConstructionPolicy_var::operator= (ConstructionPolicy_ptr p)
00901 {
00902   CORBA::release (this->ptr_);
00903   this->ptr_ = p;
00904   return *this;
00905 }
00906 
00907 CORBA::ConstructionPolicy_var &
00908 CORBA::ConstructionPolicy_var::operator= (const ::CORBA::ConstructionPolicy_var &p)
00909 {
00910   if (this != &p)
00911   {
00912     CORBA::release (this->ptr_);
00913     this->ptr_ = ::CORBA::ConstructionPolicy::_duplicate (p.ptr ());
00914   }
00915   return *this;
00916 }
00917 
00918 CORBA::ConstructionPolicy_var::operator const ::CORBA::ConstructionPolicy_ptr &() const // cast
00919 {
00920   return this->ptr_;
00921 }
00922 
00923 CORBA::ConstructionPolicy_var::operator ::CORBA::ConstructionPolicy_ptr &() // cast 
00924 {
00925   return this->ptr_;
00926 }
00927 
00928 ::CORBA::ConstructionPolicy_ptr
00929 CORBA::ConstructionPolicy_var::operator-> (void) const
00930 {
00931   return this->ptr_;
00932 }
00933 
00934 ::CORBA::ConstructionPolicy_ptr
00935 CORBA::ConstructionPolicy_var::in (void) const
00936 {
00937   return this->ptr_;
00938 }
00939 
00940 ::CORBA::ConstructionPolicy_ptr &
00941 CORBA::ConstructionPolicy_var::inout (void)
00942 {
00943   return this->ptr_;
00944 }
00945 
00946 ::CORBA::ConstructionPolicy_ptr &
00947 CORBA::ConstructionPolicy_var::out (void)
00948 {
00949   CORBA::release (this->ptr_);
00950   this->ptr_ = ::CORBA::ConstructionPolicy::_nil ();
00951   return this->ptr_;
00952 }
00953 
00954 ::CORBA::ConstructionPolicy_ptr
00955 CORBA::ConstructionPolicy_var::_retn (void)
00956 {
00957   // yield ownership of managed obj reference
00958   ::CORBA::ConstructionPolicy_ptr val = this->ptr_;
00959   this->ptr_ = ::CORBA::ConstructionPolicy::_nil ();
00960   return val;
00961 }
00962 
00963 ::CORBA::ConstructionPolicy_ptr
00964 CORBA::ConstructionPolicy_var::tao_duplicate (ConstructionPolicy_ptr p)
00965 {
00966   return ::CORBA::ConstructionPolicy::_duplicate (p);
00967 }
00968 
00969 void
00970 CORBA::ConstructionPolicy_var::tao_release (ConstructionPolicy_ptr p)
00971 {
00972   CORBA::release (p);
00973 }
00974 
00975 ::CORBA::ConstructionPolicy_ptr
00976 CORBA::ConstructionPolicy_var::tao_nil (void)
00977 {
00978   return ::CORBA::ConstructionPolicy::_nil ();
00979 }
00980 
00981 ::CORBA::ConstructionPolicy_ptr
00982 CORBA::ConstructionPolicy_var::tao_narrow (
00983     CORBA::Object *p
00984     ACE_ENV_ARG_DECL
00985   )
00986 {
00987   return ::CORBA::ConstructionPolicy::_narrow (p ACE_ENV_ARG_PARAMETER);
00988 }
00989 
00990 CORBA::Object *
00991 CORBA::ConstructionPolicy_var::tao_upcast (void *src)
00992 {
00993   ConstructionPolicy **tmp =
00994     ACE_static_cast (ConstructionPolicy **, src);
00995   return *tmp;
00996 }
00997 
00998 // *************************************************************
00999 // CORBA::ConstructionPolicy_out
01000 // TAO_IDL - Generated from
01001 // be/be_interface.cpp:932
01002 // *************************************************************
01003 
01004 CORBA::ConstructionPolicy_out::ConstructionPolicy_out (ConstructionPolicy_ptr &p)
01005   : ptr_ (p)
01006 {
01007   this->ptr_ = ::CORBA::ConstructionPolicy::_nil ();
01008 }
01009 
01010 CORBA::ConstructionPolicy_out::ConstructionPolicy_out (ConstructionPolicy_var &p) // constructor from _var
01011   : ptr_ (p.out ())
01012 {
01013   CORBA::release (this->ptr_);
01014   this->ptr_ = ::CORBA::ConstructionPolicy::_nil ();
01015 }
01016 
01017 CORBA::ConstructionPolicy_out::ConstructionPolicy_out (const ::CORBA::ConstructionPolicy_out &p) // copy constructor
01018   : ptr_ (ACE_const_cast (ConstructionPolicy_out &, p).ptr_)
01019 {}
01020 
01021 ::CORBA::ConstructionPolicy_out &
01022 CORBA::ConstructionPolicy_out::operator= (const ::CORBA::ConstructionPolicy_out &p)
01023 {
01024   this->ptr_ = ACE_const_cast (ConstructionPolicy_out&, p).ptr_;
01025   return *this;
01026 }
01027 
01028 CORBA::ConstructionPolicy_out &
01029 CORBA::ConstructionPolicy_out::operator= (const ::CORBA::ConstructionPolicy_var &p)
01030 {
01031   this->ptr_ = ::CORBA::ConstructionPolicy::_duplicate (p.ptr ());
01032   return *this;
01033 }
01034 
01035 CORBA::ConstructionPolicy_out &
01036 CORBA::ConstructionPolicy_out::operator= (ConstructionPolicy_ptr p)
01037 {
01038   this->ptr_ = p;
01039   return *this;
01040 }
01041 
01042 CORBA::ConstructionPolicy_out::operator ::CORBA::ConstructionPolicy_ptr &() // cast
01043 {
01044   return this->ptr_;
01045 }
01046 
01047 ::CORBA::ConstructionPolicy_ptr &
01048 CORBA::ConstructionPolicy_out::ptr (void) // ptr
01049 {
01050   return this->ptr_;
01051 }
01052 
01053 ::CORBA::ConstructionPolicy_ptr
01054 CORBA::ConstructionPolicy_out::operator-> (void)
01055 {
01056   return this->ptr_;
01057 }
01058 
01059 
01060 #if (TAO_HAS_INTERCEPTORS == 1)
01061 class TAO_ClientRequestInfo_CORBA_ConstructionPolicy_make_domain_manager : public TAO_ClientRequestInfo_i
01062 {
01063 public:
01064   TAO_ClientRequestInfo_CORBA_ConstructionPolicy_make_domain_manager (
01065       TAO_GIOP_Invocation *_tao_invocation,
01066       CORBA::Object_ptr _tao_target,
01067       CORBA::InterfaceDef_ptr object_type,
01068       const CORBA::Boolean & constr_policy ACE_ENV_ARG_DECL_WITH_DEFAULTS
01069     );
01070 
01071   virtual Dynamic::ParameterList * arguments (ACE_ENV_SINGLE_ARG_DECL)
01072     ACE_THROW_SPEC ((CORBA::SystemException));
01073   
01074   virtual Dynamic::ExceptionList * exceptions (ACE_ENV_SINGLE_ARG_DECL)
01075     ACE_THROW_SPEC ((CORBA::SystemException));
01076   
01077   virtual CORBA::Any * result (ACE_ENV_SINGLE_ARG_DECL)
01078     ACE_THROW_SPEC ((CORBA::SystemException));
01079 
01080 private:
01081   TAO_ClientRequestInfo_CORBA_ConstructionPolicy_make_domain_manager (const TAO_ClientRequestInfo_CORBA_ConstructionPolicy_make_domain_manager &);
01082   void operator= (const TAO_ClientRequestInfo_CORBA_ConstructionPolicy_make_domain_manager &);
01083 
01084   CORBA::InterfaceDef_ptr object_type_;
01085   const CORBA::Boolean & constr_policy_;
01086   
01087 };
01088 
01089 TAO_ClientRequestInfo_CORBA_ConstructionPolicy_make_domain_manager::TAO_ClientRequestInfo_CORBA_ConstructionPolicy_make_domain_manager (
01090     TAO_GIOP_Invocation *_tao_invocation,
01091     CORBA::Object_ptr _tao_target,
01092     CORBA::InterfaceDef_ptr object_type,
01093     const CORBA::Boolean & constr_policy ACE_ENV_ARG_DECL_NOT_USED    
01094   )
01095   : TAO_ClientRequestInfo_i (_tao_invocation, _tao_target),
01096     object_type_ (object_type),
01097     constr_policy_ (constr_policy)
01098 {}
01099 
01100 Dynamic::ParameterList *
01101 TAO_ClientRequestInfo_CORBA_ConstructionPolicy_make_domain_manager::arguments (ACE_ENV_SINGLE_ARG_DECL)
01102   ACE_THROW_SPEC ((CORBA::SystemException))
01103 {
01104   // Generate the argument list on demand.
01105   Dynamic::ParameterList *parameter_list =
01106     TAO_RequestInfo_Util::make_parameter_list (ACE_ENV_SINGLE_ARG_PARAMETER);
01107   ACE_CHECK_RETURN (0);
01108   
01109   Dynamic::ParameterList_var safe_parameter_list = parameter_list;
01110   
01111   parameter_list->length (2);
01112   CORBA::ULong len = 0;
01113   
01114   TAO_IFR_Client_Adapter *adapter =
01115     ACE_Dynamic_Service<TAO_IFR_Client_Adapter>::instance (
01116         TAO_ORB_Core::ifr_client_adapter_name ()
01117       );
01118 
01119   adapter->interfacedef_any_insert (
01120       (*parameter_list)[len].argument,
01121       this->object_type_
01122     );
01123   (*parameter_list)[len].mode = CORBA::PARAM_IN;
01124   len++;
01125     (*parameter_list)[len].argument <<= CORBA::Any::from_boolean (this->constr_policy_);
01126   (*parameter_list)[len].mode = CORBA::PARAM_IN;
01127   len++;
01128   
01129   return safe_parameter_list._retn ();
01130 }
01131 
01132 Dynamic::ExceptionList *
01133 TAO_ClientRequestInfo_CORBA_ConstructionPolicy_make_domain_manager::exceptions (ACE_ENV_SINGLE_ARG_DECL)
01134   ACE_THROW_SPEC ((CORBA::SystemException))
01135 {
01136   // Generate the exception list on demand.
01137   Dynamic::ExceptionList *exception_list =
01138     TAO_RequestInfo_Util::make_exception_list (ACE_ENV_SINGLE_ARG_PARAMETER);
01139   ACE_CHECK_RETURN (0);
01140   
01141   return exception_list;
01142 }
01143 
01144 CORBA::Any * 
01145 TAO_ClientRequestInfo_CORBA_ConstructionPolicy_make_domain_manager::result (ACE_ENV_SINGLE_ARG_DECL)
01146   ACE_THROW_SPEC ((CORBA::SystemException))
01147 {
01148   // Generate the result on demand.
01149   CORBA::Boolean tk_void_any = 1;
01150   CORBA::Any *result_any =
01151     TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER);
01152   ACE_CHECK_RETURN (0);
01153   
01154   return result_any;
01155 }
01156 
01157 #endif /* TAO_HAS_INTERCEPTORS */
01158 
01159 ///////////////////////////////////////////////////////////////////////
01160 //                Base & Remote Proxy  Implementation. 
01161 //
01162 
01163 CORBA::_TAO_ConstructionPolicy_Proxy_Impl::_TAO_ConstructionPolicy_Proxy_Impl (void)
01164 {}
01165 
01166 CORBA::_TAO_ConstructionPolicy_Remote_Proxy_Impl::_TAO_ConstructionPolicy_Remote_Proxy_Impl (void)
01167 {}
01168 
01169 // Remote Implementation of the IDL interface methods
01170 
01171 void CORBA::_TAO_ConstructionPolicy_Remote_Proxy_Impl::make_domain_manager (
01172     CORBA_Object *_collocated_tao_target_,
01173     CORBA::InterfaceDef_ptr object_type,
01174     CORBA::Boolean constr_policy
01175     ACE_ENV_ARG_DECL
01176   )
01177   ACE_THROW_SPEC ((
01178     CORBA::SystemException
01179   ))
01180 {
01181   
01182   
01183   
01184   
01185   TAO_Stub *istub = _collocated_tao_target_->_stubobj ();
01186   if (istub == 0)
01187     ACE_THROW (CORBA::INTERNAL ());
01188 
01189   
01190   TAO_GIOP_Twoway_Invocation _tao_call (
01191       istub,
01192       "make_domain_manager",
01193       19,
01194       2,
01195       istub->orb_core ()
01196     );
01197   
01198   int _invoke_status;
01199   
01200 #if (TAO_HAS_INTERCEPTORS == 1)
01201   TAO_ClientRequestInterceptor_Adapter _tao_vfr (
01202       istub->orb_core ()->client_request_interceptors (),
01203       &_tao_call,
01204       _invoke_status
01205     );
01206   
01207 #endif  /* TAO_HAS_INTERCEPTORS */
01208   
01209   TAO_IFR_Client_Adapter *adapter =
01210     ACE_Dynamic_Service<TAO_IFR_Client_Adapter>::instance (
01211         TAO_ORB_Core::ifr_client_adapter_name ()
01212       );
01213 
01214   for (;;)
01215     {
01216       _invoke_status = TAO_INVOKE_EXCEPTION;
01217       
01218 #if TAO_HAS_INTERCEPTORS == 1
01219       TAO_ClientRequestInfo_CORBA_ConstructionPolicy_make_domain_manager _tao_ri (
01220         &_tao_call,
01221         _collocated_tao_target_,
01222         object_type,
01223         constr_policy ACE_ENV_ARG_PARAMETER
01224       );
01225             ACE_CHECK;
01226 
01227 #endif /* TAO_HAS_INTERCEPTORS */
01228       
01229       
01230       CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG;
01231       TAO_INTERCEPTOR (_tao_ri.response_expected (1));
01232       
01233 #if TAO_HAS_INTERCEPTORS == 1
01234       
01235       ACE_TRY
01236         {
01237           _tao_vfr.send_request (
01238             &_tao_ri
01239             ACE_ENV_ARG_PARAMETER
01240           );
01241           ACE_TRY_CHECK;
01242           
01243           if (_invoke_status == TAO_INVOKE_RESTART)
01244             {
01245               _tao_call.restart_flag (1);
01246               continue;
01247             }
01248           
01249 #endif /* TAO_HAS_INTERCEPTORS */
01250           
01251           _tao_call.start (ACE_ENV_SINGLE_ARG_PARAMETER);
01252                     TAO_INTERCEPTOR_CHECK;
01253 
01254           _tao_call.prepare_header (
01255               ACE_static_cast (CORBA::Octet, _tao_response_flag)
01256               ACE_ENV_ARG_PARAMETER
01257             );
01258                     TAO_INTERCEPTOR_CHECK;
01259 
01260           TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
01261           if (!(
01262               (adapter->interfacedef_cdr_insert (_tao_out, object_type)) &&
01263               (_tao_out << CORBA::Any::from_boolean (constr_policy))
01264             ))
01265             TAO_INTERCEPTOR_THROW (
01266               CORBA::MARSHAL ()
01267             );
01268             
01269           _invoke_status =
01270             _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
01271                     TAO_INTERCEPTOR_CHECK;
01272 
01273           if (_invoke_status == TAO_INVOKE_EXCEPTION)
01274             {
01275               TAO_INTERCEPTOR_THROW (
01276                 CORBA::UNKNOWN (CORBA::OMGVMCID | 1, CORBA::COMPLETED_YES)
01277               );
01278               
01279             }
01280           else if (_invoke_status == TAO_INVOKE_RESTART)
01281             {
01282               TAO_INTERCEPTOR (
01283                 _tao_ri.reply_status (_invoke_status);
01284                 _tao_vfr.receive_other (
01285                   &_tao_ri
01286                   ACE_ENV_ARG_PARAMETER
01287                 );
01288                 ACE_TRY_CHECK;
01289               )
01290               
01291               continue;
01292             }
01293           
01294           
01295 #if TAO_HAS_INTERCEPTORS == 1
01296           
01297           _tao_ri.reply_status (_invoke_status);
01298           _tao_vfr.receive_reply (
01299             &_tao_ri
01300             ACE_ENV_ARG_PARAMETER
01301           );
01302           ACE_TRY_CHECK;
01303         
01304       }
01305     ACE_CATCHANY
01306       {
01307         _tao_ri.exception (&ACE_ANY_EXCEPTION);
01308         _tao_vfr.receive_exception (
01309           &_tao_ri
01310           ACE_ENV_ARG_PARAMETER
01311         );
01312         ACE_TRY_CHECK;
01313         
01314         PortableInterceptor::ReplyStatus _tao_status =
01315           _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
01316         ACE_TRY_CHECK;
01317         
01318         if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
01319             || _tao_status == PortableInterceptor::USER_EXCEPTION)
01320           ACE_RE_THROW;
01321       }
01322     ACE_ENDTRY;
01323         ACE_CHECK;
01324 
01325     PortableInterceptor::ReplyStatus _tao_status =
01326       _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
01327         ACE_CHECK;
01328 
01329     if (_tao_status == PortableInterceptor::LOCATION_FORWARD
01330         || _tao_status == PortableInterceptor::TRANSPORT_RETRY)
01331       continue;
01332     
01333 #endif  /* TAO_HAS_INTERCEPTORS */
01334     
01335     break;
01336   }
01337 
01338 }
01339 
01340 
01341 //
01342 //            End  Base & Remote  Proxy Implemeentation. 
01343 ///////////////////////////////////////////////////////////////////////
01344 
01345 
01346 ///////////////////////////////////////////////////////////////////////
01347 //           Remote & Base  Proxy Broker Implementation
01348 //
01349 
01350 CORBA::_TAO_ConstructionPolicy_Proxy_Broker::_TAO_ConstructionPolicy_Proxy_Broker (void)
01351 {
01352 }
01353 
01354 CORBA::_TAO_ConstructionPolicy_Proxy_Broker::~_TAO_ConstructionPolicy_Proxy_Broker (void)
01355 {
01356 }
01357 
01358 CORBA::_TAO_ConstructionPolicy_Proxy_Broker * (*CORBA__TAO_ConstructionPolicy_Proxy_Broker_Factory_function_pointer) (
01359     CORBA::Object_ptr obj
01360   ) = 0;
01361 
01362 // Factory Member function Implementation.
01363 CORBA::_TAO_ConstructionPolicy_Remote_Proxy_Broker *
01364 CORBA::_TAO_ConstructionPolicy_Remote_Proxy_Broker::the_TAO_ConstructionPolicy_Remote_Proxy_Broker (void)
01365 {
01366   static ::CORBA::_TAO_ConstructionPolicy_Remote_Proxy_Broker remote_proxy_broker;
01367   return &remote_proxy_broker;
01368 }
01369 
01370 CORBA::_TAO_ConstructionPolicy_Remote_Proxy_Broker::_TAO_ConstructionPolicy_Remote_Proxy_Broker (void)
01371 {
01372 }
01373 
01374 CORBA::_TAO_ConstructionPolicy_Remote_Proxy_Broker::~_TAO_ConstructionPolicy_Remote_Proxy_Broker (void)
01375 {
01376 }
01377 
01378 CORBA::_TAO_ConstructionPolicy_Proxy_Impl&
01379 CORBA::_TAO_ConstructionPolicy_Remote_Proxy_Broker::select_proxy (
01380   ::CORBA::ConstructionPolicy *
01381   ACE_ENV_ARG_DECL_NOT_USED
01382 )
01383 {
01384   return this->remote_proxy_impl_;
01385 }
01386 
01387 
01388 //
01389 //           End Remote & Base Proxy Broker Implementation
01390 ///////////////////////////////////////////////////////////////////////
01391 
01392 
01393 // TAO_IDL - Generated from 
01394 // be/be_visitor_interface/interface_cs.cpp:198
01395 
01396 CORBA::ConstructionPolicy::ConstructionPolicy (int collocated)
01397 {
01398   this->CORBA_ConstructionPolicy_setup_collocation (collocated);
01399 }
01400 
01401 CORBA::ConstructionPolicy::~ConstructionPolicy (void)
01402 {}
01403 
01404 void
01405 CORBA::ConstructionPolicy::CORBA_ConstructionPolicy_setup_collocation (int collocated)
01406 {
01407   if (collocated)
01408     this->the_TAO_ConstructionPolicy_Proxy_Broker_ =
01409       ::CORBA__TAO_ConstructionPolicy_Proxy_Broker_Factory_function_pointer (this);
01410   else
01411     this->the_TAO_ConstructionPolicy_Proxy_Broker_ =
01412       ::CORBA::_TAO_ConstructionPolicy_Remote_Proxy_Broker::the_TAO_ConstructionPolicy_Remote_Proxy_Broker ();
01413   
01414   this->CORBA_Policy_setup_collocation (collocated);
01415 }
01416 
01417 void CORBA::ConstructionPolicy::_tao_any_destructor (void *_tao_void_pointer)
01418 {
01419   ConstructionPolicy *tmp = ACE_static_cast (ConstructionPolicy*, _tao_void_pointer);
01420   CORBA::release (tmp);
01421 }
01422 
01423 CORBA::ConstructionPolicy_ptr CORBA::ConstructionPolicy::_narrow (
01424     CORBA::Object_ptr obj
01425     ACE_ENV_ARG_DECL
01426   )
01427 {
01428   if (CORBA::is_nil (obj))
01429     return ConstructionPolicy::_nil ();
01430   if (! obj->_is_local ())
01431     {
01432       CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/ConstructionPolicy:1.0" ACE_ENV_ARG_PARAMETER);
01433       ACE_CHECK_RETURN (ConstructionPolicy::_nil ());
01434       if (is_a == 0)
01435         return ConstructionPolicy::_nil ();
01436     }
01437   return ConstructionPolicy::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
01438 }
01439 
01440 CORBA::ConstructionPolicy_ptr 
01441 CORBA::ConstructionPolicy::_unchecked_narrow (
01442     CORBA::Object_ptr obj
01443     ACE_ENV_ARG_DECL_NOT_USED
01444   )
01445 {
01446   if (CORBA::is_nil (obj))
01447     return ConstructionPolicy::_nil ();
01448   if (! obj->_is_local ())
01449     {
01450       TAO_Stub* stub = obj->_stubobj ();
01451       if (stub)
01452         stub->_incr_refcnt ();
01453       ConstructionPolicy_ptr default_proxy = ConstructionPolicy::_nil ();
01454 
01455       if (
01456           !CORBA::is_nil (stub->servant_orb_var ().ptr ()) &&
01457           stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () &&
01458           obj->_is_collocated () &&
01459           CORBA__TAO_ConstructionPolicy_Proxy_Broker_Factory_function_pointer != 0
01460         )
01461         {
01462           ACE_NEW_RETURN (
01463               default_proxy,
01464               ::CORBA::ConstructionPolicy (
01465                   stub,
01466                   1,
01467                   obj->_servant ()
01468                 ),
01469               ConstructionPolicy::_nil ()
01470             );
01471         }
01472       
01473       if (CORBA::is_nil (default_proxy))
01474         {
01475           ACE_NEW_RETURN (
01476               default_proxy,
01477               ::CORBA::ConstructionPolicy (
01478                   stub,
01479                   0,
01480                   obj->_servant ()
01481                 ),
01482               ConstructionPolicy::_nil ()
01483             );
01484         }
01485       
01486       return default_proxy;
01487     }
01488   else 
01489     return
01490       ACE_reinterpret_cast
01491         (
01492           ConstructionPolicy_ptr,
01493             obj->_tao_QueryInterface
01494               (
01495                 ACE_reinterpret_cast
01496                   (
01497                     ptr_arith_t,
01498                     &ConstructionPolicy::_tao_class_id
01499                   )
01500               )
01501         );
01502 }
01503 
01504 CORBA::ConstructionPolicy_ptr
01505 CORBA::ConstructionPolicy::_duplicate (ConstructionPolicy_ptr obj)
01506 {
01507   if (!CORBA::is_nil (obj))
01508     obj->_add_ref ();
01509   return obj;
01510 }
01511 
01512 CORBA::Boolean CORBA::ConstructionPolicy::_is_a (const CORBA::Char *value ACE_ENV_ARG_DECL)
01513 {
01514   if (
01515     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/ConstructionPolicy:1.0")) ||
01516     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Policy:1.0")) ||
01517     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
01518   return 1; // success using local knowledge
01519   else
01520     return this->CORBA_Object::_is_a (value ACE_ENV_ARG_PARAMETER);
01521 }
01522 
01523 void *CORBA::ConstructionPolicy::_tao_QueryInterface (ptr_arith_t type)
01524 {
01525   void *retv = 0;
01526   if (type == ACE_reinterpret_cast
01527     (ptr_arith_t,
01528       &ACE_NESTED_CLASS (::CORBA, ConstructionPolicy)::_tao_class_id))
01529     retv = ACE_reinterpret_cast (void*, this);
01530   else if (type == ACE_reinterpret_cast
01531     (ptr_arith_t,
01532       &::CORBA::Policy::_tao_class_id))
01533     retv = ACE_reinterpret_cast
01534       (
01535         void *,
01536         ACE_static_cast
01537           (
01538             CORBA::Policy_ptr,
01539             this
01540           )
01541       );
01542   else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
01543     retv = ACE_reinterpret_cast (void *,
01544       ACE_static_cast (CORBA::Object_ptr, this));
01545     
01546   if (retv)
01547     this->_add_ref ();
01548   return retv;
01549 }
01550 
01551 const char* CORBA::ConstructionPolicy::_interface_repository_id (void) const
01552 {
01553   return "IDL:omg.org/CORBA/ConstructionPolicy:1.0";
01554 }
01555 
01556 void CORBA::ConstructionPolicy::make_domain_manager (
01557     CORBA::InterfaceDef_ptr object_type,
01558     CORBA::Boolean constr_policy
01559     ACE_ENV_ARG_DECL
01560   )
01561   ACE_THROW_SPEC ((
01562     CORBA::SystemException
01563   ))
01564 {
01565   _TAO_ConstructionPolicy_Proxy_Impl &proxy = 
01566     this->the_TAO_ConstructionPolicy_Proxy_Broker_->select_proxy (this ACE_ENV_ARG_PARAMETER);
01567   ACE_CHECK;
01568   
01569   proxy.make_domain_manager (
01570       this,
01571       object_type,
01572       constr_policy ACE_ENV_ARG_PARAMETER
01573     );
01574 }
01575 
01576 static const CORBA::Long _oc_CORBA_ConstructionPolicy[] =
01577 {
01578   TAO_ENCAP_BYTE_ORDER, // byte order
01579   41,
01580   ACE_NTOHL (0x49444c3a), 
01581   ACE_NTOHL (0x6f6d672e), 
01582   ACE_NTOHL (0x6f72672f), 
01583   ACE_NTOHL (0x434f5242), 
01584   ACE_NTOHL (0x412f436f), 
01585   ACE_NTOHL (0x6e737472), 
01586   ACE_NTOHL (0x75637469), 
01587   ACE_NTOHL (0x6f6e506f), 
01588   ACE_NTOHL (0x6c696379), 
01589   ACE_NTOHL (0x3a312e30), 
01590   ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/ConstructionPolicy:1.0
01591   19,
01592   ACE_NTOHL (0x436f6e73), 
01593   ACE_NTOHL (0x74727563), 
01594   ACE_NTOHL (0x74696f6e), 
01595   ACE_NTOHL (0x506f6c69), 
01596   ACE_NTOHL (0x63790000),  // name = ConstructionPolicy
01597 };
01598 
01599 static CORBA::TypeCode _tc_TAO_tc_CORBA_ConstructionPolicy (
01600     CORBA::tk_objref,
01601     sizeof (_oc_CORBA_ConstructionPolicy),
01602     (char *) &_oc_CORBA_ConstructionPolicy,
01603     0,
01604     sizeof (CORBA::ConstructionPolicy)
01605   );
01606 
01607 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
01608 TAO_NAMESPACE_BEGIN (CORBA)
01609 TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_ConstructionPolicy, &_tc_TAO_tc_CORBA_ConstructionPolicy)
01610 TAO_NAMESPACE_END
01611 
01612 
01613 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
01614 
01615 #if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_DOMAINMANAGERLIST_CS_)
01616 #define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_DOMAINMANAGERLIST_CS_
01617 
01618 // The Base_Sequence functions, please see tao/Sequence.h
01619 void
01620 CORBA::_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::_allocate_buffer (CORBA::ULong length)
01621 {
01622   CORBA::DomainManager **tmp = 0;
01623   tmp = _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::allocbuf (length);
01624   
01625   if (this->buffer_ != 0)
01626   {
01627     CORBA::DomainManager **old = ACE_reinterpret_cast (CORBA::DomainManager**, this->buffer_);
01628     for (CORBA::ULong i = 0; i < this->length_; ++i)
01629       {
01630         if (!this->release_)
01631           {
01632             tmp[i] = CORBA::DomainManager::_duplicate (old[i]);
01633           }
01634         else
01635           {
01636             tmp[i] = old[i];
01637           }
01638       }
01639     
01640     if (this->release_)
01641       {
01642         delete[] old;
01643       }
01644   }
01645   this->buffer_ = tmp;
01646 }
01647 
01648 void
01649 CORBA::_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::_deallocate_buffer (void)
01650 {
01651   if (this->buffer_ == 0 || this->release_ == 0)
01652     return;
01653   CORBA::DomainManager **tmp = ACE_reinterpret_cast (CORBA::DomainManager**, this->buffer_);
01654   
01655   for (CORBA::ULong i = 0; i < this->length_; ++i)
01656     {
01657       CORBA::release (tmp[i]);
01658       tmp[i] = CORBA::DomainManager::_nil ();
01659     }
01660   
01661   _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::freebuf (tmp);
01662   this->buffer_ = 0;
01663 }
01664 
01665 CORBA::_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::~_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList (void)
01666 {
01667   this->_deallocate_buffer ();
01668 }
01669 
01670 void
01671 CORBA::_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
01672 {
01673   CORBA::DomainManager **tmp = ACE_reinterpret_cast (CORBA::DomainManager**, this->buffer_);
01674   
01675   for (CORBA::ULong i = nl; i < ol; ++i)
01676     {
01677       CORBA::release (tmp[i]);
01678       tmp[i] = CORBA::DomainManager::_nil ();
01679     }
01680 }
01681 
01682 void 
01683 CORBA::_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::_downcast (
01684     void* target,
01685     CORBA_Object *src
01686     ACE_ENV_ARG_DECL
01687   )
01688 {
01689   CORBA::DomainManager **tmp = ACE_static_cast (CORBA::DomainManager**, target);
01690   *tmp = CORBA::DomainManager::_narrow (src ACE_ENV_ARG_PARAMETER);
01691   ACE_CHECK;
01692 }
01693 
01694 CORBA_Object*
01695 CORBA::_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::_upcast (void *src) const
01696 {
01697   CORBA::DomainManager **tmp = ACE_static_cast (CORBA::DomainManager**, src);
01698   return *tmp;
01699 }
01700 
01701 #endif /* end #if !defined */
01702 
01703 
01704 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
01705 
01706 #if !defined (_CORBA_DOMAINMANAGERLIST_CS_)
01707 #define _CORBA_DOMAINMANAGERLIST_CS_
01708 
01709 // *************************************************************
01710 // CORBA::DomainManagerList
01711 // *************************************************************
01712 
01713 CORBA::DomainManagerList::DomainManagerList (void)
01714 {}
01715 CORBA::DomainManagerList::DomainManagerList (CORBA::ULong max) // uses max size
01716   : 
01717 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
01718 _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList
01719 #else /* TAO_USE_SEQUENCE_TEMPLATES */
01720 TAO_Unbounded_Object_Sequence<CORBA::DomainManager,CORBA::DomainManager_var>
01721 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
01722  (max)
01723 {}
01724 CORBA::DomainManagerList::DomainManagerList (CORBA::ULong max, CORBA::ULong length, CORBA::DomainManager_ptr *buffer, CORBA::Boolean release)
01725   : 
01726 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
01727 _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList
01728 #else /* TAO_USE_SEQUENCE_TEMPLATES */
01729 TAO_Unbounded_Object_Sequence<CORBA::DomainManager,CORBA::DomainManager_var>
01730 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
01731  (max, length, buffer, release)
01732 {}
01733 CORBA::DomainManagerList::DomainManagerList (const DomainManagerList &seq) // copy ctor
01734   : 
01735 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
01736 _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList
01737 #else /* TAO_USE_SEQUENCE_TEMPLATES */
01738 TAO_Unbounded_Object_Sequence<CORBA::DomainManager,CORBA::DomainManager_var>
01739 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
01740  (seq)
01741 {}
01742 CORBA::DomainManagerList::~DomainManagerList (void) // dtor
01743 {}
01744 void CORBA::DomainManagerList::_tao_any_destructor (void *_tao_void_pointer)
01745 {
01746   DomainManagerList *tmp = ACE_static_cast (DomainManagerList*, _tao_void_pointer);
01747   delete tmp;
01748 }
01749 
01750 
01751 #endif /* end #if !defined */
01752 
01753 static const CORBA::Long _oc_CORBA_DomainManagerList[] =
01754 {
01755   TAO_ENCAP_BYTE_ORDER, // byte order
01756   40,
01757   ACE_NTOHL (0x49444c3a), 
01758   ACE_NTOHL (0x6f6d672e), 
01759   ACE_NTOHL (0x6f72672f), 
01760   ACE_NTOHL (0x434f5242), 
01761   ACE_NTOHL (0x412f446f), 
01762   ACE_NTOHL (0x6d61696e), 
01763   ACE_NTOHL (0x4d616e61), 
01764   ACE_NTOHL (0x6765724c), 
01765   ACE_NTOHL (0x6973743a), 
01766   ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/DomainManagerList:1.0
01767   18,
01768   ACE_NTOHL (0x446f6d61), 
01769   ACE_NTOHL (0x696e4d61), 
01770   ACE_NTOHL (0x6e616765), 
01771   ACE_NTOHL (0x724c6973), 
01772   ACE_NTOHL (0x74000000),  // name = DomainManagerList
01773   CORBA::tk_sequence, // typecode kind
01774   80, // encapsulation length
01775     TAO_ENCAP_BYTE_ORDER, // byte order
01776     CORBA::tk_objref, // typecode kind
01777     64, // encapsulation length
01778       TAO_ENCAP_BYTE_ORDER, // byte order
01779       36,
01780       ACE_NTOHL (0x49444c3a), 
01781       ACE_NTOHL (0x6f6d672e), 
01782       ACE_NTOHL (0x6f72672f), 
01783       ACE_NTOHL (0x434f5242), 
01784       ACE_NTOHL (0x412f446f), 
01785       ACE_NTOHL (0x6d61696e), 
01786       ACE_NTOHL (0x4d616e61), 
01787       ACE_NTOHL (0x6765723a), 
01788       ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/DomainManager:1.0
01789       14,
01790       ACE_NTOHL (0x446f6d61), 
01791       ACE_NTOHL (0x696e4d61), 
01792       ACE_NTOHL (0x6e616765), 
01793       ACE_NTOHL (0x72000000),  // name = DomainManager
01794 
01795     0U,
01796 
01797 };
01798 
01799 static CORBA::TypeCode _tc_TAO_tc_CORBA_DomainManagerList (
01800     CORBA::tk_alias,
01801     sizeof (_oc_CORBA_DomainManagerList),
01802     (char *) &_oc_CORBA_DomainManagerList,
01803     0,
01804     sizeof (CORBA::DomainManagerList)
01805   );
01806 
01807 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
01808 TAO_NAMESPACE_BEGIN (CORBA)
01809 TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_DomainManagerList, &_tc_TAO_tc_CORBA_DomainManagerList)
01810 TAO_NAMESPACE_END
01811 
01812 
01813 // TAO_IDL - Generated from 
01814 // be/be_visitor_interface/any_op_cs.cpp:60
01815 
01816 void operator<<= (
01817     CORBA::Any &_tao_any,
01818     CORBA::DomainManager_ptr _tao_elem
01819   )
01820 {
01821   TAO_OutputCDR stream;
01822   
01823   if (stream << _tao_elem)
01824     {
01825       _tao_any._tao_replace (
01826           CORBA::_tc_DomainManager, 
01827           TAO_ENCAP_BYTE_ORDER,
01828           stream.begin (),
01829           1,
01830           CORBA::DomainManager::_duplicate (_tao_elem),
01831           CORBA::DomainManager::_tao_any_destructor
01832         );
01833     }
01834 }
01835 
01836 void operator<<= (
01837     CORBA::Any &_tao_any,
01838     CORBA::DomainManager_ptr *_tao_elem
01839   )
01840 {
01841   TAO_OutputCDR stream;
01842   
01843   if (stream << *_tao_elem)
01844     {
01845       _tao_any._tao_replace (
01846           CORBA::_tc_DomainManager, 
01847           TAO_ENCAP_BYTE_ORDER,
01848           stream.begin (),
01849           1,
01850           *_tao_elem,
01851           CORBA::DomainManager::_tao_any_destructor
01852         );
01853     }
01854 }
01855 
01856 CORBA::Boolean operator>>= (
01857     const CORBA::Any &_tao_any,
01858     CORBA::DomainManager_ptr &_tao_elem
01859   )
01860 {
01861   ACE_TRY_NEW_ENV
01862   {
01863     _tao_elem = CORBA::DomainManager::_nil ();
01864     CORBA::TypeCode_var type = _tao_any.type ();
01865     
01866     CORBA::Boolean result =
01867       type->equivalent (
01868           CORBA::_tc_DomainManager
01869           ACE_ENV_ARG_PARAMETER
01870         );
01871     ACE_TRY_CHECK;
01872     
01873     if (!result)
01874       {
01875         return 0; // not equivalent
01876       }
01877     
01878     TAO_InputCDR stream (
01879         _tao_any._tao_get_cdr (),
01880         _tao_any._tao_byte_order ()
01881       );
01882     
01883     if (stream >> _tao_elem)
01884       {
01885         ((CORBA::Any *)&_tao_any)->_tao_replace (
01886             CORBA::_tc_DomainManager,
01887             1,
01888             _tao_elem,
01889             CORBA::DomainManager::_tao_any_destructor
01890           );
01891         
01892         return 1;
01893       }
01894   }
01895   ACE_CATCHANY
01896   {
01897   }
01898   ACE_ENDTRY;
01899   
01900   _tao_elem = CORBA::DomainManager::_nil ();
01901   return 0;
01902 }
01903 
01904 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
01905     defined (ACE_HAS_GNU_REPO)
01906   template class TAO_Object_Manager<CORBA::DomainManager,CORBA::DomainManager_var>;
01907 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
01908 #  pragma instantiate TAO_Object_Manager<CORBA::DomainManager,CORBA::DomainManager_var>
01909 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
01910 
01911 
01912 // TAO_IDL - Generated from 
01913 // be/be_visitor_interface/any_op_cs.cpp:60
01914 
01915 void operator<<= (
01916     CORBA::Any &_tao_any,
01917     CORBA::ConstructionPolicy_ptr _tao_elem
01918   )
01919 {
01920   TAO_OutputCDR stream;
01921   
01922   if (stream << _tao_elem)
01923     {
01924       _tao_any._tao_replace (
01925           CORBA::_tc_ConstructionPolicy, 
01926           TAO_ENCAP_BYTE_ORDER,
01927           stream.begin (),
01928           1,
01929           CORBA::ConstructionPolicy::_duplicate (_tao_elem),
01930           CORBA::ConstructionPolicy::_tao_any_destructor
01931         );
01932     }
01933 }
01934 
01935 void operator<<= (
01936     CORBA::Any &_tao_any,
01937     CORBA::ConstructionPolicy_ptr *_tao_elem
01938   )
01939 {
01940   TAO_OutputCDR stream;
01941   
01942   if (stream << *_tao_elem)
01943     {
01944       _tao_any._tao_replace (
01945           CORBA::_tc_ConstructionPolicy, 
01946           TAO_ENCAP_BYTE_ORDER,
01947           stream.begin (),
01948           1,
01949           *_tao_elem,
01950           CORBA::ConstructionPolicy::_tao_any_destructor
01951         );
01952     }
01953 }
01954 
01955 CORBA::Boolean operator>>= (
01956     const CORBA::Any &_tao_any,
01957     CORBA::ConstructionPolicy_ptr &_tao_elem
01958   )
01959 {
01960   ACE_TRY_NEW_ENV
01961   {
01962     _tao_elem = CORBA::ConstructionPolicy::_nil ();
01963     CORBA::TypeCode_var type = _tao_any.type ();
01964     
01965     CORBA::Boolean result =
01966       type->equivalent (
01967           CORBA::_tc_ConstructionPolicy
01968           ACE_ENV_ARG_PARAMETER
01969         );
01970     ACE_TRY_CHECK;
01971     
01972     if (!result)
01973       {
01974         return 0; // not equivalent
01975       }
01976     
01977     TAO_InputCDR stream (
01978         _tao_any._tao_get_cdr (),
01979         _tao_any._tao_byte_order ()
01980       );
01981     
01982     if (stream >> _tao_elem)
01983       {
01984         ((CORBA::Any *)&_tao_any)->_tao_replace (
01985             CORBA::_tc_ConstructionPolicy,
01986             1,
01987             _tao_elem,
01988             CORBA::ConstructionPolicy::_tao_any_destructor
01989           );
01990         
01991         return 1;
01992       }
01993   }
01994   ACE_CATCHANY
01995   {
01996   }
01997   ACE_ENDTRY;
01998   
01999   _tao_elem = CORBA::ConstructionPolicy::_nil ();
02000   return 0;
02001 }
02002 
02003 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
02004     defined (ACE_HAS_GNU_REPO)
02005   template class TAO_Object_Manager<CORBA::ConstructionPolicy,CORBA::ConstructionPolicy_var>;
02006 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
02007 #  pragma instantiate TAO_Object_Manager<CORBA::ConstructionPolicy,CORBA::ConstructionPolicy_var>
02008 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
02009 
02010 
02011 // TAO_IDL - Generated from 
02012 // be/be_visitor_sequence/any_op_cs.cpp:61
02013 
02014 // Copying insertion.
02015 void operator<<= (
02016     CORBA::Any &_tao_any,
02017     const CORBA::DomainManagerList &_tao_elem
02018   )
02019 {
02020   TAO_OutputCDR stream;
02021   
02022   if (stream << _tao_elem)
02023     {
02024       _tao_any._tao_replace (
02025           CORBA::_tc_DomainManagerList,
02026           TAO_ENCAP_BYTE_ORDER,
02027           stream.begin ()
02028         );
02029     }
02030 }
02031 
02032 // Non-copying insertion.
02033 void operator<<= (
02034     CORBA::Any &_tao_any,
02035     CORBA::DomainManagerList *_tao_elem
02036   )
02037 {
02038   TAO_OutputCDR stream;
02039   
02040   if (stream << *_tao_elem)
02041     {
02042       _tao_any._tao_replace (
02043           CORBA::_tc_DomainManagerList,
02044           TAO_ENCAP_BYTE_ORDER,
02045           stream.begin (),
02046           1,
02047           _tao_elem,
02048           CORBA::DomainManagerList::_tao_any_destructor
02049         );
02050     }
02051 }
02052 
02053 // Extraction to non-const pointer (deprecated).
02054 CORBA::Boolean operator>>= (
02055     const CORBA::Any &_tao_any,
02056     CORBA::DomainManagerList *&_tao_elem
02057   )
02058 {
02059   return _tao_any >>= ACE_const_cast(
02060       const CORBA::DomainManagerList*&,
02061       _tao_elem
02062     );
02063 }
02064 
02065 // Extraction to const pointer.
02066 CORBA::Boolean operator>>= (
02067     const CORBA::Any &_tao_any,
02068     const CORBA::DomainManagerList *&_tao_elem
02069   )
02070 {
02071   _tao_elem = 0;
02072   
02073   ACE_TRY_NEW_ENV
02074   {
02075     CORBA::TypeCode_var type = _tao_any.type ();
02076     
02077     CORBA::Boolean result =
02078       type->equivalent (
02079           CORBA::_tc_DomainManagerList
02080           ACE_ENV_ARG_PARAMETER
02081         );
02082     ACE_TRY_CHECK;
02083     
02084     if (!result)
02085       {
02086         return 0; // not equivalent
02087       }
02088     
02089     if (_tao_any.any_owns_data ())
02090       {
02091         _tao_elem = ACE_static_cast(
02092             const CORBA::DomainManagerList*,
02093             _tao_any.value ()
02094           );
02095         
02096         return 1;
02097       }
02098     else
02099       {
02100         CORBA::DomainManagerList *tmp = 0;
02101         ACE_NEW_RETURN (
02102             tmp,
02103             CORBA::DomainManagerList,
02104             0
02105           );
02106         
02107         TAO_InputCDR stream (
02108             _tao_any._tao_get_cdr (),
02109             _tao_any._tao_byte_order ()
02110           );
02111         
02112         if (stream >> *tmp)
02113           {
02114             ((CORBA::Any *)&_tao_any)->_tao_replace (
02115                 CORBA::_tc_DomainManagerList,
02116                 1,
02117                 ACE_static_cast (void *, tmp),
02118                 CORBA::DomainManagerList::_tao_any_destructor
02119               );
02120             
02121             _tao_elem = tmp;
02122             return 1;
02123           }
02124         else
02125           {
02126             delete tmp;
02127           }
02128       }
02129   }
02130   ACE_CATCHANY
02131   {
02132   }
02133   ACE_ENDTRY;
02134   
02135   return 0;
02136 }
02137 
02138 CORBA::Boolean operator<< (
02139     TAO_OutputCDR &strm,
02140     const CORBA::DomainManager_ptr _tao_objref
02141   )
02142 {
02143   CORBA::Object_ptr _tao_corba_obj = _tao_objref;
02144   return (strm << _tao_corba_obj);
02145 }
02146 
02147 CORBA::Boolean operator>> (
02148     TAO_InputCDR &strm,
02149     CORBA::DomainManager_ptr &_tao_objref
02150   )
02151 {
02152   ACE_TRY_NEW_ENV
02153   {
02154     CORBA::Object_var obj;
02155     if ((strm >> obj.inout ()) == 0)
02156       return 0;
02157     // narrow to the right type
02158     _tao_objref =
02159       CORBA::DomainManager::_unchecked_narrow (
02160           obj.in ()
02161           ACE_ENV_ARG_PARAMETER
02162         );
02163     ACE_TRY_CHECK;
02164     return 1;
02165   }
02166   ACE_CATCHANY
02167   {
02168     // do nothing
02169   }
02170   ACE_ENDTRY;
02171   return 0;
02172 }
02173 
02174 CORBA::Boolean operator<< (
02175     TAO_OutputCDR &strm,
02176     const CORBA::ConstructionPolicy_ptr _tao_objref
02177   )
02178 {
02179   CORBA::Object_ptr _tao_corba_obj = _tao_objref;
02180   return (strm << _tao_corba_obj);
02181 }
02182 
02183 CORBA::Boolean operator>> (
02184     TAO_InputCDR &strm,
02185     CORBA::ConstructionPolicy_ptr &_tao_objref
02186   )
02187 {
02188   ACE_TRY_NEW_ENV
02189   {
02190     CORBA::Object_var obj;
02191     if ((strm >> obj.inout ()) == 0)
02192       return 0;
02193     // narrow to the right type
02194     _tao_objref =
02195       CORBA::ConstructionPolicy::_unchecked_narrow (
02196           obj.in ()
02197           ACE_ENV_ARG_PARAMETER
02198         );
02199     ACE_TRY_CHECK;
02200     return 1;
02201   }
02202   ACE_CATCHANY
02203   {
02204     // do nothing
02205   }
02206   ACE_ENDTRY;
02207   return 0;
02208 }
02209 
02210 CORBA::Boolean operator<< (
02211     TAO_OutputCDR &strm,
02212     const CORBA::DomainManagerList &_tao_sequence
02213   )
02214 {
02215   if (strm << _tao_sequence.length ())
02216   {
02217     // encode all elements
02218     CORBA::Boolean _tao_marshal_flag = 1;
02219     for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
02220     {
02221       _tao_marshal_flag = (strm << _tao_sequence[i].in ());
02222     }
02223     return _tao_marshal_flag;
02224   }
02225   return 0; // error
02226 }
02227 
02228 CORBA::Boolean operator>> (
02229     TAO_InputCDR &strm,
02230     CORBA::DomainManagerList &_tao_sequence
02231   )
02232 {
02233   CORBA::ULong _tao_seq_len;
02234   if (strm >> _tao_seq_len)
02235   {
02236     // Add a check to the length of the sequence
02237     // to make sure it does not exceed the length
02238     // of the stream. (See bug 1159.)
02239     if (_tao_seq_len > strm.length())
02240       return 0;
02241     // set the length of the sequence
02242     _tao_sequence.length (_tao_seq_len);
02243     // If length is 0 we return true.
02244     if (0 >= _tao_seq_len) 
02245       return 1;
02246     // retrieve all the elements
02247     CORBA::Boolean _tao_marshal_flag = 1;
02248     for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
02249     {
02250       _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
02251     }
02252     return _tao_marshal_flag;
02253   }
02254   return 0; // error
02255 }
02256 

Generated on Mon Jun 16 13:48:16 2003 for TAO by doxygen1.2.14 written by Dimitri van Heesch, © 1997-2002