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

[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.

[HolgerX]

Hmm...

sollte das nicht

Delphi-Quellcode:

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

sein (TTestColor statt TTestRecord)?


EDIT:
Blubber, so wie Du in der funktion dann auf a.Value zugreifst, war es wieder richtig....

[himitsu]

Ich meinte im Helper des Records.

Du hattest ja einmal einen Helper an einem Enum, wo es nicht ging
und dann einen Helper an einem Records, wo du meinstest es ginge.

Aber stimmt schon, wenn man das Enum in einem Record verpackt,
dann könnte man die Implicite auch direkt in den Record packen, wo sie gehen,
anstatt noch einen Helper dafür zu bauen, wo es aktuell zu gehen scheint, aber es laut Doku nicht gehen sollte.

[himitsu]

@HolgerX:

Nee, Konvertierungs-Operatoren sollen eigentlich immer nur vom/zum "eigenen" Record-Typen zu/von anderen Typen gehen,
also schon TTestRecord und nicht TestColor, aber vom/zum Record zu/von TestColor, das wäre OK.

Delphi-Quellcode:

class operator Implicit(a: TTestRecord): string;
class operator Implicit(a: TTestRecord): TTestColor;
class operator Implicit(a: TTestColor): TTestRecord;
class operator Implicit(a: string): TTestRecord;

[QuickAndDirty]

War es nicht so das helper grundsätzlich nur für klassen sind? Und Records anscheinend auch so struckuriert sind wie Objekte , deswegen gehts da auch mit Methoden und helpern?

TColor ist ja nur sein integer

[himitsu]

class helper = für Klassen
record helper = für Records, einfache Typen (Integer, String, ...) und Enums
und leider nichts für Arrays

[Redeemer]

Zitat von himitsu:

und leider nichts für Arrays

Gibt's keinen class helper for TArray<T> ?
Ich benutze inzwischen überhaupt keine array of wuppdi mehr. Ich wüsste auch nicht, warum es die noch gibt. Für statische Arrays vielleicht, aber dynamische?

[dummzeuch]

Zitat von Redeemer:

Ich benutze inzwischen überhaupt keine array of wuppdi mehr. Ich wüsste auch nicht, warum es die noch gibt. Für statische Arrays vielleicht, aber dynamische?

Ganz einfach: Rückwärtskompatibilität

Wenn man mir in einer neuen Delphi-Version die "normalen" arrays wegnähme, würde ich nicht upgraden. Es gibt einfach zu viel Sourcecode, der dann umgestellt werden müsste, den man aber eigentlich gar nicht mehr anfassen will. Und dabei rede ich noch nicht einmal von GExperts sondern von Sourcecode im Job.

[bernau]

Zitat von himitsu:

class helper = für Klassen
record helper = für Records, einfache Typen (Integer, String, ...) und Enums
und leider nichts für Arrays

Record Helper nicht für Arrays? Habe ich da wieder etwas, was mir um die Ohren fliegen könnte?

Delphi-Quellcode:

type
  TFilterArray = TArray<String>;

  TFilterArrayHelper = record helper for TFilterArray
    Function FilterStartsWithText(const aValue: String): TFilterArray;
  end;

  { TFilterArrayHelper }

function TFilterArrayHelper.FilterStartsWithText(const aValue: String): TFilterArray;
begin
  Result := [];
  for var a := low(Self) to high(Self) do
    if StartsText(aValue, Self[a]) then
      Result := Result + [Self[a]];
end;

var
  lFilterArray: TFilterArray;
  lStringArray: TArray<String>;

begin
  lFilterArray := ['a1', 'a2', 'a3', 'b1', 'b2', 'b3'];

  lStringArray := lFilterArray.FilterStartsWithText('b');

  for var a := low(lStringArray) to high(lStringArray) do
    WriteLn(lStringArray[a]);

  Readln;

end.

[shebang]

Dazu fällt mir nur folgendes ein:

Zitat:

Alle sagten: Das geht nicht. Dann kam einer, der wusste das nicht und hat´s einfach gemacht