Codezeile in Funktion umwandeln mit Schwierigkeiten

[a.def]

Ich habe gerade eine Gedankenslücke und weiß nicht weiter.
Ich habe eine Codezeile wie diese hier

Delphi-Quellcode:

var
 aMode: TModes;
begin
 aMode := TEnumFunctions.GetValue<TModes>(IniF.ReadString(sCurrentSection, TEnumFunctions.GetName(TIni_Idents.mode), TEnumFunctions.GetName(TModes.mManual)));
 // ...

 // Resultat in der Ini-Datei
 // [section-name]
 // mode=mManual

 // Das versuche ich zu erreichen..
 // aMode = ReadEnum(TIni_Idents.mode, TModes);

Dasselbe habe ich auch für andere Enum-Typen.
Wie kann ich daraus eine Funktion schreiben, die alle meine Enum-Typen annehmen kann?

[Uwe Raabe]

Zitat von a.def:

Wie kann ich daraus eine Funktion schreiben, die alle meine Enum-Typen annehmen kann?

Etwas so?

Delphi-Quellcode:

function ReadFromIni<T>(IniF: TCustomInifile; const sCurrentSection: string; Ident: TIni_Idents; const Default: T): T;
begin
  Result := TEnumFunctions.GetValue<T>(IniF.ReadString(sCurrentSection, TEnumFunctions.GetName(Ident), TEnumFunctions.GetName<T>(Default)));
end;

Der Aufruf wäre dann:

Delphi-Quellcode:

begin
  aMode := ReadFromIni<TModes>(IniF, sCurrentSection, TIni_Idents.mode, TModes.mManual);
end;

Wenn das Inifile und die Section im Scope der Funktion bekannt sind, kann man die Parameter dafür auch weglassen.

[a.def]

Soweit war ich tatsächlich noch nicht. Aber mit dem ReadFromIni<T> hatte ich dann ja wohl schon recht.
Nur habe ich es wieder gelöscht, da der Editor es rot unterstreicht, obwohl Generics.Collections in der Uses-Klausel steht.

Edit
Fehlerquelle gefunden. Ich wusste nicht, dass solche Funktionen und Prozeduren eine Deklaration im Unit-Kopf verlangen.

Mein Resultat in meiner eigenen ini-Klasse

Delphi-Quellcode:

type
 TMemIniFile = class(IniFiles.TMemIniFile)
 ...
 function ReadEnum<T>(const Section: string; const Ident: TIniSettings; const Default: T): T;
 procedure WriteEnum<T>(const Section: string; const Ident: TIniSettings; Value: T);
 ...

function TMemIniFile.ReadEnum<T>(const Section: string; const Ident: TIniSettings; const Default: T): T;
begin
 Result := TEnumFunctions.GetValue<T>(ReadString(Section, TEnumFunctions.GetName(Ident), TEnumFunctions.GetName<T>(Default)));
end;

procedure TMemIniFile.WriteEnum<T>(const Section: string; const Ident: TIniSettings; Value: T);
begin
 WriteString(Section, TEnumFunctions.GetName(Ident), TEnumFunctions.GetName<T>(Value));
end;

TEnumFunctions

Delphi-Quellcode:

type
 TEnumFunctions = record
  ...
  class function GetName<T>(AValue: T): string; static;
  class function GetValue<T>(AValue: string): T; static;
  ...

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

class function TEnumFunctions.GetValue<T>(AValue: string): T;
var
 Temp: Integer;
 PTemp: Pointer;
begin
 Temp := GetEnumValue(TypeInfo(T), AValue);
 if Temp < 0 then
  Temp := 0; // gebe 0 statt 255 zurück im Falle, dass AValue nicht existiert
 PTemp := @Temp;
 Result := T(PTemp^);

 // Result := System.Rtti.TRttiEnumerationType.GetValue<T>(AValue);
end;

[a.def]

Eine Frage habe ich dann noch

Ginge auch das hier irgendwie?
procedure WriteEnum<T>(const Section: string; const Ident: T; Value: T); Also Ident: T;? Dann wäre ich nicht auf einen Enum-Typen festgelegt.

Der Compiler sagt mir leider etwas unverständlich

Zitat:

E2532 Generisches Typargument konnte aus den unterschiedlichen Argumenttypen für Methode 'WriteEnum' nicht abgeleitet werden

[Uwe Raabe]

Zitat von a.def:

Also Ident: T;? Dann wäre ich nicht auf einen Enum-Typen festgelegt.

Soll denn Ident vom selben Typ sein wie Value? Ich denke wohl nicht. Wenn es zwei unterschiedliche Typen sind, dann muss man das auch so deklarieren:

procedure WriteEnum<T,T2>(const Section: string; const Ident: T2; Value: T);

[a.def]

Scheint aber verdammt kompliziert zu sein oder ich stelle mich doof an.

Delphi-Quellcode:

function TMemIniFile.ReadEnum<T, T2>(const Section: string; const Ident: T2; const Default: T): T;
begin
 Result := TEnumFunctions.GetValue<T>(ReadString(Section, TEnumFunctions.GetName<T2>(Ident), TEnumFunctions.GetName<T>(Default)));
end;

//

aJclCompressionMethod := IniF.ReadEnum<TIniSettings, TJclCompressionMethod>(sCurrentSection, TIniSettings.zipcompression, TJclCompressionMethod.cmDeflate);

Zitat:

E2250 Es gibt keine überladene Version von 'TMemIniFile.ReadEnum<_enums.TIniSettings,JclCompr ession.TJclCompressionMethod>', die man mit diesen Argumenten aufrufen kann

Aber ich glaube es nun kapiert zu haben. Die Angabe in Klammern <T> ist wohl dazu da um der Funktion mitzuteilen, um welche Typen es sich handelt.
Dann sieht mein Konstrukt nun so aus und statt 6 Methoden habe ich nun nur noch 4

Delphi-Quellcode:

function TMemIniFile.ReadEnum<T>(const Section: string; const Ident: T; const Default: T): T;
begin
 Result := TEnumFunctions.GetValue<T>(ReadString(Section, TEnumFunctions.GetName(Ident), TEnumFunctions.GetName<T>(Default)));
end;

procedure TMemIniFile.WriteEnum<T>(const Section: string; const Ident: T; Value: T);
begin
 WriteString(Section, TEnumFunctions.GetName(Ident), TEnumFunctions.GetName<T>(Value));
end;

function TMemIniFile.ReadEnum<T, T2>(const Section: string; const Ident: T; const Default: T2): T2;
begin
 Result := TEnumFunctions.GetValue<T2>(ReadString(Section, TEnumFunctions.GetName<T>(Ident), TEnumFunctions.GetName<T2>(Default)));
end;
// => aMode := IniF.ReadEnum<TIniSettings, TModes>(sCurrentSection, TIniSettings.mode, TModes.mManual);

procedure TMemIniFile.WriteEnum<T, T2>(const Section: string; const Ident: T; Value: T2);
begin
 WriteString(Section, TEnumFunctions.GetName<T>(Ident), TEnumFunctions.GetName<T2>(Value));
end;
// => IniF.WriteEnum<TIniSettings, TModes>(sCurrentSection, TIniSettings.mode, TModes.mManual);

[Uwe Raabe]

Zitat von a.def:

Aber ich glaube es nun kapiert zu haben. Die Angabe in Klammern <T> ist wohl dazu da um der Funktion mitzuteilen, um welche Typen es sich handelt.

Das ist richtig! Es ist in der Regel auch notwendig die Typen beim Aufruf anzugeben IniF.WriteEnum<TIniSettings, TModes>(...) . Wann der Compiler das auch ohne die Angabe hinkriegt, habe ich auch noch nicht so richtig rausgefunden.

[a.def]

Zitat:

Es ist in der Regel auch notwendig die Typen beim Aufruf anzugeben

Das ist eine gute Information. Werde ich mich dran halten. Ich habe eben einfach wie wild T und T2 hin und her getauscht und so weiter und so herausbekommen, wie was funktioniert und was wofür zuständig ist. Try and Error

Danke für deine Hilfe und dafür, dass ich was neues gelernt habe.