Re: How to avoid unreferenced objects (mutexes etc)

[dmitry@elros.cbb-automation.de (Dmitry A. Kazakov)]

On Wed, 16 Jan 2002 13:30:50 -0500, "Matthew Heaney" <mheaney@on2.com>
wrote:

>"Dmitry A. Kazakov" <dmitry@elros.cbb-automation.de> wrote in message
>news:3c45865f.2709203@News.CIS.DFN.DE...
>> However, I always wished Ada having an ability to disallow primitive
>> operations. Like:
>>
>> type Unordered is new Integer;
>> function ">" (Left, Right : Unordered) is abstract; -- Disallow ">"
>
>I'm confused by your comment.  Ada95 *can* do this.
>
>I do this to turn off predefined equality for a composite type whose
>component type is a generic formal non-limited type, so that I don't
>accidently use predefined array comparisons using the predefined equality
>for the formal type, which reemerges in the composite type, ie
>
>generic
>   type T is private;
>package GP is
>   type T_Array is array (Positive range <>) of T;
>   function "=" (L, R : T_Array) return Boolean is abstract;
>end GP;
>
>Note that passing in an equality operator doesn't work here, because
>predefined equality reemerges *again* in the array declaration.  So I just
>turn off array comparison, in order to prevent any accidents.

Yes it works (I have actually used that) for some cases. It does not
work when the type is non-abstract and tagged.

Sorry for my misleading comment.

I believe it is worth to allow that for all types, i.e. to allow
overriding a non-abstract subroutine with an abstract one. A
dispatching call to a disallowed subprogram will then raise an
exception [like when tags of arguments are different].

>> >But the tagged type could contain a component of a task type.
>>
>> Yes, and another problem as well. Finalize is called *after* all task
>> components has been terminated. So when the object is being destroyed
>> you cannot notify tasks about that. You must use pointers to tasks if
>> you need a "prepare-to-die" notification.
>
>But you can use a two-part termination:
>
>package P is
>   type T (<>) is abstract tagged limited private;
>   type T_Class_Access is access all T'Class;
>   procedure Op (O : access T) is abstract;
>   procedure Free (O : in out T_Class_Access);
>private
>   type T_Task_Type (O : access T'Class) is
>      entry E;
>   end T_Task_Type;
>
>   type T is abstract new Limited_Controlled with record
>      T_Task : T_Task_Type (T'Access);
>   end record;
>
>   procedure Do_Free (O : access T);  --private, primitive op
>end P;
>
>
>package body P is
>   procedure Do_Free (O : access T) is
>   begin
>      null;
>   end;
>
>   procedure Free (O : in out T_Class_Access) is
>      procedure Deallocate is new Ada.UD (T'Class, T_Class_Access);
>   begin
>      if O /= null then
>         Do_Free (O);
>         Deallocate (O);
>      end if;
>   end Free;
>...
>end P;
>
>Each type in T'Class provides a factory function to construct instances.  To
>destruct an instance, the client calls P.Free.  Free is implemented by
>calling dispatching Do_Free, which notifies the object that it's about to be
>destroyed.  It then calls deallocate, which triggers the Finalize call.
>
>Won't this work?

Surely. But I prefer my solution because it hides nasty pointers in
the implementation. Your variant exposes them to the user. Using C++
for a long time one becomes pointer-allergic. (:-)) In fact it is the
*same* solution, i.e. pointers are inevitable. Would not it be better
to add to Ada.Finalization

procedure Postinitialize (..); -- All tasks are already running
procedure Prefinalize (..);    -- All tasks are still running

?

Regards,
Dmitry Kazakov