Sortierung: Bestimmung der Positionsänderungen

[Uwe Sauter]

Hallo,

ich möchte mittels generic ein Array sortieren und mir als Ergebnis die Positionsänderungen der Sortierung ausgeben.

Beispiel:
Eingabe TArray<string>.Create('Eins', 'Zwei', 'Drei'); //Ursprung Positionen [0, 1, 2]
Ausgabe TArray<integer> mit den Werten [2, 0, 1]. //Auf Position 0 kommt Position 2 usw.

Der beigefügte Quelltext läßt sich für den benötigten // Fall B) ZielCode nicht übersetzten. Fehlermeldung ist:
[DCC Fehler] UTest.pas(82): E2010 Inkompatible Typen: 'TComparison>TReczeile>UTest.TPositionsSortierung. Los.T>>' und 'Procedure'

Was mache ich falsch bzw. kann mir jemand Alternativen aufzeigen?

Besten Dank Uwe

unit UTest;

interface

uses
  Generics.Collections, Generics.Defaults;

type
  TRecZeile<T>=record
     iPosition : integer;
     xWert     : T;
  end;

  TPositionsSortierung=class(TObject)
  private
    class function Init<T>(const AarrDaten: TArray<T>): TList<TRecZeile<T>>;
    class function Finit<T>(ALst: TList<TRecZeile<T>>): TArray<integer>;
  public
    class function Los<T>(const AarrDaten: TArray<T>;
                          const AifCompare: IComparer<T>): TArray<integer>;
  end;


implementation

{ TPositionsSortierung }

class function TPositionsSortierung.Init<T>(const AarrDaten: TArray<T>): TList<TRecZeile<T>>;
var
  Lrec   : TRecZeile<T>;
  Li     : integer;
begin
  //Sortierobjekt erstellen
  Result := TList<TRecZeile<T>>.Create;

  //Sortierobjekt befüllen
  for Li := Low(AarrDaten) to High(AarrDaten) do
  begin
    Lrec.iPosition := Li;
    Lrec.xWert     := AarrDaten[Li];
    Result.Add(Lrec);
  end;
end;

class function TPositionsSortierung.Finit<T>(ALst: TList<TRecZeile<T>>): TArray<integer>;
var
  Li: integer;
begin
  SetLength(Result, ALst.Count);
  for Li := 0 to pred(ALst.Count) do
    Result[Li] := Alst[Li].iPosition;
end;

class function TPositionsSortierung.Los<T>(const AarrDaten: TArray<T>;
                                           const AifCompare: IComparer<T>): TArray<integer>;
var
  LLst   : TList<TRecZeile<T>>;
  LifTest: IComparer<integer>;
  LifComp: IComparer<TRecZeile<T>>;
begin
  //Daten in Sortierobjekt übertragen
  LLst := Init<T>(AarrDaten);
  try
    //Ziel: Aufruf von LLst.Sort(LifComp);

    //Vergleichsfunktionen bereitstellen

    // Fall A) Codevorlage
    // Läßt sich compilieren, ist aber für den Fall unbrauchbar.
    LifTest   := TComparer<integer>.Construct(
                  function (const Left, Right: integer): Integer
                  begin
                    Result := Left - Right;
                  end
                   );

    // Fall B) ZielCode, läßt sich aber nicht compilieren.
    LifComp := TComparer<TRecZeile<T>>.Construct(
               function(const Left, Right: TRecZeile<T>): Integer
               begin
                 Result := AifCompare.Compare(Left.xWert, Right.xWert);
               end
              );

    //Sortierung ausführen
    LLst.Sort(LifComp);

    //Sortierung auswerten und ausgeben
    Result := Finit<T>(LLst);
  finally
    LLst.Free;
  end;

end;

end.

Der Aufruf kann z.B. wie folgt aussehen:

TPositionsSortierung.Los<string>(TArray<string>.Create('Eins', 'Zwei', 'Drei'), TComparer<string>.Default);