Re: Self pointer in limited record

[Georg Bauhaus <bauhaus.rm.tsoh@maps.futureapps.de>]

Dmitry A. Kazakov wrote:
> On Fri, 31 Aug 2007 16:47:29 -0000, amado.alves@gmail.com wrote:
> 
>> Then you have seen illegal Ada code repeatedly. I wish this were
>> possible myself. Or more simply:
>>
>> type T is -- limited or not
>>    Self : access T := T'Unchecked_Access;
>>    ...
>> end;
> 
> T cannot be non-limited, because otherwise passing it by copy would make
> rubbish out of Self. In any case it would make little sense if not access
> T'Class.


I think there is an interesting use of a .Self pointer of
simple limited records with state variables of packages.

Say a procedure in a package P controls the state of some
variable in the package's body. The state variable is of type
access T, where T  is a limited record type declared in P. The
purpose of the state variable is to remember the object of type T
that will be the target of subsequent package operations.

A natural way to remember a particular object is to point
to the object. But package clients should not have to worry
about this pointing mechanism.  So the package shouldn't
declare a public access type used for internal mechanism only.
Instead there is a procedure of one T argument that can be called
by clients when they want to indicate the object to be used
in subsequent P operations.

This is where .Self can be used. We cannot take 'Access
or 'Unchecked_Access of subprogram arguments unless they
are aliased (such as those of type T'Class).
But the .Self component of the subprogram's argument supplies
the access value that is needed for storing a pointer to the
argument in the package body.


package P is

       type T is limited private;

       procedure Choose (Selected: in out T);
		-- sets target T for subsequent operations
       procedure Work;
               
private
       type Bits is array(0 .. 15) of Boolean;
       type T_Access is access all T;
       type T is limited record
               Self: T_Access := T'unchecked_access;
               Slots: Bits;
       end record;
           
end P;

package body P is

       Current: T_Access;  -- state variable, target object

       procedure Choose (Selected: in out T) is
       begin
               Current := Selected.Self;  -- here
       end Choose;

       procedure Work is
       begin
               Current.Slots(3) := not Current.Slots(3);
       end Work;
end P;


(The true O-O programmer might suggest that we should simply
pass an additional object-as-module parameter to every
package subprogram... )