Concatenate enumeration
Pablo
some enumerations.
So:
type Enumerate_Type is
(
NONE,
READY
);
for Enumerate_Type use
(
NONE => 0,
READY=> 1
);
for Enumerate_Type'Size use 1;
and I want to create a new type Enumerate2_Type which could be the
form
type Enumerate_Type is
(
NONE,
READY,
OFF
);
for Enumerate_Type use
(
NONE => 0,
READY=> 1,
OFF => 2
);
for Enumerate_Type'Size use 2;
How to I do this without having to explicit clone the first one?
Thanks
Jeffrey R. Carter
You can't. Enumeration types are not extensible.
You can do something similar in the reverse direction:
type Big is (None, Ready, Off);
subtype Small is Big range None .. Ready;
or
type Small is new Big range None .. Ready;
--
Jeff Carter
"Monsieur Arthur King, who has the brain of a duck, you know."
Monty Python & the Holy Grail
09
Robert A Duff
Note that all of the rep clauses above are unnecessary: the language
defines the default rep of enums to be (0, 1, ...),
and defines the 'Size to be 1 and 2 for the above.
If you want to confirm the 'Size, I'd do:
pragma Assert (Enumerate_Type'Size = 1);
for example.
>> How to I do this without having to explicit clone the first one?
>
> You can't. Enumeration types are not extensible.
Extensible enumeration types were proposed for Ada 9X,
but were dropped.
> You can do something similar in the reverse direction:
>
> type Big is (None, Ready, Off);
>
> subtype Small is Big range None .. Ready;
>
> or
>
> type Small is new Big range None .. Ready;
Right. And Big'Size = 2, and Small'Size = 1, by default.
- Bob
Eryndlia Mavourneen
It sounds as if you want the binary values of your enumerations to be
concatenated within a field. You *can* do this by declaring a record
that has 2 fields, one for each enumeration. You then can use a
representation clause to specify that the first type is contained in,
say, the first bit of the record and that the second type is contained
in the next 2 bits of the record.
This has the effect of concatenating the bit representations of the
types, but, of course, it does not concatenate the enumerations at the
Ada level, that is, the literals themselves.
Eryndlia
Randy Brukardt
news:wcctywk...@shell01.TheWorld.com...
...
>> You can't. Enumeration types are not extensible.
>
> Extensible enumeration types were proposed for Ada 9X,
> but were dropped.
And were proposed again for Ada 2005, and were dropped again. See
AI95-0261-1. I doubt it will ever be proposed again.
Randy.
Dmitry A. Kazakov
These are different things. I think the OP didn't want an extensible type.
He wanted a new independent type constructed in some specific way.
To extend an enumeration type E that has to have the class (E'Class). This
is a lot of work.
To reuse names of the literals of E in some other type, you only need
reflection. E.g. an attribute, say, E'Domain, which would return
"universal-set" of its literals, then you could write:
type E is (None, Ready);
type E1 is E'Domain or (Off); -- = (None, Ready, Off)
Not very useful, but in other cases reflection could be very interesting.
For example, in generics:
generic
type T is array; -- Only this
package ... is
-- The [first] array index type would be T'Index (1)
-- The array element type would be T'Element etc
--
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de
Georg Bauhaus
> Not very useful, but in other cases reflection could be very interesting.
> For example, in generics:
>
> generic
> type T is array; -- Only this
> package ... is
> -- The [first] array index type would be T'Index (1)
> -- The array element type would be T'Element etc
>
I'm probably dense. Is there a difference to what we have
now other than the unknown number of indexes of the array
type above?
generic
type T_Index is (<>);
type T_Element is private;
type T is array (T_Index range <>) of T_Element;
package ... is
Dmitry A. Kazakov
The difference is in the number of formal parameters.