CPP12 — Requiring ref counting in ServantBase

The current requirement that the default implementations of _add_ref
and _remove_ref in ServantBase do nothing creates several problems:

1. The text in the C++ mapping that states that _remove_ref
must be called on a servant means nothing unless the ref
counting mix-in was used by the servant author.

2. The intended semantics of _var types as "smart pointers"
is upheld only if the servant author goes to the extra
step of using the ref counting mix-in.

3. In many places the C++ mapping explicitly or implicitly
states that _var types will recover memory for the application
developer:

1.3.1:

Client code frequently will use the object reference
variable type (A_var) because a variable will
automatically release its object reference when it is
deallocated or when assigned a new object reference.

1.3.6:

When a _var is passed as an out parameter, any
previous value it refers to must be implicitly
released.

In addition, there are many places in the C++ mapping where
the specification of _var types for arrays, structs, strings,
sequences, type Any, type codes, value types, value boxes,
value factories, etc. guarantees that the memory will be
reclaimed when the _var goes out of scope. This makes it
easy for users to believe that all _var types will release
storage for the objects that point to.

Benefits of Proposed Resolution:

Users can depend on ORB's to manage servant memory by default
rather than by exception.

Specification text that promises or implies automatic memory
reclamation need not change.

Existing user code will still compile.

Resolution:
Revised Text:

Replace the text in section 1.36.1 beginning with the sentence:

Servant instances may implement reference counting to prevent
themselves from being destroyed while the application is
still using them.

and section 1.36.2 in its entirety with:

Servant instances may implement reference counting to prevent
themselves from being destroyed while the application is still
using them. Servant reference counting is performed using the
_add_ref and _remove_ref functions declared in ServantBase. The
default implementations of _add_ref and _remove_ref supplied by
ServantBase provide true reference counting. An instance of a
servant class derived from ServantBase initially has a reference
count of one. Invoking _add_ref on the servant instance
increases its reference count by one. Invoking _remove_ref on
the servant instance decreases its reference count by one; if the
resulting reference count equals zero, _remove_ref invokes delete
on its this pointer in order to destroy the servant. For ORBs
that operate in multi-threaded environments, the implementations
of _add_ref and _remove_ref that the ServantBase class provides
shall be thread-safe.

ServantBase supports copy construction and the default assignment
operation. Copy construction always sets the reference count of
the new servant instance to one. The default assignment
implementation merely returns *this and does not affect the
reference count.

For servants that require that servants are not reference
counted, these functions are virtual and thus may be overridden
by derived servant classes. A default mix-in class is also
provided to remove the reference counting in the PortableServer
namespace; please see Section 1.36.2, "Servant No Reference
Counting Mix-In," on page 1-??? for more details. Details
concerning POA and application responsibilities with respect to
reference counting can be found in Section 1.36.4, "Servant
Memory Management Considerations," on page 1-???.

Note that for applications that depended on the the
RefCountServantBase provided in previous revisions of this
specification ORBs must provide a default implementation of this
mix-in class in the PortableServer namespace that essentially
does nothing:

// C++
namespace PortableServer
{
class RefCountServantBase : public virtual ServantBase

;

}

1.36.2 Servant No Reference Counting Mix-In

The PortableServer namespace also provides a standard servant
mix-in class to remove the reference counting:

// C++
namespace PortableServer
{
class NoRefCountServantBase : public virtual ServantBase
{
public:
~NoRefCountServantBase();
virtual void _add_ref() {}
virtual void _remove_ref() {}
protected:
NoRefCountServantBase() {}
NoRefCountServantBase(const NoRefCountServantBase&) {}
NoRefCountServantBase& operator=(const NoRefCountServantBase&);
private:
// ...other implementation details...
};
}

The NoRefCountServantBase mix-in class overrides the inherited
_add_ref and _remove_ref functions it inherits from ServantBase,
in order to override and remove the default reference counting in
ServantBase.

see below