Enum-Typ als Parameter übergeben und mit einer Schleife durchgehen

[Glados]

Ich möchte gerne einer Funktion einen Enum-Typen als Parameter übergeben.
Das klappt glaube ich

Delphi-Quellcode:

procedure MyFunc<T>(const Param1: string; Enum: T);
begin
end;

Nun möchte ich gerne in einer Schleife auf die einzelnen Inhalte des Enums zugreifen.
Mit einem festen Enum-Typen in der procedure ist das ja einfach. Aber wie sieht das aus, wenn der Enum-Typ jeder Enum sein kann?

Was ich bisher habe und was nicht funktioniert

Delphi-Quellcode:

var i: Integer;
begin
 for i := Low(Enum) to High(Enum) do
 ...

[Zacherl]

Tja, da bist du an eine Grenze der Delphi Generics gestoßen. Da Delphi netterweise keine Constraints auf Enums erlaubt (warum auch immer man das nach Jahren nicht schafft; sollte eigentlich trivial zu implementieren sein), kannst du hier leider höchstens mit Umweg über die RTTI (z.b.

Delphi-Quellcode:

TValue

) oder Hard-Casts tricksen :?

[Glados]

Verrätst du mir netterweise wie? :pale:

[Zacherl]

Zitat:

Zitat von Glados (Beitrag 1379313)

Verrätst du mir netterweise wie? :pale:

Kommt drauf an, was genau du machen willst, also konkreter gesagt, in welcher Form du die einzelnen Werte weiterverwenden willst.

[Glados]

Mit dem genauen Typen vorher bin ich mit Low(DerEnumTyp) und High(DerEnumTyp) durchiteriert.
Und mit der Funktion hier unten habe ich mir den aktuellen Wert als String geholt. Mehr passiert da nicht

Delphi-Quellcode:

function GetName<T>(Value: T): string;
begin
 Result := System.Rtti.TRttiEnumerationType.GetName(Value);
end;

var: i: DerEnumTyp;
begin
for i := Low(DerEnumTyp) to High(DerEnumTyp) do
 s := GetName(DerEnumTyp(i));

[Zacherl]

Dann schau dir mal

Delphi-Quellcode:

TRttiEnumerationType

an.

Delphi-Quellcode:

GetMinValue

und

Delphi-Quellcode:

GetMaxValue

sind zwar leider

Delphi-Quellcode:

private

, aber folgende Methoden könnten dir evtl. schon reichen:

Delphi-Quellcode:

function GetNames: TArray<string>;
class function GetName<T{: enum}>(AValue: T): string; reintroduce; static;
class function GetValue<T{: enum}>(const AName: string): T; static;

Ansonsten hätte ich hier noch eine Möglichkeit explizit an Min und Max zu gelangen (Auszug aus einem Code, der den generischen Enum Typ in einen Ordinalwert konvertiert und dabei zur Sicherheit einige Assertions aufgrund der RTTI Infos ausführt):

Delphi-Quellcode:

var
  TypeInfo: PTypeInfo;
  TypeData: PTypeData;
  V: Integer;
begin
  Assert(SizeOf(V) >= SizeOf(T));
  TypeInfo := System.TypeInfo(T);
  Assert(Assigned(TypeInfo) and (TypeInfo^.Kind = tkEnumeration));
  TypeData := System.TypInfo.GetTypeData(TypeInfo);
  V := 0;
  Move(Value, V, SizeOf(T));
  Assert((V >= TypeData^.MinValue) and (V <= TypeData^.MaxValue));

[Glados]

Die Funktionen habe ich alle schon :P Aber ich weiß halt nicht wie ich durch die Schleife iterieren kann.
GetNames hab ich nicht.

[Zacherl]

Zitat:

Zitat von Glados (Beitrag 1379317)

Die Funktionen habe ich alle schon :P Aber ich weiß halt nicht wie ich durch die Schleife iterieren kann.

Schau mal in meinen Edit.

Im Grunde hast du allerdings nur die Möglichkeit über die Ordinalwerte zu iterieren und dann ggfls. wieder in den expliziten Typ zu hardcasten.

[Glados]

Das sieht super kompliziert aus und ich verstehe das nicht.

Zitat:

Im Grunde hast du allerdings nur die Möglichkeit über die Ordinalwerte zu iterieren und dann ggfls. wieder in den expliziten Typ zu hardcasten.

Das würde mir schon reichen. Denn mit einer anderen Funktion könnte ich dann anhand des Ordinalwerts den String bekommen.
Wie sähe das denn aus mit dem Ordinalwert? Meins oben funktioniert ja leider nicht.

Also im Grunde möchte ich meiner Funktion mehrere Enum-Typen übergeben können ("MeinEnum",... NICHT MeinEnum.XYZ)

[Zacherl]

So in der Art vielleicht:

Delphi-Quellcode:

procedure TForm1.Test<T>;
var
  TypeInfo: PTypeInfo;
  TypeData: PTypeData;
  I: Integer;
  V: T;
begin
  TypeInfo := System.TypeInfo(T);
  Assert(Assigned(TypeInfo) and (TypeInfo^.Kind = tkEnumeration));
  TypeData := System.TypInfo.GetTypeData(TypeInfo);
  for I := TypeData^.MinValue to TypeData^.MaxValue do
  begin
    Move(I, V, SizeOf(T));
    ShowMessage(TRttiEnumerationType.GetName<T>(V));
  end;
end;

bzw.

Delphi-Quellcode:

procedure TForm1.Test<T>;
var
  TypeInfo: PTypeInfo;
  TypeData: PTypeData;
  I: Integer;
  V: T absolute I;
begin
  TypeInfo := System.TypeInfo(T);
  Assert(Assigned(TypeInfo) and (TypeInfo^.Kind = tkEnumeration));
  TypeData := System.TypInfo.GetTypeData(TypeInfo);
  for I := TypeData^.MinValue to TypeData^.MaxValue do
  begin
    ShowMessage(TRttiEnumerationType.GetName<T>(V));
  end;
end;

Da gibt es aber noch diverse Fallstricke glaube ich.