diff options
Diffstat (limited to 'TAO')
33 files changed, 3241 insertions, 2928 deletions
diff --git a/TAO/ChangeLogs/ChangeLog-02a b/TAO/ChangeLogs/ChangeLog-02a index 00929db4079..3498e20b2d7 100644 --- a/TAO/ChangeLogs/ChangeLog-02a +++ b/TAO/ChangeLogs/ChangeLog-02a @@ -1,3 +1,77 @@ +Wed Nov 15 21:35:17 2000 Balachandran Natarajan <bala@cs.wustl.edu> + + This set of changes have been motivated by the CORBA 2.4 + spec. The spec specifies that the GIOP request header should not + be padded to a 8 byte boundary if there is no information or + data that is sent along. In other words, Request headers for + operations with no arguments should not be padded to a 8 byte + boundary. Actually, the CORBA 2.4 spec has specified this only + for the request header. But, the same argument has been applied + for the reply header too. ORBIX 2000 already does this. If the + operation returns a void and has no arguments, the reply header + is not padded to an 8 byte boundary. So, the same has been done + for TAO too. + + * TAO_IDL/be/be_visitor_operation/ami_cs.cpp: + * TAO_IDL/be/be_visitor_operation/operation_cs.cpp: Set a flag + for one of the arguments to the constructors of + TAO_GIOP_invocation classes. The flag is set 1 if there are any + arguments that are marshalled and 0 if there are no arguments + that are marshalled. + + * TAO_IDL/be/be_visitor_operation/operation_ss.cpp: Added a line + of generated code to set a flag in the TAO_Server_Request class + if there are no arguments and return types for the operation + that need to be marshalled. + + * tao/Invocation.h: + * tao/Invocation.cpp: + * tao/Invocation.i: + * tao/Asynch_Invocation.h: + * tao/Asynch_Invocation.cpp: + * tao/Asynch_Invocation.i: Added an extra argument to the + TAO_GIOP_Invocation classes. This argument is passed to the + constructor of TAO_Operation_details. + + * tao/DynamicInterface/DII_Invocation.h: + * tao/DynamicInterface/DII_Invocation.inl: + * tao/DynamicInterface/Request.cpp: Made the above changes to + these classes too. + + * tao/operation_details.h: + * tao/operation_details.i: Added a argument to the + constructor. Stored the argument in the class and provided an + accessor for it. + + * tao/GIOP_Message_Accept_State.cpp: + * tao/GIOP_Message_Acceptors.cpp: + * tao/GIOP_Message_Connectors.cpp: Added a check to check to see + whether the GIOP message is going to carry any data before we + align the pointer to an 8 byte boundary. + + * tao/Pluggable_Messaging_Utils.h: + * tao/TAO_Server_Request.h: + * tao/TAO_Server_Request.cpp + * tao/TAO_Server_Request.i: Added an extra flag and accessor for a + flag that would be set by the generated code to 0 if there are no + data that needs to be marshalled. + + * tao/CORBANAME_Parser.cpp: + * tao/DomainC.cpp: + * tao/PolicyC.cpp: + * tao/PortableServer/ImplRepoC.cpp: Changed the arguments for the + TAO_GIOP_invocation calls. + + + * tao/IIOP_Connector.h: + * tao/IIOP_Connector.cpp: + * tao/Strategies/SHMIOP_Connector.cpp + * tao/Strategies/SHMIOP_Connector.h + * tao/Strategies/UIOP_Connector.cpp + * tao/Strategies/UIOP_Connector.h: Totally unrelated to the above + change. Added default constructors and derstructors as g++2.7.2 + seems to be looking for it. + Wed Nov 15 19:11:28 2000 Ossama Othman <ossama@uci.edu> * orbsvcs/orbsvcs/Security.idl: diff --git a/TAO/TAO_IDL/be/be_visitor_operation/ami_cs.cpp b/TAO/TAO_IDL/be/be_visitor_operation/ami_cs.cpp index ef48bb93860..6a4d8ca270d 100644 --- a/TAO/TAO_IDL/be/be_visitor_operation/ami_cs.cpp +++ b/TAO/TAO_IDL/be/be_visitor_operation/ami_cs.cpp @@ -421,12 +421,37 @@ be_compiled_visitor_operation_ami_cs::gen_marshal_and_invoke (be_operation *node ext += 5; } + // Do we have any arguments in the operation that needs marshalling + UTL_ScopeActiveIterator si (node, + UTL_Scope::IK_decls); + AST_Decl *d = 0; + AST_Argument *arg = 0; + int flag = 0; + + while (!si.is_done ()) + { + d = si.item (); + arg = AST_Argument::narrow_from_decl (d); + + if (arg->direction () == AST_Argument::dir_IN || + arg->direction () == AST_Argument::dir_INOUT) + { + // There is something that needs marshalling + flag = 1; + break; + } + si.next (); + } + *os << node->local_name () << "\"," << be_nl << ACE_OS::strlen (node->original_local_name ()->get_string ()) + ext << "," << be_nl + << flag + << ","<< be_nl << "istub->orb_core ()," << be_nl; + // Next argument is the reply handler skeleton for this method. // Get the interface. diff --git a/TAO/TAO_IDL/be/be_visitor_operation/operation_cs.cpp b/TAO/TAO_IDL/be/be_visitor_operation/operation_cs.cpp index a2eba19e497..2ff451a6357 100644 --- a/TAO/TAO_IDL/be/be_visitor_operation/operation_cs.cpp +++ b/TAO/TAO_IDL/be/be_visitor_operation/operation_cs.cpp @@ -341,12 +341,36 @@ be_visitor_operation_cs::gen_marshal_and_invoke (be_operation *node, // Do we have "_set_" or "_get_" prepended? size_t ext = this->ctx_->attribute () ? 5 : 0; + // Do we have any arguments in the operation that needs marshalling + UTL_ScopeActiveIterator si (node, + UTL_Scope::IK_decls); + AST_Decl *d = 0; + AST_Argument *arg = 0; + int flag = 0; + + while (!si.is_done ()) + { + d = si.item (); + arg = AST_Argument::narrow_from_decl (d); + + if (arg->direction () == AST_Argument::dir_IN || + arg->direction () == AST_Argument::dir_INOUT) + { + // There is something that needs marshalling + flag = 1; + break; + } + si.next (); + } + *os << "(" << be_idt << be_idt_nl << "istub," << be_nl << this->compute_operation_name (node) << "," << be_nl << ACE_OS::strlen (node->original_local_name ()->get_string ()) + ext << "," << be_nl + << flag + << "," <<be_nl << "istub->orb_core ()" << be_uidt_nl << ");\n"; diff --git a/TAO/TAO_IDL/be/be_visitor_operation/operation_ss.cpp b/TAO/TAO_IDL/be/be_visitor_operation/operation_ss.cpp index 0a9f5be24da..f3928c7d787 100644 --- a/TAO/TAO_IDL/be/be_visitor_operation/operation_ss.cpp +++ b/TAO/TAO_IDL/be/be_visitor_operation/operation_ss.cpp @@ -153,6 +153,36 @@ be_visitor_operation_ss::visit_operation (be_operation *node) ctx.state (TAO_CodeGen::TAO_OPERATION_RETVAL_DECL_SS); be_visitor *visitor = tao_cg->make_visitor (&ctx); + // Do we have any arguments in the operation that needs marshalling + UTL_ScopeActiveIterator si (node, + UTL_Scope::IK_decls); + AST_Decl *d = 0; + AST_Argument *arg = 0; + int flag = 0; + while (!si.is_done ()) + { + d = si.item (); + arg = AST_Argument::narrow_from_decl (d); + + if (arg->direction () == AST_Argument::dir_INOUT || + arg->direction () == AST_Argument::dir_OUT) + { + // There are return type that needs to get marshalled + flag = 1; + break; + } + si.next (); + } + + // Check if the flag is zero and for the return type + if (flag == 0 && + node->void_return_type () == 1) + { + // There are no return type and argument values that needs to be + // marshalled + *os << "_tao_server_request.argument_flag (0);" << be_nl; + } + if (!visitor || (bt->accept (visitor) == -1)) { delete visitor; @@ -190,7 +220,7 @@ be_visitor_operation_ss::visit_operation (be_operation *node) // Fish out the interceptor and do preinvoke. *os << "#if (TAO_HAS_INTERCEPTORS == 1)" << be_nl - << "TAO_ServerRequestInterceptor_Adapter _tao_vfr (" + << "TAO_ServerRequestInterceptor_Adapter _tao_vfr (" << be_idt << be_idt_nl << "_tao_server_request.orb_core ()->server_request_interceptors ()" << be_uidt_nl diff --git a/TAO/tao/Asynch_Invocation.cpp b/TAO/tao/Asynch_Invocation.cpp index 45fd09af7bc..f857f75368e 100644 --- a/TAO/tao/Asynch_Invocation.cpp +++ b/TAO/tao/Asynch_Invocation.cpp @@ -5,9 +5,9 @@ ACE_RCSID(tao, Asynch_Invocation, "$Id$") -#if (TAO_HAS_AMI_CALLBACK == 1) \ - || (TAO_HAS_AMI_POLLER == 1) \ - || (TAO_HAS_MINIMUM_CORBA == 0) +#if (TAO_HAS_AMI_CALLBACK == 1) \ + || (TAO_HAS_AMI_POLLER == 1) \ + || (TAO_HAS_MINIMUM_CORBA == 0) #include "tao/Timeprobe.h" #include "tao/Stub.h" @@ -47,12 +47,12 @@ enum // Setup Timeprobes ACE_TIMEPROBE_EVENT_DESCRIPTIONS (TAO_Asynch_Invocation_Timeprobe_Description, - TAO_GIOP_ASYNCH_INVOCATION_INVOKE_START); + TAO_GIOP_ASYNCH_INVOCATION_INVOKE_START); -#endif /* ACE_ENABLE_TIMEPROBES */ +#endif /* ACE_ENABLE_TIMEPROBES */ TAO_GIOP_Asynch_Invocation::TAO_GIOP_Asynch_Invocation (void) - : rd_ (0) + : rd_ (0) { } @@ -62,45 +62,45 @@ TAO_GIOP_Asynch_Invocation::invoke (CORBA::Environment &ACE_TRY_ENV) { TAO_FUNCTION_PP_TIMEPROBE (TAO_GIOP_ASYNCH_INVOCATION_INVOKE_START); - return this->invoke_i (ACE_TRY_ENV); + return this->invoke_i (ACE_TRY_ENV); } // ************************************************************************** int -TAO_GIOP_Twoway_Asynch_Invocation::invoke_i (CORBA::Environment &ACE_TRY_ENV) +TAO_GIOP_Twoway_Asynch_Invocation::invoke_i (CORBA::Environment &ACE_TRY_ENV) ACE_THROW_SPEC ((CORBA::SystemException)) { - // Register a reply dispatcher for this Asynch_Invocation. Use the + // Register a reply dispatcher for this Asynch_Invocation. Use the // heap allocated reply dispatcher. int retval = this->transport_->tms ()->bind_dispatcher (this->op_details_.request_id (), - this->rd_); - if (retval == -1) + this->rd_); + if (retval == -1) { - // @@ What is the right way to handle this error? + // @@ What is the right way to handle this error? this->close_connection (); - ACE_THROW_RETURN (CORBA::INTERNAL (TAO_DEFAULT_MINOR_CODE, - CORBA::COMPLETED_NO), - TAO_INVOKE_EXCEPTION); + ACE_THROW_RETURN (CORBA::INTERNAL (TAO_DEFAULT_MINOR_CODE, + CORBA::COMPLETED_NO), + TAO_INVOKE_EXCEPTION); } // Just send the request, without trying to wait for the reply. retval = TAO_GIOP_Invocation::invoke (0, - ACE_TRY_ENV); + ACE_TRY_ENV); ACE_CHECK_RETURN (retval); - if (retval != TAO_INVOKE_OK) + if (retval != TAO_INVOKE_OK) return retval; - // Everything executed ok; lets remember the transport for later. + // Everything executed ok; lets remember the transport for later. this->rd_->transport (this->transport_); - // We do not wait for the reply. Let us return. + // We do not wait for the reply. Let us return. return TAO_INVOKE_OK; } -#endif /* TAO_HAS_AMI_CALLBACK == 1 - || TAO_HAS_AMI_POLLER == 1 - || TAO_HAS_MINIMUM_CORBA == 0 */ +#endif /* TAO_HAS_AMI_CALLBACK == 1 + || TAO_HAS_AMI_POLLER == 1 + || TAO_HAS_MINIMUM_CORBA == 0 */ diff --git a/TAO/tao/Asynch_Invocation.h b/TAO/tao/Asynch_Invocation.h index 9ea17ced414..4854a38ff29 100644 --- a/TAO/tao/Asynch_Invocation.h +++ b/TAO/tao/Asynch_Invocation.h @@ -33,7 +33,7 @@ #include "tao/MessagingC.h" #include "tao/Asynch_Reply_Dispatcher.h" -class TAO_Export TAO_GIOP_Asynch_Invocation +class TAO_Export TAO_GIOP_Asynch_Invocation : public TAO_GIOP_Invocation { // = TITLE @@ -51,6 +51,7 @@ public: TAO_GIOP_Asynch_Invocation (TAO_Stub *stub, const char *operation, CORBA::ULong opname_len, + CORBA::Boolean argument_flag, TAO_ORB_Core *orb_core); // Constructor. @@ -68,7 +69,7 @@ protected: // Reply dispatcher for the current asynchronous invocation. }; -class TAO_Export TAO_GIOP_Twoway_Asynch_Invocation +class TAO_Export TAO_GIOP_Twoway_Asynch_Invocation : public TAO_GIOP_Asynch_Invocation { // = TITLE @@ -85,6 +86,7 @@ public: TAO_Stub *stub, const char *operation, CORBA::ULong opname_len_, + CORBA::Boolean argument_flag, TAO_ORB_Core* orb_core, const TAO_Reply_Handler_Skeleton &reply_handler_skel, Messaging::ReplyHandler_ptr reply_handler_ptr @@ -102,8 +104,8 @@ protected: # include "tao/Asynch_Invocation.i" #endif /* __ACE_INLINE__ */ -#endif /* TAO_HAS_AMI_CALLBACK == 1 - || TAO_HAS_AMI_POLLER == 1 +#endif /* TAO_HAS_AMI_CALLBACK == 1 + || TAO_HAS_AMI_POLLER == 1 || TAO_HAS_MINIMUM_CORBA == 0 */ #include "ace/post.h" diff --git a/TAO/tao/Asynch_Invocation.i b/TAO/tao/Asynch_Invocation.i index 503151f0cf0..bc73206b139 100644 --- a/TAO/tao/Asynch_Invocation.i +++ b/TAO/tao/Asynch_Invocation.i @@ -1,4 +1,4 @@ -// This may look like C, but it's really -*- C++ -*- +// This may look like C, but it's really -*- C++ -*- // // $Id$ // @@ -8,13 +8,15 @@ TAO_GIOP_Asynch_Invocation::TAO_GIOP_Asynch_Invocation ( TAO_Stub *stub, const char *operation, CORBA::ULong opname_len, + CORBA::Boolean argument_flag, TAO_ORB_Core *orb_core ) - : TAO_GIOP_Invocation (stub, - operation, - opname_len, - orb_core), - rd_ (0) + : TAO_GIOP_Invocation (stub, + operation, + opname_len, + argument_flag, + orb_core), + rd_ (0) { } @@ -25,22 +27,23 @@ TAO_GIOP_Twoway_Asynch_Invocation::TAO_GIOP_Twoway_Asynch_Invocation ( TAO_Stub *stub, const char *operation, CORBA::ULong opname_len, + CORBA::Boolean argument_flag, TAO_ORB_Core *orb_core, const TAO_Reply_Handler_Skeleton &reply_handler_skel, - Messaging::ReplyHandler_ptr reply_handler_ptr + Messaging::ReplyHandler_ptr reply_handler_ptr ) : TAO_GIOP_Asynch_Invocation (stub, - operation, - opname_len, - orb_core) + operation, + opname_len, + argument_flag, + orb_core) { // New reply dispatcher on the heap, because - // we will go out of scope and hand over the + // we will go out of scope and hand over the // reply dispatcher to the ORB. - // So this->rd_ is 0, because we do not need to + // So this->rd_ is 0, because we do not need to // hold a pointer to it. ACE_NEW (this->rd_, - TAO_Asynch_Reply_Dispatcher (reply_handler_skel, - reply_handler_ptr)); + TAO_Asynch_Reply_Dispatcher (reply_handler_skel, + reply_handler_ptr)); } - diff --git a/TAO/tao/CORBANAME_Parser.cpp b/TAO/tao/CORBANAME_Parser.cpp index 19f8f7b975e..32e469f33cf 100644 --- a/TAO/tao/CORBANAME_Parser.cpp +++ b/TAO/tao/CORBANAME_Parser.cpp @@ -18,18 +18,18 @@ int TAO_CORBANAME_Parser::match_prefix (const char *ior_string) const { return (ACE_OS::strncmp (ior_string, - corbaname_prefix, - sizeof corbaname_prefix - 1) == 0); + corbaname_prefix, + sizeof corbaname_prefix - 1) == 0); } CORBA::Object_ptr TAO_CORBANAME_Parser:: parse_string_dynamic_request_helper (CORBA::Object_ptr naming_context, - ACE_CString &key_string, - CORBA::Environment &ACE_TRY_ENV) + ACE_CString &key_string, + CORBA::Environment &ACE_TRY_ENV) ACE_THROW_SPEC ((CORBA::SystemException)) { - CORBA::Object_ptr _tao_retval = CORBA::Object::_nil (); + CORBA::Object_ptr _tao_retval = CORBA::Object::_nil (); CORBA::Object_var _tao_safe_retval (_tao_retval); @@ -41,6 +41,7 @@ parse_string_dynamic_request_helper (CORBA::Object_ptr naming_context, istub, "resolve_str", 11, + 1, istub->orb_core () ); @@ -49,157 +50,157 @@ parse_string_dynamic_request_helper (CORBA::Object_ptr naming_context, _tao_call.start (ACE_TRY_ENV); ACE_CHECK_RETURN (CORBA::Object::_nil ()); - CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG; + CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG; _tao_call.prepare_header ( - ACE_static_cast (CORBA::Octet, _tao_response_flag), - ACE_TRY_ENV - ); + ACE_static_cast (CORBA::Octet, _tao_response_flag), + ACE_TRY_ENV + ); ACE_CHECK_RETURN (CORBA::Object::_nil ()); - TAO_OutputCDR &_tao_out = _tao_call.out_stream (); + TAO_OutputCDR &_tao_out = _tao_call.out_stream (); if (!( - (_tao_out << key_string.c_str ()) - )) - ACE_THROW_RETURN ( - CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_NO), - CORBA::Object::_nil () - ); + (_tao_out << key_string.c_str ()) + )) + ACE_THROW_RETURN ( + CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_NO), + CORBA::Object::_nil () + ); int _invoke_status = 0; ACE_TRY - { - _invoke_status = _tao_call.invoke (0, 0, ACE_TRY_ENV); - ACE_TRY_CHECK (CORBA::Object::_nil ()); - } - ACE_CATCH (CORBA::UNKNOWN, ex) - { - ACE_UNUSED_ARG (ex); - - ACE_THROW_RETURN ( - CORBA::BAD_PARAM (TAO_OMG_VMCID | TAO_OMG_MINOR_BAD_PARAM_10, - CORBA::COMPLETED_YES), - CORBA::Object::_nil () - ); - } + { + _invoke_status = _tao_call.invoke (0, 0, ACE_TRY_ENV); + ACE_TRY_CHECK (CORBA::Object::_nil ()); + } + ACE_CATCH (CORBA::UNKNOWN, ex) + { + ACE_UNUSED_ARG (ex); + + ACE_THROW_RETURN ( + CORBA::BAD_PARAM (TAO_OMG_VMCID | TAO_OMG_MINOR_BAD_PARAM_10, + CORBA::COMPLETED_YES), + CORBA::Object::_nil () + ); + } ACE_ENDTRY; ACE_CHECK_RETURN (CORBA::Object::_nil ()); if (_invoke_status == TAO_INVOKE_RESTART) - { - _tao_call.restart_flag (1); - continue; - } + { + _tao_call.restart_flag (1); + continue; + } if (_invoke_status != TAO_INVOKE_OK) - { - // @@ Is there any way we can reach this point? Any - // USER_EXCEPTION response will be caught by the UNKNOWN - // catch block above. Any SYSTEM_EXCEPTION response will - // be simply raised, and any RESTART is handled - // already... leave this here "just in case". - ACE_THROW_RETURN ( - CORBA::BAD_PARAM (TAO_OMG_VMCID | TAO_OMG_MINOR_BAD_PARAM_10, - CORBA::COMPLETED_YES), - CORBA::Object::_nil () - ); - } + { + // @@ Is there any way we can reach this point? Any + // USER_EXCEPTION response will be caught by the UNKNOWN + // catch block above. Any SYSTEM_EXCEPTION response will + // be simply raised, and any RESTART is handled + // already... leave this here "just in case". + ACE_THROW_RETURN ( + CORBA::BAD_PARAM (TAO_OMG_VMCID | TAO_OMG_MINOR_BAD_PARAM_10, + CORBA::COMPLETED_YES), + CORBA::Object::_nil () + ); + } TAO_InputCDR &_tao_in = _tao_call.inp_stream (); if (!( - (_tao_in >> _tao_safe_retval.inout ()) - )) - { - ACE_THROW_RETURN ( - CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), - CORBA::Object::_nil () - ); - } + (_tao_in >> _tao_safe_retval.inout ()) + )) + { + ACE_THROW_RETURN ( + CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), + CORBA::Object::_nil () + ); + } break; } - return _tao_safe_retval._retn (); + return _tao_safe_retval._retn (); } CORBA::Object_ptr TAO_CORBANAME_Parser::parse_string (const char *ior, - CORBA::ORB_ptr orb, - CORBA::Environment &ACE_TRY_ENV) + CORBA::ORB_ptr orb, + CORBA::Environment &ACE_TRY_ENV) ACE_THROW_SPEC ((CORBA::SystemException)) { // Skip the prefix, we know it is there because this method in only // called if <match_prefix> returns 1. - const char *corbaname = - ior + sizeof corbaname_prefix - 1; + const char *corbaname = + ior + sizeof corbaname_prefix - 1; - CORBA::Object_ptr obj = CORBA::Object::_nil (); + CORBA::Object_ptr obj = CORBA::Object::_nil (); ACE_TRY { char rir_prot [] = "rir:"; - // The position of the seperator between the obj_addr and key + // The position of the seperator between the obj_addr and key // string CORBA::ULong pos_seperator = 0; - ACE_CString corbaname_str (corbaname, 0, 1); + ACE_CString corbaname_str (corbaname, 0, 1); pos_seperator = corbaname_str.find ("#", 0); // Get the Key String ACE_CString key_string = - corbaname_str.substring (pos_seperator + 1, - -1); + corbaname_str.substring (pos_seperator + 1, + -1); - // Make it in a form understandable by <corbaloc> scheme - ACE_CString corbaloc_addr ("corbaloc:", 0, 1); + // Make it in a form understandable by <corbaloc> scheme + ACE_CString corbaloc_addr ("corbaloc:", 0, 1); if (ACE_OS::strncmp (corbaname, - rir_prot, - sizeof (rir_prot)) != 0) - { - // Implies that <iiop:> protocol is to be used. - // So .. we need to get the host address where an object of - // type NamingContext can be found. - // Get the obj_addr - ACE_CString obj_addr = corbaname_str.substring (0, - pos_seperator); + rir_prot, + sizeof (rir_prot)) != 0) + { + // Implies that <iiop:> protocol is to be used. + // So .. we need to get the host address where an object of + // type NamingContext can be found. + // Get the obj_addr + ACE_CString obj_addr = corbaname_str.substring (0, + pos_seperator); - corbaloc_addr += obj_addr; + corbaloc_addr += obj_addr; - } + } - ACE_CString name_service ("/NameService", 0, 1); + ACE_CString name_service ("/NameService", 0, 1); corbaloc_addr += name_service; - // Obtain a reference to the naming context - CORBA::Object_var name_context = - orb->string_to_object (corbaloc_addr.c_str (), - ACE_TRY_ENV); + // Obtain a reference to the naming context + CORBA::Object_var name_context = + orb->string_to_object (corbaloc_addr.c_str (), + ACE_TRY_ENV); ACE_TRY_CHECK; // Check if the Object reference is nil. - if (CORBA::is_nil (name_context.in ())) - ACE_ERROR_RETURN ((LM_ERROR, - "Cannot resolve Naming Service: CORBANAME_Parser\n"), - 0); + if (CORBA::is_nil (name_context.in ())) + ACE_ERROR_RETURN ((LM_ERROR, + "Cannot resolve Naming Service: CORBANAME_Parser\n"), + 0); CORBA::Boolean is_a = - name_context->_is_a ("IDL:omg.org/CosNaming/NamingContextExt:1.0", - ACE_TRY_ENV); + name_context->_is_a ("IDL:omg.org/CosNaming/NamingContextExt:1.0", + ACE_TRY_ENV); ACE_TRY_CHECK; if (!is_a) - { - ACE_ERROR_RETURN ((LM_ERROR, - "Cannot narrow Naming Service: " - "CORBANAME_Parser\n"), - 0); - } - - // Make a dynamic request for resolve_str in this naming context + { + ACE_ERROR_RETURN ((LM_ERROR, + "Cannot narrow Naming Service: " + "CORBANAME_Parser\n"), + 0); + } + + // Make a dynamic request for resolve_str in this naming context obj = this->parse_string_dynamic_request_helper (name_context.in (), - key_string, - ACE_TRY_ENV); + key_string, + ACE_TRY_ENV); ACE_TRY_CHECK; } ACE_CATCH (CORBA::SystemException, ex) @@ -207,18 +208,18 @@ TAO_CORBANAME_Parser::parse_string (const char *ior, ACE_PRINT_EXCEPTION (ex, "CORBANAME_Parser"); } ACE_ENDTRY; - ACE_CHECK_RETURN (CORBA::Object::_nil ()); + ACE_CHECK_RETURN (CORBA::Object::_nil ()); return obj; } ACE_STATIC_SVC_DEFINE (TAO_CORBANAME_Parser, - ACE_TEXT ("CORBANAME_Parser"), - ACE_SVC_OBJ_T, - &ACE_SVC_NAME (TAO_CORBANAME_Parser), - ACE_Service_Type::DELETE_THIS | - ACE_Service_Type::DELETE_OBJ, - 0) + ACE_TEXT ("CORBANAME_Parser"), + ACE_SVC_OBJ_T, + &ACE_SVC_NAME (TAO_CORBANAME_Parser), + ACE_Service_Type::DELETE_THIS | + ACE_Service_Type::DELETE_OBJ, + 0) ACE_FACTORY_DEFINE (TAO, TAO_CORBANAME_Parser) diff --git a/TAO/tao/DomainC.cpp b/TAO/tao/DomainC.cpp index 22b19765b15..e7bf877c2a5 100644 --- a/TAO/tao/DomainC.cpp +++ b/TAO/tao/DomainC.cpp @@ -1,11 +1,11 @@ /* -*- C++ -*- $Id$ */ -// ****** Code generated by the The ACE ORB (TAO) IDL Compiler ******* -// TAO and the TAO IDL Compiler have been developed by the Center for -// Distributed Object Computing at Washington University, St. Louis. +// ****** Code generated by the The ACE ORB (TAO) IDL Compiler ******* +// TAO and the TAO IDL Compiler have been developed by the Center for +// Distributed Object Computing at Washington University, St. Louis. // // Information about TAO is available at: -// http://www.cs.wustl.edu/~schmidt/TAO.html +// http://www.cs.wustl.edu/~schmidt/TAO.html #include "DomainC.h" #include "Stub.h" @@ -34,63 +34,63 @@ void CORBA_DomainManager::_tao_any_destructor (void *x) CORBA::release (tmp); } -CORBA_DomainManager_ptr CORBA_DomainManager::_narrow ( +CORBA_DomainManager_ptr CORBA_DomainManager::_narrow ( CORBA::Object_ptr obj, CORBA::Environment &ACE_TRY_ENV ) { if (CORBA::is_nil (obj)) return CORBA_DomainManager::_nil (); - if (! obj->_is_local ()) + if (! obj->_is_local ()) { CORBA::Boolean is_a = obj->_is_a ("IDL:CORBA/DomainManager:1.0", ACE_TRY_ENV); ACE_CHECK_RETURN (CORBA_DomainManager::_nil ()); if (is_a == 0) - return CORBA_DomainManager::_nil (); + return CORBA_DomainManager::_nil (); } - return CORBA_DomainManager::_unchecked_narrow (obj, ACE_TRY_ENV); + return CORBA_DomainManager::_unchecked_narrow (obj, ACE_TRY_ENV); } -CORBA_DomainManager_ptr CORBA_DomainManager::_unchecked_narrow ( +CORBA_DomainManager_ptr CORBA_DomainManager::_unchecked_narrow ( CORBA::Object_ptr obj, CORBA::Environment & ) { if (CORBA::is_nil (obj)) return CORBA_DomainManager::_nil (); - if (! obj->_is_local ()) + if (! obj->_is_local ()) { - TAO_Stub* stub = obj->_stubobj (); + TAO_Stub* stub = obj->_stubobj (); if (stub) - stub->_incr_refcnt (); - CORBA_DomainManager_ptr default_proxy = CORBA_DomainManager::_nil (); + stub->_incr_refcnt (); + CORBA_DomainManager_ptr default_proxy = CORBA_DomainManager::_nil (); if (obj->_is_collocated () && _TAO_collocation_CORBA_DomainManager_Stub_Factory_function_pointer != 0) - { - default_proxy = _TAO_collocation_CORBA_DomainManager_Stub_Factory_function_pointer (obj); - } - if (CORBA::is_nil (default_proxy)) - ACE_NEW_RETURN (default_proxy, ::CORBA_DomainManager (stub), CORBA_DomainManager::_nil ()); + { + default_proxy = _TAO_collocation_CORBA_DomainManager_Stub_Factory_function_pointer (obj); + } + if (CORBA::is_nil (default_proxy)) + ACE_NEW_RETURN (default_proxy, ::CORBA_DomainManager (stub), CORBA_DomainManager::_nil ()); return default_proxy; } else return ACE_reinterpret_cast - ( - CORBA_DomainManager_ptr, - obj->_tao_QueryInterface - ( - ACE_reinterpret_cast - ( - ptr_arith_t, - &CORBA_DomainManager::_narrow - ) - ) - ); + ( + CORBA_DomainManager_ptr, + obj->_tao_QueryInterface + ( + ACE_reinterpret_cast + ( + ptr_arith_t, + &CORBA_DomainManager::_narrow + ) + ) + ); } CORBA_DomainManager_ptr -CORBA_DomainManager::_duplicate (CORBA_DomainManager_ptr obj) +CORBA_DomainManager::_duplicate (CORBA_DomainManager_ptr obj) { if (!CORBA::is_nil (obj)) obj->_add_ref (); @@ -106,7 +106,7 @@ CORBA::Policy_ptr CORBA_DomainManager::get_domain_policy ( )) { - CORBA::Policy_ptr _tao_retval = CORBA::Policy::_nil (); + CORBA::Policy_ptr _tao_retval = CORBA::Policy::_nil (); CORBA::Policy_var _tao_safe_retval (_tao_retval); @@ -119,78 +119,79 @@ CORBA::Policy_ptr CORBA_DomainManager::get_domain_policy ( istub, "get_domain_policy", 17, + 1, istub->orb_core () ); #if (TAO_HAS_INTERCEPTORS == 1) TAO_ClientRequestInterceptor_Adapter - _tao_vfr (istub->orb_core ()->client_request_interceptors ()); + _tao_vfr (istub->orb_core ()->client_request_interceptors ()); CORBA_DomainManager::TAO_ClientRequest_Info_CORBA_DomainManager_get_domain_policy ri ("get_domain_policy", - _tao_call.service_info (), - this, - policy_type); + _tao_call.service_info (), + this, + policy_type); ACE_TRY { #endif /* TAO_HAS_INTERCEPTORS */ - for (;;) + for (;;) { _tao_call.start (ACE_TRY_ENV); TAO_INTERCEPTOR_CHECK_RETURN (0); TAO_INTERCEPTOR ( - ri.request_id (_tao_call.request_id ()); - _tao_vfr.send_request ( - &ri, - ACE_TRY_ENV - ) - ); + ri.request_id (_tao_call.request_id ()); + _tao_vfr.send_request ( + &ri, + ACE_TRY_ENV + ) + ); TAO_INTERCEPTOR_CHECK_RETURN (0); - CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG; + CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG; _tao_call.prepare_header ( - ACE_static_cast (CORBA::Octet, _tao_response_flag), ACE_TRY_ENV - ); + ACE_static_cast (CORBA::Octet, _tao_response_flag), ACE_TRY_ENV + ); TAO_INTERCEPTOR_CHECK_RETURN (0); - TAO_OutputCDR &_tao_out = _tao_call.out_stream (); + TAO_OutputCDR &_tao_out = _tao_call.out_stream (); if (!( - (_tao_out << policy_type) - )) + (_tao_out << policy_type) + )) TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0); int _invoke_status = - _tao_call.invoke (0, 0, ACE_TRY_ENV); - TAO_INTERCEPTOR_CHECK_RETURN (0); + _tao_call.invoke (0, 0, ACE_TRY_ENV); + TAO_INTERCEPTOR_CHECK_RETURN (0); if (_invoke_status == TAO_INVOKE_RESTART) - continue; + continue; if (_invoke_status != TAO_INVOKE_OK) { - TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0); + TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0); } TAO_InputCDR &_tao_in = _tao_call.inp_stream (); if (!( - (_tao_in >> _tao_safe_retval.inout ()) - )) + (_tao_in >> _tao_safe_retval.inout ()) + )) TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0); TAO_INTERCEPTOR ( - CORBA::Policy_ptr _tao_retval_info = _tao_safe_retval._retn (); + CORBA::Policy_ptr _tao_retval_info = _tao_safe_retval._retn (); - ri.result (_tao_retval_info); - _tao_safe_retval = _tao_retval_info; + ri.result (_tao_retval_info); + _tao_safe_retval = _tao_retval_info; ); TAO_INTERCEPTOR ( - _tao_vfr.receive_reply ( - &ri, - ACE_TRY_ENV - ) + _tao_vfr.receive_reply ( + &ri, + ACE_TRY_ENV + ) ); TAO_INTERCEPTOR_CHECK_RETURN (0); break; @@ -203,8 +204,8 @@ ACE_CATCHANY { ri.exception (&ACE_ANY_EXCEPTION); _tao_vfr.receive_exception ( - &ri, - ACE_TRY_ENV + &ri, + ACE_TRY_ENV ); ACE_RE_THROW; } @@ -214,7 +215,7 @@ ACE_CHECK_RETURN (0); return _tao_safe_retval._retn (); } -CORBA::Boolean CORBA_DomainManager::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV) +CORBA::Boolean CORBA_DomainManager::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV) { if ( (!ACE_OS::strcmp ((char *)value, "IDL:CORBA/DomainManager:1.0")) || @@ -230,12 +231,12 @@ void *CORBA_DomainManager::_tao_QueryInterface (ptr_arith_t type) if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA_DomainManager::_narrow)) - retv = ACE_reinterpret_cast (void*, this); - else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow)) - retv = ACE_reinterpret_cast ( - void *, - ACE_static_cast (CORBA::Object_ptr, this) - ); + retv = ACE_reinterpret_cast (void*, this); + else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow)) + retv = ACE_reinterpret_cast ( + void *, + ACE_static_cast (CORBA::Object_ptr, this) + ); if (retv) this->_add_ref (); @@ -250,15 +251,15 @@ const char* CORBA_DomainManager::_interface_repository_id (void) const #if (TAO_HAS_INTERCEPTORS == 1) -CORBA_DomainManager::TAO_ClientRequest_Info_CORBA_DomainManager_get_domain_policy::TAO_ClientRequest_Info_CORBA_DomainManager_get_domain_policy ( +CORBA_DomainManager::TAO_ClientRequest_Info_CORBA_DomainManager_get_domain_policy::TAO_ClientRequest_Info_CORBA_DomainManager_get_domain_policy ( const char *_tao_operation, IOP::ServiceContextList &_tao_service_context_list, CORBA::Object *_tao_target, CORBA::PolicyType &policy_type) : TAO_ClientRequestInfo ( - _tao_operation, - _tao_service_context_list, - _tao_target + _tao_operation, + _tao_service_context_list, + _tao_target ), policy_type_ (policy_type) {} @@ -268,8 +269,8 @@ CORBA_DomainManager::TAO_ClientRequest_Info_CORBA_DomainManager_get_domain_polic ACE_THROW_SPEC ((CORBA::SystemException)) { // Generate the arg list on demand - CORBA::ULong length = 0; - length = this->parameter_list_.length (); + CORBA::ULong length = 0; + length = this->parameter_list_.length (); this->parameter_list_.length (length + 1); this->parameter_list_[length].argument <<= this->policy_type_; @@ -296,15 +297,15 @@ CORBA_DomainManager::TAO_ClientRequest_Info_CORBA_DomainManager_get_domain_polic ACE_THROW_SPEC ((CORBA::SystemException)) { // Generate the result on demand : - this->result_val_ <<= this->result_; + this->result_val_ <<= this->result_; return &this->result_val_; } void CORBA_DomainManager::TAO_ClientRequest_Info_CORBA_DomainManager_get_domain_policy::result (CORBA::Policy_ptr result) { - // update the result - this->result_ = result; + // update the result + this->result_ = result; } #endif /* TAO_HAS_INTERCEPTORS */ @@ -321,7 +322,7 @@ CORBA_ConstructionPolicy::~CORBA_ConstructionPolicy (void) void CORBA_ConstructionPolicy::_tao_any_destructor (void *x) { - CORBA_ConstructionPolicy *tmp = ACE_static_cast (CORBA_ConstructionPolicy*,x); + CORBA_ConstructionPolicy *tmp = ACE_static_cast (CORBA_ConstructionPolicy*,x); CORBA::release (tmp); } @@ -332,12 +333,12 @@ CORBA_ConstructionPolicy_ptr CORBA_ConstructionPolicy::_narrow ( { if (CORBA::is_nil (obj)) return CORBA_ConstructionPolicy::_nil (); - if (! obj->_is_local ()) + if (! obj->_is_local ()) { CORBA::Boolean is_a = obj->_is_a ("IDL:CORBA/ConstructionPolicy:1.0", ACE_TRY_ENV); ACE_CHECK_RETURN (CORBA_ConstructionPolicy::_nil ()); if (is_a == 0) - return CORBA_ConstructionPolicy::_nil (); + return CORBA_ConstructionPolicy::_nil (); } return CORBA_ConstructionPolicy::_unchecked_narrow (obj, ACE_TRY_ENV); } @@ -349,35 +350,35 @@ CORBA_ConstructionPolicy_ptr CORBA_ConstructionPolicy::_unchecked_narrow ( { if (CORBA::is_nil (obj)) return CORBA_ConstructionPolicy::_nil (); - if (! obj->_is_local ()) + if (! obj->_is_local ()) { - TAO_Stub* stub = obj->_stubobj (); + TAO_Stub* stub = obj->_stubobj (); if (stub) - stub->_incr_refcnt (); + stub->_incr_refcnt (); CORBA_ConstructionPolicy_ptr default_proxy = CORBA_ConstructionPolicy::_nil (); if (obj->_is_collocated () && _TAO_collocation_CORBA_ConstructionPolicy_Stub_Factory_function_pointer != 0) - { - default_proxy = _TAO_collocation_CORBA_ConstructionPolicy_Stub_Factory_function_pointer (obj); - } - if (CORBA::is_nil (default_proxy)) - ACE_NEW_RETURN (default_proxy, ::CORBA_ConstructionPolicy (stub), CORBA_ConstructionPolicy::_nil ()); + { + default_proxy = _TAO_collocation_CORBA_ConstructionPolicy_Stub_Factory_function_pointer (obj); + } + if (CORBA::is_nil (default_proxy)) + ACE_NEW_RETURN (default_proxy, ::CORBA_ConstructionPolicy (stub), CORBA_ConstructionPolicy::_nil ()); return default_proxy; } else return ACE_reinterpret_cast - ( - CORBA_ConstructionPolicy_ptr, - obj->_tao_QueryInterface - ( - ACE_reinterpret_cast - ( - ptr_arith_t, - &CORBA_ConstructionPolicy::_narrow - ) - ) - ); + ( + CORBA_ConstructionPolicy_ptr, + obj->_tao_QueryInterface + ( + ACE_reinterpret_cast + ( + ptr_arith_t, + &CORBA_ConstructionPolicy::_narrow + ) + ) + ); } CORBA_ConstructionPolicy_ptr @@ -419,11 +420,11 @@ void CORBA_ConstructionPolicy::make_domain_manager ( #if (TAO_HAS_INTERCEPTORS == 1) - TAO_ClientRequestInterceptor_Adapter _tao_vfr ( + TAO_ClientRequestInterceptor_Adapter _tao_vfr ( istub->orb_core ()->client_request_interceptors () ); - CORBA_ConstructionPolicy::TAO_ClientRequest_Info_CORBA_ConstructionPolicy_make_domain_manager ri ( + CORBA_ConstructionPolicy::TAO_ClientRequest_Info_CORBA_ConstructionPolicy_make_domain_manager ri ( "make_domain_manager", _tao_call.service_info (), this, @@ -437,52 +438,52 @@ void CORBA_ConstructionPolicy::make_domain_manager ( #endif /* TAO_HAS_INTERCEPTORS */ for (;;) - { - _tao_call.start (ACE_TRY_ENV); - TAO_INTERCEPTOR_CHECK; - - TAO_INTERCEPTOR ( - ri.request_id (_tao_call.request_id ()); - _tao_vfr.send_request ( - &ri, - ACE_TRY_ENV - ) - ); - TAO_INTERCEPTOR_CHECK; - CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG; - - _tao_call.prepare_header ( - ACE_static_cast (CORBA::Octet, _tao_response_flag), ACE_TRY_ENV - ); - TAO_INTERCEPTOR_CHECK; - - TAO_OutputCDR &_tao_out = _tao_call.out_stream (); - if (!( - (_tao_out << object_type) && - (_tao_out << CORBA::Any::from_boolean (constr_policy)) - )) - TAO_INTERCEPTOR_THROW (CORBA::MARSHAL()); - int _invoke_status = - _tao_call.invoke (0, 0, ACE_TRY_ENV); - TAO_INTERCEPTOR_CHECK; - - if (_invoke_status == TAO_INVOKE_RESTART) - continue; - if (_invoke_status != TAO_INVOKE_OK) - { - TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN(TAO_DEFAULT_MINOR_CODE, - CORBA::COMPLETED_YES)); - } - - TAO_INTERCEPTOR ( - _tao_vfr.receive_reply ( - &ri, - ACE_TRY_ENV - ) - ); - TAO_INTERCEPTOR_CHECK; - break; - } + { + _tao_call.start (ACE_TRY_ENV); + TAO_INTERCEPTOR_CHECK; + + TAO_INTERCEPTOR ( + ri.request_id (_tao_call.request_id ()); + _tao_vfr.send_request ( + &ri, + ACE_TRY_ENV + ) + ); + TAO_INTERCEPTOR_CHECK; + CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG; + + _tao_call.prepare_header ( + ACE_static_cast (CORBA::Octet, _tao_response_flag), ACE_TRY_ENV + ); + TAO_INTERCEPTOR_CHECK; + + TAO_OutputCDR &_tao_out = _tao_call.out_stream (); + if (!( + (_tao_out << object_type) && + (_tao_out << CORBA::Any::from_boolean (constr_policy)) + )) + TAO_INTERCEPTOR_THROW (CORBA::MARSHAL()); + int _invoke_status = + _tao_call.invoke (0, 0, ACE_TRY_ENV); + TAO_INTERCEPTOR_CHECK; + + if (_invoke_status == TAO_INVOKE_RESTART) + continue; + if (_invoke_status != TAO_INVOKE_OK) + { + TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN(TAO_DEFAULT_MINOR_CODE, + CORBA::COMPLETED_YES)); + } + + TAO_INTERCEPTOR ( + _tao_vfr.receive_reply ( + &ri, + ACE_TRY_ENV + ) + ); + TAO_INTERCEPTOR_CHECK; + break; + } #if (TAO_HAS_INTERCEPTORS == 1) @@ -491,9 +492,9 @@ void CORBA_ConstructionPolicy::make_domain_manager ( { ri.exception (&ACE_ANY_EXCEPTION); _tao_vfr.receive_exception ( - &ri, - ACE_TRY_ENV - ); + &ri, + ACE_TRY_ENV + ); ACE_RE_THROW; } ACE_ENDTRY; @@ -521,21 +522,21 @@ void *CORBA_ConstructionPolicy::_tao_QueryInterface (ptr_arith_t type) if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA_ConstructionPolicy::_narrow)) - retv = ACE_reinterpret_cast (void*, this); - else if (type == ACE_reinterpret_cast + retv = ACE_reinterpret_cast (void*, this); + else if (type == ACE_reinterpret_cast (ptr_arith_t, &::CORBA::Policy::_narrow)) retv = ACE_reinterpret_cast ( - void *, - ACE_static_cast - ( - CORBA::Policy_ptr, - this - ) + void *, + ACE_static_cast + ( + CORBA::Policy_ptr, + this + ) ); - else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow)) - retv = ACE_reinterpret_cast (void *, + else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow)) + retv = ACE_reinterpret_cast (void *, ACE_static_cast (CORBA::Object_ptr, this)); if (retv) @@ -549,7 +550,7 @@ const char* CORBA_ConstructionPolicy::_interface_repository_id (void) const } -#if (TAO_HAS_INTERCEPTORS == 1) && (TAO_HAS_INTERFACE_REPOSITORY == 1) +#if (TAO_HAS_INTERCEPTORS == 1) && (TAO_HAS_INTERFACE_REPOSITORY == 1) CORBA_ConstructionPolicy::TAO_ClientRequest_Info_CORBA_ConstructionPolicy_make_domain_manager::TAO_ClientRequest_Info_CORBA_ConstructionPolicy_make_domain_manager ( const char *_tao_operation, @@ -560,9 +561,9 @@ CORBA_ConstructionPolicy::TAO_ClientRequest_Info_CORBA_ConstructionPolicy_make_d CORBA::Environment & ) : TAO_ClientRequestInfo ( - _tao_operation, - _tao_service_context_list, - _tao_target + _tao_operation, + _tao_service_context_list, + _tao_target ), object_type_ (object_type), constr_policy_ (constr_policy) @@ -573,13 +574,13 @@ CORBA_ConstructionPolicy::TAO_ClientRequest_Info_CORBA_ConstructionPolicy_make_d ACE_THROW_SPEC ((CORBA::SystemException)) { // Generate the arg list on demand - CORBA::ULong length = 0; - length = this->parameter_list_.length (); + CORBA::ULong length = 0; + length = this->parameter_list_.length (); this->parameter_list_.length (length + 1); this->parameter_list_[length].argument <<= this->object_type_; this->parameter_list_[length].mode = Dynamic::PARAM_IN; - length = this->parameter_list_.length (); + length = this->parameter_list_.length (); this->parameter_list_.length (length + 1); this->parameter_list_[length].argument <<= CORBA::Any::from_boolean (this->constr_policy_ ); this->parameter_list_[length].mode = Dynamic::PARAM_IN; @@ -613,55 +614,55 @@ CORBA_ConstructionPolicy::TAO_ClientRequest_Info_CORBA_ConstructionPolicy_make_d #endif /* TAO_HAS_INTERCEPTORS && TAO_HAS_INTERFACE_REPOSITORY */ -CORBA_ConstructionPolicy_ptr (*_TAO_collocation_CORBA_ConstructionPolicy_Stub_Factory_function_pointer) ( +CORBA_ConstructionPolicy_ptr (*_TAO_collocation_CORBA_ConstructionPolicy_Stub_Factory_function_pointer) ( CORBA::Object_ptr obj ) = 0; -void operator<<= (CORBA::Any &_tao_any, CORBA_ConstructionPolicy_ptr _tao_elem) +void operator<<= (CORBA::Any &_tao_any, CORBA_ConstructionPolicy_ptr _tao_elem) { - TAO_OutputCDR stream; - if (stream << _tao_elem) + TAO_OutputCDR stream; + if (stream << _tao_elem) { _tao_any._tao_replace ( - CORBA::_tc_ConstructionPolicy, - TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - CORBA_ConstructionPolicy::_duplicate (_tao_elem), - CORBA_ConstructionPolicy::_tao_any_destructor - ); + CORBA::_tc_ConstructionPolicy, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + CORBA_ConstructionPolicy::_duplicate (_tao_elem), + CORBA_ConstructionPolicy::_tao_any_destructor + ); } } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_ConstructionPolicy_ptr &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_ConstructionPolicy_ptr &_tao_elem) { ACE_TRY_NEW_ENV { - _tao_elem = CORBA_ConstructionPolicy::_nil (); + _tao_elem = CORBA_ConstructionPolicy::_nil (); CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (CORBA::_tc_ConstructionPolicy, ACE_TRY_ENV)) // not equal - { - return 0; - } + { + return 0; + } ACE_TRY_CHECK; TAO_InputCDR stream ( - _tao_any._tao_get_cdr (), - _tao_any._tao_byte_order () - ); + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); if (stream >> _tao_elem) { - ((CORBA::Any *)&_tao_any)->_tao_replace ( - CORBA::_tc_ConstructionPolicy, - 1, - _tao_elem, - CORBA_ConstructionPolicy::_tao_any_destructor - ); - return 1; + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_ConstructionPolicy, + 1, + _tao_elem, + CORBA_ConstructionPolicy::_tao_any_destructor + ); + return 1; } } ACE_CATCHANY { - _tao_elem = CORBA_ConstructionPolicy::_nil (); + _tao_elem = CORBA_ConstructionPolicy::_nil (); return 0; } ACE_ENDTRY; @@ -676,34 +677,34 @@ template class TAO_Object_Manager<CORBA_ConstructionPolicy,CORBA_ConstructionPol # pragma instantiate TAO_Object_Manager<CORBA_ConstructionPolicy,CORBA_ConstructionPolicy_var> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ -#endif /* TAO_HAS_MINIMUM_CORBA */ +#endif /* TAO_HAS_MINIMUM_CORBA */ #if !defined (TAO_USE_SEQUENCE_TEMPLATES) #if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_DOMAINMANAGERLIST_CS_) -#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_DOMAINMANAGERLIST_CS_ +#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_DOMAINMANAGERLIST_CS_ -// The Base_Sequence functions, please see tao/Sequence.h +// The Base_Sequence functions, please see tao/Sequence.h void _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::_allocate_buffer (CORBA::ULong length) { CORBA_DomainManager **tmp = 0; - tmp = _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::allocbuf (length); + tmp = _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::allocbuf (length); if (this->buffer_ != 0) { - CORBA_DomainManager **old = ACE_reinterpret_cast (CORBA_DomainManager**, this->buffer_); - for (CORBA::ULong i = 0; i < this->length_; ++i) - if (!this->release_) - tmp[i] = CORBA_DomainManager::_duplicate (old[i]); - else - tmp[i] = old[i]; + CORBA_DomainManager **old = ACE_reinterpret_cast (CORBA_DomainManager**, this->buffer_); + for (CORBA::ULong i = 0; i < this->length_; ++i) + if (!this->release_) + tmp[i] = CORBA_DomainManager::_duplicate (old[i]); + else + tmp[i] = old[i]; if (this->release_) - delete[] old; + delete[] old; } - this->buffer_ = tmp; + this->buffer_ = tmp; } void @@ -712,16 +713,16 @@ _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::_deallocate_buffer (void if (this->buffer_ == 0 || this->release_ == 0) return; CORBA_DomainManager **tmp = ACE_reinterpret_cast (CORBA_DomainManager**, this->buffer_); - for (CORBA::ULong i = 0; i < this->length_; ++i) + for (CORBA::ULong i = 0; i < this->length_; ++i) { CORBA::release (tmp[i]); tmp[i] = CORBA_DomainManager::_nil (); } _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::freebuf (tmp); - this->buffer_ = 0; + this->buffer_ = 0; } -_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::~_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList (void) +_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::~_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList (void) { this->_deallocate_buffer (); } @@ -731,7 +732,7 @@ _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::_shrink_buffer (CORBA::U { CORBA_DomainManager **tmp = ACE_reinterpret_cast (CORBA_DomainManager**, this->buffer_); - for (CORBA::ULong i = nl; i < ol; ++i) + for (CORBA::ULong i = nl; i < ol; ++i) { CORBA::release (tmp[i]); tmp[i] = CORBA_DomainManager::_nil (); @@ -750,7 +751,7 @@ _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::_downcast ( } CORBA_Object* -_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::_upcast (void *src) const +_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::_upcast (void *src) const { CORBA_DomainManager **tmp = ACE_static_cast (CORBA_DomainManager**, src); return *tmp; @@ -762,7 +763,7 @@ _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::_upcast (void *src) cons #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ #if !defined (_CORBA_DOMAINMANAGERLIST_CS_) -#define _CORBA_DOMAINMANAGERLIST_CS_ +#define _CORBA_DOMAINMANAGERLIST_CS_ // ************************************************************* // CORBA_DomainManagerList @@ -771,7 +772,7 @@ _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList::_upcast (void *src) cons CORBA_DomainManagerList::CORBA_DomainManagerList (void) {} -CORBA_DomainManagerList::CORBA_DomainManagerList (CORBA::ULong max) // uses max size +CORBA_DomainManagerList::CORBA_DomainManagerList (CORBA::ULong max) // uses max size : #if !defined (TAO_USE_SEQUENCE_TEMPLATES) _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList @@ -782,9 +783,9 @@ CORBA_DomainManagerList::CORBA_DomainManagerList (CORBA::ULong max) // uses max {} CORBA_DomainManagerList::CORBA_DomainManagerList ( - CORBA::ULong max, - CORBA::ULong length, - CORBA_DomainManager_ptr *buffer, + CORBA::ULong max, + CORBA::ULong length, + CORBA_DomainManager_ptr *buffer, CORBA::Boolean release ) : @@ -793,7 +794,7 @@ CORBA_DomainManagerList::CORBA_DomainManagerList ( #else /* TAO_USE_SEQUENCE_TEMPLATES */ TAO_Unbounded_Object_Sequence<CORBA_DomainManager,CORBA_DomainManager_var> #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ - (max, length, buffer, release) + (max, length, buffer, release) {} CORBA_DomainManagerList::CORBA_DomainManagerList ( @@ -811,7 +812,7 @@ CORBA_DomainManagerList::CORBA_DomainManagerList ( CORBA_DomainManagerList::~CORBA_DomainManagerList (void) // dtor {} -void CORBA_DomainManagerList::_tao_any_destructor (void *x) +void CORBA_DomainManagerList::_tao_any_destructor (void *x) { CORBA_DomainManagerList *tmp = ACE_static_cast (CORBA_DomainManagerList*,x); delete tmp; @@ -819,59 +820,59 @@ void CORBA_DomainManagerList::_tao_any_destructor (void *x) #endif /* end #if !defined */ -CORBA_DomainManager_ptr (*_TAO_collocation_CORBA_DomainManager_Stub_Factory_function_pointer) ( +CORBA_DomainManager_ptr (*_TAO_collocation_CORBA_DomainManager_Stub_Factory_function_pointer) ( CORBA::Object_ptr obj ) = 0; -void operator<<= (CORBA::Any &_tao_any, CORBA_DomainManager_ptr _tao_elem) +void operator<<= (CORBA::Any &_tao_any, CORBA_DomainManager_ptr _tao_elem) { - TAO_OutputCDR stream; - if (stream << _tao_elem) + TAO_OutputCDR stream; + if (stream << _tao_elem) { _tao_any._tao_replace ( - CORBA::_tc_DomainManager, - TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - CORBA_DomainManager::_duplicate (_tao_elem), - CORBA_DomainManager::_tao_any_destructor - ); + CORBA::_tc_DomainManager, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + CORBA_DomainManager::_duplicate (_tao_elem), + CORBA_DomainManager::_tao_any_destructor + ); } } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_DomainManager_ptr &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_DomainManager_ptr &_tao_elem) { ACE_TRY_NEW_ENV { - _tao_elem = CORBA_DomainManager::_nil (); + _tao_elem = CORBA_DomainManager::_nil (); CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equivalent (CORBA::_tc_DomainManager, ACE_TRY_ENV)) // not equal - { - return 0; - } + if (!type->equivalent (CORBA::_tc_DomainManager, ACE_TRY_ENV)) // not equal + { + return 0; + } ACE_TRY_CHECK; TAO_InputCDR stream ( - _tao_any._tao_get_cdr (), - _tao_any._tao_byte_order () - ); + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); if (stream >> _tao_elem) { - ((CORBA::Any *)&_tao_any)->_tao_replace ( - CORBA::_tc_DomainManager, - 1, - _tao_elem, - CORBA_DomainManager::_tao_any_destructor - ); - return 1; + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_DomainManager, + 1, + _tao_elem, + CORBA_DomainManager::_tao_any_destructor + ); + return 1; } } ACE_CATCHANY { - _tao_elem = CORBA_DomainManager::_nil (); + _tao_elem = CORBA_DomainManager::_nil (); return 0; } ACE_ENDTRY; - _tao_elem = CORBA_DomainManager::_nil (); + _tao_elem = CORBA_DomainManager::_nil (); return 0; } @@ -887,22 +888,22 @@ void operator<<= ( const CORBA_DomainManagerList &_tao_elem ) // copying { - TAO_OutputCDR stream; - if (stream << _tao_elem) + TAO_OutputCDR stream; + if (stream << _tao_elem) { _tao_any._tao_replace ( - CORBA::_tc_DomainManagerList, - TAO_ENCAP_BYTE_ORDER, - stream.begin () - ); + CORBA::_tc_DomainManagerList, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); } } -void operator<<= (CORBA::Any &_tao_any, CORBA_DomainManagerList *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA_DomainManagerList *_tao_elem) // non copying { - TAO_OutputCDR stream; + TAO_OutputCDR stream; stream << *_tao_elem; - _tao_any._tao_replace ( + _tao_any._tao_replace ( CORBA::_tc_DomainManagerList, TAO_ENCAP_BYTE_ORDER, stream.begin (), @@ -912,7 +913,7 @@ void operator<<= (CORBA::Any &_tao_any, CORBA_DomainManagerList *_tao_elem) // n ); } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_DomainManagerList *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_DomainManagerList *&_tao_elem) { return _tao_any >>= ACE_const_cast( const CORBA_DomainManagerList*&, @@ -920,48 +921,48 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_DomainManagerList ); } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_DomainManagerList *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_DomainManagerList *&_tao_elem) { _tao_elem = 0; ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equivalent (CORBA::_tc_DomainManagerList, ACE_TRY_ENV)) // not equal - { - return 0; - } + if (!type->equivalent (CORBA::_tc_DomainManagerList, ACE_TRY_ENV)) // not equal + { + return 0; + } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = ACE_static_cast( - const CORBA_DomainManagerList*, - _tao_any.value () - ); - return 1; + _tao_elem = ACE_static_cast( + const CORBA_DomainManagerList*, + _tao_any.value () + ); + return 1; } else { - CORBA_DomainManagerList *tmp; - ACE_NEW_RETURN (tmp, CORBA_DomainManagerList, 0); - TAO_InputCDR stream ( - _tao_any._tao_get_cdr (), - _tao_any._tao_byte_order () - ); - if (stream >> *tmp) - { - ((CORBA::Any *)&_tao_any)->_tao_replace ( - CORBA::_tc_DomainManagerList, - 1, - ACE_static_cast (void *, tmp), - CORBA_DomainManagerList::_tao_any_destructor - ); - _tao_elem = tmp; - return 1; - } - else - { - delete tmp; - } + CORBA_DomainManagerList *tmp; + ACE_NEW_RETURN (tmp, CORBA_DomainManagerList, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *tmp) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_DomainManagerList, + 1, + ACE_static_cast (void *, tmp), + CORBA_DomainManagerList::_tao_any_destructor + ); + _tao_elem = tmp; + return 1; + } + else + { + delete tmp; + } } } ACE_CATCHANY @@ -978,11 +979,11 @@ CORBA::Boolean operator<< ( { if (strm << _tao_sequence.length ()) { - // encode all elements + // encode all elements CORBA::Boolean _tao_marshal_flag = 1; - for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++) + for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++) { - _tao_marshal_flag = (strm << _tao_sequence[i].in ()); + _tao_marshal_flag = (strm << _tao_sequence[i].in ()); } return _tao_marshal_flag; } @@ -997,16 +998,16 @@ CORBA::Boolean operator>> ( CORBA::ULong _tao_seq_len; if (strm >> _tao_seq_len) { - // set the length of the sequence + // set the length of the sequence _tao_sequence.length (_tao_seq_len); - // If length is 0 we return true. + // If length is 0 we return true. if (0 >= _tao_seq_len) - return 1; + return 1; // retrieve all the elements CORBA::Boolean _tao_marshal_flag = 1; - for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++) + for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++) { - _tao_marshal_flag = (strm >> _tao_sequence[i].out ()); + _tao_marshal_flag = (strm >> _tao_sequence[i].out ()); } return _tao_marshal_flag; } diff --git a/TAO/tao/DynamicInterface/DII_Invocation.h b/TAO/tao/DynamicInterface/DII_Invocation.h index f2d64e79199..6ec9d811c54 100644 --- a/TAO/tao/DynamicInterface/DII_Invocation.h +++ b/TAO/tao/DynamicInterface/DII_Invocation.h @@ -40,13 +40,14 @@ class TAO_GIOP_DII_Invocation : public TAO_GIOP_Twoway_Invocation // = DESCRIPTION // This class replaces just one method - invoke - of its base // class with one of a slightly different signature. The class - // is not exported because it is only instantiated by + // is not exported because it is only instantiated by // CORBA::Request in this library. // public: TAO_GIOP_DII_Invocation (TAO_Stub *data, const char *operation, CORBA::ULong opname_len, + CORBA::Boolean argument_flag, TAO_ORB_Core *orb_core); // Constructor. @@ -72,6 +73,7 @@ class TAO_DynamicInterface_Export TAO_GIOP_DII_Deferred_Invocation public: TAO_GIOP_DII_Deferred_Invocation (TAO_Stub *data, TAO_ORB_Core* orb_core, + CORBA::Boolean argument_flag, const CORBA::Request_ptr req); // Constructor. diff --git a/TAO/tao/DynamicInterface/DII_Invocation.inl b/TAO/tao/DynamicInterface/DII_Invocation.inl index 36df85f8e81..eb93cac56c0 100644 --- a/TAO/tao/DynamicInterface/DII_Invocation.inl +++ b/TAO/tao/DynamicInterface/DII_Invocation.inl @@ -7,10 +7,12 @@ ACE_INLINE TAO_GIOP_DII_Invocation::TAO_GIOP_DII_Invocation (TAO_Stub *data, const char *operation, CORBA::ULong opname_len, + CORBA::Boolean argument_flag, TAO_ORB_Core *orb_core) : TAO_GIOP_Twoway_Invocation (data, operation, opname_len, + argument_flag, orb_core) { } @@ -19,11 +21,13 @@ ACE_INLINE TAO_GIOP_DII_Deferred_Invocation::TAO_GIOP_DII_Deferred_Invocation ( TAO_Stub *stub, TAO_ORB_Core *orb_core, + CORBA::Boolean argument_flag, const CORBA::Request_ptr req ) : TAO_GIOP_Invocation (stub, req->operation (), ACE_OS::strlen (req->operation ()), + argument_flag, orb_core) { // New reply dispatcher on the heap, because diff --git a/TAO/tao/DynamicInterface/Request.cpp b/TAO/tao/DynamicInterface/Request.cpp index bb4090eee6a..ec1d3960a9b 100644 --- a/TAO/tao/DynamicInterface/Request.cpp +++ b/TAO/tao/DynamicInterface/Request.cpp @@ -105,10 +105,10 @@ CORBA_Request::CORBA_Request (CORBA::Object_ptr obj, this->exceptions_ = tmp; - ACE_NEW (this->args_, + ACE_NEW (this->args_, CORBA::NVList); - ACE_NEW (this->result_, + ACE_NEW (this->result_, CORBA::NamedValue); } @@ -133,9 +133,12 @@ CORBA_Request::~CORBA_Request (void) void CORBA_Request::invoke (CORBA::Environment &ACE_TRY_ENV) { + CORBA::Boolean argument_flag = this->args_->count () ? 1 : 0; + TAO_GIOP_DII_Invocation call (this->target_->_stubobj (), this->opname_, ACE_OS::strlen (this->opname_), + argument_flag, this->orb_->orb_core ()); // Loop as needed for forwarding. @@ -146,7 +149,7 @@ CORBA_Request::invoke (CORBA::Environment &ACE_TRY_ENV) CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; - call.prepare_header (ACE_static_cast (CORBA::Octet, + call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); ACE_CHECK; @@ -158,7 +161,7 @@ CORBA_Request::invoke (CORBA::Environment &ACE_TRY_ENV) ACE_CHECK; // Make the call ... blocking for the response. - int status = call.invoke (this->exceptions_.in (), + int status = call.invoke (this->exceptions_.in (), ACE_TRY_ENV); ACE_CHECK; @@ -209,9 +212,11 @@ CORBA_Request::invoke (CORBA::Environment &ACE_TRY_ENV) void CORBA_Request::send_oneway (CORBA::Environment &ACE_TRY_ENV) { + CORBA::Boolean argument_flag = this->args_->count () ? 1 : 0; TAO_GIOP_Oneway_Invocation call (this->target_->_stubobj (), this->opname_, ACE_OS::strlen (this->opname_), + argument_flag, this->orb_->orb_core ()); // Loop as needed for forwarding. @@ -273,8 +278,10 @@ CORBA_Request::send_deferred (CORBA::Environment &ACE_TRY_ENV) this->response_received_ = 0; } + CORBA::Boolean argument_flag = this->args_->count () ? 1: 0; TAO_GIOP_DII_Deferred_Invocation call (this->target_->_stubobj (), this->orb_->orb_core (), + argument_flag, this); // Loop as needed for forwarding. diff --git a/TAO/tao/GIOP_Message_Accept_State.cpp b/TAO/tao/GIOP_Message_Accept_State.cpp index 0dc42b409af..e000ee06bbe 100644 --- a/TAO/tao/GIOP_Message_Accept_State.cpp +++ b/TAO/tao/GIOP_Message_Accept_State.cpp @@ -659,11 +659,15 @@ TAO_GIOP_Message_Accept_State_12::write_reply_header ( } #endif /*TAO_HAS_MINIMUM_CORBA */ - if (output.align_write_ptr (TAO_GIOP_MESSAGE_ALIGN_PTR) == -1) + if (reply.argument_flag_) { - return 0; + // If we have some data to be marshalled, then we align the + // pointer to a 8 byte boundary. Else, we just leave it throu + if (output.align_write_ptr (TAO_GIOP_MESSAGE_ALIGN_PTR) == -1) + { + return 0; + } } - return 1; } @@ -679,9 +683,14 @@ TAO_GIOP_Message_Accept_State_12::write_locate_reply_mesg ( // Make the header for the locate request output.write_ulong (status_info.status); - if (output.align_write_ptr (TAO_GIOP_MESSAGE_ALIGN_PTR) == -1) + if (status_info.status == TAO_GIOP_OBJECT_FORWARD || + status_info.status == TAO_GIOP_OBJECT_FORWARD_PERM) { - return 0; + // We have to send some data, so align the pointer + if (output.align_write_ptr (TAO_GIOP_MESSAGE_ALIGN_PTR) == -1) + { + return 0; + } } switch (status_info.status) diff --git a/TAO/tao/GIOP_Message_Acceptors.cpp b/TAO/tao/GIOP_Message_Acceptors.cpp index dcf916038f2..21c603a412a 100644 --- a/TAO/tao/GIOP_Message_Acceptors.cpp +++ b/TAO/tao/GIOP_Message_Acceptors.cpp @@ -449,6 +449,9 @@ TAO_GIOP_Message_Acceptors::send_reply_exception ( reply_params.request_id_ = request_id; reply_params.svc_ctx_.length (0); + // We are going to send some data + reply_params.argument_flag_ = 1; + // Send back the service context we received. (RTCORBA relies on // this). reply_params.service_context_notowned (svc_info); diff --git a/TAO/tao/GIOP_Message_Connectors.cpp b/TAO/tao/GIOP_Message_Connectors.cpp index 2a0ceb36a9c..009eda30db7 100644 --- a/TAO/tao/GIOP_Message_Connectors.cpp +++ b/TAO/tao/GIOP_Message_Connectors.cpp @@ -16,112 +16,112 @@ # include "tao/GIOP_Message_Connectors.i" #endif /* __ACE_INLINE__ */ -ACE_RCSID(tao, GIOP_Message_Connectors, "$Id$") +ACE_RCSID(tao, GIOP_Message_Connectors, "$Id$") int TAO_GIOP_Message_Connectors:: parse_reply (TAO_Message_State_Factory &mesg_state, - TAO_Pluggable_Reply_Params ¶ms) + TAO_Pluggable_Reply_Params ¶ms) { - // @@ Bala: See how the message state is a per-protocol thing? - // Wouldn't it be better to have each protocol define its own - // message state and just use that type directly (i.e no - // message_state base class). As far as i can see (but i may be - // wrong), only very tightly related messaging protocols and - // transport protocols can use the same message state (for - // example GIOP 1.x and GIOP Lite). Furthermore, if i'm proven - // wrong and there is common functionality among different - // pluggable messaging protocols, we can simply re-factor at that - // point. - // IMHO the right approach is to factor out common functionality - // and interfaces 'a posteriori', otherwise we will define - // ackward interfaces that will have to be changed anyway! - - // @@ Carlos: I agree. But I see a problem. Other than the transport - // classes, we store state information in our Reply despatcers, - // Transport Mux Strategy etc. I would only love to have the - // Message States local to GIOP or say some other protocol. One - // example that spoils this idea is the Mux_Strategies that we - // have. I am ready to hear anything you suggest to get around - // this. + // @@ Bala: See how the message state is a per-protocol thing? + // Wouldn't it be better to have each protocol define its own + // message state and just use that type directly (i.e no + // message_state base class). As far as i can see (but i may be + // wrong), only very tightly related messaging protocols and + // transport protocols can use the same message state (for + // example GIOP 1.x and GIOP Lite). Furthermore, if i'm proven + // wrong and there is common functionality among different + // pluggable messaging protocols, we can simply re-factor at that + // point. + // IMHO the right approach is to factor out common functionality + // and interfaces 'a posteriori', otherwise we will define + // ackward interfaces that will have to be changed anyway! + + // @@ Carlos: I agree. But I see a problem. Other than the transport + // classes, we store state information in our Reply despatcers, + // Transport Mux Strategy etc. I would only love to have the + // Message States local to GIOP or say some other protocol. One + // example that spoils this idea is the Mux_Strategies that we + // have. I am ready to hear anything you suggest to get around + // this. // Cast to the GIOP Message state - TAO_GIOP_Message_State *state = ACE_dynamic_cast (TAO_GIOP_Message_State *, - &mesg_state); + TAO_GIOP_Message_State *state = ACE_dynamic_cast (TAO_GIOP_Message_State *, + &mesg_state); // Read the request id if (!state->cdr.read_ulong (params.request_id_)) { if (TAO_debug_level > 0) - ACE_DEBUG ((LM_DEBUG, - "TAO (%P|%t|%N|%l) : TAO_GIOP_Message_1_1::parse_reply, " - "extracting request id")); + ACE_DEBUG ((LM_DEBUG, + "TAO (%P|%t|%N|%l) : TAO_GIOP_Message_1_1::parse_reply, " + "extracting request id")); return -1; } - // and the reply status type. status can be NO_EXCEPTION, + // and the reply status type. status can be NO_EXCEPTION, // SYSTEM_EXCEPTION, USER_EXCEPTION, LOCATION_FORWARD // Cannot handle LOCATION_FORWARD_PERM here - CORBA::ULong rep_stat = 0; + CORBA::ULong rep_stat = 0; if (!state->cdr.read_ulong (rep_stat)) { if (TAO_debug_level > 0) - ACE_DEBUG ((LM_DEBUG, - "TAO (%P|%t|%N|%l) : TAO_GIOP_Message_1_1::parse_reply, " - "extracting reply status\n")); + ACE_DEBUG ((LM_DEBUG, + "TAO (%P|%t|%N|%l) : TAO_GIOP_Message_1_1::parse_reply, " + "extracting reply status\n")); return -1; } - // @@ Bala: More silly translations! + // @@ Bala: More silly translations! - // @@ Carlos: Please let me know what I can do to mask them from the - // user of this method + // @@ Carlos: Please let me know what I can do to mask them from the + // user of this method - // Pass the right Pluggable interface code to the transport layer + // Pass the right Pluggable interface code to the transport layer switch (rep_stat) { // Request completed successfully case TAO_GIOP_NO_EXCEPTION: params.reply_status_ = - TAO_PLUGGABLE_MESSAGE_NO_EXCEPTION; + TAO_PLUGGABLE_MESSAGE_NO_EXCEPTION; break; // Request terminated with user exception case TAO_GIOP_USER_EXCEPTION: params.reply_status_ = - TAO_PLUGGABLE_MESSAGE_USER_EXCEPTION; + TAO_PLUGGABLE_MESSAGE_USER_EXCEPTION; break; - // Request terminated with system exception + // Request terminated with system exception case TAO_GIOP_SYSTEM_EXCEPTION: params.reply_status_ = - TAO_PLUGGABLE_MESSAGE_SYSTEM_EXCEPTION; + TAO_PLUGGABLE_MESSAGE_SYSTEM_EXCEPTION; break; // Reply is a location forward type case TAO_GIOP_LOCATION_FORWARD: params.reply_status_ = - TAO_PLUGGABLE_MESSAGE_LOCATION_FORWARD; + TAO_PLUGGABLE_MESSAGE_LOCATION_FORWARD; break; // Reply is a location forward perm type - // @@For the time being the behaviour of the - // LOCATION_FORWARD_PERM would be similar to the - // LOCATION_FORWARD as there is a controversy surrounding the + // @@For the time being the behaviour of the + // LOCATION_FORWARD_PERM would be similar to the + // LOCATION_FORWARD as there is a controversy surrounding the // usage of this in the OMG. case TAO_GIOP_LOCATION_FORWARD_PERM: params.reply_status_ = - TAO_PLUGGABLE_MESSAGE_LOCATION_FORWARD; + TAO_PLUGGABLE_MESSAGE_LOCATION_FORWARD; break; // Reply is a location forward type case TAO_GIOP_NEEDS_ADDRESSING_MODE: params.reply_status_ = - TAO_PLUGGABLE_MESSAGE_NEEDS_ADDRESSING_MODE; + TAO_PLUGGABLE_MESSAGE_NEEDS_ADDRESSING_MODE; break; default: if (TAO_debug_level > 0) - ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("(%N|%l) Unknown reply status \n"))); + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("(%N|%l) Unknown reply status \n"))); } return 0; @@ -131,32 +131,32 @@ TAO_GIOP_Message_Connectors:: int TAO_GIOP_Message_Connectors:: parse_locate_reply (TAO_GIOP_Message_State &state, - TAO_Pluggable_Reply_Params ¶ms) + TAO_Pluggable_Reply_Params ¶ms) { // Read the request id if (!state.cdr.read_ulong (params.request_id_)) { if (TAO_debug_level > 0) - ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("TAO (%P|%t|%N|%l) : TAO_GIOP_Message_1_1::parse_reply, ") - ACE_TEXT ("extracting request id"))); + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("TAO (%P|%t|%N|%l) : TAO_GIOP_Message_1_1::parse_reply, ") + ACE_TEXT ("extracting request id"))); return -1; } - // and the reply status type. status can be NO_EXCEPTION, + // and the reply status type. status can be NO_EXCEPTION, // SYSTEM_EXCEPTION, USER_EXCEPTION, LOCATION_FORWARD // Cannot handle LOCATION_FORWARD_PERM here - // Please note here that we are NOT converting to the Pluggable + // Please note here that we are NOT converting to the Pluggable // messaging layer exception as this is GIOP specific. Not many // messaging protocols have the locate_* messages. if (!state.cdr.read_ulong (params.reply_status_)) { if (TAO_debug_level > 0) - ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("TAO (%P|%t) : TAO_GIOP_Message_Connectors::parse_locate_reply, ") - ACE_TEXT ("extracting reply status\n"))); + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("TAO (%P|%t) : TAO_GIOP_Message_Connectors::parse_locate_reply, ") + ACE_TEXT ("extracting reply status\n"))); return -1; } @@ -170,7 +170,7 @@ TAO_GIOP_Message_Connectors::validate_version (TAO_GIOP_Message_State *state) { // Grab the read pointer - char *buf = state->cdr.rd_ptr (); + char *buf = state->cdr.rd_ptr (); if ((buf[TAO_GIOP_VERSION_MAJOR_OFFSET] != this->major_version ()) || (buf[TAO_GIOP_VERSION_MINOR_OFFSET] != this->minor_version ())) @@ -185,19 +185,19 @@ TAO_GIOP_Message_Connectors::validate_version (TAO_GIOP_Message_State *state) int TAO_GIOP_Message_Connectors::process_client_message (TAO_Transport * /*transport*/, - TAO_ORB_Core * /*orb_core*/, - TAO_InputCDR & /*input*/, - CORBA::Octet /*message_type*/) + TAO_ORB_Core * /*orb_core*/, + TAO_InputCDR & /*input*/, + CORBA::Octet /*message_type*/) { ACE_NOTSUP_RETURN (-1); } CORBA::Boolean -TAO_GIOP_Message_Connectors::write_reply_header (TAO_OutputCDR & /*cdr*/, - TAO_Pluggable_Reply_Params & /*params*/, - CORBA::Environment & - /*ACE_TRY_ENV*/) +TAO_GIOP_Message_Connectors::write_reply_header (TAO_OutputCDR & /*cdr*/, + TAO_Pluggable_Reply_Params & /*params*/, + CORBA::Environment & + /*ACE_TRY_ENV*/) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_NOTSUP_RETURN (0); @@ -211,56 +211,56 @@ TAO_GIOP_Message_Connectors::write_reply_header (TAO_OutputCDR & /*cdr*/, CORBA::Boolean TAO_GIOP_Message_Connector_10:: write_request_header (const TAO_Operation_Details &opdetails, - TAO_Target_Specification &spec, - TAO_OutputCDR &msg) + TAO_Target_Specification &spec, + TAO_OutputCDR &msg) { - // This is sepecific to GIOP 1.1. So put them here - msg << opdetails.service_info (); + // This is sepecific to GIOP 1.1. So put them here + msg << opdetails.service_info (); // First the request id msg << opdetails.request_id (); - const CORBA::Octet response_flags = opdetails.response_flags (); + const CORBA::Octet response_flags = opdetails.response_flags (); - // @@ (JP) Temporary hack until all of GIOP 1.2 is implemented. - if (response_flags == TAO_TWOWAY_RESPONSE_FLAG) - msg << CORBA::Any::from_octet (1); + // @@ (JP) Temporary hack until all of GIOP 1.2 is implemented. + if (response_flags == TAO_TWOWAY_RESPONSE_FLAG) + msg << CORBA::Any::from_octet (1); else - msg << CORBA::Any::from_octet (0); + msg << CORBA::Any::from_octet (0); - // In this case we cannot recognise anything other than the Object - // key as the address disposition variable. But we do a sanity check + // In this case we cannot recognise anything other than the Object + // key as the address disposition variable. But we do a sanity check // anyway. - const TAO_ObjectKey *key = spec.object_key (); + const TAO_ObjectKey *key = spec.object_key (); if (key) { - // Put in the object key + // Put in the object key msg << *key; } else { if (TAO_debug_level) - ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("(%N |%l) Unable to handle this request \n"))); + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("(%N |%l) Unable to handle this request \n"))); return 0; } msg.write_string (opdetails.opname_len (), - opdetails.opname ()); + opdetails.opname ()); // Last element of request header is the principal; no portable way - // to get it, we just pass empty principal (convention: indicates - // "anybody"). Steps upward in security include passing an - // unverified user ID, and then verifying the message (i.e. a dummy - // service context entry is set up to hold a digital signature for - // this message, then patched shortly before it's sent). + // to get it, we just pass empty principal (convention: indicates + // "anybody"). Steps upward in security include passing an + // unverified user ID, and then verifying the message (i.e. a dummy + // service context entry is set up to hold a digital signature for + // this message, then patched shortly before it's sent). /***** This has been deprecated in the 2.4 spec ******/ - //static CORBA::Principal_ptr principal = 0; - //msg << principal; + //static CORBA::Principal_ptr principal = 0; + //msg << principal; // This is now introduced in 2.4 spec - CORBA::OctetSeq req_principal (0); + CORBA::OctetSeq req_principal (0); req_principal.length (0); msg << req_principal; @@ -276,15 +276,15 @@ TAO_GIOP_Message_Connector_10:: CORBA::Boolean TAO_GIOP_Message_Connector_10:: write_locate_request_header (CORBA::ULong request_id, - TAO_Target_Specification &spec, - TAO_OutputCDR &msg) + TAO_Target_Specification &spec, + TAO_OutputCDR &msg) { msg << request_id; - // In this case we cannot recognise anything other than the Object - // key as the address disposition variable. But we do a sanity check + // In this case we cannot recognise anything other than the Object + // key as the address disposition variable. But we do a sanity check // anyway. - const TAO_ObjectKey *key = spec.object_key (); + const TAO_ObjectKey *key = spec.object_key (); if (key) { // Everything is fine @@ -293,8 +293,8 @@ TAO_GIOP_Message_Connector_10:: else { if (TAO_debug_level) - ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("(%N | %l) Unable to handle this request \n"))); + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("(%N | %l) Unable to handle this request \n"))); return 0; } @@ -305,51 +305,51 @@ TAO_GIOP_Message_Connector_10:: int TAO_GIOP_Message_Connector_10:: parse_reply (TAO_Message_State_Factory &mesg_state, - TAO_Pluggable_Reply_Params ¶ms) + TAO_Pluggable_Reply_Params ¶ms) { // Cast to the GIOP Message state - TAO_GIOP_Message_State *state = ACE_dynamic_cast (TAO_GIOP_Message_State *, - &mesg_state); + TAO_GIOP_Message_State *state = ACE_dynamic_cast (TAO_GIOP_Message_State *, + &mesg_state); switch (state->message_type) { case TAO_GIOP_REQUEST: // In GIOP 1.0 and GIOP 1.1 this is an error, ACE_ERROR_RETURN ((LM_ERROR, - ACE_TEXT ("TAO (%P|%t) TAO_GIOP_Message_Connector_10::parse_reply: ") - ACE_TEXT ("request.\n")), - -1); + ACE_TEXT ("TAO (%P|%t) TAO_GIOP_Message_Connector_10::parse_reply: ") + ACE_TEXT ("request.\n")), + -1); case TAO_GIOP_CANCELREQUEST: case TAO_GIOP_LOCATEREQUEST: // Errors case TAO_GIOP_CLOSECONNECTION: default: - ACE_ERROR_RETURN ((LM_ERROR, - ACE_TEXT ("TAO (%P|%t) %N:%l parse_reply: ") - ACE_TEXT ("wrong message.\n")), - -1); + ACE_ERROR_RETURN ((LM_ERROR, + ACE_TEXT ("TAO (%P|%t) %N:%l parse_reply: ") + ACE_TEXT ("wrong message.\n")), + -1); case TAO_GIOP_LOCATEREPLY: if (this->parse_locate_reply (*state, - params) == -1) - return -1; + params) == -1) + return -1; break; case TAO_GIOP_REPLY: if ((state->cdr >> params.svc_ctx_) == 0) - { - if (TAO_debug_level > 0) - ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("TAO (%P|%t) parse_reply, ") - ACE_TEXT ("extracting context\n"))); - return -1; - } + { + if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("TAO (%P|%t) parse_reply, ") + ACE_TEXT ("extracting context\n"))); + return -1; + } if (TAO_GIOP_Message_Connectors::parse_reply (*state, - params) == -1) - return -1; + params) == -1) + return -1; break; case TAO_GIOP_FRAGMENT: - // Never happens: why?? + // Never happens: why?? break; } @@ -357,14 +357,14 @@ TAO_GIOP_Message_Connector_10:: } CORBA::Octet -TAO_GIOP_Message_Connector_10:: major_version (void) +TAO_GIOP_Message_Connector_10:: major_version (void) { // Any harm in hardcoding?? - return (CORBA::Octet) 1; + return (CORBA::Octet) 1; } CORBA::Octet -TAO_GIOP_Message_Connector_10:: minor_version (void) +TAO_GIOP_Message_Connector_10:: minor_version (void) { // Any harm in hardcoding?? return 0; @@ -376,10 +376,10 @@ TAO_GIOP_Message_Connector_10:: minor_version (void) ////////////////////////////////////////////////////////////////// CORBA::Octet -TAO_GIOP_Message_Connector_11:: minor_version (void) +TAO_GIOP_Message_Connector_11:: minor_version (void) { // Any harm in hardcoding?? - return (CORBA::Octet) 1; + return (CORBA::Octet) 1; } /////////////////////////////////////////////////////////////////// @@ -389,64 +389,67 @@ TAO_GIOP_Message_Connector_11:: minor_version (void) CORBA::Boolean TAO_GIOP_Message_Connector_12:: write_request_header (const TAO_Operation_Details &opdetails, - TAO_Target_Specification &spec, - TAO_OutputCDR &msg) + TAO_Target_Specification &spec, + TAO_OutputCDR &msg) { // First the request id msg << opdetails.request_id (); - const CORBA::Octet response_flags = opdetails.response_flags (); + const CORBA::Octet response_flags = opdetails.response_flags (); - // Here are the Octet values for different policies - // '00000000' for SYNC_NONE - // '00000000' for SYNC_WITH_TRANSPORT - // '00000010' for SYNC_WITH_SERVER - // '00000011' for SYNC_WITH_TARGET - // '00000011' for regular two ways, but if they are invoked via a + // Here are the Octet values for different policies + // '00000000' for SYNC_NONE + // '00000000' for SYNC_WITH_TRANSPORT + // '00000010' for SYNC_WITH_SERVER + // '00000011' for SYNC_WITH_TARGET + // '00000011' for regular two ways, but if they are invoked via a // DII with INV_NO_RESPONSE flag set then we need to send '00000001' // - // We have not implemented the policy INV_NO_RESPONSE for DII. - if (response_flags == TAO_TWOWAY_RESPONSE_FLAG) - msg << CORBA::Any::from_octet (3); - // Second the response flags - // Sync scope - ignored by server if request is not oneway. + // We have not implemented the policy INV_NO_RESPONSE for DII. + if (response_flags == TAO_TWOWAY_RESPONSE_FLAG) + msg << CORBA::Any::from_octet (3); + // Second the response flags + // Sync scope - ignored by server if request is not oneway. else if (response_flags == CORBA::Octet (TAO::SYNC_NONE) || - response_flags == CORBA::Octet (TAO::SYNC_WITH_TRANSPORT) || - response_flags == CORBA::Octet (TAO::SYNC_EAGER_BUFFERING) || - response_flags == CORBA::Octet (TAO::SYNC_DELAYED_BUFFERING)) + response_flags == CORBA::Octet (TAO::SYNC_WITH_TRANSPORT) || + response_flags == CORBA::Octet (TAO::SYNC_EAGER_BUFFERING) || + response_flags == CORBA::Octet (TAO::SYNC_DELAYED_BUFFERING)) // No response required. - msg << CORBA::Any::from_octet (0); + msg << CORBA::Any::from_octet (0); else if (response_flags == CORBA::Octet (TAO::SYNC_WITH_SERVER)) - // Return before dispatching to the servant - msg << CORBA::Any::from_octet (1); + // Return before dispatching to the servant + msg << CORBA::Any::from_octet (1); else if (response_flags == CORBA::Octet (TAO::SYNC_WITH_TARGET)) - // Return after dispatching servant. - msg << CORBA::Any::from_octet (3); + // Return after dispatching servant. + msg << CORBA::Any::from_octet (3); else - // Until more flags are defined by the OMG. + // Until more flags are defined by the OMG. return 0; // The reserved field CORBA::Octet reserved[3] = {0, 0, 0}; - msg.write_octet_array (reserved, 3); + msg.write_octet_array (reserved, 3); if (this->marshall_target_spec (spec, - msg) == 0) + msg) == 0) return 0; // Write the operation name msg.write_string (opdetails.opname_len (), - opdetails.opname ()); + opdetails.opname ()); // Write the service context list - msg << opdetails.service_info (); + msg << opdetails.service_info (); - // We need to align the pointer - if (msg.align_write_ptr (TAO_GIOP_MESSAGE_ALIGN_PTR) == -1) - return 0; + // We align the pointer only if the operation has arguments. + if (opdetails.argument_flag ()) + { + if (msg.align_write_ptr (TAO_GIOP_MESSAGE_ALIGN_PTR) == -1) + return 0; + } return 1; } @@ -455,120 +458,122 @@ TAO_GIOP_Message_Connector_12:: CORBA::Boolean TAO_GIOP_Message_Connector_12:: write_locate_request_header (CORBA::ULong request_id, - TAO_Target_Specification &spec, - TAO_OutputCDR &msg) + TAO_Target_Specification &spec, + TAO_OutputCDR &msg) { // Write the request id msg << request_id; // Write the target address if (this->marshall_target_spec (spec, - msg) == 0) + msg) == 0) return 0; - // We need to align the pointer - if (msg.align_write_ptr (TAO_GIOP_MESSAGE_ALIGN_PTR) == -1) - return 0; + // I dont think we need to align the pointer to an 8 byte boundary + // here. + // We need to align the pointer + // if (msg.align_write_ptr (TAO_GIOP_MESSAGE_ALIGN_PTR) == -1) + // return 0; // Return success return 1; } CORBA::Octet -TAO_GIOP_Message_Connector_12:: major_version (void) +TAO_GIOP_Message_Connector_12:: major_version (void) { // Any harm in hardcoding?? - return (CORBA::Octet) 1; + return (CORBA::Octet) 1; } CORBA::Octet -TAO_GIOP_Message_Connector_12:: minor_version (void) +TAO_GIOP_Message_Connector_12:: minor_version (void) { // Any harm in hardcoding?? - return (CORBA::Octet) 2; + return (CORBA::Octet) 2; } CORBA::Boolean TAO_GIOP_Message_Connector_12:: marshall_target_spec (TAO_Target_Specification &spec, - TAO_OutputCDR &msg) + TAO_OutputCDR &msg) { switch (spec.specifier ()) { case TAO_Target_Specification::Key_Addr: { - // As this is a union send in the discriminant first - msg << GIOP::KeyAddr; - - // Get the object key - const TAO_ObjectKey *key = spec.object_key (); - if (key) - { - // Marshall in the object key - msg << *key; - } - else - { - if (TAO_debug_level) - ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("(%N |%l) Unable to handle this request \n"))); - return 0; - } - break; + // As this is a union send in the discriminant first + msg << GIOP::KeyAddr; + + // Get the object key + const TAO_ObjectKey *key = spec.object_key (); + if (key) + { + // Marshall in the object key + msg << *key; + } + else + { + if (TAO_debug_level) + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("(%N |%l) Unable to handle this request \n"))); + return 0; + } + break; } case TAO_Target_Specification::Profile_Addr: { - // As this is a union send in the discriminant first - msg << GIOP::ProfileAddr; - - // Get the profile - const IOP::TaggedProfile *pfile = spec.profile (); - - if (pfile) - { - // Marshall in the object key - msg << *pfile; - } - else - { - if (TAO_debug_level) - ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("(%N |%l) Unable to handle this request \n"))); - return 0; - } - break; + // As this is a union send in the discriminant first + msg << GIOP::ProfileAddr; + + // Get the profile + const IOP::TaggedProfile *pfile = spec.profile (); + + if (pfile) + { + // Marshall in the object key + msg << *pfile; + } + else + { + if (TAO_debug_level) + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("(%N |%l) Unable to handle this request \n"))); + return 0; + } + break; } case TAO_Target_Specification::Reference_Addr: { - // As this is a union send in the discriminant first - msg << GIOP::ReferenceAddr; - - // Get the IOR - IOP::IOR *ior; - CORBA::ULong index = spec.iop_ior (ior); - - if (ior) - { - // This is a struct IORAddressingInfo. So, marshall each - // member of the struct one after another in the order - // defined. - msg << index; - msg << *ior; - } - else - { - if (TAO_debug_level) - ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("(%N |%l) Unable to handle this request \n"))); - return 0; - } - break; + // As this is a union send in the discriminant first + msg << GIOP::ReferenceAddr; + + // Get the IOR + IOP::IOR *ior; + CORBA::ULong index = spec.iop_ior (ior); + + if (ior) + { + // This is a struct IORAddressingInfo. So, marshall each + // member of the struct one after another in the order + // defined. + msg << index; + msg << *ior; + } + else + { + if (TAO_debug_level) + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("(%N |%l) Unable to handle this request \n"))); + return 0; + } + break; } default: if (TAO_debug_level) - ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("(%N |%l) Unable to handle this request \n"))); + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("(%N |%l) Unable to handle this request \n"))); return 0; } @@ -578,50 +583,50 @@ TAO_GIOP_Message_Connector_12:: int TAO_GIOP_Message_Connector_12:: parse_reply (TAO_Message_State_Factory &mesg_state, - TAO_Pluggable_Reply_Params ¶ms) + TAO_Pluggable_Reply_Params ¶ms) { // Cast to the GIOP Message state - TAO_GIOP_Message_State *state = ACE_dynamic_cast (TAO_GIOP_Message_State *, - &mesg_state); + TAO_GIOP_Message_State *state = ACE_dynamic_cast (TAO_GIOP_Message_State *, + &mesg_state); switch (state->message_type) { case TAO_GIOP_REQUEST: // We could get this in Bi_Dir GIOP - // So, we take some action. + // So, we take some action. break; case TAO_GIOP_CANCELREQUEST: case TAO_GIOP_LOCATEREQUEST: // Errors case TAO_GIOP_CLOSECONNECTION: default: - ACE_ERROR_RETURN ((LM_ERROR, - ACE_TEXT ("TAO (%P|%t) %N:%l parse_reply: ") - ACE_TEXT ("wrong message.\n")), - -1); + ACE_ERROR_RETURN ((LM_ERROR, + ACE_TEXT ("TAO (%P|%t) %N:%l parse_reply: ") + ACE_TEXT ("wrong message.\n")), + -1); case TAO_GIOP_LOCATEREPLY: if (this->parse_locate_reply (*state, - params) == -1) - return -1; + params) == -1) + return -1; break; case TAO_GIOP_REPLY: if (TAO_GIOP_Message_Connectors::parse_reply (*state, - params) - == -1) - return -1; + params) + == -1) + return -1; if ((state->cdr >> params.svc_ctx_) == 0) - { - if (TAO_debug_level > 0) - ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("TAO (%P|%t) parse_reply, ") - ACE_TEXT ("extracting context\n"))); - return -1; - } + { + if (TAO_debug_level > 0) + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("TAO (%P|%t) parse_reply, ") + ACE_TEXT ("extracting context\n"))); + return -1; + } // Rest of the stuff after the switch break; case TAO_GIOP_FRAGMENT: - // Never happens: why?? + // Never happens: why?? break; } diff --git a/TAO/tao/IIOP_Connector.cpp b/TAO/tao/IIOP_Connector.cpp index 8c6cc9182f4..21175313bf7 100644 --- a/TAO/tao/IIOP_Connector.cpp +++ b/TAO/tao/IIOP_Connector.cpp @@ -30,6 +30,11 @@ TAO_IIOP_Connect_Creation_Strategy:: } +TAO_IIOP_Connect_Creation_Strategy:: + ~TAO_IIOP_Connect_Creation_Strategy (void) +{ +} + int TAO_IIOP_Connect_Creation_Strategy::make_svc_handler (TAO_IIOP_Client_Connection_Handler *&sh) diff --git a/TAO/tao/IIOP_Connector.h b/TAO/tao/IIOP_Connector.h index 1f1a85a8984..3a0abe1e6cf 100644 --- a/TAO/tao/IIOP_Connector.h +++ b/TAO/tao/IIOP_Connector.h @@ -55,6 +55,9 @@ public: // state/info to the service handler upon creation. Currently used // by IIOP and UIOP to pass protocol configuration properties. + ~TAO_IIOP_Connect_Creation_Strategy (void); + // Default destructor g++, 2.7.2 seems to be needing this + virtual int make_svc_handler (TAO_IIOP_Client_Connection_Handler *&sh); // Makes TAO_IIOP_Client_Connection_Handlers diff --git a/TAO/tao/Invocation.cpp b/TAO/tao/Invocation.cpp index 22bffffb184..447ad42f032 100644 --- a/TAO/tao/Invocation.cpp +++ b/TAO/tao/Invocation.cpp @@ -55,32 +55,33 @@ enum // Setup Timeprobes ACE_TIMEPROBE_EVENT_DESCRIPTIONS (TAO_Invocation_Timeprobe_Description, - TAO_GIOP_INVOCATION_INVOKE_START); + TAO_GIOP_INVOCATION_INVOKE_START); -#endif /* ACE_ENABLE_TIMEPROBES */ +#endif /* ACE_ENABLE_TIMEPROBES */ -// Normal invocations don't involve any heap al; messages are -// constructed into stack-based buffers and are read into those -// buffers too. Larger buffers are heap-allocated as needed. +// Normal invocations don't involve any heap al; messages are +// constructed into stack-based buffers and are read into those +// buffers too. Larger buffers are heap-allocated as needed. // -// The constraint on request IDs is that no two requests from the same -// client with the same ID are outstanding at the same time. In -// single threaded environments, this is met by any number whatever. -// When multiple threads are used, we eliminate the need for any -// locked state by using the thread ID as the request ID, since any -// given thread has at most one request outstanding at a time. +// The constraint on request IDs is that no two requests from the same +// client with the same ID are outstanding at the same time. In +// single threaded environments, this is met by any number whatever. +// When multiple threads are used, we eliminate the need for any +// locked state by using the thread ID as the request ID, since any +// given thread has at most one request outstanding at a time. // // NOTE: this means that if "deferred synchronous" calls get -// supported, it's done by creating a thread internally to make the +// supported, it's done by creating a thread internally to make the // call. That is less disruptive (and error prone) in general than -// restructuring an ORB core in terms of asynchrony. +// restructuring an ORB core in terms of asynchrony. // **************************************************************** TAO_GIOP_Invocation::TAO_GIOP_Invocation (void) : stub_ (0), - op_details_ (0, - 0), - out_stream_ (), + op_details_ (0, + 0, + 0), + out_stream_ (), orb_core_ (0), transport_ (0), endpoint_selector_ (0), @@ -95,20 +96,22 @@ TAO_GIOP_Invocation::TAO_GIOP_Invocation (void) } TAO_GIOP_Invocation::TAO_GIOP_Invocation (TAO_Stub *stub, - const char *operation, - CORBA::ULong opname_len, - TAO_ORB_Core *orb_core) + const char *operation, + CORBA::ULong opname_len, + CORBA::Boolean argument_flag, + TAO_ORB_Core *orb_core) : stub_ (stub), - op_details_ (operation, - opname_len), - out_stream_ (this->buffer_, - sizeof this->buffer_, /* ACE_CDR::DEFAULT_BUFSIZE */ - TAO_ENCAP_BYTE_ORDER, - orb_core->output_cdr_buffer_allocator (), - orb_core->output_cdr_dblock_allocator (), - orb_core->orb_params ()->cdr_memcpy_tradeoff (), - orb_core->to_iso8859 (), - orb_core->to_unicode ()), + op_details_ (operation, + opname_len, + argument_flag), + out_stream_ (this->buffer_, + sizeof this->buffer_, /* ACE_CDR::DEFAULT_BUFSIZE */ + TAO_ENCAP_BYTE_ORDER, + orb_core->output_cdr_buffer_allocator (), + orb_core->output_cdr_dblock_allocator (), + orb_core->orb_params ()->cdr_memcpy_tradeoff (), + orb_core->to_iso8859 (), + orb_core->to_unicode ()), orb_core_ (orb_core), transport_ (0), endpoint_selector_ (0), @@ -126,66 +129,66 @@ TAO_GIOP_Invocation::~TAO_GIOP_Invocation (void) { } -// The public API involves creating an invocation, starting it, filling +// The public API involves creating an invocation, starting it, filling // in request parameters, actually performing the invocation, getting -// response parameters, and then cleaning up. Sometimes they must be -// restarted (e.g. request forwarding). This is the start/restart entry. +// response parameters, and then cleaning up. Sometimes they must be +// restarted (e.g. request forwarding). This is the start/restart entry. void TAO_GIOP_Invocation::start (CORBA::Environment &ACE_TRY_ENV) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_FUNCTION_TIMEPROBE (TAO_GIOP_INVOCATION_START_ENTER); - TAO_MINIMAL_TIMEPROBE (TAO_GIOP_INVOCATION_START_ENTER); + TAO_MINIMAL_TIMEPROBE (TAO_GIOP_INVOCATION_START_ENTER); // First try to bind to the appropriate address. We do that here - // since we may get forwarded to a different objref in the course of - // any given call, with new start () call each time. It's not + // since we may get forwarded to a different objref in the course of + // any given call, with new start () call each time. It's not // cached in the objref data since the connections change - // asynchronously from objref invocations and this simplifies - // connection management. - // We also need to bind *before* marshalling, because different - // Profiles have different ObjectKeys, thus a change of Profile can + // asynchronously from objref invocations and this simplifies + // connection management. + // We also need to bind *before* marshalling, because different + // Profiles have different ObjectKeys, thus a change of Profile can // result in different alignment for the buffer. // - // THREADING NOTE: this connection is reserved to this call. Also, - // starting at this point in the call, new forwarding information + // THREADING NOTE: this connection is reserved to this call. Also, + // starting at this point in the call, new forwarding information // will not be used until/unless the call is reissued. Correctness - // is not affected, the call will just be forwarded later than it - // might be in a more complex implementation. + // is not affected, the call will just be forwarded later than it + // might be in a more complex implementation. - // @@ assert is evil, it crashes the program, changed to an + // @@ assert is evil, it crashes the program, changed to an // exception (coryan) // assert (this->stub_ != 0); if (this->stub_ == 0) { - ACE_THROW (CORBA::INTERNAL ( - CORBA_SystemException::_tao_minor_code ( - TAO_DEFAULT_MINOR_CODE, - EINVAL), - CORBA::COMPLETED_NO)); + ACE_THROW (CORBA::INTERNAL ( + CORBA_SystemException::_tao_minor_code ( + TAO_DEFAULT_MINOR_CODE, + EINVAL), + CORBA::COMPLETED_NO)); } // Get a pointer to the connector registry, which might be in - // thread-specific storage, depending on the concurrency model. + // thread-specific storage, depending on the concurrency model. TAO_Connector_Registry *conn_reg = - this->orb_core_->connector_registry (); + this->orb_core_->connector_registry (); if (conn_reg == 0) { - ACE_THROW (CORBA::INTERNAL ( - CORBA_SystemException::_tao_minor_code ( - TAO_DEFAULT_MINOR_CODE, - EINVAL), - CORBA::COMPLETED_NO)); + ACE_THROW (CORBA::INTERNAL ( + CORBA_SystemException::_tao_minor_code ( + TAO_DEFAULT_MINOR_CODE, + EINVAL), + CORBA::COMPLETED_NO)); } - // Initialize endpoint selection strategy. + // Initialize endpoint selection strategy. if (!this->is_selector_initialized_) { this->orb_core_->endpoint_selector_factory ()->get_selector (this, - ACE_TRY_ENV); + ACE_TRY_ENV); ACE_CHECK; this->is_selector_initialized_ = 1; } @@ -194,76 +197,76 @@ TAO_GIOP_Invocation::start (CORBA::Environment &ACE_TRY_ENV) { int has_timeout; this->orb_core_->call_timeout_hook (this->stub_, - has_timeout, - this->max_wait_time_value_); + has_timeout, + this->max_wait_time_value_); if (has_timeout) - { - this->max_wait_time_ = &this->max_wait_time_value_; - } + { + this->max_wait_time_ = &this->max_wait_time_value_; + } } ACE_Countdown_Time countdown (this->max_wait_time_); - // Loop until a connection is established or there aren't any more + // Loop until a connection is established or there aren't any more // profiles to try. for (;;) { // Allow loaded services to select the profile. if (this->stub_->service_profile_selection ()) - { - this->profile_ = this->stub_->profile_in_use (); - this->endpoint_ = this->profile_->endpoint (); - } + { + this->profile_ = this->stub_->profile_in_use (); + this->endpoint_ = this->profile_->endpoint (); + } else - { - // If loaded services have nothing to say on - // profile/endpoint selection, let the strategy do the work. - this->endpoint_selector_->select_endpoint (this, - ACE_TRY_ENV); - ACE_CHECK; - } + { + // If loaded services have nothing to say on + // profile/endpoint selection, let the strategy do the work. + this->endpoint_selector_->select_endpoint (this, + ACE_TRY_ENV); + ACE_CHECK; + } // Get the transport object. if (this->transport_ != 0) - { - this->transport_->idle (); - } + { + this->transport_->idle (); + } - // Obtain a connection. + // Obtain a connection. int result = conn_reg->connect (this->endpoint_, - this->transport_, - this->max_wait_time_, - ACE_TRY_ENV); + this->transport_, + this->max_wait_time_, + ACE_TRY_ENV); ACE_CHECK; if (result == 0) - { - // Now that we have the client connection handler object we need to - // set the right messaging protocol for in the client side transport. - const TAO_GIOP_Version& version = this->profile_->version (); - result = this->transport_->messaging_init (version.major, - version.minor); - if (result == -1) - { - if (TAO_debug_level > 0) - { - ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("(%N|%l|%p|%t) ") - ACE_TEXT ("messaging_init() failed\n"))); - } - } - else - break; - } - - if (errno == ETIME) - { - ACE_THROW (CORBA::TIMEOUT ( - CORBA_SystemException::_tao_minor_code ( - TAO_TIMEOUT_CONNECT_MINOR_CODE, - errno), - CORBA::COMPLETED_NO)); - } + { + // Now that we have the client connection handler object we need to + // set the right messaging protocol for in the client side transport. + const TAO_GIOP_Version& version = this->profile_->version (); + result = this->transport_->messaging_init (version.major, + version.minor); + if (result == -1) + { + if (TAO_debug_level > 0) + { + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("(%N|%l|%p|%t) ") + ACE_TEXT ("messaging_init() failed\n"))); + } + } + else + break; + } + + if (errno == ETIME) + { + ACE_THROW (CORBA::TIMEOUT ( + CORBA_SystemException::_tao_minor_code ( + TAO_TIMEOUT_CONNECT_MINOR_CODE, + errno), + CORBA::COMPLETED_NO)); + } // Try another profile/endpoint. this->endpoint_selector_->next (this, ACE_TRY_ENV); @@ -274,129 +277,129 @@ TAO_GIOP_Invocation::start (CORBA::Environment &ACE_TRY_ENV) // Obtain unique request id from the RMS. this->op_details_.request_id ( - this->transport_->tms ()->request_id ()); + this->transport_->tms ()->request_id ()); - // Make sure that you have the right object key + // Make sure that you have the right object key this->target_spec_.target_specifier (this->profile_->object_key ()); } void TAO_GIOP_Invocation::prepare_header (CORBA::Octet response_flags, - CORBA_Environment &ACE_TRY_ENV) + CORBA_Environment &ACE_TRY_ENV) ACE_THROW_SPEC ((CORBA::SystemException)) { // Then fill in the rest of the RequestHeader // Fill up the service context lists // First lookup at the services to see whether they have anything to - // add to the service context lists - this->orb_core_->service_context_list (this->stub_, - this->service_info (), - this->restart_flag_, - ACE_TRY_ENV); + // add to the service context lists + this->orb_core_->service_context_list (this->stub_, + this->service_info (), + this->restart_flag_, + ACE_TRY_ENV); ACE_CHECK; this->add_rt_service_context (ACE_TRY_ENV); ACE_CHECK; - // The target specification mode + // The target specification mode if (this->stub_->addressing_mode () == TAO_Target_Specification::Key_Addr) { this->target_spec_.target_specifier ( - this->profile_->object_key ()); + this->profile_->object_key ()); } - else if (this->stub_->addressing_mode () - == TAO_Target_Specification::Profile_Addr) + else if (this->stub_->addressing_mode () + == TAO_Target_Specification::Profile_Addr) { this->target_spec_.target_specifier ( - this->profile_->create_tagged_profile () - ); + this->profile_->create_tagged_profile () + ); } - else if (this->stub_->addressing_mode () - == TAO_Target_Specification::Reference_Addr) + else if (this->stub_->addressing_mode () + == TAO_Target_Specification::Reference_Addr) { - // We need to call the method seperately. If there is no - // IOP::IOR info, the call would create the info and return the + // We need to call the method seperately. If there is no + // IOP::IOR info, the call would create the info and return the // index that we need. - // @@Will not work for RT CORBA as the index we get would be + // @@Will not work for RT CORBA as the index we get would be // wrong. CORBA::ULong index = this->create_ior_info (); this->target_spec_.target_specifier (this->ior_info_, - index); + index); } - // Update the response flags + // Update the response flags this->op_details_.response_flags (response_flags); // Send the request for the header if (this->transport_->send_request_header (this->op_details_, - this->target_spec_, - this->out_stream_) - == 0) + this->target_spec_, + this->out_stream_) + == 0) { - ACE_THROW (CORBA::MARSHAL ()); + ACE_THROW (CORBA::MARSHAL ()); } } -// Send request. +// Send request. int TAO_GIOP_Invocation::invoke (CORBA::Boolean is_roundtrip, - CORBA::Environment &ACE_TRY_ENV) + CORBA::Environment &ACE_TRY_ENV) ACE_THROW_SPEC ((CORBA::SystemException)) { ACE_Countdown_Time countdown (this->max_wait_time_); if (this->transport_ == 0) { - ACE_THROW_RETURN (CORBA::INTERNAL (), - TAO_INVOKE_EXCEPTION); + ACE_THROW_RETURN (CORBA::INTERNAL (), + TAO_INVOKE_EXCEPTION); } - // @@ Alex: the <is_roundtrip> flag will be tricky when we move to - // AMI: now it is used both to indicate the the CORBA request in - // a twoway and that the send_request() operation should block. - // Even for oneways: with AMI it is possible to wait for a - // response (empty) for oneways, just to make sure that they - // arrive, there are policies to control that. + // @@ Alex: the <is_roundtrip> flag will be tricky when we move to + // AMI: now it is used both to indicate the the CORBA request in + // a twoway and that the send_request() operation should block. + // Even for oneways: with AMI it is possible to wait for a + // response (empty) for oneways, just to make sure that they + // arrive, there are policies to control that. int result = this->transport_->send_request (this->stub_, - this->orb_core_, - this->out_stream_, - is_roundtrip, - this->max_wait_time_); + this->orb_core_, + this->out_stream_, + is_roundtrip, + this->max_wait_time_); // - // @@ highly desirable to know whether we wrote _any_ data; if - // we wrote none, then there's no chance the call completed and - // applications don't have to deal with those nasty - // indeterminate states where they can't immediatly tell if + // @@ highly desirable to know whether we wrote _any_ data; if + // we wrote none, then there's no chance the call completed and + // applications don't have to deal with those nasty + // indeterminate states where they can't immediatly tell if // what's safe to do. // - // @@ also, there might have been a GIOP::CloseConnection - // message in the input queue. If so, this request should be - // treated as a (full) "rebind" case. Can't do that from this - // point in the code however! Some minor restructuring needs to + // @@ also, there might have been a GIOP::CloseConnection + // message in the input queue. If so, this request should be + // treated as a (full) "rebind" case. Can't do that from this + // point in the code however! Some minor restructuring needs to // happen. // - if (result == -1) + if (result == -1) { - if (errno == ETIME) - { - ACE_THROW_RETURN ( - CORBA::TIMEOUT ( - CORBA_SystemException::_tao_minor_code ( - TAO_TIMEOUT_SEND_MINOR_CODE, - errno - ), - CORBA::COMPLETED_NO - ), - TAO_INVOKE_EXCEPTION - ); - } + if (errno == ETIME) + { + ACE_THROW_RETURN ( + CORBA::TIMEOUT ( + CORBA_SystemException::_tao_minor_code ( + TAO_TIMEOUT_SEND_MINOR_CODE, + errno + ), + CORBA::COMPLETED_NO + ), + TAO_INVOKE_EXCEPTION + ); + } this->transport_->close_connection (); this->transport_ = 0; @@ -405,9 +408,9 @@ TAO_GIOP_Invocation::invoke (CORBA::Boolean is_roundtrip, return TAO_INVOKE_RESTART; } - // Indicate that the endpoint/profile was used successfully. - // @@ Maybe the right place to do this is once the reply is - // received? But what about oneways? + // Indicate that the endpoint/profile was used successfully. + // @@ Maybe the right place to do this is once the reply is + // received? But what about oneways? this->endpoint_selector_->success (this); return TAO_INVOKE_OK; @@ -416,9 +419,9 @@ TAO_GIOP_Invocation::invoke (CORBA::Boolean is_roundtrip, int TAO_GIOP_Invocation::close_connection (void) { - // Special case of forwarding -- server was closing the - // connection, which just indicates resource constraints, not an - // error. The client is effectively "forwarded" to the same + // Special case of forwarding -- server was closing the + // connection, which just indicates resource constraints, not an + // error. The client is effectively "forwarded" to the same // server! // // However, we must reinitialize the forwarding chain, since the @@ -444,12 +447,12 @@ TAO_GIOP_Invocation::close_connection (void) int TAO_GIOP_Invocation::location_forward (TAO_InputCDR &inp_stream, - CORBA::Environment &ACE_TRY_ENV) + CORBA::Environment &ACE_TRY_ENV) ACE_THROW_SPEC ((CORBA::SystemException)) { - // It can be assumed that the GIOP header and the reply header + // It can be assumed that the GIOP header and the reply header // are already handled. Further it can be assumed that the - // reply body contains an object reference to the new object. + // reply body contains an object reference to the new object. // This object pointer will be now extracted. CORBA::Object_var object = 0; @@ -457,23 +460,23 @@ TAO_GIOP_Invocation::location_forward (TAO_InputCDR &inp_stream, if ( (inp_stream >> object.inout ()) == 0) { ACE_THROW_RETURN (CORBA::MARSHAL (), - TAO_INVOKE_EXCEPTION); + TAO_INVOKE_EXCEPTION); } - // The object pointer has to be changed to a TAO_Stub pointer - // in order to obtain the profiles. + // The object pointer has to be changed to a TAO_Stub pointer + // in order to obtain the profiles. TAO_Stub *stubobj = object->_stubobj (); if (stubobj == 0) { - ACE_THROW_RETURN (CORBA::INTERNAL (), - TAO_INVOKE_EXCEPTION); + ACE_THROW_RETURN (CORBA::INTERNAL (), + TAO_INVOKE_EXCEPTION); } - // Modify the state as appropriate to include new forwarding profiles. + // Modify the state as appropriate to include new forwarding profiles. this->endpoint_selector_->forward (this, - stubobj->base_profiles (), - ACE_TRY_ENV); + stubobj->base_profiles (), + ACE_TRY_ENV); ACE_CHECK_RETURN (TAO_INVOKE_EXCEPTION); return TAO_INVOKE_RESTART; @@ -484,34 +487,34 @@ CORBA::ULong TAO_GIOP_Invocation::create_ior_info (void) { // Get the list of profiles - const TAO_MProfile &mprofile = this->stub_->base_profiles (); + const TAO_MProfile &mprofile = this->stub_->base_profiles (); if (this->ior_info_.profiles.length () == 0) { - // We are making a copy, it is expensive. We want a copy of the - // profiles as we dont want to modify the profile set held by + // We are making a copy, it is expensive. We want a copy of the + // profiles as we dont want to modify the profile set held by // the Stub classes. We may want to hold a lock for doing - // that. To avoid unnecssary complications we make a copy and + // that. To avoid unnecssary complications we make a copy and // get the info // @@ There should be a better way to do this - Bala TAO_MProfile *multi_prof = - this->stub_->make_profiles (); + this->stub_->make_profiles (); - // Get the number of elements + // Get the number of elements CORBA::ULong count = multi_prof->profile_count (); - // Set the number of elements in the sequence of tagged_profile + // Set the number of elements in the sequence of tagged_profile this->ior_info_.profiles.length (count); - // Call the create_tagged_profile one every member of the + // Call the create_tagged_profile one every member of the // profile and make the sequence - for (CORBA::ULong index = 0; index < count; ++index) - { - TAO_Profile *prof = multi_prof->get_profile (index); + for (CORBA::ULong index = 0; index < count; ++index) + { + TAO_Profile *prof = multi_prof->get_profile (index); - this->ior_info_.profiles[index] = prof->create_tagged_profile (); - } + this->ior_info_.profiles[index] = prof->create_tagged_profile (); + } delete multi_prof; } @@ -523,8 +526,8 @@ void TAO_GIOP_Invocation::add_rt_service_context (CORBA_Environment &ACE_TRY_ENV) { // RTCORBA-specific processing. - // If invocation target supports RTCORBA::CLIENT_PROPAGATED priority - // model, we must add IOP::RTCorbaPriority service context to the + // If invocation target supports RTCORBA::CLIENT_PROPAGATED priority + // model, we must add IOP::RTCorbaPriority service context to the // list. #if (TAO_HAS_RT_CORBA == 1) @@ -539,58 +542,58 @@ TAO_GIOP_Invocation::add_rt_service_context (CORBA_Environment &ACE_TRY_ENV) if (this->endpoint_selection_state_.priority_model_policy_) { if (this->endpoint_selection_state_.priority_model_policy_-> - get_priority_model () == RTCORBA::CLIENT_PROPAGATED) - { - // Encapsulate the priority of the current thread into - // a service context. - TAO_OutputCDR cdr; - if ((cdr << ACE_OutputCDR::from_boolean (TAO_ENCAP_BYTE_ORDER) - == 0) - || (cdr << this->endpoint_selection_state_.client_priority_) - == 0) - ACE_THROW (CORBA::MARSHAL ()); - - IOP::ServiceContextList &context_list = this->service_info (); - - CORBA::ULong l = context_list.length (); - context_list.length (l + 1); - context_list[l].context_id = IOP::RTCorbaPriority; - - // Make a *copy* of the CDR stream... - CORBA::ULong length = cdr.total_length (); - context_list[l].context_data.length (length); - CORBA::Octet *buf = context_list[l].context_data.get_buffer (); - - for (const ACE_Message_Block *i = cdr.begin (); - i != 0; - i = i->cont ()) - { - ACE_OS::memcpy (buf, - i->rd_ptr (), - i->length ()); - buf += i->length (); - } - } + get_priority_model () == RTCORBA::CLIENT_PROPAGATED) + { + // Encapsulate the priority of the current thread into + // a service context. + TAO_OutputCDR cdr; + if ((cdr << ACE_OutputCDR::from_boolean (TAO_ENCAP_BYTE_ORDER) + == 0) + || (cdr << this->endpoint_selection_state_.client_priority_) + == 0) + ACE_THROW (CORBA::MARSHAL ()); + + IOP::ServiceContextList &context_list = this->service_info (); + + CORBA::ULong l = context_list.length (); + context_list.length (l + 1); + context_list[l].context_id = IOP::RTCorbaPriority; + + // Make a *copy* of the CDR stream... + CORBA::ULong length = cdr.total_length (); + context_list[l].context_data.length (length); + CORBA::Octet *buf = context_list[l].context_data.get_buffer (); + + for (const ACE_Message_Block *i = cdr.begin (); + i != 0; + i = i->cont ()) + { + ACE_OS::memcpy (buf, + i->rd_ptr (), + i->length ()); + buf += i->length (); + } + } } else { // The Object does not contain PriorityModel policy in its IOR. - // We must be talking to a non-RT ORB. Do nothing. + // We must be talking to a non-RT ORB. Do nothing. } - this->rt_context_initialized_ = 1; + this->rt_context_initialized_ = 1; #else ACE_UNUSED_ARG (ACE_TRY_ENV); -#endif /* TAO_HAS_RT_CORBA == 1 */ +#endif /* TAO_HAS_RT_CORBA == 1 */ } // **************************************************************** TAO_GIOP_Synch_Invocation::TAO_GIOP_Synch_Invocation (void) - : rd_ (0, - this->op_details_.service_info ()) + : rd_ (0, + this->op_details_.service_info ()) { } @@ -604,88 +607,88 @@ TAO_GIOP_Synch_Invocation::~TAO_GIOP_Synch_Invocation (void) int TAO_GIOP_Synch_Invocation::invoke_i (CORBA::Boolean is_locate_request, - CORBA::Environment &ACE_TRY_ENV) + CORBA::Environment &ACE_TRY_ENV) ACE_THROW_SPEC ((CORBA::SystemException)) { - // Register a reply dispatcher for this invocation. Use the - // preallocated reply dispatcher. + // Register a reply dispatcher for this invocation. Use the + // preallocated reply dispatcher. // Bind. TAO_Transport_Mux_Strategy *tms = this->transport_->tms (); TAO_Bind_Dispatcher_Guard dispatch_guard (this->op_details_.request_id(), - &this->rd_, - tms); + &this->rd_, + tms); int retval = dispatch_guard.status (); - if (retval == -1) + if (retval == -1) { - // @@ What is the right way to handle this error? + // @@ What is the right way to handle this error? this->close_connection (); - ACE_THROW_RETURN (CORBA::INTERNAL (TAO_DEFAULT_MINOR_CODE, - CORBA::COMPLETED_NO), - TAO_INVOKE_EXCEPTION); + ACE_THROW_RETURN (CORBA::INTERNAL (TAO_DEFAULT_MINOR_CODE, + CORBA::COMPLETED_NO), + TAO_INVOKE_EXCEPTION); } // Just send the request, without trying to wait for the reply. retval = TAO_GIOP_Invocation::invoke (1, - ACE_TRY_ENV); + ACE_TRY_ENV); ACE_CHECK_RETURN (retval); - if (retval != TAO_INVOKE_OK) + if (retval != TAO_INVOKE_OK) { return retval; } // This blocks until the response is read. In the current version, // there is only one client thread that ever uses this connection, - // so most response messages are illegal. + // so most response messages are illegal. // - // @@ In all MT environments, there's a cancellation point lurking - // here; need to investigate. Client threads would frequently be + // @@ In all MT environments, there's a cancellation point lurking + // here; need to investigate. Client threads would frequently be // canceled sometime during recv_request ... the correct action to - // take on being canceled is to issue a CancelRequest message to the - // server and then imediately let other client-side cancellation + // take on being canceled is to issue a CancelRequest message to the + // server and then imediately let other client-side cancellation // handlers do their jobs. // - // In C++, that basically means to unwind the stack using almost - // normal procedures: all destructors should fire, and some "catch" + // In C++, that basically means to unwind the stack using almost + // normal procedures: all destructors should fire, and some "catch" // blocks should probably be able to handle things like releasing - // pointers. (Without unwinding the C++ stack, resources that must - // be freed by thread cancellation won't be freed, and the process - // won't continue to function correctly.) The tricky part is that + // pointers. (Without unwinding the C++ stack, resources that must + // be freed by thread cancellation won't be freed, and the process + // won't continue to function correctly.) The tricky part is that // according to POSIX, all C stack frames must also have their - // (explicitly coded) handlers called. We assume a POSIX.1c/C/C++ + // (explicitly coded) handlers called. We assume a POSIX.1c/C/C++ // environment. // Get the reply status. // Wait for the reply. - if (TAO_debug_level > 0 && this->max_wait_time_ != 0) + if (TAO_debug_level > 0 && this->max_wait_time_ != 0) { CORBA::ULong msecs = this->max_wait_time_->msec (); - ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("TAO (%P|%t) Timeout on recv is <%u>\n"), - msecs)); + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("TAO (%P|%t) Timeout on recv is <%u>\n"), + msecs)); } int reply_error = this->transport_->wait_strategy ()->wait (this->max_wait_time_, - this->rd_.reply_received ()); + this->rd_.reply_received ()); - if (TAO_debug_level > 0 && this->max_wait_time_ != 0) + if (TAO_debug_level > 0 && this->max_wait_time_ != 0) { CORBA::ULong msecs = this->max_wait_time_->msec (); - ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("TAO (%P|%t) Timeout after recv is <%u> status <%d>\n"), - msecs, - reply_error)); + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("TAO (%P|%t) Timeout after recv is <%u> status <%d>\n"), + msecs, + reply_error)); } // Check the reply error. @@ -693,41 +696,41 @@ TAO_GIOP_Synch_Invocation::invoke_i (CORBA::Boolean is_locate_request, if (reply_error == -1) { // The guard automatically unbinds the dispatcher. - if (errno == ETIME) - { - // Just a timeout, don't close the connection or - // anything... - ACE_THROW_RETURN (CORBA::TIMEOUT ( - CORBA_SystemException::_tao_minor_code ( - TAO_TIMEOUT_SEND_MINOR_CODE, - errno), - CORBA::COMPLETED_NO), - TAO_INVOKE_EXCEPTION); - } - - // Call the ORB Core which would check whether we need to really - // raise an exception or are we going to base our decision on the - // loaded services. + if (errno == ETIME) + { + // Just a timeout, don't close the connection or + // anything... + ACE_THROW_RETURN (CORBA::TIMEOUT ( + CORBA_SystemException::_tao_minor_code ( + TAO_TIMEOUT_SEND_MINOR_CODE, + errno), + CORBA::COMPLETED_NO), + TAO_INVOKE_EXCEPTION); + } + + // Call the ORB Core which would check whether we need to really + // raise an exception or are we going to base our decision on the + // loaded services. return this->orb_core_->service_raise_comm_failure (this, - this->profile_, - ACE_TRY_ENV); + this->profile_, + ACE_TRY_ENV); } - // @@ Alex: the old version of this had some error handling code, - // like: this->profile_->reset_hint () - // Can you make sure we don't forget to do that on exceptions - // and/or errors. - // BTW, think about native exceptions where if the exception is - // raised in the wait() method you won't get a chance - // to do that kind of error handling. Do you really need - // exceptions in the transport objects? + // @@ Alex: the old version of this had some error handling code, + // like: this->profile_->reset_hint () + // Can you make sure we don't forget to do that on exceptions + // and/or errors. + // BTW, think about native exceptions where if the exception is + // raised in the wait() method you won't get a chance + // to do that kind of error handling. Do you really need + // exceptions in the transport objects? CORBA::ULong reply_status = this->rd_.reply_status (); if (is_locate_request) { - // A locate request checks a different set of enum return values, - // so we return to the TAO_GIOP_Locate_Request_Invocation caller + // A locate request checks a different set of enum return values, + // so we return to the TAO_GIOP_Locate_Request_Invocation caller // to do that. return reply_status; } @@ -735,92 +738,92 @@ TAO_GIOP_Synch_Invocation::invoke_i (CORBA::Boolean is_locate_request, switch (reply_status) { case TAO_PLUGGABLE_MESSAGE_NO_EXCEPTION: - // Return so that the STUB can demarshal the reply. + // Return so that the STUB can demarshal the reply. return TAO_INVOKE_OK; case TAO_PLUGGABLE_MESSAGE_USER_EXCEPTION: - // Return so the exception can be handled. - return TAO_INVOKE_EXCEPTION; + // Return so the exception can be handled. + return TAO_INVOKE_EXCEPTION; case TAO_PLUGGABLE_MESSAGE_SYSTEM_EXCEPTION: { - // @@ Add the location macros for this exceptions... - - CORBA::String_var type_id; - - if ((this->inp_stream () >> type_id.inout ()) == 0) - { - // Could not demarshal the exception id, raise an local - // CORBA::MARSHAL - ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, - CORBA::COMPLETED_MAYBE), - TAO_INVOKE_OK); - } - - CORBA::ULong minor = 0; - CORBA::ULong completion = 0; - - if ((this->inp_stream () >> minor) == 0 - || (this->inp_stream () >> completion) == 0) - { - ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, - CORBA::COMPLETED_MAYBE), - TAO_INVOKE_OK); - } - - CORBA::SystemException* ex = - TAO_Exceptions::create_system_exception (type_id.in (), - ACE_TRY_ENV); - ACE_CHECK_RETURN (TAO_INVOKE_OK); - - if (ex == 0) - { - // @@ We should raise a CORBA::NO_MEMORY, but we ran out - // of memory already. We need a pre-allocated, TSS, - // CORBA::NO_MEMORY instance - ACE_NEW_RETURN (ex, - CORBA::UNKNOWN, - TAO_INVOKE_EXCEPTION); - } - - ex->minor (minor); - ex->completed (CORBA::CompletionStatus (completion)); - - - // @@ There should be a better way to raise this exception! - // This code works for both native and emulated exceptions, - // but it is ugly. - ACE_TRY_ENV.exception (ex); // We can not use ACE_THROW here. - return TAO_INVOKE_OK; + // @@ Add the location macros for this exceptions... + + CORBA::String_var type_id; + + if ((this->inp_stream () >> type_id.inout ()) == 0) + { + // Could not demarshal the exception id, raise an local + // CORBA::MARSHAL + ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, + CORBA::COMPLETED_MAYBE), + TAO_INVOKE_OK); + } + + CORBA::ULong minor = 0; + CORBA::ULong completion = 0; + + if ((this->inp_stream () >> minor) == 0 + || (this->inp_stream () >> completion) == 0) + { + ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, + CORBA::COMPLETED_MAYBE), + TAO_INVOKE_OK); + } + + CORBA::SystemException* ex = + TAO_Exceptions::create_system_exception (type_id.in (), + ACE_TRY_ENV); + ACE_CHECK_RETURN (TAO_INVOKE_OK); + + if (ex == 0) + { + // @@ We should raise a CORBA::NO_MEMORY, but we ran out + // of memory already. We need a pre-allocated, TSS, + // CORBA::NO_MEMORY instance + ACE_NEW_RETURN (ex, + CORBA::UNKNOWN, + TAO_INVOKE_EXCEPTION); + } + + ex->minor (minor); + ex->completed (CORBA::CompletionStatus (completion)); + + + // @@ There should be a better way to raise this exception! + // This code works for both native and emulated exceptions, + // but it is ugly. + ACE_TRY_ENV.exception (ex); // We can not use ACE_THROW here. + return TAO_INVOKE_OK; } // NOTREACHED. case TAO_PLUGGABLE_MESSAGE_LOCATION_FORWARD: - // Handle the forwarding and return so the stub restarts the + // Handle the forwarding and return so the stub restarts the // request! return this->location_forward (this->inp_stream (), - ACE_TRY_ENV); + ACE_TRY_ENV); case TAO_PLUGGABLE_MESSAGE_NEEDS_ADDRESSING_MODE: { - // We have received an exception with a request to change the - // addressing mode. First let us read the mode that the - // server/agent asks for. - CORBA::Short addr_mode = 0; - if (this->inp_stream ().read_short (addr_mode) == 0) - { - // Could not demarshal the addressing disposition, raise an local - // CORBA::MARSHAL - ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, - CORBA::COMPLETED_MAYBE), - TAO_INVOKE_OK); - } - - // Now set this addressing mode in the stub object, so that - // the next invocation need not go through this. - this->stub_->addressing_mode (addr_mode); - - // Now restart the invocation - return TAO_INVOKE_RESTART; + // We have received an exception with a request to change the + // addressing mode. First let us read the mode that the + // server/agent asks for. + CORBA::Short addr_mode = 0; + if (this->inp_stream ().read_short (addr_mode) == 0) + { + // Could not demarshal the addressing disposition, raise an local + // CORBA::MARSHAL + ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, + CORBA::COMPLETED_MAYBE), + TAO_INVOKE_OK); + } + + // Now set this addressing mode in the stub object, so that + // the next invocation need not go through this. + this->stub_->addressing_mode (addr_mode); + + // Now restart the invocation + return TAO_INVOKE_RESTART; } } @@ -838,91 +841,91 @@ TAO_GIOP_Twoway_Invocation::start (CORBA_Environment &ACE_TRY_ENV) ACE_CHECK; this->transport_->start_request (this->orb_core_, - this->target_spec_, - this->out_stream_, - ACE_TRY_ENV); + this->target_spec_, + this->out_stream_, + ACE_TRY_ENV); } -// Send request, block until any reply comes back, and unmarshal reply +// Send request, block until any reply comes back, and unmarshal reply // parameters as appropriate. int TAO_GIOP_Twoway_Invocation::invoke (TAO_Exception_Data *excepts, - CORBA::ULong except_count, - CORBA::Environment &ACE_TRY_ENV) + CORBA::ULong except_count, + CORBA::Environment &ACE_TRY_ENV) ACE_THROW_SPEC ((CORBA::Exception)) { TAO_FUNCTION_PP_TIMEPROBE (TAO_GIOP_INVOCATION_INVOKE_START); int retval = this->invoke_i (0, - ACE_TRY_ENV); + ACE_TRY_ENV); ACE_CHECK_RETURN (retval); - // A TAO_INVOKE_EXCEPTION status, but no exception raised means that - // we have a user exception. - // @@ This is a bit brittle, think about a better implementation. - if (retval == TAO_INVOKE_EXCEPTION) + // A TAO_INVOKE_EXCEPTION status, but no exception raised means that + // we have a user exception. + // @@ This is a bit brittle, think about a better implementation. + if (retval == TAO_INVOKE_EXCEPTION) { // Pull the exception from the stream. - CORBA::String_var buf; + CORBA::String_var buf; - if ((this->inp_stream () >> buf.inout ()) == 0) - { - // Could not demarshal the exception id, raise an local - // CORBA::MARSHAL - ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, - CORBA::COMPLETED_MAYBE), - TAO_INVOKE_EXCEPTION); - } + if ((this->inp_stream () >> buf.inout ()) == 0) + { + // Could not demarshal the exception id, raise an local + // CORBA::MARSHAL + ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, + CORBA::COMPLETED_MAYBE), + TAO_INVOKE_EXCEPTION); + } // Match the exception interface repository id with the // exception in the exception list. // This is important to decode the exception. - for (CORBA::ULong i = 0; i < except_count; ++i) - { - CORBA::TypeCode_ptr tcp = excepts[i].tc; - const char *xid = tcp->id (ACE_TRY_ENV); - ACE_CHECK_RETURN (TAO_INVOKE_EXCEPTION); - - if (ACE_OS::strcmp (buf.in (), xid) != 0) - { - continue; - } - - // match - CORBA::Exception *exception = excepts[i].alloc (); - - if (exception == 0) - { - ACE_THROW_RETURN (CORBA::NO_MEMORY (TAO_DEFAULT_MINOR_CODE, - CORBA::COMPLETED_YES), - TAO_INVOKE_EXCEPTION); - } - - exception->_tao_decode (this->inp_stream (), - ACE_TRY_ENV); - ACE_CHECK_RETURN (TAO_INVOKE_EXCEPTION); - - if (TAO_debug_level > 5) - { - ACE_DEBUG ((LM_DEBUG, - ACE_TEXT ("TAO: (%P|%t) Raising exception %s\n"), - buf.in ())); - } - - // @@ Think about a better way to raise the exception here, - // maybe we need some more macros? - ACE_TRY_ENV.exception (exception); // We can not use ACE_THROW here. - return TAO_INVOKE_EXCEPTION; - } - - // If we couldn't find the right exception, report it as + for (CORBA::ULong i = 0; i < except_count; ++i) + { + CORBA::TypeCode_ptr tcp = excepts[i].tc; + const char *xid = tcp->id (ACE_TRY_ENV); + ACE_CHECK_RETURN (TAO_INVOKE_EXCEPTION); + + if (ACE_OS::strcmp (buf.in (), xid) != 0) + { + continue; + } + + // match + CORBA::Exception *exception = excepts[i].alloc (); + + if (exception == 0) + { + ACE_THROW_RETURN (CORBA::NO_MEMORY (TAO_DEFAULT_MINOR_CODE, + CORBA::COMPLETED_YES), + TAO_INVOKE_EXCEPTION); + } + + exception->_tao_decode (this->inp_stream (), + ACE_TRY_ENV); + ACE_CHECK_RETURN (TAO_INVOKE_EXCEPTION); + + if (TAO_debug_level > 5) + { + ACE_DEBUG ((LM_DEBUG, + ACE_TEXT ("TAO: (%P|%t) Raising exception %s\n"), + buf.in ())); + } + + // @@ Think about a better way to raise the exception here, + // maybe we need some more macros? + ACE_TRY_ENV.exception (exception); // We can not use ACE_THROW here. + return TAO_INVOKE_EXCEPTION; + } + + // If we couldn't find the right exception, report it as // CORBA::UNKNOWN. ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, - CORBA::COMPLETED_YES), - TAO_INVOKE_EXCEPTION); + CORBA::COMPLETED_YES), + TAO_INVOKE_EXCEPTION); } return retval; @@ -934,19 +937,21 @@ TAO_GIOP_Oneway_Invocation::TAO_GIOP_Oneway_Invocation ( TAO_Stub *stub, const char *operation, CORBA::ULong opname_len, + CORBA::Boolean argument_flag, TAO_ORB_Core *orb_core ) : TAO_GIOP_Synch_Invocation (stub, - operation, - opname_len, - orb_core), - sync_scope_ (TAO::SYNC_WITH_TRANSPORT) + operation, + opname_len, + argument_flag, + orb_core), + sync_scope_ (TAO::SYNC_WITH_TRANSPORT) { int has_synchronization = 0; int scope = 0; - this->orb_core_->call_sync_scope_hook (this->stub_, - has_synchronization, - scope); + this->orb_core_->call_sync_scope_hook (this->stub_, + has_synchronization, + scope); this->sync_scope_ = scope; } @@ -959,50 +964,50 @@ TAO_GIOP_Oneway_Invocation::start (CORBA_Environment &ACE_TRY_ENV) ACE_CHECK; this->transport_->start_request (this->orb_core_, - this->target_spec_, - this->out_stream_, - ACE_TRY_ENV); + this->target_spec_, + this->out_stream_, + ACE_TRY_ENV); } int TAO_GIOP_Oneway_Invocation::invoke (CORBA::Environment &ACE_TRY_ENV) ACE_THROW_SPEC ((CORBA::SystemException)) { - if (this->sync_scope_ == TAO::SYNC_WITH_TRANSPORT + if (this->sync_scope_ == TAO::SYNC_WITH_TRANSPORT || this->sync_scope_ == TAO::SYNC_NONE || this->sync_scope_ == TAO::SYNC_EAGER_BUFFERING || this->sync_scope_ == TAO::SYNC_DELAYED_BUFFERING) { return TAO_GIOP_Invocation::invoke (0, - ACE_TRY_ENV); + ACE_TRY_ENV); } int retval = this->invoke_i (0, - ACE_TRY_ENV); + ACE_TRY_ENV); ACE_CHECK_RETURN (retval); - // A TAO_INVOKE_EXCEPTION status, but no exception raised means that - // we have a user exception. - // @@ This is a bit brittle, think about a better implementation. - if (retval == TAO_INVOKE_EXCEPTION) + // A TAO_INVOKE_EXCEPTION status, but no exception raised means that + // we have a user exception. + // @@ This is a bit brittle, think about a better implementation. + if (retval == TAO_INVOKE_EXCEPTION) { // Pull the exception from the stream. - CORBA::String_var buf; - - if ((this->inp_stream () >> buf.inout ()) == 0) - { - // Could not demarshal the exception id, raise an local - // CORBA::MARSHAL - ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, - CORBA::COMPLETED_MAYBE), - TAO_INVOKE_EXCEPTION); - } - - // This kind of exception shouldn't happen with oneways, - // but if it does, we turn it into a CORBA::UNKNOWN exception. + CORBA::String_var buf; + + if ((this->inp_stream () >> buf.inout ()) == 0) + { + // Could not demarshal the exception id, raise an local + // CORBA::MARSHAL + ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, + CORBA::COMPLETED_MAYBE), + TAO_INVOKE_EXCEPTION); + } + + // This kind of exception shouldn't happen with oneways, + // but if it does, we turn it into a CORBA::UNKNOWN exception. ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, - CORBA::COMPLETED_YES), - TAO_INVOKE_EXCEPTION); + CORBA::COMPLETED_YES), + TAO_INVOKE_EXCEPTION); } return retval; @@ -1018,25 +1023,25 @@ TAO_GIOP_Locate_Request_Invocation::start (CORBA_Environment &ACE_TRY_ENV) ACE_CHECK; this->transport_->start_locate (this->orb_core_, - this->target_spec_, - this->op_details_, - this->out_stream_, - ACE_TRY_ENV); + this->target_spec_, + this->op_details_, + this->out_stream_, + ACE_TRY_ENV); } -// Send request, block until any reply comes back. +// Send request, block until any reply comes back. int TAO_GIOP_Locate_Request_Invocation::invoke (CORBA::Environment &ACE_TRY_ENV) ACE_THROW_SPEC ((CORBA::SystemException)) { if (this->transport_ == 0) { - ACE_THROW_RETURN (CORBA::INTERNAL (), - TAO_INVOKE_EXCEPTION); + ACE_THROW_RETURN (CORBA::INTERNAL (), + TAO_INVOKE_EXCEPTION); } CORBA::ULong locate_status = this->invoke_i (1, - ACE_TRY_ENV); + ACE_TRY_ENV); ACE_CHECK_RETURN (TAO_INVOKE_EXCEPTION); switch (locate_status) @@ -1044,55 +1049,55 @@ TAO_GIOP_Locate_Request_Invocation::invoke (CORBA::Environment &ACE_TRY_ENV) case TAO_GIOP_OBJECT_HERE: break; case TAO_GIOP_UNKNOWN_OBJECT: - ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (TAO_DEFAULT_MINOR_CODE, - CORBA::COMPLETED_YES), - TAO_INVOKE_EXCEPTION); + ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (TAO_DEFAULT_MINOR_CODE, + CORBA::COMPLETED_YES), + TAO_INVOKE_EXCEPTION); // NOTREACHED. case TAO_GIOP_OBJECT_FORWARD: return this->location_forward (this->inp_stream (), - ACE_TRY_ENV); + ACE_TRY_ENV); case TAO_GIOP_LOC_SYSTEM_EXCEPTION: { - // Pull the exception from the stream. - CORBA::String_var buf; - - if ((this->inp_stream () >> buf.inout ()) == 0) - { - // Could not demarshal the exception id, raise a local - // CORBA::MARSHAL exception. - ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, - CORBA::COMPLETED_MAYBE), - TAO_INVOKE_EXCEPTION); - } - - // This kind of exception shouldn't happen with oneways, - // but if it does, we turn it into a CORBA::UNKNOWN exception. - ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, - CORBA::COMPLETED_YES), - TAO_INVOKE_EXCEPTION); + // Pull the exception from the stream. + CORBA::String_var buf; + + if ((this->inp_stream () >> buf.inout ()) == 0) + { + // Could not demarshal the exception id, raise a local + // CORBA::MARSHAL exception. + ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, + CORBA::COMPLETED_MAYBE), + TAO_INVOKE_EXCEPTION); + } + + // This kind of exception shouldn't happen with oneways, + // but if it does, we turn it into a CORBA::UNKNOWN exception. + ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, + CORBA::COMPLETED_YES), + TAO_INVOKE_EXCEPTION); } case TAO_GIOP_LOC_NEEDS_ADDRESSING_MODE: { - // We have received an exception with a request to change the - // addressing mode. First let us read the mode that the - // server/agent asks for. - CORBA::Short addr_mode = 0; - - if (this->inp_stream ().read_short (addr_mode) == 0) - { - // Could not demarshal the addressing disposition, raise a local - // CORBA::MARSHAL exception. - ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, - CORBA::COMPLETED_MAYBE), - TAO_INVOKE_OK); - } - - // Now set this addressing mode in the stub object, so that - // the next invocation need not go through this. - this->stub_->addressing_mode (addr_mode); - - // Restart the invocation. - return TAO_INVOKE_RESTART; + // We have received an exception with a request to change the + // addressing mode. First let us read the mode that the + // server/agent asks for. + CORBA::Short addr_mode = 0; + + if (this->inp_stream ().read_short (addr_mode) == 0) + { + // Could not demarshal the addressing disposition, raise a local + // CORBA::MARSHAL exception. + ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, + CORBA::COMPLETED_MAYBE), + TAO_INVOKE_OK); + } + + // Now set this addressing mode in the stub object, so that + // the next invocation need not go through this. + this->stub_->addressing_mode (addr_mode); + + // Restart the invocation. + return TAO_INVOKE_RESTART; } } diff --git a/TAO/tao/Invocation.h b/TAO/tao/Invocation.h index 213091a8ed0..e42dce2cb5b 100644 --- a/TAO/tao/Invocation.h +++ b/TAO/tao/Invocation.h @@ -1,4 +1,4 @@ -// This may look like C, but it's really -*- C++ -*- +// This may look like C, but it's really -*- C++ -*- // $Id$ // ============================================================================ @@ -10,31 +10,31 @@ // Invocation.h // // = DESCRIPTION -// Encapsulate the logic for remote invocations, oneways or +// Encapsulate the logic for remote invocations, oneways or // twoways. // // THREADING NOTE: Threads should never manipulate another -// thread's invocations. In this implementation, all data -// structures used to represent invocations (and parts of them) +// thread's invocations. In this implementation, all data +// structures used to represent invocations (and parts of them) // are owned by the thread which created them. Multiple threads -// may make of course concurrent invocations safely, since the +// may make of course concurrent invocations safely, since the // GIOP code is reentrant. // // = AUTHOR -// Carlos O'Ryan <coryan@cs.wustl.edu> and Alexander Babu Arulanthu +// Carlos O'Ryan <coryan@cs.wustl.edu> and Alexander Babu Arulanthu // <alex@cs.wustl.edu> // // ============================================================================ -#ifndef TAO_INVOCATION_H -#define TAO_INVOCATION_H +#ifndef TAO_INVOCATION_H +#define TAO_INVOCATION_H #include "ace/pre.h" #include "tao/CDR.h" #if !defined (ACE_LACKS_PRAGMA_ONCE) # pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ +#endif /* ACE_LACKS_PRAGMA_ONCE */ #include "tao/Any.h" #include "tao/Synch_Reply_Dispatcher.h" @@ -52,10 +52,10 @@ enum TAO_Invoke_Status // invoke() call successful. TAO_INVOKE_RESTART, - // The request must be restarted, a temporary failure has ocurred. + // The request must be restarted, a temporary failure has ocurred. TAO_INVOKE_EXCEPTION - // An exception was raised. + // An exception was raised. }; // **************************************************************** @@ -63,14 +63,14 @@ enum TAO_Invoke_Status class TAO_Export TAO_GIOP_Invocation { // = TITLE - // Encapsulates common behavior for both oneway and twoway - // invocations. + // Encapsulates common behavior for both oneway and twoway + // invocations. // // = DESCRIPTION - // This class connects (or lookups a connection from the cache) - // to the remote server, builds the CDR stream for the Request, - // send the CDR stream and expects the response and interprets - // the incoming CDR stream. + // This class connects (or lookups a connection from the cache) + // to the remote server, builds the CDR stream for the Request, + // send the CDR stream and expects the response and interprets + // the incoming CDR stream. friend class TAO_Endpoint_Selector_Factory; friend class TAO_Default_Endpoint_Selector; @@ -83,149 +83,150 @@ class TAO_Export TAO_GIOP_Invocation public: TAO_GIOP_Invocation (void); - // Default constructor. This should never get called, it is here + // Default constructor. This should never get called, it is here // only to appease older versions of g++. - TAO_GIOP_Invocation (TAO_Stub *data, - const char *operation, - CORBA::ULong opname_len, - TAO_ORB_Core *orb_core); + TAO_GIOP_Invocation (TAO_Stub *data, + const char *operation, + CORBA::ULong opname_len, + CORBA::Boolean argument_flag, + TAO_ORB_Core *orb_core); // Constructor. virtual ~TAO_GIOP_Invocation (void); - // This destructor is virtual so that the derived synchronous - // invocation classes can call <idle> method on the <Transport>, if + // This destructor is virtual so that the derived synchronous + // invocation classes can call <idle> method on the <Transport>, if // they want to. All the synchronous invocations <idle> the - // Transport, but asynchronous invocations do not do that. + // Transport, but asynchronous invocations do not do that. void prepare_header (CORBA::Octet response_flags, - CORBA_Environment &ACE_TRY_ENV = - TAO_default_environment ()) + CORBA_Environment &ACE_TRY_ENV = + TAO_default_environment ()) ACE_THROW_SPEC ((CORBA::SystemException)); - // Initialize the Request header. - // The <message_size> field of the GIOP header is left blank and + // Initialize the Request header. + // The <message_size> field of the GIOP header is left blank and // must be filled later. // The function only returns once a connection has been succesfully - // established *OR* all profiles have been tried. In that case it - // raises the CORBA::TRANSIENT exception. + // established *OR* all profiles have been tried. In that case it + // raises the CORBA::TRANSIENT exception. - IOP::ServiceContextList& service_info (void); + IOP::ServiceContextList& service_info (void); // Accessor to the request ServiceContextList. Only valid when // sending a request message. CORBA::ULong request_id (void); - // Return the request id of this invocation. + // Return the request id of this invocation. - TAO_OutputCDR &out_stream (void); - // Return the underlying output stream. + TAO_OutputCDR &out_stream (void); + // Return the underlying output stream. // CORBA::Boolean restart_flag (void); void restart_flag (CORBA::Boolean flag); // Set the value for the restart flag. int close_connection (void); - // resets the forwarding profile and behaves like we are fowarded + // resets the forwarding profile and behaves like we are fowarded // (to the same server) - void start (CORBA_Environment &ACE_TRY_ENV = - TAO_default_environment ()) + void start (CORBA_Environment &ACE_TRY_ENV = + TAO_default_environment ()) ACE_THROW_SPEC ((CORBA::SystemException)); // Establishes a connection to the remote server, initializes // the GIOP headers in the output CDR. protected: int invoke (CORBA::Boolean is_roundtrip, - CORBA_Environment &ACE_TRY_ENV = - TAO_default_environment ()) + CORBA_Environment &ACE_TRY_ENV = + TAO_default_environment ()) ACE_THROW_SPEC ((CORBA::SystemException)); - // Sends the request, does not wait for the response. - // Returns TAO_INVOKE_RESTART if the write call failed and the + // Sends the request, does not wait for the response. + // Returns TAO_INVOKE_RESTART if the write call failed and the // request must be re-attempted. - // Notice that the same profile is tried again because it may be - // that the server closed the connection simply to release + // Notice that the same profile is tried again because it may be + // that the server closed the connection simply to release // resources. int location_forward (TAO_InputCDR &inp_stream, - CORBA_Environment &ACE_TRY_ENV = - TAO_default_environment ()) + CORBA_Environment &ACE_TRY_ENV = + TAO_default_environment ()) ACE_THROW_SPEC ((CORBA::SystemException)); - // Helper method, the response for a Request or LocateRequest was a + // Helper method, the response for a Request or LocateRequest was a // LOCATION_FORWARD or TAO_GIOP_OBJECT_FORWARD. - // In any case we must demarshal the object reference and setup the + // In any case we must demarshal the object reference and setup the // profiles. - // It returns TAO_INVOKE_RESTART unless an exception is raised. + // It returns TAO_INVOKE_RESTART unless an exception is raised. CORBA::ULong create_ior_info (void); - // Create the IOP::IOR info. We will create the info atmost - // once. This method will not work for RTCorba - Bala + // Create the IOP::IOR info. We will create the info atmost + // once. This method will not work for RTCorba - Bala void add_rt_service_context (CORBA_Environment &ACE_TRY_ENV = - TAO_default_environment ()); - // Add RT-related context to the service context list if the - // invocation target supports RTCORBA::CLIENT_PROPAGATED priority - // model. + TAO_default_environment ()); + // Add RT-related context to the service context list if the + // invocation target supports RTCORBA::CLIENT_PROPAGATED priority + // model. protected: TAO_Stub *stub_; - // The object on which this invocation is going. + // The object on which this invocation is going. char buffer_ [ACE_CDR::DEFAULT_BUFSIZE]; // Buffer used for both the output and input CDR streams, this is - // "safe" because we only one of the streams at a time. + // "safe" because we only one of the streams at a time. - TAO_Operation_Details op_details_; + TAO_Operation_Details op_details_; // The relevant operation detail TAO_Target_Specification target_spec_; - TAO_OutputCDR out_stream_; + TAO_OutputCDR out_stream_; // Stream into which the response is placed. - TAO_ORB_Core* orb_core_; - // The orb_core context where we make this invocation. + TAO_ORB_Core* orb_core_; + // The orb_core context where we make this invocation. - TAO_Transport *transport_; - // This invocation is using this transport, may change... + TAO_Transport *transport_; + // This invocation is using this transport, may change... TAO_Invocation_Endpoint_Selector *endpoint_selector_; - // Strategy for making decisions about which endpoint/profile to use + // Strategy for making decisions about which endpoint/profile to use // for invocation. int is_selector_initialized_; // Flag indicating whether <endpoint_selector_> has been - // initialized. + // initialized. #if (TAO_HAS_RT_CORBA == 1) TAO_Endpoint_Selection_State endpoint_selection_state_; - // Store information used by <endpoint_selector_> for making - // endpoint selection decisions. + // Store information used by <endpoint_selector_> for making + // endpoint selection decisions. -#endif /* TAO_HAS_RT_CORBA == 1 */ +#endif /* TAO_HAS_RT_CORBA == 1 */ TAO_Profile *profile_; - // This invocation is using this profile. + // This invocation is using this profile. TAO_Endpoint *endpoint_; - // This invocation is using this endpoint from <profile_>. + // This invocation is using this endpoint from <profile_>. ACE_Time_Value max_wait_time_value_; ACE_Time_Value *max_wait_time_; - // The timeout remaining for this request, it is initialized in + // The timeout remaining for this request, it is initialized in // start() and updated as required. IOP::IOR ior_info_; - // The ior info. This would be needed for GIOP 1.2, as the clients - // could receive an exception from the server asking for this + // The ior info. This would be needed for GIOP 1.2, as the clients + // could receive an exception from the server asking for this // info. The exception that the client receives is - // LOC_NEEDS_ADDRESSING_MODE. If we receive an exception we will - // fill up this data atmost *once* and send it to the server. + // LOC_NEEDS_ADDRESSING_MODE. If we receive an exception we will + // fill up this data atmost *once* and send it to the server. int rt_context_initialized_; // Flag indicating whether RTCORBA-specific service context list - // processing has taken place. This is needed because + // processing has taken place. This is needed because // <prepare_header> may get called multiple times, but we only need - // to do the service context list processing once. + // to do the service context list processing once. CORBA::Boolean restart_flag_; // This flag is turned on when the previous invocation on an @@ -239,36 +240,37 @@ protected: class TAO_Export TAO_GIOP_Synch_Invocation : public TAO_GIOP_Invocation { // = TITLE - // TAO_GIOP_Synch_Invocation. + // TAO_GIOP_Synch_Invocation. // // = DESCRIPTION - // Base class for TAO_GIOP_Twoway_Invocation and - // TAO_GIOP_Oneway_Invocation. + // Base class for TAO_GIOP_Twoway_Invocation and + // TAO_GIOP_Oneway_Invocation. // public: TAO_GIOP_Synch_Invocation (void); - // Default constructor. This should never get called, it is here + // Default constructor. This should never get called, it is here // only to appease older versions of g++. TAO_GIOP_Synch_Invocation (TAO_Stub *stub, - const char *operation, - CORBA::ULong opname_len, - TAO_ORB_Core *orb_core); + const char *operation, + CORBA::ULong opname_len, + CORBA::Boolean argument_flag, + TAO_ORB_Core *orb_core); // Constructor. virtual ~TAO_GIOP_Synch_Invocation (void); // Destructor. TAO_InputCDR &inp_stream (void); - // Return the underlying input stream. Called by the stub to demarshal - // the results of the upcall into whatever return arguments there may be. + // Return the underlying input stream. Called by the stub to demarshal + // the results of the upcall into whatever return arguments there may be. protected: int invoke_i (CORBA::Boolean is_locate_request, - CORBA::Environment &ACE_TRY_ENV) + CORBA::Environment &ACE_TRY_ENV) ACE_THROW_SPEC ((CORBA::SystemException)); // Implementation of the invoke() methods, handles the basic - // send/reply code and the system exceptions. + // send/reply code and the system exceptions. TAO_Synch_Reply_Dispatcher rd_; // Reply dispatcher for the current synchronous invocation. @@ -276,77 +278,79 @@ protected: // **************************************************************** -class TAO_Export TAO_GIOP_Twoway_Invocation +class TAO_Export TAO_GIOP_Twoway_Invocation : public TAO_GIOP_Synch_Invocation { // = TITLE - // TAO_GIOP_Twoway_Invocation. + // TAO_GIOP_Twoway_Invocation. // // = DESCRIPTION - // Sends a two-way request, and expects the reply. - // This class connects (or lookups a connection from the cache) to - // the remote server, builds the CDR stream for the Request, send - // the CDR stream and expects the response and interprets the - // incoming CDR stream. + // Sends a two-way request, and expects the reply. + // This class connects (or lookups a connection from the cache) to + // the remote server, builds the CDR stream for the Request, send + // the CDR stream and expects the response and interprets the + // incoming CDR stream. // public: TAO_GIOP_Twoway_Invocation (TAO_Stub *stub, - const char *operation, - CORBA::ULong opname_len, - TAO_ORB_Core *orb_core); + const char *operation, + CORBA::ULong opname_len, + CORBA::Boolean argument_flag, + TAO_ORB_Core *orb_core); // Constructor. virtual ~TAO_GIOP_Twoway_Invocation (void); // Destructor. - void start (CORBA_Environment &ACE_TRY_ENV = - TAO_default_environment ()) + void start (CORBA_Environment &ACE_TRY_ENV = + TAO_default_environment ()) ACE_THROW_SPEC ((CORBA::SystemException)); // Establishes a connection to the remote server, initializes // the GIOP headers in the output CDR. int invoke (TAO_Exception_Data *excepts, - CORBA::ULong except_count, - CORBA_Environment &ACE_TRY_ENV = - TAO_default_environment ()) + CORBA::ULong except_count, + CORBA_Environment &ACE_TRY_ENV = + TAO_default_environment ()) ACE_THROW_SPEC ((CORBA::Exception)); - // Special purpose invoke method used by the generated stubs. This - // accomplishes the same task as the normal invoke except that - // Exceptions are allocated and decoded here. This reduces the - // footprint of the generated stubs. + // Special purpose invoke method used by the generated stubs. This + // accomplishes the same task as the normal invoke except that + // Exceptions are allocated and decoded here. This reduces the + // footprint of the generated stubs. }; // **************************************************************** -class TAO_Export TAO_GIOP_Oneway_Invocation +class TAO_Export TAO_GIOP_Oneway_Invocation : public TAO_GIOP_Synch_Invocation { // = TITLE - // TAO_GIOP_Oneway_Invocation + // TAO_GIOP_Oneway_Invocation // // = DESCRIPTION - // Sends a oneway request. + // Sends a oneway request. // public: TAO_GIOP_Oneway_Invocation (TAO_Stub *stub, - const char *operation, - CORBA::ULong opname_len, - TAO_ORB_Core *orb_core); + const char *operation, + CORBA::ULong opname_len, + CORBA::Boolean argument_flag, + TAO_ORB_Core *orb_core); // Constructor. virtual ~TAO_GIOP_Oneway_Invocation (void); // Destructor. - void start (CORBA_Environment &ACE_TRY_ENV = - TAO_default_environment ()) + void start (CORBA_Environment &ACE_TRY_ENV = + TAO_default_environment ()) ACE_THROW_SPEC ((CORBA::SystemException)); // Establishes a connection to the remote server, initializes // the GIOP headers in the output CDR. - int invoke (CORBA_Environment &ACE_TRY_ENV = - TAO_default_environment ()) + int invoke (CORBA_Environment &ACE_TRY_ENV = + TAO_default_environment ()) ACE_THROW_SPEC ((CORBA::SystemException)); - // Send request, without blocking for any response. + // Send request, without blocking for any response. TAO::SyncScope sync_scope (void); // Acessor for private member. @@ -357,7 +361,7 @@ private: // **************************************************************** -class TAO_Export TAO_GIOP_Locate_Request_Invocation +class TAO_Export TAO_GIOP_Locate_Request_Invocation : public TAO_GIOP_Synch_Invocation { // = TITLE @@ -365,22 +369,22 @@ class TAO_Export TAO_GIOP_Locate_Request_Invocation // public: TAO_GIOP_Locate_Request_Invocation (TAO_Stub *data, - TAO_ORB_Core *orb_core); + TAO_ORB_Core *orb_core); // Constructor. ~TAO_GIOP_Locate_Request_Invocation (void); // Destructor. - void start (CORBA_Environment &ACE_TRY_ENV = - TAO_default_environment ()) + void start (CORBA_Environment &ACE_TRY_ENV = + TAO_default_environment ()) ACE_THROW_SPEC ((CORBA::SystemException)); // Establishes a connection to the remote server, initializes // the GIOP headers in the output CDR. - int invoke (CORBA_Environment &ACE_TRY_ENV = - TAO_default_environment ()) + int invoke (CORBA_Environment &ACE_TRY_ENV = + TAO_default_environment ()) ACE_THROW_SPEC ((CORBA::SystemException)); - // Send request, without blocking for any response. + // Send request, without blocking for any response. }; // **************************************************************** diff --git a/TAO/tao/Invocation.i b/TAO/tao/Invocation.i index fde2229f09c..af4c16b81bf 100644 --- a/TAO/tao/Invocation.i +++ b/TAO/tao/Invocation.i @@ -1,4 +1,4 @@ -// This may look like C, but it's really -*- C++ -*- +// This may look like C, but it's really -*- C++ -*- // // $Id$ // @@ -6,17 +6,17 @@ ACE_INLINE IOP::ServiceContextList & TAO_GIOP_Invocation::service_info (void) { - return this->op_details_.service_info (); + return this->op_details_.service_info (); } ACE_INLINE CORBA::ULong -TAO_GIOP_Invocation::request_id (void) +TAO_GIOP_Invocation::request_id (void) { return this->op_details_.request_id (); } ACE_INLINE TAO_OutputCDR & -TAO_GIOP_Invocation::out_stream (void) +TAO_GIOP_Invocation::out_stream (void) { return this->out_stream_; } @@ -25,7 +25,7 @@ ACE_INLINE void TAO_GIOP_Invocation::restart_flag (CORBA::Boolean flag) { // Set the flag - this->restart_flag_ = flag; + this->restart_flag_ = flag; } // **************************************************************** @@ -35,18 +35,20 @@ TAO_GIOP_Synch_Invocation::TAO_GIOP_Synch_Invocation ( TAO_Stub *stub, const char *operation, CORBA::ULong opname_len, + CORBA::Boolean argument_flag, TAO_ORB_Core *orb_core ) - : TAO_GIOP_Invocation (stub, - operation, - opname_len, + : TAO_GIOP_Invocation (stub, + operation, + opname_len, + argument_flag, orb_core), - rd_ (orb_core, - this->op_details_.service_info ()) + rd_ (orb_core, + this->op_details_.service_info ()) { } -ACE_INLINE TAO_InputCDR & +ACE_INLINE TAO_InputCDR & TAO_GIOP_Synch_Invocation::inp_stream (void) { return this->rd_.reply_cdr (); @@ -59,24 +61,26 @@ TAO_GIOP_Twoway_Invocation::TAO_GIOP_Twoway_Invocation ( TAO_Stub *stub, const char *operation, CORBA::ULong opname_len, + CORBA::Boolean argument_flag, TAO_ORB_Core *orb_core ) - : TAO_GIOP_Synch_Invocation (stub, - operation, - opname_len, + : TAO_GIOP_Synch_Invocation (stub, + operation, + opname_len, + argument_flag, orb_core) { } ACE_INLINE -TAO_GIOP_Twoway_Invocation::~TAO_GIOP_Twoway_Invocation (void) +TAO_GIOP_Twoway_Invocation::~TAO_GIOP_Twoway_Invocation (void) { } // **************************************************************** ACE_INLINE -TAO_GIOP_Oneway_Invocation::~TAO_GIOP_Oneway_Invocation (void) +TAO_GIOP_Oneway_Invocation::~TAO_GIOP_Oneway_Invocation (void) { } @@ -91,16 +95,16 @@ TAO_GIOP_Oneway_Invocation::sync_scope (void) ACE_INLINE TAO_GIOP_Locate_Request_Invocation:: TAO_GIOP_Locate_Request_Invocation (TAO_Stub *stub, - TAO_ORB_Core *orb_core) - : TAO_GIOP_Synch_Invocation (stub, - 0, - 0, + TAO_ORB_Core *orb_core) + : TAO_GIOP_Synch_Invocation (stub, + 0, + 0, + 0, orb_core) { } ACE_INLINE -TAO_GIOP_Locate_Request_Invocation::~TAO_GIOP_Locate_Request_Invocation (void) +TAO_GIOP_Locate_Request_Invocation::~TAO_GIOP_Locate_Request_Invocation (void) { } - diff --git a/TAO/tao/Pluggable_Messaging_Utils.h b/TAO/tao/Pluggable_Messaging_Utils.h index a9057a1fe36..d6c96cbfc93 100644 --- a/TAO/tao/Pluggable_Messaging_Utils.h +++ b/TAO/tao/Pluggable_Messaging_Utils.h @@ -74,9 +74,13 @@ public: // a service context list and would like to pass on their contents // without a copy. + CORBA::Boolean argument_flag_; + // A flag that indicates if there is any data is going to get + // marshalled in the reply + private: IOP::ServiceContextList *service_context_; - // The service context list that we don't own. + // The service context list that we don't own. }; // @@ Bala: this is a GIOPism too, there is no such thing as locate diff --git a/TAO/tao/PolicyC.cpp b/TAO/tao/PolicyC.cpp index b042108953e..aeee1ce9ffe 100644 --- a/TAO/tao/PolicyC.cpp +++ b/TAO/tao/PolicyC.cpp @@ -1,11 +1,11 @@ /* -*- C++ -*- $Id$ */ -// ****** Code generated by the The ACE ORB (TAO) IDL Compiler ******* -// TAO and the TAO IDL Compiler have been developed by the Center for -// Distributed Object Computing at Washington University, St. Louis. +// ****** Code generated by the The ACE ORB (TAO) IDL Compiler ******* +// TAO and the TAO IDL Compiler have been developed by the Center for +// Distributed Object Computing at Washington University, St. Louis. // // Information about TAO is available at: -// http://www.cs.wustl.edu/~schmidt/TAO.html +// http://www.cs.wustl.edu/~schmidt/TAO.html #include "tao/PolicyC.h" #include "tao/Stub.h" @@ -19,11 +19,11 @@ TAO_NAMESPACE_TYPE (const CORBA::PolicyErrorCode) TAO_NAMESPACE_BEGIN (CORBA) -TAO_NAMESPACE_DEFINE (const CORBA::PolicyErrorCode, BAD_POLICY, 0) +TAO_NAMESPACE_DEFINE (const CORBA::PolicyErrorCode, BAD_POLICY, 0) TAO_NAMESPACE_END TAO_NAMESPACE_TYPE (const CORBA::PolicyErrorCode) TAO_NAMESPACE_BEGIN (CORBA) -TAO_NAMESPACE_DEFINE (const CORBA::PolicyErrorCode, UNSUPPORTED_POLICY, 1) +TAO_NAMESPACE_DEFINE (const CORBA::PolicyErrorCode, UNSUPPORTED_POLICY, 1) TAO_NAMESPACE_END TAO_NAMESPACE_TYPE (const CORBA::PolicyErrorCode) TAO_NAMESPACE_BEGIN (CORBA) @@ -42,11 +42,11 @@ TAO_NAMESPACE_END // default constructor CORBA_PolicyError::CORBA_PolicyError (void) - : CORBA_UserException ("IDL:omg.org/CORBA/PolicyError:1.0") + : CORBA_UserException ("IDL:omg.org/CORBA/PolicyError:1.0") { } -// destructor - all members are of self managing types +// destructor - all members are of self managing types CORBA_PolicyError::~CORBA_PolicyError (void) { } @@ -57,16 +57,16 @@ void CORBA_PolicyError::_tao_any_destructor (void *x) delete tmp; } -// copy constructor -CORBA_PolicyError::CORBA_PolicyError (const ::CORBA_PolicyError &_tao_excp) - : CORBA_UserException (_tao_excp._id ()) +// copy constructor +CORBA_PolicyError::CORBA_PolicyError (const ::CORBA_PolicyError &_tao_excp) + : CORBA_UserException (_tao_excp._id ()) { this->reason = _tao_excp.reason; } // assignment operator CORBA_PolicyError& -CORBA_PolicyError::operator= (const ::CORBA_PolicyError &_tao_excp) +CORBA_PolicyError::operator= (const ::CORBA_PolicyError &_tao_excp) { this->CORBA_UserException::operator= (_tao_excp); @@ -121,122 +121,122 @@ CORBA::Exception *CORBA_PolicyError::_alloc (void) CORBA_PolicyError::CORBA_PolicyError ( CORBA::PolicyErrorCode _tao_reason ) - : CORBA_UserException (CORBA::string_dup ("IDL:omg.org/CORBA/PolicyError:1.0")) + : CORBA_UserException (CORBA::string_dup ("IDL:omg.org/CORBA/PolicyError:1.0")) { this->reason = _tao_reason; } static const CORBA::Long _oc_CORBA_PolicyError[] = { - TAO_ENCAP_BYTE_ORDER, // byte order - 34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x415f506f), ACE_NTOHL (0x6c696379), ACE_NTOHL (0x4572726f), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000), // repository ID = IDL:omg.org/CORBA_PolicyError:1.0 - 18, ACE_NTOHL (0x434f5242), ACE_NTOHL (0x415f506f), ACE_NTOHL (0x6c696379), ACE_NTOHL (0x4572726f), ACE_NTOHL (0x72000000), // name = CORBA_PolicyError - 1, // member count - 7, ACE_NTOHL (0x72656173), ACE_NTOHL (0x6f6e0000), // name = reason - CORBA::tk_alias, // typecode kind for typedefs + TAO_ENCAP_BYTE_ORDER, // byte order + 34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x415f506f), ACE_NTOHL (0x6c696379), ACE_NTOHL (0x4572726f), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000), // repository ID = IDL:omg.org/CORBA_PolicyError:1.0 + 18, ACE_NTOHL (0x434f5242), ACE_NTOHL (0x415f506f), ACE_NTOHL (0x6c696379), ACE_NTOHL (0x4572726f), ACE_NTOHL (0x72000000), // name = CORBA_PolicyError + 1, // member count + 7, ACE_NTOHL (0x72656173), ACE_NTOHL (0x6f6e0000), // name = reason + CORBA::tk_alias, // typecode kind for typedefs 72, // encapsulation length TAO_ENCAP_BYTE_ORDER, // byte order - 38, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f506f), ACE_NTOHL (0x6c696379), ACE_NTOHL (0x4572726f), ACE_NTOHL (0x72436f64), ACE_NTOHL (0x653a312e), ACE_NTOHL (0x30000000), // repository ID = IDL:omg.org/CORBA/PolicyErrorCode:1.0 - 16, ACE_NTOHL (0x506f6c69), ACE_NTOHL (0x63794572), ACE_NTOHL (0x726f7243), ACE_NTOHL (0x6f646500), // name = PolicyErrorCode + 38, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f506f), ACE_NTOHL (0x6c696379), ACE_NTOHL (0x4572726f), ACE_NTOHL (0x72436f64), ACE_NTOHL (0x653a312e), ACE_NTOHL (0x30000000), // repository ID = IDL:omg.org/CORBA/PolicyErrorCode:1.0 + 16, ACE_NTOHL (0x506f6c69), ACE_NTOHL (0x63794572), ACE_NTOHL (0x726f7243), ACE_NTOHL (0x6f646500), // name = PolicyErrorCode CORBA::tk_short, }; -static CORBA::TypeCode _tc_TAO_tc_CORBA_PolicyError (CORBA::tk_except, sizeof (_oc_CORBA_PolicyError), (char *) &_oc_CORBA_PolicyError, 0, sizeof (CORBA_PolicyError)); +static CORBA::TypeCode _tc_TAO_tc_CORBA_PolicyError (CORBA::tk_except, sizeof (_oc_CORBA_PolicyError), (char *) &_oc_CORBA_PolicyError, 0, sizeof (CORBA_PolicyError)); CORBA::TypeCode_ptr _tc_CORBA_PolicyError = &_tc_TAO_tc_CORBA_PolicyError; CORBA::TypeCode_ptr -CORBA_PolicyError::_type (void) const +CORBA_PolicyError::_type (void) const { return _tc_CORBA_PolicyError; } #if !defined (TAO_USE_SEQUENCE_TEMPLATES) - + #if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_INVALIDPOLICIES__TAO_SEQ_USHORT_CS_) -#define __TAO_UNBOUNDED_SEQUENCE_CORBA_INVALIDPOLICIES__TAO_SEQ_USHORT_CS_ +#define __TAO_UNBOUNDED_SEQUENCE_CORBA_INVALIDPOLICIES__TAO_SEQ_USHORT_CS_ void CORBA_InvalidPolicies::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::_allocate_buffer (CORBA::ULong length) { CORBA::UShort* tmp = 0; - tmp = _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::allocbuf (length); - + tmp = _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::allocbuf (length); + if (this->buffer_ != 0) { - CORBA::UShort *old = ACE_reinterpret_cast (CORBA::UShort *,this->buffer_); - - for (CORBA::ULong i = 0; i < this->length_; ++i) - tmp[i] = old[i]; - + CORBA::UShort *old = ACE_reinterpret_cast (CORBA::UShort *,this->buffer_); + + for (CORBA::ULong i = 0; i < this->length_; ++i) + tmp[i] = old[i]; + if (this->release_) - _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::freebuf (old); - + _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::freebuf (old); + } this->buffer_ = tmp; } - + void CORBA_InvalidPolicies::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::_deallocate_buffer (void) { - if (this->buffer_ == 0 || this->release_ == 0) + if (this->buffer_ == 0 || this->release_ == 0) return; - + CORBA::UShort *tmp = ACE_reinterpret_cast (CORBA::UShort *,this->buffer_); - + _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::freebuf (tmp); this->buffer_ = 0; - } - + } + CORBA_InvalidPolicies::_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort::~_TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort (void) // Dtor. { this->_deallocate_buffer (); } - - + + #endif /* end #if !defined */ -#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ #if !defined (_CORBA_INVALIDPOLICIES__TAO_SEQ_USHORT_CS_) -#define _CORBA_INVALIDPOLICIES__TAO_SEQ_USHORT_CS_ +#define _CORBA_INVALIDPOLICIES__TAO_SEQ_USHORT_CS_ // ************************************************************* // CORBA_InvalidPolicies::_tao_seq_UShort // ************************************************************* -CORBA_InvalidPolicies::_tao_seq_UShort::_tao_seq_UShort (void) +CORBA_InvalidPolicies::_tao_seq_UShort::_tao_seq_UShort (void) {} -CORBA_InvalidPolicies::_tao_seq_UShort::_tao_seq_UShort (CORBA::ULong max) // uses max size - : +CORBA_InvalidPolicies::_tao_seq_UShort::_tao_seq_UShort (CORBA::ULong max) // uses max size + : #if !defined (TAO_USE_SEQUENCE_TEMPLATES) _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort #else /* TAO_USE_SEQUENCE_TEMPLATES */ TAO_Unbounded_Sequence<CORBA::UShort> -#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ (max) {} -CORBA_InvalidPolicies::_tao_seq_UShort::_tao_seq_UShort (CORBA::ULong max, CORBA::ULong length, CORBA::UShort *buffer, CORBA::Boolean release) - : +CORBA_InvalidPolicies::_tao_seq_UShort::_tao_seq_UShort (CORBA::ULong max, CORBA::ULong length, CORBA::UShort *buffer, CORBA::Boolean release) + : #if !defined (TAO_USE_SEQUENCE_TEMPLATES) _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort #else /* TAO_USE_SEQUENCE_TEMPLATES */ TAO_Unbounded_Sequence<CORBA::UShort> -#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ (max, length, buffer, release) {} -CORBA_InvalidPolicies::_tao_seq_UShort::_tao_seq_UShort (const _tao_seq_UShort &seq) // copy ctor - : +CORBA_InvalidPolicies::_tao_seq_UShort::_tao_seq_UShort (const _tao_seq_UShort &seq) // copy ctor + : #if !defined (TAO_USE_SEQUENCE_TEMPLATES) _TAO_Unbounded_Sequence_CORBA_InvalidPolicies__tao_seq_UShort #else /* TAO_USE_SEQUENCE_TEMPLATES */ TAO_Unbounded_Sequence<CORBA::UShort> -#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ (seq) {} -CORBA_InvalidPolicies::_tao_seq_UShort::~_tao_seq_UShort (void) // dtor +CORBA_InvalidPolicies::_tao_seq_UShort::~_tao_seq_UShort (void) // dtor {} void CORBA_InvalidPolicies::_tao_seq_UShort::_tao_any_destructor (void *x) { @@ -249,35 +249,35 @@ void CORBA_InvalidPolicies::_tao_seq_UShort::_tao_any_destructor (void *x) // default constructor CORBA_InvalidPolicies::CORBA_InvalidPolicies (void) - : CORBA_UserException ("IDL:omg.org/CORBA/InvalidPolicies:1.0") + : CORBA_UserException ("IDL:omg.org/CORBA/InvalidPolicies:1.0") { } -// destructor - all members are of self managing types +// destructor - all members are of self managing types CORBA_InvalidPolicies::~CORBA_InvalidPolicies (void) { } -void CORBA_InvalidPolicies::_tao_any_destructor (void *x) +void CORBA_InvalidPolicies::_tao_any_destructor (void *x) { - CORBA_InvalidPolicies *tmp = ACE_static_cast (CORBA_InvalidPolicies*,x); + CORBA_InvalidPolicies *tmp = ACE_static_cast (CORBA_InvalidPolicies*,x); delete tmp; } -// copy constructor +// copy constructor CORBA_InvalidPolicies::CORBA_InvalidPolicies (const ::CORBA_InvalidPolicies &_tao_excp) - : CORBA_UserException (_tao_excp._id ()) + : CORBA_UserException (_tao_excp._id ()) { this->indices = _tao_excp.indices; } // assignment operator CORBA_InvalidPolicies& -CORBA_InvalidPolicies::operator= (const ::CORBA_InvalidPolicies &_tao_excp) +CORBA_InvalidPolicies::operator= (const ::CORBA_InvalidPolicies &_tao_excp) { this->CORBA_UserException::operator= (_tao_excp); - this->indices = _tao_excp.indices; + this->indices = _tao_excp.indices; return *this; } @@ -285,7 +285,7 @@ CORBA_InvalidPolicies::operator= (const ::CORBA_InvalidPolicies &_tao_excp) CORBA_InvalidPolicies * CORBA_InvalidPolicies::_downcast (CORBA::Exception *exc) { - if (!ACE_OS::strcmp ("IDL:omg.org/CORBA/InvalidPolicies:1.0", exc->_id ())) // same type + if (!ACE_OS::strcmp ("IDL:omg.org/CORBA/InvalidPolicies:1.0", exc->_id ())) // same type return ACE_dynamic_cast (CORBA_InvalidPolicies *, exc); else return 0; @@ -298,7 +298,7 @@ void CORBA_InvalidPolicies::_raise () } -void CORBA_InvalidPolicies::_tao_encode ( +void CORBA_InvalidPolicies::_tao_encode ( TAO_OutputCDR &cdr, CORBA::Environment &ACE_TRY_ENV) const { @@ -308,7 +308,7 @@ void CORBA_InvalidPolicies::_tao_encode ( } -void CORBA_InvalidPolicies::_tao_decode ( +void CORBA_InvalidPolicies::_tao_decode ( TAO_InputCDR &cdr, CORBA::Environment &ACE_TRY_ENV) { @@ -318,7 +318,7 @@ void CORBA_InvalidPolicies::_tao_decode ( } // TAO extension - the _alloc method -CORBA::Exception *CORBA_InvalidPolicies::_alloc (void) +CORBA::Exception *CORBA_InvalidPolicies::_alloc (void) { CORBA::Exception *retval = 0; ACE_NEW_RETURN (retval, ::CORBA_InvalidPolicies, 0); @@ -326,20 +326,20 @@ CORBA::Exception *CORBA_InvalidPolicies::_alloc (void) } CORBA_InvalidPolicies::CORBA_InvalidPolicies ( - const CORBA_InvalidPolicies::_tao_seq_UShort & _tao_indices + const CORBA_InvalidPolicies::_tao_seq_UShort & _tao_indices ) - : CORBA_UserException (CORBA::string_dup ("IDL:omg.org/CORBA/InvalidPolicies:1.0")) + : CORBA_UserException (CORBA::string_dup ("IDL:omg.org/CORBA/InvalidPolicies:1.0")) { this->indices = _tao_indices; } static const CORBA::Long _oc_CORBA_InvalidPolicies[] = { - TAO_ENCAP_BYTE_ORDER, // byte order - 38, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x415f496e), ACE_NTOHL (0x76616c69), ACE_NTOHL (0x64506f6c), ACE_NTOHL (0x69636965), ACE_NTOHL (0x733a312e), ACE_NTOHL (0x30000000), // repository ID = IDL:omg.org/CORBA_InvalidPolicies:1.0 - 22, ACE_NTOHL (0x434f5242), ACE_NTOHL (0x415f496e), ACE_NTOHL (0x76616c69), ACE_NTOHL (0x64506f6c), ACE_NTOHL (0x69636965), ACE_NTOHL (0x73000000), // name = CORBA_InvalidPolicies - 1, // member count - 8, ACE_NTOHL (0x696e6469), ACE_NTOHL (0x63657300), // name = indices + TAO_ENCAP_BYTE_ORDER, // byte order + 38, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x415f496e), ACE_NTOHL (0x76616c69), ACE_NTOHL (0x64506f6c), ACE_NTOHL (0x69636965), ACE_NTOHL (0x733a312e), ACE_NTOHL (0x30000000), // repository ID = IDL:omg.org/CORBA_InvalidPolicies:1.0 + 22, ACE_NTOHL (0x434f5242), ACE_NTOHL (0x415f496e), ACE_NTOHL (0x76616c69), ACE_NTOHL (0x64506f6c), ACE_NTOHL (0x69636965), ACE_NTOHL (0x73000000), // name = CORBA_InvalidPolicies + 1, // member count + 8, ACE_NTOHL (0x696e6469), ACE_NTOHL (0x63657300), // name = indices CORBA::tk_sequence, // typecode kind 12, // encapsulation length TAO_ENCAP_BYTE_ORDER, // byte order @@ -348,8 +348,8 @@ static const CORBA::Long _oc_CORBA_InvalidPolicies[] = 0U, }; -static CORBA::TypeCode _tc_TAO_tc_CORBA_InvalidPolicies (CORBA::tk_except, sizeof (_oc_CORBA_InvalidPolicies), (char *) &_oc_CORBA_InvalidPolicies, 0, sizeof (CORBA_InvalidPolicies)); -CORBA::TypeCode_ptr _tc_CORBA_InvalidPolicies = &_tc_TAO_tc_CORBA_InvalidPolicies; +static CORBA::TypeCode _tc_TAO_tc_CORBA_InvalidPolicies (CORBA::tk_except, sizeof (_oc_CORBA_InvalidPolicies), (char *) &_oc_CORBA_InvalidPolicies, 0, sizeof (CORBA_InvalidPolicies)); +CORBA::TypeCode_ptr _tc_CORBA_InvalidPolicies = &_tc_TAO_tc_CORBA_InvalidPolicies; CORBA::TypeCode_ptr CORBA_InvalidPolicies::_type (void) const @@ -378,12 +378,12 @@ CORBA_Policy_ptr CORBA_Policy::_narrow ( { if (CORBA::is_nil (obj)) return CORBA_Policy::_nil (); - if (! obj->_is_local ()) + if (! obj->_is_local ()) { - CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/Policy:1.0", ACE_TRY_ENV); + CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/Policy:1.0", ACE_TRY_ENV); ACE_CHECK_RETURN (CORBA_Policy::_nil ()); if (is_a == 0) - return CORBA_Policy::_nil (); + return CORBA_Policy::_nil (); } return CORBA_Policy::_unchecked_narrow (obj, ACE_TRY_ENV); } @@ -395,35 +395,35 @@ CORBA_Policy_ptr CORBA_Policy::_unchecked_narrow ( { if (CORBA::is_nil (obj)) return CORBA_Policy::_nil (); - if (! obj->_is_local ()) + if (! obj->_is_local ()) { - TAO_Stub* stub = obj->_stubobj (); + TAO_Stub* stub = obj->_stubobj (); if (stub) - stub->_incr_refcnt (); + stub->_incr_refcnt (); CORBA_Policy_ptr default_proxy = CORBA_Policy::_nil (); - if (obj->_is_collocated () && _TAO_collocation_CORBA_Policy_Stub_Factory_function_pointer != 0) - { - default_proxy = _TAO_collocation_CORBA_Policy_Stub_Factory_function_pointer (obj); - } - if (CORBA::is_nil (default_proxy)) - ACE_NEW_RETURN (default_proxy, CORBA_Policy (stub), CORBA_Policy::_nil ()); - return default_proxy; + if (obj->_is_collocated () && _TAO_collocation_CORBA_Policy_Stub_Factory_function_pointer != 0) + { + default_proxy = _TAO_collocation_CORBA_Policy_Stub_Factory_function_pointer (obj); + } + if (CORBA::is_nil (default_proxy)) + ACE_NEW_RETURN (default_proxy, CORBA_Policy (stub), CORBA_Policy::_nil ()); + return default_proxy; } - else + else return ACE_reinterpret_cast - ( - CORBA_Policy_ptr, - obj->_tao_QueryInterface - ( - ACE_reinterpret_cast - ( - ptr_arith_t, - &CORBA_Policy::_narrow - ) - ) - ); + ( + CORBA_Policy_ptr, + obj->_tao_QueryInterface + ( + ACE_reinterpret_cast + ( + ptr_arith_t, + &CORBA_Policy::_narrow + ) + ) + ); } CORBA_Policy_ptr @@ -441,51 +441,52 @@ CORBA::PolicyType CORBA_Policy::policy_type ( CORBA::SystemException )) { - - CORBA::PolicyType _tao_retval = 0; - - + + CORBA::PolicyType _tao_retval = 0; + + TAO_Stub *istub = this->_stubobj (); if (istub == 0) ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval); - + TAO_GIOP_Twoway_Invocation _tao_call ( istub, "_get_policy_type", 16, + 0, istub->orb_core () ); for (;;) { - _tao_call.start (ACE_TRY_ENV); - ACE_CHECK_RETURN (_tao_retval); - - CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; - - _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); - ACE_CHECK_RETURN (_tao_retval); - - int _invoke_status = - _tao_call.invoke (0, 0, ACE_TRY_ENV); - ACE_CHECK_RETURN (_tao_retval); - - if (_invoke_status == TAO_INVOKE_RESTART) - continue; - if (_invoke_status != TAO_INVOKE_OK) - { - ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval); - - } - TAO_InputCDR &_tao_in = _tao_call.inp_stream (); - if (!( - (_tao_in >> _tao_retval) - )) - ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval); - - break; - + _tao_call.start (ACE_TRY_ENV); + ACE_CHECK_RETURN (_tao_retval); + + CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; + + _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); + ACE_CHECK_RETURN (_tao_retval); + + int _invoke_status = + _tao_call.invoke (0, 0, ACE_TRY_ENV); + ACE_CHECK_RETURN (_tao_retval); + + if (_invoke_status == TAO_INVOKE_RESTART) + continue; + if (_invoke_status != TAO_INVOKE_OK) + { + ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval); + + } + TAO_InputCDR &_tao_in = _tao_call.inp_stream (); + if (!( + (_tao_in >> _tao_retval) + )) + ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval); + + break; + } return _tao_retval; } @@ -497,54 +498,55 @@ CORBA_Policy_ptr CORBA_Policy::copy ( CORBA::SystemException )) { - + CORBA_Policy_ptr _tao_retval = CORBA_Policy::_nil (); CORBA_Policy_var _tao_safe_retval (_tao_retval); - - + + TAO_Stub *istub = this->_stubobj (); if (istub == 0) ACE_THROW_RETURN (CORBA::INTERNAL (), 0); - + TAO_GIOP_Twoway_Invocation _tao_call ( istub, "copy", 4, + 0, istub->orb_core () ); for (;;) { - _tao_call.start (ACE_TRY_ENV); - ACE_CHECK_RETURN (0); - - CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; - - _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); - ACE_CHECK_RETURN (0); - - int _invoke_status = - _tao_call.invoke (0, 0, ACE_TRY_ENV); - ACE_CHECK_RETURN (0); - - if (_invoke_status == TAO_INVOKE_RESTART) - continue; - if (_invoke_status != TAO_INVOKE_OK) - { - ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0); - - } - TAO_InputCDR &_tao_in = _tao_call.inp_stream (); - if (!( - (_tao_in >> _tao_safe_retval.inout ()) - )) - ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0); - - break; - + _tao_call.start (ACE_TRY_ENV); + ACE_CHECK_RETURN (0); + + CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; + + _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); + ACE_CHECK_RETURN (0); + + int _invoke_status = + _tao_call.invoke (0, 0, ACE_TRY_ENV); + ACE_CHECK_RETURN (0); + + if (_invoke_status == TAO_INVOKE_RESTART) + continue; + if (_invoke_status != TAO_INVOKE_OK) + { + ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0); + + } + TAO_InputCDR &_tao_in = _tao_call.inp_stream (); + if (!( + (_tao_in >> _tao_safe_retval.inout ()) + )) + ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0); + + break; + } - return _tao_safe_retval._retn (); + return _tao_safe_retval._retn (); } void CORBA_Policy::destroy ( @@ -554,46 +556,47 @@ void CORBA_Policy::destroy ( CORBA::SystemException )) { - - - + + + TAO_Stub *istub = this->_stubobj (); if (istub == 0) ACE_THROW (CORBA::INTERNAL ()); - + TAO_GIOP_Twoway_Invocation _tao_call ( istub, "destroy", 7, + 0, istub->orb_core () ); for (;;) { - _tao_call.start (ACE_TRY_ENV); - ACE_CHECK; - - CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; - - _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); - ACE_CHECK; - - int _invoke_status = - _tao_call.invoke (0, 0, ACE_TRY_ENV); - ACE_CHECK; - - if (_invoke_status == TAO_INVOKE_RESTART) - continue; - if (_invoke_status != TAO_INVOKE_OK) - { - ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)); - } - - break; - + _tao_call.start (ACE_TRY_ENV); + ACE_CHECK; + + CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; + + _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); + ACE_CHECK; + + int _invoke_status = + _tao_call.invoke (0, 0, ACE_TRY_ENV); + ACE_CHECK; + + if (_invoke_status == TAO_INVOKE_RESTART) + continue; + if (_invoke_status != TAO_INVOKE_OK) + { + ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)); + } + + break; + } } @@ -608,17 +611,17 @@ CORBA::Boolean CORBA_Policy::_is_a (const CORBA::Char *value, CORBA::Environment return this->CORBA_Object::_is_a (value, ACE_TRY_ENV); } -void *CORBA_Policy::_tao_QueryInterface (ptr_arith_t type) +void *CORBA_Policy::_tao_QueryInterface (ptr_arith_t type) { void *retv = 0; if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA_Policy::_narrow)) - retv = ACE_reinterpret_cast (void*, this); - else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow)) - retv = ACE_reinterpret_cast (void *, + retv = ACE_reinterpret_cast (void*, this); + else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow)) + retv = ACE_reinterpret_cast (void *, ACE_static_cast (CORBA::Object_ptr, this)); - + if (retv) this->_add_ref (); return retv; @@ -636,56 +639,56 @@ CORBA_Policy::_tao_encode (TAO_OutputCDR &) } CORBA::Boolean -CORBA_Policy::_tao_decode (TAO_InputCDR &) +CORBA_Policy::_tao_decode (TAO_InputCDR &) { return 0; } static const CORBA::Long _oc_CORBA_Policy[] = { - TAO_ENCAP_BYTE_ORDER, // byte order - 29, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x415f506f), ACE_NTOHL (0x6c696379), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:omg.org/CORBA_Policy:1.0 - 13, ACE_NTOHL (0x434f5242), ACE_NTOHL (0x415f506f), ACE_NTOHL (0x6c696379), ACE_NTOHL (0x0), // name = CORBA_Policy + TAO_ENCAP_BYTE_ORDER, // byte order + 29, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x415f506f), ACE_NTOHL (0x6c696379), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:omg.org/CORBA_Policy:1.0 + 13, ACE_NTOHL (0x434f5242), ACE_NTOHL (0x415f506f), ACE_NTOHL (0x6c696379), ACE_NTOHL (0x0), // name = CORBA_Policy }; static CORBA::TypeCode _tc_TAO_tc_CORBA_Policy (CORBA::tk_objref, sizeof (_oc_CORBA_Policy), (char *) &_oc_CORBA_Policy, 0, sizeof (CORBA_Policy)); CORBA::TypeCode_ptr _tc_CORBA_Policy = &_tc_TAO_tc_CORBA_Policy; #if !defined (TAO_USE_SEQUENCE_TEMPLATES) - + #if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_POLICYLIST_CS_) -#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_POLICYLIST_CS_ +#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_POLICYLIST_CS_ // The Base_Sequence functions, please see tao/Sequence.h void _TAO_Unbounded_Object_Sequence_CORBA_PolicyList::_allocate_buffer (CORBA::ULong length) { CORBA_Policy **tmp = 0; - tmp = _TAO_Unbounded_Object_Sequence_CORBA_PolicyList::allocbuf (length); - + tmp = _TAO_Unbounded_Object_Sequence_CORBA_PolicyList::allocbuf (length); + if (this->buffer_ != 0) { - CORBA_Policy **old = ACE_reinterpret_cast (CORBA_Policy**, this->buffer_); - for (CORBA::ULong i = 0; i < this->length_; ++i) - if (!this->release_) - tmp[i] = CORBA_Policy::_duplicate (old[i]); - else - tmp[i] = old[i]; - + CORBA_Policy **old = ACE_reinterpret_cast (CORBA_Policy**, this->buffer_); + for (CORBA::ULong i = 0; i < this->length_; ++i) + if (!this->release_) + tmp[i] = CORBA_Policy::_duplicate (old[i]); + else + tmp[i] = old[i]; + if (this->release_) - delete[] old; - + delete[] old; + } this->buffer_ = tmp; } - + void _TAO_Unbounded_Object_Sequence_CORBA_PolicyList::_deallocate_buffer (void) { - if (this->buffer_ == 0 || this->release_ == 0) + if (this->buffer_ == 0 || this->release_ == 0) return; CORBA_Policy **tmp = ACE_reinterpret_cast (CORBA_Policy**, this->buffer_); - for (CORBA::ULong i = 0; i < this->length_; ++i) + for (CORBA::ULong i = 0; i < this->length_; ++i) { CORBA::release (tmp[i]); tmp[i] = CORBA_Policy::_nil (); @@ -693,28 +696,28 @@ CORBA::TypeCode_ptr _tc_CORBA_Policy = &_tc_TAO_tc_CORBA_Policy; _TAO_Unbounded_Object_Sequence_CORBA_PolicyList::freebuf (tmp); this->buffer_ = 0; } - + _TAO_Unbounded_Object_Sequence_CORBA_PolicyList::~_TAO_Unbounded_Object_Sequence_CORBA_PolicyList (void) { this->_deallocate_buffer (); } - + void - _TAO_Unbounded_Object_Sequence_CORBA_PolicyList::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol) + _TAO_Unbounded_Object_Sequence_CORBA_PolicyList::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol) { CORBA_Policy **tmp = ACE_reinterpret_cast (CORBA_Policy**, this->buffer_); - - for (CORBA::ULong i = nl; i < ol; ++i) + + for (CORBA::ULong i = nl; i < ol; ++i) { CORBA::release (tmp[i]); tmp[i] = CORBA_Policy::_nil (); } } - void + void _TAO_Unbounded_Object_Sequence_CORBA_PolicyList::_downcast ( void* target, CORBA_Object *src, - CORBA_Environment &ACE_TRY_ENV + CORBA_Environment &ACE_TRY_ENV ) { CORBA_Policy **tmp = ACE_static_cast (CORBA_Policy**, target); @@ -727,14 +730,14 @@ CORBA::TypeCode_ptr _tc_CORBA_Policy = &_tc_TAO_tc_CORBA_Policy; CORBA_Policy **tmp = ACE_static_cast (CORBA_Policy**, src); return *tmp; } - + #endif /* end #if !defined */ -#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ #if !defined (_CORBA_POLICYLIST_CS_) -#define _CORBA_POLICYLIST_CS_ +#define _CORBA_POLICYLIST_CS_ // ************************************************************* // CORBA_PolicyList @@ -743,53 +746,53 @@ CORBA::TypeCode_ptr _tc_CORBA_Policy = &_tc_TAO_tc_CORBA_Policy; CORBA_PolicyList::CORBA_PolicyList (void) {} CORBA_PolicyList::CORBA_PolicyList (CORBA::ULong max) // uses max size - : + : #if !defined (TAO_USE_SEQUENCE_TEMPLATES) _TAO_Unbounded_Object_Sequence_CORBA_PolicyList #else /* TAO_USE_SEQUENCE_TEMPLATES */ TAO_Unbounded_Object_Sequence<CORBA_Policy,CORBA_Policy_var> -#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ (max) {} CORBA_PolicyList::CORBA_PolicyList (CORBA::ULong max, CORBA::ULong length, CORBA_Policy_ptr *buffer, CORBA::Boolean release) - : + : #if !defined (TAO_USE_SEQUENCE_TEMPLATES) _TAO_Unbounded_Object_Sequence_CORBA_PolicyList #else /* TAO_USE_SEQUENCE_TEMPLATES */ TAO_Unbounded_Object_Sequence<CORBA_Policy,CORBA_Policy_var> -#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ (max, length, buffer, release) {} CORBA_PolicyList::CORBA_PolicyList (const CORBA_PolicyList &seq) // copy ctor - : + : #if !defined (TAO_USE_SEQUENCE_TEMPLATES) _TAO_Unbounded_Object_Sequence_CORBA_PolicyList #else /* TAO_USE_SEQUENCE_TEMPLATES */ TAO_Unbounded_Object_Sequence<CORBA_Policy,CORBA_Policy_var> -#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ (seq) {} CORBA_PolicyList::~CORBA_PolicyList (void) // dtor {} void CORBA_PolicyList::_tao_any_destructor (void *x) { - CORBA_PolicyList *tmp = ACE_static_cast (CORBA_PolicyList*,x); + CORBA_PolicyList *tmp = ACE_static_cast (CORBA_PolicyList*,x); delete tmp; } #endif /* end #if !defined */ -static const CORBA::Long _oc_CORBA_PolicyList[] = +static const CORBA::Long _oc_CORBA_PolicyList[] = { - TAO_ENCAP_BYTE_ORDER, // byte order - 33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x415f506f), ACE_NTOHL (0x6c696379), ACE_NTOHL (0x4c697374), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:omg.org/CORBA_PolicyList:1.0 - 17, ACE_NTOHL (0x434f5242), ACE_NTOHL (0x415f506f), ACE_NTOHL (0x6c696379), ACE_NTOHL (0x4c697374), ACE_NTOHL (0x0), // name = CORBA_PolicyList + TAO_ENCAP_BYTE_ORDER, // byte order + 33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x415f506f), ACE_NTOHL (0x6c696379), ACE_NTOHL (0x4c697374), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:omg.org/CORBA_PolicyList:1.0 + 17, ACE_NTOHL (0x434f5242), ACE_NTOHL (0x415f506f), ACE_NTOHL (0x6c696379), ACE_NTOHL (0x4c697374), ACE_NTOHL (0x0), // name = CORBA_PolicyList CORBA::tk_sequence, // typecode kind 76, // encapsulation length TAO_ENCAP_BYTE_ORDER, // byte order CORBA::tk_objref, // typecode kind - 60, // encapsulation length + 60, // encapsulation length TAO_ENCAP_BYTE_ORDER, // byte order 29, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x415f506f), ACE_NTOHL (0x6c696379), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:omg.org/CORBA_Policy:1.0 13, ACE_NTOHL (0x434f5242), ACE_NTOHL (0x415f506f), ACE_NTOHL (0x6c696379), ACE_NTOHL (0x0), // name = CORBA_Policy @@ -802,55 +805,55 @@ CORBA::TypeCode_ptr _tc_CORBA_PolicyList = &_tc_TAO_tc_CORBA_PolicyList; #if !defined (TAO_USE_SEQUENCE_TEMPLATES) - + #if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_POLICYTYPESEQ_CS_) -#define __TAO_UNBOUNDED_SEQUENCE_CORBA_POLICYTYPESEQ_CS_ +#define __TAO_UNBOUNDED_SEQUENCE_CORBA_POLICYTYPESEQ_CS_ void - _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::_allocate_buffer (CORBA::ULong length) + _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::_allocate_buffer (CORBA::ULong length) { - CORBA::ULong* tmp = 0; - tmp = _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::allocbuf (length); - + CORBA::ULong* tmp = 0; + tmp = _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::allocbuf (length); + if (this->buffer_ != 0) { - CORBA::ULong *old = ACE_reinterpret_cast (CORBA::ULong *,this->buffer_); - - for (CORBA::ULong i = 0; i < this->length_; ++i) - tmp[i] = old[i]; - + CORBA::ULong *old = ACE_reinterpret_cast (CORBA::ULong *,this->buffer_); + + for (CORBA::ULong i = 0; i < this->length_; ++i) + tmp[i] = old[i]; + if (this->release_) - _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::freebuf (old); - + _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::freebuf (old); + } this->buffer_ = tmp; } - + void _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::_deallocate_buffer (void) { - if (this->buffer_ == 0 || this->release_ == 0) + if (this->buffer_ == 0 || this->release_ == 0) return; - - CORBA::ULong *tmp = ACE_reinterpret_cast (CORBA::ULong *,this->buffer_); - + + CORBA::ULong *tmp = ACE_reinterpret_cast (CORBA::ULong *,this->buffer_); + _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::freebuf (tmp); this->buffer_ = 0; - } - + } + _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::~_TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq (void) // Dtor. { this->_deallocate_buffer (); } - - + + #endif /* end #if !defined */ -#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ #if !defined (_CORBA_POLICYTYPESEQ_CS_) -#define _CORBA_POLICYTYPESEQ_CS_ +#define _CORBA_POLICYTYPESEQ_CS_ // ************************************************************* // CORBA_PolicyTypeSeq @@ -858,31 +861,31 @@ CORBA::TypeCode_ptr _tc_CORBA_PolicyList = &_tc_TAO_tc_CORBA_PolicyList; CORBA_PolicyTypeSeq::CORBA_PolicyTypeSeq (void) {} -CORBA_PolicyTypeSeq::CORBA_PolicyTypeSeq (CORBA::ULong max) // uses max size - : +CORBA_PolicyTypeSeq::CORBA_PolicyTypeSeq (CORBA::ULong max) // uses max size + : #if !defined (TAO_USE_SEQUENCE_TEMPLATES) _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq #else /* TAO_USE_SEQUENCE_TEMPLATES */ TAO_Unbounded_Sequence<CORBA::ULong> -#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ (max) {} CORBA_PolicyTypeSeq::CORBA_PolicyTypeSeq (CORBA::ULong max, CORBA::ULong length, CORBA::ULong *buffer, CORBA::Boolean release) - : + : #if !defined (TAO_USE_SEQUENCE_TEMPLATES) _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq #else /* TAO_USE_SEQUENCE_TEMPLATES */ TAO_Unbounded_Sequence<CORBA::ULong> -#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ (max, length, buffer, release) {} -CORBA_PolicyTypeSeq::CORBA_PolicyTypeSeq (const CORBA_PolicyTypeSeq &seq) // copy ctor - : +CORBA_PolicyTypeSeq::CORBA_PolicyTypeSeq (const CORBA_PolicyTypeSeq &seq) // copy ctor + : #if !defined (TAO_USE_SEQUENCE_TEMPLATES) _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq #else /* TAO_USE_SEQUENCE_TEMPLATES */ TAO_Unbounded_Sequence<CORBA::ULong> -#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ (seq) {} CORBA_PolicyTypeSeq::~CORBA_PolicyTypeSeq (void) // dtor @@ -898,14 +901,14 @@ void CORBA_PolicyTypeSeq::_tao_any_destructor (void *x) static const CORBA::Long _oc_CORBA_PolicyTypeSeq[] = { - TAO_ENCAP_BYTE_ORDER, // byte order - 36, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x415f506f), ACE_NTOHL (0x6c696379), ACE_NTOHL (0x54797065), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000), // repository ID = IDL:omg.org/CORBA_PolicyTypeSeq:1.0 - 20, ACE_NTOHL (0x434f5242), ACE_NTOHL (0x415f506f), ACE_NTOHL (0x6c696379), ACE_NTOHL (0x54797065), ACE_NTOHL (0x53657100), // name = CORBA_PolicyTypeSeq + TAO_ENCAP_BYTE_ORDER, // byte order + 36, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x415f506f), ACE_NTOHL (0x6c696379), ACE_NTOHL (0x54797065), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000), // repository ID = IDL:omg.org/CORBA_PolicyTypeSeq:1.0 + 20, ACE_NTOHL (0x434f5242), ACE_NTOHL (0x415f506f), ACE_NTOHL (0x6c696379), ACE_NTOHL (0x54797065), ACE_NTOHL (0x53657100), // name = CORBA_PolicyTypeSeq CORBA::tk_sequence, // typecode kind 80, // encapsulation length TAO_ENCAP_BYTE_ORDER, // byte order - CORBA::tk_alias, // typecode kind for typedefs - 64, // encapsulation length + CORBA::tk_alias, // typecode kind for typedefs + 64, // encapsulation length TAO_ENCAP_BYTE_ORDER, // byte order 33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f506f), ACE_NTOHL (0x6c696379), ACE_NTOHL (0x54797065), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:omg.org/CORBA/PolicyType:1.0 11, ACE_NTOHL (0x506f6c69), ACE_NTOHL (0x63795479), ACE_NTOHL (0x70650000), // name = PolicyType @@ -915,7 +918,7 @@ static const CORBA::Long _oc_CORBA_PolicyTypeSeq[] = 0U, }; -static CORBA::TypeCode _tc_TAO_tc_CORBA_PolicyTypeSeq (CORBA::tk_alias, sizeof (_oc_CORBA_PolicyTypeSeq), (char *) &_oc_CORBA_PolicyTypeSeq, 0, sizeof (CORBA_PolicyTypeSeq)); +static CORBA::TypeCode _tc_TAO_tc_CORBA_PolicyTypeSeq (CORBA::tk_alias, sizeof (_oc_CORBA_PolicyTypeSeq), (char *) &_oc_CORBA_PolicyTypeSeq, 0, sizeof (CORBA_PolicyTypeSeq)); CORBA::TypeCode_ptr _tc_CORBA_PolicyTypeSeq = &_tc_TAO_tc_CORBA_PolicyTypeSeq; @@ -927,15 +930,15 @@ CORBA_PolicyManager::CORBA_PolicyManager (void) CORBA_PolicyManager::~CORBA_PolicyManager (void) {} -CORBA_PolicyManager_ptr CORBA_PolicyManager::_narrow ( +CORBA_PolicyManager_ptr CORBA_PolicyManager::_narrow ( CORBA::Object_ptr obj, CORBA::Environment &ACE_TRY_ENV ) { - return CORBA_PolicyManager::_unchecked_narrow (obj, ACE_TRY_ENV); + return CORBA_PolicyManager::_unchecked_narrow (obj, ACE_TRY_ENV); } -CORBA_PolicyManager_ptr CORBA_PolicyManager::_unchecked_narrow ( +CORBA_PolicyManager_ptr CORBA_PolicyManager::_unchecked_narrow ( CORBA::Object_ptr obj, CORBA::Environment & ) @@ -944,21 +947,21 @@ CORBA_PolicyManager_ptr CORBA_PolicyManager::_unchecked_narrow ( return CORBA_PolicyManager::_nil (); return ACE_reinterpret_cast - ( - CORBA_PolicyManager_ptr, - obj->_tao_QueryInterface - ( - ACE_reinterpret_cast - ( - ptr_arith_t, - &CORBA_PolicyManager::_narrow - ) - ) - ); + ( + CORBA_PolicyManager_ptr, + obj->_tao_QueryInterface + ( + ACE_reinterpret_cast + ( + ptr_arith_t, + &CORBA_PolicyManager::_narrow + ) + ) + ); } CORBA_PolicyManager_ptr -CORBA_PolicyManager::_duplicate (CORBA_PolicyManager_ptr obj) +CORBA_PolicyManager::_duplicate (CORBA_PolicyManager_ptr obj) { if (!CORBA::is_nil (obj)) obj->_add_ref (); @@ -971,11 +974,11 @@ void *CORBA_PolicyManager::_tao_QueryInterface (ptr_arith_t type) if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA_PolicyManager::_narrow)) - retv = ACE_reinterpret_cast (void*, this); - else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow)) - retv = ACE_reinterpret_cast (void *, + retv = ACE_reinterpret_cast (void*, this); + else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow)) + retv = ACE_reinterpret_cast (void *, ACE_static_cast (CORBA::Object_ptr, this)); - + if (retv) this->_add_ref (); return retv; @@ -995,15 +998,15 @@ CORBA_PolicyCurrent::CORBA_PolicyCurrent (void) CORBA_PolicyCurrent::~CORBA_PolicyCurrent (void) {} -CORBA_PolicyCurrent_ptr CORBA_PolicyCurrent::_narrow ( +CORBA_PolicyCurrent_ptr CORBA_PolicyCurrent::_narrow ( CORBA::Object_ptr obj, CORBA::Environment &ACE_TRY_ENV ) { - return CORBA_PolicyCurrent::_unchecked_narrow (obj, ACE_TRY_ENV); + return CORBA_PolicyCurrent::_unchecked_narrow (obj, ACE_TRY_ENV); } -CORBA_PolicyCurrent_ptr CORBA_PolicyCurrent::_unchecked_narrow ( +CORBA_PolicyCurrent_ptr CORBA_PolicyCurrent::_unchecked_narrow ( CORBA::Object_ptr obj, CORBA::Environment & ) @@ -1012,21 +1015,21 @@ CORBA_PolicyCurrent_ptr CORBA_PolicyCurrent::_unchecked_narrow ( return CORBA_PolicyCurrent::_nil (); return ACE_reinterpret_cast - ( - CORBA_PolicyCurrent_ptr, - obj->_tao_QueryInterface - ( - ACE_reinterpret_cast - ( - ptr_arith_t, - &CORBA_PolicyCurrent::_narrow - ) - ) - ); + ( + CORBA_PolicyCurrent_ptr, + obj->_tao_QueryInterface + ( + ACE_reinterpret_cast + ( + ptr_arith_t, + &CORBA_PolicyCurrent::_narrow + ) + ) + ); } CORBA_PolicyCurrent_ptr -CORBA_PolicyCurrent::_duplicate (CORBA_PolicyCurrent_ptr obj) +CORBA_PolicyCurrent::_duplicate (CORBA_PolicyCurrent_ptr obj) { if (!CORBA::is_nil (obj)) obj->_add_ref (); @@ -1039,35 +1042,35 @@ void *CORBA_PolicyCurrent::_tao_QueryInterface (ptr_arith_t type) if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA_PolicyCurrent::_narrow)) - retv = ACE_reinterpret_cast (void*, this); - else if (type == ACE_reinterpret_cast + retv = ACE_reinterpret_cast (void*, this); + else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA_PolicyManager::_narrow)) retv = ACE_reinterpret_cast ( - void *, - ACE_static_cast - ( - CORBA_PolicyManager_ptr, - this - ) + void *, + ACE_static_cast + ( + CORBA_PolicyManager_ptr, + this + ) ); - else if (type == ACE_reinterpret_cast + else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA_Current::_narrow)) retv = ACE_reinterpret_cast ( - void *, - ACE_static_cast - ( - CORBA_Current_ptr, - this - ) + void *, + ACE_static_cast + ( + CORBA_Current_ptr, + this + ) ); - else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow)) - retv = ACE_reinterpret_cast (void *, + else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_narrow)) + retv = ACE_reinterpret_cast (void *, ACE_static_cast (CORBA::Object_ptr, this)); - + if (retv) this->_add_ref (); return retv; @@ -1078,30 +1081,30 @@ const char* CORBA_PolicyCurrent::_interface_repository_id (void) const return "IDL:omg.org/CORBA/PolicyCurrent:1.0"; } -void operator<<= (CORBA::Any &_tao_any, CORBA::SetOverrideType _tao_elem) +void operator<<= (CORBA::Any &_tao_any, CORBA::SetOverrideType _tao_elem) { - TAO_OutputCDR stream; + TAO_OutputCDR stream; stream << _tao_elem; - _tao_any._tao_replace ( + _tao_any._tao_replace ( CORBA::_tc_SetOverrideType, TAO_ENCAP_BYTE_ORDER, stream.begin () ); } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::SetOverrideType &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::SetOverrideType &_tao_elem) { ACE_TRY_NEW_ENV { - CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equivalent (CORBA::_tc_SetOverrideType, ACE_TRY_ENV)) // not equal + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (CORBA::_tc_SetOverrideType, ACE_TRY_ENV)) // not equal { - return 0; + return 0; } ACE_TRY_CHECK; - TAO_InputCDR stream ( - _tao_any._tao_get_cdr (), - _tao_any._tao_byte_order () + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () ); if (stream >> _tao_elem) { @@ -1116,22 +1119,22 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::SetOverrideType & return 0; } -void operator<<= (CORBA::Any &_tao_any, const CORBA_PolicyError &_tao_elem) // copying +void operator<<= (CORBA::Any &_tao_any, const CORBA_PolicyError &_tao_elem) // copying { - TAO_OutputCDR stream; + TAO_OutputCDR stream; stream << _tao_elem; - _tao_any._tao_replace ( + _tao_any._tao_replace ( _tc_CORBA_PolicyError, TAO_ENCAP_BYTE_ORDER, stream.begin () ); } -void operator<<= (CORBA::Any &_tao_any, CORBA_PolicyError *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA_PolicyError *_tao_elem) // non copying { - TAO_OutputCDR stream; + TAO_OutputCDR stream; stream << *_tao_elem; - _tao_any._tao_replace ( + _tao_any._tao_replace ( _tc_CORBA_PolicyError, TAO_ENCAP_BYTE_ORDER, stream.begin (), @@ -1141,7 +1144,7 @@ void operator<<= (CORBA::Any &_tao_any, CORBA_PolicyError *_tao_elem) // non cop ); } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_PolicyError *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_PolicyError *&_tao_elem) { return _tao_any >>= ACE_const_cast( const CORBA_PolicyError*&, @@ -1149,51 +1152,51 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_PolicyError *&_tao ); } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_PolicyError *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_PolicyError *&_tao_elem) { _tao_elem = 0; ACE_TRY_NEW_ENV { - CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equivalent (_tc_CORBA_PolicyError, ACE_TRY_ENV)) // not equal + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (_tc_CORBA_PolicyError, ACE_TRY_ENV)) // not equal { - return 0; + return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_PolicyError *)_tao_any.value (); + _tao_elem = (CORBA_PolicyError *)_tao_any.value (); return 1; } else { - CORBA_PolicyError *tmp; + CORBA_PolicyError *tmp; ACE_NEW_RETURN (tmp, CORBA_PolicyError, 0); TAO_InputCDR stream ( - _tao_any._tao_get_cdr (), - _tao_any._tao_byte_order () - ); - CORBA::String_var interface_repository_id; + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + CORBA::String_var interface_repository_id; if (!(stream >> interface_repository_id.out ())) - return 0; + return 0; if (ACE_OS::strcmp ( - interface_repository_id.in (), - "IDL:omg.org/CORBA/PolicyError:1.0")) - return 0; + interface_repository_id.in (), + "IDL:omg.org/CORBA/PolicyError:1.0")) + return 0; if (stream >> *tmp) { - ((CORBA::Any *)&_tao_any)->_tao_replace ( - _tc_CORBA_PolicyError, - 1, - tmp, - CORBA_PolicyError::_tao_any_destructor - ); - _tao_elem = tmp; - return 1; + ((CORBA::Any *)&_tao_any)->_tao_replace ( + _tc_CORBA_PolicyError, + 1, + tmp, + CORBA_PolicyError::_tao_any_destructor + ); + _tao_elem = tmp; + return 1; } else { - delete tmp; + delete tmp; } } } @@ -1204,22 +1207,22 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_PolicyError return 0; } -void operator<<= (CORBA::Any &_tao_any, const CORBA_InvalidPolicies &_tao_elem) // copying +void operator<<= (CORBA::Any &_tao_any, const CORBA_InvalidPolicies &_tao_elem) // copying { - TAO_OutputCDR stream; + TAO_OutputCDR stream; stream << _tao_elem; - _tao_any._tao_replace ( + _tao_any._tao_replace ( _tc_CORBA_InvalidPolicies, TAO_ENCAP_BYTE_ORDER, stream.begin () ); } -void operator<<= (CORBA::Any &_tao_any, CORBA_InvalidPolicies *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA_InvalidPolicies *_tao_elem) // non copying { - TAO_OutputCDR stream; + TAO_OutputCDR stream; stream << *_tao_elem; - _tao_any._tao_replace ( + _tao_any._tao_replace ( _tc_CORBA_InvalidPolicies, TAO_ENCAP_BYTE_ORDER, stream.begin (), @@ -1229,7 +1232,7 @@ void operator<<= (CORBA::Any &_tao_any, CORBA_InvalidPolicies *_tao_elem) // non ); } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_InvalidPolicies *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_InvalidPolicies *&_tao_elem) { return _tao_any >>= ACE_const_cast( const CORBA_InvalidPolicies*&, @@ -1237,20 +1240,20 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_InvalidPolicies *& ); } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_InvalidPolicies *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_InvalidPolicies *&_tao_elem) { _tao_elem = 0; ACE_TRY_NEW_ENV { - CORBA::TypeCode_var type = _tao_any.type (); + CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (_tc_CORBA_InvalidPolicies, ACE_TRY_ENV)) // not equal { - return 0; + return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (CORBA_InvalidPolicies *)_tao_any.value (); + _tao_elem = (CORBA_InvalidPolicies *)_tao_any.value (); return 1; } else @@ -1258,30 +1261,30 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_InvalidPolic CORBA_InvalidPolicies *tmp; ACE_NEW_RETURN (tmp, CORBA_InvalidPolicies, 0); TAO_InputCDR stream ( - _tao_any._tao_get_cdr (), - _tao_any._tao_byte_order () - ); - CORBA::String_var interface_repository_id; + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + CORBA::String_var interface_repository_id; if (!(stream >> interface_repository_id.out ())) - return 0; + return 0; if (ACE_OS::strcmp ( - interface_repository_id.in (), - "IDL:omg.org/CORBA/InvalidPolicies:1.0")) - return 0; + interface_repository_id.in (), + "IDL:omg.org/CORBA/InvalidPolicies:1.0")) + return 0; if (stream >> *tmp) { - ((CORBA::Any *)&_tao_any)->_tao_replace ( - _tc_CORBA_InvalidPolicies, - 1, - tmp, - CORBA_InvalidPolicies::_tao_any_destructor - ); - _tao_elem = tmp; - return 1; + ((CORBA::Any *)&_tao_any)->_tao_replace ( + _tc_CORBA_InvalidPolicies, + 1, + tmp, + CORBA_InvalidPolicies::_tao_any_destructor + ); + _tao_elem = tmp; + return 1; } else { - delete tmp; + delete tmp; } } } @@ -1292,54 +1295,54 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_InvalidPolic return 0; } -CORBA_Policy_ptr (*_TAO_collocation_CORBA_Policy_Stub_Factory_function_pointer) ( +CORBA_Policy_ptr (*_TAO_collocation_CORBA_Policy_Stub_Factory_function_pointer) ( CORBA::Object_ptr obj ) = 0; -void operator<<= (CORBA::Any &_tao_any, CORBA_Policy_ptr _tao_elem) +void operator<<= (CORBA::Any &_tao_any, CORBA_Policy_ptr _tao_elem) { - TAO_OutputCDR stream; - if (stream << _tao_elem) + TAO_OutputCDR stream; + if (stream << _tao_elem) { _tao_any._tao_replace ( - _tc_CORBA_Policy, - TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - CORBA_Policy::_duplicate (_tao_elem), - CORBA_Policy::_tao_any_destructor + _tc_CORBA_Policy, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + CORBA_Policy::_duplicate (_tao_elem), + CORBA_Policy::_tao_any_destructor ); } } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_Policy_ptr &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_Policy_ptr &_tao_elem) { ACE_TRY_NEW_ENV { - _tao_elem = CORBA_Policy::_nil (); - CORBA::TypeCode_var type = _tao_any.type (); + _tao_elem = CORBA_Policy::_nil (); + CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (_tc_CORBA_Policy, ACE_TRY_ENV)) // not equal { - return 0; + return 0; } ACE_TRY_CHECK; - TAO_InputCDR stream ( - _tao_any._tao_get_cdr (), - _tao_any._tao_byte_order () + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () ); if (stream >> _tao_elem) { ((CORBA::Any *)&_tao_any)->_tao_replace ( - _tc_CORBA_Policy, - 1, - _tao_elem, - CORBA_Policy::_tao_any_destructor - ); + _tc_CORBA_Policy, + 1, + _tao_elem, + CORBA_Policy::_tao_any_destructor + ); return 1; } } ACE_CATCHANY { - _tao_elem = CORBA_Policy::_nil (); + _tao_elem = CORBA_Policy::_nil (); return 0; } ACE_ENDTRY; @@ -1350,8 +1353,8 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_Policy_ptr &_tao_e #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ defined (ACE_HAS_GNU_REPO) template class TAO_Object_Manager<CORBA_Policy,CORBA_Policy_var>; - #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) - # pragma instantiate TAO_Object_Manager<CORBA_Policy,CORBA_Policy_var> + #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) + # pragma instantiate TAO_Object_Manager<CORBA_Policy,CORBA_Policy_var> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ void operator<<= ( @@ -1359,22 +1362,22 @@ void operator<<= ( const CORBA_PolicyList &_tao_elem ) // copying { - TAO_OutputCDR stream; - if (stream << _tao_elem) + TAO_OutputCDR stream; + if (stream << _tao_elem) { _tao_any._tao_replace ( - _tc_CORBA_PolicyList, - TAO_ENCAP_BYTE_ORDER, - stream.begin () + _tc_CORBA_PolicyList, + TAO_ENCAP_BYTE_ORDER, + stream.begin () ); } } -void operator<<= (CORBA::Any &_tao_any, CORBA_PolicyList *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA_PolicyList *_tao_elem) // non copying { - TAO_OutputCDR stream; + TAO_OutputCDR stream; stream << *_tao_elem; - _tao_any._tao_replace ( + _tao_any._tao_replace ( _tc_CORBA_PolicyList, TAO_ENCAP_BYTE_ORDER, stream.begin (), @@ -1384,7 +1387,7 @@ void operator<<= (CORBA::Any &_tao_any, CORBA_PolicyList *_tao_elem) // non copy ); } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_PolicyList *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_PolicyList *&_tao_elem) { return _tao_any >>= ACE_const_cast( const CORBA_PolicyList*&, @@ -1392,23 +1395,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_PolicyList *&_tao_ ); } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_PolicyList *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_PolicyList *&_tao_elem) { _tao_elem = 0; ACE_TRY_NEW_ENV { - CORBA::TypeCode_var type = _tao_any.type (); + CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (_tc_CORBA_PolicyList, ACE_TRY_ENV)) // not equal { - return 0; + return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = ACE_static_cast( - const CORBA_PolicyList*, - _tao_any.value () - ); + _tao_elem = ACE_static_cast( + const CORBA_PolicyList*, + _tao_any.value () + ); return 1; } else @@ -1416,23 +1419,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_PolicyList * CORBA_PolicyList *tmp; ACE_NEW_RETURN (tmp, CORBA_PolicyList, 0); TAO_InputCDR stream ( - _tao_any._tao_get_cdr (), - _tao_any._tao_byte_order () - ); + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); if (stream >> *tmp) { - ((CORBA::Any *)&_tao_any)->_tao_replace ( - _tc_CORBA_PolicyList, - 1, - ACE_static_cast (void *, tmp), - CORBA_PolicyList::_tao_any_destructor - ); - _tao_elem = tmp; - return 1; + ((CORBA::Any *)&_tao_any)->_tao_replace ( + _tc_CORBA_PolicyList, + 1, + ACE_static_cast (void *, tmp), + CORBA_PolicyList::_tao_any_destructor + ); + _tao_elem = tmp; + return 1; } else { - delete tmp; + delete tmp; } } } @@ -1448,22 +1451,22 @@ void operator<<= ( const CORBA_PolicyTypeSeq &_tao_elem ) // copying { - TAO_OutputCDR stream; - if (stream << _tao_elem) + TAO_OutputCDR stream; + if (stream << _tao_elem) { _tao_any._tao_replace ( - _tc_CORBA_PolicyTypeSeq, - TAO_ENCAP_BYTE_ORDER, - stream.begin () + _tc_CORBA_PolicyTypeSeq, + TAO_ENCAP_BYTE_ORDER, + stream.begin () ); } } -void operator<<= (CORBA::Any &_tao_any, CORBA_PolicyTypeSeq *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA_PolicyTypeSeq *_tao_elem) // non copying { - TAO_OutputCDR stream; + TAO_OutputCDR stream; stream << *_tao_elem; - _tao_any._tao_replace ( + _tao_any._tao_replace ( _tc_CORBA_PolicyTypeSeq, TAO_ENCAP_BYTE_ORDER, stream.begin (), @@ -1473,7 +1476,7 @@ void operator<<= (CORBA::Any &_tao_any, CORBA_PolicyTypeSeq *_tao_elem) // non c ); } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_PolicyTypeSeq *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_PolicyTypeSeq *&_tao_elem) { return _tao_any >>= ACE_const_cast( const CORBA_PolicyTypeSeq*&, @@ -1481,47 +1484,47 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_PolicyTypeSeq *&_t ); } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_PolicyTypeSeq *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_PolicyTypeSeq *&_tao_elem) { _tao_elem = 0; ACE_TRY_NEW_ENV { - CORBA::TypeCode_var type = _tao_any.type (); + CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (_tc_CORBA_PolicyTypeSeq, ACE_TRY_ENV)) // not equal { - return 0; + return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = ACE_static_cast( - const CORBA_PolicyTypeSeq*, - _tao_any.value () - ); + _tao_elem = ACE_static_cast( + const CORBA_PolicyTypeSeq*, + _tao_any.value () + ); return 1; } else { CORBA_PolicyTypeSeq *tmp; - ACE_NEW_RETURN (tmp, CORBA_PolicyTypeSeq, 0); + ACE_NEW_RETURN (tmp, CORBA_PolicyTypeSeq, 0); TAO_InputCDR stream ( - _tao_any._tao_get_cdr (), - _tao_any._tao_byte_order () - ); + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); if (stream >> *tmp) { - ((CORBA::Any *)&_tao_any)->_tao_replace ( - _tc_CORBA_PolicyTypeSeq, - 1, - ACE_static_cast (void *, tmp), - CORBA_PolicyTypeSeq::_tao_any_destructor - ); - _tao_elem = tmp; - return 1; + ((CORBA::Any *)&_tao_any)->_tao_replace ( + _tc_CORBA_PolicyTypeSeq, + 1, + ACE_static_cast (void *, tmp), + CORBA_PolicyTypeSeq::_tao_any_destructor + ); + _tao_elem = tmp; + return 1; } else { - delete tmp; + delete tmp; } } } @@ -1535,20 +1538,20 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_PolicyTypeSe #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ defined (ACE_HAS_GNU_REPO) template class TAO_Object_Manager<CORBA_PolicyManager,CORBA_PolicyManager_var>; - #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) - # pragma instantiate TAO_Object_Manager<CORBA_PolicyManager,CORBA_PolicyManager_var> + #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) + # pragma instantiate TAO_Object_Manager<CORBA_PolicyManager,CORBA_PolicyManager_var> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ defined (ACE_HAS_GNU_REPO) template class TAO_Object_Manager<CORBA_PolicyCurrent,CORBA_PolicyCurrent_var>; - #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) - # pragma instantiate TAO_Object_Manager<CORBA_PolicyCurrent,CORBA_PolicyCurrent_var> + #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) + # pragma instantiate TAO_Object_Manager<CORBA_PolicyCurrent,CORBA_PolicyCurrent_var> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ #if !defined _TAO_CDR_OP_CORBA_InvalidPolicies__tao_seq_UShort_CPP_ -#define _TAO_CDR_OP_CORBA_InvalidPolicies__tao_seq_UShort_CPP_ +#define _TAO_CDR_OP_CORBA_InvalidPolicies__tao_seq_UShort_CPP_ CORBA::Boolean operator<< ( TAO_OutputCDR &strm, @@ -1573,11 +1576,11 @@ CORBA::Boolean operator>> ( { // set the length of the sequence _tao_sequence.length (_tao_seq_len); - // If length is 0 we return true. - if (0 >= _tao_seq_len) + // If length is 0 we return true. + if (0 >= _tao_seq_len) return 1; - // retrieve all the elements - return strm.read_ushort_array (_tao_sequence.get_buffer (), _tao_sequence.length ()); + // retrieve all the elements + return strm.read_ushort_array (_tao_sequence.get_buffer (), _tao_sequence.length ()); } return 0; // error } @@ -1593,9 +1596,9 @@ CORBA::Boolean operator<< ( { // encode all elements CORBA::Boolean _tao_marshal_flag = 1; - for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++) + for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++) { - _tao_marshal_flag = (strm << _tao_sequence[i].in ()); + _tao_marshal_flag = (strm << _tao_sequence[i].in ()); } return _tao_marshal_flag; } @@ -1612,14 +1615,14 @@ CORBA::Boolean operator>> ( { // set the length of the sequence _tao_sequence.length (_tao_seq_len); - // If length is 0 we return true. - if (0 >= _tao_seq_len) + // If length is 0 we return true. + if (0 >= _tao_seq_len) return 1; - // retrieve all the elements + // retrieve all the elements CORBA::Boolean _tao_marshal_flag = 1; - for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++) + for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++) { - _tao_marshal_flag = (strm >> _tao_sequence[i].out ()); + _tao_marshal_flag = (strm >> _tao_sequence[i].out ()); } return _tao_marshal_flag; } @@ -1634,14 +1637,14 @@ CORBA::Boolean operator<< ( if (strm << _tao_sequence.length ()) { // encode all elements - return strm.write_ulong_array (_tao_sequence.get_buffer (), _tao_sequence.length ()); + return strm.write_ulong_array (_tao_sequence.get_buffer (), _tao_sequence.length ()); } return 0; // error } CORBA::Boolean operator>> ( TAO_InputCDR &strm, - CORBA_PolicyTypeSeq &_tao_sequence + CORBA_PolicyTypeSeq &_tao_sequence ) { CORBA::ULong _tao_seq_len; @@ -1649,10 +1652,10 @@ CORBA::Boolean operator>> ( { // set the length of the sequence _tao_sequence.length (_tao_seq_len); - // If length is 0 we return true. - if (0 >= _tao_seq_len) + // If length is 0 we return true. + if (0 >= _tao_seq_len) return 1; - // retrieve all the elements + // retrieve all the elements return strm.read_ulong_array (_tao_sequence.get_buffer (), _tao_sequence.length ()); } return 0; // error diff --git a/TAO/tao/PortableServer/ImplRepoC.cpp b/TAO/tao/PortableServer/ImplRepoC.cpp index 840f65855c6..c89cc142e1b 100644 --- a/TAO/tao/PortableServer/ImplRepoC.cpp +++ b/TAO/tao/PortableServer/ImplRepoC.cpp @@ -1,11 +1,11 @@ /* -*- C++ -*- $Id$ */ -// ****** Code generated by the The ACE ORB (TAO) IDL Compiler ******* -// TAO and the TAO IDL Compiler have been developed by the Center for -// Distributed Object Computing at Washington University, St. Louis. +// ****** Code generated by the The ACE ORB (TAO) IDL Compiler ******* +// TAO and the TAO IDL Compiler have been developed by the Center for +// Distributed Object Computing at Washington University, St. Louis. // // Information about TAO is available at: -// http://www.cs.wustl.edu/~schmidt/TAO.html +// http://www.cs.wustl.edu/~schmidt/TAO.html #include "ImplRepoC.h" #include "tao/Stub.h" @@ -19,7 +19,7 @@ void ImplementationRepository::ServerObject::_tao_any_destructor (void *x) { - ImplementationRepository::ServerObject *tmp = ACE_static_cast (ImplementationRepository::ServerObject*,x); + ImplementationRepository::ServerObject *tmp = ACE_static_cast (ImplementationRepository::ServerObject*,x); CORBA::release (tmp); } @@ -30,7 +30,7 @@ ImplementationRepository::ServerObject_ptr ImplementationRepository::ServerObjec { if (CORBA::is_nil (obj)) return ServerObject::_nil (); - CORBA::Boolean is_a = obj->_is_a ("IDL:ImplementationRepository/ServerObject:1.0", ACE_TRY_ENV); + CORBA::Boolean is_a = obj->_is_a ("IDL:ImplementationRepository/ServerObject:1.0", ACE_TRY_ENV); ACE_CHECK_RETURN (ServerObject::_nil ()); if (is_a == 0) return ServerObject::_nil (); @@ -47,12 +47,12 @@ ImplementationRepository::ServerObject_ptr ImplementationRepository::ServerObjec TAO_Stub* stub = obj->_stubobj (); stub->_incr_refcnt (); ServerObject_ptr default_proxy = ServerObject::_nil (); - if (obj->_is_collocated () && _TAO_collocation_ImplementationRepository_ServerObject_Stub_Factory_function_pointer != 0) + if (obj->_is_collocated () && _TAO_collocation_ImplementationRepository_ServerObject_Stub_Factory_function_pointer != 0) { default_proxy = _TAO_collocation_ImplementationRepository_ServerObject_Stub_Factory_function_pointer (obj); } if (CORBA::is_nil (default_proxy)) - ACE_NEW_RETURN (default_proxy, ServerObject (stub), ServerObject::_nil ()); + ACE_NEW_RETURN (default_proxy, ServerObject (stub), ServerObject::_nil ()); return TAO_ImplementationRepository_ServerObject_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy); } @@ -80,30 +80,31 @@ void ImplementationRepository::ServerObject::ping ( istub, "ping", 4, + 0, istub->orb_core () ); for (;;) { - _tao_call.start (ACE_TRY_ENV); - ACE_CHECK; - CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; - // Tremporary hack until GIOP 1.2 is implemented. - - _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); - ACE_CHECK; - - int _invoke_status = - _tao_call.invoke (0, 0, ACE_TRY_ENV); - ACE_CHECK; - - if (_invoke_status == TAO_INVOKE_RESTART) - continue; - if (_invoke_status != TAO_INVOKE_OK) - { - ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)); - } - break; + _tao_call.start (ACE_TRY_ENV); + ACE_CHECK; + CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; + // Tremporary hack until GIOP 1.2 is implemented. + + _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); + ACE_CHECK; + + int _invoke_status = + _tao_call.invoke (0, 0, ACE_TRY_ENV); + ACE_CHECK; + + if (_invoke_status == TAO_INVOKE_RESTART) + continue; + if (_invoke_status != TAO_INVOKE_OK) + { + ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)); + } + break; } } @@ -125,38 +126,39 @@ void ImplementationRepository::ServerObject::shutdown ( istub, "shutdown", 8, + 0, istub->orb_core () ); for (;;) { - _tao_call.start (ACE_TRY_ENV); - ACE_CHECK; + _tao_call.start (ACE_TRY_ENV); + ACE_CHECK; - CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; - // Tremporary hack until GIOP 1.2 is implemented. + CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; + // Tremporary hack until GIOP 1.2 is implemented. - _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); - ACE_CHECK; + _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); + ACE_CHECK; - int _invoke_status = - _tao_call.invoke (0, 0, ACE_TRY_ENV); - ACE_CHECK; + int _invoke_status = + _tao_call.invoke (0, 0, ACE_TRY_ENV); + ACE_CHECK; - if (_invoke_status == TAO_INVOKE_RESTART) - continue; - if (_invoke_status != TAO_INVOKE_OK) - { - ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)); - } - ACE_CHECK; - break; + if (_invoke_status == TAO_INVOKE_RESTART) + continue; + if (_invoke_status != TAO_INVOKE_OK) + { + ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)); + } + ACE_CHECK; + break; } } -CORBA::Boolean ImplementationRepository::ServerObject::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV) +CORBA::Boolean ImplementationRepository::ServerObject::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV) { if ( (!ACE_OS::strcmp ((char *)value, "IDL:ImplementationRepository/ServerObject:1.0")) || @@ -171,11 +173,11 @@ const char* ImplementationRepository::ServerObject::_interface_repository_id (vo return "IDL:ImplementationRepository/ServerObject:1.0"; } -ImplementationRepository::TAO_ImplementationRepository_ServerObject_Default_Proxy_Factory::TAO_ImplementationRepository_ServerObject_Default_Proxy_Factory (int register_proxy_factory) +ImplementationRepository::TAO_ImplementationRepository_ServerObject_Default_Proxy_Factory::TAO_ImplementationRepository_ServerObject_Default_Proxy_Factory (int register_proxy_factory) { if (register_proxy_factory) { - TAO_ImplementationRepository_ServerObject_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this); + TAO_ImplementationRepository_ServerObject_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this); } } @@ -184,7 +186,7 @@ ImplementationRepository::TAO_ImplementationRepository_ServerObject_Default_Prox } ImplementationRepository::ServerObject_ptr -ImplementationRepository::TAO_ImplementationRepository_ServerObject_Default_Proxy_Factory::create_proxy ( +ImplementationRepository::TAO_ImplementationRepository_ServerObject_Default_Proxy_Factory::create_proxy ( ::ImplementationRepository::ServerObject_ptr proxy, CORBA::Environment & ) @@ -200,7 +202,7 @@ ImplementationRepository::TAO_ImplementationRepository_ServerObject_Proxy_Factor ImplementationRepository::TAO_ImplementationRepository_ServerObject_Proxy_Factory_Adapter::~TAO_ImplementationRepository_ServerObject_Proxy_Factory_Adapter (void) { - // Making sure the factory which the adapter has is destroyed with it. + // Making sure the factory which the adapter has is destroyed with it. if (this->proxy_factory_ != 0) delete this->proxy_factory_; } @@ -208,15 +210,15 @@ ImplementationRepository::TAO_ImplementationRepository_ServerObject_Proxy_Factor int ImplementationRepository::TAO_ImplementationRepository_ServerObject_Proxy_Factory_Adapter::register_proxy_factory ( TAO_ImplementationRepository_ServerObject_Default_Proxy_Factory *df, - CORBA::Environment &ACE_TRY_ENV + CORBA::Environment &ACE_TRY_ENV ) { - ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon, + ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon, this->lock_, 0)); - // Remove any existing <proxy_factory_> and replace with the new one. + // Remove any existing <proxy_factory_> and replace with the new one. this->unregister_proxy_factory (ACE_TRY_ENV); this->proxy_factory_ = df; - this->delete_proxy_factory_ = 0; + this->delete_proxy_factory_ = 0; return 0; } @@ -225,13 +227,13 @@ ImplementationRepository::TAO_ImplementationRepository_ServerObject_Proxy_Factor CORBA::Environment & ) { - ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon, + ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon, this->lock_, 0)); if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0) { - // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it - // doesnt get into an infinite loop in <unregister_proxy_factory> as it is - // invoked in the destructor of the class too. + // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it + // doesnt get into an infinite loop in <unregister_proxy_factory> as it is + // invoked in the destructor of the class too. this->delete_proxy_factory_ = 1; delete this->proxy_factory_; this->proxy_factory_ = 0; @@ -240,18 +242,18 @@ return 0; } ImplementationRepository::ServerObject_ptr -ImplementationRepository::TAO_ImplementationRepository_ServerObject_Proxy_Factory_Adapter::create_proxy ( +ImplementationRepository::TAO_ImplementationRepository_ServerObject_Proxy_Factory_Adapter::create_proxy ( ::ImplementationRepository::ServerObject_ptr proxy, CORBA::Environment & ) { - ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon, + ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon, this->lock_, 0)); - // Verify that an <proxy_factory_> is available else make one. + // Verify that an <proxy_factory_> is available else make one. if (this->proxy_factory_ == 0) ACE_NEW_RETURN (this->proxy_factory_, - TAO_ImplementationRepository_ServerObject_Default_Proxy_Factory (1), - 0); + TAO_ImplementationRepository_ServerObject_Default_Proxy_Factory (1), + 0); return this->proxy_factory_->create_proxy (proxy); @@ -266,7 +268,7 @@ ImplementationRepository::TAO_ImplementationRepository_ServerObject_Smart_Proxy_ { } -void ImplementationRepository::TAO_ImplementationRepository_ServerObject_Smart_Proxy_Base::ping ( +void ImplementationRepository::TAO_ImplementationRepository_ServerObject_Smart_Proxy_Base::ping ( CORBA::Environment &ACE_TRY_ENV ) ACE_THROW_SPEC (( @@ -294,80 +296,80 @@ void ImplementationRepository::TAO_ImplementationRepository_ServerObject_Smart_P #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ defined (ACE_HAS_GNU_REPO) -template class TAO_Singleton<ImplementationRepository::TAO_ImplementationRepository_ServerObject_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >; +template class TAO_Singleton<ImplementationRepository::TAO_ImplementationRepository_ServerObject_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >; #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) -#pragma instantiate TAO_Singleton<ImplementationRepository::TAO_ImplementationRepository_ServerObject_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> +#pragma instantiate TAO_Singleton<ImplementationRepository::TAO_ImplementationRepository_ServerObject_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ static const CORBA::Long _oc_ImplementationRepository_ServerObject[] = { - TAO_ENCAP_BYTE_ORDER, // byte order - 46, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f536572), ACE_NTOHL (0x7665724f), ACE_NTOHL (0x626a6563), ACE_NTOHL (0x743a312e), ACE_NTOHL (0x30000000), // repository ID = IDL:ImplementationRepository/ServerObject:1.0 - 13, ACE_NTOHL (0x53657276), ACE_NTOHL (0x65724f62), ACE_NTOHL (0x6a656374), ACE_NTOHL (0x0), // name = ServerObject + TAO_ENCAP_BYTE_ORDER, // byte order + 46, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f536572), ACE_NTOHL (0x7665724f), ACE_NTOHL (0x626a6563), ACE_NTOHL (0x743a312e), ACE_NTOHL (0x30000000), // repository ID = IDL:ImplementationRepository/ServerObject:1.0 + 13, ACE_NTOHL (0x53657276), ACE_NTOHL (0x65724f62), ACE_NTOHL (0x6a656374), ACE_NTOHL (0x0), // name = ServerObject }; -static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_ServerObject (CORBA::tk_objref, sizeof (_oc_ImplementationRepository_ServerObject), (char *) &_oc_ImplementationRepository_ServerObject, 0, sizeof (ImplementationRepository::ServerObject)); +static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_ServerObject (CORBA::tk_objref, sizeof (_oc_ImplementationRepository_ServerObject), (char *) &_oc_ImplementationRepository_ServerObject, 0, sizeof (ImplementationRepository::ServerObject)); TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) TAO_NAMESPACE_BEGIN (ImplementationRepository) TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ServerObject, &_tc_TAO_tc_ImplementationRepository_ServerObject) TAO_NAMESPACE_END static const CORBA::Long _oc_ImplementationRepository_EnvironmentVariable[] = { - TAO_ENCAP_BYTE_ORDER, // byte order - 53, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f456e76), ACE_NTOHL (0x69726f6e), ACE_NTOHL (0x6d656e74), ACE_NTOHL (0x56617269), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:ImplementationRepository/EnvironmentVariable:1.0 - 20, ACE_NTOHL (0x456e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e7456), ACE_NTOHL (0x61726961), ACE_NTOHL (0x626c6500), // name = EnvironmentVariable - 2, // member count + TAO_ENCAP_BYTE_ORDER, // byte order + 53, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f456e76), ACE_NTOHL (0x69726f6e), ACE_NTOHL (0x6d656e74), ACE_NTOHL (0x56617269), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:ImplementationRepository/EnvironmentVariable:1.0 + 20, ACE_NTOHL (0x456e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e7456), ACE_NTOHL (0x61726961), ACE_NTOHL (0x626c6500), // name = EnvironmentVariable + 2, // member count 5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0), // name = name CORBA::tk_string, - 0U, // string length - 6, ACE_NTOHL (0x76616c75), ACE_NTOHL (0x65000000), // name = value + 0U, // string length + 6, ACE_NTOHL (0x76616c75), ACE_NTOHL (0x65000000), // name = value CORBA::tk_string, - 0U, // string length + 0U, // string length }; static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_EnvironmentVariable (CORBA::tk_struct, sizeof (_oc_ImplementationRepository_EnvironmentVariable), (char *) &_oc_ImplementationRepository_EnvironmentVariable, 0, sizeof (ImplementationRepository::EnvironmentVariable)); TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) TAO_NAMESPACE_BEGIN (ImplementationRepository) TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_EnvironmentVariable, &_tc_TAO_tc_ImplementationRepository_EnvironmentVariable) TAO_NAMESPACE_END -void ImplementationRepository::EnvironmentVariable::_tao_any_destructor (void *x) +void ImplementationRepository::EnvironmentVariable::_tao_any_destructor (void *x) { - ImplementationRepository::EnvironmentVariable *tmp = ACE_static_cast (ImplementationRepository::EnvironmentVariable*,x); + ImplementationRepository::EnvironmentVariable *tmp = ACE_static_cast (ImplementationRepository::EnvironmentVariable*,x); delete tmp; } -static const CORBA::Long _oc_ImplementationRepository_Address[] = +static const CORBA::Long _oc_ImplementationRepository_Address[] = { - TAO_ENCAP_BYTE_ORDER, // byte order - 41, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f416464), ACE_NTOHL (0x72657373), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:ImplementationRepository/Address:1.0 - 8, ACE_NTOHL (0x41646472), ACE_NTOHL (0x65737300), // name = Address + TAO_ENCAP_BYTE_ORDER, // byte order + 41, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f416464), ACE_NTOHL (0x72657373), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:ImplementationRepository/Address:1.0 + 8, ACE_NTOHL (0x41646472), ACE_NTOHL (0x65737300), // name = Address CORBA::tk_string, - 0U, // string length + 0U, // string length }; static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_Address (CORBA::tk_alias, sizeof (_oc_ImplementationRepository_Address), (char *) &_oc_ImplementationRepository_Address, 0, sizeof (ImplementationRepository::Address)); TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) TAO_NAMESPACE_BEGIN (ImplementationRepository) -TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_Address, &_tc_TAO_tc_ImplementationRepository_Address) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_Address, &_tc_TAO_tc_ImplementationRepository_Address) TAO_NAMESPACE_END #if !defined (TAO_USE_SEQUENCE_TEMPLATES) #if !defined (__TAO_UNBOUNDED_SEQUENCE_IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CS_) -#define __TAO_UNBOUNDED_SEQUENCE_IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CS_ +#define __TAO_UNBOUNDED_SEQUENCE_IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CS_ void ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::_allocate_buffer (CORBA::ULong length) { ImplementationRepository::EnvironmentVariable* tmp = 0; - tmp = _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::allocbuf (length); + tmp = _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::allocbuf (length); if (this->buffer_ != 0) { - ImplementationRepository::EnvironmentVariable *old = ACE_reinterpret_cast (ImplementationRepository::EnvironmentVariable *,this->buffer_); + ImplementationRepository::EnvironmentVariable *old = ACE_reinterpret_cast (ImplementationRepository::EnvironmentVariable *,this->buffer_); - for (CORBA::ULong i = 0; i < this->length_; ++i) - tmp[i] = old[i]; + for (CORBA::ULong i = 0; i < this->length_; ++i) + tmp[i] = old[i]; if (this->release_) - _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::freebuf (old); + _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::freebuf (old); } this->buffer_ = tmp; @@ -376,7 +378,7 @@ TAO_NAMESPACE_END void ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::_deallocate_buffer (void) { - if (this->buffer_ == 0 || this->release_ == 0) + if (this->buffer_ == 0 || this->release_ == 0) return; ImplementationRepository::EnvironmentVariable *tmp = ACE_reinterpret_cast (ImplementationRepository::EnvironmentVariable *,this->buffer_); @@ -385,7 +387,7 @@ TAO_NAMESPACE_END this->buffer_ = 0; } - ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::~_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList (void) // Dtor. + ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList::~_TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList (void) // Dtor. { this->_deallocate_buffer (); } @@ -397,7 +399,7 @@ TAO_NAMESPACE_END #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ #if !defined (_IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CS_) -#define _IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CS_ +#define _IMPLEMENTATIONREPOSITORY_ENVIRONMENTLIST_CS_ // ************************************************************* // ImplementationRepository::EnvironmentList @@ -423,7 +425,7 @@ ImplementationRepository::EnvironmentList::EnvironmentList (CORBA::ULong max, CO #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ (max, length, buffer, release) {} -ImplementationRepository::EnvironmentList::EnvironmentList (const EnvironmentList &seq) // copy ctor +ImplementationRepository::EnvironmentList::EnvironmentList (const EnvironmentList &seq) // copy ctor : #if !defined (TAO_USE_SEQUENCE_TEMPLATES) _TAO_Unbounded_Sequence_ImplementationRepository_EnvironmentList @@ -443,13 +445,13 @@ void ImplementationRepository::EnvironmentList::_tao_any_destructor (void *x) #endif /* end #if !defined */ -static const CORBA::Long _oc_ImplementationRepository_EnvironmentList[] = +static const CORBA::Long _oc_ImplementationRepository_EnvironmentList[] = { - TAO_ENCAP_BYTE_ORDER, // byte order - 49, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f456e76), ACE_NTOHL (0x69726f6e), ACE_NTOHL (0x6d656e74), ACE_NTOHL (0x4c697374), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:ImplementationRepository/EnvironmentList:1.0 - 16, ACE_NTOHL (0x456e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e744c), ACE_NTOHL (0x69737400), // name = EnvironmentList + TAO_ENCAP_BYTE_ORDER, // byte order + 49, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f456e76), ACE_NTOHL (0x69726f6e), ACE_NTOHL (0x6d656e74), ACE_NTOHL (0x4c697374), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:ImplementationRepository/EnvironmentList:1.0 + 16, ACE_NTOHL (0x456e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e744c), ACE_NTOHL (0x69737400), // name = EnvironmentList CORBA::tk_sequence, // typecode kind - 148, // encapsulation length + 148, // encapsulation length TAO_ENCAP_BYTE_ORDER, // byte order CORBA::tk_struct, // typecode kind 132, // encapsulation length @@ -470,72 +472,72 @@ static const CORBA::Long _oc_ImplementationRepository_EnvironmentList[] = static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_EnvironmentList (CORBA::tk_alias, sizeof (_oc_ImplementationRepository_EnvironmentList), (char *) &_oc_ImplementationRepository_EnvironmentList, 0, sizeof (ImplementationRepository::EnvironmentList)); TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) TAO_NAMESPACE_BEGIN (ImplementationRepository) -TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_EnvironmentList, &_tc_TAO_tc_ImplementationRepository_EnvironmentList) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_EnvironmentList, &_tc_TAO_tc_ImplementationRepository_EnvironmentList) TAO_NAMESPACE_END static const CORBA::Long _oc_ImplementationRepository_ActivationMode[] = { - TAO_ENCAP_BYTE_ORDER, // byte order - 48, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f416374), ACE_NTOHL (0x69766174), ACE_NTOHL (0x696f6e4d), ACE_NTOHL (0x6f64653a), ACE_NTOHL (0x312e3000), // repository ID = IDL:ImplementationRepository/ActivationMode:1.0 - 15, ACE_NTOHL (0x41637469), ACE_NTOHL (0x76617469), ACE_NTOHL (0x6f6e4d6f), ACE_NTOHL (0x64650000), // name = ActivationMode - 4, // member count - 7, ACE_NTOHL (0x4e4f524d), ACE_NTOHL (0x414c0000), // name = NORMAL - 7, ACE_NTOHL (0x4d414e55), ACE_NTOHL (0x414c0000), // name = MANUAL - 11, ACE_NTOHL (0x5045525f), ACE_NTOHL (0x434c4945), ACE_NTOHL (0x4e540000), // name = PER_CLIENT - 11, ACE_NTOHL (0x4155544f), ACE_NTOHL (0x5f535441), ACE_NTOHL (0x52540000), // name = AUTO_START + TAO_ENCAP_BYTE_ORDER, // byte order + 48, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f416374), ACE_NTOHL (0x69766174), ACE_NTOHL (0x696f6e4d), ACE_NTOHL (0x6f64653a), ACE_NTOHL (0x312e3000), // repository ID = IDL:ImplementationRepository/ActivationMode:1.0 + 15, ACE_NTOHL (0x41637469), ACE_NTOHL (0x76617469), ACE_NTOHL (0x6f6e4d6f), ACE_NTOHL (0x64650000), // name = ActivationMode + 4, // member count + 7, ACE_NTOHL (0x4e4f524d), ACE_NTOHL (0x414c0000), // name = NORMAL + 7, ACE_NTOHL (0x4d414e55), ACE_NTOHL (0x414c0000), // name = MANUAL + 11, ACE_NTOHL (0x5045525f), ACE_NTOHL (0x434c4945), ACE_NTOHL (0x4e540000), // name = PER_CLIENT + 11, ACE_NTOHL (0x4155544f), ACE_NTOHL (0x5f535441), ACE_NTOHL (0x52540000), // name = AUTO_START }; -static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_ActivationMode (CORBA::tk_enum, sizeof (_oc_ImplementationRepository_ActivationMode), (char *) &_oc_ImplementationRepository_ActivationMode, 0, sizeof (ImplementationRepository::ActivationMode)); +static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_ActivationMode (CORBA::tk_enum, sizeof (_oc_ImplementationRepository_ActivationMode), (char *) &_oc_ImplementationRepository_ActivationMode, 0, sizeof (ImplementationRepository::ActivationMode)); TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) TAO_NAMESPACE_BEGIN (ImplementationRepository) TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ActivationMode, &_tc_TAO_tc_ImplementationRepository_ActivationMode) TAO_NAMESPACE_END static const CORBA::Long _oc_ImplementationRepository_StartupOptions[] = { - TAO_ENCAP_BYTE_ORDER, // byte order - 48, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f537461), ACE_NTOHL (0x72747570), ACE_NTOHL (0x4f707469), ACE_NTOHL (0x6f6e733a), ACE_NTOHL (0x312e3000), // repository ID = IDL:ImplementationRepository/StartupOptions:1.0 - 15, ACE_NTOHL (0x53746172), ACE_NTOHL (0x7475704f), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000), // name = StartupOptions - 4, // member count - 13, ACE_NTOHL (0x636f6d6d), ACE_NTOHL (0x616e645f), ACE_NTOHL (0x6c696e65), ACE_NTOHL (0x0), // name = command_line + TAO_ENCAP_BYTE_ORDER, // byte order + 48, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f537461), ACE_NTOHL (0x72747570), ACE_NTOHL (0x4f707469), ACE_NTOHL (0x6f6e733a), ACE_NTOHL (0x312e3000), // repository ID = IDL:ImplementationRepository/StartupOptions:1.0 + 15, ACE_NTOHL (0x53746172), ACE_NTOHL (0x7475704f), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000), // name = StartupOptions + 4, // member count + 13, ACE_NTOHL (0x636f6d6d), ACE_NTOHL (0x616e645f), ACE_NTOHL (0x6c696e65), ACE_NTOHL (0x0), // name = command_line CORBA::tk_string, - 0U, // string length - 12, ACE_NTOHL (0x656e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e7400), // name = environment - CORBA::tk_alias, // typecode kind for typedefs - 236, // encapsulation length + 0U, // string length + 12, ACE_NTOHL (0x656e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e7400), // name = environment + CORBA::tk_alias, // typecode kind for typedefs + 236, // encapsulation length TAO_ENCAP_BYTE_ORDER, // byte order - 49, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f456e76), ACE_NTOHL (0x69726f6e), ACE_NTOHL (0x6d656e74), ACE_NTOHL (0x4c697374), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:ImplementationRepository/EnvironmentList:1.0 - 16, ACE_NTOHL (0x456e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e744c), ACE_NTOHL (0x69737400), // name = EnvironmentList - CORBA::tk_sequence, // typecode kind + 49, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f456e76), ACE_NTOHL (0x69726f6e), ACE_NTOHL (0x6d656e74), ACE_NTOHL (0x4c697374), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:ImplementationRepository/EnvironmentList:1.0 + 16, ACE_NTOHL (0x456e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e744c), ACE_NTOHL (0x69737400), // name = EnvironmentList + CORBA::tk_sequence, // typecode kind 148, // encapsulation length TAO_ENCAP_BYTE_ORDER, // byte order - CORBA::tk_struct, // typecode kind + CORBA::tk_struct, // typecode kind 132, // encapsulation length - TAO_ENCAP_BYTE_ORDER, // byte order - 53, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f456e76), ACE_NTOHL (0x69726f6e), ACE_NTOHL (0x6d656e74), ACE_NTOHL (0x56617269), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:ImplementationRepository/EnvironmentVariable:1.0 - 20, ACE_NTOHL (0x456e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e7456), ACE_NTOHL (0x61726961), ACE_NTOHL (0x626c6500), // name = EnvironmentVariable - 2, // member count - 5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0), // name = name - CORBA::tk_string, - 0U, // string length - 6, ACE_NTOHL (0x76616c75), ACE_NTOHL (0x65000000), // name = value - CORBA::tk_string, - 0U, // string length + TAO_ENCAP_BYTE_ORDER, // byte order + 53, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f456e76), ACE_NTOHL (0x69726f6e), ACE_NTOHL (0x6d656e74), ACE_NTOHL (0x56617269), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:ImplementationRepository/EnvironmentVariable:1.0 + 20, ACE_NTOHL (0x456e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e7456), ACE_NTOHL (0x61726961), ACE_NTOHL (0x626c6500), // name = EnvironmentVariable + 2, // member count + 5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0), // name = name + CORBA::tk_string, + 0U, // string length + 6, ACE_NTOHL (0x76616c75), ACE_NTOHL (0x65000000), // name = value + CORBA::tk_string, + 0U, // string length 0U, - 18, ACE_NTOHL (0x776f726b), ACE_NTOHL (0x696e675f), ACE_NTOHL (0x64697265), ACE_NTOHL (0x63746f72), ACE_NTOHL (0x79000000), // name = working_directory + 18, ACE_NTOHL (0x776f726b), ACE_NTOHL (0x696e675f), ACE_NTOHL (0x64697265), ACE_NTOHL (0x63746f72), ACE_NTOHL (0x79000000), // name = working_directory CORBA::tk_string, - 0U, // string length - 11, ACE_NTOHL (0x61637469), ACE_NTOHL (0x76617469), ACE_NTOHL (0x6f6e0000), // name = activation + 0U, // string length + 11, ACE_NTOHL (0x61637469), ACE_NTOHL (0x76617469), ACE_NTOHL (0x6f6e0000), // name = activation CORBA::tk_enum, // typecode kind - 136, // encapsulation length + 136, // encapsulation length TAO_ENCAP_BYTE_ORDER, // byte order - 48, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f416374), ACE_NTOHL (0x69766174), ACE_NTOHL (0x696f6e4d), ACE_NTOHL (0x6f64653a), ACE_NTOHL (0x312e3000), // repository ID = IDL:ImplementationRepository/ActivationMode:1.0 - 15, ACE_NTOHL (0x41637469), ACE_NTOHL (0x76617469), ACE_NTOHL (0x6f6e4d6f), ACE_NTOHL (0x64650000), // name = ActivationMode + 48, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f416374), ACE_NTOHL (0x69766174), ACE_NTOHL (0x696f6e4d), ACE_NTOHL (0x6f64653a), ACE_NTOHL (0x312e3000), // repository ID = IDL:ImplementationRepository/ActivationMode:1.0 + 15, ACE_NTOHL (0x41637469), ACE_NTOHL (0x76617469), ACE_NTOHL (0x6f6e4d6f), ACE_NTOHL (0x64650000), // name = ActivationMode 4, // member count - 7, ACE_NTOHL (0x4e4f524d), ACE_NTOHL (0x414c0000), // name = NORMAL - 7, ACE_NTOHL (0x4d414e55), ACE_NTOHL (0x414c0000), // name = MANUAL - 11, ACE_NTOHL (0x5045525f), ACE_NTOHL (0x434c4945), ACE_NTOHL (0x4e540000), // name = PER_CLIENT - 11, ACE_NTOHL (0x4155544f), ACE_NTOHL (0x5f535441), ACE_NTOHL (0x52540000), // name = AUTO_START + 7, ACE_NTOHL (0x4e4f524d), ACE_NTOHL (0x414c0000), // name = NORMAL + 7, ACE_NTOHL (0x4d414e55), ACE_NTOHL (0x414c0000), // name = MANUAL + 11, ACE_NTOHL (0x5045525f), ACE_NTOHL (0x434c4945), ACE_NTOHL (0x4e540000), // name = PER_CLIENT + 11, ACE_NTOHL (0x4155544f), ACE_NTOHL (0x5f535441), ACE_NTOHL (0x52540000), // name = AUTO_START }; static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_StartupOptions (CORBA::tk_struct, sizeof (_oc_ImplementationRepository_StartupOptions), (char *) &_oc_ImplementationRepository_StartupOptions, 0, sizeof (ImplementationRepository::StartupOptions)); @@ -545,62 +547,62 @@ TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_StartupOptions, &_tc_TAO_tc_Imple TAO_NAMESPACE_END void ImplementationRepository::StartupOptions::_tao_any_destructor (void *x) { - ImplementationRepository::StartupOptions *tmp = ACE_static_cast (ImplementationRepository::StartupOptions*,x); + ImplementationRepository::StartupOptions *tmp = ACE_static_cast (ImplementationRepository::StartupOptions*,x); delete tmp; } static const CORBA::Long _oc_ImplementationRepository_ServerInformation[] = { - TAO_ENCAP_BYTE_ORDER, // byte order - 51, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f536572), ACE_NTOHL (0x76657249), ACE_NTOHL (0x6e666f72), ACE_NTOHL (0x6d617469), ACE_NTOHL (0x6f6e3a31), ACE_NTOHL (0x2e300000), // repository ID = IDL:ImplementationRepository/ServerInformation:1.0 - 18, ACE_NTOHL (0x53657276), ACE_NTOHL (0x6572496e), ACE_NTOHL (0x666f726d), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e000000), // name = ServerInformation - 4, // member count - 15, ACE_NTOHL (0x6c6f6769), ACE_NTOHL (0x63616c5f), ACE_NTOHL (0x73657276), ACE_NTOHL (0x65720000), // name = logical_server + TAO_ENCAP_BYTE_ORDER, // byte order + 51, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f536572), ACE_NTOHL (0x76657249), ACE_NTOHL (0x6e666f72), ACE_NTOHL (0x6d617469), ACE_NTOHL (0x6f6e3a31), ACE_NTOHL (0x2e300000), // repository ID = IDL:ImplementationRepository/ServerInformation:1.0 + 18, ACE_NTOHL (0x53657276), ACE_NTOHL (0x6572496e), ACE_NTOHL (0x666f726d), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e000000), // name = ServerInformation + 4, // member count + 15, ACE_NTOHL (0x6c6f6769), ACE_NTOHL (0x63616c5f), ACE_NTOHL (0x73657276), ACE_NTOHL (0x65720000), // name = logical_server CORBA::tk_string, - 0U, // string length - 7, ACE_NTOHL (0x73657276), ACE_NTOHL (0x65720000), // name = server + 0U, // string length + 7, ACE_NTOHL (0x73657276), ACE_NTOHL (0x65720000), // name = server CORBA::tk_string, - 0U, // string length - 8, ACE_NTOHL (0x73746172), ACE_NTOHL (0x74757000), // name = startup - CORBA::tk_struct, // typecode kind - 560, // encapsulation length + 0U, // string length + 8, ACE_NTOHL (0x73746172), ACE_NTOHL (0x74757000), // name = startup + CORBA::tk_struct, // typecode kind + 560, // encapsulation length TAO_ENCAP_BYTE_ORDER, // byte order - 48, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f537461), ACE_NTOHL (0x72747570), ACE_NTOHL (0x4f707469), ACE_NTOHL (0x6f6e733a), ACE_NTOHL (0x312e3000), // repository ID = IDL:ImplementationRepository/StartupOptions:1.0 - 15, ACE_NTOHL (0x53746172), ACE_NTOHL (0x7475704f), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000), // name = StartupOptions + 48, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f537461), ACE_NTOHL (0x72747570), ACE_NTOHL (0x4f707469), ACE_NTOHL (0x6f6e733a), ACE_NTOHL (0x312e3000), // repository ID = IDL:ImplementationRepository/StartupOptions:1.0 + 15, ACE_NTOHL (0x53746172), ACE_NTOHL (0x7475704f), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000), // name = StartupOptions 4, // member count - 13, ACE_NTOHL (0x636f6d6d), ACE_NTOHL (0x616e645f), ACE_NTOHL (0x6c696e65), ACE_NTOHL (0x0), // name = command_line + 13, ACE_NTOHL (0x636f6d6d), ACE_NTOHL (0x616e645f), ACE_NTOHL (0x6c696e65), ACE_NTOHL (0x0), // name = command_line CORBA::tk_string, - 0U, // string length - 12, ACE_NTOHL (0x656e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e7400), // name = environment - CORBA::tk_alias, // typecode kind for typedefs + 0U, // string length + 12, ACE_NTOHL (0x656e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e7400), // name = environment + CORBA::tk_alias, // typecode kind for typedefs 236, // encapsulation length TAO_ENCAP_BYTE_ORDER, // byte order 49, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f456e76), ACE_NTOHL (0x69726f6e), ACE_NTOHL (0x6d656e74), ACE_NTOHL (0x4c697374), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:ImplementationRepository/EnvironmentList:1.0 16, ACE_NTOHL (0x456e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e744c), ACE_NTOHL (0x69737400), // name = EnvironmentList CORBA::tk_sequence, // typecode kind 148, // encapsulation length - TAO_ENCAP_BYTE_ORDER, // byte order - CORBA::tk_struct, // typecode kind - 132, // encapsulation length - TAO_ENCAP_BYTE_ORDER, // byte order - 53, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f456e76), ACE_NTOHL (0x69726f6e), ACE_NTOHL (0x6d656e74), ACE_NTOHL (0x56617269), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:ImplementationRepository/EnvironmentVariable:1.0 - 20, ACE_NTOHL (0x456e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e7456), ACE_NTOHL (0x61726961), ACE_NTOHL (0x626c6500), // name = EnvironmentVariable - 2, // member count - 5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0), // name = name - CORBA::tk_string, - 0U, // string length - 6, ACE_NTOHL (0x76616c75), ACE_NTOHL (0x65000000), // name = value - CORBA::tk_string, - 0U, // string length - - 0U, - - - 18, ACE_NTOHL (0x776f726b), ACE_NTOHL (0x696e675f), ACE_NTOHL (0x64697265), ACE_NTOHL (0x63746f72), ACE_NTOHL (0x79000000), // name = working_directory + TAO_ENCAP_BYTE_ORDER, // byte order + CORBA::tk_struct, // typecode kind + 132, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 53, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f456e76), ACE_NTOHL (0x69726f6e), ACE_NTOHL (0x6d656e74), ACE_NTOHL (0x56617269), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:ImplementationRepository/EnvironmentVariable:1.0 + 20, ACE_NTOHL (0x456e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e7456), ACE_NTOHL (0x61726961), ACE_NTOHL (0x626c6500), // name = EnvironmentVariable + 2, // member count + 5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0), // name = name + CORBA::tk_string, + 0U, // string length + 6, ACE_NTOHL (0x76616c75), ACE_NTOHL (0x65000000), // name = value + CORBA::tk_string, + 0U, // string length + + 0U, + + + 18, ACE_NTOHL (0x776f726b), ACE_NTOHL (0x696e675f), ACE_NTOHL (0x64697265), ACE_NTOHL (0x63746f72), ACE_NTOHL (0x79000000), // name = working_directory CORBA::tk_string, - 0U, // string length - 11, ACE_NTOHL (0x61637469), ACE_NTOHL (0x76617469), ACE_NTOHL (0x6f6e0000), // name = activation - CORBA::tk_enum, // typecode kind + 0U, // string length + 11, ACE_NTOHL (0x61637469), ACE_NTOHL (0x76617469), ACE_NTOHL (0x6f6e0000), // name = activation + CORBA::tk_enum, // typecode kind 136, // encapsulation length TAO_ENCAP_BYTE_ORDER, // byte order 48, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f416374), ACE_NTOHL (0x69766174), ACE_NTOHL (0x696f6e4d), ACE_NTOHL (0x6f64653a), ACE_NTOHL (0x312e3000), // repository ID = IDL:ImplementationRepository/ActivationMode:1.0 @@ -613,16 +615,16 @@ static const CORBA::Long _oc_ImplementationRepository_ServerInformation[] = 9, ACE_NTOHL (0x6c6f6361), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0), // name = location - CORBA::tk_alias, // typecode kind for typedefs + CORBA::tk_alias, // typecode kind for typedefs 72, // encapsulation length TAO_ENCAP_BYTE_ORDER, // byte order - 41, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f416464), ACE_NTOHL (0x72657373), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:ImplementationRepository/Address:1.0 - 8, ACE_NTOHL (0x41646472), ACE_NTOHL (0x65737300), // name = Address + 41, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f416464), ACE_NTOHL (0x72657373), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:ImplementationRepository/Address:1.0 + 8, ACE_NTOHL (0x41646472), ACE_NTOHL (0x65737300), // name = Address CORBA::tk_string, - 0U, // string length + 0U, // string length }; -static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_ServerInformation (CORBA::tk_struct, sizeof (_oc_ImplementationRepository_ServerInformation), (char *) &_oc_ImplementationRepository_ServerInformation, 0, sizeof (ImplementationRepository::ServerInformation)); +static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_ServerInformation (CORBA::tk_struct, sizeof (_oc_ImplementationRepository_ServerInformation), (char *) &_oc_ImplementationRepository_ServerInformation, 0, sizeof (ImplementationRepository::ServerInformation)); TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) TAO_NAMESPACE_BEGIN (ImplementationRepository) TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ServerInformation, &_tc_TAO_tc_ImplementationRepository_ServerInformation) @@ -637,23 +639,23 @@ void ImplementationRepository::ServerInformation::_tao_any_destructor (void *x) #if !defined (TAO_USE_SEQUENCE_TEMPLATES) #if !defined (__TAO_UNBOUNDED_SEQUENCE_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CS_) -#define __TAO_UNBOUNDED_SEQUENCE_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CS_ +#define __TAO_UNBOUNDED_SEQUENCE_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CS_ void ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::_allocate_buffer (CORBA::ULong length) { ImplementationRepository::ServerInformation* tmp = 0; - tmp = _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::allocbuf (length); + tmp = _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::allocbuf (length); if (this->buffer_ != 0) { ImplementationRepository::ServerInformation *old = ACE_reinterpret_cast (ImplementationRepository::ServerInformation *,this->buffer_); - for (CORBA::ULong i = 0; i < this->length_; ++i) - tmp[i] = old[i]; + for (CORBA::ULong i = 0; i < this->length_; ++i) + tmp[i] = old[i]; if (this->release_) - _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::freebuf (old); + _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::freebuf (old); } this->buffer_ = tmp; @@ -662,10 +664,10 @@ void ImplementationRepository::ServerInformation::_tao_any_destructor (void *x) void ImplementationRepository::_TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::_deallocate_buffer (void) { - if (this->buffer_ == 0 || this->release_ == 0) + if (this->buffer_ == 0 || this->release_ == 0) return; - ImplementationRepository::ServerInformation *tmp = ACE_reinterpret_cast (ImplementationRepository::ServerInformation *,this->buffer_); + ImplementationRepository::ServerInformation *tmp = ACE_reinterpret_cast (ImplementationRepository::ServerInformation *,this->buffer_); _TAO_Unbounded_Sequence_ImplementationRepository_ServerInformationList::freebuf (tmp); this->buffer_ = 0; @@ -683,7 +685,7 @@ void ImplementationRepository::ServerInformation::_tao_any_destructor (void *x) #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ #if !defined (_IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CS_) -#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CS_ +#define _IMPLEMENTATIONREPOSITORY_SERVERINFORMATIONLIST_CS_ // ************************************************************* // ImplementationRepository::ServerInformationList @@ -718,9 +720,9 @@ ImplementationRepository::ServerInformationList::ServerInformationList (const Se #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ (seq) {} -ImplementationRepository::ServerInformationList::~ServerInformationList (void) // dtor +ImplementationRepository::ServerInformationList::~ServerInformationList (void) // dtor {} -void ImplementationRepository::ServerInformationList::_tao_any_destructor (void *x) +void ImplementationRepository::ServerInformationList::_tao_any_destructor (void *x) { ImplementationRepository::ServerInformationList *tmp = ACE_static_cast (ImplementationRepository::ServerInformationList*,x); delete tmp; @@ -731,11 +733,11 @@ void ImplementationRepository::ServerInformationList::_tao_any_destructor (void static const CORBA::Long _oc_ImplementationRepository_ServerInformationList[] = { - TAO_ENCAP_BYTE_ORDER, // byte order - 55, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f536572), ACE_NTOHL (0x76657249), ACE_NTOHL (0x6e666f72), ACE_NTOHL (0x6d617469), ACE_NTOHL (0x6f6e4c69), ACE_NTOHL (0x73743a31), ACE_NTOHL (0x2e300000), // repository ID = IDL:ImplementationRepository/ServerInformationList:1.0 - 22, ACE_NTOHL (0x53657276), ACE_NTOHL (0x6572496e), ACE_NTOHL (0x666f726d), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e4c6973), ACE_NTOHL (0x74000000), // name = ServerInformationList + TAO_ENCAP_BYTE_ORDER, // byte order + 55, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f536572), ACE_NTOHL (0x76657249), ACE_NTOHL (0x6e666f72), ACE_NTOHL (0x6d617469), ACE_NTOHL (0x6f6e4c69), ACE_NTOHL (0x73743a31), ACE_NTOHL (0x2e300000), // repository ID = IDL:ImplementationRepository/ServerInformationList:1.0 + 22, ACE_NTOHL (0x53657276), ACE_NTOHL (0x6572496e), ACE_NTOHL (0x666f726d), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e4c6973), ACE_NTOHL (0x74000000), // name = ServerInformationList CORBA::tk_sequence, // typecode kind - 828, // encapsulation length + 828, // encapsulation length TAO_ENCAP_BYTE_ORDER, // byte order CORBA::tk_struct, // typecode kind 812, // encapsulation length @@ -750,77 +752,77 @@ static const CORBA::Long _oc_ImplementationRepository_ServerInformationList[] = CORBA::tk_string, 0U, // string length 8, ACE_NTOHL (0x73746172), ACE_NTOHL (0x74757000), // name = startup - CORBA::tk_struct, // typecode kind + CORBA::tk_struct, // typecode kind 560, // encapsulation length - TAO_ENCAP_BYTE_ORDER, // byte order - 48, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f537461), ACE_NTOHL (0x72747570), ACE_NTOHL (0x4f707469), ACE_NTOHL (0x6f6e733a), ACE_NTOHL (0x312e3000), // repository ID = IDL:ImplementationRepository/StartupOptions:1.0 - 15, ACE_NTOHL (0x53746172), ACE_NTOHL (0x7475704f), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000), // name = StartupOptions - 4, // member count - 13, ACE_NTOHL (0x636f6d6d), ACE_NTOHL (0x616e645f), ACE_NTOHL (0x6c696e65), ACE_NTOHL (0x0), // name = command_line - CORBA::tk_string, - 0U, // string length - 12, ACE_NTOHL (0x656e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e7400), // name = environment - CORBA::tk_alias, // typecode kind for typedefs - 236, // encapsulation length - TAO_ENCAP_BYTE_ORDER, // byte order - 49, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f456e76), ACE_NTOHL (0x69726f6e), ACE_NTOHL (0x6d656e74), ACE_NTOHL (0x4c697374), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:ImplementationRepository/EnvironmentList:1.0 - 16, ACE_NTOHL (0x456e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e744c), ACE_NTOHL (0x69737400), // name = EnvironmentList - CORBA::tk_sequence, // typecode kind - 148, // encapsulation length - TAO_ENCAP_BYTE_ORDER, // byte order - CORBA::tk_struct, // typecode kind - 132, // encapsulation length - TAO_ENCAP_BYTE_ORDER, // byte order - 53, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f456e76), ACE_NTOHL (0x69726f6e), ACE_NTOHL (0x6d656e74), ACE_NTOHL (0x56617269), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:ImplementationRepository/EnvironmentVariable:1.0 - 20, ACE_NTOHL (0x456e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e7456), ACE_NTOHL (0x61726961), ACE_NTOHL (0x626c6500), // name = EnvironmentVariable - 2, // member count - 5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0), // name = name - CORBA::tk_string, - 0U, // string length - 6, ACE_NTOHL (0x76616c75), ACE_NTOHL (0x65000000), // name = value - CORBA::tk_string, - 0U, // string length - - 0U, - - - 18, ACE_NTOHL (0x776f726b), ACE_NTOHL (0x696e675f), ACE_NTOHL (0x64697265), ACE_NTOHL (0x63746f72), ACE_NTOHL (0x79000000), // name = working_directory - CORBA::tk_string, - 0U, // string length - 11, ACE_NTOHL (0x61637469), ACE_NTOHL (0x76617469), ACE_NTOHL (0x6f6e0000), // name = activation - CORBA::tk_enum, // typecode kind - 136, // encapsulation length - TAO_ENCAP_BYTE_ORDER, // byte order - 48, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f416374), ACE_NTOHL (0x69766174), ACE_NTOHL (0x696f6e4d), ACE_NTOHL (0x6f64653a), ACE_NTOHL (0x312e3000), // repository ID = IDL:ImplementationRepository/ActivationMode:1.0 - 15, ACE_NTOHL (0x41637469), ACE_NTOHL (0x76617469), ACE_NTOHL (0x6f6e4d6f), ACE_NTOHL (0x64650000), // name = ActivationMode - 4, // member count - 7, ACE_NTOHL (0x4e4f524d), ACE_NTOHL (0x414c0000), // name = NORMAL - 7, ACE_NTOHL (0x4d414e55), ACE_NTOHL (0x414c0000), // name = MANUAL - 11, ACE_NTOHL (0x5045525f), ACE_NTOHL (0x434c4945), ACE_NTOHL (0x4e540000), // name = PER_CLIENT - 11, ACE_NTOHL (0x4155544f), ACE_NTOHL (0x5f535441), ACE_NTOHL (0x52540000), // name = AUTO_START + TAO_ENCAP_BYTE_ORDER, // byte order + 48, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f537461), ACE_NTOHL (0x72747570), ACE_NTOHL (0x4f707469), ACE_NTOHL (0x6f6e733a), ACE_NTOHL (0x312e3000), // repository ID = IDL:ImplementationRepository/StartupOptions:1.0 + 15, ACE_NTOHL (0x53746172), ACE_NTOHL (0x7475704f), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000), // name = StartupOptions + 4, // member count + 13, ACE_NTOHL (0x636f6d6d), ACE_NTOHL (0x616e645f), ACE_NTOHL (0x6c696e65), ACE_NTOHL (0x0), // name = command_line + CORBA::tk_string, + 0U, // string length + 12, ACE_NTOHL (0x656e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e7400), // name = environment + CORBA::tk_alias, // typecode kind for typedefs + 236, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 49, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f456e76), ACE_NTOHL (0x69726f6e), ACE_NTOHL (0x6d656e74), ACE_NTOHL (0x4c697374), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:ImplementationRepository/EnvironmentList:1.0 + 16, ACE_NTOHL (0x456e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e744c), ACE_NTOHL (0x69737400), // name = EnvironmentList + CORBA::tk_sequence, // typecode kind + 148, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + CORBA::tk_struct, // typecode kind + 132, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 53, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f456e76), ACE_NTOHL (0x69726f6e), ACE_NTOHL (0x6d656e74), ACE_NTOHL (0x56617269), ACE_NTOHL (0x61626c65), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:ImplementationRepository/EnvironmentVariable:1.0 + 20, ACE_NTOHL (0x456e7669), ACE_NTOHL (0x726f6e6d), ACE_NTOHL (0x656e7456), ACE_NTOHL (0x61726961), ACE_NTOHL (0x626c6500), // name = EnvironmentVariable + 2, // member count + 5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0), // name = name + CORBA::tk_string, + 0U, // string length + 6, ACE_NTOHL (0x76616c75), ACE_NTOHL (0x65000000), // name = value + CORBA::tk_string, + 0U, // string length + + 0U, + + + 18, ACE_NTOHL (0x776f726b), ACE_NTOHL (0x696e675f), ACE_NTOHL (0x64697265), ACE_NTOHL (0x63746f72), ACE_NTOHL (0x79000000), // name = working_directory + CORBA::tk_string, + 0U, // string length + 11, ACE_NTOHL (0x61637469), ACE_NTOHL (0x76617469), ACE_NTOHL (0x6f6e0000), // name = activation + CORBA::tk_enum, // typecode kind + 136, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 48, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f416374), ACE_NTOHL (0x69766174), ACE_NTOHL (0x696f6e4d), ACE_NTOHL (0x6f64653a), ACE_NTOHL (0x312e3000), // repository ID = IDL:ImplementationRepository/ActivationMode:1.0 + 15, ACE_NTOHL (0x41637469), ACE_NTOHL (0x76617469), ACE_NTOHL (0x6f6e4d6f), ACE_NTOHL (0x64650000), // name = ActivationMode + 4, // member count + 7, ACE_NTOHL (0x4e4f524d), ACE_NTOHL (0x414c0000), // name = NORMAL + 7, ACE_NTOHL (0x4d414e55), ACE_NTOHL (0x414c0000), // name = MANUAL + 11, ACE_NTOHL (0x5045525f), ACE_NTOHL (0x434c4945), ACE_NTOHL (0x4e540000), // name = PER_CLIENT + 11, ACE_NTOHL (0x4155544f), ACE_NTOHL (0x5f535441), ACE_NTOHL (0x52540000), // name = AUTO_START 9, ACE_NTOHL (0x6c6f6361), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0), // name = location - CORBA::tk_alias, // typecode kind for typedefs + CORBA::tk_alias, // typecode kind for typedefs 72, // encapsulation length - TAO_ENCAP_BYTE_ORDER, // byte order - 41, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f416464), ACE_NTOHL (0x72657373), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:ImplementationRepository/Address:1.0 - 8, ACE_NTOHL (0x41646472), ACE_NTOHL (0x65737300), // name = Address - CORBA::tk_string, - 0U, // string length + TAO_ENCAP_BYTE_ORDER, // byte order + 41, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f416464), ACE_NTOHL (0x72657373), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:ImplementationRepository/Address:1.0 + 8, ACE_NTOHL (0x41646472), ACE_NTOHL (0x65737300), // name = Address + CORBA::tk_string, + 0U, // string length 0U, }; -static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_ServerInformationList (CORBA::tk_alias, sizeof (_oc_ImplementationRepository_ServerInformationList), (char *) &_oc_ImplementationRepository_ServerInformationList, 0, sizeof (ImplementationRepository::ServerInformationList)); +static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_ServerInformationList (CORBA::tk_alias, sizeof (_oc_ImplementationRepository_ServerInformationList), (char *) &_oc_ImplementationRepository_ServerInformationList, 0, sizeof (ImplementationRepository::ServerInformationList)); TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) TAO_NAMESPACE_BEGIN (ImplementationRepository) TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ServerInformationList, &_tc_TAO_tc_ImplementationRepository_ServerInformationList) TAO_NAMESPACE_END void ImplementationRepository::Administration::_tao_any_destructor (void *x) { - ImplementationRepository::Administration *tmp = ACE_static_cast (ImplementationRepository::Administration*,x); + ImplementationRepository::Administration *tmp = ACE_static_cast (ImplementationRepository::Administration*,x); CORBA::release (tmp); } @@ -830,11 +832,11 @@ ImplementationRepository::Administration_ptr ImplementationRepository::Administr ) { if (CORBA::is_nil (obj)) - return Administration::_nil (); - CORBA::Boolean is_a = obj->_is_a ("IDL:ImplementationRepository/Administration:1.0", ACE_TRY_ENV); + return Administration::_nil (); + CORBA::Boolean is_a = obj->_is_a ("IDL:ImplementationRepository/Administration:1.0", ACE_TRY_ENV); ACE_CHECK_RETURN (Administration::_nil ()); if (is_a == 0) - return Administration::_nil (); + return Administration::_nil (); return Administration::_unchecked_narrow (obj, ACE_TRY_ENV); } @@ -844,11 +846,11 @@ ImplementationRepository::Administration_ptr ImplementationRepository::Administr ) { if (CORBA::is_nil (obj)) - return Administration::_nil (); + return Administration::_nil (); TAO_Stub* stub = obj->_stubobj (); stub->_incr_refcnt (); Administration_ptr default_proxy = Administration::_nil (); - if (obj->_is_collocated () && _TAO_collocation_ImplementationRepository_Administration_Stub_Factory_function_pointer != 0) + if (obj->_is_collocated () && _TAO_collocation_ImplementationRepository_Administration_Stub_Factory_function_pointer != 0) { default_proxy = _TAO_collocation_ImplementationRepository_Administration_Stub_Factory_function_pointer (obj); } @@ -867,12 +869,12 @@ ImplementationRepository::Administration::_duplicate (Administration_ptr obj) // default constructor ImplementationRepository::Administration::AlreadyRegistered::AlreadyRegistered (void) - : CORBA_UserException ("IDL:ImplementationRepository/Administration/AlreadyRegistered:1.0") + : CORBA_UserException ("IDL:ImplementationRepository/Administration/AlreadyRegistered:1.0") { } -// destructor - all members are of self managing types -ImplementationRepository::Administration::AlreadyRegistered::~AlreadyRegistered (void) +// destructor - all members are of self managing types +ImplementationRepository::Administration::AlreadyRegistered::~AlreadyRegistered (void) { } @@ -882,9 +884,9 @@ void ImplementationRepository::Administration::AlreadyRegistered::_tao_any_destr delete tmp; } -// copy constructor +// copy constructor ImplementationRepository::Administration::AlreadyRegistered::AlreadyRegistered (const ::ImplementationRepository::Administration::AlreadyRegistered &_tao_excp) - : CORBA_UserException (_tao_excp._id ()) + : CORBA_UserException (_tao_excp._id ()) { } @@ -943,12 +945,12 @@ CORBA::Exception *ImplementationRepository::Administration::AlreadyRegistered::_ static const CORBA::Long _oc_ImplementationRepository_Administration_AlreadyRegistered[] = { - TAO_ENCAP_BYTE_ORDER, // byte order - 66, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f41646d), ACE_NTOHL (0x696e6973), ACE_NTOHL (0x74726174), ACE_NTOHL (0x696f6e2f), ACE_NTOHL (0x416c7265), ACE_NTOHL (0x61647952), ACE_NTOHL (0x65676973), ACE_NTOHL (0x74657265), ACE_NTOHL (0x643a312e), ACE_NTOHL (0x30000000), // repository ID = IDL:ImplementationRepository/Administration/AlreadyRegistered:1.0 - 18, ACE_NTOHL (0x416c7265), ACE_NTOHL (0x61647952), ACE_NTOHL (0x65676973), ACE_NTOHL (0x74657265), ACE_NTOHL (0x64000000), // name = AlreadyRegistered - 0, // member count + TAO_ENCAP_BYTE_ORDER, // byte order + 66, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f41646d), ACE_NTOHL (0x696e6973), ACE_NTOHL (0x74726174), ACE_NTOHL (0x696f6e2f), ACE_NTOHL (0x416c7265), ACE_NTOHL (0x61647952), ACE_NTOHL (0x65676973), ACE_NTOHL (0x74657265), ACE_NTOHL (0x643a312e), ACE_NTOHL (0x30000000), // repository ID = IDL:ImplementationRepository/Administration/AlreadyRegistered:1.0 + 18, ACE_NTOHL (0x416c7265), ACE_NTOHL (0x61647952), ACE_NTOHL (0x65676973), ACE_NTOHL (0x74657265), ACE_NTOHL (0x64000000), // name = AlreadyRegistered + 0, // member count }; -static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_Administration_AlreadyRegistered (CORBA::tk_except, sizeof (_oc_ImplementationRepository_Administration_AlreadyRegistered), (char *) &_oc_ImplementationRepository_Administration_AlreadyRegistered, 0, sizeof (ImplementationRepository::Administration::AlreadyRegistered)); +static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_Administration_AlreadyRegistered (CORBA::tk_except, sizeof (_oc_ImplementationRepository_Administration_AlreadyRegistered), (char *) &_oc_ImplementationRepository_Administration_AlreadyRegistered, 0, sizeof (ImplementationRepository::Administration::AlreadyRegistered)); CORBA::TypeCode_ptr ImplementationRepository::Administration::_tc_AlreadyRegistered = &_tc_TAO_tc_ImplementationRepository_Administration_AlreadyRegistered; CORBA::TypeCode_ptr @@ -959,24 +961,24 @@ ImplementationRepository::Administration::AlreadyRegistered::_type (void) const // default constructor ImplementationRepository::Administration::CannotActivate::CannotActivate (void) - : CORBA_UserException ("IDL:ImplementationRepository/Administration/CannotActivate:1.0") + : CORBA_UserException ("IDL:ImplementationRepository/Administration/CannotActivate:1.0") { } -// destructor - all members are of self managing types +// destructor - all members are of self managing types ImplementationRepository::Administration::CannotActivate::~CannotActivate (void) { } void ImplementationRepository::Administration::CannotActivate::_tao_any_destructor (void *x) { - ImplementationRepository::Administration::CannotActivate *tmp = ACE_static_cast (ImplementationRepository::Administration::CannotActivate*,x); + ImplementationRepository::Administration::CannotActivate *tmp = ACE_static_cast (ImplementationRepository::Administration::CannotActivate*,x); delete tmp; } -// copy constructor -ImplementationRepository::Administration::CannotActivate::CannotActivate (const ::ImplementationRepository::Administration::CannotActivate &_tao_excp) - : CORBA_UserException (_tao_excp._id ()) +// copy constructor +ImplementationRepository::Administration::CannotActivate::CannotActivate (const ::ImplementationRepository::Administration::CannotActivate &_tao_excp) + : CORBA_UserException (_tao_excp._id ()) { this->reason = CORBA::string_dup (_tao_excp.reason.in ()); } @@ -987,7 +989,7 @@ ImplementationRepository::Administration::CannotActivate::operator= (const ::Imp { this->CORBA_UserException::operator= (_tao_excp); - this->reason = CORBA::string_dup (_tao_excp.reason.in ()); + this->reason = CORBA::string_dup (_tao_excp.reason.in ()); return *this; } @@ -1036,39 +1038,39 @@ CORBA::Exception *ImplementationRepository::Administration::CannotActivate::_all } ImplementationRepository::Administration::CannotActivate::CannotActivate ( - const char * _tao_reason + const char * _tao_reason ) - : CORBA_UserException (CORBA::string_dup ("IDL:ImplementationRepository/Administration/CannotActivate:1.0")) + : CORBA_UserException (CORBA::string_dup ("IDL:ImplementationRepository/Administration/CannotActivate:1.0")) { this->reason = CORBA::string_dup (_tao_reason); } static const CORBA::Long _oc_ImplementationRepository_Administration_CannotActivate[] = { - TAO_ENCAP_BYTE_ORDER, // byte order - 63, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f41646d), ACE_NTOHL (0x696e6973), ACE_NTOHL (0x74726174), ACE_NTOHL (0x696f6e2f), ACE_NTOHL (0x43616e6e), ACE_NTOHL (0x6f744163), ACE_NTOHL (0x74697661), ACE_NTOHL (0x74653a31), ACE_NTOHL (0x2e300000), // repository ID = IDL:ImplementationRepository/Administration/CannotActivate:1.0 - 15, ACE_NTOHL (0x43616e6e), ACE_NTOHL (0x6f744163), ACE_NTOHL (0x74697661), ACE_NTOHL (0x74650000), // name = CannotActivate - 1, // member count - 7, ACE_NTOHL (0x72656173), ACE_NTOHL (0x6f6e0000), // name = reason + TAO_ENCAP_BYTE_ORDER, // byte order + 63, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f41646d), ACE_NTOHL (0x696e6973), ACE_NTOHL (0x74726174), ACE_NTOHL (0x696f6e2f), ACE_NTOHL (0x43616e6e), ACE_NTOHL (0x6f744163), ACE_NTOHL (0x74697661), ACE_NTOHL (0x74653a31), ACE_NTOHL (0x2e300000), // repository ID = IDL:ImplementationRepository/Administration/CannotActivate:1.0 + 15, ACE_NTOHL (0x43616e6e), ACE_NTOHL (0x6f744163), ACE_NTOHL (0x74697661), ACE_NTOHL (0x74650000), // name = CannotActivate + 1, // member count + 7, ACE_NTOHL (0x72656173), ACE_NTOHL (0x6f6e0000), // name = reason CORBA::tk_string, - 0U, // string length + 0U, // string length }; static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_Administration_CannotActivate (CORBA::tk_except, sizeof (_oc_ImplementationRepository_Administration_CannotActivate), (char *) &_oc_ImplementationRepository_Administration_CannotActivate, 0, sizeof (ImplementationRepository::Administration::CannotActivate)); CORBA::TypeCode_ptr ImplementationRepository::Administration::_tc_CannotActivate = &_tc_TAO_tc_ImplementationRepository_Administration_CannotActivate; CORBA::TypeCode_ptr -ImplementationRepository::Administration::CannotActivate::_type (void) const +ImplementationRepository::Administration::CannotActivate::_type (void) const { return _tc_CannotActivate; } // default constructor ImplementationRepository::Administration::NotFound::NotFound (void) - : CORBA_UserException ("IDL:ImplementationRepository/Administration/NotFound:1.0") + : CORBA_UserException ("IDL:ImplementationRepository/Administration/NotFound:1.0") { } -// destructor - all members are of self managing types +// destructor - all members are of self managing types ImplementationRepository::Administration::NotFound::~NotFound (void) { } @@ -1079,9 +1081,9 @@ void ImplementationRepository::Administration::NotFound::_tao_any_destructor (vo delete tmp; } -// copy constructor +// copy constructor ImplementationRepository::Administration::NotFound::NotFound (const ::ImplementationRepository::Administration::NotFound &_tao_excp) - : CORBA_UserException (_tao_excp._id ()) + : CORBA_UserException (_tao_excp._id ()) { } @@ -1096,7 +1098,7 @@ ImplementationRepository::Administration::NotFound::operator= (const ::Implement // narrow ImplementationRepository::Administration::NotFound * -ImplementationRepository::Administration::NotFound::_downcast (CORBA::Exception *exc) +ImplementationRepository::Administration::NotFound::_downcast (CORBA::Exception *exc) { if (!ACE_OS::strcmp ("IDL:ImplementationRepository/Administration/NotFound:1.0", exc->_id ())) // same type return ACE_dynamic_cast (NotFound *, exc); @@ -1105,7 +1107,7 @@ ImplementationRepository::Administration::NotFound::_downcast (CORBA::Exception } -void ImplementationRepository::Administration::NotFound::_raise () +void ImplementationRepository::Administration::NotFound::_raise () { TAO_RAISE(*this); } @@ -1134,18 +1136,18 @@ void ImplementationRepository::Administration::NotFound::_tao_decode ( CORBA::Exception *ImplementationRepository::Administration::NotFound::_alloc (void) { CORBA::Exception *retval = 0; - ACE_NEW_RETURN (retval, ::ImplementationRepository::Administration::NotFound, 0); + ACE_NEW_RETURN (retval, ::ImplementationRepository::Administration::NotFound, 0); return retval; } -static const CORBA::Long _oc_ImplementationRepository_Administration_NotFound[] = +static const CORBA::Long _oc_ImplementationRepository_Administration_NotFound[] = { - TAO_ENCAP_BYTE_ORDER, // byte order - 57, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f41646d), ACE_NTOHL (0x696e6973), ACE_NTOHL (0x74726174), ACE_NTOHL (0x696f6e2f), ACE_NTOHL (0x4e6f7446), ACE_NTOHL (0x6f756e64), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:ImplementationRepository/Administration/NotFound:1.0 + TAO_ENCAP_BYTE_ORDER, // byte order + 57, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f41646d), ACE_NTOHL (0x696e6973), ACE_NTOHL (0x74726174), ACE_NTOHL (0x696f6e2f), ACE_NTOHL (0x4e6f7446), ACE_NTOHL (0x6f756e64), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:ImplementationRepository/Administration/NotFound:1.0 9, ACE_NTOHL (0x4e6f7446), ACE_NTOHL (0x6f756e64), ACE_NTOHL (0x0), // name = NotFound - 0, // member count + 0, // member count }; -static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_Administration_NotFound (CORBA::tk_except, sizeof (_oc_ImplementationRepository_Administration_NotFound), (char *) &_oc_ImplementationRepository_Administration_NotFound, 0, sizeof (ImplementationRepository::Administration::NotFound)); +static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_Administration_NotFound (CORBA::tk_except, sizeof (_oc_ImplementationRepository_Administration_NotFound), (char *) &_oc_ImplementationRepository_Administration_NotFound, 0, sizeof (ImplementationRepository::Administration::NotFound)); CORBA::TypeCode_ptr ImplementationRepository::Administration::_tc_NotFound = &_tc_TAO_tc_ImplementationRepository_Administration_NotFound; CORBA::TypeCode_ptr @@ -1183,34 +1185,35 @@ void ImplementationRepository::Administration::activate_server ( istub, "activate_server", 15, + 1, istub->orb_core () ); for (;;) { - _tao_call.start (ACE_TRY_ENV); - ACE_CHECK; - CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; - // Tremporary hack until GIOP 1.2 is implemented. - - _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); - ACE_CHECK; - - TAO_OutputCDR &_tao_out = _tao_call.out_stream (); - if (!( - (_tao_out << server) - )) - ACE_THROW (CORBA::MARSHAL ()); - int _invoke_status = - _tao_call.invoke (_tao_ImplementationRepository_Administration_activate_server_exceptiondata, 2, ACE_TRY_ENV); - ACE_CHECK; - - if (_invoke_status == TAO_INVOKE_RESTART) - continue; - if (_invoke_status != TAO_INVOKE_OK) - { - ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)); - } - break; + _tao_call.start (ACE_TRY_ENV); + ACE_CHECK; + CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; + // Tremporary hack until GIOP 1.2 is implemented. + + _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); + ACE_CHECK; + + TAO_OutputCDR &_tao_out = _tao_call.out_stream (); + if (!( + (_tao_out << server) + )) + ACE_THROW (CORBA::MARSHAL ()); + int _invoke_status = + _tao_call.invoke (_tao_ImplementationRepository_Administration_activate_server_exceptiondata, 2, ACE_TRY_ENV); + ACE_CHECK; + + if (_invoke_status == TAO_INVOKE_RESTART) + continue; + if (_invoke_status != TAO_INVOKE_OK) + { + ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)); + } + break; } } @@ -1243,37 +1246,38 @@ void ImplementationRepository::Administration::register_server ( istub, "register_server", 15, + 1, istub->orb_core () ); for (;;) { - _tao_call.start (ACE_TRY_ENV); - ACE_CHECK; - - CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; - // Tremporary hack until GIOP 1.2 is implemented. - - _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); - ACE_CHECK; - - TAO_OutputCDR &_tao_out = _tao_call.out_stream (); - if (!( - (_tao_out << server) && - (_tao_out << options) - )) - ACE_THROW (CORBA::MARSHAL ()); - int _invoke_status = - _tao_call.invoke (_tao_ImplementationRepository_Administration_register_server_exceptiondata, 1, ACE_TRY_ENV); - ACE_CHECK; - - if (_invoke_status == TAO_INVOKE_RESTART) - continue; - if (_invoke_status != TAO_INVOKE_OK) - { - ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)); - } - break; + _tao_call.start (ACE_TRY_ENV); + ACE_CHECK; + + CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; + // Tremporary hack until GIOP 1.2 is implemented. + + _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); + ACE_CHECK; + + TAO_OutputCDR &_tao_out = _tao_call.out_stream (); + if (!( + (_tao_out << server) && + (_tao_out << options) + )) + ACE_THROW (CORBA::MARSHAL ()); + int _invoke_status = + _tao_call.invoke (_tao_ImplementationRepository_Administration_register_server_exceptiondata, 1, ACE_TRY_ENV); + ACE_CHECK; + + if (_invoke_status == TAO_INVOKE_RESTART) + continue; + if (_invoke_status != TAO_INVOKE_OK) + { + ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)); + } + break; } } @@ -1300,35 +1304,36 @@ void ImplementationRepository::Administration::reregister_server ( istub, "reregister_server", 17, + 1, istub->orb_core () ); for (;;) { - _tao_call.start (ACE_TRY_ENV); - ACE_CHECK; - CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; - // Tremporary hack until GIOP 1.2 is implemented. - - _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); - ACE_CHECK; - - TAO_OutputCDR &_tao_out = _tao_call.out_stream (); - if (!( - (_tao_out << server) && - (_tao_out << options) - )) - ACE_THROW (CORBA::MARSHAL ()); - int _invoke_status = - _tao_call.invoke (0, 0, ACE_TRY_ENV); - ACE_CHECK; - - if (_invoke_status == TAO_INVOKE_RESTART) - continue; - if (_invoke_status != TAO_INVOKE_OK) - { - ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)); - } - break; + _tao_call.start (ACE_TRY_ENV); + ACE_CHECK; + CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; + // Tremporary hack until GIOP 1.2 is implemented. + + _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); + ACE_CHECK; + + TAO_OutputCDR &_tao_out = _tao_call.out_stream (); + if (!( + (_tao_out << server) && + (_tao_out << options) + )) + ACE_THROW (CORBA::MARSHAL ()); + int _invoke_status = + _tao_call.invoke (0, 0, ACE_TRY_ENV); + ACE_CHECK; + + if (_invoke_status == TAO_INVOKE_RESTART) + continue; + if (_invoke_status != TAO_INVOKE_OK) + { + ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)); + } + break; } } @@ -1343,7 +1348,7 @@ void ImplementationRepository::Administration::remove_server ( )) { - static TAO_Exception_Data _tao_ImplementationRepository_Administration_remove_server_exceptiondata [] = + static TAO_Exception_Data _tao_ImplementationRepository_Administration_remove_server_exceptiondata [] = { {ImplementationRepository::Administration::_tc_NotFound, ImplementationRepository::Administration::NotFound::_alloc} }; @@ -1360,36 +1365,37 @@ void ImplementationRepository::Administration::remove_server ( istub, "remove_server", 13, + 1, istub->orb_core () ); for (;;) { - _tao_call.start (ACE_TRY_ENV); - ACE_CHECK; - - CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; - // Tremporary hack until GIOP 1.2 is implemented. - - _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); - ACE_CHECK; - - TAO_OutputCDR &_tao_out = _tao_call.out_stream (); - if (!( - (_tao_out << server) - )) - ACE_THROW (CORBA::MARSHAL ()); - int _invoke_status = - _tao_call.invoke (_tao_ImplementationRepository_Administration_remove_server_exceptiondata, 1, ACE_TRY_ENV); - ACE_CHECK; - - if (_invoke_status == TAO_INVOKE_RESTART) - continue; - if (_invoke_status != TAO_INVOKE_OK) - { - ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)); - } - break; + _tao_call.start (ACE_TRY_ENV); + ACE_CHECK; + + CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; + // Tremporary hack until GIOP 1.2 is implemented. + + _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); + ACE_CHECK; + + TAO_OutputCDR &_tao_out = _tao_call.out_stream (); + if (!( + (_tao_out << server) + )) + ACE_THROW (CORBA::MARSHAL ()); + int _invoke_status = + _tao_call.invoke (_tao_ImplementationRepository_Administration_remove_server_exceptiondata, 1, ACE_TRY_ENV); + ACE_CHECK; + + if (_invoke_status == TAO_INVOKE_RESTART) + continue; + if (_invoke_status != TAO_INVOKE_OK) + { + ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)); + } + break; } } @@ -1420,37 +1426,38 @@ void ImplementationRepository::Administration::shutdown_server ( istub, "shutdown_server", 15, + 1, istub->orb_core () ); for (;;) { - _tao_call.start (ACE_TRY_ENV); - ACE_CHECK; + _tao_call.start (ACE_TRY_ENV); + ACE_CHECK; - CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; - // Tremporary hack until GIOP 1.2 is implemented. + CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; + // Tremporary hack until GIOP 1.2 is implemented. - _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); - ACE_CHECK; + _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); + ACE_CHECK; - TAO_OutputCDR &_tao_out = _tao_call.out_stream (); - if (!( - (_tao_out << server) - )) - ACE_THROW (CORBA::MARSHAL ()); - int _invoke_status = - _tao_call.invoke (_tao_ImplementationRepository_Administration_shutdown_server_exceptiondata, 1, ACE_TRY_ENV); - ACE_CHECK; + TAO_OutputCDR &_tao_out = _tao_call.out_stream (); + if (!( + (_tao_out << server) + )) + ACE_THROW (CORBA::MARSHAL ()); + int _invoke_status = + _tao_call.invoke (_tao_ImplementationRepository_Administration_shutdown_server_exceptiondata, 1, ACE_TRY_ENV); + ACE_CHECK; - if (_invoke_status == TAO_INVOKE_RESTART) - continue; - if (_invoke_status != TAO_INVOKE_OK) - { - ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)); - } + if (_invoke_status == TAO_INVOKE_RESTART) + continue; + if (_invoke_status != TAO_INVOKE_OK) + { + ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)); + } - break; + break; } } @@ -1484,49 +1491,50 @@ char * ImplementationRepository::Administration::server_is_running ( istub, "server_is_running", 17, + 1, istub->orb_core () ); for (;;) { - _tao_call.start (ACE_TRY_ENV); - ACE_CHECK_RETURN (0); - - CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; - // Tremporary hack until GIOP 1.2 is implemented. - - _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); - ACE_CHECK_RETURN (0); - - TAO_OutputCDR &_tao_out = _tao_call.out_stream (); - if (!( - (_tao_out << server) && - (_tao_out << addr) && - (_tao_out << server_object) - )) - ACE_THROW_RETURN (CORBA::MARSHAL (), 0); - - int _invoke_status = - _tao_call.invoke (_tao_ImplementationRepository_Administration_server_is_running_exceptiondata, 1, ACE_TRY_ENV); - ACE_CHECK_RETURN (0); - - if (_invoke_status == TAO_INVOKE_RESTART) - continue; - if (_invoke_status != TAO_INVOKE_OK) - { - ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0); - - } - TAO_InputCDR &_tao_in = _tao_call.inp_stream (); - if (!( - (_tao_in >> _tao_safe_retval.inout ()) - )) - ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0); - - break; + _tao_call.start (ACE_TRY_ENV); + ACE_CHECK_RETURN (0); + + CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; + // Tremporary hack until GIOP 1.2 is implemented. + + _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); + ACE_CHECK_RETURN (0); + + TAO_OutputCDR &_tao_out = _tao_call.out_stream (); + if (!( + (_tao_out << server) && + (_tao_out << addr) && + (_tao_out << server_object) + )) + ACE_THROW_RETURN (CORBA::MARSHAL (), 0); + + int _invoke_status = + _tao_call.invoke (_tao_ImplementationRepository_Administration_server_is_running_exceptiondata, 1, ACE_TRY_ENV); + ACE_CHECK_RETURN (0); + + if (_invoke_status == TAO_INVOKE_RESTART) + continue; + if (_invoke_status != TAO_INVOKE_OK) + { + ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0); + + } + TAO_InputCDR &_tao_in = _tao_call.inp_stream (); + if (!( + (_tao_in >> _tao_safe_retval.inout ()) + )) + ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0); + + break; } - return _tao_safe_retval._retn (); + return _tao_safe_retval._retn (); } void ImplementationRepository::Administration::server_is_shutting_down ( @@ -1553,37 +1561,38 @@ void ImplementationRepository::Administration::server_is_shutting_down ( istub, "server_is_shutting_down", 23, + 1, istub->orb_core () ); for (;;) { - _tao_call.start (ACE_TRY_ENV); - ACE_CHECK; + _tao_call.start (ACE_TRY_ENV); + ACE_CHECK; - CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; - // Tremporary hack until GIOP 1.2 is implemented. + CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; + // Tremporary hack until GIOP 1.2 is implemented. - _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); - ACE_CHECK; + _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); + ACE_CHECK; - TAO_OutputCDR &_tao_out = _tao_call.out_stream (); - if (!( - (_tao_out << server) - )) - ACE_THROW (CORBA::MARSHAL ()); - int _invoke_status = - _tao_call.invoke (_tao_ImplementationRepository_Administration_server_is_shutting_down_exceptiondata, 1, ACE_TRY_ENV); - ACE_CHECK; + TAO_OutputCDR &_tao_out = _tao_call.out_stream (); + if (!( + (_tao_out << server) + )) + ACE_THROW (CORBA::MARSHAL ()); + int _invoke_status = + _tao_call.invoke (_tao_ImplementationRepository_Administration_server_is_shutting_down_exceptiondata, 1, ACE_TRY_ENV); + ACE_CHECK; - if (_invoke_status == TAO_INVOKE_RESTART) - continue; - if (_invoke_status != TAO_INVOKE_OK) - { - ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)); - } + if (_invoke_status == TAO_INVOKE_RESTART) + continue; + if (_invoke_status != TAO_INVOKE_OK) + { + ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)); + } - break; + break; } @@ -1613,46 +1622,47 @@ void ImplementationRepository::Administration::find ( ACE_THROW (CORBA::INTERNAL ()); - ACE_NEW (info.ptr (), ImplementationRepository::ServerInformation); + ACE_NEW (info.ptr (), ImplementationRepository::ServerInformation); TAO_GIOP_Twoway_Invocation _tao_call ( istub, "find", 4, + 1, istub->orb_core () ); for (;;) { - _tao_call.start (ACE_TRY_ENV); - ACE_CHECK; - CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; - // Tremporary hack until GIOP 1.2 is implemented. - - _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); - ACE_CHECK; - - TAO_OutputCDR &_tao_out = _tao_call.out_stream (); - if (!( - (_tao_out << server) - )) - ACE_THROW (CORBA::MARSHAL ()); - int _invoke_status = - _tao_call.invoke (_tao_ImplementationRepository_Administration_find_exceptiondata, 1, ACE_TRY_ENV); - ACE_CHECK; - - if (_invoke_status == TAO_INVOKE_RESTART) - continue; - if (_invoke_status != TAO_INVOKE_OK) - { - ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)); - } - TAO_InputCDR &_tao_in = _tao_call.inp_stream (); - if (!( - (_tao_in >> *info.ptr ()) - )) - ACE_THROW (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)); - break; + _tao_call.start (ACE_TRY_ENV); + ACE_CHECK; + CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; + // Tremporary hack until GIOP 1.2 is implemented. + + _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); + ACE_CHECK; + + TAO_OutputCDR &_tao_out = _tao_call.out_stream (); + if (!( + (_tao_out << server) + )) + ACE_THROW (CORBA::MARSHAL ()); + int _invoke_status = + _tao_call.invoke (_tao_ImplementationRepository_Administration_find_exceptiondata, 1, ACE_TRY_ENV); + ACE_CHECK; + + if (_invoke_status == TAO_INVOKE_RESTART) + continue; + if (_invoke_status != TAO_INVOKE_OK) + { + ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)); + } + TAO_InputCDR &_tao_in = _tao_call.inp_stream (); + if (!( + (_tao_in >> *info.ptr ()) + )) + ACE_THROW (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)); + break; } @@ -1660,7 +1670,7 @@ void ImplementationRepository::Administration::find ( void ImplementationRepository::Administration::list ( CORBA::ULong how_many, - ImplementationRepository::ServerInformationList_out server_list, + ImplementationRepository::ServerInformationList_out server_list, ImplementationRepository::ServerInformationIterator_out server_iterator, CORBA::Environment &ACE_TRY_ENV ) @@ -1682,42 +1692,43 @@ void ImplementationRepository::Administration::list ( istub, "list", 4, + 1, istub->orb_core () ); for (;;) { - _tao_call.start (ACE_TRY_ENV); - ACE_CHECK; - - CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; - // Tremporary hack until GIOP 1.2 is implemented. - - _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); - ACE_CHECK; - - TAO_OutputCDR &_tao_out = _tao_call.out_stream (); - if (!( - (_tao_out << how_many) - )) - ACE_THROW (CORBA::MARSHAL ()); - int _invoke_status = - _tao_call.invoke (0, 0, ACE_TRY_ENV); - ACE_CHECK; - - if (_invoke_status == TAO_INVOKE_RESTART) - continue; - if (_invoke_status != TAO_INVOKE_OK) - { - ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)); - } - TAO_InputCDR &_tao_in = _tao_call.inp_stream (); - if (!( - (_tao_in >> *server_list.ptr ()) && - (_tao_in >> server_iterator.ptr ()) - )) - ACE_THROW (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)); - break; + _tao_call.start (ACE_TRY_ENV); + ACE_CHECK; + + CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; + // Tremporary hack until GIOP 1.2 is implemented. + + _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); + ACE_CHECK; + + TAO_OutputCDR &_tao_out = _tao_call.out_stream (); + if (!( + (_tao_out << how_many) + )) + ACE_THROW (CORBA::MARSHAL ()); + int _invoke_status = + _tao_call.invoke (0, 0, ACE_TRY_ENV); + ACE_CHECK; + + if (_invoke_status == TAO_INVOKE_RESTART) + continue; + if (_invoke_status != TAO_INVOKE_OK) + { + ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)); + } + TAO_InputCDR &_tao_in = _tao_call.inp_stream (); + if (!( + (_tao_in >> *server_list.ptr ()) && + (_tao_in >> server_iterator.ptr ()) + )) + ACE_THROW (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)); + break; } @@ -1746,7 +1757,7 @@ ImplementationRepository::TAO_ImplementationRepository_Administration_Default_Pr } } -ImplementationRepository::TAO_ImplementationRepository_Administration_Default_Proxy_Factory::~TAO_ImplementationRepository_Administration_Default_Proxy_Factory (void) +ImplementationRepository::TAO_ImplementationRepository_Administration_Default_Proxy_Factory::~TAO_ImplementationRepository_Administration_Default_Proxy_Factory (void) { } @@ -1765,9 +1776,9 @@ ImplementationRepository::TAO_ImplementationRepository_Administration_Proxy_Fact { } -ImplementationRepository::TAO_ImplementationRepository_Administration_Proxy_Factory_Adapter::~TAO_ImplementationRepository_Administration_Proxy_Factory_Adapter (void) +ImplementationRepository::TAO_ImplementationRepository_Administration_Proxy_Factory_Adapter::~TAO_ImplementationRepository_Administration_Proxy_Factory_Adapter (void) { - // Making sure the factory which the adapter has is destroyed with it. + // Making sure the factory which the adapter has is destroyed with it. if (this->proxy_factory_ != 0) delete this->proxy_factory_; } @@ -1775,15 +1786,15 @@ ImplementationRepository::TAO_ImplementationRepository_Administration_Proxy_Fact int ImplementationRepository::TAO_ImplementationRepository_Administration_Proxy_Factory_Adapter::register_proxy_factory ( TAO_ImplementationRepository_Administration_Default_Proxy_Factory *df, - CORBA::Environment &ACE_TRY_ENV + CORBA::Environment &ACE_TRY_ENV ) { - ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon, + ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon, this->lock_, 0)); - // Remove any existing <proxy_factory_> and replace with the new one. + // Remove any existing <proxy_factory_> and replace with the new one. this->unregister_proxy_factory (ACE_TRY_ENV); this->proxy_factory_ = df; - this->delete_proxy_factory_ = 0; + this->delete_proxy_factory_ = 0; return 0; } @@ -1792,13 +1803,13 @@ ImplementationRepository::TAO_ImplementationRepository_Administration_Proxy_Fact CORBA::Environment & ) { - ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon, + ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon, this->lock_, 0)); if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0) { - // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it - // doesnt get into an infinite loop in <unregister_proxy_factory> as it is - // invoked in the destructor of the class too. + // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it + // doesnt get into an infinite loop in <unregister_proxy_factory> as it is + // invoked in the destructor of the class too. this->delete_proxy_factory_ = 1; delete this->proxy_factory_; this->proxy_factory_ = 0; @@ -1812,13 +1823,13 @@ ImplementationRepository::TAO_ImplementationRepository_Administration_Proxy_Fact CORBA::Environment & ) { - ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon, + ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon, this->lock_, 0)); - // Verify that an <proxy_factory_> is available else make one. + // Verify that an <proxy_factory_> is available else make one. if (this->proxy_factory_ == 0) ACE_NEW_RETURN (this->proxy_factory_, - TAO_ImplementationRepository_Administration_Default_Proxy_Factory (1), - 0); + TAO_ImplementationRepository_Administration_Default_Proxy_Factory (1), + 0); return this->proxy_factory_->create_proxy (proxy); @@ -1868,7 +1879,7 @@ void ImplementationRepository::TAO_ImplementationRepository_Administration_Smart } -void ImplementationRepository::TAO_ImplementationRepository_Administration_Smart_Proxy_Base::reregister_server ( +void ImplementationRepository::TAO_ImplementationRepository_Administration_Smart_Proxy_Base::reregister_server ( const char * server, const ImplementationRepository::StartupOptions & options, CORBA::Environment &ACE_TRY_ENV @@ -1973,7 +1984,7 @@ void ImplementationRepository::TAO_ImplementationRepository_Administration_Smart void ImplementationRepository::TAO_ImplementationRepository_Administration_Smart_Proxy_Base::list ( CORBA::ULong how_many, - ImplementationRepository::ServerInformationList_out server_list, + ImplementationRepository::ServerInformationList_out server_list, ImplementationRepository::ServerInformationIterator_out server_iterator, CORBA::Environment &ACE_TRY_ENV ) @@ -1994,14 +2005,14 @@ void ImplementationRepository::TAO_ImplementationRepository_Administration_Smart defined (ACE_HAS_GNU_REPO) template class TAO_Singleton<ImplementationRepository::TAO_ImplementationRepository_Administration_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >; #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) -#pragma instantiate TAO_Singleton<ImplementationRepository::TAO_ImplementationRepository_Administration_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> +#pragma instantiate TAO_Singleton<ImplementationRepository::TAO_ImplementationRepository_Administration_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ static const CORBA::Long _oc_ImplementationRepository_Administration[] = { - TAO_ENCAP_BYTE_ORDER, // byte order - 48, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f41646d), ACE_NTOHL (0x696e6973), ACE_NTOHL (0x74726174), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000), // repository ID = IDL:ImplementationRepository/Administration:1.0 - 15, ACE_NTOHL (0x41646d69), ACE_NTOHL (0x6e697374), ACE_NTOHL (0x72617469), ACE_NTOHL (0x6f6e0000), // name = Administration + TAO_ENCAP_BYTE_ORDER, // byte order + 48, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f41646d), ACE_NTOHL (0x696e6973), ACE_NTOHL (0x74726174), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000), // repository ID = IDL:ImplementationRepository/Administration:1.0 + 15, ACE_NTOHL (0x41646d69), ACE_NTOHL (0x6e697374), ACE_NTOHL (0x72617469), ACE_NTOHL (0x6f6e0000), // name = Administration }; static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_Administration (CORBA::tk_objref, sizeof (_oc_ImplementationRepository_Administration), (char *) &_oc_ImplementationRepository_Administration, 0, sizeof (ImplementationRepository::Administration)); TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) @@ -2014,21 +2025,21 @@ void ImplementationRepository::ServerInformationIterator::_tao_any_destructor (v CORBA::release (tmp); } -ImplementationRepository::ServerInformationIterator_ptr ImplementationRepository::ServerInformationIterator::_narrow ( +ImplementationRepository::ServerInformationIterator_ptr ImplementationRepository::ServerInformationIterator::_narrow ( CORBA::Object_ptr obj, CORBA::Environment &ACE_TRY_ENV ) { if (CORBA::is_nil (obj)) return ServerInformationIterator::_nil (); - CORBA::Boolean is_a = obj->_is_a ("IDL:ImplementationRepository/ServerInformationIterator:1.0", ACE_TRY_ENV); + CORBA::Boolean is_a = obj->_is_a ("IDL:ImplementationRepository/ServerInformationIterator:1.0", ACE_TRY_ENV); ACE_CHECK_RETURN (ServerInformationIterator::_nil ()); if (is_a == 0) return ServerInformationIterator::_nil (); return ServerInformationIterator::_unchecked_narrow (obj, ACE_TRY_ENV); } -ImplementationRepository::ServerInformationIterator_ptr ImplementationRepository::ServerInformationIterator::_unchecked_narrow ( +ImplementationRepository::ServerInformationIterator_ptr ImplementationRepository::ServerInformationIterator::_unchecked_narrow ( CORBA::Object_ptr obj, CORBA::Environment & ) @@ -2037,18 +2048,18 @@ ImplementationRepository::ServerInformationIterator_ptr ImplementationRepository return ServerInformationIterator::_nil (); TAO_Stub* stub = obj->_stubobj (); stub->_incr_refcnt (); - ServerInformationIterator_ptr default_proxy = ServerInformationIterator::_nil (); - if (obj->_is_collocated () && _TAO_collocation_ImplementationRepository_ServerInformationIterator_Stub_Factory_function_pointer != 0) + ServerInformationIterator_ptr default_proxy = ServerInformationIterator::_nil (); + if (obj->_is_collocated () && _TAO_collocation_ImplementationRepository_ServerInformationIterator_Stub_Factory_function_pointer != 0) { - default_proxy = _TAO_collocation_ImplementationRepository_ServerInformationIterator_Stub_Factory_function_pointer (obj); + default_proxy = _TAO_collocation_ImplementationRepository_ServerInformationIterator_Stub_Factory_function_pointer (obj); } if (CORBA::is_nil (default_proxy)) ACE_NEW_RETURN (default_proxy, ServerInformationIterator (stub), ServerInformationIterator::_nil ()); - return TAO_ImplementationRepository_ServerInformationIterator_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy); + return TAO_ImplementationRepository_ServerInformationIterator_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy); } ImplementationRepository::ServerInformationIterator_ptr -ImplementationRepository::ServerInformationIterator::_duplicate (ServerInformationIterator_ptr obj) +ImplementationRepository::ServerInformationIterator::_duplicate (ServerInformationIterator_ptr obj) { if (!CORBA::is_nil (obj)) obj->_add_ref (); @@ -2057,7 +2068,7 @@ ImplementationRepository::ServerInformationIterator::_duplicate (ServerInformati CORBA::Boolean ImplementationRepository::ServerInformationIterator::next_n ( CORBA::ULong how_many, - ImplementationRepository::ServerInformationList_out server_list, + ImplementationRepository::ServerInformationList_out server_list, CORBA::Environment &ACE_TRY_ENV ) ACE_THROW_SPEC (( @@ -2078,45 +2089,46 @@ CORBA::Boolean ImplementationRepository::ServerInformationIterator::next_n ( istub, "next_n", 6, + 1, istub->orb_core () ); for (;;) { - _tao_call.start (ACE_TRY_ENV); - ACE_CHECK_RETURN (_tao_retval); - - ACE_CHECK_RETURN (_tao_retval); - CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; - // Tremporary hack until GIOP 1.2 is implemented. - - _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); - ACE_CHECK_RETURN (_tao_retval); - - TAO_OutputCDR &_tao_out = _tao_call.out_stream (); - if (!( - (_tao_out << how_many) - )) - ACE_THROW_RETURN (CORBA::MARSHAL (), _tao_retval); - - int _invoke_status = - _tao_call.invoke (0, 0, ACE_TRY_ENV); - ACE_CHECK_RETURN (_tao_retval); - - if (_invoke_status == TAO_INVOKE_RESTART) - continue; - if (_invoke_status != TAO_INVOKE_OK) - { - ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval); - - } - TAO_InputCDR &_tao_in = _tao_call.inp_stream (); - if (!( - (_tao_in >> CORBA::Any::to_boolean (_tao_retval)) && - (_tao_in >> *server_list.ptr ()) - )) - ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval); - - break; + _tao_call.start (ACE_TRY_ENV); + ACE_CHECK_RETURN (_tao_retval); + + ACE_CHECK_RETURN (_tao_retval); + CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; + // Tremporary hack until GIOP 1.2 is implemented. + + _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); + ACE_CHECK_RETURN (_tao_retval); + + TAO_OutputCDR &_tao_out = _tao_call.out_stream (); + if (!( + (_tao_out << how_many) + )) + ACE_THROW_RETURN (CORBA::MARSHAL (), _tao_retval); + + int _invoke_status = + _tao_call.invoke (0, 0, ACE_TRY_ENV); + ACE_CHECK_RETURN (_tao_retval); + + if (_invoke_status == TAO_INVOKE_RESTART) + continue; + if (_invoke_status != TAO_INVOKE_OK) + { + ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval); + + } + TAO_InputCDR &_tao_in = _tao_call.inp_stream (); + if (!( + (_tao_in >> CORBA::Any::to_boolean (_tao_retval)) && + (_tao_in >> *server_list.ptr ()) + )) + ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval); + + break; } return _tao_retval; @@ -2142,38 +2154,39 @@ void ImplementationRepository::ServerInformationIterator::destroy ( istub, "destroy", 7, + 0, istub->orb_core () ); for (;;) { - _tao_call.start (ACE_TRY_ENV); - ACE_CHECK; + _tao_call.start (ACE_TRY_ENV); + ACE_CHECK; - CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; - // Tremporary hack until GIOP 1.2 is implemented. + CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; + // Tremporary hack until GIOP 1.2 is implemented. - _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); - ACE_CHECK; + _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV); + ACE_CHECK; - int _invoke_status = - _tao_call.invoke (0, 0, ACE_TRY_ENV); - ACE_CHECK; + int _invoke_status = + _tao_call.invoke (0, 0, ACE_TRY_ENV); + ACE_CHECK; - if (_invoke_status == TAO_INVOKE_RESTART) - continue; - if (_invoke_status != TAO_INVOKE_OK) - { - ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)); - } + if (_invoke_status == TAO_INVOKE_RESTART) + continue; + if (_invoke_status != TAO_INVOKE_OK) + { + ACE_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES)); + } - break; + break; } } -CORBA::Boolean ImplementationRepository::ServerInformationIterator::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV) +CORBA::Boolean ImplementationRepository::ServerInformationIterator::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV) { if ( (!ACE_OS::strcmp ((char *)value, "IDL:ImplementationRepository/ServerInformationIterator:1.0")) || @@ -2192,7 +2205,7 @@ ImplementationRepository::TAO_ImplementationRepository_ServerInformationIterator { if (register_proxy_factory) { - TAO_ImplementationRepository_ServerInformationIterator_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this); + TAO_ImplementationRepository_ServerInformationIterator_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this); } } @@ -2217,7 +2230,7 @@ ImplementationRepository::TAO_ImplementationRepository_ServerInformationIterator ImplementationRepository::TAO_ImplementationRepository_ServerInformationIterator_Proxy_Factory_Adapter::~TAO_ImplementationRepository_ServerInformationIterator_Proxy_Factory_Adapter (void) { - // Making sure the factory which the adapter has is destroyed with it. + // Making sure the factory which the adapter has is destroyed with it. if (this->proxy_factory_ != 0) delete this->proxy_factory_; } @@ -2225,15 +2238,15 @@ ImplementationRepository::TAO_ImplementationRepository_ServerInformationIterator int ImplementationRepository::TAO_ImplementationRepository_ServerInformationIterator_Proxy_Factory_Adapter::register_proxy_factory ( TAO_ImplementationRepository_ServerInformationIterator_Default_Proxy_Factory *df, - CORBA::Environment &ACE_TRY_ENV + CORBA::Environment &ACE_TRY_ENV ) { - ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon, + ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon, this->lock_, 0)); - // Remove any existing <proxy_factory_> and replace with the new one. + // Remove any existing <proxy_factory_> and replace with the new one. this->unregister_proxy_factory (ACE_TRY_ENV); this->proxy_factory_ = df; - this->delete_proxy_factory_ = 0; + this->delete_proxy_factory_ = 0; return 0; } @@ -2242,13 +2255,13 @@ ImplementationRepository::TAO_ImplementationRepository_ServerInformationIterator CORBA::Environment & ) { - ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon, + ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon, this->lock_, 0)); if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0) { - // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it - // doesnt get into an infinite loop in <unregister_proxy_factory> as it is - // invoked in the destructor of the class too. + // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it + // doesnt get into an infinite loop in <unregister_proxy_factory> as it is + // invoked in the destructor of the class too. this->delete_proxy_factory_ = 1; delete this->proxy_factory_; this->proxy_factory_ = 0; @@ -2262,13 +2275,13 @@ ImplementationRepository::TAO_ImplementationRepository_ServerInformationIterator CORBA::Environment & ) { - ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon, + ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon, this->lock_, 0)); - // Verify that an <proxy_factory_> is available else make one. + // Verify that an <proxy_factory_> is available else make one. if (this->proxy_factory_ == 0) ACE_NEW_RETURN (this->proxy_factory_, - TAO_ImplementationRepository_ServerInformationIterator_Default_Proxy_Factory (1), - 0); + TAO_ImplementationRepository_ServerInformationIterator_Default_Proxy_Factory (1), + 0); return this->proxy_factory_->create_proxy (proxy); @@ -2285,7 +2298,7 @@ ImplementationRepository::TAO_ImplementationRepository_ServerInformationIterator CORBA::Boolean ImplementationRepository::TAO_ImplementationRepository_ServerInformationIterator_Smart_Proxy_Base::next_n ( CORBA::ULong how_many, - ImplementationRepository::ServerInformationList_out server_list, + ImplementationRepository::ServerInformationList_out server_list, CORBA::Environment &ACE_TRY_ENV ) ACE_THROW_SPEC (( @@ -2300,7 +2313,7 @@ CORBA::Boolean ImplementationRepository::TAO_ImplementationRepository_ServerInfo } -void ImplementationRepository::TAO_ImplementationRepository_ServerInformationIterator_Smart_Proxy_Base::destroy ( +void ImplementationRepository::TAO_ImplementationRepository_ServerInformationIterator_Smart_Proxy_Base::destroy ( CORBA::Environment &ACE_TRY_ENV ) ACE_THROW_SPEC (( @@ -2317,16 +2330,16 @@ void ImplementationRepository::TAO_ImplementationRepository_ServerInformationIte defined (ACE_HAS_GNU_REPO) template class TAO_Singleton<ImplementationRepository::TAO_ImplementationRepository_ServerInformationIterator_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >; #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) -#pragma instantiate TAO_Singleton<ImplementationRepository::TAO_ImplementationRepository_ServerInformationIterator_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> +#pragma instantiate TAO_Singleton<ImplementationRepository::TAO_ImplementationRepository_ServerInformationIterator_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ static const CORBA::Long _oc_ImplementationRepository_ServerInformationIterator[] = { - TAO_ENCAP_BYTE_ORDER, // byte order - 59, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f536572), ACE_NTOHL (0x76657249), ACE_NTOHL (0x6e666f72), ACE_NTOHL (0x6d617469), ACE_NTOHL (0x6f6e4974), ACE_NTOHL (0x65726174), ACE_NTOHL (0x6f723a31), ACE_NTOHL (0x2e300000), // repository ID = IDL:ImplementationRepository/ServerInformationIterator:1.0 - 26, ACE_NTOHL (0x53657276), ACE_NTOHL (0x6572496e), ACE_NTOHL (0x666f726d), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e497465), ACE_NTOHL (0x7261746f), ACE_NTOHL (0x72000000), // name = ServerInformationIterator + TAO_ENCAP_BYTE_ORDER, // byte order + 59, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x496d706c), ACE_NTOHL (0x656d656e), ACE_NTOHL (0x74617469), ACE_NTOHL (0x6f6e5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x2f536572), ACE_NTOHL (0x76657249), ACE_NTOHL (0x6e666f72), ACE_NTOHL (0x6d617469), ACE_NTOHL (0x6f6e4974), ACE_NTOHL (0x65726174), ACE_NTOHL (0x6f723a31), ACE_NTOHL (0x2e300000), // repository ID = IDL:ImplementationRepository/ServerInformationIterator:1.0 + 26, ACE_NTOHL (0x53657276), ACE_NTOHL (0x6572496e), ACE_NTOHL (0x666f726d), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e497465), ACE_NTOHL (0x7261746f), ACE_NTOHL (0x72000000), // name = ServerInformationIterator }; -static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_ServerInformationIterator (CORBA::tk_objref, sizeof (_oc_ImplementationRepository_ServerInformationIterator), (char *) &_oc_ImplementationRepository_ServerInformationIterator, 0, sizeof (ImplementationRepository::ServerInformationIterator)); +static CORBA::TypeCode _tc_TAO_tc_ImplementationRepository_ServerInformationIterator (CORBA::tk_objref, sizeof (_oc_ImplementationRepository_ServerInformationIterator), (char *) &_oc_ImplementationRepository_ServerInformationIterator, 0, sizeof (ImplementationRepository::ServerInformationIterator)); TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) TAO_NAMESPACE_BEGIN (ImplementationRepository) TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ServerInformationIterator, &_tc_TAO_tc_ImplementationRepository_ServerInformationIterator) @@ -2334,51 +2347,51 @@ TAO_NAMESPACE_END ImplementationRepository::ServerObject_ptr (*_TAO_collocation_ImplementationRepository_ServerObject_Stub_Factory_function_pointer) ( CORBA::Object_ptr obj ) = 0; -void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::ServerObject_ptr _tao_elem) +void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::ServerObject_ptr _tao_elem) { - TAO_OutputCDR stream; - if (stream << _tao_elem) + TAO_OutputCDR stream; + if (stream << _tao_elem) { _tao_any._tao_replace ( - ImplementationRepository::_tc_ServerObject, - TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - ImplementationRepository::ServerObject::_duplicate (_tao_elem), - ImplementationRepository::ServerObject::_tao_any_destructor + ImplementationRepository::_tc_ServerObject, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + ImplementationRepository::ServerObject::_duplicate (_tao_elem), + ImplementationRepository::ServerObject::_tao_any_destructor ); } } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::ServerObject_ptr &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::ServerObject_ptr &_tao_elem) { ACE_TRY_NEW_ENV { - _tao_elem = ImplementationRepository::ServerObject::_nil (); - CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equivalent (ImplementationRepository::_tc_ServerObject, ACE_TRY_ENV)) // not equal + _tao_elem = ImplementationRepository::ServerObject::_nil (); + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (ImplementationRepository::_tc_ServerObject, ACE_TRY_ENV)) // not equal { - return 0; + return 0; } ACE_TRY_CHECK; - TAO_InputCDR stream ( - _tao_any._tao_get_cdr (), - _tao_any._tao_byte_order () + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () ); if (stream >> _tao_elem) { ((CORBA::Any *)&_tao_any)->_tao_replace ( - ImplementationRepository::_tc_ServerObject, - 1, - _tao_elem, - ImplementationRepository::ServerObject::_tao_any_destructor - ); + ImplementationRepository::_tc_ServerObject, + 1, + _tao_elem, + ImplementationRepository::ServerObject::_tao_any_destructor + ); return 1; } } ACE_CATCHANY { - _tao_elem = ImplementationRepository::ServerObject::_nil (); + _tao_elem = ImplementationRepository::ServerObject::_nil (); return 0; } ACE_ENDTRY; @@ -2393,22 +2406,22 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository # pragma instantiate TAO_Object_Manager<ImplementationRepository::ServerObject,ImplementationRepository::ServerObject_var> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ -void operator<<= (CORBA::Any &_tao_any, const ImplementationRepository::EnvironmentVariable &_tao_elem) // copying +void operator<<= (CORBA::Any &_tao_any, const ImplementationRepository::EnvironmentVariable &_tao_elem) // copying { - TAO_OutputCDR stream; + TAO_OutputCDR stream; stream << _tao_elem; - _tao_any._tao_replace ( + _tao_any._tao_replace ( ImplementationRepository::_tc_EnvironmentVariable, TAO_ENCAP_BYTE_ORDER, stream.begin () ); } -void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::EnvironmentVariable *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::EnvironmentVariable *_tao_elem) // non copying { - TAO_OutputCDR stream; + TAO_OutputCDR stream; stream << *_tao_elem; - _tao_any._tao_replace ( + _tao_any._tao_replace ( ImplementationRepository::_tc_EnvironmentVariable, TAO_ENCAP_BYTE_ORDER, stream.begin (), @@ -2418,28 +2431,28 @@ void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::EnvironmentVar ); } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::EnvironmentVariable *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::EnvironmentVariable *&_tao_elem) { return _tao_any >>= ACE_const_cast(ImplementationRepository::EnvironmentVariable*&,_tao_elem); } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepository::EnvironmentVariable *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepository::EnvironmentVariable *&_tao_elem) { _tao_elem = 0; ACE_TRY_NEW_ENV { - CORBA::TypeCode_var type = _tao_any.type (); + CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (ImplementationRepository::_tc_EnvironmentVariable, ACE_TRY_ENV)) // not equal { - return 0; + return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = ACE_static_cast( - const ImplementationRepository::EnvironmentVariable*, - _tao_any.value () - ); + _tao_elem = ACE_static_cast( + const ImplementationRepository::EnvironmentVariable*, + _tao_any.value () + ); return 1; } else @@ -2447,23 +2460,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepo ImplementationRepository::EnvironmentVariable *tmp; ACE_NEW_RETURN (tmp, ImplementationRepository::EnvironmentVariable, 0); TAO_InputCDR stream ( - _tao_any._tao_get_cdr (), - _tao_any._tao_byte_order () - ); + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); if (stream >> *tmp) { - ((CORBA::Any *)&_tao_any)->_tao_replace ( - ImplementationRepository::_tc_EnvironmentVariable, - 1, - ACE_static_cast (void *, tmp), - ImplementationRepository::EnvironmentVariable::_tao_any_destructor - ); - _tao_elem = tmp; - return 1; + ((CORBA::Any *)&_tao_any)->_tao_replace ( + ImplementationRepository::_tc_EnvironmentVariable, + 1, + ACE_static_cast (void *, tmp), + ImplementationRepository::EnvironmentVariable::_tao_any_destructor + ); + _tao_elem = tmp; + return 1; } else { - delete tmp; + delete tmp; } } } @@ -2479,22 +2492,22 @@ void operator<<= ( const ImplementationRepository::EnvironmentList &_tao_elem ) // copying { - TAO_OutputCDR stream; - if (stream << _tao_elem) + TAO_OutputCDR stream; + if (stream << _tao_elem) { _tao_any._tao_replace ( - ImplementationRepository::_tc_EnvironmentList, - TAO_ENCAP_BYTE_ORDER, - stream.begin () + ImplementationRepository::_tc_EnvironmentList, + TAO_ENCAP_BYTE_ORDER, + stream.begin () ); } } -void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::EnvironmentList *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::EnvironmentList *_tao_elem) // non copying { - TAO_OutputCDR stream; + TAO_OutputCDR stream; stream << *_tao_elem; - _tao_any._tao_replace ( + _tao_any._tao_replace ( ImplementationRepository::_tc_EnvironmentList, TAO_ENCAP_BYTE_ORDER, stream.begin (), @@ -2504,7 +2517,7 @@ void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::EnvironmentLis ); } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::EnvironmentList *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::EnvironmentList *&_tao_elem) { return _tao_any >>= ACE_const_cast( const ImplementationRepository::EnvironmentList*&, @@ -2512,47 +2525,47 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository ); } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepository::EnvironmentList *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepository::EnvironmentList *&_tao_elem) { _tao_elem = 0; ACE_TRY_NEW_ENV { - CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equivalent (ImplementationRepository::_tc_EnvironmentList, ACE_TRY_ENV)) // not equal + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (ImplementationRepository::_tc_EnvironmentList, ACE_TRY_ENV)) // not equal { - return 0; + return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = ACE_static_cast( - const ImplementationRepository::EnvironmentList*, - _tao_any.value () - ); + _tao_elem = ACE_static_cast( + const ImplementationRepository::EnvironmentList*, + _tao_any.value () + ); return 1; } else { - ImplementationRepository::EnvironmentList *tmp; + ImplementationRepository::EnvironmentList *tmp; ACE_NEW_RETURN (tmp, ImplementationRepository::EnvironmentList, 0); TAO_InputCDR stream ( - _tao_any._tao_get_cdr (), - _tao_any._tao_byte_order () - ); + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); if (stream >> *tmp) { - ((CORBA::Any *)&_tao_any)->_tao_replace ( - ImplementationRepository::_tc_EnvironmentList, - 1, - ACE_static_cast (void *, tmp), - ImplementationRepository::EnvironmentList::_tao_any_destructor - ); - _tao_elem = tmp; - return 1; + ((CORBA::Any *)&_tao_any)->_tao_replace ( + ImplementationRepository::_tc_EnvironmentList, + 1, + ACE_static_cast (void *, tmp), + ImplementationRepository::EnvironmentList::_tao_any_destructor + ); + _tao_elem = tmp; + return 1; } else { - delete tmp; + delete tmp; } } } @@ -2563,30 +2576,30 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepo return 0; } -void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::ActivationMode _tao_elem) +void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::ActivationMode _tao_elem) { - TAO_OutputCDR stream; + TAO_OutputCDR stream; stream << _tao_elem; - _tao_any._tao_replace ( + _tao_any._tao_replace ( ImplementationRepository::_tc_ActivationMode, TAO_ENCAP_BYTE_ORDER, stream.begin () ); } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::ActivationMode &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::ActivationMode &_tao_elem) { ACE_TRY_NEW_ENV { - CORBA::TypeCode_var type = _tao_any.type (); + CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (ImplementationRepository::_tc_ActivationMode, ACE_TRY_ENV)) // not equal { - return 0; + return 0; } ACE_TRY_CHECK; - TAO_InputCDR stream ( - _tao_any._tao_get_cdr (), - _tao_any._tao_byte_order () + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () ); if (stream >> _tao_elem) { @@ -2601,22 +2614,22 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository return 0; } -void operator<<= (CORBA::Any &_tao_any, const ImplementationRepository::StartupOptions &_tao_elem) // copying +void operator<<= (CORBA::Any &_tao_any, const ImplementationRepository::StartupOptions &_tao_elem) // copying { - TAO_OutputCDR stream; + TAO_OutputCDR stream; stream << _tao_elem; - _tao_any._tao_replace ( + _tao_any._tao_replace ( ImplementationRepository::_tc_StartupOptions, TAO_ENCAP_BYTE_ORDER, stream.begin () ); } -void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::StartupOptions *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::StartupOptions *_tao_elem) // non copying { - TAO_OutputCDR stream; + TAO_OutputCDR stream; stream << *_tao_elem; - _tao_any._tao_replace ( + _tao_any._tao_replace ( ImplementationRepository::_tc_StartupOptions, TAO_ENCAP_BYTE_ORDER, stream.begin (), @@ -2626,28 +2639,28 @@ void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::StartupOptions ); } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::StartupOptions *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::StartupOptions *&_tao_elem) { return _tao_any >>= ACE_const_cast(ImplementationRepository::StartupOptions*&,_tao_elem); } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepository::StartupOptions *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepository::StartupOptions *&_tao_elem) { _tao_elem = 0; ACE_TRY_NEW_ENV { - CORBA::TypeCode_var type = _tao_any.type (); + CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (ImplementationRepository::_tc_StartupOptions, ACE_TRY_ENV)) // not equal { - return 0; + return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = ACE_static_cast( - const ImplementationRepository::StartupOptions*, - _tao_any.value () - ); + _tao_elem = ACE_static_cast( + const ImplementationRepository::StartupOptions*, + _tao_any.value () + ); return 1; } else @@ -2655,23 +2668,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepo ImplementationRepository::StartupOptions *tmp; ACE_NEW_RETURN (tmp, ImplementationRepository::StartupOptions, 0); TAO_InputCDR stream ( - _tao_any._tao_get_cdr (), - _tao_any._tao_byte_order () - ); + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); if (stream >> *tmp) { - ((CORBA::Any *)&_tao_any)->_tao_replace ( - ImplementationRepository::_tc_StartupOptions, - 1, - ACE_static_cast (void *, tmp), - ImplementationRepository::StartupOptions::_tao_any_destructor - ); - _tao_elem = tmp; - return 1; + ((CORBA::Any *)&_tao_any)->_tao_replace ( + ImplementationRepository::_tc_StartupOptions, + 1, + ACE_static_cast (void *, tmp), + ImplementationRepository::StartupOptions::_tao_any_destructor + ); + _tao_elem = tmp; + return 1; } else { - delete tmp; + delete tmp; } } } @@ -2682,22 +2695,22 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepo return 0; } -void operator<<= (CORBA::Any &_tao_any, const ImplementationRepository::ServerInformation &_tao_elem) // copying +void operator<<= (CORBA::Any &_tao_any, const ImplementationRepository::ServerInformation &_tao_elem) // copying { - TAO_OutputCDR stream; + TAO_OutputCDR stream; stream << _tao_elem; - _tao_any._tao_replace ( + _tao_any._tao_replace ( ImplementationRepository::_tc_ServerInformation, TAO_ENCAP_BYTE_ORDER, stream.begin () ); } -void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::ServerInformation *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::ServerInformation *_tao_elem) // non copying { - TAO_OutputCDR stream; + TAO_OutputCDR stream; stream << *_tao_elem; - _tao_any._tao_replace ( + _tao_any._tao_replace ( ImplementationRepository::_tc_ServerInformation, TAO_ENCAP_BYTE_ORDER, stream.begin (), @@ -2707,52 +2720,52 @@ void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::ServerInformat ); } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::ServerInformation *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::ServerInformation *&_tao_elem) { return _tao_any >>= ACE_const_cast(ImplementationRepository::ServerInformation*&,_tao_elem); } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepository::ServerInformation *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepository::ServerInformation *&_tao_elem) { _tao_elem = 0; ACE_TRY_NEW_ENV { - CORBA::TypeCode_var type = _tao_any.type (); + CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (ImplementationRepository::_tc_ServerInformation, ACE_TRY_ENV)) // not equal { - return 0; + return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = ACE_static_cast( - const ImplementationRepository::ServerInformation*, - _tao_any.value () - ); + _tao_elem = ACE_static_cast( + const ImplementationRepository::ServerInformation*, + _tao_any.value () + ); return 1; } else { ImplementationRepository::ServerInformation *tmp; - ACE_NEW_RETURN (tmp, ImplementationRepository::ServerInformation, 0); + ACE_NEW_RETURN (tmp, ImplementationRepository::ServerInformation, 0); TAO_InputCDR stream ( - _tao_any._tao_get_cdr (), - _tao_any._tao_byte_order () - ); + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); if (stream >> *tmp) { - ((CORBA::Any *)&_tao_any)->_tao_replace ( - ImplementationRepository::_tc_ServerInformation, - 1, - ACE_static_cast (void *, tmp), - ImplementationRepository::ServerInformation::_tao_any_destructor - ); - _tao_elem = tmp; - return 1; + ((CORBA::Any *)&_tao_any)->_tao_replace ( + ImplementationRepository::_tc_ServerInformation, + 1, + ACE_static_cast (void *, tmp), + ImplementationRepository::ServerInformation::_tao_any_destructor + ); + _tao_elem = tmp; + return 1; } else { - delete tmp; + delete tmp; } } } @@ -2768,22 +2781,22 @@ void operator<<= ( const ImplementationRepository::ServerInformationList &_tao_elem ) // copying { - TAO_OutputCDR stream; - if (stream << _tao_elem) + TAO_OutputCDR stream; + if (stream << _tao_elem) { _tao_any._tao_replace ( - ImplementationRepository::_tc_ServerInformationList, - TAO_ENCAP_BYTE_ORDER, - stream.begin () + ImplementationRepository::_tc_ServerInformationList, + TAO_ENCAP_BYTE_ORDER, + stream.begin () ); } } -void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::ServerInformationList *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::ServerInformationList *_tao_elem) // non copying { - TAO_OutputCDR stream; + TAO_OutputCDR stream; stream << *_tao_elem; - _tao_any._tao_replace ( + _tao_any._tao_replace ( ImplementationRepository::_tc_ServerInformationList, TAO_ENCAP_BYTE_ORDER, stream.begin (), @@ -2793,7 +2806,7 @@ void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::ServerInformat ); } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::ServerInformationList *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::ServerInformationList *&_tao_elem) { return _tao_any >>= ACE_const_cast( const ImplementationRepository::ServerInformationList*&, @@ -2801,23 +2814,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository ); } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepository::ServerInformationList *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepository::ServerInformationList *&_tao_elem) { _tao_elem = 0; ACE_TRY_NEW_ENV { - CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equivalent (ImplementationRepository::_tc_ServerInformationList, ACE_TRY_ENV)) // not equal + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (ImplementationRepository::_tc_ServerInformationList, ACE_TRY_ENV)) // not equal { - return 0; + return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = ACE_static_cast( - const ImplementationRepository::ServerInformationList*, - _tao_any.value () - ); + _tao_elem = ACE_static_cast( + const ImplementationRepository::ServerInformationList*, + _tao_any.value () + ); return 1; } else @@ -2825,23 +2838,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepo ImplementationRepository::ServerInformationList *tmp; ACE_NEW_RETURN (tmp, ImplementationRepository::ServerInformationList, 0); TAO_InputCDR stream ( - _tao_any._tao_get_cdr (), - _tao_any._tao_byte_order () - ); + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); if (stream >> *tmp) { - ((CORBA::Any *)&_tao_any)->_tao_replace ( - ImplementationRepository::_tc_ServerInformationList, - 1, - ACE_static_cast (void *, tmp), - ImplementationRepository::ServerInformationList::_tao_any_destructor - ); - _tao_elem = tmp; - return 1; + ((CORBA::Any *)&_tao_any)->_tao_replace ( + ImplementationRepository::_tc_ServerInformationList, + 1, + ACE_static_cast (void *, tmp), + ImplementationRepository::ServerInformationList::_tao_any_destructor + ); + _tao_elem = tmp; + return 1; } else { - delete tmp; + delete tmp; } } } @@ -2855,51 +2868,51 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepo ImplementationRepository::Administration_ptr (*_TAO_collocation_ImplementationRepository_Administration_Stub_Factory_function_pointer) ( CORBA::Object_ptr obj ) = 0; -void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::Administration_ptr _tao_elem) +void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::Administration_ptr _tao_elem) { - TAO_OutputCDR stream; - if (stream << _tao_elem) + TAO_OutputCDR stream; + if (stream << _tao_elem) { _tao_any._tao_replace ( - ImplementationRepository::_tc_Administration, - TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - ImplementationRepository::Administration::_duplicate (_tao_elem), - ImplementationRepository::Administration::_tao_any_destructor + ImplementationRepository::_tc_Administration, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + ImplementationRepository::Administration::_duplicate (_tao_elem), + ImplementationRepository::Administration::_tao_any_destructor ); } } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::Administration_ptr &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::Administration_ptr &_tao_elem) { ACE_TRY_NEW_ENV { - _tao_elem = ImplementationRepository::Administration::_nil (); - CORBA::TypeCode_var type = _tao_any.type (); + _tao_elem = ImplementationRepository::Administration::_nil (); + CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (ImplementationRepository::_tc_Administration, ACE_TRY_ENV)) // not equal { - return 0; + return 0; } ACE_TRY_CHECK; - TAO_InputCDR stream ( - _tao_any._tao_get_cdr (), - _tao_any._tao_byte_order () + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () ); if (stream >> _tao_elem) { ((CORBA::Any *)&_tao_any)->_tao_replace ( - ImplementationRepository::_tc_Administration, - 1, - _tao_elem, - ImplementationRepository::Administration::_tao_any_destructor - ); + ImplementationRepository::_tc_Administration, + 1, + _tao_elem, + ImplementationRepository::Administration::_tao_any_destructor + ); return 1; } } ACE_CATCHANY { - _tao_elem = ImplementationRepository::Administration::_nil (); + _tao_elem = ImplementationRepository::Administration::_nil (); return 0; } ACE_ENDTRY; @@ -2914,22 +2927,22 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository # pragma instantiate TAO_Object_Manager<ImplementationRepository::Administration,ImplementationRepository::Administration_var> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ -void operator<<= (CORBA::Any &_tao_any, const ImplementationRepository::Administration::AlreadyRegistered &_tao_elem) // copying +void operator<<= (CORBA::Any &_tao_any, const ImplementationRepository::Administration::AlreadyRegistered &_tao_elem) // copying { - TAO_OutputCDR stream; + TAO_OutputCDR stream; stream << _tao_elem; - _tao_any._tao_replace ( + _tao_any._tao_replace ( ImplementationRepository::Administration::_tc_AlreadyRegistered, TAO_ENCAP_BYTE_ORDER, stream.begin () ); } -void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::Administration::AlreadyRegistered *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::Administration::AlreadyRegistered *_tao_elem) // non copying { - TAO_OutputCDR stream; + TAO_OutputCDR stream; stream << *_tao_elem; - _tao_any._tao_replace ( + _tao_any._tao_replace ( ImplementationRepository::Administration::_tc_AlreadyRegistered, TAO_ENCAP_BYTE_ORDER, stream.begin (), @@ -2939,7 +2952,7 @@ void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::Administration ); } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::Administration::AlreadyRegistered *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::Administration::AlreadyRegistered *&_tao_elem) { return _tao_any >>= ACE_const_cast( const ImplementationRepository::Administration::AlreadyRegistered*&, @@ -2947,44 +2960,44 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository ); } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepository::Administration::AlreadyRegistered *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepository::Administration::AlreadyRegistered *&_tao_elem) { _tao_elem = 0; ACE_TRY_NEW_ENV { - CORBA::TypeCode_var type = _tao_any.type (); + CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (ImplementationRepository::Administration::_tc_AlreadyRegistered, ACE_TRY_ENV)) // not equal { - return 0; + return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (ImplementationRepository::Administration::AlreadyRegistered *)_tao_any.value (); + _tao_elem = (ImplementationRepository::Administration::AlreadyRegistered *)_tao_any.value (); return 1; } else { ImplementationRepository::Administration::AlreadyRegistered *tmp; - ACE_NEW_RETURN (tmp, ImplementationRepository::Administration::AlreadyRegistered, 0); + ACE_NEW_RETURN (tmp, ImplementationRepository::Administration::AlreadyRegistered, 0); TAO_InputCDR stream ( - _tao_any._tao_get_cdr (), - _tao_any._tao_byte_order () - ); + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); if (stream >> *tmp) { - ((CORBA::Any *)&_tao_any)->_tao_replace ( - ImplementationRepository::Administration::_tc_AlreadyRegistered, - 1, - tmp, - ImplementationRepository::Administration::AlreadyRegistered::_tao_any_destructor - ); - _tao_elem = tmp; - return 1; + ((CORBA::Any *)&_tao_any)->_tao_replace ( + ImplementationRepository::Administration::_tc_AlreadyRegistered, + 1, + tmp, + ImplementationRepository::Administration::AlreadyRegistered::_tao_any_destructor + ); + _tao_elem = tmp; + return 1; } else { - delete tmp; + delete tmp; } } } @@ -2995,22 +3008,22 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepo return 0; } -void operator<<= (CORBA::Any &_tao_any, const ImplementationRepository::Administration::CannotActivate &_tao_elem) // copying +void operator<<= (CORBA::Any &_tao_any, const ImplementationRepository::Administration::CannotActivate &_tao_elem) // copying { - TAO_OutputCDR stream; + TAO_OutputCDR stream; stream << _tao_elem; - _tao_any._tao_replace ( + _tao_any._tao_replace ( ImplementationRepository::Administration::_tc_CannotActivate, TAO_ENCAP_BYTE_ORDER, stream.begin () ); } -void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::Administration::CannotActivate *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::Administration::CannotActivate *_tao_elem) // non copying { - TAO_OutputCDR stream; + TAO_OutputCDR stream; stream << *_tao_elem; - _tao_any._tao_replace ( + _tao_any._tao_replace ( ImplementationRepository::Administration::_tc_CannotActivate, TAO_ENCAP_BYTE_ORDER, stream.begin (), @@ -3020,7 +3033,7 @@ void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::Administration ); } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::Administration::CannotActivate *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::Administration::CannotActivate *&_tao_elem) { return _tao_any >>= ACE_const_cast( const ImplementationRepository::Administration::CannotActivate*&, @@ -3028,20 +3041,20 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository ); } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepository::Administration::CannotActivate *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepository::Administration::CannotActivate *&_tao_elem) { _tao_elem = 0; ACE_TRY_NEW_ENV { - CORBA::TypeCode_var type = _tao_any.type (); + CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (ImplementationRepository::Administration::_tc_CannotActivate, ACE_TRY_ENV)) // not equal { - return 0; + return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (ImplementationRepository::Administration::CannotActivate *)_tao_any.value (); + _tao_elem = (ImplementationRepository::Administration::CannotActivate *)_tao_any.value (); return 1; } else @@ -3049,23 +3062,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepo ImplementationRepository::Administration::CannotActivate *tmp; ACE_NEW_RETURN (tmp, ImplementationRepository::Administration::CannotActivate, 0); TAO_InputCDR stream ( - _tao_any._tao_get_cdr (), - _tao_any._tao_byte_order () - ); + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); if (stream >> *tmp) { - ((CORBA::Any *)&_tao_any)->_tao_replace ( - ImplementationRepository::Administration::_tc_CannotActivate, - 1, - tmp, - ImplementationRepository::Administration::CannotActivate::_tao_any_destructor - ); - _tao_elem = tmp; - return 1; + ((CORBA::Any *)&_tao_any)->_tao_replace ( + ImplementationRepository::Administration::_tc_CannotActivate, + 1, + tmp, + ImplementationRepository::Administration::CannotActivate::_tao_any_destructor + ); + _tao_elem = tmp; + return 1; } else { - delete tmp; + delete tmp; } } } @@ -3076,22 +3089,22 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepo return 0; } -void operator<<= (CORBA::Any &_tao_any, const ImplementationRepository::Administration::NotFound &_tao_elem) // copying +void operator<<= (CORBA::Any &_tao_any, const ImplementationRepository::Administration::NotFound &_tao_elem) // copying { - TAO_OutputCDR stream; + TAO_OutputCDR stream; stream << _tao_elem; - _tao_any._tao_replace ( + _tao_any._tao_replace ( ImplementationRepository::Administration::_tc_NotFound, TAO_ENCAP_BYTE_ORDER, stream.begin () ); } -void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::Administration::NotFound *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::Administration::NotFound *_tao_elem) // non copying { - TAO_OutputCDR stream; + TAO_OutputCDR stream; stream << *_tao_elem; - _tao_any._tao_replace ( + _tao_any._tao_replace ( ImplementationRepository::Administration::_tc_NotFound, TAO_ENCAP_BYTE_ORDER, stream.begin (), @@ -3101,7 +3114,7 @@ void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::Administration ); } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::Administration::NotFound *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::Administration::NotFound *&_tao_elem) { return _tao_any >>= ACE_const_cast( const ImplementationRepository::Administration::NotFound*&, @@ -3109,20 +3122,20 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository ); } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepository::Administration::NotFound *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepository::Administration::NotFound *&_tao_elem) { _tao_elem = 0; ACE_TRY_NEW_ENV { - CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equivalent (ImplementationRepository::Administration::_tc_NotFound, ACE_TRY_ENV)) // not equal + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (ImplementationRepository::Administration::_tc_NotFound, ACE_TRY_ENV)) // not equal { - return 0; + return 0; } ACE_TRY_CHECK; if (_tao_any.any_owns_data ()) { - _tao_elem = (ImplementationRepository::Administration::NotFound *)_tao_any.value (); + _tao_elem = (ImplementationRepository::Administration::NotFound *)_tao_any.value (); return 1; } else @@ -3130,23 +3143,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepo ImplementationRepository::Administration::NotFound *tmp; ACE_NEW_RETURN (tmp, ImplementationRepository::Administration::NotFound, 0); TAO_InputCDR stream ( - _tao_any._tao_get_cdr (), - _tao_any._tao_byte_order () - ); + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); if (stream >> *tmp) { - ((CORBA::Any *)&_tao_any)->_tao_replace ( - ImplementationRepository::Administration::_tc_NotFound, - 1, - tmp, - ImplementationRepository::Administration::NotFound::_tao_any_destructor - ); - _tao_elem = tmp; - return 1; + ((CORBA::Any *)&_tao_any)->_tao_replace ( + ImplementationRepository::Administration::_tc_NotFound, + 1, + tmp, + ImplementationRepository::Administration::NotFound::_tao_any_destructor + ); + _tao_elem = tmp; + return 1; } else { - delete tmp; + delete tmp; } } } @@ -3157,58 +3170,58 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const ImplementationRepo return 0; } -ImplementationRepository::ServerInformationIterator_ptr (*_TAO_collocation_ImplementationRepository_ServerInformationIterator_Stub_Factory_function_pointer) ( +ImplementationRepository::ServerInformationIterator_ptr (*_TAO_collocation_ImplementationRepository_ServerInformationIterator_Stub_Factory_function_pointer) ( CORBA::Object_ptr obj ) = 0; -void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::ServerInformationIterator_ptr _tao_elem) +void operator<<= (CORBA::Any &_tao_any, ImplementationRepository::ServerInformationIterator_ptr _tao_elem) { - TAO_OutputCDR stream; - if (stream << _tao_elem) + TAO_OutputCDR stream; + if (stream << _tao_elem) { _tao_any._tao_replace ( - ImplementationRepository::_tc_ServerInformationIterator, - TAO_ENCAP_BYTE_ORDER, - stream.begin (), - 1, - ImplementationRepository::ServerInformationIterator::_duplicate (_tao_elem), - ImplementationRepository::ServerInformationIterator::_tao_any_destructor + ImplementationRepository::_tc_ServerInformationIterator, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + ImplementationRepository::ServerInformationIterator::_duplicate (_tao_elem), + ImplementationRepository::ServerInformationIterator::_tao_any_destructor ); } } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::ServerInformationIterator_ptr &_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, ImplementationRepository::ServerInformationIterator_ptr &_tao_elem) { ACE_TRY_NEW_ENV { - _tao_elem = ImplementationRepository::ServerInformationIterator::_nil (); - CORBA::TypeCode_var type = _tao_any.type (); + _tao_elem = ImplementationRepository::ServerInformationIterator::_nil (); + CORBA::TypeCode_var type = _tao_any.type (); if (!type->equivalent (ImplementationRepository::_tc_ServerInformationIterator, ACE_TRY_ENV)) // not equal { - return 0; + return 0; } ACE_TRY_CHECK; - TAO_InputCDR stream ( - _tao_any._tao_get_cdr (), - _tao_any._tao_byte_order () + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () ); if (stream >> _tao_elem) { ((CORBA::Any *)&_tao_any)->_tao_replace ( - ImplementationRepository::_tc_ServerInformationIterator, - 1, - _tao_elem, - ImplementationRepository::ServerInformationIterator::_tao_any_destructor - ); + ImplementationRepository::_tc_ServerInformationIterator, + 1, + _tao_elem, + ImplementationRepository::ServerInformationIterator::_tao_any_destructor + ); return 1; } } ACE_CATCHANY { - _tao_elem = ImplementationRepository::ServerInformationIterator::_nil (); + _tao_elem = ImplementationRepository::ServerInformationIterator::_nil (); return 0; } ACE_ENDTRY; - _tao_elem = ImplementationRepository::ServerInformationIterator::_nil (); + _tao_elem = ImplementationRepository::ServerInformationIterator::_nil (); return 0; } @@ -3228,9 +3241,9 @@ CORBA::Boolean operator<< ( { // encode all elements CORBA::Boolean _tao_marshal_flag = 1; - for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++) + for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++) { - _tao_marshal_flag = (strm << _tao_sequence[i]); + _tao_marshal_flag = (strm << _tao_sequence[i]); } return _tao_marshal_flag; } @@ -3247,14 +3260,14 @@ CORBA::Boolean operator>> ( { // set the length of the sequence _tao_sequence.length (_tao_seq_len); - // If length is 0 we return true. + // If length is 0 we return true. if (0 >= _tao_seq_len) return 1; - // retrieve all the elements + // retrieve all the elements CORBA::Boolean _tao_marshal_flag = 1; - for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++) + for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++) { - _tao_marshal_flag = (strm >> _tao_sequence[i]); + _tao_marshal_flag = (strm >> _tao_sequence[i]); } return _tao_marshal_flag; } @@ -3270,9 +3283,9 @@ CORBA::Boolean operator<< ( { // encode all elements CORBA::Boolean _tao_marshal_flag = 1; - for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++) + for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++) { - _tao_marshal_flag = (strm << _tao_sequence[i]); + _tao_marshal_flag = (strm << _tao_sequence[i]); } return _tao_marshal_flag; } @@ -3289,14 +3302,14 @@ CORBA::Boolean operator>> ( { // set the length of the sequence _tao_sequence.length (_tao_seq_len); - // If length is 0 we return true. + // If length is 0 we return true. if (0 >= _tao_seq_len) return 1; - // retrieve all the elements + // retrieve all the elements CORBA::Boolean _tao_marshal_flag = 1; - for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++) + for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++) { - _tao_marshal_flag = (strm >> _tao_sequence[i]); + _tao_marshal_flag = (strm >> _tao_sequence[i]); } return _tao_marshal_flag; } diff --git a/TAO/tao/Remote_Object_Proxy_Impl.cpp b/TAO/tao/Remote_Object_Proxy_Impl.cpp index a924ce7c12d..f10ae9a55d5 100644 --- a/TAO/tao/Remote_Object_Proxy_Impl.cpp +++ b/TAO/tao/Remote_Object_Proxy_Impl.cpp @@ -10,73 +10,74 @@ TAO_Remote_Object_Proxy_Impl::~TAO_Remote_Object_Proxy_Impl(void) CORBA::Boolean TAO_Remote_Object_Proxy_Impl::_is_a (const CORBA::Object_ptr target, - const CORBA::Char *logical_type_id, - CORBA_Environment &ACE_TRY_ENV) + const CORBA::Char *logical_type_id, + CORBA_Environment &ACE_TRY_ENV) { if (target->_stubobj ()->type_id.in () != 0 - && ACE_OS::strcmp (logical_type_id, - target->_stubobj ()->type_id.in ()) == 0) + && ACE_OS::strcmp (logical_type_id, + target->_stubobj ()->type_id.in ()) == 0) return 1; - // Here we go remote to answer the question. + // Here we go remote to answer the question. CORBA::Boolean _tao_retval = 0; TAO_Stub *istub = target->_stubobj (); if (istub == 0) ACE_THROW_RETURN (CORBA::INTERNAL ( - CORBA_SystemException::_tao_minor_code ( - TAO_DEFAULT_MINOR_CODE, - EINVAL), - CORBA::COMPLETED_NO), - _tao_retval); + CORBA_SystemException::_tao_minor_code ( + TAO_DEFAULT_MINOR_CODE, + EINVAL), + CORBA::COMPLETED_NO), + _tao_retval); TAO_GIOP_Twoway_Invocation _tao_call (istub, - "_is_a", - 5, - istub->orb_core ()); - - // Loop until we succeed or we raise an exception. - // @@ Nanbor: Do we still need to clear the environment variable? - // ACE_TRY_ENV.clear (); + "_is_a", + 5, + 1, + istub->orb_core ()); + + // Loop until we succeed or we raise an exception. + // @@ Nanbor: Do we still need to clear the environment variable? + // ACE_TRY_ENV.clear (); for (;;) { _tao_call.start (ACE_TRY_ENV); ACE_CHECK_RETURN (_tao_retval); - CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; + CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; - _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), - ACE_TRY_ENV); + _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), + ACE_TRY_ENV); ACE_CHECK_RETURN (_tao_retval); - TAO_OutputCDR &_tao_out = _tao_call.out_stream (); + TAO_OutputCDR &_tao_out = _tao_call.out_stream (); if (!( - (_tao_out << logical_type_id) - )) - ACE_THROW_RETURN (CORBA::MARSHAL (), _tao_retval); + (_tao_out << logical_type_id) + )) + ACE_THROW_RETURN (CORBA::MARSHAL (), _tao_retval); int _invoke_status = - _tao_call.invoke (0, 0, ACE_TRY_ENV); + _tao_call.invoke (0, 0, ACE_TRY_ENV); ACE_CHECK_RETURN (_tao_retval); if (_invoke_status == TAO_INVOKE_RESTART) - continue; + continue; // if (_invoke_status == TAO_INVOKE_EXCEPTION) - // cannot happen + // cannot happen if (_invoke_status != TAO_INVOKE_OK) - { - ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, - CORBA::COMPLETED_YES), - _tao_retval); + { + ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, + CORBA::COMPLETED_YES), + _tao_retval); - } + } break; } - TAO_InputCDR &_tao_in = _tao_call.inp_stream (); - if (!(_tao_in >> CORBA::Any::to_boolean (_tao_retval))) + TAO_InputCDR &_tao_in = _tao_call.inp_stream (); + if (!(_tao_in >> CORBA::Any::to_boolean (_tao_retval))) ACE_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, - CORBA::COMPLETED_YES), - _tao_retval); + CORBA::COMPLETED_YES), + _tao_retval); return _tao_retval; } @@ -84,61 +85,62 @@ TAO_Remote_Object_Proxy_Impl::_is_a (const CORBA::Object_ptr target, #if (TAO_HAS_MINIMUM_CORBA == 0) CORBA::Boolean TAO_Remote_Object_Proxy_Impl::_non_existent (const CORBA::Object_ptr target, - CORBA_Environment &ACE_TRY_ENV) + CORBA_Environment &ACE_TRY_ENV) { CORBA::Boolean _tao_retval = 0; ACE_TRY { - // Must catch exceptions, if the server raises a - // CORBA::OBJECT_NOT_EXIST then we must return 1, instead of + // Must catch exceptions, if the server raises a + // CORBA::OBJECT_NOT_EXIST then we must return 1, instead of // propagating the exception. - TAO_Stub *istub = target->_stubobj (); - if (istub == 0) - ACE_THROW_RETURN (CORBA::INTERNAL ( - CORBA_SystemException::_tao_minor_code ( - TAO_DEFAULT_MINOR_CODE, - EINVAL), - CORBA::COMPLETED_NO), - _tao_retval); + TAO_Stub *istub = target->_stubobj (); + if (istub == 0) + ACE_THROW_RETURN (CORBA::INTERNAL ( + CORBA_SystemException::_tao_minor_code ( + TAO_DEFAULT_MINOR_CODE, + EINVAL), + CORBA::COMPLETED_NO), + _tao_retval); TAO_GIOP_Twoway_Invocation _tao_call (istub, - "_non_existent", - 13, - istub->orb_core ()); + "_non_existent", + 13, + 1, + istub->orb_core ()); // ACE_TRY_ENV.clear (); for (;;) - { - _tao_call.start (ACE_TRY_ENV); - ACE_TRY_CHECK; - - CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; - - _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), - ACE_TRY_ENV); - ACE_TRY_CHECK; - - int _invoke_status = - _tao_call.invoke (0, 0, ACE_TRY_ENV); - ACE_TRY_CHECK; - - if (_invoke_status == TAO_INVOKE_RESTART) - continue; - ACE_ASSERT (_invoke_status != TAO_INVOKE_EXCEPTION); - if (_invoke_status != TAO_INVOKE_OK) - { - ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, - CORBA::COMPLETED_YES), - _tao_retval); - } - break; - } + { + _tao_call.start (ACE_TRY_ENV); + ACE_TRY_CHECK; + + CORBA::Short flag = TAO_TWOWAY_RESPONSE_FLAG; + + _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), + ACE_TRY_ENV); + ACE_TRY_CHECK; + + int _invoke_status = + _tao_call.invoke (0, 0, ACE_TRY_ENV); + ACE_TRY_CHECK; + + if (_invoke_status == TAO_INVOKE_RESTART) + continue; + ACE_ASSERT (_invoke_status != TAO_INVOKE_EXCEPTION); + if (_invoke_status != TAO_INVOKE_OK) + { + ACE_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, + CORBA::COMPLETED_YES), + _tao_retval); + } + break; + } TAO_InputCDR &_tao_in = _tao_call.inp_stream (); if (!( - (_tao_in >> CORBA::Any::to_boolean (_tao_retval)) - )) - ACE_THROW_RETURN (CORBA::MARSHAL (), _tao_retval); + (_tao_in >> CORBA::Any::to_boolean (_tao_retval)) + )) + ACE_THROW_RETURN (CORBA::MARSHAL (), _tao_retval); } ACE_CATCH (CORBA::OBJECT_NOT_EXIST, ex) { @@ -152,4 +154,4 @@ CORBA::Boolean TAO_Remote_Object_Proxy_Impl::_non_existent (const CORBA::Object_ return _tao_retval; } -#endif /* TAO_HAS_MINIMUM_CORBA == 0 */ +#endif /* TAO_HAS_MINIMUM_CORBA == 0 */ diff --git a/TAO/tao/Strategies/SHMIOP_Connector.cpp b/TAO/tao/Strategies/SHMIOP_Connector.cpp index 045686cb32a..e51d6dca207 100644 --- a/TAO/tao/Strategies/SHMIOP_Connector.cpp +++ b/TAO/tao/Strategies/SHMIOP_Connector.cpp @@ -25,6 +25,11 @@ TAO_SHMIOP_Connect_Creation_Strategy:: { } +TAO_SHMIOP_Connect_Creation_Strategy:: + ~TAO_SHMIOP_Connect_Creation_Strategy (void) +{ +} + int TAO_SHMIOP_Connect_Creation_Strategy::make_svc_handler (TAO_SHMIOP_Client_Connection_Handler *&sh) @@ -47,6 +52,11 @@ TAO_SHMIOP_Connector::TAO_SHMIOP_Connector (CORBA::Octet flag) { } +TAO_SHMIOP_Connector::~TAO_SHMIOP_Connector (void) +{ +} + + int TAO_SHMIOP_Connector::open (TAO_ORB_Core *orb_core) { diff --git a/TAO/tao/Strategies/SHMIOP_Connector.h b/TAO/tao/Strategies/SHMIOP_Connector.h index 2ed17ee6338..124aa7bd95d 100644 --- a/TAO/tao/Strategies/SHMIOP_Connector.h +++ b/TAO/tao/Strategies/SHMIOP_Connector.h @@ -52,6 +52,9 @@ public: TAO_ORB_Core* orb_core = 0, CORBA::Boolean flag = 0); + ~TAO_SHMIOP_Connect_Creation_Strategy (void); + // Default destructor + virtual int make_svc_handler (TAO_SHMIOP_Client_Connection_Handler *&sh); // Makes TAO_SHMIOP_Client_Connection_Handlers @@ -80,6 +83,9 @@ public: TAO_SHMIOP_Connector (CORBA::Boolean flag = 0); // Constructor. + ~TAO_SHMIOP_Connector (void); + // Default destructor + // = The TAO_Connector methods, please check the documentation on // Pluggable.h int open (TAO_ORB_Core *orb_core); diff --git a/TAO/tao/Strategies/UIOP_Connector.cpp b/TAO/tao/Strategies/UIOP_Connector.cpp index 511c09f9a25..3e450e3d48f 100644 --- a/TAO/tao/Strategies/UIOP_Connector.cpp +++ b/TAO/tao/Strategies/UIOP_Connector.cpp @@ -27,6 +27,12 @@ TAO_UIOP_Connect_Creation_Strategy:: { } +TAO_UIOP_Connect_Creation_Strategy:: + ~TAO_UIOP_Connect_Creation_Strategy (void) +{ +} + + int TAO_UIOP_Connect_Creation_Strategy::make_svc_handler (TAO_UIOP_Client_Connection_Handler *&sh) @@ -53,6 +59,10 @@ TAO_UIOP_Connector::TAO_UIOP_Connector (CORBA::Boolean flag) { } +TAO_UIOP_Connector::~TAO_UIOP_Connector (void) +{ +} + int TAO_UIOP_Connector::open (TAO_ORB_Core *orb_core) { diff --git a/TAO/tao/Strategies/UIOP_Connector.h b/TAO/tao/Strategies/UIOP_Connector.h index 0cdc1a606d9..9676bd4d97d 100644 --- a/TAO/tao/Strategies/UIOP_Connector.h +++ b/TAO/tao/Strategies/UIOP_Connector.h @@ -58,6 +58,9 @@ public: // state/info to the service handler upon creation. Currently used // by IIOP and UIOP to pass protocol configuration properties. + ~TAO_UIOP_Connect_Creation_Strategy (void); + // Destructor + virtual int make_svc_handler (TAO_UIOP_Client_Connection_Handler *&sh); // Makes TAO_UIOP_Client_Connection_Handlers @@ -88,6 +91,9 @@ public: // @@ Do we want to pass in the tag here or should it be statically // defined? + ~TAO_UIOP_Connector (void); + // Destructor + // = The TAO_Connector methods, please check the documentation on // Pluggable.h int open (TAO_ORB_Core *orb_core); diff --git a/TAO/tao/TAO_Server_Request.cpp b/TAO/tao/TAO_Server_Request.cpp index a993d9046b1..997601111b6 100644 --- a/TAO/tao/TAO_Server_Request.cpp +++ b/TAO/tao/TAO_Server_Request.cpp @@ -58,7 +58,8 @@ TAO_ServerRequest::TAO_ServerRequest (TAO_Pluggable_Messaging *mesg_base, profile_ (orb_core), requesting_principal_ (0), is_dsi_ (0), - dsi_nvlist_align_ (0) + dsi_nvlist_align_ (0), + argument_flag_ (1) { ACE_FUNCTION_TIMEPROBE (TAO_SERVER_REQUEST_START); // No-op. @@ -89,7 +90,8 @@ TAO_ServerRequest::TAO_ServerRequest (TAO_Pluggable_Messaging *mesg_base, profile_ (orb_core), requesting_principal_ (0), is_dsi_ (0), - dsi_nvlist_align_ (0) + dsi_nvlist_align_ (0), + argument_flag_ (1) { profile_.object_key (object_key); parse_error = 0; @@ -128,6 +130,9 @@ TAO_ServerRequest::init_reply (CORBA::Environment &) // modifying...) marina reply_params.service_context_notowned (&this->service_info_); + // Are we going to marshall any data with the reply? + reply_params.argument_flag_ = this->argument_flag_; + // Forward exception only. if (!CORBA::is_nil (this->forward_location_.in ())) { @@ -182,6 +187,9 @@ TAO_ServerRequest::send_no_exception_reply (void) reply_params.reply_status_ = TAO_GIOP_NO_EXCEPTION; + // No data anyway. + reply_params.argument_flag_ = 0; + // Construct a REPLY header. this->mesg_base_->write_reply_header (*this->outgoing_, reply_params); diff --git a/TAO/tao/TAO_Server_Request.h b/TAO/tao/TAO_Server_Request.h index 03da51d2b28..ca55cc1adb0 100644 --- a/TAO/tao/TAO_Server_Request.h +++ b/TAO/tao/TAO_Server_Request.h @@ -158,7 +158,12 @@ public: void dsi_nvlist_align (ptr_arith_t alignment); // Set the member. + void argument_flag (CORBA::Boolean flag); + CORBA::Boolean argument_flag (void); + // Get/Set operations for the argument_flag + private: + TAO_Pluggable_Messaging *mesg_base_; ACE_CString operation_; @@ -214,6 +219,12 @@ private: ptr_arith_t dsi_nvlist_align_; // Used to pad CDR stream if we have used DSI. + + CORBA::Boolean argument_flag_; + // An argument flag to indicate whether there is any data that is + // going to get marshalled along as a reply. The default will be 1 + // which indicates that we have some data that needs to be sent back + // to the client. }; #if defined (__ACE_INLINE__) diff --git a/TAO/tao/TAO_Server_Request.i b/TAO/tao/TAO_Server_Request.i index 8a3945ff85a..dd0418f1bfd 100644 --- a/TAO/tao/TAO_Server_Request.i +++ b/TAO/tao/TAO_Server_Request.i @@ -145,3 +145,15 @@ TAO_ServerRequest::dsi_nvlist_align (ptr_arith_t alignment) { this->dsi_nvlist_align_ = alignment; } + +ACE_INLINE CORBA::Boolean +TAO_ServerRequest::argument_flag (void) +{ + return this->argument_flag_; +} + +ACE_INLINE void +TAO_ServerRequest::argument_flag (CORBA::Boolean flag) +{ + this->argument_flag_ = flag; +} diff --git a/TAO/tao/operation_details.h b/TAO/tao/operation_details.h index 471261c94b8..b21e3facd54 100644 --- a/TAO/tao/operation_details.h +++ b/TAO/tao/operation_details.h @@ -1,4 +1,4 @@ -// This may look like C, but it's really -*- C++ -*- +// This may look like C, but it's really -*- C++ -*- // $Id$ // ============================================================================ // @@ -9,18 +9,18 @@ // operation_details.h // // = AUTHOR -// Bala Natarajan <bala@cs.wustl.edu> +// Bala Natarajan <bala@cs.wustl.edu> // ============================================================================ -#ifndef TAO_OPERATION_DETAILS_H -#define TAO_OPERATION_DETAILS_H +#ifndef TAO_OPERATION_DETAILS_H +#define TAO_OPERATION_DETAILS_H #include "ace/pre.h" #include "tao/corbafwd.h" #include "tao/IOPC.h" #include "tao/target_specification.h" -// @@ Bala: Why is this not part of the RequestHeader?! +// @@ Bala: Why is this not part of the RequestHeader?! class TAO_Export TAO_Operation_Details { // = TITLE @@ -28,71 +28,81 @@ class TAO_Export TAO_Operation_Details // // = DESCRIPTION // This class stores some of the "operation" details that would be - // required by the invocation classes. this class is in its - // infancy now but I expect this one to grow as we come with - // different varieties of use cases. + // required by the invocation classes. this class is in its + // infancy now but I expect this one to grow as we come with + // different varieties of use cases. public: - TAO_Operation_Details (const char *name, - CORBA::ULong len); + TAO_Operation_Details (const char *name, + CORBA::ULong len, + CORBA::Boolean argument_flag); //Ctor - - const char* opname (void) const; + + const char* opname (void) const; // Operation name - + CORBA::ULong opname_len (void) const; // Length of the operation name - + + CORBA::Boolean argument_flag (void) const; + // Return the flag that indicates whether the operation has any + // arguments + void response_flags (CORBA::Octet flags); // Set the response flags - + CORBA::Octet response_flags (void); CORBA::Octet response_flags (void) const; // Get the response flags - IOP::ServiceContextList &service_info (void); - const IOP::ServiceContextList &service_info (void) const; + IOP::ServiceContextList &service_info (void); + const IOP::ServiceContextList &service_info (void) const; // Get the service context list - void request_id (CORBA::ULong id); + void request_id (CORBA::ULong id); CORBA::ULong request_id (void); CORBA::ULong request_id (void) const; // Get for request id - + TAO_Target_Specification::TAO_Target_Address addressing_mode (void); - TAO_Target_Specification::TAO_Target_Address + TAO_Target_Specification::TAO_Target_Address addressing_mode (void) const; - // Get method for the addressing mode + // Get method for the addressing mode + + void + addressing_mode (CORBA::Short addr); + // Set method for the addressing mode - void - addressing_mode (CORBA::Short addr); - // Set method for the addressing mode - private: - const char *opname_; + const char *opname_; // Name of the operation being invoked. CORBA::ULong opname_len_; // Precalculated length of opname_. CORBA::ULong request_id_; - // Request ID of this operation. - + // Request ID of this operation. + + CORBA::Boolean argument_flag_; + // Flag that indicates whether the operation has any arguments. If + // there are any arguments the falg will have a value of 1, 0 + // otherwise. + CORBA::Octet response_flags_; // Response flags - + IOP::ServiceContextList service_info_; - // The ServiceContextList sent to the server side. Only valid + // The ServiceContextList sent to the server side. Only valid // when sending a request. - + // The first element of header is service context list; - // transactional context would be acquired here using the - // transaction service APIs. Other kinds of context are as yet + // transactional context would be acquired here using the + // transaction service APIs. Other kinds of context are as yet // undefined. // TAO_Target_Specification::TAO_Target_Address addressing_mode_; - // Addressing mode for this request. + // Addressing mode for this request. }; #if defined (__ACE_INLINE__) diff --git a/TAO/tao/operation_details.i b/TAO/tao/operation_details.i index 736261b89f7..4934a77ceed 100644 --- a/TAO/tao/operation_details.i +++ b/TAO/tao/operation_details.i @@ -2,10 +2,12 @@ //$Id$ ACE_INLINE TAO_Operation_Details::TAO_Operation_Details (const char *name, - CORBA::ULong len) + CORBA::ULong len, + CORBA::Boolean argument_flag) :opname_ (name), opname_len_ (len), request_id_ (0), + argument_flag_ (argument_flag), response_flags_ (0), addressing_mode_ (TAO_Target_Specification::Key_Addr) { @@ -24,6 +26,12 @@ TAO_Operation_Details::opname_len (void) const return this->opname_len_; } +ACE_INLINE CORBA::Boolean +TAO_Operation_Details::argument_flag (void) const +{ + return this->argument_flag_; +} + ACE_INLINE IOP::ServiceContextList & TAO_Operation_Details::service_info (void) { @@ -37,7 +45,7 @@ TAO_Operation_Details::service_info (void) const } ACE_INLINE void -TAO_Operation_Details::request_id (CORBA::ULong id) +TAO_Operation_Details::request_id (CORBA::ULong id) { this->request_id_ = id; } @@ -57,7 +65,7 @@ TAO_Operation_Details::request_id (void) const ACE_INLINE void TAO_Operation_Details::response_flags (CORBA::Octet flags) { - this->response_flags_ = flags; + this->response_flags_ = flags; } ACE_INLINE CORBA::Octet @@ -72,27 +80,26 @@ TAO_Operation_Details::response_flags (void) const return this->response_flags_; } -ACE_INLINE TAO_Target_Specification::TAO_Target_Address +ACE_INLINE TAO_Target_Specification::TAO_Target_Address TAO_Operation_Details::addressing_mode (void) { return this->addressing_mode_; } -ACE_INLINE TAO_Target_Specification::TAO_Target_Address +ACE_INLINE TAO_Target_Specification::TAO_Target_Address TAO_Operation_Details::addressing_mode (void) const { return this->addressing_mode_; } -ACE_INLINE void +ACE_INLINE void TAO_Operation_Details:: - addressing_mode (CORBA::Short mode) + addressing_mode (CORBA::Short mode) { if (mode == 0) this->addressing_mode_ = TAO_Target_Specification::Key_Addr; - else if (mode == 1) + else if (mode == 1) this->addressing_mode_ = TAO_Target_Specification::Profile_Addr; - else if (mode == 2) + else if (mode == 2) this->addressing_mode_ = TAO_Target_Specification::Reference_Addr; } - |