Hello CLA-

Many of you Ada vets out there may know about this already, but I have
worked with Ada for years and never knew it was possible. What I am
referring to is the ability to use the 'Access attribute on a TYPE in a
limited type declaration. For example:

   type My_Obj_Type is abstract tagged limited private;

private

   -- A special initialization function that returns the initialization
value for one of an object's
   -- attributes, could also as a side effect initialize all of the
other fields or do other things
   function Special_Init_Function (The_Object : access My_Obj_Type)
return My_Type;

   type My_Obj_Type is abstract tagged limited
      record
         Attr_1 : My_Type := Special_Init_Function(The_Object =>
My_Obj_Type'Access);
         -- more attributes
      end record;

This will cause Special_Init_Function to be invoked whenever an instance
of any type derived from My_Obj_Type is created, and the object passed
in to the function will be the newly-created instance! You don't need to
use abstract tagged types with this, but I showed this as an example
because it seemed useful.

I don't know about the rest of you, but I always thought that the only
way to get an "initialization hook" that would be called whenever an
object was created was to use the Ada.Finalization package. Annex K of
the LRM does not indicate that 'Access can be used against a subtype,
and even Norm Cohen's excellent book "Ada as a Second Language" does not
mention this as far as I could tell.

I was informed about it during an e-mail dialogue with our support folks
at Green Hills. The only thing I could find in the LRM that indicated
that something like this would work was LRM 3.10.2 paragraph 24:
"X'Access yields an access value that designates the object denoted by
X. The type of X'Access is an access-to-object type, as determined by
the expected type. The expected type shall be a general access type. X
shall denote an aliased view of an object, including possibly the
current instance (see 8.6) of a limited type within its definition, ..."

I think this is a very powerful and handy capability, as it allows you
have an initialization hook without using controlled types. I was
investigating this as part of our work on the Real-time Object Database
with Extensions to ODMG (RODEO) project, which is an Ada95 real-time
object-oriented database manager we (LMC) are using as part of the
AN/SLY-2 (AIEWS) system.

Hope someone else finds this as useful as I did!

- Mike