I need to sort a list of objects by the object property "Addr", which
is a word item. The Object has a lot of other properties and methods
etc, but I need to make sure that they are in sequential order by Addr
in the list after processing.
The list is implemented as a TObjectList and I am using Delphi7 for
this project.

I have googled this and found an old thread where Wayne Niddery and
Remy Lebeau gave different solutions. The thread URL is:
https://forums.embarcadero.com/message.jspa?messageID=238358

Wayne defined a general sorting function like this:
{code}
function SortByCodeName(Item1, Item2: Pointer): Integer;
  var
    li1: TListItem absolute Item1;
    li2: TListItem absolute Item2;
begin
  //Body contains compare statements for li1 aganst li2
  ...
end;

procedure TForm12.Button1Click(Sender: TObject);
begin
  list.Sort(SortByCodeName);
end;
{code}
whereas Remy defined his solution as follows:
{code}
function MySortFunc(Item1, Item2: TListItem): Integer;
begin
  //Body compares directly properties of Item1 and Item2
  ...
end;
 
begin
  ...
  MyObjectList.Sort(TListSortCompare(@MySortFunc));
  ...
end;
{code}

So the compare functions are defined in different ways and the usage
of them is also completely differently looking.
Wayne defines local variables on top of the supplied pointer arguments
(absolute directive) whereas Remy has defined the compare function as
using the specific type of object as the arguments. So he had to make
the call in a special way by typecasting the argument function.

QUESTION
Is there not a simpler way to do this or do you need to use one or the
other of the suggested methods?
I lean towards the following variation of Waynes solution:
{code}
function SortByCodeName(Item1, Item2: Pointer): Integer;
  var
    li1: TListItem;
    li2: TListItem;
begin
  li1 := TListItem(Item1);
  li2 := TListItem(Item2);
  ...
  //Body contains compare statements for li1 aganst li2
  ...
end;

procedure TForm12.Button1Click(Sender: TObject);
begin
  list.Sort(SortByCodeName);
end;
{code}
Is this going to violate some rules concerning usage of sort functions
with TObjectList?

--

Bo Berglund
Developer in Sweden

Bo wrote:

> So the compare functions are defined in different ways and the usage
> of them is also completely differently looking.

They are different only in code syntax.  Their behavior at runtime is identical.

> Is there not a simpler way to do this

No.  The alternative would be to sort the list manually, and that is certainly 
not "simpler".

> do you need to use one or the other of the suggested methods?

If you want to use the list's built-in sort routine, then yes.

> I lean towards the following variation of Waynes solution:

That is just an explicit form of what Wayne's example does.  My example eliminates 
the need for casting the parameters at all.  But the end effect is the same 
either way.  The list will be passing typed items (in your case, pointers 
to instances of your custom class type) to the sort routine, so you have 
to somehow tell the compiler that the parameters of the routine are of a 
specific type so it can access each item's members.

> Is this going to violate some rules concerning usage of sort functions
> with TObjectList?

No.

--
Remy Lebeau (TeamB)

On Wed, 2 Jul 2014 13:44:29 -0700, Remy Lebeau (TeamB)
<no.spam@no.spam.com> wrote:

>Bo wrote:
>
>> So the compare functions are defined in different ways and the usage
>> of them is also completely differently looking.
>
>They are different only in code syntax.  Their behavior at runtime is identical.
>
>> Is this going to violate some rules concerning usage of sort functions
>> with TObjectList?
>
>No.
Well, I tried my hand at it now and did the following:
In the class managing the list of objects I added two methods, one
private and one public:
{code}
  TElectrodeList = class
  private
    FElecs: TObjectList;
    function GetElectrode(Index: integer): TElectrode;
    function GetElectrodeCount: integer;
    function GetElectrodeByAddr(Addr: word): TElectrode;
    function CompareElectrodes(Item1, Item2: TElectrode): Integer;
  public
    constructor Create;
    destructor Destroy; override;
    property ElectrodeCount: integer read GetElectrodeCount;
    property Electrodes[Index: integer]: TElectrode read GetElectrode;
    property ElectrodeByAddr[Addr: word]: TElectrode read
GetElectrodeByAddr;
    function  Add: TElectrode;
    procedure Clear;
    procedure SortEleByAddress;
  end;

  ....
function TElectrodeList.CompareElectrodes(Item1, Item2: TElectrode):
Integer;
{Compare function passed to TobjectList.Sort()}
var
  EL1: TElectrode;
  EL2: TElectrode;
begin
  EL1 := TElectrode(Item1);
  EL2 := TElectrode(Item2);

  if EL1.Address > EL2.Address then
    Result := -1
  else if EL1.Address < EL2.Address then
    Result := 1
  else
    Result := 0;
end;

procedure TElectrodeList.SortEleByAddress;
begin
  FElecs.Sort(CompareElectrodes);
end;
{code}

But when I compile this I get an error in SortEleByAddress:
[Error] PSCmdFile.pas(881): Incompatible types: 'regular procedure and
method pointer'

Does this mean that I cannot isolate the compare function into the
object that needs it and instead I must make it a regular totally
public function????
Seems strange if that is the case, it would be more OO if it could be
contained within the object itself.

--

Bo Berglund
Developer in Sweden

Bo wrote:

> Well, I tried my hand at it now and did the following:
<snip>
> But when I compile this I get an error in SortEleByAddress:
> [Error] PSCmdFile.pas(881): Incompatible types: 'regular procedure
> and method pointer'

The Sort() routine cannot be a non-static class method.  Look at its declaration:

{code}
TListSortCompare = function (Item1, Item2: Pointer): Integer;

procedure Sort(Compare: TListSortCompare);
{code}

TListSortCompare is not declared as "of object", so it will not accept a 
non-static class method.  You will have to adjust your code accordingly.

> Does this mean that I cannot isolate the compare function into the
> object that needs it and instead I must make it a regular totally
> public function????

No.  You just have to declare it as 'static' to remove the portions that 
are not compatible (namely, the hidden Self parameter), for example:

{code}
TElectrodeList = class
private
  FElecs: TObjectList;
  ...
  class function CompareElectrodes(Item1, Item2: TElectrode): Integer; static;
public
  ...
  procedure SortEleByAddress;
end;

class function TElectrodeList.CompareElectrodes(Item1, Item2: TElectrode): 
Integer;
begin
  if Item1.Address > Item2.Address then
    Result := -1
  else if Item1.Address < Item2.Address then
    Result := 1
  else
    Result := 0;

  // this function can be simplified to this:
  // Result := Integer(Item2.Address) - Integer(Item1.Address);
end;

procedure TElectrodeList.SortEleByAddress;
begin
  FElecs.Sort(TListSortCompare(@CompareElectrodes));
end;
{code}

--
Remy Lebeau (TeamB)

On Wed, 2 Jul 2014 14:45:24 -0700, Remy Lebeau (TeamB)
<no.spam@no.spam.com> wrote:

>The Sort() routine cannot be a non-static class method.  Look at its declaration:
>
>{code}
>TListSortCompare = function (Item1, Item2: Pointer): Integer;
>
>procedure Sort(Compare: TListSortCompare);
>{code}
>
>TListSortCompare is not declared as "of object", so it will not accept a 
>non-static class method.  You will have to adjust your code accordingly.
>
>
>You just have to declare it as 'static' to remove the portions that 
>are not compatible (namely, the hidden Self parameter), for example:
>
>  class function CompareElectrodes(Item1, Item2: TElectrode): Integer; static;

I tried this but it resulted in the following strange error message on
compile:
[Error] PSCmdFile.pas(57): Field definition not allowed after methods
or properties

Maybe class functions and the static keyword is not allowed in Delphi
7?

By making the function a non-class standard function directly after
the implementation keyword there are no more compile errors.

--

Bo Berglund
Developer in Sweden

Bo wrote:

> Maybe class functions and the static keyword is not allowed in
> Delphi 7?

According to this page, they should be:

http://www.tindex.net/Language/staticclassmethods.html

{quote}
Class methods are available in Delphi 7 and are useful for building factory 
classes. Class methods can now be made static by adding the static keyword.
{quote}

But sure enough, the example on that page does not compile in Delphi 7.

This page:

New Delphi language features since Delphi 7 
http://edn.embarcadero.com/article/34324

Lists "static class methods" as a feature "released after the Delphi 7 version". 
 So there you go.

--
Remy Lebeau (TeamB)

On Thu, 3 Jul 2014 10:14:20 -0700, Remy Lebeau (TeamB)
<no.spam@no.spam.com> wrote:

>Bo wrote:
>
>> Maybe class functions and the static keyword is not allowed in
>> Delphi 7?
>
>According to this page, they should be:
>
>http://www.tindex.net/Language/staticclassmethods.html
>
>{quote}
>Class methods are available in Delphi 7 and are useful for building factory 
>classes. Class methods can now be made static by adding the static keyword.
>{quote}
>
>But sure enough, the example on that page does not compile in Delphi 7.
>
>This page:
>
>New Delphi language features since Delphi 7 
>http://edn.embarcadero.com/article/34324
>
>Lists "static class methods" as a feature "released after the Delphi 7 version". 
> So there you go.

That's life....
I am not that dogmatic that I insist on isolation, so I have put the
compare function outside the classes but not referenced in interface.
Now it works.
Maybe when I have finished the other changes I will bring the project
up in Delphi 2007 and change this just as a test.

Thanks for your help in getting the sorting working!
--

Bo Berglund
Developer in Sweden