record helper für Enum -> implicit funktioniert nicht.

[bernau]

Ich arbeite schon lange mit record helpern für alle möglichen Typen. Auch für Enum benutze ich record helper und die funktionieren sehr gut.

Ich stoße bei Enum allerdings auf ein Problem mit impliziter Zuweisung.

Hier ein Codebeispiel, der mir sogar von der "RAD AI Companion" vorgeschlagen wurde.

Delphi-Quellcode:

type
  TColor = (rot, grün, blau);

  TColorHelper = record helper for TColor
    class operator Implicit(a: TColor): string;
    class operator Implicit(a: string): TColor;
  end;

class operator TColorHelper.Implicit(a: TColor): string;
begin
  case a of
    rot: Result := 'rot';
    grün: Result := 'grün';
    blau: Result := 'blau';
  else
    Result := 'unbekannt';
  end;
end;

class operator TColorHelper.Implicit(a: string): TColor;
begin
  if a = 'rot' then
    Result := rot
  else if a = 'grün' then
    Result := grün
  else if a = 'blau' then
    Result := blau
  else
    raise Exception.Create('Ungültiger Farbname');
end;

var
  lFarbe: string;
  color: TColor;
begin
  color := rot;
  lFarbe := color; // implizite Konvertierung von TColor zu string -> [dcc32 Fehler] Test.dpr(49): E2010 Inkompatible Typen: 'TColor' und 'string'
  WriteLn(lFarbe); // Ausgabe: rot

  lFarbe := 'grün';
  color := lFarbe; // implizite Konvertierung von string zu TColor -> [dcc32 Fehler] Test.dpr(53): E2010 Inkompatible Typen: 'string' und 'TColor'
  WriteLn(Ord(color)); // Ausgabe: 1 (Ordinalwert von grün)
end.

Habe ich irgendetwas übersehen? Compilerschalter? Fehlender Uses-Eintrag?

[himitsu]

Nenn das Ding mal probehalber nicht TColor.

[bernau]

Umbenannt. Immer noch der Fehler.

[Uwe Raabe]

Operator overloading wird in Helpern nicht unterstützt: Helper Syntax

Zitat:

Class and record helpers do not support operator overloading.

[himitsu]

man stelle sich mal vor, der Compiler würde einem Sagen, wenn er was ignoriert.

[bernau]

Zitat von Uwe Raabe:

Operator overloading wird in Helpern nicht unterstützt:

Folgendes compiliert und funktioniert. Da ist auch der class operator im Helper. Verstecktes feature

Delphi-Quellcode:

type
  TTestRecord = record
    value:Integer;
    end;

  TTestRecordHelper = record helper for TTestRecord
    class operator Implicit(a: TTestRecord): string;
    class operator Implicit(a: string): TTestRecord;
    class operator Implicit(a: TTestRecord): Integer;
    class operator Implicit(a: Integer): TTestRecord;
  end;

class operator TTestRecordHelper.Implicit(a: TTestRecord): string;
begin
  Result := inttostr(a.value);
end;

class operator TTestRecordHelper.Implicit(a: string): TTestRecord;
begin
  Result.value := strtoint(a);
end;

class operator TTestRecordHelper.Implicit(a: Integer): TTestRecord;
begin
  Result.value := a;
end;

class operator TTestRecordHelper.Implicit(a: TTestRecord): Integer;
begin
 Result := a.value;
end;

var
  lTestRecord:TTestRecord;
  lString:string;
  lInteger:Integer;
begin
  lTestRecord := 1;
  lString := lTestRecord;
  WriteLn(lString);

  lTestRecord := '2';
  lInteger := lTestRecord;
  WriteLn(inttostr(lInteger));

  Readln;
end.

[Rollo62]

Das ist ja wirklich super, dass dies funktioniert, aber soll ich das jetzt nutzen oder besser nicht
Wie steht Embarcadero denn dazu?

Die Implicit-Überladung scheint für Records zu funktionieren, für Enums aber nicht.
Enums werden in Delphi intern als Integer behandelt, das behandelt der Compiler womöglich nicht als Record.

[bernau]

Zitat von Rollo62:

Die Implicit-Überladung scheint für Records zu funktionieren, für Enums aber nicht.
Enums werden in Delphi intern als Integer behandelt, das behandelt der Compiler womöglich nicht als Record.

Die Implicit-Überladung bei Records ohne record helper funktioniert ja. Deshalb geht es wahrscheinlich auch im helper.

Schade, hätte es bei Enum sehr gut gebrauchen können.

[himitsu]

Zitat:

wenn ...

Du kannst also deinen Enum in einen Record packen und dort das "zufällig" funktionierende Implizite nutzen (fall Emba was ändert und es bald nicht mehr funktioniert ..... sie werden sich dann auch weigern es zu reparieren und mit ihrem geliebten "works as expected" antworten, denn es ist ja dokumentiert, dass es "eigentlich" nicht funktioniert)

[bernau]

Zitat von himitsu:

Zitat:

wenn ...

Du kannst also deinen Enum in einen Record packen und dort das "zufällig" funktionierende Implizite nutzen (fall Emba was ändert und es bald nicht mehr funktioniert ..... sie werden sich dann auch weigern es zu reparieren und mit ihrem geliebten "works as expected" antworten, denn es ist ja dokumentiert, dass es "eigentlich" nicht funktioniert)

Ein Implizit im Record sollte ja "offiziell" funktionieren. Nur im Helper ist es zufällig.

Also folgendes ist von der Doku gedeckt.

Delphi-Quellcode:

type
  TTestColor = (rot, gruen, blau);

  TTestRecord = record
    value: TTestColor;
    class operator Implicit(a: TTestRecord): string;
  end;

var
  lTestRecord: TTestRecord;
  lString: string;

  { TTestRecord }

class operator TTestRecord.Implicit(a: TTestRecord): string;
begin
  case a.value of
    rot: Result := 'rot';
    gruen: Result := 'gruen';
    blau: Result := 'blau';
  else
    Result := 'xxx';
  end;
end;

begin
  lTestRecord.value := gruen;
  lString := lTestRecord;
  WriteLn(lString);

  Readln;

end.