Re: Heterogenous array

["Robert I. Eachus" <rieachus@comcast.net>]

Bj�rn Persson wrote:

> I need an array type that can hold elements of different types. My 
> current attempt (somewhat simplified) is below. My question is, is there 
> a way to do this without pointers?

Sure, try:

with Ada.Strings.Bounded; with Ada.Strings.Unbounded;
package Multirecord is

     package A_Bounded_String is new 
Ada.Strings.Bounded.Generic_Bounded_Length(80);
     subtype A_Bounded_String_Type is A_Bounded_String.Bounded_String;

     type T_Param_Type is (Int, Str);
     type Parameter_Definition(Param_Type : T_Param_Type := Int) is record
        Name : A_Bounded_String_Type;
        case Param_Type is
           when Int =>
              Min : Integer;
              Max : Integer;
              Int_Value : Integer;
           when Str =>
              Str_Value : Ada.Strings.Unbounded.Unbounded_String;
        end case;
     end record;

     type Parameter_Wrapper is record
       Content: Parameter_Definition;
     end record;

     type Parameter_Array is array(Positive range <>) of
                            Parameter_Wrapper;

end Multirecord;

It should compile without problems and do exactly what you want.  The 
type Parameter_Wrapper is needed so that the element type of 
Parameter_Array is constrained.  The rule that requires this may seem 
silly but it is not.  Objects of type Parameter_Definition can be 
different sizes, objects of type Parameter_Wrapper are not.  In effect, 
the reason for having the Parameter_Wrapper type is for the compiler to 
have a hook to do the mutable type thing. (Which in Ada is only a 
property of records with (defaulted) discriminants but never of array 
elements.)

Whether the implementation accomplishes this by making Parameter_Wrapper 
the size of the largest possible Parameter_Definition or uses "hidden" 
pointers is, of course, up to the implementation.  Some compilers alway 
"allocate the max," others only do that if the maximum size is below 
some threshold.  I am not sure whether there are any compilers that 
always use hidden pointers.

-- 
                                           Robert I. Eachus

"The only thing necessary for the triumph of evil is for good men to do 
nothing." --Edmund Burke