TList.Sort Rückwärts?

[xZise]

Zitat von Khabarakh:

Zitat von xZise:

Ich habe mindestens 4 Methoden die ich dann doppelt habe.

Äh, nicht wirklich . Im zweiten Comparer rufst du einfach den ersten mit vertauschten Argumenten auf - immer noch perfekt DRY.

Hmmmm also statt

Delphi-Quellcode:

function PublishedCompare(Item1, Item2: Pointer): Integer;
begin
  Result := CompareValue(TVersion(Item1).PublishedTime, TVersion(Item2).PublishedTime);
end;

function PublishedCompareB(Item1, Item2: Pointer): Integer;
begin
  Result := -CompareValue(TVersion(Item1).PublishedTime, TVersion(Item2).PublishedTime);
end;

soll ich

Delphi-Quellcode:

function PublishedCompare(Item1, Item2: Pointer): Integer;
begin
  Result := CompareValue(TVersion(Item1).PublishedTime, TVersion(Item2).PublishedTime);
end;

function PublishedCompareB(Item1, Item2: Pointer): Integer;
begin
  Result := PublishedCompare(Item2, Item1);
end;

aufrufen? Nicht wirklich "weniger"...

Am elegantesten wäre es direkt bei TList:

Delphi-Quellcode:

procedure QuickSort(SortList: PPointerList; L, R, F: Integer;
  SCompare: TListSortCompare);
var
  I, J: Integer;
  P, T: Pointer;
begin
  repeat
    I := L;
    J := R;
    P := SortList^[(L + R) shr 1];
    repeat
      while F*SCompare(SortList^[I], P) < 0 do
        Inc(I);
      while F*SCompare(SortList^[J], P) > 0 do
        Dec(J);
      if I <= J then
      begin
        if I <> J then
        begin
          T := SortList^[I];
          SortList^[I] := SortList^[J];
          SortList^[J] := T;
        end;
        Inc(I);
        Dec(J);
      end;
    until I > J;
    if L < J then
      QuickSort(SortList, L, J, SCompare);
    L := I;
  until I >= R;
end;

procedure TList.Sort(Compare: TListSortCompare; Backwards : Boolean = False);
var
  F : Integer;
begin
  if Backwards then
    F := -1
  else
    F := 1;
  if (FList <> nil) and (Count > 1) then
    QuickSort(FList, 0, Count - 1, F, Compare);
end;

Zitat von Khabarakh:

Und wenn dir das immer noch zu viel Syntax-Gewurstel drum herum ist, dann nutze doch die anonymen Methoden von D2009: TList<T> im Zusammenspiel mit TDelegatedComparer<T>.

1. Wollte ich das auch abwärtskompatibel gestalten
2. Gibt es irgendwo ein Tut ?

MfG
xZise