Subject: Re: Beware: Rep spec on an enumeration type causes code explosion
From: John G. Volan, johnv@ac3i.dseg.ti.com
Date: Thu, 11 Dec 1997 09:38:53 -0800

Ken Garlington wrote:
> 
> One of the nice things about "holey" representations in Ada, when used
> for
> interfacing to external systems, is the use of 'Valid to check for valid
> input
> data in a very readable manner. However, I would convert the raw input
> to a non-holey type after the check, using either a map or case
> statement
> (depending upon the compiler).

There is no need for anything so elaborate.  Just derive a holey
enumeration type from a contiguous enumeration type. Then you can simply
use ordinary Ada type-conversions, and the compiler will implicitly do
the mapping for you:

    with Ada.Text_IO;
    procedure Holey_Enum_Demo is
    
      type Contiguous_Type is (A, B, C, D, E);
      -- *no* rep spec!
    
      type Holey_Type is new Contiguous_Type;
      for Holey_Type use (A => 1, B => 2, C => 4, D => 8, E => 16);
    
      Contiguous : Contiguous_Type := A;
      Holey      : Holey_Type      := B;

    begin
    
      Contiguous := Contiguous_Type (Holey);
      -- implicitly does equivalent of 'Pos

      Holey      := Holey_Type (Contiguous);
      -- implicitly does equivalent of 'Val
    
    end Holey_Enum_Demo;

My feeling is that "holey" enumeration types (like other Chapter 13
features) should really only be used at the "edges" of a program,
wherever you're immediately reading from or writing to some external
system that is expecting a certain data format.  Contiguous enumeration
types should be used internally everywhere else in your program, for all
the efficiency reasons that have been ... enumerated :-) ... in this
thread. Luckily, Ada provides this convenient way of converting between
holey and contiguous representations.