Re: Self pointer in limited record

["Randy Brukardt" <randy@rrsoftware.com>]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message
news:h9v0j8x5uuf3.puwqdmssdfn6$.dlg@40tude.net...
> On Mon, 10 Sep 2007 16:27:50 -0000, amado.alves@gmail.com wrote:
>
> > FWIW, the problem was the following. I am writing a library. I wanted
> > to provide a function to the user to allow him to specify the parent
> > of an object in a simple way e.g.
> >   Parent_Object : Object := Lookup (Name = "foo foo");
> >   Object : Object := Create (Name => "bla bla", Parent =>
> > Parent_Object);
>
> What happens when the parent gets finalized before its child? The point is
> that if you have a reference semantics, then probably Object must be a
> reference. So access Obkect'Class were a better design. If you want to
hide
> references, then you should use smart pointers instead.

I disagree. Claw uses a design rather like the one proposed here. All of the
needed references are created inside of the Claw library, and managed there
(with Finalization and Adjust). For instance, if the parent object is
finalized, the child object is finalized first (that's necessary because
destroying a parent window also destroys any children). If a child window is
finalized, it is unlinked from any lists that it is in.

Keep in mind that a tagged parameter is always considered aliased. So there
is no problem creating any references you need inside the library (assuming
that yyour basic types are tagged -- which they usually will be in order to
have them Controlled).

I strongly believe that having explicit access types in a specification is
wrong. Because of limitations in Ada, they can't quite all be eliminated (no
"in out" parameters for functions, for instance), but I think they should
only be used if there is no viable alternative. (This opinion is not
universal.)

> > The idea was to have a clean profile like
> >    Create (Name : String; Parent : Object);
> > instead of
> >    Create (Name : String; Parent : access Object);

Yes, except the first probably ought to be
   Create (Name : String; Parent : Object'Class);
(tagged subroutines either should be primitive operations or have class-wide
parameters, otherwise there is something suspicious going on. And surely
Create is not a primitive of the parent object's type!)

> > Inside the function there is code like
> >    New_Object.Parent := Parent.Self; -- (clean profile)

Don't even need that. Just use:

    New_Object.Parent := Parent'Unchecked_Access;

since tagged parameters are always considered aliased. (You do need to keep
a list of children in Parent as well so that it can be unlinked from the
child if it is finalized first).

I personally think self pointers are overrated in Ada; you only really need
them to work around language bugs ("in out" parameters for functions again);
for everything else, just use the object directly.

                 Randy.