Is it possible to extend an enumeration, while preserving strong type checking? In other words, given existing code like

type    TUpstreamServerCapabilitiesBase= (uscConnected, uscCanIssueGUID);
         TLocalServerCapabilitiesBase= (lscConnected, lscCanIssueGUID,
lscIsFirebird);
         TUpstreamServerCapabilities= set of
TUpstreamServerCapabilitiesBase;
         TLocalServerCapabilities= set of TLocalServerCapabilitiesBase;

can the common parts of those enumerations- whether a connection was initially established and so on- be moved into a common declaration, preferably using "classical" Pascal so that I can store capabilities as a set?

It is not possible to extend an enumeration type. If you are not willing to use separate sets to hold common and extended elements, you can use a generic (not parametric) set type, say SET OF 0..31, that can hold all possible elements, and define the possible elements as constants.

Not sure I understand what you are trying to do but perhaps you are looking for subrange types:

type
    TAllServerCapabilitiesBase=(uscConnected,
uscCanIssueGUID,lscConnected, lscCanIssueGUID, lscIsFirebird);
    TUpstreamServerCapabilitiesBase= uscConnected .. uscCanIssueGUID;
    TLocalServerCapabilitiesBase= lscConnected..lscIsFirebird;
    TAllServerCapabiliets=set of TAllServerCapabilitiesBase;
    TUpstreamServerCapabilities= set of TUpstreamServerCapabilitiesBase;
    TLocalServerCapabilities= set of TLocalServerCapabilitiesBase;

Ludo

Yes, except that that loses type checking.

Thanks, but I was hoping for something the other way round i.e.:

type	TCommonServerCapabilitiesBase= (scConnected, scCanIssueGUID);
         TLocalServerCapabilitiesBase(TCommonServerCapabilitiesBase) +=
		(lscIsFirebird); // INVALID CODE, EXAMPLE ONLY.
	TLocalServerCapabilities= set of TLocalServerCapabilitiesBase;

I'd be fairly happy with any solution that did the necessary type/range

Mark Morgan Lloyd
markMLl .AT. telemetry.co .DOT. uk

[Opinions above are the author's, not those of his employers or colleagues]

Enumerations have an ordinal value that starts with 0 by default. "Combining" enumerations has to make sure the ordinal values are different. As a result you can go from bigger to smaller but not the other way around. In your case with 2 subranges you could do something like:

type
    TAllServerCapabilitiesBase=(uscWhatever scConnected,
scCanIssueGUID,  lscIsFirebird);
    TUpstreamServerCapabilitiesBase= uscWhatever .. uscCanIssueGUID;
    TLocalServerCapabilitiesBase= scConnected..lscIsFirebird;

Just make sure you put the common values in the middle.

Ludo

Obviously that should read
   TUpstreamServerCapabilitiesBase= uscWhatever .. scCanIssueGUID;

If you do not allow clients of your unit to define new elements or change the set values, and what you want to do is prevent, say, accidentally adding an extended element to the set in the base class, you can declare extended elements as class-local constants. Otherwise you will need to add checks in property setters.

OK, so if I'm reading that correctly you're putting all possible values into the initial enumeration, declaring subranges of that, and finally declaring sets from the subranges (which might occupy more bits than strictly needed, since the size is determined by the initial enumeration).