Re: "access constant" discriminant

[mheaney@on2.com (Matthew Heaney)]

Stephen Leake <Stephen.A.Leake@nasa.gov> wrote in message news:<uu1eyluui.fsf@nasa.gov>...
>
> Because the body needs to call other functions that take access types
> (that may beg the question, but it's the best I can do :).

Access parameters carry accessibility information around, to check
that an object in an outer scope doesn't refer to another object in an
inner scope.

These accessibility checks can be turned off using the
'Unchecked_Access attribute, or by using a pragma to suppress
Access_Check.

One example of the use of access parameters is the "multiple views"
idiom in Ada95, to effect the equivalent of multiple inheritance in
other languages.  For example, given a mechanism to store objects that
are "persistent":

   procedure Write 
     (Persistence : access Persistence_Type'Class);

then we can save any object that supports this view, like this:

   Some_Object : aliased T;
   ...
   Write (Persistence_View (Some_Object'Access));

The selector function would be written as:

  function Persistence_View 
   (Object : access T) return Persistence_Class_Access;

In the canonical model, type T would have an aliased component whose
type derives from Root_Persistence_Type, and the selector function is
implemented simply as:

   fuction Persistence_View 
     (Object : access T) return Persistence_Class_Access is
   begin
      return Object.Persistence_View'Access;
   end;

Here we see the reason why we passed an access parameter: it's because
we're returning an access value that designates one of our own
components.

The view component would be implemented like this:

   type Persistence_Type is
      new Root_Persistence_Type (Object : access T) with null record;

   type T is
      limited record
         Persistence_View : aliased Persistence_Type (T'Access);
         ...
      end record;

Presumably the Root_Persistence_Type has primitive operations for
writing an object into a stream, e.g.

   procedure Write 
     (Persistence : access Root_Persistence_Type;
      Stream      : in out Root_Stream_Type'Class) is abstract;

The Persisence_Type about would override the Write operation, to write
a T object into the stream.  It has visibility to the T object via its
access discriminant.

Access discriminants are very powerful.  No serious Ada95 program can
be written without them.