Re: Variant records..

[Ludovic Brenta <ludovic.brenta@insalien.org>]

ganesh.ramasivan@gdcanada.com (Ganesh Ramasivan) writes:

> Preben Randhol wrote...
> > On 2004-02-15, Ganesh Ramasivan wrote:
> > > In the following example, how would i forbid the user of data type Foo
> > > from specifying the following:
> > >
> > > John : Foo(Vehicle => MAN, Power => AUTOMATIC);
> > >
> > > ie. is there a way to restrict the user from specifying certain types
> > > as variants?
> > 
> > I guess this is homework? If it is why don't you simply try to do this
> > and see what happens?
> 
> This is just a simple example I am working with as I am an ada newbie.
> 
> I tried and it compiles. What I am trying to do is to prevent the user
> from creating types that do not make sense.

IOW, you want to introduce a constraint between Vehicle and Power.
Personally, I would replace the two discriminants with just one:

type Vehicle is (Man, Bicycle, Car_Automatic, Car_Manual, Helicopter, Jet,
                 Space_Launcher);

The alternative would be to make type Foo private, hide the
discriminants from the user, and provide a constructor function.  This
however replaces the static checks performed by the compiler with a
run-time check, so your user needs a unit test wherever they call
New_Foo.

procedure Vehicles is

   package P is
      type Vehicle_Type is (Man, Bicycle, Car, Helicopter, Jet,
                            Space_Launcher);
      type Power_Type is (Automatic, Manual, None);
      type Foo (<>) is private;
      function New_Foo (Vehicle : Vehicle_Type; Power : Power_Type) return Foo;
   private
      type Foo (Vehicle : Vehicle_Type; Power : Power_Type) is record
         Horsepower : Float;
         case Power is
            when Automatic | Manual =>
               Gears : Positive;
            when others =>
               null;
         end case;
      end record;
   end P;

   package body P is
      function New_Foo (Vehicle : Vehicle_Type; Power : Power_Type) return Foo
      is
      begin
         case Vehicle is
            when Car =>
               if Power = None then raise Constraint_Error; end if;
            when others =>
               if Power /= None then raise Constraint_Error; end if;
         end case;
         declare
            Result : Foo (Vehicle, Power);
         begin
            return Result;
         end;
      end New_Foo;
   end P;

   use P;

   F : Foo := New_Foo (Vehicle => Man, Power => Automatic);
begin
   null;
end Vehicles;

-- 
Ludovic Brenta.