Re: tagged types extensions - language design question

["Vladimir Olensky" <vladimir_olensky@yahoo.com>]

Matthew Heaney wrote in message ...
>In article <s9av7kh45io46@corp.supernews.com> , "Vladimir Olensky"
><vladimir_olensky@yahoo.com> wrote:
>
>Yes, you have to declare the public part of abstraction first.
>
>> Very similar to the case when one wants to declare deallocation
>> procedure for some private type in the same package where this
>> private type is declared. Here right sequence is also very important
>> and might be even less obvious for those who encounter that need
>> for the first time.


<...>

>The other issue is how to reclaim instances.  You can either provide:
>
>1) a classwide Free operation (declared in the root package, and
>implemented by calling an instantiation of Unchecked_Deallocation, or by
>calling a private dispatching deconstructor)
>
>2) instead of using an access type, use a smart pointer, and let
>deallocation be automatically


As a matter of fact I am using both techniques when appropriate.

For private types I frequently use inlined public classwide Free
procedure that calls  private Free_Obj  classwide procedure:

package P is

 type Root is  abstract new Limited_Controlled with private;
 type Root_Ref is access all Root'Class;

 procedure Free (obj_Ref : in out Root_Ref);
 pragma Inline (Free);

private

     type Root is abstract  new Limited_Controlled with
         record
              Ref_Count : Integer := 0;  -- for "smart pointer" when it is
used;
              <some root common private fields>;
         record;

    procedure Free_Obj  is  new
               Ada.Unchecked_Deallocation ( Root'Class, Root_Ref );

end P;

package body P is

     procedure Free (obj_Ref : in out T_Ref) is
          Free_Obj (obj_Ref);
     end Free;

end P;

That's it.  It works for any descendants of the root class.

>In general, a client should never invoke an allocator ("new T")
>directly.  Give them a constructor, and invoke the allocator internally.

Constructor for any descendants of Controlled type  is it's Initialize
procedure.  With controlled types   one does not need to create
special public constructor for the derived class. Everything is
done  automatically by the Initialize.

Yes, if one  does  not want to use controlled type then one
may  want to provide his/her own public constructor.

Regards,
Vladimir Olensky