Aufzählungstypen vereinigen

[blablab]

Hallo!

Ich möchte eine Aufzählung definieren, die aus mehreren anderen Aufzählungen besteht.

Delphi-Quellcode:

type
   TTeilmengeA = (a1, a2, a3);
   TTeilmengeB = (b1, b2, b3);
   TAll = TTeilmengeA + TTeilmengeB;

Da das leider nicht geht hab ich es so versucht:

Delphi-Quellcode:

type
   TAll = (a1, a2, a3, b1, b2, b3);
   TTeilmengeA = a1..a3;
   TTeilmengeB = b1..b3;

Am Schluss möchte ich dann eine Variable vom Typ TAll haben und überprüfen ob sie sich in der Teilmenge TTeilmengeA oder TTeilmengeB befindet. In etwa so:

Delphi-Quellcode:

var typ: TAll;
if typ in TeilmengeA then begin
...

Das einzige was mir dazu einfällt ist:

Delphi-Quellcode:

var typ: TAll;
if (typ >= Low(TTeilmengeA)) and (typ <= High(TTeilmengeA)) then begin ...

Gibt es hier noch eine bessere Lösung?

Grüße
blablab

[uligerhardt]

Vielleicht so:

Delphi-Quellcode:

type
  TAll = (a1, a2, a3, b1, b2, b3);
const
  cTeilmengeA = [a1..a3];
  cTeilmengeB = [b1..b3];
var
  typ: TAll;

  if typ in cTeilmengeA then

[Blup]

Der "in"-Operator ist nur für ein Element einer Menge definiert, nicht für Menge in Menge.

Delphi-Quellcode:

type
  Ta = (a1, a2, a3, a4, a5, a6);
  TaMenge = set of Ta;

function AinB(const A, B: TaMenge): Boolean;
begin
  Result := (a = (a * b));
end;

procedure TestMenge;
const
  a:  TaMenge = [a1, a6];
  b1: TaMenge = [a1, a2, a4, a5];
  b2: TaMenge = [a2, a4, a6];
begin
  if AinB(a, b1 + b2) then
    {...}

[uligerhardt]

Zitat von Blup:

Der "in"-Operator ist nur für ein Element einer Menge definiert, nicht für Menge in Menge.

Und Ersteres will der OP ja auch:

Zitat von blablab:

Am Schluss möchte ich dann eine Variable vom Typ TAll haben und überprüfen ob sie sich in der Teilmenge TTeilmengeA oder TTeilmengeB befindet. In etwa so:

Delphi-Quellcode:

var typ: TAll;
if typ in TeilmengeA then begin
...

[himitsu]

OK, dann
IN ist nur für das Prüfen eines Elementes in einer Mengenvariable
und nicht in einem Mengentypen.

Man könnte Embarcadero im QS mal fragen, ob die das nicht implementieren könnten
oder man geht eben doch über die Konstanten.

Delphi-Quellcode:

type
   TAll = (a1, a2, a3, b1, b2, b3);
   TTeilmengeA = a1..a3;
   TTeilmengeB = b1..b3;

const
//cTeilmengeA = [a1..a3];
//cTeilmengeB = [b1..b3];
  cTeilmengeA = [Low(TTeilmengeA)..High(TTeilmengeA)];
  cTeilmengeB = [Low(TTeilmengeB)..High(TTeilmengeB)];

Man könnte sich auch sowas basteln

Delphi-Quellcode:

type
  MyHelper = class abstract
    class function IsInType<TEnum{: ENUM}>(const Value: TEnum): Boolean;
  end;

Schade daß es die Einschränkung enum/ordinal nicht gibt, dann wäre der Code darin voll einfach, ohne über die RTTI und einige Casts gehn zu müssen.

[Iwo Asnet]

Interessant, konzeptionell unvereinbare Mengen (Enums) plötzlich über einen Kamm zu scheren und unter einen Hut packen zu wollen.

Ob da nicht ein Designfehler vorliegt?