Re: Enforcing initialization protocol for protected type

[Adam Beneschan <adam@irvine.com>]

On Sep 10, 9:39 am, Per Sandberg <per.sandb...@bredband.net> wrote:
> The following will solve your problem but there is a catch.
> The only compiler that will fix it is to my knowledge the most bleeding
> edge gnat.
> /Per
>
> -----------------------------
>        package p is
>           type Protected_t;
>           type initializer_t (Wrapped : not null access  Protected_t)
>             is new ada.Finalization.Limited_Controlled with null record;
>
>           procedure Initialize (self : in out initializer_t);
>           procedure Finalize   (self : in out initializer_t);
>
>           protected type Protected_t is
>              entry tick;
>              procedure Initialize;
>              procedure finalize;
>           private
>              initializer : initializer_t (Protected_t'access);
>           end;
>        end p;
>
>        package body p is
>           protected body Protected_t is
>              entry tick when True is begin
>                 null;
>              end;
>              procedure Initialize is
>              begin
>                 null;
>              end;
>              procedure finalize is
>              begin
>                 null;
>              end;
>           end;
>           procedure Initialize (self : in out initializer_t) is
>           begin
>              self.Wrapped.Initialize;
>           end;
>           procedure Finalize   (self : in out initializer_t) is
>           begin
>              self.Wrapped.Initialize;

That last probably ought to be self.Wrapped.Finalize.

>           end;
>        end p;

By the way, I think this will work, but it does mean that a protected
action will be called on a protected object before the object is fully
initialized.  I've looked through the language rules and I'm not
convinced this is a problem.  In Ada 95, 3.3.1(18-19) appeared to mean
that the object was *created* before its components were initialized,
and I suspect that creating the protected object included creating its
entry queues and completing whatever else would be necessary so that
the protected action that takes place when the Initialize protected
subprogram was called could be completed successfully (including
servicing the entry queues as required by 9.5.1(7)).  In Ada 2005,
however, 3.3.1(18-19) have been merged into one paragraph, so that the
timing isn't quite as clear, depending on how you interpret the new
paragraph.  Any language lawyers care to comment?  Is Per's example
(with additional code as needed in the Initialize procedure)
guaranteed to work (as long as the Initialize protected procedure
doesn't reference any components with per-object constraints that
haven't yet been initialized), or is it ambiguous whether it will work
or not?

                                        -- Adam