Zuweisung für Enums überladen

[Codewalker]

Seit einigen Delphi-Versionen kann man ja Operatoren für eigene Datentypen überladen. Wie genau funktioniert das denn z.B. für Enums. Häufig möchte ich diese konvertieren (z.B. einen repräsentativen String, also nicht genau den Enum-Namen).
Beispiel wäre TFontStyle = (fsBold, fsItalic) und bei der Zuweisung zu einem String soll dann z.B. "fett" und "kursiv" herauskommen. Bisher habe ich immer eine Hilfsfunktion gemacht, die das per Case abhandelt, würde es aber lieber direkt über einen Operator abhandeln.

[DeddyH]

Reicht auch die Billig-Variante?

Delphi-Quellcode:

type
  TMyType = (mtOne, mtTwo, mtThree);

const
  MYTYPENAMES = array[TMyType] of string = ('Eins', 'Zwei', 'Drei');

function TypeAsString(aType: TMyType): string;
begin
  Result := MYTYPENAMES[aType];
end;

[Codewalker]

Naja, nicht wirklich. Jetzt habe ich eine Funktion und dazu noch ein Array und kann die meisten Vorzüge der Überladung nicht nutzen. Ist ja das gleiche nur anders

[DeddyH]

Einen Versuch war es wert

[himitsu]

Operatoren gehen nur bei Records.
Record-Methoden (ähnlich wie bei Klassen) gibt es seit D2006 natürlich auch nur für Records.
Class Helper und Record Helper gibt es auch nur für Klassen und Records. (Interfaces weiß ich jetzt nicht)

Einfache Typen und Interfaces fehlen leider noch.


Die Übersetzungen könnte man über Attribute und die neue RTTI regeln.

[s.h.a.r.k]

@himitsu: Meintest du etwa sowas hier?!

[himitsu]

Jupp.

Delphi macht es zwar nicht automatisch, aber selbst kann man es schon machen.

Ich bastel mir grade ein paar Basicunits zusammen, für alle meine Projekte, inklusive eigener Typendefinitionen für Integer und Co.
Dort ist auch 'ne generische Typkonvertierung drin ... da würde sowas perfekt reinpasen.

[Panthrax]

Delphi-Quellcode:

program Project1;

{$APPTYPE CONSOLE}

uses
  SysUtils;

type
  TSomeEnum = (seOne, seTwo, seThree);

  TMyEnum = record
  strict private
    FValue: TSomeEnum;

    class function Translate(const Value: TSomeEnum): String; overload; static;
    class function Translate(const Value: String): TSomeEnum; overload; static;

  public
    class operator Implicit(const Value: String): TMyEnum;
    class operator Implicit(const Value: TMyEnum): String;
    class operator Implicit(const Value: TMyEnum): TSomeEnum;
    class operator Implicit(const Value: TSomeEnum): TMyEnum;
  end;

{ TMyEnum }

class operator TMyEnum.Implicit(const Value: TMyEnum): String;
begin
  Result := Translate(Value.FValue);
end;

class function TMyEnum.Translate(const Value: TSomeEnum): String;
begin
  case Value of
    seOne:
      Result := 'Eins';
    seTwo:
      Result := 'Zwei';
    seThree:
      Result := 'Drei';
  end;
end;

class operator TMyEnum.Implicit(const Value: String): TMyEnum;
begin
  Result.FValue := Translate(Value);
end;

class operator TMyEnum.Implicit(const Value: TSomeEnum): TMyEnum;
begin
  Result.FValue := Value;
end;

class operator TMyEnum.Implicit(const Value: TMyEnum): TSomeEnum;
begin
  Result := Value.FValue;
end;

class function TMyEnum.Translate(const Value: String): TSomeEnum;
begin
  if Value = 'Eins' then
    Result := seOne
  else
  if Value = 'Zwei' then
    Result := seTwo
  else
  if Value = 'Drei' then
    Result := seThree
  else
    raise Exception.Create('Ungültiger Wert.');
end;

var
  MyEnum: TMyEnum;
  SomeEnum: TSomeEnum;
begin
  try
    SomeEnum := seTwo;
    MyEnum := SomeEnum;
    WriteLn('MyEnum: ' + MyEnum);
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
  ReadLn;
end.

Code:

MyEnum: Zwei