Reputation: 690
Is it possible to extend an Enum type in Ada? if I have for example:
type ABC_Type is (A, B, C);
Now I want new type ABCDE_Type that will include everything that ABC_Type has and Also (D, E). Is there a way to do that?
Upvotes: 5
Views: 2072
Reputation: 4198
The answer given by oneone is correct; you cannot extend enumeration (or numeric) types. You can however extend tagged types, using Yony's Animal/Fox example I've translated it into Ada's OO-model:
-- Percent defines an integer-value between zero and one-hundred, inclusive.
Subtype Percent is Natural Range 0..100;
-- Attribute defines an integer between one and ten, inclusive.
Subtype Attribute is Positive Range 1..10;
-- Animal, the base object-class.
Type Animal is Abstract Tagged Record
-- All Animals have a survivability attribute.
Survivability : Percent:= Percent'Last; -- Default "survivability" to Max.
End Record;
-----------------------------------------------------
-- Declaration of Primitive Operations for Animal. --
-----------------------------------------------------
-- Name; returns the name of the type of the animal.
Function Name( Object : In Animal'Class ) Return String;
-------------------------------------------------------
-- Implementation of Primitive Operations for Animal --
-------------------------------------------------------
Function Name( Object : In Animal'Class ) Return String is
Use Ada.Tags;
begin
-- This is implementation dependent; with the compiler I'm using the Uppercased
-- type-name of the actual object will be returned.
Return External_Tag(Object'Tag);
end Name;
---------------------------
-- The Fox object-class. --
---------------------------
Type Fox is New Animal with record
Cunning : Attribute:= Attribute'First;
end record;
In fact, both extension (OO-inheritance) and exclusion (subtyping) can be used in the same program, and the same subprograms operating on a type.
package Windowing is
Type Window is tagged private;
-- Pointers for windows.
Type Window_Pointer is Access Window'Class; -- Normal pointer
Subtype Handle is Not Null Window_Pointer; -- Pointer with Null excluded.
-- A light 'vector' of handles.
Type Window_List is Array (Positive Range <>) of Handle;
-- Primitive operations
Function Get_Child_Windows( Object : In Handle ) Return Window_List;
Procedure Set_Window_Height( Object : In Handle; Height : In Positive );
Function Get_Window_Height( Object : In Handle ) Return Positive;
-- more primitive operations... including subprograms to create windows
-- and perhaps assign them as children.
Private
Package Win_Vectors is new
Ada.Containers.Vectors(Index_Type => Positive, Element_Type => Handle);
Type Window is Tagged Record
-- X & Y may be negative, or zero.
X, Y : Integer:= Positive'First;
-- Height & Width must be positive.
Height, Width : Positive:= Positive'First;
-- Child-list
Children : Win_Vectors.Vector:= Win_Vectors.Empty_Vector;
End Record;
End Windowing;
package body Windowing is
Procedure Set_Window_Height( Object : In Handle; Height : In Positive ) is
begin
Object.Height:= Set_Window_Height.Height;
end Set_Window_Height;
Function Get_Window_Height( Object : In Handle ) Return Positive is
begin
Return Object.Height;
end Get_Window_Height;
Function Get_Child_Windows ( Object : In Handle ) Return Window_List is
begin
-- Return a null-array if there are no child windows.
if Object.Children.Is_Empty then
Return (2..1 => Object);
end if;
-- Create an array of the proper size, then initialize to self-referential
-- handle to avoid null-exclusion error.
Return Result : Window_List( 1..Positive(Object.Children.Length) ):=
(others => Object) do
Declare
Procedure Assign_Handle(Position : Win_Vectors.Cursor) is
Use Win_Vectors;
Index : Positive:= To_Index( Position );
begin
Result(Index):= Element(Position);
end Assign_Handle;
Begin
-- Replace the self-referential handles with the correct ones.
Object.Children.Iterate( Process => Assign_Handle'Access );
End;
End Return;
end Get_Child_Windows;
end Windowing;
Subtyping itself can be be a powerful concept on its own. Indeed when modeling mathematics, Ada's subtypings can allow functions to exactly match their mathematical definitions, or implement things in such a way that certain checks are completely unnessacary.
-- Remove non-normal representations.
Subtype Real is Float Range Float'Range;
-- Constrain to non-negative numbers.
Subtype Natural_Real is Real Range 0.0 .. Real'Last;
-- Because of the parameter-type, we do not need to implement any checks
-- for negative numbers in the subprogram body.
Function Square_Root( X : In Natural_Real ) Return Natural_Real;
-- Because Divisor is positive, we need not worry about ddivide-by-zero.
Function Good_Divide( Quotient: Integer; Divisor: Positive ) Return Natural;
Upvotes: 1
Reputation: 1804
No, you cannot extend an Enum type in Ada, you can only create derivations/subtypes that cover a subset of the original one.
You have to do it the other way round:
type ABCDE_Type is (A, B, C, D, E);
type ABC_Type is new ABCDE_Type range A .. C;
-- or
subtype ABC_Type is ABCDE_Type range A .. C;
Upvotes: 6