Re: Array of Variant Records Question...

["Matthew Heaney" <matthew_heaney@acm.org>]

In article <7r5vh3$imu1@svlss.lmms.lmco.com> , "Bruce Detter" 
<bruce.detter@lmco.com> wrote:

> How do you declare an array of variant records where each variant record's
> descriminant is the array index?  Can it be done at all?  I would prefer not
> to use access pointers if it can be avoided.

I did something like this in all my dining philosopher examples, in the ACM
Ada95 design pattern archives.  Look for the "Dining Philosophers" example
in the Apr 99 link.

In that example, it's a task that has a discriminant, but that's equivalent
to your variant record.


   subtype Philosopher_Id is Positive range 1 .. 5;

   package Id_Management is

      function Get_Id return Philosopher_Id;

   end;
   use Id_Management;

   package body Id_Management is

      Id : Natural := 0;

      function Get_Id return Philosopher_Id is
      begin
         Id := Id + 1;
         return Id;
      end;

   end Id_Management;



   task type Philosopher_Task_Type
     (Id : Philosopher_Id := Get_Id) is

      entry Start;
   end;

   type Philosopher_Task_Array is
      array (Philosopher_Id) of Philosopher_Task_Type;

   Philosopher_Tasks : Philosopher_Task_Array;


At elaboration time, as each task in the array elaborates, it calls Get_Id,
which returns an Id for that task.

Note, however, that there is no necessary correlation between the order of
elaboration of array elements, and the index of the array.  In the example
I've shown above, the task Philosopher_Tasks (1) doesn't necessarily have an
Id with the value 1.

If you need that correspondence, you're going to have to use indirection.
Populate another array with access objects designating the task with that
array index, ie

   <as before>

   type Philosopher_Task_Array is
      array (Philosopher_Id) of aliased Philosopher_Task_Type;
   -- array components are now aliased

   Philosopher_Tasks : Philosopher_Task_Array;

   type Philosopher_Task_Access is
     access all Philosopher_Task_Type;

   type Philosopher_Task_Access_Array is
     array (Philosopher_Id) of Philosopher_Task_Access;

   Philosopher_Index : Philosopher_Task_Access_Array;
   ...
 begin  -- the begin part of the body, or where-ever

   for Id in Philosopher_Tasks'Range loop
     declare
       PT : Philosopher_Task_Type renames
          Philosopher_Task_Array (Id);
     begin
       Philosopher_Index (PT.Id) := PT'Access;
     end;
   end loop;

  end;


Now Philosopher_Index (i) points to the philosopher task whose Id = i.  So
you'll have to use a level of indirection:

  declare
    PT : Phil_Task_Type renames Philosopher_Index (I).all;
  begin
    -- PT.Id = I


Sorry it's a bit complicated; this is one of the glaring flaws in the
language.  But as you can see there is a work-around.

--
Matt

It is impossible to feel great confidence in a negative theory which has
always rested its main support on the weak points of its opponent.

Joseph Needham, "A Mechanistic Criticism of Vitalism"