Issue 1626: C++ issue to coordinate with proposed resolution of issue 752 (cxx_revision) Source: (, ) Nature: Revision Severity: Summary: Summary: In coordination with the proposed resolution to the ORB Portability RTF Issue #752, add the following operations to PortableServer::ServantBase in section 20.34.1: class ServantBase { ... public: ... virtual InterfaceDef_ptr _get_interface() throw(SystemException); virtual Boolean _is_a(const char * logical_type_id) throw(SystemException); virtual Boolean _non_existent() throw(SystemException); ... }; and change the last paragraph of section 20.34.1 to: The default implementation of the _default_POA() function provided by ServantBase returns an object reference to the root POA of the default ORB in this process — the same as the return value of an invocation of ORB::resolve_initial_references("RootPOA") on the default ORB. Classes derived from ServantBase can override this definition to return the POA of their choice, if desired. and add the following text at the end of section 20.34.1: ServantBase provides default implementations of the _get_interface(), _is_a(), and _non_existent() standard object reference operations that can be overridden by the object implementation if the default behavior is not adequate. These functions are called just like normal skeleton operations by the POA, so the programmer can use _this() and and the PortableServer::Current interface in the function bodies. The default implementation of the _get_interface() and _is_a() functions provided by ServantBase uses the interface associated with the skeleton class if it is static to determine its return value. If the skeleton is dynamic (see 20.36) it uses the _primary_interface() function to determine its return value. The default implementation of the _non_existent() function simply returns false. Resolution: :ServantBase Revised Text: Actions taken: July 2, 1998: received issue February 23, 1999: closed issue Discussion: End of Annotations:===== Return-Path: Date: Wed, 01 Jul 1998 16:37:59 -0400 From: Jonathan Biggar Organization: Floorboard Software To: cxx_revision@omg.org, issues@omg.org Subject: New C++ issue In coordination with the proposed resolution to the ORB Portability RTF Issue #752, add the following operations to PortableServer::ServantBase in section 20.34.1: class ServantBase { ... public: ... virtual InterfaceDef_ptr _get_interface() throw(SystemException); virtual Boolean _is_a(const char * logical_type_id) throw(SystemException); virtual Boolean _non_existent() throw(SystemException); ... }; and change the last paragraph of section 20.34.1 to: The default implementation of the _default_POA() function provided by ServantBase returns an object reference to the root POA of the default ORB in this process this definition to return the POA of their choice, if desired. and add the following text at the end of section 20.34.1: ServantBase provides default implementations of the _get_interface(), _is_a(), and _non_existent() standard object reference operations that can be overridden by the object implementation if the default behavior is not adequate. These functions are called just like normal skeleton operations by the POA, so the programmer can use _this() and and the PortableServer::Current interface in the function bodies. The default implementation of the _get_interface() and _is_a() functions provided by ServantBase uses the interface associated with the skeleton class if it is static to determine its return value. If the skeleton is dynamic (see 20.36) it uses the _primary_interface() function to determine its return value. The default implementation of the _non_existent() function simply returns false. -- Jon Biggar Floorboard Software jon@floorboard.com jon@biggar.org Return-Path: Sender: jon@floorboard.com Date: Fri, 17 Jul 1998 19:35:23 -0700 From: Jonathan Biggar To: cxx_revision@omg.org Subject: Proposal for issue #1626 Here is the second proposal for consideration by the C++ RTF for CORBA 2.3: In coordination with the resolution to the Issue #738, which has been approved by the ORB Portability RTF, add the following operations to PortableServer::ServantBase in section 20.34.1: class ServantBase { ... public: ... virtual InterfaceDef_ptr _get_interface() throw(SystemException); virtual Boolean _is_a(const char * logical_type_id) throw(SystemException); virtual Boolean _non_existent() throw(SystemException); ... }; and change the last paragraph of section 20.34.1 to: The default implementation of the _default_POA() function provided by ServantBase returns an object reference to the root POA of the default ORB in this process (the same as the return value of an invocation of ORB::resolve_initial_references("RootPOA") on the default ORB). Classes derived from ServantBase can override this definition to return the POA of their choice, if desired. and add the following text at the end of section 20.34.1: ServantBase provides default implementations of the _get_interface(), _is_a(), and _non_existent() standard object reference operations that can be overridden by the object implementation if the default behavior is not adequate. These functions are called just like normal skeleton operations by the POA, so the programmer can use _this() and and the PortableServer::Current interface in the function bodies. The default implementation of the _get_interface() and _is_a() functions provided by ServantBase uses the interface associated with the skeleton class if it is static to determine its return value. If the skeleton is dynamic (see 20.36) it uses the _primary_interface() function to determine its return value. The default implementation of the _non_existent() function simply returns false. Rational: The CORBA 2.2 C++ language mapping did not address these standard object operations. Some static skeleton classes may need to provide a custom implementation of the _non_existent operation to assure that the proper state of the object is returned. Dynamic skeleton classes that are acting as bridge objects need to provide custom implementations of all three of these functions that forward the operation to the real target object. By defining these functions as virtual with reasonable default implementations, skeletons written to the CORBA 2.2 specification will still operate correctly. -- Jon Biggar Floorboard Software jon@floorboard.com jon@biggar.org Return-Path: X-Sender: vinoski@mail.boston.iona.ie Date: Sat, 18 Jul 1998 09:27:20 -0400 To: Jonathan Biggar From: Steve Vinoski Subject: Re: Proposal for issue #1626 Cc: cxx_revision@omg.org At 07:35 PM 7/17/98 -0700, Jonathan Biggar wrote: >In coordination with the resolution to the Issue #738, which has been >approved by the ORB Portability RTF, add the following operations to >PortableServer::ServantBase in section 20.34.1: > >class ServantBase { > ... >public: > ... > virtual InterfaceDef_ptr _get_interface() throw(SystemException); > virtual Boolean _is_a(const char * logical_type_id) >throw(SystemException); > virtual Boolean _non_existent() throw(SystemException); > ... >}; > >and change the last paragraph of section 20.34.1 to: > >The default implementation of the _default_POA() function provided by >ServantBase returns an object reference to the root POA of the default >ORB in this process (the same as the return value of an invocation of >ORB::resolve_initial_references("RootPOA") on the default ORB). Classes >derived from ServantBase can override this definition to return the POA >of their choice, if desired. > >and add the following text at the end of section 20.34.1: > >ServantBase provides default implementations of the _get_interface(), >_is_a(), and _non_existent() standard object reference operations that >can be overridden by the object implementation if the default behavior >is not adequate. These functions are called just like normal skeleton >operations by the POA, so the programmer can use _this() and and the >PortableServer::Current interface in the function bodies. > >The default implementation of the _get_interface() and _is_a() functions >provided by ServantBase uses the interface associated with the skeleton >class if it is static to determine its return value. If the skeleton is >dynamic (see 20.36) it uses the _primary_interface() function to >determine its return value. > >The default implementation of the _non_existent() function simply >returns false. IONA votes to adopt this proposed change. --steve Return-Path: Sender: jon@floorboard.com Date: Sat, 18 Jul 1998 09:33:31 -0700 From: Jonathan Biggar To: cxx_revision@omg.org Subject: Proposals for 1319 & 1626 I suppose it goes without saying that Floorboard votes YES on both of these proposals. :-) -- Jon Biggar Floorboard Software jon@floorboard.com jon@biggar.org Return-Path: X-Authentication-Warning: tigger.dstc.edu.au: michi owned process doing -bs Date: Sun, 19 Jul 1998 07:48:32 +1000 (EST) From: Michi Henning To: Jonathan Biggar cc: cxx_revision@omg.org Subject: Re: Proposal for issue #1626 On Fri, 17 Jul 1998, Jonathan Biggar wrote: > Here is the second proposal for consideration by the C++ RTF for CORBA > 2.3: > > In coordination with the resolution to the Issue #738, which has been > approved by the ORB Portability RTF, add the following operations to > PortableServer::ServantBase in section 20.34.1: > > class ServantBase { > ... > public: > ... > virtual InterfaceDef_ptr _get_interface() throw(SystemException); > virtual Boolean _is_a(const char * logical_type_id) > throw(SystemException); > virtual Boolean _non_existent() throw(SystemException); > ... > }; DSTC votes yes to accept this change. Cheers, Michi. -- Michi Henning +61 7 33654310 DSTC Pty Ltd +61 7 33654311 (fax) University of Qld 4072 michi@dstc.edu.au AUSTRALIA http://www.dstc.edu.au/BDU/staff/michi-henning.html Return-Path: Date: Sat, 18 Jul 1998 17:14:18 -0700 From: "Jon Goldberg" To: Michi Henning CC: jon@floorboard.com, cxx_revision@omg.org Subject: Re: Proposal for issue #1626 References: Count a YES from inprise as well. -Jon Michi Henning wrote: > > On Fri, 17 Jul 1998, Jonathan Biggar wrote: > > > Here is the second proposal for consideration by the C++ RTF for > CORBA > > 2.3: > > > > In coordination with the resolution to the Issue #738, which has > been > > approved by the ORB Portability RTF, add the following operations > to > > PortableServer::ServantBase in section 20.34.1: > > > > class ServantBase { > > ... > > public: > > ... > > virtual InterfaceDef_ptr _get_interface() > throw(SystemException); > > virtual Boolean _is_a(const char * logical_type_id) > > throw(SystemException); > > virtual Boolean _non_existent() throw(SystemException); > > ... > > }; > > DSTC votes yes to accept this change. > > Cheers, > > > Michi. > > > > ------------------------------------------------------------------------ > > Part.001 Name: Part.001 > Type: Plain Text (text/plain) Return-Path: X-Sender: vinoski@mail.boston.iona.ie Date: Fri, 24 Jul 1998 16:44:45 -0400 To: cxx_revision@omg.org From: Steve Vinoski Subject: Re: We need votes!!!!!!! References: <9807241648.AA06909@jam.tid.es> At 08:56 AM 7/24/98 -0700, Jonathan Biggar wrote: >Ok, here's the new scoreboard: > >Issue 1319: > Yes: 6 (Floorboard, DSTC, HP, IONA, Inprise, Telefonica) > No: 0 > NV: 4 > >Issue 1626: > Yes: 6 (Floorboard, DSTC, HP, IONA, Inprise, Telefonica) > No: 0 > NV: 4 Because we have ten RTF members, once a proposal has six votes, it passes. This means that 1319 and 1626 have been adopted. Just a reminder: the voting deadline is Monday July 27th at 5:00pm EDT. I will then get a revised C++ document reflecting the adopted proposals out to this RTF sometime on Tuesday, as early as possible, and it will need a very quick review from you guys because it is due to the OMG on Wednesday. Sorry for the short timeframes, but with all the other RTFs in progress and the time needed to vet these proposals, it's the best we could do. --steve