CORBA24 — Servant deactivation callback?

Consider a servant for a persistent object that sits in front of a database.
Assume a simple implementation model, using RETAIN and
USE_ACTIVE_OBJECT_MAP_ONLY.

We have n CORBA objects with n servants, and each servant implements
its operations by reading/writing through to the persistent store, possibly
also caching some state and maintaining other resources, such as database
connections or memory buffers.

I want to implement a life cycle destroy() operation. In the body of
destroy, I have to write something like:

void
Foo_impl::
destroy() throw(CORBA::SystemException)

The problem is that the servant can't simply blow things away at that
point because there may be other operations running concurrently in the
same servant, and those operations would get awfully surprised if their
state suddenly disappeared.

So, I delay reclaiming resources and deleting the database record until
the servant becomes idle. In C++, that's no problem. Eventually, the
servant's AOM entry disappears and (at least if I use reference-counted
servants) that triggers the destructor of the servant, and I can
clean up in the destructor.

However, it appears that this doesn't work for other languages because they
may not have destructors or, like Java, make no guarantees about when
the destructor will be called.

The problem is that there is no way for me to find out at what
point the servant becomes idle, so that I could clean up.

I think we need a callback from the ORB to the server application code that
notifies the server when a servant finally becomes idle. Otherwise, it is
pretty much impossible to implement life cycle support in languages other
than C++, especially for threaded servers.

Close no change.